@peter.prib/renderengine 0.2.5 → 0.2.7

package/src/charting/archimate/ArchimateCanvasEditor.js

@@ -1,815 +1,825 @@
-import { ViewLineEdge } from './ViewLineEdge.js';
-import { typeTitle, ARCHIMATE_TYPE_MIME } from './archimateNames.js';
-import { RemoveLineCommand } from '../diagrams/RemoveLineCommand.js';
-import { canvasBoxMenuItems } from '../canvas/canvasBoxMenuItems.js';
-import { hintMenuItems } from '../canvas/hintMenuItems.js';
-import { CANVAS_BOX_MIME } from '../canvas/CanvasPalette.js';
-import { MODEL_ELEMENT_MIME } from '../modelTree/ModelTreePanel.js';
-import { showGlobalSettingsDialog } from '../SettingsDialog.js';
-import { specializationCatalogDialog } from './specializationCatalogDialog.js';
-import { CustomViewpoints } from './CustomViewpoints.js';
-import { ShowElementCommand } from '../diagrams/ShowElementCommand.js';
-import { DiagramEditor } from '../DiagramEditor.js';
-import { CompositeCommand } from '../CommandHistory.js';
-import { ElementInstance } from '../diagrams/ElementInstance.js';
-import { RelationshipInstance } from '../diagrams/RelationshipInstance.js';
-import { ViewObjectInstance } from '../diagrams/ViewObjectInstance.js';
-import { PlaceItemsCommand } from '../diagrams/PlaceItemsCommand.js';
-import { AddRelationshipToViewCommand, AddRelationshipCommand, RemoveRelationshipFromViewCommand, DeleteElementCommand, AddToViewCommand } from '../diagrams/ArchimateCommands.js';
-import { NestInstanceCommand } from '../diagrams/NestInstanceCommand.js';
-import { NESTING_KINDS, nestingRelationships } from '../diagrams/nesting.js';
-import { treeLayerOf } from '../modelTree/treeLayers.js';
-import { parseDate } from '../diagrams/roadmap.js';
-import { ArchimateValidator } from '../diagrams/ArchimateValidator.js';
-import { GraphDiagram } from '../diagrams/GraphDiagram.js';
-import { ArchimateElementTemplate } from './ArchimateElementTemplate.js';
-import { ArchimateEdge } from './ArchimateEdge.js';
-import { ViewpointRule } from './ViewpointRule.js';
-import { DerivedEdge } from './DerivedEdge.js';
-import { ViewGroupTemplate } from './ViewGroupTemplate.js';
-import { RemoveGroupFromViewCommand } from '../diagrams/RemoveGroupFromViewCommand.js';
-import { DerivedRelationships } from '../diagrams/DerivedRelationships.js';
-import { ElementFilterRule } from './ElementFilterRule.js';
-import { ArchimateViewpoints, ArchimateNotation } from '../../archimate.js';
-import { PropertyListEditor } from '../PropertyListEditor.js';
-import { FormDialog } from '../FormDialog.js';
-import { elementPropertyFields, elementEditCommand, conceptEditCommand, manyElementsFields, manyElementsEditCommands } from './elementProperties.js';
-
-/**
- * Which allowed relationship kind a new connection takes when nobody is asked:
- * the dependency and dynamic kinds people usually mean first, the structural
- * whole/part kinds last.
- */
-export const KIND_PREFERENCE = Object.freeze([
-    'assignment', 'realization', 'serving', 'access', 'influence', 'triggering', 'flow',
-    'specialization', 'aggregation', 'composition', 'association',
-]);
-
-// Kept in a module of their own (archimateNames.js), so the palette needs no import of this editor.
-export { typeTitle, ARCHIMATE_TYPE_MIME };
-
-/**
- * ArchimateCanvasEditor — the diagram editor's canvas over one ArchiMate
- * view: its element instances as ArchimateElementTemplates, its relationship
- * instances as ArchimateEdges, and its own undo history. Everything the base
- * editor does (move, resize, restack, bend points, sides, styles, zoom,
- * snapping) edits the view directly; the editor's maps are rebuilt from the
- * view on every render, so undo of a view edit shows straight away.
- *
- * What stands for something else in ArchiMate is done through the view and
- * model instead of the maps:
- * - dropping a palette type adds a new model element and shows it;
- * - connecting two elements adds a relationship, its kind the first the
- *   ArchiMate rules allow between them (association if none);
- * - deleting removes from the view (with the element's lines); the model
- *   keeps its elements and relationships.
- * Each is one step on the view's history.
- */
-export class ArchimateCanvasEditor extends DiagramEditor {
-    /**
-     * @param {Object} options - DiagramEditor options, plus:
-     * @param {ArchimateView} options.view
-     * @param {ArchimateModel} options.model
-     * @param {Object} [options.nodeOptions] - ArchimateDiagram.buildNode options (archimateVersion, useDistinctShapes, ...),
-     *   and the viewpoint: `viewpoint` (a name; 'All' or none for every type), `viewpointMode` ('fade' or 'hide')
-     * @param {(kinds: string[], from: Object, to: Object) => Promise<string|null>|string|null} [options.chooseKind]
-     *   Asks which relationship kind a new connection is, given the kinds allowed between the two
-     *   elements (null cancels). Without it the first of KIND_PREFERENCE that is allowed is used.
-     * @param {(nodeOptions: Object) => void} [options.onNodeOptionsChange] - The ⚙ Settings menu changed
-     *   the version or distinct shapes (the host may need to redraw more than the canvas, e.g. a palette)
-     */
-    constructor({ view, model, nodeOptions = {}, chooseKind = null, onNodeOptionsChange = null, templateMenu = null, customViewpoints = [], settingsManager = null, ...options }) {
-        super({ ...options, templates: new Map(), edges: new Map(), history: view.history, arrangement: view.arrangement });
-        this.view = view;
-        this.model = model;
-        this.nodeOptions = nodeOptions;
-        this.chooseKind = chooseKind;
-        this.onNodeOptionsChange = onNodeOptionsChange;
-        /** Viewpoints of the user's own, offered with the standard ones. */
-        this.customViewpoints = customViewpoints;
-        /** The settings the ⚙ Settings menu's Model settings… edits (a SettingsManager), if any. */
-        this.settingsManager = settingsManager;
-        /** Canvas templates (a CanvasTemplateMenu): placed on the canvas, saved from its shapes. */
-        this.templateMenu = templateMenu;
-        this.addDropHandler({
-            accepts: (dt) => Array.from(dt.types).includes(ARCHIMATE_TYPE_MIME),
-            drop: (dt, point) => this.addElement(dt.getData(ARCHIMATE_TYPE_MIME), point),
-        });
-        // An element from the model tree: shown here, with its relationships to what is already shown.
-        this.addDropHandler({
-            accepts: (dt) => Array.from(dt.types).includes(MODEL_ELEMENT_MIME),
-            drop: (dt, point) => this.showElement(dt.getData(MODEL_ELEMENT_MIME), point),
-        });
-        // A picture file dropped (or pasted): an image box where it fell (pasted: in the middle).
-        if (typeof document !== 'undefined') this.enableImageDrop((dataURL, point) => this.addImage(dataURL, point));
-        // A canvas palette tile: the box, where it was dropped (an image asks for its picture).
-        this.addDropHandler({
-            accepts: (dt) => Array.from(dt.types).includes(CANVAS_BOX_MIME),
-            drop: (dt, point) => this.addCanvasBox(dt.getData(CANVAS_BOX_MIME), point),
-        });
-    }
-
-    get version() {
-        return this.nodeOptions.archimateVersion ?? '4';
-    }
-
-    /**
-     * An element's own items (a view of it and what it relates to; its
-     * relationships to what is shown, when some are not), a canvas box's hint,
-     * and the shape's selection (or the shape and its group) as a template.
-     */
-    shapeMenuExtras(elementId) {
-        const ids = this.selectedIds.has(elementId) ? this.getSelectedIds() : [elementId];
-        const items = this.templateMenu?.saveAsTemplateItems(this.view.id, { itemIds: [...this.arrangement.movers(ids)] }) ?? [];
-        const element = this._elementOf(elementId);
-        const missing = element ? this.missingRelationshipsOf(elementId) : [];
-        return [
-            ...(element ? [{ label: 'Generate View For This', action: () => this.model.generateView([element.id]) }] : []),
-            ...(missing.length ? [{ label: `Add Missing Relationships (${missing.length})`, action: () => this.addMissingRelationships(elementId) }] : []),
-            ...hintMenuItems(this.view, elementId, { onChange: () => this.render() }),
-            ...(items.length ? [{ label: 'Save as template', items }] : []),
-        ];
-    }
-
-    /** The model's relationships between this box's element and what is shown that the view does not draw from this box. */
-    missingRelationshipsOf(instanceId) {
-        const instance = this.view.getElementInstance(instanceId);
-        if (!instance) return [];
-        return this.view.missingRelationshipInstances(instance.elementId)
-            .filter(line => line.sourceInstanceId === instanceId || line.targetInstanceId === instanceId);
-    }
-
-    /** Draw them all, as one undo step. */
-    addMissingRelationships(instanceId) {
-        const missing = this.missingRelationshipsOf(instanceId);
-        if (!missing.length) return null;
-        const cmd = new CompositeCommand(`Add ${missing.length} relationship${missing.length === 1 ? '' : 's'}`,
-            missing.map(line => new AddRelationshipToViewCommand(this.view, line)));
-        this._executeCommand(cmd);
-        return cmd;
-    }
-
-    /** The view's boxes (a canvas's palette; a note or picture elsewhere) at the point clicked, and on a canvas a template placed there. */
-    canvasMenuItems(at) {
-        const boxes = canvasBoxMenuItems(this.view, at, { onAdded: (box) => { this.render(); this.selectTemplate(box.id); } });
-        const items = this.templateMenu?.placeTemplateItems(this.view.id, at) ?? [];
-        // Elements from text: not on a canvas, whose boxes are not elements.
-        const fromText = this.view.constructor.kind === 'canvas' ? [] : super.canvasMenuItems(at);
-        return [...boxes, ...fromText, ...(items.length ? [{ label: 'Place template', items }] : []), ...hintMenuItems(this.view, null, { onChange: () => this.render() })];
-    }
-
-    /** The View menu, and Generate roadmap… (elements with dates on a time line). */
-    viewMenuItems() {
-        return [...super.viewMenuItems(), { label: 'Generate roadmap…', action: () => this.askRoadmap() }];
-    }
-
-    /**
-     * Generate roadmap…: which elements (the selection's, or every element in
-     * the model with both dates), the properties their dates are in, and how
-     * months are named; the roadmap view comes to the front (ArchimateModel#generateRoadmap).
-     */
-    askRoadmap() {
-        const selected = this.getSelectedIds().map(id => this._elementOf(id)?.id).filter(Boolean);
-        const names = [...new Set(this.model.elements().flatMap(e => (e.properties ?? []).map(p => p.name ?? p.key)).filter(Boolean))].sort();
-        return new FormDialog({
-            title: 'Generate roadmap',
-            description: 'A view with each element a bar from its start date to its end date, under the months.',
-            fields: [
-                { key: 'from', label: 'Elements', type: 'select', value: selected.length ? 'selection' : 'model', choices: [...(selected.length ? [['selection', `The ${selected.length} selected`]] : []), ['model', 'Every element with both dates']] },
-                { key: 'start', label: 'Start date property', type: 'text', value: 'Start Date', suggestions: names },
-                { key: 'end', label: 'End date property', type: 'text', value: 'End Date', suggestions: names },
-                { key: 'months', label: 'Month names', type: 'select', value: 'short', choices: [['short', 'Short (Jan)'], ['full', 'Full (January)']] },
-                { key: 'name', label: 'View name', type: 'text', value: 'Roadmap' },
-            ],
-            submitLabel: 'Generate',
-            idPrefix: 'roadmap-',
-            document: this.document ?? globalThis.document,
-            validate: (v) => (this.roadmapFor(v).view === null ? `No element has both "${v.start}" and "${v.end}" as dates` : null),
-            onApply: (v) => this.generateRoadmap(v),
-        }).open();
-    }
-
-    /** What a roadmap of these dialog values would hold: `{view: null}` when nothing would be on it (a dry run). @private */
-    roadmapFor({ from, start, end }) {
-        const ids = from === 'selection' ? this.getSelectedIds().map(id => this._elementOf(id)?.id).filter(Boolean) : this.model.elements().map(e => e.id);
-        const date = (e, key) => parseDate((e.properties ?? []).find(p => (p.name ?? p.key) === key)?.value);
-        const any = ids.map(id => this.model.getElement(id)).some(e => e && date(e, start) && date(e, end) && date(e, end) >= date(e, start));
-        return { ids, view: any ? true : null };
-    }
-
-    /** Generate the roadmap of Generate roadmap…'s values. @returns {{view, skipped}} */
-    generateRoadmap({ from = 'model', start = 'Start Date', end = 'End Date', months = 'short', name = 'Roadmap' } = {}) {
-        const { ids } = this.roadmapFor({ from, start, end });
-        return this.model.generateRoadmap(ids, { startProperty: start, endProperty: end, monthNames: months, name });
-    }
-
-    /** An element's box keeps room for its type badge, and Archi's height. */
-    textFit(template) {
-        return this._elementOf(template.id) ? { padding: 44, min: { width: 80, height: 55 } } : super.textFit(template);
-    }
-
-    /** Text becomes elements of any type of this version (the viewpoint's, when it limits them). */
-    shapeTypes() {
-        const viewpoint = this.nodeOptions.viewpoint;
-        const allowed = viewpoint && viewpoint !== 'All' ? ArchimateViewpoints.allowedElementTypes(viewpoint, this.version, this.customViewpoints) : null;
-        return ArchimateNotation.elementTypeNames(this.version)
-            .filter(t => !allowed || allowed.includes(t))
-            .map(t => [t, typeTitle(t)]);
-    }
-
-    /**
-     * New model elements from text, each with its box here: one undo step.
-     * A documentation column becomes the element's documentation.
-     */
-    createShapesCommand(items) {
-        const ids = this.model.elements().map(e => e.id);
-        const steps = [], createdIds = [];
-        for (const item of items) {
-            const id = GraphDiagram.generateNodeId(`${item.type}-${item.name}`, ids);
-            ids.push(id);
-            const instance = new ElementInstance(id, item.x, item.y);
-            createdIds.push(instance.id);
-            steps.push(new AddToViewCommand(this.view, instance, { element: { id, name: item.name, type: item.type, ...(item.documentation && { documentation: item.documentation }) } }));
-        }
-        const cmd = new CompositeCommand(`Add ${steps.length} element${steps.length === 1 ? '' : 's'} from text`, steps);
-        cmd.createdIds = createdIds;
-        return cmd;
-    }
-
-    /** What elements can be coloured by: their layer, type, specialization, and each property any of them has. */
-    colourKeys(templates = [...this.templates.values()]) {
-        const properties = new Set();
-        for (const t of templates) for (const p of this._elementOf(t.id)?.properties ?? []) if (p.name ?? p.key) properties.add(p.name ?? p.key);
-        return [
-            ['layer', 'Layer'], ['type', 'Type'], ['specialization', 'Specialization'],
-            ...[...properties].sort().map(name => [`property:${name}`, `Property "${name}"`]),
-        ];
-    }
-
-    /** An element's value for a colourKeys key (notes and pictures have none). */
-    colourValue(template, key) {
-        const element = this._elementOf(template.id);
-        if (!element) return undefined;
-        if (key === 'layer') return typeTitle(treeLayerOf(element));
-        if (key === 'type') return typeTitle(element.type ?? '');
-        if (key === 'specialization') return element.specialization;
-        if (key.startsWith('property:')) {
-            const p = (element.properties ?? []).find(q => (q.name ?? q.key) === key.slice(9));
-            return p?.value === undefined || p?.value === null ? undefined : String(p.value);
-        }
-        return super.colourValue(template, key);
-    }
-
-    /** The kind legend: each element type on the view, in the colour of its first box. */
-    kindLegendEntries() {
-        const types = new Map();
-        for (const t of this.templates.values()) {
-            const element = this._elementOf(t.id);
-            if (!element || types.has(element.type)) continue;
-            types.set(element.type, t.fillColor);
-        }
-        return [...types].map(([type, fillColor]) => ({ label: typeTitle(type), fillColor }));
-    }
-
-    /** A legend is notes (stickies on a canvas) on the view: one PlaceItemsCommand. */
-    legendCommand(entries, title) {
-        if (!entries.length) return null;
-        const kind = this.view.constructor.BOX_KINDS.find(k => k.key === 'note') ?? this.view.constructor.BOX_KINDS.find(k => k.key === 'sticky');
-        if (!kind) return null;
-        const { x, y } = this.legendPosition();
-        const stamp = Date.now().toString(36);
-        const box = (i, name, fillColor) => {
-            const inst = new ViewObjectInstance(kind.content(`legend-${stamp}-${i}`, { name }), x + 60 + i * 130, y + 20);
-            inst.size = { width: 120, height: 40 };
-            inst.appearance = { ...kind.appearance, fillColor };
-            return inst;
-        };
-        const boxes = [box(0, title, '#ffffff'), ...entries.map((e, i) => box(i + 1, e.label, e.fillColor))];
-        return new PlaceItemsCommand(this.view, { elementInstances: boxes }, { label: `Add legend: ${title}` });
-    }
-
-    /** Likely duplicates can be merged (Merge…: choose the one to keep). */
-    findingActions(finding) {
-        return finding.code === 'possible-duplicate' ? [{ label: 'Merge…', action: () => this.askMerge(finding.ids) }] : [];
-    }
-
-    /**
-     * Ask which of some elements to keep, then merge the others into it
-     * (ArchimateModel#mergeCommand), one undo step. Each choice says where the
-     * element is used, to help pick.
-     */
-    askMerge(elementIds) {
-        const elements = elementIds.map(id => this.model.getElement(id)).filter(Boolean);
-        if (elements.length < 2) return null;
-        const used = (e) => {
-            const views = this.model.views().filter(v => v.elementInstancesFor?.(e.id).length).length;
-            const { incoming, outgoing } = this.model.relationshipsFor(e.id);
-            return `${views} view${views === 1 ? '' : 's'}, ${incoming.length + outgoing.length} relationship${incoming.length + outgoing.length === 1 ? '' : 's'}`;
-        };
-        return new FormDialog({
-            title: `Merge ${elements.length} elements`,
-            description: 'The one kept takes the others\' relationships, their boxes on every view, and the documentation and properties it lacks; the others go.',
-            fields: [{ key: 'keep', label: 'Keep', type: 'select', value: elements[0].id, choices: elements.map(e => [e.id, `${e.name || e.id} (${used(e)})`]) }],
-            submitLabel: 'Merge',
-            idPrefix: 'merge-',
-            document: this.document ?? globalThis.document,
-            onApply: ({ keep }) => this.mergeElements(keep, elementIds.filter(id => id !== keep)),
-        }).open();
-    }
-
-    /** Merge elements into one (`keepId`), one undo step; the canvas and tree redraw. */
-    mergeElements(keepId, otherIds) {
-        const cmd = this.model.mergeCommand(keepId, otherIds);
-        this._executeCommand(cmd);
-        return cmd;
-    }
-
-    /** The checks use this editor's ArchiMate version. */
-    checkerOptions() {
-        return { version: this.version };
-    }
-
-    /** An element is shown by selecting its first occurrence on this view. */
-    revealFinding(finding) {
-        if (finding.kind !== 'element') return super.revealFinding(finding);
-        const instance = this.view.elementInstancesFor(finding.ids[0])[0];
-        if (instance && this.templates.has(instance.id)) {
-            this.selectTemplate(instance.id);
-            this.render();
-        }
-    }
-
-    /**
-     * Bring the editor's templates and lines in line with the view, reusing
-     * the template or line of each instance still there.
-     */
-    syncFromView() {
-        const { view, model } = this;
-        const templates = new Map();
-        for (const inst of view.elementInstances.values()) {
-            if (!inst.shownIn(view) || !inst.resolve(model)) continue;
-            const existing = this.templates.get(inst.id);
-            templates.set(inst.id, existing?.instance === inst ? existing
-                : new ArchimateElementTemplate(inst, model, { nodeOptions: this.nodeOptions }));
-        }
-        for (const t of templates.values()) t.nodeOptions = this.nodeOptions;
-        // The view's groups (Archi groups: model folders with bounds on this view).
-        for (const folder of view.placedFolders) {
-            const existing = this.templates.get(folder.id);
-            templates.set(folder.id, existing instanceof ViewGroupTemplate && existing.view === view ? existing : new ViewGroupTemplate(folder.id, view));
-        }
-        const edges = new Map();
-        for (const inst of view.relationshipInstances.values()) {
-            const existing = this.edges.get(inst.id);
-            const edge = existing?.instance === inst ? existing : new ArchimateEdge(inst, view);
-            if (edge.relationship && templates.has(edge.sourceId) && templates.has(edge.targetId)) edges.set(inst.id, edge);
-        }
-        // Plain lines (a canvas's connections, a line from a note).
-        for (const line of view.viewConnections.values()) {
-            const existing = this.edges.get(line.id);
-            const edge = existing?.line === line ? existing : new ViewLineEdge(line);
-            if (line.visible !== false && templates.has(edge.sourceId) && templates.has(edge.targetId)) edges.set(line.id, edge);
-        }
-        // Derived relationships (⚙ Settings → Show derived): drawn between elements both on the view.
-        if (this.nodeOptions.showDerived) {
-            const shown = (elementId) => view.elementInstancesFor(elementId).find(inst => templates.has(inst.id))?.id;
-            for (const derived of DerivedRelationships.compute(model, { maxHops: 2 }).derived) {
-                const from = shown(derived.source), to = shown(derived.target);
-                if (from && to) edges.set(derived.id, new DerivedEdge(derived, from, to));
-            }
-        }
-        this.templates.clear();
-        for (const [id, t] of templates) this.templates.set(id, t);
-        this.edges.clear();
-        for (const [id, e] of edges) this.edges.set(id, e);
-    }
-
-    render() {
-        if (this.disposed) return;
-        this.syncFromView();
-        super.render();
-    }
-
-    /** ⚙ Settings: the notation (version, distinct shapes), then the base editor's grid and line styles. */
-    settingsMenuItems() {
-        const set = (patch) => {
-            this.nodeOptions = { ...this.nodeOptions, ...patch };
-            if (this.onNodeOptionsChange) this.onNodeOptionsChange(this.nodeOptions);
-            else this.render();
-        };
-        const distinct = !!this.nodeOptions.useDistinctShapes;
-        const viewpoint = this.nodeOptions.viewpoint ?? 'All';
-        const mode = this.nodeOptions.viewpointMode ?? 'fade';
-        return [
-            {
-                label: `Version: ArchiMate ${this.version}`,
-                items: ['4', '3.2'].map(v => ({ label: `ArchiMate ${v}`, checked: v === this.version, action: () => set({ archimateVersion: v }) })),
-            },
-            { label: `Distinct shapes: ${distinct ? 'on' : 'off'}`, action: () => set({ useDistinctShapes: !distinct }) },
-            { label: `Show derived: ${this.nodeOptions.showDerived ? 'on' : 'off'}`, action: () => set({ showDerived: !this.nodeOptions.showDerived }) },
-            {
-                label: `Viewpoint: ${viewpoint}`,
-                items: ArchimateViewpoints.all(this.customViewpoints).map(vp => ({ label: vp.name, checked: vp.name === viewpoint, action: () => set({ viewpoint: vp.name }) })),
-            },
-            {
-                label: `Outside the viewpoint: ${mode === 'hide' ? 'hidden' : 'faded'}`,
-                items: [['fade', 'Faded'], ['hide', 'Hidden']].map(([m, text]) => ({ label: text, checked: m === mode, action: () => set({ viewpointMode: m }) })),
-            },
-            { separator: true },
-            { separator: true },
-            { label: 'Specializations…', action: () => this.editSpecializations() },
-            { label: 'Viewpoints…', action: () => this.editViewpoints() },
-            ...super.settingsMenuItems(),
-            ...(this.settingsManager ? [{ separator: true }, { label: 'Model settings…', action: () => showGlobalSettingsDialog(this.document ?? globalThis.document, this.settingsManager, 'default') }] : []),
-        ];
-    }
-
-    /**
-     * What the ArchiMate rules say against a relationship's line, or null
-     * (ArchimateValidator, for this ArchiMate version). Off when the view's
-     * `invalidRelationships` setting is 'off'; with 'tooltip' it is the tooltip, not drawn red.
-     */
-    edgeWarning(edge) {
-        const relationship = edge.relationship;
-        const mode = this.viewSettings().invalidRelationships ?? 'highlight';
-        if (!relationship || mode === 'off') return null;
-        const from = this.model.getElement(relationship.source), to = this.model.getElement(relationship.target);
-        if (!from || !to) return null;
-        const result = ArchimateValidator.validateRelationship(from, to, relationship.kind, this.version);
-        return result.valid ? null : { message: result.message, highlight: mode === 'highlight' };
-    }
-
-    /** Edit the specialization catalog; elements given one redraw with it. */
-    editSpecializations() {
-        return specializationCatalogDialog({ version: this.version, document: this.document ?? globalThis.document, onChange: () => this._notationChanged() }).open();
-    }
-
-    /** Edit the user's own viewpoints; they are offered (and applied) from then on. */
-    editViewpoints() {
-        return CustomViewpoints.dialog({
-            version: this.version, document: this.document ?? globalThis.document,
-            onChange: (viewpoints) => { this.customViewpoints = viewpoints; this._viewpointRule = null; this._notationChanged(); },
-        }).open();
-    }
-
-    /** The notation's catalogs changed: the host redraws (its palette too), or this editor does. @private */
-    _notationChanged() {
-        if (this.onNodeOptionsChange) this.onNodeOptionsChange(this.nodeOptions);
-        else this.render();
-    }
-
-    /**
-     * The base editor's rules (a highlight), then the active filter's result
-     * (ElementFilterRule) and the viewpoint (ViewpointRule, from the notation options).
-     */
-    emphasisRules() {
-        const { viewpoint, viewpointMode } = this.nodeOptions;
-        const key = `${viewpoint}|${viewpointMode}|${this.version}`;
-        if (this._viewpointRule?.key !== key) {
-            this._viewpointRule = { key, rule: new ViewpointRule({ viewpoint, mode: viewpointMode, version: this.version, customViewpoints: this.customViewpoints }) };
-        }
-        return [...super.emphasisRules(), ...(this.elementFilter ? [this.elementFilter] : []), ...(this._viewpointRule.rule.viewpoint ? [this._viewpointRule.rule] : [])];
-    }
-
-    /** Dim every model element but these (a filter's result); null clears it. Redraws. */
-    setElementFilter(elementIds) {
-        this.elementFilter = elementIds ? new ElementFilterRule(elementIds) : null;
-        this.render();
-    }
-
-    /**
-     * The Element section of a shape's properties: the model element's own
-     * name, type, specialization, icon, documentation and typed properties (the same on every view;
-     * the dialog's Name above labels this occurrence only). None for a note,
-     * image or canvas box.
-     */
-    conceptFields(template) {
-        const element = this._elementOf(template.id);
-        if (!element) return [];
-        return [
-            { type: 'heading', label: 'Element (on every view)' },
-            ...elementPropertyFields(element, { version: this.version, document: this.document ?? globalThis.document }),
-        ];
-    }
-
-    /** The element's changes as one EditViewItemCommand (null when nothing changed). */
-    conceptCommand(template, values) {
-        const element = this._elementOf(template.id);
-        return element ? elementEditCommand(element, values, { instance: template.instance }) : null;
-    }
-
-    /**
-     * With several shapes selected, the Elements section: their type, their
-     * specialization when they share a type, and one property to set on all.
-     * Only when every selected shape is an element.
-     */
-    manyConceptFields(templates) {
-        const elements = this._elementsOf(templates);
-        return elements ? manyElementsFields(elements, { version: this.version }) : [];
-    }
-
-    /** The elements' changes as one step (null when nothing changed). */
-    manyConceptCommand(templates, values) {
-        const elements = this._elementsOf(templates);
-        const instances = new Map(templates.map(t => [this._elementOf(t.id), t.instance]));
-        const commands = elements ? manyElementsEditCommands(elements, values, { instanceOf: (e) => instances.get(e) }) : [];
-        return commands.length ? new CompositeCommand(`Edit ${commands.length} elements`, commands) : null;
-    }
-
-    /** The model elements the shapes show, each once; null unless every shape shows one. @private */
-    _elementsOf(templates) {
-        const elements = templates.map(t => this._elementOf(t.id));
-        return elements.every(Boolean) ? [...new Set(elements)] : null;
-    }
-
-    /**
-     * The Relationship section of a line's properties: its kind (among those
-     * the ArchiMate rules allow between its ends, and its own), documentation
-     * and typed properties. None for a plain line or a derived one.
-     */
-    edgeConceptFields(edge) {
-        const relationship = edge.relationship;
-        if (!relationship || edge.editable === false) return [];
-        const kinds = [...new Set([relationship.kind, ...this.allowedKinds(edge.sourceId, edge.targetId)].filter(Boolean))];
-        return [
-            { type: 'heading', label: 'Relationship (on every view)' },
-            { key: 'relationship.kind', label: 'Kind', type: 'select', value: relationship.kind, choices: kinds.map(k => [k, typeTitle(k)]) },
-            { key: 'relationship.documentation', label: 'Documentation', type: 'textarea', rows: 3, value: relationship.documentation ?? '' },
-            { type: 'heading', label: 'Properties' },
-            PropertyListEditor.field(relationship.properties, { key: 'relationship.properties', document: this.document ?? globalThis.document }),
-        ];
-    }
-
-    /** The relationship's changes as one EditViewItemCommand (null when nothing changed). */
-    edgeConceptCommand(edge, values) {
-        return edge.relationship ? conceptEditCommand(edge.relationship, values, { prefix: 'relationship', instance: edge.instance }) : null;
-    }
-
-    /** A new element of `type` at `point` (snapped), created in the model and shown here. One undo step. */
-    addElement(type, point) {
-        const name = typeTitle(type);
-        const id = GraphDiagram.generateNodeId(name, this.model.elements().map(e => e.id));
-        const at = this._snapToGrid(point);
-        const instance = new ElementInstance(id, at.x, at.y);
-        this._executeCommand(new AddToViewCommand(this.view, instance, { element: { id, name, type }, label: `Add ${name}` }));
-        return instance;
-    }
-
-    /**
-     * Show an element the model has at `point` (snapped), with its
-     * relationships to the elements already on the view (ShowElementCommand).
-     * One undo step. Null for an element the model lacks.
-     */
-    showElement(elementId, point) {
-        if (!this.model.getElement(elementId)) return null;
-        const at = this._snapToGrid(point);
-        const instance = new ElementInstance(elementId, at.x, at.y);
-        this._executeCommand(new ShowElementCommand(this.view, instance, { label: `Show ${this.model.getElement(elementId).name || elementId}` }));
-        this.selectTemplate(instance.id);
-        return instance;
-    }
-
-    /**
-     * A picture as an image box on this view at `point` (snapped), one undo
-     * step, selected. Null when this kind of view has no image box.
-     * @param {string} dataURL - The picture
-     */
-    addImage(dataURL, point) {
-        if (!this.view.constructor.BOX_KINDS?.some(k => k.key === 'image')) return null;
-        const box = this.view.addBox('image', this._snapToGrid(point), { iconUrl: dataURL });
-        this.render();
-        this.selectTemplate(box.id);
-        return box;
-    }
-
-    /**
-     * Add a box of a canvas palette kind ('block', 'sticky', 'image') at `point`
-     * (snapped), as the canvas menu would. One undo step.
-     */
-    addCanvasBox(kindKey, point) {
-        const item = canvasBoxMenuItems(this.view, this._snapToGrid(point), {
-            onAdded: (box) => { this.render(); this.selectTemplate(box.id); },
-        }).find((_, i) => this.view.constructor.BOX_KINDS[i].key === kindKey);
-        return item?.action();
-    }
-
-    /** The relationship kinds the ArchiMate rules allow from one instance's element to another's (association always). */
-    allowedKinds(sourceId, targetId) {
-        const from = this._elementOf(sourceId), to = this._elementOf(targetId);
-        if (!from || !to) return [];
-        const kinds = ArchimateValidator.allowedKinds(from, to, this.version);
-        return kinds.includes('association') ? kinds : [...kinds, 'association'];
-    }
-
-    /**
-     * Connect two elements: the kind is asked for (`chooseKind`) among those
-     * allowed, or taken from KIND_PREFERENCE. One undo step once chosen.
-     * @returns {Command|null|Promise<Command|null>}
-     */
-    connect(sourceId, targetId) {
-        if (sourceId === targetId) return null;
-        // A box or note at either end: a plain line (the view's rule), one undo step.
-        if (!this.view.linesAreRelationships(sourceId, targetId)) {
-            if (!this.templates.has(sourceId) || !this.templates.has(targetId)) return null;
-            const line = this.view.connect(sourceId, targetId);
-            this.render();
-            return line;
-        }
-        const kinds = this.allowedKinds(sourceId, targetId);
-        if (!kinds.length) return null;
-        const run = (kind) => (kind && kinds.includes(kind) ? this._connectAs(sourceId, targetId, kind) : null);
-        if (!this.chooseKind) return run(KIND_PREFERENCE.find(k => kinds.includes(k)) ?? kinds[0]);
-        const chosen = this.chooseKind(kinds, this._elementOf(sourceId), this._elementOf(targetId));
-        return chosen && typeof chosen.then === 'function' ? chosen.then(run) : run(chosen);
-    }
-
-    /** @private */
-    _connectAs(sourceId, targetId, kind) {
-        const cmd = this.connectCommand(sourceId, targetId, kind);
-        if (cmd) this._executeCommand(cmd);
-        return cmd;
-    }
-
-    /** The model element an instance on this canvas shows (notes and images have none). @private */
-    /** A box of a model element links to the element's page in a report. */
-    reportRef(template) {
-        const element = this._elementOf(template.id);
-        return element ? { kind: 'element', id: element.id } : null;
-    }
-
-    _elementOf(instanceId) {
-        const inst = this.templates.get(instanceId)?.instance;
-        return inst ? this.model.getElement(inst.elementId) : undefined;
-    }
-
-    /** A new relationship of `kind` between two elements' instances, created in the model and shown here. */
-    connectCommand(sourceId, targetId, kind = KIND_PREFERENCE.find(k => this.allowedKinds(sourceId, targetId).includes(k))) {
-        const source = this.templates.get(sourceId)?.instance;
-        const target = this.templates.get(targetId)?.instance;
-        const from = this._elementOf(sourceId);
-        const to = this._elementOf(targetId);
-        // Notes and images are not model elements: they take no relationships.
-        if (!from || !to || !kind) return null;
-        const id = GraphDiagram.generateNodeId(`${from.id}-${kind}-${to.id}`, this.model.relationships().map(r => r.id));
-        const instance = new RelationshipInstance(id, null, source.id, target.id);
-        return new AddRelationshipToViewCommand(this.view, instance, {
-            relationship: { id, source: from.id, target: to.id, kind },
-            label: `Add ${kind}`,
-        });
-    }
-
-    /**
-     * Deleting takes a box off the view (its lines go with it, see the base's
-     * deleteTemplatesCommand); the model keeps its element. A group goes off the
-     * view and what it held stays; the model keeps its folder.
-     */
-    /** Copies are ArchiMate views' items: they paste into ArchiMate views (any model), not the template editor. */
-    static clipboardKind = 'archimate';
-
-    /**
-     * A copy of these boxes: the view's JSON of them (ArchimateView#toJSON),
-     * with the lines and relationships between them and the elements they show.
-     * Groups are not copied (they are model folders).
-     */
-    copyPayload(ids) {
-        const boxes = ids.filter(id => this.view.getElementInstance(id));
-        return boxes.length ? this.view.toJSON({ itemIds: boxes }) : null;
-    }
-
-    /** Paste: new boxes for the same elements (added to the model when it lacks them), one undo step. */
-    pasteCommand(payload, options) {
-        return this.view.pasteCommand(payload, options);
-    }
-
-    /** Deleting is off the view: the model keeps what it showed. */
-    deleteLabel(templateIds) {
-        return `${super.deleteLabel(templateIds)} from view`;
-    }
-
-    removeTemplateCommand(templateId) {
-        return this.templates.get(templateId) instanceof ViewGroupTemplate
-            ? new RemoveGroupFromViewCommand(this.view, templateId)
-            : new DeleteElementCommand(this.view, templateId);
-    }
-
-    /**
-     * What moves with a shape: for a group, the elements drawn in it (its folder's),
-     * the notes and pictures Archi drew in it, and the groups inside it; for a box (a canvas block), the boxes Archi drew inside it.
-     */
-    containedIn(templateId) {
-        const template = this.templates.get(templateId);
-        const view = this.view;
-        if (template instanceof ViewGroupTemplate) {
-            const inner = [];
-            for (const t of this.templates.values()) {
-                if (t instanceof ViewGroupTemplate) {
-                    if (t.id !== templateId && view.placedFolders.find(f => f.id === t.id)?.parentId === templateId) inner.push(t.id);
-                } else if (t.instance?.archi?.parent === templateId
-                    || (t.instance?.elementId && view.placedFolderOf(t.instance.elementId) === templateId)) {
-                    inner.push(t.id);
-                }
-            }
-            return inner;
-        }
-        const visualId = template?.instance?.visualId;
-        if (!visualId) return [];
-        return [...this.templates.values()].filter(t => t.instance?.nestedIn === visualId).map(t => t.id);
-    }
-
-    // ===== Nesting =====
-
-    /** The box this one is drawn inside: an element's box, or a canvas block (a group holds by folder, not here). */
-    parentOf(templateId) {
-        const visualId = this.templates.get(templateId)?.instance?.nestedIn;
-        if (!visualId) return null;
-        const parent = [...this.templates.values()].find(t => t.instance?.visualId === visualId);
-        return parent?.id ?? null;
-    }
-
-    /**
-     * An element's parts on this view: the elements it is composed of or
-     * aggregates (its composition and aggregation relationships' targets),
-     * each by its first box here.
-     */
-    partsOf(templateId) {
-        const element = this._elementOf(templateId);
-        if (!element) return [];
-        const parts = this.model.relationships()
-            .filter(r => r.source === element.id && r.target !== element.id && (r.kind === 'composition' || r.kind === 'aggregation'))
-            .map(r => this.view.elementInstancesFor(r.target)[0]?.id)
-            .filter(id => id && this.templates.has(id) && this.canHold(templateId, id));
-        return [...new Set(parts)];
-    }
-
-    /** The "by kind" layout puts an element's box in its layer's row (notes and images in their own). */
-    layoutCategory(template) {
-        const element = this._elementOf(template.id);
-        return element ? treeLayerOf(element) : 'other';
-    }
-
-    /** An element's box holds any box but a group; on a canvas, a block holds boxes. */
-    canHold(parentId, childId) {
-        const parent = this.templates.get(parentId), child = this.templates.get(childId);
-        if (!parent?.instance || !child?.instance || parent instanceof ViewGroupTemplate || child instanceof ViewGroupTemplate) return false;
-        return !!this._elementOf(parentId) || parent.instance.content?.archiVisualType === 'canvas-model-block';
-    }
-
-    nestCommand(childId, parentId) {
-        const child = this.templates.get(childId)?.instance;
-        if (!child) return null;
-        return new NestInstanceCommand(child, parentId ? this.templates.get(parentId)?.instance ?? null : null);
-    }
-
-    /** After nesting an element in another: offer the relationship the nesting stands for (nestingKinds). */
-    nested(changes) {
-        let chain = Promise.resolve();
-        for (const { childId, parentId } of changes) {
-            chain = chain.then(() => this.offerNestingRelationship(parentId, childId));   // taken out: nothing to offer
-        }
-        return chain;
-    }
-
-    /**
-     * The kinds a nesting can stand for, from parent to child, as Archi offers
-     * them: those of NESTING_KINDS the rules allow. None when the two already
-     * have such a relationship.
-     */
-    nestingKinds(parentId, childId) {
-        const from = this._elementOf(parentId), to = this._elementOf(childId);
-        if (!from || !to || from === to) return [];
-        if (nestingRelationships(this.model, from.id, to.id).length) return [];
-        const allowed = this.allowedKinds(parentId, childId);
-        return NESTING_KINDS.filter(k => allowed.includes(k));
-    }
-
-    /**
-     * Ask which relationship a nesting stands for (`chooseKind`, with the
-     * reason 'nesting'; none chosen adds none) and add it to the model, drawn
-     * on no view: the nesting shows it. One undo step. Without `chooseKind`, nothing is added.
-     * @returns {Promise<Command|null>}
-     */
-    async offerNestingRelationship(parentId, childId) {
-        const kinds = this.nestingKinds(parentId, childId);
-        if (!kinds.length || !this.chooseKind) return null;
-        const from = this._elementOf(parentId), to = this._elementOf(childId);
-        const kind = await this.chooseKind(kinds, from, to, { reason: 'nesting' });
-        if (!kind || !kinds.includes(kind)) return null;
-        const cmd = this.nestingRelationshipCommand(parentId, childId, kind);
-        this._executeCommand(cmd);
-        return cmd;
-    }
-
-    /** The relationship of `kind` a nesting stands for, from parent to child, in the model only. */
-    nestingRelationshipCommand(parentId, childId, kind) {
-        const from = this._elementOf(parentId), to = this._elementOf(childId);
-        const id = GraphDiagram.generateNodeId(`${from.id}-${kind}-${to.id}`, this.model.relationships().map(r => r.id));
-        return new AddRelationshipCommand(this.model, { id, source: from.id, target: to.id, kind }, `Add ${kind} (nested)`);
-    }
-
-    /** Deleting a line takes it off the view: a plain line goes; a relationship stays in the model. */
-    deleteEdgeCommand(edgeId) {
-        return this.view.viewConnections.has(edgeId)
-            ? new RemoveLineCommand(this.view, edgeId)
-            : new RemoveRelationshipFromViewCommand(this.view, edgeId);
-    }
-}
+import { ViewLineEdge } from './ViewLineEdge.js';
+import { typeTitle, ARCHIMATE_TYPE_MIME } from './archimateNames.js';
+import { RemoveLineCommand } from '../diagrams/RemoveLineCommand.js';
+import { canvasBoxMenuItems } from '../canvas/canvasBoxMenuItems.js';
+import { hintMenuItems } from '../canvas/hintMenuItems.js';
+import { CANVAS_BOX_MIME } from '../canvas/CanvasPalette.js';
+import { MODEL_ELEMENT_MIME } from '../modelTree/ModelTreePanel.js';
+import { showGlobalSettingsDialog } from '../SettingsDialog.js';
+import { specializationCatalogDialog } from './specializationCatalogDialog.js';
+import { CustomViewpoints } from './CustomViewpoints.js';
+import { ShowElementCommand } from '../diagrams/ShowElementCommand.js';
+import { DiagramEditor } from '../DiagramEditor.js';
+import { CompositeCommand } from '../CommandHistory.js';
+import { ElementInstance } from '../diagrams/ElementInstance.js';
+import { RelationshipInstance } from '../diagrams/RelationshipInstance.js';
+import { ViewObjectInstance } from '../diagrams/ViewObjectInstance.js';
+import { PlaceItemsCommand } from '../diagrams/PlaceItemsCommand.js';
+import { AddRelationshipToViewCommand, AddRelationshipCommand, RemoveRelationshipFromViewCommand, DeleteElementCommand, AddToViewCommand } from '../diagrams/ArchimateCommands.js';
+import { NestInstanceCommand } from '../diagrams/NestInstanceCommand.js';
+import { NESTING_KINDS, nestingRelationships, hiddenByNesting } from '../diagrams/nesting.js';
+import { treeLayerOf } from '../modelTree/treeLayers.js';
+import { parseDate } from '../diagrams/roadmap.js';
+import { ArchimateValidator } from '../diagrams/ArchimateValidator.js';
+import { GraphDiagram } from '../diagrams/GraphDiagram.js';
+import { ArchimateElementTemplate } from './ArchimateElementTemplate.js';
+import { ArchimateEdge } from './ArchimateEdge.js';
+import { ViewpointRule } from './ViewpointRule.js';
+import { DerivedEdge } from './DerivedEdge.js';
+import { ViewGroupTemplate } from './ViewGroupTemplate.js';
+import { RemoveGroupFromViewCommand } from '../diagrams/RemoveGroupFromViewCommand.js';
+import { DerivedRelationships } from '../diagrams/DerivedRelationships.js';
+import { ElementFilterRule } from './ElementFilterRule.js';
+import { ArchimateViewpoints, ArchimateNotation } from '../../archimate.js';
+import { PropertyListEditor } from '../PropertyListEditor.js';
+import { FormDialog } from '../FormDialog.js';
+import { elementPropertyFields, elementEditCommand, conceptEditCommand, manyElementsFields, manyElementsEditCommands } from './elementProperties.js';
+
+/**
+ * Which allowed relationship kind a new connection takes when nobody is asked:
+ * the dependency and dynamic kinds people usually mean first, the structural
+ * whole/part kinds last.
+ */
+export const KIND_PREFERENCE = Object.freeze([
+    'assignment', 'realization', 'serving', 'access', 'influence', 'triggering', 'flow',
+    'specialization', 'aggregation', 'composition', 'association',
+]);
+
+// Kept in a module of their own (archimateNames.js), so the palette needs no import of this editor.
+export { typeTitle, ARCHIMATE_TYPE_MIME };
+
+/**
+ * ArchimateCanvasEditor — the diagram editor's canvas over one ArchiMate
+ * view: its element instances as ArchimateElementTemplates, its relationship
+ * instances as ArchimateEdges, and its own undo history. Everything the base
+ * editor does (move, resize, restack, bend points, sides, styles, zoom,
+ * snapping) edits the view directly; the editor's maps are rebuilt from the
+ * view on every render, so undo of a view edit shows straight away.
+ *
+ * What stands for something else in ArchiMate is done through the view and
+ * model instead of the maps:
+ * - dropping a palette type adds a new model element and shows it;
+ * - connecting two elements adds a relationship, its kind the first the
+ *   ArchiMate rules allow between them (association if none);
+ * - deleting removes from the view (with the element's lines); the model
+ *   keeps its elements and relationships.
+ * Each is one step on the view's history.
+ */
+export class ArchimateCanvasEditor extends DiagramEditor {
+    /**
+     * @param {Object} options - DiagramEditor options, plus:
+     * @param {ArchimateView} options.view
+     * @param {ArchimateModel} options.model
+     * @param {Object} [options.nodeOptions] - ArchimateDiagram.buildNode options (archimateVersion, useDistinctShapes, ...),
+     *   and the viewpoint: `viewpoint` (a name; 'All' or none for every type), `viewpointMode` ('fade' or 'hide')
+     * @param {(kinds: string[], from: Object, to: Object) => Promise<string|null>|string|null} [options.chooseKind]
+     *   Asks which relationship kind a new connection is, given the kinds allowed between the two
+     *   elements (null cancels). Without it the first of KIND_PREFERENCE that is allowed is used.
+     * @param {(nodeOptions: Object) => void} [options.onNodeOptionsChange] - The ⚙ Settings menu changed
+     *   the version or distinct shapes (the host may need to redraw more than the canvas, e.g. a palette)
+     */
+    constructor({ view, model, nodeOptions = {}, chooseKind = null, onNodeOptionsChange = null, templateMenu = null, customViewpoints = [], settingsManager = null, ...options }) {
+        super({ ...options, templates: new Map(), edges: new Map(), history: view.history, arrangement: view.arrangement });
+        this.view = view;
+        this.model = model;
+        this.nodeOptions = nodeOptions;
+        this.chooseKind = chooseKind;
+        this.onNodeOptionsChange = onNodeOptionsChange;
+        /** Viewpoints of the user's own, offered with the standard ones. */
+        this.customViewpoints = customViewpoints;
+        /** The settings the ⚙ Settings menu's Model settings… edits (a SettingsManager), if any. */
+        this.settingsManager = settingsManager;
+        /** Canvas templates (a CanvasTemplateMenu): placed on the canvas, saved from its shapes. */
+        this.templateMenu = templateMenu;
+        this.addDropHandler({
+            accepts: (dt) => Array.from(dt.types).includes(ARCHIMATE_TYPE_MIME),
+            drop: (dt, point) => this.addElement(dt.getData(ARCHIMATE_TYPE_MIME), point),
+        });
+        // An element from the model tree: shown here, with its relationships to what is already shown.
+        this.addDropHandler({
+            accepts: (dt) => Array.from(dt.types).includes(MODEL_ELEMENT_MIME),
+            drop: (dt, point) => this.showElement(dt.getData(MODEL_ELEMENT_MIME), point),
+        });
+        // A picture file dropped (or pasted): an image box where it fell (pasted: in the middle).
+        if (typeof document !== 'undefined') this.enableImageDrop((dataURL, point) => this.addImage(dataURL, point));
+        // A canvas palette tile: the box, where it was dropped (an image asks for its picture).
+        this.addDropHandler({
+            accepts: (dt) => Array.from(dt.types).includes(CANVAS_BOX_MIME),
+            drop: (dt, point) => this.addCanvasBox(dt.getData(CANVAS_BOX_MIME), point),
+        });
+    }
+
+    get version() {
+        return this.nodeOptions.archimateVersion ?? '4';
+    }
+
+    /**
+     * An element's own items (a view of it and what it relates to; its
+     * relationships to what is shown, when some are not), a canvas box's hint,
+     * and the shape's selection (or the shape and its group) as a template.
+     */
+    shapeMenuExtras(elementId) {
+        const ids = this.selectedIds.has(elementId) ? this.getSelectedIds() : [elementId];
+        const items = this.templateMenu?.saveAsTemplateItems(this.view.id, { itemIds: [...this.arrangement.movers(ids)] }) ?? [];
+        const element = this._elementOf(elementId);
+        const missing = element ? this.missingRelationshipsOf(elementId) : [];
+        return [
+            ...(element ? [{ label: 'Generate View For This', action: () => this.model.generateView([element.id]) }] : []),
+            ...(missing.length ? [{ label: `Add Missing Relationships (${missing.length})`, action: () => this.addMissingRelationships(elementId) }] : []),
+            ...hintMenuItems(this.view, elementId, { onChange: () => this.render() }),
+            ...(items.length ? [{ label: 'Save as template', items }] : []),
+        ];
+    }
+
+    /** The model's relationships between this box's element and what is shown that the view does not draw from this box. */
+    missingRelationshipsOf(instanceId) {
+        const instance = this.view.getElementInstance(instanceId);
+        if (!instance) return [];
+        return this.view.missingRelationshipInstances(instance.elementId)
+            .filter(line => line.sourceInstanceId === instanceId || line.targetInstanceId === instanceId);
+    }
+
+    /** Draw them all, as one undo step. */
+    addMissingRelationships(instanceId) {
+        const missing = this.missingRelationshipsOf(instanceId);
+        if (!missing.length) return null;
+        const cmd = new CompositeCommand(`Add ${missing.length} relationship${missing.length === 1 ? '' : 's'}`,
+            missing.map(line => new AddRelationshipToViewCommand(this.view, line)));
+        this._executeCommand(cmd);
+        return cmd;
+    }
+
+    /** The view's boxes (a canvas's palette; a note or picture elsewhere) at the point clicked, and on a canvas a template placed there. */
+    canvasMenuItems(at) {
+        const boxes = canvasBoxMenuItems(this.view, at, { onAdded: (box) => { this.render(); this.selectTemplate(box.id); } });
+        const items = this.templateMenu?.placeTemplateItems(this.view.id, at) ?? [];
+        // Elements from text: not on a canvas, whose boxes are not elements.
+        const fromText = this.view.constructor.kind === 'canvas' ? [] : super.canvasMenuItems(at);
+        return [...boxes, ...fromText, ...(items.length ? [{ label: 'Place template', items }] : []), ...hintMenuItems(this.view, null, { onChange: () => this.render() })];
+    }
+
+    /** The View menu, and Generate roadmap… (elements with dates on a time line). */
+    viewMenuItems() {
+        return [...super.viewMenuItems(), { label: 'Generate roadmap…', action: () => this.askRoadmap() }];
+    }
+
+    /**
+     * Generate roadmap…: which elements (the selection's, or every element in
+     * the model with both dates), the properties their dates are in, and how
+     * months are named; the roadmap view comes to the front (ArchimateModel#generateRoadmap).
+     */
+    askRoadmap() {
+        const selected = this.getSelectedIds().map(id => this._elementOf(id)?.id).filter(Boolean);
+        const names = [...new Set(this.model.elements().flatMap(e => (e.properties ?? []).map(p => p.name ?? p.key)).filter(Boolean))].sort();
+        return new FormDialog({
+            title: 'Generate roadmap',
+            description: 'A view with each element a bar from its start date to its end date, under the months.',
+            fields: [
+                { key: 'from', label: 'Elements', type: 'select', value: selected.length ? 'selection' : 'model', choices: [...(selected.length ? [['selection', `The ${selected.length} selected`]] : []), ['model', 'Every element with both dates']] },
+                { key: 'start', label: 'Start date property', type: 'text', value: 'Start Date', suggestions: names },
+                { key: 'end', label: 'End date property', type: 'text', value: 'End Date', suggestions: names },
+                { key: 'months', label: 'Month names', type: 'select', value: 'short', choices: [['short', 'Short (Jan)'], ['full', 'Full (January)']] },
+                { key: 'name', label: 'View name', type: 'text', value: 'Roadmap' },
+            ],
+            submitLabel: 'Generate',
+            idPrefix: 'roadmap-',
+            document: this.document ?? globalThis.document,
+            validate: (v) => (this.roadmapFor(v).view === null ? `No element has both "${v.start}" and "${v.end}" as dates` : null),
+            onApply: (v) => this.generateRoadmap(v),
+        }).open();
+    }
+
+    /** What a roadmap of these dialog values would hold: `{view: null}` when nothing would be on it (a dry run). @private */
+    roadmapFor({ from, start, end }) {
+        const ids = from === 'selection' ? this.getSelectedIds().map(id => this._elementOf(id)?.id).filter(Boolean) : this.model.elements().map(e => e.id);
+        const date = (e, key) => parseDate((e.properties ?? []).find(p => (p.name ?? p.key) === key)?.value);
+        const any = ids.map(id => this.model.getElement(id)).some(e => e && date(e, start) && date(e, end) && date(e, end) >= date(e, start));
+        return { ids, view: any ? true : null };
+    }
+
+    /** Generate the roadmap of Generate roadmap…'s values. @returns {{view, skipped}} */
+    generateRoadmap({ from = 'model', start = 'Start Date', end = 'End Date', months = 'short', name = 'Roadmap' } = {}) {
+        const { ids } = this.roadmapFor({ from, start, end });
+        return this.model.generateRoadmap(ids, { startProperty: start, endProperty: end, monthNames: months, name });
+    }
+
+    /** An element's box keeps room for its type badge, and Archi's height. */
+    textFit(template) {
+        return this._elementOf(template.id) ? { padding: 44, min: { width: 80, height: 55 } } : super.textFit(template);
+    }
+
+    /** Text becomes elements of any type of this version (the viewpoint's, when it limits them). */
+    shapeTypes() {
+        const viewpoint = this.nodeOptions.viewpoint;
+        const allowed = viewpoint && viewpoint !== 'All' ? ArchimateViewpoints.allowedElementTypes(viewpoint, this.version, this.customViewpoints) : null;
+        return ArchimateNotation.elementTypeNames(this.version)
+            .filter(t => !allowed || allowed.includes(t))
+            .map(t => [t, typeTitle(t)]);
+    }
+
+    /**
+     * New model elements from text, each with its box here: one undo step.
+     * A documentation column becomes the element's documentation.
+     */
+    createShapesCommand(items) {
+        const ids = this.model.elements().map(e => e.id);
+        const steps = [], createdIds = [];
+        for (const item of items) {
+            const id = GraphDiagram.generateNodeId(`${item.type}-${item.name}`, ids);
+            ids.push(id);
+            const instance = new ElementInstance(id, item.x, item.y);
+            createdIds.push(instance.id);
+            steps.push(new AddToViewCommand(this.view, instance, { element: { id, name: item.name, type: item.type, ...(item.documentation && { documentation: item.documentation }) } }));
+        }
+        const cmd = new CompositeCommand(`Add ${steps.length} element${steps.length === 1 ? '' : 's'} from text`, steps);
+        cmd.createdIds = createdIds;
+        return cmd;
+    }
+
+    /** What elements can be coloured by: their layer, type, specialization, and each property any of them has. */
+    colourKeys(templates = [...this.templates.values()]) {
+        const properties = new Set();
+        for (const t of templates) for (const p of this._elementOf(t.id)?.properties ?? []) if (p.name ?? p.key) properties.add(p.name ?? p.key);
+        return [
+            ['layer', 'Layer'], ['type', 'Type'], ['specialization', 'Specialization'],
+            ...[...properties].sort().map(name => [`property:${name}`, `Property "${name}"`]),
+        ];
+    }
+
+    /** An element's value for a colourKeys key (notes and pictures have none). */
+    colourValue(template, key) {
+        const element = this._elementOf(template.id);
+        if (!element) return undefined;
+        if (key === 'layer') return typeTitle(treeLayerOf(element));
+        if (key === 'type') return typeTitle(element.type ?? '');
+        if (key === 'specialization') return element.specialization;
+        if (key.startsWith('property:')) {
+            const p = (element.properties ?? []).find(q => (q.name ?? q.key) === key.slice(9));
+            return p?.value === undefined || p?.value === null ? undefined : String(p.value);
+        }
+        return super.colourValue(template, key);
+    }
+
+    /** The kind legend: each element type on the view, in the colour of its first box. */
+    kindLegendEntries() {
+        const types = new Map();
+        for (const t of this.templates.values()) {
+            const element = this._elementOf(t.id);
+            if (!element || types.has(element.type)) continue;
+            types.set(element.type, t.fillColor);
+        }
+        return [...types].map(([type, fillColor]) => ({ label: typeTitle(type), fillColor }));
+    }
+
+    /** A legend is notes (stickies on a canvas) on the view: one PlaceItemsCommand. */
+    legendCommand(entries, title) {
+        if (!entries.length) return null;
+        const kind = this.view.constructor.BOX_KINDS.find(k => k.key === 'note') ?? this.view.constructor.BOX_KINDS.find(k => k.key === 'sticky');
+        if (!kind) return null;
+        const { x, y } = this.legendPosition();
+        const stamp = Date.now().toString(36);
+        const box = (i, name, fillColor) => {
+            const inst = new ViewObjectInstance(kind.content(`legend-${stamp}-${i}`, { name }), x + 60 + i * 130, y + 20);
+            inst.size = { width: 120, height: 40 };
+            inst.appearance = { ...kind.appearance, fillColor };
+            return inst;
+        };
+        const boxes = [box(0, title, '#ffffff'), ...entries.map((e, i) => box(i + 1, e.label, e.fillColor))];
+        return new PlaceItemsCommand(this.view, { elementInstances: boxes }, { label: `Add legend: ${title}` });
+    }
+
+    /** Likely duplicates can be merged (Merge…: choose the one to keep). */
+    findingActions(finding) {
+        return finding.code === 'possible-duplicate' ? [{ label: 'Merge…', action: () => this.askMerge(finding.ids) }] : [];
+    }
+
+    /**
+     * Ask which of some elements to keep, then merge the others into it
+     * (ArchimateModel#mergeCommand), one undo step. Each choice says where the
+     * element is used, to help pick.
+     */
+    askMerge(elementIds) {
+        const elements = elementIds.map(id => this.model.getElement(id)).filter(Boolean);
+        if (elements.length < 2) return null;
+        const used = (e) => {
+            const views = this.model.views().filter(v => v.elementInstancesFor?.(e.id).length).length;
+            const { incoming, outgoing } = this.model.relationshipsFor(e.id);
+            return `${views} view${views === 1 ? '' : 's'}, ${incoming.length + outgoing.length} relationship${incoming.length + outgoing.length === 1 ? '' : 's'}`;
+        };
+        return new FormDialog({
+            title: `Merge ${elements.length} elements`,
+            description: 'The one kept takes the others\' relationships, their boxes on every view, and the documentation and properties it lacks; the others go.',
+            fields: [{ key: 'keep', label: 'Keep', type: 'select', value: elements[0].id, choices: elements.map(e => [e.id, `${e.name || e.id} (${used(e)})`]) }],
+            submitLabel: 'Merge',
+            idPrefix: 'merge-',
+            document: this.document ?? globalThis.document,
+            onApply: ({ keep }) => this.mergeElements(keep, elementIds.filter(id => id !== keep)),
+        }).open();
+    }
+
+    /** Merge elements into one (`keepId`), one undo step; the canvas and tree redraw. */
+    mergeElements(keepId, otherIds) {
+        const cmd = this.model.mergeCommand(keepId, otherIds);
+        this._executeCommand(cmd);
+        return cmd;
+    }
+
+    /** The checks use this editor's ArchiMate version. */
+    checkerOptions() {
+        return { version: this.version };
+    }
+
+    /** An element is shown by selecting its first occurrence on this view. */
+    revealFinding(finding) {
+        if (finding.kind !== 'element') return super.revealFinding(finding);
+        const instance = this.view.elementInstancesFor(finding.ids[0])[0];
+        if (instance && this.templates.has(instance.id)) {
+            this.selectTemplate(instance.id);
+            this.render();
+        }
+    }
+
+    /**
+     * Bring the editor's templates and lines in line with the view, reusing
+     * the template or line of each instance still there.
+     */
+    syncFromView() {
+        const { view, model } = this;
+        const templates = new Map();
+        for (const inst of view.elementInstances.values()) {
+            if (!inst.shownIn(view) || !inst.resolve(model)) continue;
+            const existing = this.templates.get(inst.id);
+            templates.set(inst.id, existing?.instance === inst ? existing
+                : new ArchimateElementTemplate(inst, model, { nodeOptions: this.nodeOptions }));
+        }
+        for (const t of templates.values()) t.nodeOptions = this.nodeOptions;
+        // The view's groups (Archi groups: model folders with bounds on this view).
+        for (const folder of view.placedFolders) {
+            const existing = this.templates.get(folder.id);
+            templates.set(folder.id, existing instanceof ViewGroupTemplate && existing.view === view ? existing : new ViewGroupTemplate(folder.id, view));
+        }
+        const edges = new Map();
+        // A line a nesting stands for, to a box nested in its source (at any depth), is not drawn unless asked (Archi's way).
+        const nestedOut = (edge) => !this.nodeOptions.showNestedLines
+            && hiddenByNesting(view, edge.relationship, templates.get(edge.sourceId).instance, templates.get(edge.targetId).instance);
+        for (const inst of view.relationshipInstances.values()) {
+            const existing = this.edges.get(inst.id);
+            const edge = existing?.instance === inst ? existing : new ArchimateEdge(inst, view);
+            if (edge.relationship && templates.has(edge.sourceId) && templates.has(edge.targetId) && !nestedOut(edge)) edges.set(inst.id, edge);
+        }
+        // Plain lines (a canvas's connections, a line from a note).
+        for (const line of view.viewConnections.values()) {
+            const existing = this.edges.get(line.id);
+            const edge = existing?.line === line ? existing : new ViewLineEdge(line);
+            if (line.visible !== false && templates.has(edge.sourceId) && templates.has(edge.targetId)) edges.set(line.id, edge);
+        }
+        // Derived relationships (⚙ Settings → Show derived): drawn between elements both on the view.
+        if (this.nodeOptions.showDerived) {
+            const shown = (elementId) => view.elementInstancesFor(elementId).find(inst => templates.has(inst.id))?.id;
+            for (const derived of DerivedRelationships.compute(model, { maxHops: 2 }).derived) {
+                const from = shown(derived.source), to = shown(derived.target);
+                if (from && to) edges.set(derived.id, new DerivedEdge(derived, from, to));
+            }
+        }
+        this.templates.clear();
+        for (const [id, t] of templates) this.templates.set(id, t);
+        this.edges.clear();
+        for (const [id, e] of edges) this.edges.set(id, e);
+    }
+
+    render() {
+        if (this.disposed) return;
+        this.syncFromView();
+        super.render();
+    }
+
+    /** ⚙ Settings: the notation (version, distinct shapes), then the base editor's grid and line styles. */
+    settingsMenuItems() {
+        const set = (patch) => {
+            this.nodeOptions = { ...this.nodeOptions, ...patch };
+            if (this.onNodeOptionsChange) this.onNodeOptionsChange(this.nodeOptions);
+            else this.render();
+        };
+        const distinct = !!this.nodeOptions.useDistinctShapes;
+        const viewpoint = this.nodeOptions.viewpoint ?? 'All';
+        const mode = this.nodeOptions.viewpointMode ?? 'fade';
+        return [
+            {
+                label: `Version: ArchiMate ${this.version}`,
+                items: ['4', '3.2'].map(v => ({ label: `ArchiMate ${v}`, checked: v === this.version, action: () => set({ archimateVersion: v }) })),
+            },
+            { label: `Distinct shapes: ${distinct ? 'on' : 'off'}`, action: () => set({ useDistinctShapes: !distinct }) },
+            { label: `Show derived: ${this.nodeOptions.showDerived ? 'on' : 'off'}`, action: () => set({ showDerived: !this.nodeOptions.showDerived }) },
+            { label: `Lines to nested boxes: ${this.nodeOptions.showNestedLines ? 'shown' : 'hidden'}`, action: () => set({ showNestedLines: !this.nodeOptions.showNestedLines }) },
+            {
+                label: `Viewpoint: ${viewpoint}`,
+                items: ArchimateViewpoints.all(this.customViewpoints).map(vp => ({ label: vp.name, checked: vp.name === viewpoint, action: () => set({ viewpoint: vp.name }) })),
+            },
+            {
+                label: `Outside the viewpoint: ${mode === 'hide' ? 'hidden' : 'faded'}`,
+                items: [['fade', 'Faded'], ['hide', 'Hidden']].map(([m, text]) => ({ label: text, checked: m === mode, action: () => set({ viewpointMode: m }) })),
+            },
+            { separator: true },
+            { separator: true },
+            { label: 'Specializations…', action: () => this.editSpecializations() },
+            { label: 'Viewpoints…', action: () => this.editViewpoints() },
+            ...super.settingsMenuItems(),
+            ...(this.settingsManager ? [{ separator: true }, { label: 'Model settings…', action: () => showGlobalSettingsDialog(this.document ?? globalThis.document, this.settingsManager, 'default') }] : []),
+        ];
+    }
+
+    /**
+     * What the ArchiMate rules say against a relationship's line, or null
+     * (ArchimateValidator, for this ArchiMate version). Off when the view's
+     * `invalidRelationships` setting is 'off'; with 'tooltip' it is the tooltip, not drawn red.
+     */
+    edgeWarning(edge) {
+        const relationship = edge.relationship;
+        const mode = this.viewSettings().invalidRelationships ?? 'highlight';
+        if (!relationship || mode === 'off') return null;
+        const from = this.model.getElement(relationship.source), to = this.model.getElement(relationship.target);
+        if (!from || !to) return null;
+        const result = ArchimateValidator.validateRelationship(from, to, relationship.kind, this.version);
+        return result.valid ? null : { message: result.message, highlight: mode === 'highlight' };
+    }
+
+    /** Edit the specialization catalog; elements given one redraw with it. */
+    editSpecializations() {
+        return specializationCatalogDialog({ version: this.version, document: this.document ?? globalThis.document, onChange: () => this._notationChanged() }).open();
+    }
+
+    /** Edit the user's own viewpoints; they are offered (and applied) from then on. */
+    editViewpoints() {
+        return CustomViewpoints.dialog({
+            version: this.version, document: this.document ?? globalThis.document,
+            onChange: (viewpoints) => { this.customViewpoints = viewpoints; this._viewpointRule = null; this._notationChanged(); },
+        }).open();
+    }
+
+    /** The notation's catalogs changed: the host redraws (its palette too), or this editor does. @private */
+    _notationChanged() {
+        if (this.onNodeOptionsChange) this.onNodeOptionsChange(this.nodeOptions);
+        else this.render();
+    }
+
+    /**
+     * The base editor's rules (a highlight), then the active filter's result
+     * (ElementFilterRule) and the viewpoint (ViewpointRule, from the notation options).
+     */
+    emphasisRules() {
+        const { viewpoint, viewpointMode } = this.nodeOptions;
+        const key = `${viewpoint}|${viewpointMode}|${this.version}`;
+        if (this._viewpointRule?.key !== key) {
+            this._viewpointRule = { key, rule: new ViewpointRule({ viewpoint, mode: viewpointMode, version: this.version, customViewpoints: this.customViewpoints }) };
+        }
+        return [...super.emphasisRules(), ...(this.elementFilter ? [this.elementFilter] : []), ...(this._viewpointRule.rule.viewpoint ? [this._viewpointRule.rule] : [])];
+    }
+
+    /** Dim every model element but these (a filter's result); null clears it. Redraws. */
+    setElementFilter(elementIds) {
+        this.elementFilter = elementIds ? new ElementFilterRule(elementIds) : null;
+        this.render();
+    }
+
+    /**
+     * The Element section of a shape's properties: the model element's own
+     * name, type, specialization, icon, documentation and typed properties (the same on every view;
+     * the dialog's Name above labels this occurrence only). None for a note,
+     * image or canvas box.
+     */
+    conceptFields(template) {
+        const element = this._elementOf(template.id);
+        if (!element) return [];
+        return [
+            { type: 'heading', label: 'Element (on every view)' },
+            ...elementPropertyFields(element, { version: this.version, document: this.document ?? globalThis.document }),
+        ];
+    }
+
+    /** The element's changes as one EditViewItemCommand (null when nothing changed). */
+    conceptCommand(template, values) {
+        const element = this._elementOf(template.id);
+        return element ? elementEditCommand(element, values, { instance: template.instance }) : null;
+    }
+
+    /**
+     * With several shapes selected, the Elements section: their type, their
+     * specialization when they share a type, and one property to set on all.
+     * Only when every selected shape is an element.
+     */
+    manyConceptFields(templates) {
+        const elements = this._elementsOf(templates);
+        return elements ? manyElementsFields(elements, { version: this.version }) : [];
+    }
+
+    /** The elements' changes as one step (null when nothing changed). */
+    manyConceptCommand(templates, values) {
+        const elements = this._elementsOf(templates);
+        const instances = new Map(templates.map(t => [this._elementOf(t.id), t.instance]));
+        const commands = elements ? manyElementsEditCommands(elements, values, { instanceOf: (e) => instances.get(e) }) : [];
+        return commands.length ? new CompositeCommand(`Edit ${commands.length} elements`, commands) : null;
+    }
+
+    /** The model elements the shapes show, each once; null unless every shape shows one. @private */
+    _elementsOf(templates) {
+        const elements = templates.map(t => this._elementOf(t.id));
+        return elements.every(Boolean) ? [...new Set(elements)] : null;
+    }
+
+    /**
+     * The Relationship section of a line's properties: its kind (among those
+     * the ArchiMate rules allow between its ends, and its own), documentation
+     * and typed properties. None for a plain line or a derived one.
+     */
+    edgeConceptFields(edge) {
+        const relationship = edge.relationship;
+        if (!relationship || edge.editable === false) return [];
+        const kinds = [...new Set([relationship.kind, ...this.allowedKinds(edge.sourceId, edge.targetId)].filter(Boolean))];
+        return [
+            { type: 'heading', label: 'Relationship (on every view)' },
+            { key: 'relationship.kind', label: 'Kind', type: 'select', value: relationship.kind, choices: kinds.map(k => [k, typeTitle(k)]) },
+            { key: 'relationship.documentation', label: 'Documentation', type: 'textarea', rows: 3, value: relationship.documentation ?? '' },
+            { type: 'heading', label: 'Properties' },
+            PropertyListEditor.field(relationship.properties, { key: 'relationship.properties', document: this.document ?? globalThis.document }),
+        ];
+    }
+
+    /** The relationship's changes as one EditViewItemCommand (null when nothing changed). */
+    edgeConceptCommand(edge, values) {
+        return edge.relationship ? conceptEditCommand(edge.relationship, values, { prefix: 'relationship', instance: edge.instance }) : null;
+    }
+
+    /** A new element of `type` at `point` (snapped), created in the model and shown here. One undo step. */
+    addElement(type, point) {
+        const name = typeTitle(type);
+        const id = GraphDiagram.generateNodeId(name, this.model.elements().map(e => e.id));
+        const at = this._snapToGrid(point);
+        const instance = new ElementInstance(id, at.x, at.y);
+        this._executeCommand(new AddToViewCommand(this.view, instance, { element: { id, name, type }, label: `Add ${name}` }));
+        return instance;
+    }
+
+    /**
+     * Show an element the model has at `point` (snapped), with its
+     * relationships to the elements already on the view (ShowElementCommand).
+     * One undo step. Null for an element the model lacks.
+     */
+    showElement(elementId, point) {
+        if (!this.model.getElement(elementId)) return null;
+        const at = this._snapToGrid(point);
+        const instance = new ElementInstance(elementId, at.x, at.y);
+        this._executeCommand(new ShowElementCommand(this.view, instance, { label: `Show ${this.model.getElement(elementId).name || elementId}` }));
+        this.selectTemplate(instance.id);
+        return instance;
+    }
+
+    /**
+     * A picture as an image box on this view at `point` (snapped), one undo
+     * step, selected. Null when this kind of view has no image box.
+     * @param {string} dataURL - The picture
+     */
+    addImage(dataURL, point) {
+        if (!this.view.constructor.BOX_KINDS?.some(k => k.key === 'image')) return null;
+        const box = this.view.addBox('image', this._snapToGrid(point), { iconUrl: dataURL });
+        this.render();
+        this.selectTemplate(box.id);
+        return box;
+    }
+
+    /**
+     * Add a box of a canvas palette kind ('block', 'sticky', 'image') at `point`
+     * (snapped), as the canvas menu would. One undo step.
+     */
+    addCanvasBox(kindKey, point) {
+        const item = canvasBoxMenuItems(this.view, this._snapToGrid(point), {
+            onAdded: (box) => { this.render(); this.selectTemplate(box.id); },
+        }).find((_, i) => this.view.constructor.BOX_KINDS[i].key === kindKey);
+        return item?.action();
+    }
+
+    /** The relationship kinds the ArchiMate rules allow from one instance's element to another's (association always). */
+    allowedKinds(sourceId, targetId) {
+        const from = this._elementOf(sourceId), to = this._elementOf(targetId);
+        if (!from || !to) return [];
+        const kinds = ArchimateValidator.allowedKinds(from, to, this.version);
+        return kinds.includes('association') ? kinds : [...kinds, 'association'];
+    }
+
+    /**
+     * Connect two elements: the kind is asked for (`chooseKind`) among those
+     * allowed, or taken from KIND_PREFERENCE. One undo step once chosen.
+     * @returns {Command|null|Promise<Command|null>}
+     */
+    connect(sourceId, targetId) {
+        if (sourceId === targetId) return null;
+        // A box or note at either end: a plain line (the view's rule), one undo step.
+        if (!this.view.linesAreRelationships(sourceId, targetId)) {
+            if (!this.templates.has(sourceId) || !this.templates.has(targetId)) return null;
+            const line = this.view.connect(sourceId, targetId);
+            this.render();
+            return line;
+        }
+        const kinds = this.allowedKinds(sourceId, targetId);
+        if (!kinds.length) return null;
+        const run = (kind) => (kind && kinds.includes(kind) ? this._connectAs(sourceId, targetId, kind) : null);
+        if (!this.chooseKind) return run(KIND_PREFERENCE.find(k => kinds.includes(k)) ?? kinds[0]);
+        const chosen = this.chooseKind(kinds, this._elementOf(sourceId), this._elementOf(targetId));
+        return chosen && typeof chosen.then === 'function' ? chosen.then(run) : run(chosen);
+    }
+
+    /** @private */
+    _connectAs(sourceId, targetId, kind) {
+        const cmd = this.connectCommand(sourceId, targetId, kind);
+        if (cmd) this._executeCommand(cmd);
+        return cmd;
+    }
+
+    /** The model element an instance on this canvas shows (notes and images have none). @private */
+    /** A box of a model element links to the element's page in a report. */
+    reportRef(template) {
+        const element = this._elementOf(template.id);
+        return element ? { kind: 'element', id: element.id } : null;
+    }
+
+    _elementOf(instanceId) {
+        const inst = this.templates.get(instanceId)?.instance;
+        return inst ? this.model.getElement(inst.elementId) : undefined;
+    }
+
+    /** A new relationship of `kind` between two elements' instances, created in the model and shown here. */
+    connectCommand(sourceId, targetId, kind = KIND_PREFERENCE.find(k => this.allowedKinds(sourceId, targetId).includes(k))) {
+        const source = this.templates.get(sourceId)?.instance;
+        const target = this.templates.get(targetId)?.instance;
+        const from = this._elementOf(sourceId);
+        const to = this._elementOf(targetId);
+        // Notes and images are not model elements: they take no relationships.
+        if (!from || !to || !kind) return null;
+        const id = GraphDiagram.generateNodeId(`${from.id}-${kind}-${to.id}`, this.model.relationships().map(r => r.id));
+        const instance = new RelationshipInstance(id, null, source.id, target.id);
+        return new AddRelationshipToViewCommand(this.view, instance, {
+            relationship: { id, source: from.id, target: to.id, kind },
+            label: `Add ${kind}`,
+        });
+    }
+
+    /**
+     * Deleting takes a box off the view (its lines go with it, see the base's
+     * deleteTemplatesCommand); the model keeps its element. A group goes off the
+     * view and what it held stays; the model keeps its folder.
+     */
+    /** Copies are ArchiMate views' items: they paste into ArchiMate views (any model), not the template editor. */
+    static clipboardKind = 'archimate';
+
+    /**
+     * A copy of these boxes: the view's JSON of them (ArchimateView#toJSON),
+     * with the lines and relationships between them and the elements they show.
+     * Groups are not copied (they are model folders).
+     */
+    copyPayload(ids) {
+        const boxes = ids.filter(id => this.view.getElementInstance(id));
+        return boxes.length ? this.view.toJSON({ itemIds: boxes }) : null;
+    }
+
+    /** Paste: new boxes for the same elements (added to the model when it lacks them), one undo step. */
+    pasteCommand(payload, options) {
+        return this.view.pasteCommand(payload, options);
+    }
+
+    /** Deleting is off the view: the model keeps what it showed. */
+    deleteLabel(templateIds) {
+        return `${super.deleteLabel(templateIds)} from view`;
+    }
+
+    removeTemplateCommand(templateId) {
+        return this.templates.get(templateId) instanceof ViewGroupTemplate
+            ? new RemoveGroupFromViewCommand(this.view, templateId)
+            : new DeleteElementCommand(this.view, templateId);
+    }
+
+    /**
+     * What moves with a shape: for a group, the elements drawn in it (its folder's),
+     * the notes and pictures Archi drew in it, and the groups inside it; for a box (a canvas block), the boxes Archi drew inside it.
+     */
+    containedIn(templateId) {
+        const template = this.templates.get(templateId);
+        const view = this.view;
+        if (template instanceof ViewGroupTemplate) {
+            const inner = [];
+            for (const t of this.templates.values()) {
+                if (t instanceof ViewGroupTemplate) {
+                    if (t.id !== templateId && view.placedFolders.find(f => f.id === t.id)?.parentId === templateId) inner.push(t.id);
+                } else if (t.instance?.archi?.parent === templateId
+                    || (t.instance?.elementId && view.placedFolderOf(t.instance.elementId) === templateId)) {
+                    inner.push(t.id);
+                }
+            }
+            return inner;
+        }
+        const visualId = template?.instance?.visualId;
+        if (!visualId) return [];
+        return [...this.templates.values()].filter(t => t.instance?.nestedIn === visualId).map(t => t.id);
+    }
+
+    // ===== Nesting =====
+
+    /** The box this one is drawn inside: an element's box, or a canvas block (a group holds by folder, not here). */
+    parentOf(templateId) {
+        const visualId = this.templates.get(templateId)?.instance?.nestedIn;
+        if (!visualId) return null;
+        const parent = [...this.templates.values()].find(t => t.instance?.visualId === visualId);
+        return parent?.id ?? null;
+    }
+
+    /**
+     * An element's parts on this view: the elements it is composed of or
+     * aggregates (its composition and aggregation relationships' targets),
+     * each by its first box here.
+     */
+    partsOf(templateId) {
+        const element = this._elementOf(templateId);
+        if (!element) return [];
+        const parts = this.model.relationships()
+            .filter(r => r.source === element.id && r.target !== element.id && (r.kind === 'composition' || r.kind === 'aggregation'))
+            .map(r => this.view.elementInstancesFor(r.target)[0]?.id)
+            .filter(id => id && this.templates.has(id) && this.canHold(templateId, id));
+        return [...new Set(parts)];
+    }
+
+    /** The "by kind" layout puts an element's box in its layer's row (notes and images in their own). */
+    layoutCategory(template) {
+        const element = this._elementOf(template.id);
+        return element ? treeLayerOf(element) : 'other';
+    }
+
+    /** An element's box holds any box but a group; on a canvas, a block holds boxes. */
+    canHold(parentId, childId) {
+        const parent = this.templates.get(parentId), child = this.templates.get(childId);
+        if (!parent?.instance || !child?.instance || parent instanceof ViewGroupTemplate || child instanceof ViewGroupTemplate) return false;
+        return !!this._elementOf(parentId) || parent.instance.content?.archiVisualType === 'canvas-model-block';
+    }
+
+    /** An element dropped on another nests there when a relationship a nesting stands for (NESTING_KINDS) is allowed between them. */
+    nestsOnDrop(parentId, childId) {
+        if (!this._elementOf(parentId) || !this._elementOf(childId)) return false;
+        return this.allowedKinds(parentId, childId).some(kind => NESTING_KINDS.includes(kind));
+    }
+
+    nestCommand(childId, parentId) {
+        const child = this.templates.get(childId)?.instance;
+        if (!child) return null;
+        return new NestInstanceCommand(child, parentId ? this.templates.get(parentId)?.instance ?? null : null);
+    }
+
+    /** After nesting an element in another: offer the relationship the nesting stands for (nestingKinds). */
+    nested(changes) {
+        let chain = Promise.resolve();
+        for (const { childId, parentId } of changes) {
+            chain = chain.then(() => this.offerNestingRelationship(parentId, childId));   // taken out: nothing to offer
+        }
+        return chain;
+    }
+
+    /**
+     * The kinds a nesting can stand for, from parent to child, as Archi offers
+     * them: those of NESTING_KINDS the rules allow. None when the two already
+     * have such a relationship.
+     */
+    nestingKinds(parentId, childId) {
+        const from = this._elementOf(parentId), to = this._elementOf(childId);
+        if (!from || !to || from === to) return [];
+        if (nestingRelationships(this.model, from.id, to.id).length) return [];
+        const allowed = this.allowedKinds(parentId, childId);
+        return NESTING_KINDS.filter(k => allowed.includes(k));
+    }
+
+    /**
+     * Ask which relationship a nesting stands for (`chooseKind`, with the
+     * reason 'nesting'; none chosen adds none) and add it to the model, drawn
+     * on no view: the nesting shows it. One undo step. Without `chooseKind`, nothing is added.
+     * @returns {Promise<Command|null>}
+     */
+    async offerNestingRelationship(parentId, childId) {
+        const kinds = this.nestingKinds(parentId, childId);
+        if (!kinds.length || !this.chooseKind) return null;
+        const from = this._elementOf(parentId), to = this._elementOf(childId);
+        const kind = await this.chooseKind(kinds, from, to, { reason: 'nesting' });
+        if (!kind || !kinds.includes(kind)) return null;
+        const cmd = this.nestingRelationshipCommand(parentId, childId, kind);
+        this._executeCommand(cmd);
+        return cmd;
+    }
+
+    /** The relationship of `kind` a nesting stands for, from parent to child, in the model only. */
+    nestingRelationshipCommand(parentId, childId, kind) {
+        const from = this._elementOf(parentId), to = this._elementOf(childId);
+        const id = GraphDiagram.generateNodeId(`${from.id}-${kind}-${to.id}`, this.model.relationships().map(r => r.id));
+        return new AddRelationshipCommand(this.model, { id, source: from.id, target: to.id, kind }, `Add ${kind} (nested)`);
+    }
+
+    /** Deleting a line takes it off the view: a plain line goes; a relationship stays in the model. */
+    deleteEdgeCommand(edgeId) {
+        return this.view.viewConnections.has(edgeId)
+            ? new RemoveLineCommand(this.view, edgeId)
+            : new RemoveRelationshipFromViewCommand(this.view, edgeId);
+    }
+}