@formicoidea/labre-framework-uml 0.59.0 → 0.60.0

package/dist/actions.d.ts

@@ -1,7 +1,7 @@
 import { type UmlDiagramKind, UmlDiagramElementModel, type UmlFragmentOperator } from '@formicoidea/labre-core/model';
 import type { BlockStdScope } from '@formicoidea/labre-core/std';
 import { type GfxPrimitiveElementModel } from '@formicoidea/labre-core/std/gfx';
-import { type UmlEdgeRole } from './edge-styles.js';
+import type { UmlEdgeRole } from './edge-styles.js';
 /**
  * Create a UML diagram frame centred on the viewport — the sheet one diagram is
  * drawn on (Annex A).
@@ -164,14 +164,14 @@ export type UmlGlyphKind = 'package' | 'note' | 'actor' | 'use-case' | 'port' |
  *
  * ## `uml:name` for five of them, `uml:label` for the rest
  *
- * See {@link NAMED_GLYPHS}: a package, a note and the three cubes carry a NAME
- * the grammar parses a keyword off; a port, a ball and a socket carry a LABEL.
- * Keeping them apart is what lets the exporter read a tier without first asking
- * what shape it is under.
+ * See `NAMED_GLYPH_KINDS` (`presets.ts`): a package, a note and the three
+ * cubes carry a NAME the grammar parses a keyword off; a port, a ball and a
+ * socket carry a LABEL. Keeping them apart is what lets the exporter read a
+ * tier without first asking what shape it is under.
  *
  * ## The label is where the notation puts it, and that is not this file's call
  *
- * The box comes out of {@link umlCompartmentBoxes}, which is where every
+ * The box comes out of `umlCompartmentBoxes`, which is where every
  * "beside the glyph" and "inside the front face" decision is written down: a
  * port's label sits next to the square rather than on it (the square is 16
  * units, and words do not fit in it), an interface mark's sits beside the ball
@@ -214,12 +214,13 @@ export declare function createUmlNode(std: BlockStdScope, kind: UmlGlyphKind): v
  *
  * ## How many tiers is the LAYOUT's answer, not this file's
  *
- * The walk below writes a tier for each box `umlCompartmentBoxes` returns and
- * for no other, which is what lets two kinds be added to the notation without a
- * line changing here: a component and an artifact arrive with the name tier and
- * the one body tier §11.6.4 and §19.3.4 draw them with, because that is what the
- * layout hands over. The alternative — a table of tier counts in this file —
- * would be a second statement of the geometry, and the first one to drift.
+ * The assembly (`umlArtefactElements`) writes a tier for each box
+ * `umlCompartmentBoxes` returns and for no other, which is what lets two kinds
+ * be added to the notation without a line changing here: a component and an
+ * artifact arrive with the name tier and the one body tier §11.6.4 and §19.3.4
+ * draw them with, because that is what the layout hands over. The alternative
+ * — a table of tier counts in this file — would be a second statement of the
+ * geometry, and the first one to drift.
  *
  * ## Four or five elements, and the object is the four
  *
@@ -264,7 +265,7 @@ export type { UmlEdgeRole };
  * Because UML has twelve of them and they differ on three props out of a table
  * that is otherwise identical — the same mode, the same ink, the same weight. A
  * dozen near-identical functions would be a dozen places for a stroke width to
- * drift, and {@link UML_EDGE_STYLE} is the notation itself, which is the thing
+ * drift, and `UML_EDGE_STYLE` is the notation itself, which is the thing
  * worth reading. It is also what made phase 2 free: `deploy`, `manifest` and
  * `communication-path` arm through this function without a line changing in it.
  *

package/dist/actions.js

@@ -1,19 +1,16 @@
 import { DefaultTool, runInterchangeImportFile, } from '@formicoidea/labre-core/blocks/surface';
 import { ConnectorTool } from '@formicoidea/labre-core/gfx/connector';
-import { ConnectorMode, TextAlign, UmlDiagramElementModel, } from '@formicoidea/labre-core/model';
+import { UmlDiagramElementModel, } from '@formicoidea/labre-core/model';
 import { translateKey } from '@formicoidea/labre-core/shared/services';
 import { downloadBlob } from '@formicoidea/labre-core/shared/utils';
-import { Bound } from '@formicoidea/labre-core/global/gfx';
 import { GfxControllerIdentifier, } from '@formicoidea/labre-core/std/gfx';
-import { umlCompartmentBoxes, umlLabelRoleOf, } from './component.js';
-import { UML_BODY_FONT_SIZE, UML_DIAGRAM_BOX, UML_EDGE_WIDTH, UML_FRAGMENT_BOX, UML_INK, UML_NAME_FONT_SIZE, UML_NODE_BOX, UML_PARTITION_BOX, UML_REGION_BOX, UML_SUBJECT_BOX, } from './consts.js';
+import { UML_NODE_BOX } from './consts.js';
 import { decodeDrawio } from './drawio-decode.js';
-import { UML_EDGE_STYLE } from './edge-styles.js';
 import { umlSafeFilename } from './filename.js';
 import { UML_DRAWIO_IMPORT, UML_PLANTUML_EXPORT, UML_PLANTUML_IMPORT, UML_XMI_EXPORT, UML_XMI_IMPORT, } from './interchange.js';
-import { UML_ATTRIBUTES_SEED, UML_ATTRIBUTES_SEED_KEY, UML_NAME_SEED, UML_OPERATIONS_SEED, UML_OPERATIONS_SEED_KEY, UML_SLOTS_SEED, UML_SLOTS_SEED_KEY, UML_UNLABELLED_KINDS, umlSeedKey, } from './keywords.js';
-import { umlNameDecoration, umlNodeProps, umlTextProps } from './presets.js';
-import { UML_ROLE, umlDiagramRoleKey, umlRoleKey, umlSubjectRoleKey, } from './roles.js';
+import { UML_NAME_SEED, UML_OPERATIONS_SEED, UML_OPERATIONS_SEED_KEY, UML_UNLABELLED_KINDS, umlBodySeed, umlSeedKey, } from './keywords.js';
+import { umlConnectorProps, UML_FRAME_BOX, } from './presets.js';
+import { UML_FRAME_SEED, umlFrameElement, umlNodeElements } from './toolbox.js';
 /**
  * Standalone creation/activation actions for the UML toolbox — the same shape
  * BPMN's and C4's `actions.ts` have, and for the same reason: the menu is a pure
@@ -27,13 +24,64 @@ function finish(gfx, id) {
     gfx.selection.set({ elements: [id], editing: false });
     // Keep the palette open (native sub-menu behaviour).
 }
-/** One compartment of a component, as a canvas TEXT element. */
-function addTier(surface, index, role, text, box, options) {
-    return surface.addElement({
-        ...umlTextProps(role, box, options),
-        text,
-        index,
-    });
+/**
+ * Write a toolbox builder's elements (`toolbox.ts`, `docs/adr/0045`) the way
+ * the toolbar does, and say what the gesture produced.
+ *
+ * What only an editor has stays here: the layer index, minted per element in
+ * painting order — a stability statement, since two elements sharing an index
+ * sort by nanoid — and the surface's own ids, which a group's `children` is
+ * rewritten to name. The group is LAST in a builder's list, so every member
+ * already has its id when the group is written.
+ *
+ * Returns the group's id when there is one, else the first element's: what a
+ * gesture selects.
+ */
+function place(gfx, elements) {
+    const surface = gfx.surface;
+    if (!surface)
+        return undefined;
+    const minted = new Map();
+    let first;
+    let group;
+    for (const { id: local, ...props } of elements) {
+        if (props.type === 'group') {
+            // A plain record is a legal `children`: the group's own `propsToY` takes
+            // the KEYS and forces every value to `true`.
+            props.children = Object.fromEntries(Object.keys(props.children).map(child => [
+                minted.get(child) ?? child,
+                true,
+            ]));
+        }
+        const id = surface.addElement({
+            ...props,
+            index: gfx.layer.generateIndex(),
+        });
+        minted.set(local, id);
+        first ??= id;
+        if (props.type === 'group')
+            group = id;
+    }
+    return group ?? first;
+}
+/** A frame centred on the viewport, written and selected. */
+function createUmlFrame(std, type, name, options) {
+    const gfx = gfxOf(std);
+    const surface = gfx.surface;
+    if (!surface)
+        return;
+    const { w, h } = UML_FRAME_BOX[type];
+    const { centerX: cx, centerY: cy } = gfx.viewport;
+    const { id: _local, ...props } = umlFrameElement(type, { x: cx - w / 2, y: cy - h / 2 }, name, type, options);
+    finish(gfx, surface.addElement(props));
+}
+/**
+ * A frame's default name, resolved through the translation seam at placement
+ * and never again: content from the moment it lands (#183).
+ */
+function frameName(std, type) {
+    const [key, english] = UML_FRAME_SEED[type];
+    return translateKey(std, key, english);
 }
 /* ── The sheet and the frame on it ─────────────────────────────────────── */
 /**
@@ -54,22 +102,10 @@ function addTier(surface, index, role, text, box, options) {
  * once and never re-resolved.
  */
 export function createUmlDiagram(std, kind = 'class') {
-    const gfx = gfxOf(std);
-    const surface = gfx.surface;
-    if (!surface)
-        return;
-    const { w, h } = UML_DIAGRAM_BOX;
-    const { centerX: cx, centerY: cy } = gfx.viewport;
-    const id = surface.addElement({
-        type: 'umlDiagram',
-        // The FRAME the elements are drawn on, and a role of its own: a rule written
-        // on the artefacts must never fall on the sheet holding them.
-        role: UML_ROLE.diagram,
-        name: translateKey(std, umlDiagramRoleKey, 'Diagram'),
-        kind,
-        xywh: new Bound(cx - w / 2, cy - h / 2, w, h).serialize(),
-    });
-    finish(gfx, id);
+    // The FRAME the elements are drawn on, with a role of its own
+    // (`umlFrameProps`): a rule written on the artefacts must never fall on the
+    // sheet holding them.
+    createUmlFrame(std, 'umlDiagram', frameName(std, 'umlDiagram'), { kind });
 }
 /**
  * Create a use case SUBJECT centred on the viewport (§18.1.4) — the rectangle
@@ -79,30 +115,8 @@ export function createUmlDiagram(std, kind = 'class') {
  * ONE name, so there is nothing for a discriminant to discriminate.
  */
 export function createUmlSubject(std) {
-    const gfx = gfxOf(std);
-    const surface = gfx.surface;
-    if (!surface)
-        return;
-    const { w, h } = UML_SUBJECT_BOX;
-    const { centerX: cx, centerY: cy } = gfx.viewport;
-    const id = surface.addElement({
-        type: 'umlSubject',
-        role: UML_ROLE.subject,
-        name: translateKey(std, umlSubjectRoleKey, 'Subject'),
-        xywh: new Bound(cx - w / 2, cy - h / 2, w, h).serialize(),
-    });
-    finish(gfx, id);
+    createUmlFrame(std, 'umlSubject', frameName(std, 'umlSubject'));
 }
-/**
- * The two behaviour BACKGROUNDS, named through the same seam the subject is.
- *
- * `umlRoleKey` rather than a `umlPartitionRoleKey` export, and it is the same
- * string either way (`roles.ts` derives both from the role's local name): a
- * default name is asked for ONCE, at creation, and it is the author's content
- * from that moment on — so the call site needs the key and nothing else.
- */
-const umlPartitionRoleKey = umlRoleKey('partition');
-const umlRegionRoleKey = umlRoleKey('region');
 /**
  * Create an activity PARTITION — a swimlane (§15.6.4), the band an activity
  * diagram draws round the steps one participant is responsible for.
@@ -127,19 +141,7 @@ const umlRegionRoleKey = umlRoleKey('region');
  * turns a column into a row.
  */
 export function createUmlPartition(std) {
-    const gfx = gfxOf(std);
-    const surface = gfx.surface;
-    if (!surface)
-        return;
-    const { w, h } = UML_PARTITION_BOX;
-    const { centerX: cx, centerY: cy } = gfx.viewport;
-    const id = surface.addElement({
-        type: 'umlPartition',
-        role: UML_ROLE.partition,
-        name: translateKey(std, umlPartitionRoleKey, 'Partition'),
-        xywh: new Bound(cx - w / 2, cy - h / 2, w, h).serialize(),
-    });
-    finish(gfx, id);
+    createUmlFrame(std, 'umlPartition', frameName(std, 'umlPartition'));
 }
 /**
  * Create a REGION — the rounded, named rectangle a composite state is drawn as
@@ -155,19 +157,7 @@ export function createUmlPartition(std) {
  * into.
  */
 export function createUmlRegion(std) {
-    const gfx = gfxOf(std);
-    const surface = gfx.surface;
-    if (!surface)
-        return;
-    const { w, h } = UML_REGION_BOX;
-    const { centerX: cx, centerY: cy } = gfx.viewport;
-    const id = surface.addElement({
-        type: 'umlRegion',
-        role: UML_ROLE.region,
-        name: translateKey(std, umlRegionRoleKey, 'Region'),
-        xywh: new Bound(cx - w / 2, cy - h / 2, w, h).serialize(),
-    });
-    finish(gfx, id);
+    createUmlFrame(std, 'umlRegion', frameName(std, 'umlRegion'));
 }
 /* ── Phase 3: the combined fragment (§17.6.4) and the interaction use ───── */
 /**
@@ -209,19 +199,7 @@ export function createUmlRegion(std) {
  * putting a branch on the sheet nobody asked for.
  */
 export function createUmlFragment(std, operator = 'alt') {
-    const gfx = gfxOf(std);
-    const surface = gfx.surface;
-    if (!surface)
-        return;
-    const { w, h } = UML_FRAGMENT_BOX;
-    const { centerX: cx, centerY: cy } = gfx.viewport;
-    const id = surface.addElement({
-        type: 'umlFragment',
-        role: UML_ROLE.fragment,
-        operator,
-        xywh: new Bound(cx - w / 2, cy - h / 2, w, h).serialize(),
-    });
-    finish(gfx, id);
+    createUmlFrame(std, 'umlFragment', undefined, { operator });
 }
 /**
  * Create an INTERACTION USE — §17.7.4's `ref` frame, the box that says "and
@@ -245,42 +223,37 @@ export function createUmlInteractionUse(std) {
     createUmlFragment(std, 'ref');
 }
 /**
- * The glyph kinds whose one tier is a `uml:name` rather than a `uml:label`.
- *
- * The line between the two is drawn by `roles.ts` and it is not about having a
- * rectangle: `uml:name` is the tier a KEYWORD may be written on and the grammar
- * reads back, `uml:label` is a name and nothing else. So:
- *
- *  - a **package** name is a namespace, parseable and qualified (§12.2.4), and a
- *    **note**'s text is what the exporter writes as the comment's body;
- *  - the three **deployment cubes** are named INSIDE their front face, over a
- *    keyword line — `«device»`, `«executionEnvironment»` (§19.4.4) — which is
- *    exactly what a name compartment is for. It is also load-bearing rather than
- *    tidy: the morph's `afterMorph` rewrites `uml:name` and only that, so a cube
- *    labelled instead of named would morph into a device that never said so.
- *
- * Everything else here carries a LABEL: a port's word sits beside a 16-unit
- * square and the two interface marks' beside a ball and a socket, none of them
- * inside anything, and none of them ever carrying a keyword.
- */
-const NAMED_GLYPHS = new Set([
-    'package',
-    'note',
-    'node',
-    'device',
-    'execution-environment',
-]);
-/**
- * Where the viewport centre puts a node of this kind.
- *
- * Shared by the two creation functions so a class and a use case are centred by
- * the same arithmetic — the geometry is the only thing the two gestures have in
- * common, and it is worth not writing twice.
+ * Place an artefact centred on the viewport and select what the gesture
+ * produced: the GROUP when the kind has words, the SHAPE when it is a mark.
+ *
+ * The elements come from the ONE assembly a host with no editor and every
+ * importer also call (`umlNodeElements`, `toolbox.ts`, over
+ * `umlArtefactElements`, `presets.ts`, `docs/adr/0045`). What only an editor
+ * has stays here: the viewport centre, and every seed resolved through the
+ * translation SEAM — the words a gesture writes are persisted, so a host that
+ * has a catalogue must be asked before they land: a package dropped in a
+ * French editor is never called "Package" afterwards (R30). Resolved once,
+ * here; content from that moment on.
  */
-function centredBox(gfx, kind) {
+function createUmlArtefact(std, kind) {
+    const gfx = gfxOf(std);
+    if (!gfx.surface)
+        return;
     const { w, h } = UML_NODE_BOX[kind];
     const { centerX: cx, centerY: cy } = gfx.viewport;
-    return { x: cx - w / 2, y: cy - h / 2, w, h };
+    const [bodyKey, bodyText] = umlBodySeed(kind);
+    const elements = umlNodeElements(kind, { x: cx - w / 2, y: cy - h / 2 }, 
+    // A mark asks for no key: there is no word to translate.
+    UML_UNLABELLED_KINDS.has(kind)
+        ? {}
+        : {
+            name: translateKey(std, umlSeedKey(kind), UML_NAME_SEED[kind]),
+            attributes: bodyKey ? translateKey(std, bodyKey, bodyText) : bodyText,
+            operations: translateKey(std, UML_OPERATIONS_SEED_KEY, UML_OPERATIONS_SEED),
+        });
+    const id = place(gfx, elements);
+    if (id)
+        finish(gfx, id);
 }
 /**
  * Create one of the SINGLE-LABEL artefacts — a package, a note, an actor, a use
@@ -299,14 +272,14 @@ function centredBox(gfx, kind) {
  *
  * ## `uml:name` for five of them, `uml:label` for the rest
  *
- * See {@link NAMED_GLYPHS}: a package, a note and the three cubes carry a NAME
- * the grammar parses a keyword off; a port, a ball and a socket carry a LABEL.
- * Keeping them apart is what lets the exporter read a tier without first asking
- * what shape it is under.
+ * See `NAMED_GLYPH_KINDS` (`presets.ts`): a package, a note and the three
+ * cubes carry a NAME the grammar parses a keyword off; a port, a ball and a
+ * socket carry a LABEL. Keeping them apart is what lets the exporter read a
+ * tier without first asking what shape it is under.
  *
  * ## The label is where the notation puts it, and that is not this file's call
  *
- * The box comes out of {@link umlCompartmentBoxes}, which is where every
+ * The box comes out of `umlCompartmentBoxes`, which is where every
  * "beside the glyph" and "inside the front face" decision is written down: a
  * port's label sits next to the square rather than on it (the square is 16
  * units, and words do not fit in it), an interface mark's sits beside the ball
@@ -342,83 +315,8 @@ function centredBox(gfx, kind) {
  * rules off and the exporter reads.
  */
 export function createUmlNode(std, kind) {
-    const gfx = gfxOf(std);
-    const surface = gfx.surface;
-    if (!surface)
-        return;
-    const { x, y, w, h } = centredBox(gfx, kind);
-    const shapeId = surface.addElement({
-        // Every prop the kind is worth, from the ONE table the morph also reads
-        // (`presets.ts`). NO `text`: the words are the child below, and the shape is
-        // a body and nothing else.
-        ...umlNodeProps(kind, { xywh: new Bound(x, y, w, h).serialize() }),
-        index: gfx.layer.generateIndex(),
-    });
-    // The marks the notation draws without a word on them: the shape IS the
-    // artefact, so there is nothing to group it with and nothing to seed.
-    if (UML_UNLABELLED_KINDS.has(kind)) {
-        finish(gfx, shapeId);
-        return;
-    }
-    const { name: box } = umlCompartmentBoxes(kind, x, y, w, h);
-    const isLabel = !NAMED_GLYPHS.has(kind);
-    const textId = addTier(surface, gfx.layer.generateIndex(), 
-    // WHICH label role is the kind's own answer, not this file's: a lifeline's
-    // head carries `uml:lifeline-ident` and every other single word carries
-    // `uml:label` (`component.ts`, {@link umlLabelRoleOf}).
-    isLabel ? umlLabelRoleOf(kind) : UML_ROLE.name, 
-    // Through the SEAM, like the frames above: the words a gesture writes are
-    // persisted, so a host that has a catalogue must be asked before they land
-    // — a package dropped in a French editor is never called "Package"
-    // afterwards (R30). Resolved once, here; content from that moment on.
-    translateKey(std, umlSeedKey(kind), UML_NAME_SEED[kind]), box, {
-        fontSize: UML_NAME_FONT_SIZE,
-        align: kind === 'note' ? TextAlign.Left : TextAlign.Center,
-    });
-    // The group LAST, so it is written after everything it holds: the elements are
-    // created in painting order — the shape first and the words above it — and the
-    // group's own `xywh` is derived from its children.
-    const groupId = surface.addElement({
-        type: 'group',
-        index: gfx.layer.generateIndex(),
-        // A plain record is a legal `children`: the group's own `propsToY` takes the
-        // KEYS and forces every value to `true`.
-        children: { [shapeId]: true, [textId]: true },
-        // No title, deliberately. The group renderer paints one only while the
-        // artefact is selected, and a package announcing itself as "Group 3" above
-        // its own name is a label nobody wrote.
-    });
-    finish(gfx, groupId);
+    createUmlArtefact(std, kind);
 }
-/**
- * What the SECOND compartment says on a fresh artefact, where it is not the
- * §9.5.4 attribute line every classifier gets.
- *
- * Two exceptions and a default, rather than three entries, because the default
- * is the rule: `+ attribute : Type` is what a divided rectangle's body tier
- * holds unless the kind's own clause says otherwise.
- *
- *  - an **object**'s tier holds SLOTS (§9.8.4) — `attribute = value`, an
- *    instance giving its classifier's features values rather than redeclaring
- *    them;
- *  - a **state**'s holds INTERNAL ACTIVITIES (§14.2.4.4) and is seeded EMPTY.
- *    That is the one place in this pack where a blank tier is the right
- *    stencil, and it is the exporter that decides it: `model.ts` reads
- *    `entry / …`, `do / …` and `exit / …` off these lines and treats a label
- *    with nothing after it as no behaviour at all, so a seeded `entry / ` would
- *    be a prompt that reads as content and exports as nothing. §14.2.4's own
- *    figures draw exactly this — a named state with a ruled-off compartment
- *    waiting to be filled — and the author types the first line the grammar
- *    then reads back.
- *
- * Each is paired with the key it is the English default of, and the state's is
- * `null` for the reason an unlabelled kind contributes none: there is no word
- * to translate.
- */
-const BODY_SEED = {
-    object: [UML_SLOTS_SEED_KEY, UML_SLOTS_SEED],
-    state: [null, ''],
-};
 /**
  * Create one of the COMPARTMENTED artefacts — a class, an interface, an
  * enumeration, an object, and since phase 2 a component, an artifact or a
@@ -426,12 +324,13 @@ const BODY_SEED = {
  *
  * ## How many tiers is the LAYOUT's answer, not this file's
  *
- * The walk below writes a tier for each box `umlCompartmentBoxes` returns and
- * for no other, which is what lets two kinds be added to the notation without a
- * line changing here: a component and an artifact arrive with the name tier and
- * the one body tier §11.6.4 and §19.3.4 draw them with, because that is what the
- * layout hands over. The alternative — a table of tier counts in this file —
- * would be a second statement of the geometry, and the first one to drift.
+ * The assembly (`umlArtefactElements`) writes a tier for each box
+ * `umlCompartmentBoxes` returns and for no other, which is what lets two kinds
+ * be added to the notation without a line changing here: a component and an
+ * artifact arrive with the name tier and the one body tier §11.6.4 and §19.3.4
+ * draw them with, because that is what the layout hands over. The alternative
+ * — a table of tier counts in this file — would be a second statement of the
+ * geometry, and the first one to drift.
  *
  * ## Four or five elements, and the object is the four
  *
@@ -460,41 +359,7 @@ const BODY_SEED = {
  * visual cue UML gives for visibility (§9.5.4).
  */
 export function createUmlClassifier(std, kind) {
-    const gfx = gfxOf(std);
-    const surface = gfx.surface;
-    if (!surface)
-        return;
-    const { x, y, w, h } = centredBox(gfx, kind);
-    const shapeId = surface.addElement({
-        ...umlNodeProps(kind, { xywh: new Bound(x, y, w, h).serialize() }),
-        index: gfx.layer.generateIndex(),
-    });
-    const boxes = umlCompartmentBoxes(kind, x, y, w, h);
-    const children = { [shapeId]: true };
-    children[addTier(surface, gfx.layer.generateIndex(), UML_ROLE.name, 
-    // Through the seam, exactly as {@link createUmlNode} writes its one tier.
-    translateKey(std, umlSeedKey(kind), UML_NAME_SEED[kind]), boxes.name, {
-        fontSize: UML_NAME_FONT_SIZE,
-        align: TextAlign.Center,
-        bold: true,
-        decoration: umlNameDecoration(kind),
-    })] = true;
-    if (boxes.attributes) {
-        const [bodyKey, bodyText] = BODY_SEED[kind] ?? [
-            UML_ATTRIBUTES_SEED_KEY,
-            UML_ATTRIBUTES_SEED,
-        ];
-        children[addTier(surface, gfx.layer.generateIndex(), UML_ROLE.attributes, bodyKey ? translateKey(std, bodyKey, bodyText) : bodyText, boxes.attributes, { fontSize: UML_BODY_FONT_SIZE, align: TextAlign.Left })] = true;
-    }
-    if (boxes.operations) {
-        children[addTier(surface, gfx.layer.generateIndex(), UML_ROLE.operations, translateKey(std, UML_OPERATIONS_SEED_KEY, UML_OPERATIONS_SEED), boxes.operations, { fontSize: UML_BODY_FONT_SIZE, align: TextAlign.Left })] = true;
-    }
-    const groupId = surface.addElement({
-        type: 'group',
-        index: gfx.layer.generateIndex(),
-        children,
-    });
-    finish(gfx, groupId);
+    createUmlArtefact(std, kind);
 }
 /**
  * Arm the native connector tool, pre-styled for one UML relationship.
@@ -504,7 +369,7 @@ export function createUmlClassifier(std, kind) {
  * Because UML has twelve of them and they differ on three props out of a table
  * that is otherwise identical — the same mode, the same ink, the same weight. A
  * dozen near-identical functions would be a dozen places for a stroke width to
- * drift, and {@link UML_EDGE_STYLE} is the notation itself, which is the thing
+ * drift, and `UML_EDGE_STYLE` is the notation itself, which is the thing
  * worth reading. It is also what made phase 2 free: `deploy`, `manifest` and
  * `communication-path` arm through this function without a line changing in it.
  *
@@ -522,15 +387,10 @@ export function createUmlClassifier(std, kind) {
  * keep the user's own style (#144 M1).
  */
 export function activateUmlEdge(std, role) {
-    gfxOf(std).tool.setTool(ConnectorTool, {
-        mode: ConnectorMode.Straight,
-        role: UML_ROLE[role],
-        style: {
-            stroke: UML_INK,
-            strokeWidth: UML_EDGE_WIDTH,
-            ...UML_EDGE_STYLE[role],
-        },
-    });
+    // The line a host's connector and an imported one are drawn in too
+    // (`umlConnectorProps`, `docs/adr/0045`): one table, read three ways.
+    const { type: _type, role: roleId, mode, ...style } = umlConnectorProps(role);
+    gfxOf(std).tool.setTool(ConnectorTool, { mode, role: roleId, style });
     // Keep the palette open (native sub-menu behaviour).
 }
 /* ── The legend ────────────────────────────────────────────────────────── */

package/dist/component.d.ts

@@ -309,10 +309,10 @@ export declare const UML_HEAD_LABEL_KINDS: ReadonlySet<UmlNodeKind>;
  * single role could only ever have asked them the same question (`roles.ts`).
  *
  * It does NOT answer for the compartmented kinds or for the five glyphs named
- * rather than labelled (`actions.ts`, `NAMED_GLYPHS`): those carry `uml:name`,
- * which is a different statement — a tier a keyword may be written over — and a
- * helper that folded all three answers together would be a second place to
- * decide what the grammar reads.
+ * rather than labelled (`presets.ts`, `NAMED_GLYPH_KINDS`): those carry
+ * `uml:name`, which is a different statement — a tier a keyword may be written
+ * over — and a helper that folded all three answers together would be a second
+ * place to decide what the grammar reads.
  */
 export declare function umlLabelRoleOf(kind: UmlNodeKind): UmlRoleId;
 /**

package/dist/component.js

@@ -330,10 +330,10 @@ export const UML_HEAD_LABEL_KINDS = new Set(['lifeline']);
  * single role could only ever have asked them the same question (`roles.ts`).
  *
  * It does NOT answer for the compartmented kinds or for the five glyphs named
- * rather than labelled (`actions.ts`, `NAMED_GLYPHS`): those carry `uml:name`,
- * which is a different statement — a tier a keyword may be written over — and a
- * helper that folded all three answers together would be a second place to
- * decide what the grammar reads.
+ * rather than labelled (`presets.ts`, `NAMED_GLYPH_KINDS`): those carry
+ * `uml:name`, which is a different statement — a tier a keyword may be written
+ * over — and a helper that folded all three answers together would be a second
+ * place to decide what the grammar reads.
  */
 export function umlLabelRoleOf(kind) {
     return UML_HEAD_LABEL_KINDS.has(kind)

package/dist/import.d.ts

@@ -1,5 +1,5 @@
 import type { InterchangeNote, SerializedElementProps } from '@formicoidea/labre-core/blocks/surface';
-import { type UmlBox } from './component.js';
+import type { UmlBox } from './component.js';
 import { type UmlModel, type UmlNodeBase, type UmlRelation, type UmlRelationKind } from './model.js';
 /**
  * The **one materializer** every UML importer ends on — a model in, the
@@ -23,11 +23,12 @@ import { type UmlModel, type UmlNodeBase, type UmlRelation, type UmlRelationKind
  *
  * ## Never a size, never a colour, never a seed
  *
- * Every prop below comes out of {@link umlNodeProps}, {@link umlTextProps} and
- * {@link umlCompartmentBoxes} — the very three functions the creation site calls
- * (R17). Not one measurement is restated here, so an imported class and a drawn
- * one are the same element down to the stroke width, and a restyle that moves
- * the pack moves the import with it.
+ * Every artefact below comes out of {@link umlArtefactElements}, every frame
+ * out of {@link umlFrameProps} and every line out of {@link umlConnectorProps}
+ * — the very assembly the toolbar and the toolbox call (R17,
+ * `docs/adr/0045`). Not one measurement is restated here, so an imported class
+ * and a drawn one are the same element down to the stroke width, and a restyle
+ * that moves the pack moves the import with it.
  *
  * ## The two names an element carries, and they are not the same name
  *