@formicoidea/labre-framework-bpmn 0.43.1 → 0.45.0

package/dist/import.js

@@ -1,9 +1,9 @@
 import { InterchangeImportError, } from '@formicoidea/labre-core/blocks/surface';
 import { ConnectorMode, PointStyle, StrokeStyle } from '@formicoidea/labre-core/model';
 import { Bound } from '@formicoidea/labre-core/global/gfx';
-import { ASSOCIATION_STROKE, ASSOCIATION_WIDTH, MESSAGE_STROKE, MESSAGE_WIDTH, NODE_SIZE, POOL_BAND_WIDTH, POOL_REF_HEIGHT, POOL_REF_WIDTH, SEQUENCE_STROKE, SEQUENCE_WIDTH, } from './consts.js';
+import { ASSOCIATION_STROKE, ASSOCIATION_WIDTH, bpmnLabelMode, MESSAGE_STROKE, MESSAGE_WIDTH, NODE_SIZE, POOL_BAND_WIDTH, POOL_REF_HEIGHT, POOL_REF_WIDTH, SEQUENCE_STROKE, SEQUENCE_WIDTH, } from './consts.js';
 import { BPMN_FORMAT_ID, BPMN_NS, BPMN_OWN_DECLARATIONS, BPMN_SCOPE, BPMN_XML_OF_KIND, escapeAttr, escapeText, } from './export.js';
-import { bpmnNodeProps } from './presets.js';
+import { bpmnLabelBoxUnder, bpmnLabelProps, bpmnNodeProps } from './presets.js';
 import { BPMN_ROLE } from './roles.js';
 /**
  * The remarks whose wording is FIXED, as `[key, English]` pairs — one entry
@@ -158,8 +158,23 @@ export const BPMN_IMPORT_ERRORS = {
  * `source` / `target` below name the **source file's** ids rather than surface
  * ones. The caller creates the elements, folds the array into a map from each
  * element's `interchange.bpmn.id` to the id the surface minted for it, and
- * rewrites the two endpoints. Every element carries that id, so the map is a
- * fold over the very array this returned; nothing else is needed to finish it.
+ * rewrites the two endpoints. Every element a flow can name carries that id, so
+ * the map is a fold over the very array this returned.
+ *
+ * ## The gravitating label, and the second name it needs
+ *
+ * An event, a gateway or a data shape wears its `name` UNDER the symbol, as a
+ * free `bpmn:label` text grouped with it (R38, `bpmnLabelMode`) — the element
+ * the palette draws. Imported, that is three elements where the file wrote
+ * one: the node (no `text`), the label, and a native `group` holding the two.
+ * The label and the group are Labre's and no file ever named them, so they
+ * carry no `interchange` payload, and the group cannot point at its children
+ * by a source id. The three therefore carry a PROVISIONAL `id`
+ * (`bpmn-import-<n>`, UML's arrangement): `surface.addElement` overwrites it,
+ * and `materializeInterchangeImport` rewrites the group's `children` through
+ * it. The group is written LAST, after what it holds. An export reads the name
+ * back through the group (`bpmnBoardFrom`), which is what closes the round
+ * trip. An unnamed event stays a bare node: no label is invented.
  *
  * ## Three states, and no fourth
  *
@@ -269,16 +284,6 @@ export const BPMN_KIND_OF_XML = new Map(Object.entries(BPMN_XML_OF_KIND).map(([k
     xmlKindKey(mapping.element, mapping.eventDefinition),
     kind,
 ]));
-/**
- * `.bpmn`'s scope vocabulary — where a carried fragment came off (D2, as
- * amended in #157), and where the writer puts it back.
- *
- * Declared in `export.ts` and re-exported here, for the reason
- * {@link BPMN_FORMAT_ID} is: the reader files a fragment under a scope and the
- * writer looks it up under one, and a table written twice is a table that
- * drifts. See its doc comment there for what a scope means.
- */
-export { BPMN_SCOPE };
 /**
  * The three edge elements, and the role each one IS.
  *
@@ -671,9 +676,14 @@ function boundOf(draft) {
  * did not.
  */
 function layOutTheUndrawn(drafts, minted) {
+    // A label counts as placed when its node was: it hangs under a box the file
+    // drew, and the sweep must not land something on top of it. A group has no
+    // box of its own, and an edge is routed between its ends.
     const placed = drafts.filter(draft => draft.needsLayout === undefined &&
+        draft.follows?.needsLayout === undefined &&
         draft !== minted &&
-        draft.kind !== 'edge');
+        draft.kind !== 'edge' &&
+        draft.kind !== 'group');
     const boxes = placed.map(boundOf);
     const maxX = boxes.length > 0 ? Math.max(...boxes.map(box => box.x + box.w)) : 0;
     const minY = boxes.length > 0 ? Math.min(...boxes.map(box => box.y)) : 0;
@@ -686,14 +696,25 @@ function layOutTheUndrawn(drafts, minted) {
         seat++;
         draft.props.xywh = new Bound(maxX + SWEEP_GAP + column * SWEEP_STEP, minY + row * SWEEP_STEP, draft.needsLayout.w, draft.needsLayout.h).serialize();
     }
+    // A label follows its node AFTER the sweep, so a swept event keeps its name
+    // under it rather than at the origin it was drafted at.
+    for (const draft of drafts) {
+        if (!draft.follows?.needsLayout)
+            continue;
+        const node = boundOf(draft.follows);
+        const { x, y } = bpmnLabelBoxUnder(node.x + node.w / 2, node.y + node.h);
+        const label = boundOf(draft);
+        draft.props.xywh = new Bound(x, y, label.w, label.h).serialize();
+    }
     // The pool minted for a file that had no participant (D6) is sized LAST, to
     // hold everything: a pool's plot is what decides which artefacts are in it,
     // and an artefact drawn outside every plot would be exported back into a
-    // process of its own.
+    // process of its own. The labels are inside too, or a name would hang below
+    // the frame of the process it names.
     if (!minted)
         return;
     const inside = drafts
-        .filter(draft => draft !== minted && draft.kind === 'node')
+        .filter(draft => draft !== minted && (draft.kind === 'node' || draft.kind === 'label'))
         .map(boundOf);
     if (inside.length === 0)
         return;
@@ -726,6 +747,9 @@ export function importBpmnXml(source, context = {}) {
     let quarantined = 0;
     let explicitRoutes = 0;
     const drafts = [];
+    /** The provisional names a gravitating label's group is wired by. */
+    let provisional = 0;
+    const mint = () => `bpmn-import-${++provisional}`;
     const seenSourceIds = new Set();
     /** Source ids that became an artefact a flow may attach to: pools and nodes. */
     const mappedSourceIds = new Set();
@@ -1287,23 +1311,64 @@ export function importBpmnXml(source, context = {}) {
             carryChild(payload, BPMN_SCOPE.self, child, sourceId);
         }
         const size = NODE_SIZE[kind];
-        drafts.push({
+        const box = bounds
+            ? new Bound(bounds.x, bounds.y, bounds.w, bounds.h)
+            : new Bound(0, 0, size.w, size.h);
+        // An external kind's name is not the shape's to hold (R38): it goes to a
+        // grouped label under the symbol, and the node is drawn bare.
+        const gravitating = text !== '' && bpmnLabelMode(kind) === 'external';
+        const order = shape?.index ?? Number.POSITIVE_INFINITY;
+        const nodeDraft = {
             props: bpmnNodeProps(kind, {
-                xywh: (bounds
-                    ? new Bound(bounds.x, bounds.y, bounds.w, bounds.h)
-                    : new Bound(0, 0, size.w, size.h)).serialize(),
-                text: text || undefined,
-                // The file's own box, which this reader may not rewrite — so the label
-                // is fitted to it rather than painted past it (#184). A shape the file
-                // did not draw is laid out at the pack's own size below, and wants the
-                // pack's own type: no fit, and an element identical to a drawn one.
-                ...(bounds ? { fitLabel: true } : {}),
+                xywh: box.serialize(),
+                ...(gravitating
+                    ? {}
+                    : {
+                        text: text || undefined,
+                        // The file's own box, which this reader may not rewrite — so the
+                        // label is fitted to it rather than painted past it (#184). A
+                        // shape the file did not draw is laid out at the pack's own size
+                        // below, and wants the pack's own type: no fit, and an element
+                        // identical to a drawn one.
+                        ...(bounds ? { fitLabel: true } : {}),
+                    }),
             }),
             payload,
-            order: shape?.index ?? Number.POSITIVE_INFINITY,
+            order,
             kind: 'node',
             ...(bounds ? {} : { needsLayout: size }),
-        });
+        };
+        drafts.push(nodeDraft);
+        if (gravitating) {
+            // ponytail: the label is always placed centred under the symbol, and a
+            // `BPMNLabel`'s own bounds are ignored for placement (they are still
+            // carried verbatim as DI, so the file gets them back). Ceiling: a file
+            // that set its label beside an event lands it under. Upgrade: read the
+            // `dc:Bounds` of the shape's `BPMNLabel` and place the text there.
+            const nodeId = mint();
+            const labelId = mint();
+            nodeDraft.props.id = nodeId;
+            const under = bpmnLabelBoxUnder(box.x + box.w / 2, box.y + box.h);
+            // Same order as the node, pushed after it: the stable sort keeps the
+            // node, then its label, then the group that holds both.
+            drafts.push({
+                props: { ...bpmnLabelProps(text, under.x, under.y), id: labelId },
+                payload: {},
+                order,
+                kind: 'label',
+                follows: nodeDraft,
+            });
+            drafts.push({
+                props: {
+                    type: 'group',
+                    id: mint(),
+                    children: { [nodeId]: true, [labelId]: true },
+                },
+                payload: {},
+                order,
+                kind: 'group',
+            });
+        }
         if (sourceId !== undefined && bounds)
             nodeBounds.set(sourceId, bounds);
         if (!bounds) {
@@ -1621,6 +1686,9 @@ export function importBpmnXml(source, context = {}) {
             : { ...draft.props, interchange: { [BPMN_FORMAT_ID]: payload } };
     });
     const lanes = ordered.reduce((total, draft) => total + (Array.isArray(draft.props.lanes) ? draft.props.lanes.length : 0), 0);
+    // A gravitating label and its group are how a node wears its name, not
+    // artefacts of the file: counting them would report one event as three.
+    const artefacts = ordered.filter(draft => draft.kind !== 'label' && draft.kind !== 'group').length;
     const sourceVersion = sourceVersionOf(definitions);
     return {
         elements,
@@ -1628,7 +1696,7 @@ export function importBpmnXml(source, context = {}) {
             // Everything that became a drawn, editable artefact: the pools, the flow
             // objects, the arrows — and the LANES, which are drawn and editable and
             // are not elements of their own.
-            mapped: ordered.length + lanes,
+            mapped: artefacts + lanes,
             carried,
             quarantined,
             notes,

package/dist/interchange.d.ts

@@ -81,21 +81,16 @@ export declare const BPMN_XML_FORMAT: InterchangeFormat;
  * Connectors are deliberately NOT counted: a neutral arrow states nothing
  * (`docs/adr/0010`), so there is nothing to lose, which is the reason
  * `export.ts` has always dropped one in silence. Neither is a generated legend
- * — see {@link legendMemberIds}.
+ * — see {@link legendMemberIds} — nor a gravitating label and the group that
+ * binds it to its node, which the file DOES carry, as the node's `name` — see
+ * {@link gravitatingLabels}.
  */
 export declare function bpmnBoardFrom(elements: readonly GfxPrimitiveElementModel[]): BpmnExportBoard;
 /**
- * A name a file system will accept, minus the extension.
- *
- * Every character a file system reserves becomes `-`, whitespace runs collapse,
- * and the result is capped: `process` is a better download than one a browser
- * silently refuses.
- *
- * The trailing `[. ]` trim is the Windows tail case and it is not decorative: a
- * board called "Order to cash." would otherwise download as
- * `Order to cash..bpmn`, and Windows strips trailing dots and spaces from a
- * name anyway — so the extension is what would get eaten. Trimmed AFTER the
- * cap, because the cap can create one.
+ * A name a file system will accept, minus the extension: the shared
+ * `safeFilename` with BPMN's fallback — `process` is a better download than
+ * one a browser silently refuses. Held to it by
+ * `safe-filename-parity.unit.spec.ts`.
  */
 export declare function bpmnSafeFilename(raw: string | undefined): string;
 /** `bpmn:bpmn:export` — the registry's first capability. */

package/dist/interchange.js

@@ -1,6 +1,7 @@
 import { interchangeCapabilityId, LEGEND_ROLE, parseSvgSketch, SVG_SKETCH_EXTENSION, SVG_SKETCH_FORMAT_ID, SVG_SKETCH_MIME, } from '@formicoidea/labre-core/blocks/surface';
-import { BpmnNodeElementModel, BpmnPoolElementModel, ConnectorElementModel, } from '@formicoidea/labre-core/model';
+import { BpmnNodeElementModel, BpmnPoolElementModel, ConnectorElementModel, GroupElementModel, TextElementModel, } from '@formicoidea/labre-core/model';
 import { fillPlaceholders } from '@formicoidea/labre-core/shared/services';
+import { safeFilename } from '@formicoidea/labre-core/shared/utils';
 import { BPMN_FORMAT_ID, exportBpmnXmlWithWarnings, } from './export.js';
 import { bpmnPoolOf } from './facts.js';
 import { importBpmnXml } from './import.js';
@@ -86,6 +87,48 @@ function legendMemberIds(elements) {
     }
     return members;
 }
+/**
+ * Every node's gravitating name (R38), and the elements that carried it.
+ *
+ * A native group holding exactly one picked node and exactly one `bpmn:label`
+ * text binds the two: the text is the node's name, whatever the geometry says
+ * (the palette and the importer both write that pair). GROUP membership is the
+ * binding, as it is for Wardley's composites (`labelOfComposite`, `morph.ts`),
+ * because a label dragged aside is still the name and a stray text that
+ * happens to sit under an event is not.
+ *
+ * `consumed` is what the file does carry after all — the bound label, and the
+ * group when it holds nothing but BPMN nodes and their labels — so the
+ * left-out count does not report a name that IS written. An unbound
+ * `bpmn:label` stays counted: its words are in no file.
+ *
+ * Direct children only, read defensively: they came out of a Y.Map.
+ */
+function gravitatingLabels(elements, picked) {
+    const byId = new Map(elements.map(element => [element.id, element]));
+    const labels = new Map();
+    const consumed = new Set();
+    const isLabel = (element) => element instanceof TextElementModel && element.role === BPMN_ROLE.label;
+    for (const group of elements) {
+        if (!(group instanceof GroupElementModel))
+            continue;
+        const ids = group.childIds;
+        if (!Array.isArray(ids))
+            continue;
+        const members = ids.map(id => typeof id === 'string' ? byId.get(id) : undefined);
+        const nodes = members.filter((member) => member !== undefined && picked.has(member.id));
+        const texts = members.filter((member) => isLabel(member));
+        if (nodes.length === 1 && texts.length === 1) {
+            labels.set(nodes[0].id, texts[0].text?.toString() ?? '');
+            consumed.add(texts[0].id);
+        }
+        if (members.length > 0 &&
+            members.every(member => member && (picked.has(member.id) || isLabel(member)))) {
+            consumed.add(group.id);
+        }
+    }
+    return { labels, consumed };
+}
 /**
  * The artefacts the exporter speaks about, picked out of a surface's elements
  * and kept in the order they were given.
@@ -127,7 +170,9 @@ function legendMemberIds(elements) {
  * Connectors are deliberately NOT counted: a neutral arrow states nothing
  * (`docs/adr/0010`), so there is nothing to lose, which is the reason
  * `export.ts` has always dropped one in silence. Neither is a generated legend
- * — see {@link legendMemberIds}.
+ * — see {@link legendMemberIds} — nor a gravitating label and the group that
+ * binds it to its node, which the file DOES carry, as the node's `name` — see
+ * {@link gravitatingLabels}.
  */
 export function bpmnBoardFrom(elements) {
     const pools = [];
@@ -160,32 +205,26 @@ export function bpmnBoardFrom(elements) {
     // audit and the serializer use, so what is reported left out is what the rest
     // of the framework agrees is in there.
     const legend = legendMemberIds(elements);
+    const { labels, consumed } = gravitatingLabels(elements, new Set(nodes.map(node => node.id)));
     const leftOut = roleless.filter(element => !legend.has(element.id) &&
+        !consumed.has(element.id) &&
         bpmnPoolOf(pools, element.elementBound) !== null).length;
-    return { pools, nodes, connectors, ...(leftOut > 0 ? { leftOut } : {}) };
+    return {
+        pools,
+        nodes,
+        connectors,
+        ...(labels.size > 0 ? { labels } : {}),
+        ...(leftOut > 0 ? { leftOut } : {}),
+    };
 }
 /**
- * A name a file system will accept, minus the extension.
- *
- * Every character a file system reserves becomes `-`, whitespace runs collapse,
- * and the result is capped: `process` is a better download than one a browser
- * silently refuses.
- *
- * The trailing `[. ]` trim is the Windows tail case and it is not decorative: a
- * board called "Order to cash." would otherwise download as
- * `Order to cash..bpmn`, and Windows strips trailing dots and spaces from a
- * name anyway — so the extension is what would get eaten. Trimmed AFTER the
- * cap, because the cap can create one.
+ * A name a file system will accept, minus the extension: the shared
+ * `safeFilename` with BPMN's fallback — `process` is a better download than
+ * one a browser silently refuses. Held to it by
+ * `safe-filename-parity.unit.spec.ts`.
  */
 export function bpmnSafeFilename(raw) {
-    const safe = (raw ?? '')
-        .trim()
-        .replaceAll(/[\\/:*?"<>|]/g, '-')
-        .replaceAll(/\s+/g, ' ')
-        .trim()
-        .slice(0, 120)
-        .replace(/[. ]+$/, '');
-    return safe || 'process';
+    return safeFilename(raw, 'process');
 }
 /* ── The capability ───────────────────────────────────────────────────── */
 /**

package/dist/morph.d.ts

@@ -1,5 +1,7 @@
 import { type MorphSpec } from '@formicoidea/labre-core/blocks/surface';
-import { type BpmnNodeKind } from '@formicoidea/labre-core/model';
+import { BpmnNodeElementModel, type BpmnNodeKind } from '@formicoidea/labre-core/model';
+import type { BlockStdScope } from '@formicoidea/labre-core/std';
+import type { GfxPrimitiveElementModel } from '@formicoidea/labre-core/std/gfx';
 /**
  * What a BPMN artefact may BECOME — the declaration behind the "Change type"
  * dropdown on a selected node's contextual toolbar.
@@ -42,6 +44,31 @@ import { type BpmnNodeKind } from '@formicoidea/labre-core/model';
  * `roles.ts` already gives them in the role tree.
  */
 export declare const BPMN_MORPH_FAMILIES: readonly (readonly BpmnNodeKind[])[];
+/**
+ * The BPMN node a selected GROUP is the artefact of — `undefined` when it is
+ * not one.
+ *
+ * An event, a gateway or a data shape is born as a native group of the symbol
+ * and its `bpmn:label` (`createBpmnNode`, R38), so a click selects the GROUP
+ * and the `kind` lives on the node inside it. Mirrors
+ * `wardleyNodeOfComponent`: only a `BpmnNodeElementModel` of an EXTERNAL kind
+ * is a candidate (the label, a connector or an activity somebody grouped in
+ * beside it are not), and TWO candidates is a refusal rather than a first-wins
+ * pick — morphing "it" in a group of two events would mean choosing one by
+ * document order.
+ */
+export declare function bpmnNodeOfComposite(model: GfxPrimitiveElementModel): BpmnNodeElementModel | undefined;
+/**
+ * The name an artefact should carry once it has morphed — or `null` when the
+ * name is the AUTHOR's.
+ *
+ * Exactly one case rewrites: the label still says the SOURCE kind's seed,
+ * English or translated, letter for letter. A "Start event" that became a
+ * timer start and still read "Start event" would contradict its own glyph;
+ * anything typed over the seed is content and survives the morph untouched —
+ * the rule `wardleyMorphedLabel` states, for the same reason.
+ */
+export declare function bpmnMorphedLabel(from: BpmnNodeKind, to: BpmnNodeKind, rawText: string | null | undefined, std?: BlockStdScope): string | null;
 /**
  * BPMN's morph declaration, handed to the generic `morphToolbarConfig`.
  *
@@ -59,3 +86,12 @@ export declare const BPMN_MORPH_FAMILIES: readonly (readonly BpmnNodeKind[])[];
  * the presets on the day one gains a member that styles itself differently.
  */
 export declare const BPMN_MORPH_SPEC: MorphSpec<BpmnNodeKind>;
+/**
+ * The same declaration on the GROUP row: an event, a gateway or a data shape
+ * is a native group of the symbol and its label (R38), and the group is what a
+ * click on one selects. `modelType` is therefore `GroupElementModel`, and
+ * everything that makes that safe is {@link bpmnNodeOfComposite} — the
+ * toolbar's homogeneity test only proves each selected element is A group.
+ * Mirrors `WARDLEY_MORPH_SPEC`.
+ */
+export declare const BPMN_GROUP_MORPH_SPEC: MorphSpec<BpmnNodeKind>;

package/dist/morph.js

@@ -1,8 +1,10 @@
 import { morphLabel, } from '@formicoidea/labre-core/blocks/surface';
-import { BpmnNodeElementModel } from '@formicoidea/labre-core/model';
+import { BpmnNodeElementModel, GroupElementModel, TextElementModel, } from '@formicoidea/labre-core/model';
+import { translateKey } from '@formicoidea/labre-core/shared/services';
 import { bpmnCommandIcons, bpmnCommands } from './commands.js';
+import { bpmnLabelMode, NODE_LABEL, nodeLabelKey } from './consts.js';
 import { bpmnMorphClears, bpmnMorphProps } from './presets.js';
-import { BPMN_ROLE_OF_KIND } from './roles.js';
+import { BPMN_ROLE, BPMN_ROLE_OF_KIND } from './roles.js';
 /**
  * What a BPMN artefact may BECOME — the declaration behind the "Change type"
  * dropdown on a selected node's contextual toolbar.
@@ -88,6 +90,112 @@ function iconOf(kind) {
     const iconKey = NODE_COMMANDS.get(kind)?.iconKey;
     return ((iconKey && bpmnCommandIcons[iconKey]) || bpmnCommandIcons['bpmn.task']);
 }
+/* ── The gravitating label (R38) ───────────────────────────────────────── */
+/**
+ * Every element under a group, however deeply nested — the same walk as
+ * Wardley's `descendants`, so an author who grouped a composite with
+ * something else still has it resolved.
+ */
+function* descendants(group) {
+    for (const child of group.childElements) {
+        yield child;
+        if (child instanceof GroupElementModel)
+            yield* descendants(child);
+    }
+}
+/**
+ * The BPMN node a selected GROUP is the artefact of — `undefined` when it is
+ * not one.
+ *
+ * An event, a gateway or a data shape is born as a native group of the symbol
+ * and its `bpmn:label` (`createBpmnNode`, R38), so a click selects the GROUP
+ * and the `kind` lives on the node inside it. Mirrors
+ * `wardleyNodeOfComponent`: only a `BpmnNodeElementModel` of an EXTERNAL kind
+ * is a candidate (the label, a connector or an activity somebody grouped in
+ * beside it are not), and TWO candidates is a refusal rather than a first-wins
+ * pick — morphing "it" in a group of two events would mean choosing one by
+ * document order.
+ */
+export function bpmnNodeOfComposite(model) {
+    if (!(model instanceof GroupElementModel))
+        return undefined;
+    let found;
+    for (const child of descendants(model)) {
+        if (!(child instanceof BpmnNodeElementModel))
+            continue;
+        if (bpmnLabelMode(child.kind) !== 'external')
+            continue;
+        if (found)
+            return undefined;
+        found = child;
+    }
+    return found;
+}
+/**
+ * The one `bpmn:label` of the composite the selected element belongs to —
+ * the group itself when the group row morphed, the node's group when the node
+ * row did. `undefined` when there is not exactly one.
+ */
+function labelOfComposite(selected) {
+    const group = selected instanceof GroupElementModel
+        ? selected
+        : selected.group instanceof GroupElementModel
+            ? selected.group
+            : undefined;
+    if (!group)
+        return undefined;
+    let found;
+    for (const child of descendants(group)) {
+        if (!(child instanceof TextElementModel))
+            continue;
+        if (child.role !== BPMN_ROLE.label)
+            continue;
+        if (found)
+            return undefined;
+        found = child;
+    }
+    return found;
+}
+/**
+ * The name an artefact should carry once it has morphed — or `null` when the
+ * name is the AUTHOR's.
+ *
+ * Exactly one case rewrites: the label still says the SOURCE kind's seed,
+ * English or translated, letter for letter. A "Start event" that became a
+ * timer start and still read "Start event" would contradict its own glyph;
+ * anything typed over the seed is content and survives the morph untouched —
+ * the rule `wardleyMorphedLabel` states, for the same reason.
+ */
+export function bpmnMorphedLabel(from, to, rawText, std) {
+    const text = (rawText ?? '').trim();
+    const fromSeed = std
+        ? translateKey(std, nodeLabelKey(from), NODE_LABEL[from])
+        : NODE_LABEL[from];
+    if (text !== NODE_LABEL[from] && text !== fromSeed)
+        return null;
+    return std
+        ? translateKey(std, nodeLabelKey(to), NODE_LABEL[to])
+        : NODE_LABEL[to];
+}
+/**
+ * The structural half of a morph on an external kind: rewrite the grouped
+ * label when it is still the source kind's seed. The families never cross
+ * inscribed ⇄ external, so nothing moves in or out of the shape; an inscribed
+ * kind has no grouped label and this does nothing for it.
+ */
+function bpmnMorphLabel(selected, from, to, std) {
+    const label = labelOfComposite(selected);
+    if (!label || label.isLocked())
+        return;
+    const text = label.text.toString().trim();
+    const next = bpmnMorphedLabel(from, to, text, std);
+    if (next === null || next === text)
+        return;
+    label.surface.store.transact(() => {
+        label.text.delete(0, label.text.length);
+        label.text.insert(0, next);
+    });
+}
 /**
  * BPMN's morph declaration, handed to the generic `morphToolbarConfig`.
  *
@@ -112,7 +220,21 @@ export const BPMN_MORPH_SPEC = {
     roleOf: kind => BPMN_ROLE_OF_KIND[kind],
     propsOf: bpmnMorphProps,
     clearOf: bpmnMorphClears,
+    afterMorph: bpmnMorphLabel,
     labelOf,
     iconOf,
     label: morphLabel('com.labre.morph.toolbar.label', 'Change type'),
 };
+/**
+ * The same declaration on the GROUP row: an event, a gateway or a data shape
+ * is a native group of the symbol and its label (R38), and the group is what a
+ * click on one selects. `modelType` is therefore `GroupElementModel`, and
+ * everything that makes that safe is {@link bpmnNodeOfComposite} — the
+ * toolbar's homogeneity test only proves each selected element is A group.
+ * Mirrors `WARDLEY_MORPH_SPEC`.
+ */
+export const BPMN_GROUP_MORPH_SPEC = {
+    ...BPMN_MORPH_SPEC,
+    modelType: GroupElementModel,
+    resolveTarget: bpmnNodeOfComposite,
+};

package/dist/node/node-renderer.d.ts

@@ -1,6 +1,6 @@
 import { type ElementRenderer } from '@formicoidea/labre-core/blocks/surface';
 import { type BpmnNodeElementModel } from '@formicoidea/labre-core/model';
 export declare const bpmnNode: ElementRenderer<BpmnNodeElementModel>;
-export declare const BpmnNodeRendererExtension: import("@formicoidea/labre-core/store").ExtensionType & {
+export declare const BpmnNodeRendererExtension: import("@formicoidea/labre-core/_pkgs/store").ExtensionType & {
     identifier: import("@formicoidea/labre-core/_pkgs/global/di").ServiceIdentifier<ElementRenderer<BpmnNodeElementModel>>;
 };

package/dist/node/node-view.d.ts

@@ -1,12 +1,33 @@
 import { type BpmnNodeElementModel } from '@formicoidea/labre-core/model';
 import { GfxElementModelView } from '@formicoidea/labre-core/std/gfx';
+/**
+ * Whether a double-click on this node opens the shape's own inner-text editor.
+ *
+ * An INSCRIBED kind (activities, annotation, group) wears its name inside the
+ * shape, so the gesture lands there, exactly like a native shape.
+ *
+ * An EXTERNAL kind (events, gateways, data shapes) wears its name as a separate
+ * `bpmn:label` text grouped under it (R38), which is edited by double-clicking
+ * that text — `TextElementView`'s job, not this one's. The symbol itself has
+ * nothing to open, the same answer Wardley's node view gives its circles: an
+ * editor mounted here would write a second, invisible name into a field that
+ * must stay empty. No redirect to the label either: Wardley does not redirect,
+ * and the label is one click away inside the group.
+ *
+ * The one exception is a LEGACY node: an event drawn before R38 may carry inner
+ * text (nothing is migrated, `BPMN_EXTERNAL_LABEL_KINDS`). That text is still
+ * painted, so it must still be editable — hence "already has text" reopens
+ * the editor, and emptying it closes the door behind it.
+ */
+export declare function bpmnNodeEditsInnerText(model: BpmnNodeElementModel): boolean;
 /**
  * View for a BPMN flow-object node. Registering it ensures `gfx.view.get(model)`
  * returns a view (required so move / select / connector interactions work).
  *
- * BPMN nodes are native shapes, so we reuse the shape inner-text editor: a
- * double-click mounts the editable text overlay (`mountShapeTextEditor`),
- * exactly like a native shape (used to label the task).
+ * BPMN nodes are native shapes, so an inscribed kind reuses the shape
+ * inner-text editor: a double-click mounts the editable text overlay
+ * (`mountShapeTextEditor`), exactly like a native shape. Which kinds do is
+ * {@link bpmnNodeEditsInnerText}'s call.
  *
  * Mirrors {@link EdgyNodeView}.
  */

package/dist/node/node-view.js

@@ -1,13 +1,39 @@
 import { mountShapeTextEditor } from '@formicoidea/labre-core/gfx/shape';
 import { ShapeElementModel, } from '@formicoidea/labre-core/model';
 import { GfxElementModelView } from '@formicoidea/labre-core/std/gfx';
+import { bpmnLabelMode } from '../consts.js';
+/**
+ * Whether a double-click on this node opens the shape's own inner-text editor.
+ *
+ * An INSCRIBED kind (activities, annotation, group) wears its name inside the
+ * shape, so the gesture lands there, exactly like a native shape.
+ *
+ * An EXTERNAL kind (events, gateways, data shapes) wears its name as a separate
+ * `bpmn:label` text grouped under it (R38), which is edited by double-clicking
+ * that text — `TextElementView`'s job, not this one's. The symbol itself has
+ * nothing to open, the same answer Wardley's node view gives its circles: an
+ * editor mounted here would write a second, invisible name into a field that
+ * must stay empty. No redirect to the label either: Wardley does not redirect,
+ * and the label is one click away inside the group.
+ *
+ * The one exception is a LEGACY node: an event drawn before R38 may carry inner
+ * text (nothing is migrated, `BPMN_EXTERNAL_LABEL_KINDS`). That text is still
+ * painted, so it must still be editable — hence "already has text" reopens
+ * the editor, and emptying it closes the door behind it.
+ */
+export function bpmnNodeEditsInnerText(model) {
+    if (bpmnLabelMode(model.kind) === 'inscribed')
+        return true;
+    return (model.text?.length ?? 0) > 0;
+}
 /**
  * View for a BPMN flow-object node. Registering it ensures `gfx.view.get(model)`
  * returns a view (required so move / select / connector interactions work).
  *
- * BPMN nodes are native shapes, so we reuse the shape inner-text editor: a
- * double-click mounts the editable text overlay (`mountShapeTextEditor`),
- * exactly like a native shape (used to label the task).
+ * BPMN nodes are native shapes, so an inscribed kind reuses the shape
+ * inner-text editor: a double-click mounts the editable text overlay
+ * (`mountShapeTextEditor`), exactly like a native shape. Which kinds do is
+ * {@link bpmnNodeEditsInnerText}'s call.
  *
  * Mirrors {@link EdgyNodeView}.
  */
@@ -19,7 +45,8 @@ export class BpmnNodeView extends GfxElementModelView {
             const edgeless = this.std.view.getBlock(this.std.store.root.id);
             if (edgeless &&
                 !this.model.isLocked() &&
-                this.model instanceof ShapeElementModel) {
+                this.model instanceof ShapeElementModel &&
+                bpmnNodeEditsInnerText(this.model)) {
                 mountShapeTextEditor(this.model, edgeless);
             }
         });