@formicoidea/labre-framework-bpmn 0.42.0 → 0.45.0

package/dist/actions.d.ts

@@ -2,7 +2,17 @@ import { type InterchangeReport, type SerializedElementProps } from '@formicoide
 import { type BpmnLane, type BpmnNodeKind, BpmnPoolElementModel } from '@formicoidea/labre-core/model';
 import type { BlockStdScope } from '@formicoidea/labre-core/std';
 import { type BpmnExportBoard } from './export.js';
-/** Create a flow-object node (native shape) centred on the viewport. */
+/**
+ * Create a flow-object node (native shape) centred on the viewport.
+ *
+ * An inscribed kind (activities, annotation, group) carries its name as the
+ * shape's own inner text. An external kind (events, gateways, data shapes)
+ * is born WITHOUT inner text and gets a gravitating label instead: a free
+ * `bpmn:label` text centred under the symbol, grouped with it through the
+ * native group command — exactly Wardley's `createWardleyNode` (R38). The
+ * group is what makes the pair move as one; the role is what tells the name
+ * from a note typed beside the process.
+ */
 export declare function createBpmnNode(std: BlockStdScope, kind: BpmnNodeKind): void;
 /** Create a pool (background container) centred on the viewport. */
 export declare function createBpmnPool(std: BlockStdScope): void;

package/dist/actions.js

@@ -1,14 +1,15 @@
 import { DefaultTool, EdgelessCRUDIdentifier, generateElementId, materializeInterchangeImport, reportInterchangeImport, runInterchangeImportFile, } from '@formicoidea/labre-core/blocks/surface';
 import { ConnectorTool } from '@formicoidea/labre-core/gfx/connector';
+import { createGroupCommand } from '@formicoidea/labre-core/gfx/group';
 import { BpmnPoolElementModel, ConnectorMode, } from '@formicoidea/labre-core/model';
 import { NotificationProvider, 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 { BPMN_EDGE_STYLE, LANE_NAME_FALLBACK, LANE_NAME_KEY, NODE_LABEL, nodeLabelKey, NODE_SIZE, POOL_NAME_FALLBACK, POOL_NAME_KEY, } from './consts.js';
+import { BPMN_EDGE_STYLE, bpmnLabelMode, LANE_NAME_FALLBACK, LANE_NAME_KEY, NODE_LABEL, nodeLabelKey, NODE_SIZE, POOL_NAME_FALLBACK, POOL_NAME_KEY, } from './consts.js';
 import { BPMN_FORMAT_ID, exportBpmnXmlWithWarnings, } from './export.js';
 import { BPMN_SVG_IMPORT, BPMN_XML_EXPORT, BPMN_XML_FORMAT, BPMN_XML_IMPORT, bpmnBoardFrom, bpmnSafeFilename, } from './interchange.js';
-import { bpmnNodeProps, bpmnPoolProps } from './presets.js';
+import { bpmnLabelBoxFor, bpmnLabelProps, bpmnNodeProps, bpmnPoolProps, } from './presets.js';
 import { BPMN_ROLE } from './roles.js';
 /**
  * Standalone creation/activation actions for the BPMN toolbox — lifted out of
@@ -22,7 +23,28 @@ function finish(gfx, id) {
     gfx.selection.set({ elements: [id], editing: false });
     // Keep the palette open (native sub-menu behaviour).
 }
-/** Create a flow-object node (native shape) centred on the viewport. */
+/**
+ * Group elements; returns the group id, or the first id if grouping failed —
+ * the same fallback as Wardley's helper, so a failed group still leaves the
+ * symbol selected rather than nothing.
+ */
+function group(gfx, ids) {
+    const [, result] = gfx.std.command.exec(createGroupCommand, {
+        elements: ids,
+    });
+    return result.groupId || ids[0];
+}
+/**
+ * Create a flow-object node (native shape) centred on the viewport.
+ *
+ * An inscribed kind (activities, annotation, group) carries its name as the
+ * shape's own inner text. An external kind (events, gateways, data shapes)
+ * is born WITHOUT inner text and gets a gravitating label instead: a free
+ * `bpmn:label` text centred under the symbol, grouped with it through the
+ * native group command — exactly Wardley's `createWardleyNode` (R38). The
+ * group is what makes the pair move as one; the role is what tells the name
+ * from a note typed beside the process.
+ */
 export function createBpmnNode(std, kind) {
     const gfx = gfxOf(std);
     const surface = gfx.surface;
@@ -30,6 +52,14 @@ export function createBpmnNode(std, kind) {
         return;
     const { w, h } = NODE_SIZE[kind];
     const { centerX: cx, centerY: cy } = gfx.viewport;
+    // Translated HERE and once: the caption is document content the moment it
+    // lands, so the host's catalogue is asked at placement and never again
+    // (`nodeLabelKey`, and #183 on why a French board should not start in
+    // English).
+    const seed = NODE_LABEL[kind]
+        ? translateKey(std, nodeLabelKey(kind), NODE_LABEL[kind])
+        : undefined;
+    const external = bpmnLabelMode(kind) === 'external';
     // What a node IS lives in one place (`./presets.ts`), because the importer
     // creates the same artefacts out of a `.bpmn` file and the two must not
     // drift: a task read from a file and a task drawn here are one element type
@@ -37,15 +67,15 @@ export function createBpmnNode(std, kind) {
     // nothing else.
     const id = surface.addElement(bpmnNodeProps(kind, {
         xywh: new Bound(cx - w / 2, cy - h / 2, w, h).serialize(),
-        // Translated HERE and once: the caption is document content the moment
-        // it lands, so the host's catalogue is asked at placement and never
-        // again (`nodeLabelKey`, and #183 on why a French board should not
-        // start in English).
-        text: NODE_LABEL[kind]
-            ? translateKey(std, nodeLabelKey(kind), NODE_LABEL[kind])
-            : undefined,
+        text: external ? undefined : seed,
     }));
-    finish(gfx, id);
+    if (!external || seed === undefined) {
+        finish(gfx, id);
+        return;
+    }
+    const { x, y } = bpmnLabelBoxFor(kind, cx, cy);
+    const labelId = surface.addElement(bpmnLabelProps(seed, x, y));
+    finish(gfx, group(gfx, [id, labelId]));
 }
 /** Create a pool (background container) centred on the viewport. */
 export function createBpmnPool(std) {

package/dist/consts.d.ts

@@ -35,8 +35,9 @@ export declare const CALL_ACTIVITY_WIDTH = 4;
 /** Task corner radius (absolute px — a lightly rounded rectangle). */
 export declare const TASK_RADIUS = 10;
 /**
- * The group's corner radius — twice a task's, because it is drawn at three
- * times the size and a 10-unit corner on a 300-unit box reads as a square one.
+ * The group's corner radius — twice a task's, because a group is born the
+ * biggest artefact on the board and a 10-unit corner on a 300-unit box reads
+ * as a square one.
  */
 export declare const GROUP_RADIUS = 20;
 /**
@@ -58,7 +59,8 @@ export declare const INNER_FONT_SIZE = 18;
  *
  * A file draws its artefacts at whatever scale its author's tool uses, and
  * bpmn.io's normative sizes are about six tenths of this pack's: a 36-unit
- * event against a 56-unit one, a 100×72 task against a 120×72. The label of an
+ * event against a 56-unit one, a 100×80 task against the 120×72 activities are
+ * fitted against (`ACTIVITY_FIT_REF`). The label of an
  * imported artefact is therefore asked for at a size proportional to the box
  * the FILE gave, and 10 is where that shrinking stops — under it a label is no
  * longer read, it is guessed at.
@@ -75,19 +77,20 @@ export declare const LABEL_MIN_FONT_SIZE = 10;
  * How much of a box a fitted label gives up to its margin, per side.
  *
  * A shape's native inset is a FIXED 20 units horizontally
- * (`SHAPE_TEXT_PADDING`), which is a sixth of this pack's 120-unit task and
- * therefore invisible on a drawn board — and more than the whole width of a
- * 36-unit event, which leaves NEGATIVE room for the text and is why an imported
- * label breaks in the middle of a word. Expressed as a ratio, the margin
- * follows the artefact down: it is exactly the native inset at the pack's own
- * task width and it never grows past it, so a drawn node is untouched and a
- * small one keeps a usable line.
+ * (`SHAPE_TEXT_PADDING`), which is a sixth of the 120-unit activity width
+ * labels are fitted against (`ACTIVITY_FIT_REF`) and therefore invisible on a
+ * drawn board — and more than the whole width of a 36-unit event, which leaves
+ * NEGATIVE room for the text and is why an imported label breaks in the middle
+ * of a word. Expressed as a ratio, the margin follows the artefact down: it is
+ * exactly the native inset at 120 units and it never grows past it (the cap in
+ * `bpmnLabelFit`), so a drawn node — 180 wide since activities grew — is
+ * untouched and a small one keeps a usable line.
  */
 export declare const LABEL_INSET_RATIO: number;
 /**
  * Default node sizes (model units) per kind.
  *
- * Three sizes carry the whole scale: the 56-unit event, the 120×72 task and the
+ * Three sizes carry the whole scale: the 56-unit event, the 180×108 task and the
  * 72-unit gateway. Everything the descriptive profile adds takes one of them —
  * a message start is a start event, a user task is a task — except the three
  * data/artifact shapes, which have no sibling to inherit from:
@@ -96,32 +99,74 @@ export declare const LABEL_INSET_RATIO: number;
  *    56-unit event without looking like a shrunken task;
  *  - `dataStore` is the event's own diameter, which is what a cylinder needs to
  *    read as one rather than as a squashed ellipse;
- *  - `textAnnotation` is wider than a task and shorter — it holds a sentence,
- *    not a verb phrase.
+ *  - `textAnnotation` is a wide, short strip (140×48) — it holds a sentence,
+ *    not a verb phrase. It was sized against the 120×72 task and kept when the
+ *    activities grew.
  *
  * These three are ~1.2–1.4× bpmn.io's normative pixel sizes, which is the ratio
- * this pack's event and task already sit at against the same reference.
+ * this pack's event sits at against the same reference (the activities sat
+ * there too until they grew 1.5×, see below).
  *
  * `group` is on no scale at all: it is a LASSO, so it has to be born big enough
- * to have something in it. 300×200 holds two tasks and the arrow between them,
- * which is the smallest thing anybody draws a group around.
+ * to have something in it — bigger than any other artefact on both axes. It
+ * was sized for two 120×72 tasks and the arrow between them; since the
+ * activities grew it holds one task with room around it, and the author
+ * stretches it from there.
  */
 export declare const NODE_SIZE: Record<BpmnNodeKind, {
     w: number;
     h: number;
 }>;
 /**
- * Default inner text per kind.
+ * The box an ACTIVITY's inscribed label is fitted against on import
+ * (`bpmnLabelFit`, `presets.ts`) — the 120×72 the drawn task shipped at, kept
+ * as the fit reference when the drawn task grew to 180×108.
  *
- * The activities carry one, because a rectangle with nothing written in it says
- * nothing at all. Events and gateways do not: their meaning is the glyph, and
- * BPMN puts whatever name they have OUTSIDE the symbol.
+ * The fit scales the 18-unit type by how much smaller a file's box is than
+ * "the box this typography is comfortable in". That box did not change when
+ * the palette's did: 18 units were comfortable at 120×72 (that is why the pack
+ * shipped there), so a bpmn.io task of 100×80 still reads at 15 units rather
+ * than falling to the 10-unit floor it would hit against 180×108.
+ */
+export declare const ACTIVITY_FIT_REF: {
+    w: number;
+    h: number;
+};
+/** The five activity kinds — the ones drawn at the 180×108 box. */
+export declare const isBpmnActivityKind: (kind: BpmnNodeKind) => boolean;
+/**
+ * The kinds whose name GRAVITATES: a free text element centred under the
+ * symbol, grouped with it — never the shape's own inner text (R38).
+ *
+ * Events, gateways and the two data shapes are small, punctual symbols: two
+ * five-letter words at 18 units do not fit a 56-unit ring or a 72-unit diamond
+ * without enlarging it, and the glyph is already inside. BPMN itself draws
+ * their name below the symbol, which is what `bpmnLabelBoxFor` places.
+ *
+ * The activities, the annotation and the group stay INSCRIBED: the label fits
+ * (`label-mode.unit.spec.ts` proves it against the rule's arithmetic), and for
+ * the annotation the text IS the artefact.
+ *
+ * A stored node keeps whatever it was born with: an event drawn before this
+ * list existed carries inner text and keeps painting it. Nothing is migrated.
+ */
+export declare const BPMN_EXTERNAL_LABEL_KINDS: readonly ["startEvent", "startEventMessage", "startEventTimer", "endEvent", "endEventMessage", "endEventTerminate", "gatewayExclusive", "gatewayParallel", "dataObject", "dataStore"];
+/** Whether a kind's name is the shape's inner text or a grouped text beside it. */
+export declare const bpmnLabelMode: (kind: BpmnNodeKind) => "inscribed" | "external";
+/** Gravitating-label metrics: a 120-wide, one-line box under the symbol. */
+export declare const LABEL_FONT_SIZE = 18;
+export declare const BPMN_LABEL_W = 120;
+export declare const BPMN_LABEL_H: number;
+/** Gap between the symbol's bottom edge and the label's top. */
+export declare const BPMN_LABEL_GAP = 6;
+/**
+ * Default text per kind — the shape's inner text for an inscribed kind, the
+ * grouped label's text for an external one ({@link bpmnLabelMode}).
  *
- * `dataObject` and `dataStore` are empty for the same reason plus one of our
- * own: the spec puts their name under the shape, the native inner text can only
- * go inside it, and inside is where the folded page and the cylinder already
- * are. The user can still type — the text simply overflows, which is the
- * honest failure rather than a label painted over the glyph.
+ * Every kind carries one, because a symbol whose label is born empty is a text
+ * element nobody can find to click (PO, 24/09/2026 — the Wardley precedent
+ * seeds "Component" for the same reason). The external kinds are seeded with
+ * the spec's own name for the artefact, the wording their role already carries.
  *
  * The caption is asked of the host's catalogue under {@link nodeLabelKey} when
  * the artefact is placed, with the entry below as the English default.
@@ -133,8 +178,8 @@ export declare const NODE_LABEL: Record<BpmnNodeKind, string>;
  * Resolved AT PLACEMENT (`createBpmnNode`) and never afterwards: what a gesture
  * writes into the document is content the author owns from that moment on, and
  * a renderer that re-translated it on every paint would silently overwrite a
- * name somebody typed. The kinds with an empty label ask for nothing — there is
- * no word to translate, and BPMN puts an event's name outside its glyph anyway.
+ * name somebody typed. Every kind has a seed now; for an external kind it is
+ * written into the grouped `bpmn:label` rather than the shape (R38).
  */
 export declare const nodeLabelKey: (kind: BpmnNodeKind) => string;
 /**

package/dist/consts.js

@@ -35,8 +35,9 @@ export const CALL_ACTIVITY_WIDTH = END_WIDTH;
 /** Task corner radius (absolute px — a lightly rounded rectangle). */
 export const TASK_RADIUS = 10;
 /**
- * The group's corner radius — twice a task's, because it is drawn at three
- * times the size and a 10-unit corner on a 300-unit box reads as a square one.
+ * The group's corner radius — twice a task's, because a group is born the
+ * biggest artefact on the board and a 10-unit corner on a 300-unit box reads
+ * as a square one.
  */
 export const GROUP_RADIUS = 20;
 /**
@@ -58,7 +59,8 @@ export const INNER_FONT_SIZE = 18;
  *
  * A file draws its artefacts at whatever scale its author's tool uses, and
  * bpmn.io's normative sizes are about six tenths of this pack's: a 36-unit
- * event against a 56-unit one, a 100×72 task against a 120×72. The label of an
+ * event against a 56-unit one, a 100×80 task against the 120×72 activities are
+ * fitted against (`ACTIVITY_FIT_REF`). The label of an
  * imported artefact is therefore asked for at a size proportional to the box
  * the FILE gave, and 10 is where that shrinking stops — under it a label is no
  * longer read, it is guessed at.
@@ -75,19 +77,20 @@ export const LABEL_MIN_FONT_SIZE = 10;
  * How much of a box a fitted label gives up to its margin, per side.
  *
  * A shape's native inset is a FIXED 20 units horizontally
- * (`SHAPE_TEXT_PADDING`), which is a sixth of this pack's 120-unit task and
- * therefore invisible on a drawn board — and more than the whole width of a
- * 36-unit event, which leaves NEGATIVE room for the text and is why an imported
- * label breaks in the middle of a word. Expressed as a ratio, the margin
- * follows the artefact down: it is exactly the native inset at the pack's own
- * task width and it never grows past it, so a drawn node is untouched and a
- * small one keeps a usable line.
+ * (`SHAPE_TEXT_PADDING`), which is a sixth of the 120-unit activity width
+ * labels are fitted against (`ACTIVITY_FIT_REF`) and therefore invisible on a
+ * drawn board — and more than the whole width of a 36-unit event, which leaves
+ * NEGATIVE room for the text and is why an imported label breaks in the middle
+ * of a word. Expressed as a ratio, the margin follows the artefact down: it is
+ * exactly the native inset at 120 units and it never grows past it (the cap in
+ * `bpmnLabelFit`), so a drawn node — 180 wide since activities grew — is
+ * untouched and a small one keeps a usable line.
  */
 export const LABEL_INSET_RATIO = 1 / 6;
 /**
  * Default node sizes (model units) per kind.
  *
- * Three sizes carry the whole scale: the 56-unit event, the 120×72 task and the
+ * Three sizes carry the whole scale: the 56-unit event, the 180×108 task and the
  * 72-unit gateway. Everything the descriptive profile adds takes one of them —
  * a message start is a start event, a user task is a task — except the three
  * data/artifact shapes, which have no sibling to inherit from:
@@ -96,15 +99,19 @@ export const LABEL_INSET_RATIO = 1 / 6;
  *    56-unit event without looking like a shrunken task;
  *  - `dataStore` is the event's own diameter, which is what a cylinder needs to
  *    read as one rather than as a squashed ellipse;
- *  - `textAnnotation` is wider than a task and shorter — it holds a sentence,
- *    not a verb phrase.
+ *  - `textAnnotation` is a wide, short strip (140×48) — it holds a sentence,
+ *    not a verb phrase. It was sized against the 120×72 task and kept when the
+ *    activities grew.
  *
  * These three are ~1.2–1.4× bpmn.io's normative pixel sizes, which is the ratio
- * this pack's event and task already sit at against the same reference.
+ * this pack's event sits at against the same reference (the activities sat
+ * there too until they grew 1.5×, see below).
  *
  * `group` is on no scale at all: it is a LASSO, so it has to be born big enough
- * to have something in it. 300×200 holds two tasks and the arrow between them,
- * which is the smallest thing anybody draws a group around.
+ * to have something in it — bigger than any other artefact on both axes. It
+ * was sized for two 120×72 tasks and the arrow between them; since the
+ * activities grew it holds one task with room around it, and the author
+ * stretches it from there.
  */
 export const NODE_SIZE = {
     startEvent: { w: 56, h: 56 },
@@ -113,11 +120,14 @@ export const NODE_SIZE = {
     endEvent: { w: 56, h: 56 },
     endEventMessage: { w: 56, h: 56 },
     endEventTerminate: { w: 56, h: 56 },
-    task: { w: 120, h: 72 },
-    taskUser: { w: 120, h: 72 },
-    taskService: { w: 120, h: 72 },
-    subProcess: { w: 120, h: 72 },
-    callActivity: { w: 120, h: 72 },
+    // Activities: 1.5× the 120×72 they shipped at (user feedback, 24/09/2026):
+    // the inscribed label at 18 units needs the room, and the type does not
+    // grow with the box (R38, `docs/add-a-framework/02-framework-rules.md`).
+    task: { w: 180, h: 108 },
+    taskUser: { w: 180, h: 108 },
+    taskService: { w: 180, h: 108 },
+    subProcess: { w: 180, h: 108 },
+    callActivity: { w: 180, h: 108 },
     gatewayExclusive: { w: 72, h: 72 },
     gatewayParallel: { w: 72, h: 72 },
     dataObject: { w: 48, h: 64 },
@@ -126,37 +136,91 @@ export const NODE_SIZE = {
     group: { w: 300, h: 200 },
 };
 /**
- * Default inner text per kind.
+ * The box an ACTIVITY's inscribed label is fitted against on import
+ * (`bpmnLabelFit`, `presets.ts`) — the 120×72 the drawn task shipped at, kept
+ * as the fit reference when the drawn task grew to 180×108.
  *
- * The activities carry one, because a rectangle with nothing written in it says
- * nothing at all. Events and gateways do not: their meaning is the glyph, and
- * BPMN puts whatever name they have OUTSIDE the symbol.
+ * The fit scales the 18-unit type by how much smaller a file's box is than
+ * "the box this typography is comfortable in". That box did not change when
+ * the palette's did: 18 units were comfortable at 120×72 (that is why the pack
+ * shipped there), so a bpmn.io task of 100×80 still reads at 15 units rather
+ * than falling to the 10-unit floor it would hit against 180×108.
+ */
+export const ACTIVITY_FIT_REF = { w: 120, h: 72 };
+const ACTIVITY_KINDS = new Set([
+    'task',
+    'taskUser',
+    'taskService',
+    'subProcess',
+    'callActivity',
+]);
+/** The five activity kinds — the ones drawn at the 180×108 box. */
+export const isBpmnActivityKind = (kind) => ACTIVITY_KINDS.has(kind);
+/**
+ * The kinds whose name GRAVITATES: a free text element centred under the
+ * symbol, grouped with it — never the shape's own inner text (R38).
+ *
+ * Events, gateways and the two data shapes are small, punctual symbols: two
+ * five-letter words at 18 units do not fit a 56-unit ring or a 72-unit diamond
+ * without enlarging it, and the glyph is already inside. BPMN itself draws
+ * their name below the symbol, which is what `bpmnLabelBoxFor` places.
+ *
+ * The activities, the annotation and the group stay INSCRIBED: the label fits
+ * (`label-mode.unit.spec.ts` proves it against the rule's arithmetic), and for
+ * the annotation the text IS the artefact.
+ *
+ * A stored node keeps whatever it was born with: an event drawn before this
+ * list existed carries inner text and keeps painting it. Nothing is migrated.
+ */
+export const BPMN_EXTERNAL_LABEL_KINDS = [
+    'startEvent',
+    'startEventMessage',
+    'startEventTimer',
+    'endEvent',
+    'endEventMessage',
+    'endEventTerminate',
+    'gatewayExclusive',
+    'gatewayParallel',
+    'dataObject',
+    'dataStore',
+];
+const EXTERNAL_LABEL_KINDS = new Set(BPMN_EXTERNAL_LABEL_KINDS);
+/** Whether a kind's name is the shape's inner text or a grouped text beside it. */
+export const bpmnLabelMode = (kind) => EXTERNAL_LABEL_KINDS.has(kind) ? 'external' : 'inscribed';
+/** Gravitating-label metrics: a 120-wide, one-line box under the symbol. */
+export const LABEL_FONT_SIZE = INNER_FONT_SIZE;
+export const BPMN_LABEL_W = 120;
+export const BPMN_LABEL_H = LABEL_FONT_SIZE + 8;
+/** Gap between the symbol's bottom edge and the label's top. */
+export const BPMN_LABEL_GAP = 6;
+/**
+ * Default text per kind — the shape's inner text for an inscribed kind, the
+ * grouped label's text for an external one ({@link bpmnLabelMode}).
  *
- * `dataObject` and `dataStore` are empty for the same reason plus one of our
- * own: the spec puts their name under the shape, the native inner text can only
- * go inside it, and inside is where the folded page and the cylinder already
- * are. The user can still type — the text simply overflows, which is the
- * honest failure rather than a label painted over the glyph.
+ * Every kind carries one, because a symbol whose label is born empty is a text
+ * element nobody can find to click (PO, 24/09/2026 — the Wardley precedent
+ * seeds "Component" for the same reason). The external kinds are seeded with
+ * the spec's own name for the artefact, the wording their role already carries.
  *
  * The caption is asked of the host's catalogue under {@link nodeLabelKey} when
  * the artefact is placed, with the entry below as the English default.
  */
 export const NODE_LABEL = {
-    startEvent: '',
-    startEventMessage: '',
-    startEventTimer: '',
-    endEvent: '',
-    endEventMessage: '',
-    endEventTerminate: '',
+    startEvent: 'Start event',
+    startEventMessage: 'Message start event',
+    startEventTimer: 'Timer start event',
+    endEvent: 'End event',
+    endEventMessage: 'Message end event',
+    endEventTerminate: 'Terminate end event',
     task: 'Task',
     taskUser: 'User task',
     taskService: 'Service task',
     subProcess: 'Sub-process',
     callActivity: 'Call activity',
-    gatewayExclusive: '',
-    gatewayParallel: '',
-    dataObject: '',
-    dataStore: '',
+    gatewayExclusive: 'Exclusive gateway',
+    gatewayParallel: 'Parallel gateway',
+    dataObject: 'Data object',
+    dataStore: 'Data store',
     // The one artefact that IS its text.
     textAnnotation: 'Annotation',
     // The group's label is a CategoryValue in the spec. A plain editable string
@@ -170,8 +234,8 @@ export const NODE_LABEL = {
  * Resolved AT PLACEMENT (`createBpmnNode`) and never afterwards: what a gesture
  * writes into the document is content the author owns from that moment on, and
  * a renderer that re-translated it on every paint would silently overwrite a
- * name somebody typed. The kinds with an empty label ask for nothing — there is
- * no word to translate, and BPMN puts an event's name outside its glyph anyway.
+ * name somebody typed. Every kind has a seed now; for an external kind it is
+ * written into the grouped `bpmn:label` rather than the shape (R38).
  */
 export const nodeLabelKey = (kind) => `com.labre.bpmn.seed.${kind}`;
 /**

package/dist/element-renderer.d.ts

@@ -13,6 +13,6 @@ import type { BpmnPoolElementModel } from '@formicoidea/labre-core/model';
  * drives it directly with a canvas stub.
  */
 export declare const bpmnPool: ElementRenderer<BpmnPoolElementModel>;
-export declare const BpmnPoolRendererExtension: import("@formicoidea/labre-core/store").ExtensionType & {
+export declare const BpmnPoolRendererExtension: import("@formicoidea/labre-core/_pkgs/store").ExtensionType & {
     identifier: import("@formicoidea/labre-core/_pkgs/global/di").ServiceIdentifier<ElementRenderer<BpmnPoolElementModel>>;
 };

package/dist/element-view.js

@@ -301,7 +301,7 @@ export class BpmnPoolView extends GfxElementModelView {
             font: '14px Inter, sans-serif',
             color: 'var(--affine-text-primary-color, #1f2328)',
             background: 'var(--affine-background-overlay-panel-color, #ffffff)',
-            border: '1px solid var(--affine-primary-color, #1e96eb)',
+            border: '1px solid var(--affine-primary-color)',
             borderRadius: '6px',
             boxShadow: 'var(--affine-shadow-2, 0 2px 8px rgba(0,0,0,0.18))',
             outline: 'none',

package/dist/export.d.ts

@@ -217,6 +217,18 @@ export interface BpmnExportBoard {
     pools: readonly BpmnPoolElementModel[];
     nodes: readonly BpmnNodeElementModel[];
     connectors: readonly ConnectorElementModel[];
+    /**
+     * A node's gravitating name, keyed by the node's surface id: the text of the
+     * `bpmn:label` that shares its native group (R38, `bpmnLabelMode`).
+     *
+     * Resolved by whoever picked the board (`bpmnBoardFrom`), because group
+     * membership is a fact about the surface and this writer sees none of it.
+     * GROUP membership is the binding and never geometry: a label dragged away
+     * from its event is still its name, and a text that happens to sit under an
+     * event is not. A node with no entry falls back to its own `text` — every
+     * inscribed kind, and an event drawn before its name gravitated.
+     */
+    labels?: ReadonlyMap<string, string>;
     /**
      * How many things drawn INSIDE a pool the picking left behind because they
      * carry no BPMN role — a free shape, a text, an artefact drawn before roles

package/dist/export.js

@@ -1128,7 +1128,9 @@ export function exportBpmnXmlWithWarnings(board, options = {}) {
             : hasCollaboration && mapping.slot === 'artifact'
                 ? COLLABORATION
                 : orphanProcessIndex();
-        const name = labelOf(model.text);
+        // The grouped label first, then the shape's own text: a legacy event kept
+        // its inner text and must still export the same name.
+        const name = labelOf(board.labels?.get(model.id)) || labelOf(model.text);
         const node = {
             model,
             mapping,

package/dist/import.d.ts

@@ -1,6 +1,5 @@
 import { type InterchangeImportContext, type InterchangeImportResult } from '@formicoidea/labre-core/blocks/surface';
 import type { BpmnNodeKind } from '@formicoidea/labre-core/model';
-import { BPMN_SCOPE } from './export.js';
 /**
  * The remarks whose wording is FIXED, as `[key, English]` pairs — one entry
  * per SHAPE of sentence, never one per exact string: a remark that names
@@ -62,6 +61,16 @@ export declare const BPMN_IMPORT_ERRORS: {
     readonly malformedXml: readonly ["com.labre.bpmn.import.error.malformed-xml", "This file is not well-formed XML, so no BPMN can be read out of it: {{detail}}"];
     readonly notDefinitions: readonly ["com.labre.bpmn.import.error.not-definitions", "A BPMN file opens on <definitions>; this one opens on <{{tag}}>."];
     readonly wrongNamespace: readonly ["com.labre.bpmn.import.error.wrong-namespace", "This <definitions> is in \"{{namespace}}\", not in BPMN 2.0's (\"{{bpmnNamespace}}\"). A DMN decision model and a BPMN process open on the same element name and are not the same file."];
+    /**
+     * Its OWN entry rather than `wrongNamespace` with the words "no namespace"
+     * poured into `{{namespace}}` (#390). That fragment was English prose
+     * substituted into a translated sentence — the one shape a `messageParams`
+     * hole cannot carry, because the reader is pure and has no `std` to resolve
+     * it with. It is also a different FACT, which is what this table is a list
+     * of: a `<definitions>` in the wrong namespace names one, a `<definitions>`
+     * in none names nothing at all.
+     */
+    readonly missingNamespace: readonly ["com.labre.bpmn.import.error.missing-namespace", "This <definitions> declares no namespace, so it does not say it is BPMN 2.0 (\"{{bpmnNamespace}}\"). A DMN decision model and a BPMN process open on the same element name and are not the same file."];
     readonly declinedRootKind: readonly ["com.labre.bpmn.import.error.declined-root-kind", "This file is a BPMN {{kind}}, which Labre does not draw. Only a process or a collaboration can be imported."];
 };
 /**
@@ -81,16 +90,6 @@ export declare const BPMN_IMPORT_ERRORS: {
  * instead of this line assuming it.
  */
 export declare const BPMN_KIND_OF_XML: ReadonlyMap<string, BpmnNodeKind>;
-/**
- * `.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 four reasons a fragment is kept and not written back (D5). Closed. */
 export declare const BPMN_QUARANTINE_REASON: {
     readonly colour: string;