@formicoidea/labre-framework-bpmn 0.42.0 → 0.45.0

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);
             }
         });

package/dist/presets.d.ts

@@ -67,7 +67,9 @@ export interface BpmnLabelFit {
  *
  * Every value the creation builder writes is calibrated against
  * {@link NODE_SIZE}: an 18-unit font and the shape's native 20-unit horizontal
- * inset are comfortable in a 120-unit task, which is what the palette draws.
+ * inset are comfortable in a 120-unit task — the box the palette drew when
+ * this was written, kept as the activities' fit reference
+ * (`ACTIVITY_FIT_REF`) now that it draws 180×108.
  * A file draws to its author's scale, and bpmn.io's normative sizes — the ones
  * nearly every `.bpmn` in the wild carries — are a 100×80 task and a 36-unit
  * event. In a 100-unit task the native inset leaves 60 units of line, which is
@@ -124,6 +126,35 @@ export declare function bpmnNodeProps(kind: BpmnNodeKind, box: {
 }): Record<string, unknown> & {
     type: string;
 };
+/**
+ * Where an external label's box goes for a symbol centred on `(cx, cy)`:
+ * centred on the symbol's vertical axis, {@link BPMN_LABEL_GAP} under its
+ * bottom edge — the placement BPMN's own cartography uses for an event's, a
+ * gateway's or a data shape's name.
+ *
+ * Reads the kind's canonical size, so the creation gesture and a template scene
+ * agree; an importer that keeps a file's own box passes that box's bottom
+ * through {@link bpmnLabelBoxUnder} instead.
+ */
+export declare function bpmnLabelBoxFor(kind: BpmnNodeKind, cx: number, cy: number): {
+    x: number;
+    y: number;
+};
+/** The label box for a symbol whose vertical axis is `cx` and bottom edge `bottom`. */
+export declare function bpmnLabelBoxUnder(cx: number, bottom: number): {
+    x: number;
+    y: number;
+};
+/**
+ * A gravitating label, as props — a free text element in the pack's own type,
+ * centred, carrying the role that makes it a NAME rather than a note.
+ *
+ * Mirrors `wardleyLabelProps`; one builder so the palette, the scenes and the
+ * importer write the same element.
+ */
+export declare function bpmnLabelProps(text: string, x: number, y: number): Record<string, unknown> & {
+    type: string;
+};
 /**
  * One BPMN pool, as the props `surface.addElement` takes.
  *

package/dist/presets.js

@@ -1,6 +1,6 @@
 import { FontFamily, SHAPE_TEXT_PADDING, SHAPE_TEXT_VERTICAL_PADDING, ShapeStyle, StrokeStyle, TextAlign, TextFitMode, TextVerticalAlign, } from '@formicoidea/labre-core/model';
 import { Bound } from '@formicoidea/labre-core/global/gfx';
-import { CALL_ACTIVITY_WIDTH, END_WIDTH, EVENT_END, EVENT_START, GROUP_RADIUS, GROUP_STROKE, INNER_FONT_SIZE, LABEL_INSET_RATIO, LABEL_MIN_FONT_SIZE, NEUTRAL_STROKE, NODE_FILL, NODE_SIZE, NODE_STROKE_WIDTH, START_WIDTH, TASK_RADIUS, } from './consts.js';
+import { ACTIVITY_FIT_REF, BPMN_LABEL_GAP, BPMN_LABEL_H, BPMN_LABEL_W, CALL_ACTIVITY_WIDTH, END_WIDTH, EVENT_END, EVENT_START, GROUP_RADIUS, GROUP_STROKE, INNER_FONT_SIZE, isBpmnActivityKind, LABEL_FONT_SIZE, LABEL_INSET_RATIO, LABEL_MIN_FONT_SIZE, NEUTRAL_STROKE, NODE_FILL, NODE_SIZE, NODE_STROKE_WIDTH, START_WIDTH, TASK_RADIUS, } from './consts.js';
 import { BPMN_ROLE, BPMN_ROLE_OF_KIND } from './roles.js';
 /** Per-kind native shape + accent presets (style C). */
 export const NODE_PRESETS = {
@@ -141,7 +141,9 @@ const insetOf = (extent, native) => Number.isFinite(extent) && extent > 0
  *
  * Every value the creation builder writes is calibrated against
  * {@link NODE_SIZE}: an 18-unit font and the shape's native 20-unit horizontal
- * inset are comfortable in a 120-unit task, which is what the palette draws.
+ * inset are comfortable in a 120-unit task — the box the palette drew when
+ * this was written, kept as the activities' fit reference
+ * (`ACTIVITY_FIT_REF`) now that it draws 180×108.
  * A file draws to its author's scale, and bpmn.io's normative sizes — the ones
  * nearly every `.bpmn` in the wild carries — are a 100×80 task and a 36-unit
  * event. In a 100-unit task the native inset leaves 60 units of line, which is
@@ -171,7 +173,9 @@ const insetOf = (extent, native) => Number.isFinite(extent) && extent > 0
  * box was never going to hold.
  */
 export function bpmnLabelFit(kind, w, h) {
-    const size = NODE_SIZE[kind];
+    // An activity is fitted against the box its type was calibrated in, not the
+    // box the palette now draws (see `ACTIVITY_FIT_REF`).
+    const size = isBpmnActivityKind(kind) ? ACTIVITY_FIT_REF : NODE_SIZE[kind];
     const scale = Math.min(1, ratioOf(w, size.w), ratioOf(h, size.h));
     return {
         fontSize: Math.max(LABEL_MIN_FONT_SIZE, Math.round(INNER_FONT_SIZE * scale)),
@@ -256,6 +260,43 @@ export function bpmnNodeProps(kind, box) {
         xywh: box.xywh,
     };
 }
+/* ── The gravitating label (R38) ───────────────────────────────────────── */
+/**
+ * Where an external label's box goes for a symbol centred on `(cx, cy)`:
+ * centred on the symbol's vertical axis, {@link BPMN_LABEL_GAP} under its
+ * bottom edge — the placement BPMN's own cartography uses for an event's, a
+ * gateway's or a data shape's name.
+ *
+ * Reads the kind's canonical size, so the creation gesture and a template scene
+ * agree; an importer that keeps a file's own box passes that box's bottom
+ * through {@link bpmnLabelBoxUnder} instead.
+ */
+export function bpmnLabelBoxFor(kind, cx, cy) {
+    return bpmnLabelBoxUnder(cx, cy + NODE_SIZE[kind].h / 2);
+}
+/** The label box for a symbol whose vertical axis is `cx` and bottom edge `bottom`. */
+export function bpmnLabelBoxUnder(cx, bottom) {
+    return { x: cx - BPMN_LABEL_W / 2, y: bottom + BPMN_LABEL_GAP };
+}
+/**
+ * A gravitating label, as props — a free text element in the pack's own type,
+ * centred, carrying the role that makes it a NAME rather than a note.
+ *
+ * Mirrors `wardleyLabelProps`; one builder so the palette, the scenes and the
+ * importer write the same element.
+ */
+export function bpmnLabelProps(text, x, y) {
+    return {
+        type: 'text',
+        text,
+        role: BPMN_ROLE.label,
+        fontFamily: FontFamily.Inter,
+        fontSize: LABEL_FONT_SIZE,
+        color: NEUTRAL_STROKE,
+        textAlign: TextAlign.Center,
+        xywh: new Bound(x, y, BPMN_LABEL_W, BPMN_LABEL_H).serialize(),
+    };
+}
 /**
  * One BPMN pool, as the props `surface.addElement` takes.
  *

package/dist/reading.js

@@ -1,3 +1,4 @@
+import { BPMN_POOL_BACKGROUND } from './background.js';
 import { BPMN_ROLE, BPMN_ROLES } from './roles.js';
 /**
  * What BPMN lets the tool read of an artefact (MF3, the reversed reading).
@@ -35,13 +36,44 @@ import { BPMN_ROLE, BPMN_ROLES } from './roles.js';
  * under the sequence flow's two words would put a sentence in the panel that
  * the notation never said.
  *
- * ## No nature, no phase
+ * ## A name inscribed, or a name beside
+ *
+ * Since R38 (`docs/adr/0029`) an event, a gateway and a data shape carry their
+ * name on a free `bpmn:label` text grouped with them, not as inner text. The
+ * two profiles that read them therefore declare `labelRole`, which the engine
+ * falls back to when the subject's own text is empty — Wardley's reading does
+ * the same. An activity's inscribed name still wins, because own text is read
+ * first; the annotation and the group ARE their text and need no fallback.
+ *
+ * ## No nature; a lane, not a phase
  *
  * BPMN ships no type-3 tag pack: its kinds ARE the roles, and the panel says
  * them on the type line, chain included ("Message start event › Start event ›
- * Event › Flow object"). And a pool's lanes are participants, not zones on a
- * plotted axis, so there is nothing a position could be read against yet.
+ * Event › Flow object").
+ *
+ * A pool's lanes are not an ordered axis, but they ARE where a flow object or a
+ * data shape is drawn: the lane its centre falls in, read in two dimensions (no
+ * `axis`) off the pool's own `lanes` and named by the name the user gave it —
+ * the same lane `bpmnLaneOf` and the audit report. The annotation and the group
+ * are left without a frame: commentary is about the picture, not in a lane, and
+ * §10.4 lets a group cross every lane there is.
+ */
+/**
+ * The pool, read for its lanes. Shared by the two profiles that sit IN a lane,
+ * so a task and the data object beside it are placed by one declaration.
  */
+const BPMN_LANE_FRAME = {
+    backgroundRole: BPMN_ROLE.pool,
+    background: BPMN_POOL_BACKGROUND,
+    label: {
+        labelKey: 'com.labre.bpmn.reading.field.lane',
+        labelFallback: 'Lane',
+    },
+    none: {
+        labelKey: 'com.labre.bpmn.reading.lane.none',
+        labelFallback: 'Not in a lane of a pool.',
+    },
+};
 /**
  * The two words a sequence flow is read with, from the subject's end.
  *
@@ -65,7 +97,10 @@ export const BPMN_READING = {
     framework: 'bpmn',
     roles: BPMN_ROLES,
     appliesTo: BPMN_ROLE.flowObject,
+    // An event's or a gateway's name gravitates (R38): see the module comment.
+    labelRole: BPMN_ROLE.label,
     relation: { edgeRole: BPMN_ROLE.sequenceFlow, sides: SEQUENCE_SIDES },
+    frame: BPMN_LANE_FRAME,
 };
 /**
  * The paperwork: a data object and a data store.
@@ -78,6 +113,9 @@ export const BPMN_DATA_READING = {
     framework: 'bpmn',
     roles: BPMN_ROLES,
     appliesTo: BPMN_ROLE.data,
+    // Both data shapes are named beside the symbol (R38).
+    labelRole: BPMN_ROLE.label,
+    frame: BPMN_LANE_FRAME,
 };
 /** A note on the picture. Readable, so a reader can link it to a record. */
 export const BPMN_ANNOTATION_READING = {

package/dist/roles.d.ts

@@ -51,7 +51,7 @@ import type { RoleDefs, RoleId } from '@formicoidea/labre-core/std/gfx';
  * same promise every role in this library has made (PRD principle 8).
  */
 /** Every role this framework declares. */
-export type BpmnRole = 'flow-object' | 'event' | 'start-event' | 'message-start-event' | 'timer-start-event' | 'end-event' | 'message-end-event' | 'terminate-end-event' | 'activity' | 'task' | 'user-task' | 'service-task' | 'sub-process' | 'call-activity' | 'gateway' | 'gateway-exclusive' | 'parallel-gateway' | 'data' | 'data-object' | 'data-store' | 'text-annotation' | 'group' | 'pool' | 'sequence-flow' | 'message-flow' | 'association';
+export type BpmnRole = 'flow-object' | 'event' | 'start-event' | 'message-start-event' | 'timer-start-event' | 'end-event' | 'message-end-event' | 'terminate-end-event' | 'activity' | 'task' | 'user-task' | 'service-task' | 'sub-process' | 'call-activity' | 'gateway' | 'gateway-exclusive' | 'parallel-gateway' | 'data' | 'data-object' | 'data-store' | 'text-annotation' | 'group' | 'pool' | 'sequence-flow' | 'message-flow' | 'association' | 'label';
 export type BpmnRoleId = `bpmn:${BpmnRole}`;
 /** Role ids, keyed by the `kind` used at the creation sites. */
 export declare const BPMN_ROLE: {
@@ -81,6 +81,7 @@ export declare const BPMN_ROLE: {
     readonly sequenceFlow: "bpmn:sequence-flow";
     readonly messageFlow: "bpmn:message-flow";
     readonly association: "bpmn:association";
+    readonly label: "bpmn:label";
 };
 export declare const BPMN_ROLES: RoleDefs;
 /**

package/dist/roles.js

@@ -40,6 +40,10 @@ export const BPMN_ROLE = {
     sequenceFlow: 'bpmn:sequence-flow',
     messageFlow: 'bpmn:message-flow',
     association: 'bpmn:association',
+    // The gravitating name: a free text grouped under an event, a gateway or a
+    // data shape. Same call as `wardley:label` — the role is the only thing that
+    // tells a name from a free text the author typed beside the process.
+    label: 'bpmn:label',
 };
 const _everyRoleIsMapped = true;
 void _everyRoleIsMapped;
@@ -369,12 +373,31 @@ const FLOW_DEFS = [
         labelFallback: 'Association',
     },
 ];
+/**
+ * The gravitating label (R38): the text element grouped under an event, a
+ * gateway or a data shape, whose words are that artefact's NAME.
+ *
+ * Kind `text`, parent-less: it is not a flow object, not data and not an
+ * artifact, and no rule about the process may fall on the words that name a
+ * step. It exists so the export, the reading panel and the board picker can
+ * tell a name from a free text the author typed beside the process — exactly
+ * what `wardley:label` does for a component.
+ */
+const LABEL_DEFS = [
+    {
+        id: BPMN_ROLE.label,
+        kind: 'text',
+        labelKey: roleKey(BPMN_ROLE.label),
+        labelFallback: 'Label',
+    },
+];
 const DEFS = [
     ...FLOW_OBJECT_DEFS,
     ...DATA_DEFS,
     ...ARTIFACT_DEFS,
     ...POOL_DEFS,
     ...FLOW_DEFS,
+    ...LABEL_DEFS,
 ];
 // Null prototype: this is a lookup table keyed by ids that may one day come
 // from host-supplied packs, so `defs['toString']` must not resolve.

package/dist/rules.d.ts

@@ -147,7 +147,10 @@ import type { EndpointTriplet, ValidationRule } from '@formicoidea/labre-core/bl
  *   not a bound that failed and its sentence never reads like one;
  * - `label-presence` reads the subject's OWN `text`. A framework whose artefacts
  *   are named by a separate element beside them is asking a different question,
- *   and this family cannot answer it. BPMN names its steps in place, so it can.
+ *   and this family cannot answer it. BPMN names its ACTIVITIES in place, so it
+ *   can ask it of them; since R38 its events, gateways and data shapes are
+ *   named by a grouped `bpmn:label` instead, and are not asked (see
+ *   {@link unlabeledStep}).
  */
 /**
  * `eitherMin` was also shipped, and this pack deliberately does not use it.

package/dist/rules.js

@@ -148,7 +148,10 @@ import { BPMN_ROLE, BPMN_ROLES } from './roles.js';
  *   not a bound that failed and its sentence never reads like one;
  * - `label-presence` reads the subject's OWN `text`. A framework whose artefacts
  *   are named by a separate element beside them is asking a different question,
- *   and this family cannot answer it. BPMN names its steps in place, so it can.
+ *   and this family cannot answer it. BPMN names its ACTIVITIES in place, so it
+ *   can ask it of them; since R38 its events, gateways and data shapes are
+ *   named by a grouped `bpmn:label` instead, and are not asked (see
+ *   {@link unlabeledStep}).
  */
 /**
  * `eitherMin` was also shipped, and this pack deliberately does not use it.
@@ -1452,23 +1455,36 @@ const singleBlankStart = {
  * **`audit`**, because an unnamed step is a diagram that is not done rather than
  * a diagram that is wrong, and the panel is where "not done" belongs.
  *
- * Written on `bpmn:flow-object`: an unnamed gateway is worse than an unnamed
- * task, since the whole content of a decision is the question it asks.
- *
- * The `label-presence` family reads the subject's OWN `text`, which is where
- * BPMN puts the name of a step — so this rule can be asked at all.
+ * Written on `bpmn:activity`, and only there. The `label-presence` family
+ * reads the subject's OWN `text`, and since R38 (`docs/adr/0029`) only an
+ * activity keeps its name there: an event, a gateway or a data shape is named
+ * by a free `bpmn:label` text grouped with it, which the family cannot see
+ * (`packages/affine/blocks/surface/src/extensions/validation.ts`, the
+ * label-presence evaluator). Left on `bpmn:flow-object`, the rule would report
+ * every NAMED event and gateway as unnamed.
+ *
+ * Losing them costs little: BPMN practice commonly leaves an event or a
+ * converging gateway unnamed, while an activity is a box whose whole content is
+ * its name — an empty one says nothing at all. The rule id is kept (ids are
+ * forever); it was shipped as "step", and an activity is the step par
+ * excellence.
+ *
+ * ponytail: the ceiling is "a gateway that asks no question is not reported".
+ * The upgrade path is a label-presence mode that also reads the `labelRole`
+ * member of the subject's group, the way `readName` does for the reading
+ * panel — an engine change, not a pack one.
  */
 const unlabeledStep = {
     id: 'bpmn.unlabeled-step',
     framework: 'bpmn',
     family: 'label-presence',
     severity: 'audit',
-    appliesTo: BPMN_ROLE.flowObject,
+    appliesTo: BPMN_ROLE.activity,
     roles: BPMN_ROLES,
     messageKey: 'com.labre.bpmn.validation.unlabeled-step',
     messageFallback: 'This step has no name.',
     suggestionKey: 'com.labre.bpmn.validation.unlabeled-step.suggestion',
-    suggestionFallback: 'Name it in a verb phrase a reader outside the room would understand — "Check the credit limit" rather than "Step 3". An unnamed gateway is worse still: the whole content of a decision is the question it asks.',
+    suggestionFallback: 'Name it in a verb phrase a reader outside the room would understand — "Check the credit limit" rather than "Step 3".',
     version: 1,
     // A name is nowhere required by the specification: an unnamed step is a
     // diagram that is not done, never one that is wrong.

package/dist/templates/index.d.ts

@@ -23,6 +23,18 @@ export declare const SIMPLE_PROCESS_SEED: {
         readonly key: "com.labre.bpmn.example.simple-process.reject";
         readonly fallback: "Reject";
     };
+    readonly requestReceived: {
+        readonly key: "com.labre.bpmn.example.simple-process.request-received";
+        readonly fallback: "Request received";
+    };
+    readonly approved: {
+        readonly key: "com.labre.bpmn.example.simple-process.approved";
+        readonly fallback: "Approved?";
+    };
+    readonly requestHandled: {
+        readonly key: "com.labre.bpmn.example.simple-process.request-handled";
+        readonly fallback: "Request handled";
+    };
 };
 /**
  * The two worked scenes' and the free-standing "Sequence flow" swatch's own
@@ -53,5 +65,13 @@ export declare const MESSAGE_EXCHANGE_SEED: {
         readonly key: "com.labre.bpmn.example.message-exchange.confirm-order";
         readonly fallback: "Confirm order";
     };
+    readonly orderNeeded: {
+        readonly key: "com.labre.bpmn.example.message-exchange.order-needed";
+        readonly fallback: "Order needed";
+    };
+    readonly orderPlaced: {
+        readonly key: "com.labre.bpmn.example.message-exchange.order-placed";
+        readonly fallback: "Order placed";
+    };
 };
 export declare const bpmnTemplateCategory: TemplateCategory;

package/dist/templates/index.js

@@ -1,9 +1,9 @@
-import { makeTemplateSnapshot, surfaceText, templateFromCommand, } from '@formicoidea/labre-core/gfx/template';
+import { makeTemplateSnapshot, surfaceText, surfaceYMap, templateFromCommand, } from '@formicoidea/labre-core/gfx/template';
 import { ConnectorMode, PointStyle, StrokeStyle, } from '@formicoidea/labre-core/model';
 import { translateKey, } from '@formicoidea/labre-core/shared/services';
 import { bpmnCommands } from '../commands.js';
 import { EVENT_END, EVENT_START, GROUP_STROKE, MESSAGE_STROKE, MESSAGE_WIDTH, NEUTRAL_STROKE, NODE_SIZE, POOL_BAND_FILL, POOL_FRAME_COLOR, SEQUENCE_STROKE, SEQUENCE_WIDTH, } from '../consts.js';
-import { bpmnNodeProps, bpmnPoolProps } from '../presets.js';
+import { bpmnLabelBoxFor, bpmnLabelProps, bpmnNodeProps, bpmnPoolProps, } from '../presets.js';
 import { BPMN_ROLE } from '../roles.js';
 /**
  * The seeds the two worked scenes write — declared once so the scene builder
@@ -28,6 +28,22 @@ export const SIMPLE_PROCESS_SEED = {
         key: 'com.labre.bpmn.example.simple-process.reject',
         fallback: 'Reject',
     },
+    // The three names the scene's events and gateway carry since they gravitate
+    // (R38): a worked example names its punctual symbols the way BPMN practice
+    // does — a state for an event, a question for a gateway — rather than
+    // repeating the artefact's kind under it.
+    requestReceived: {
+        key: 'com.labre.bpmn.example.simple-process.request-received',
+        fallback: 'Request received',
+    },
+    approved: {
+        key: 'com.labre.bpmn.example.simple-process.approved',
+        fallback: 'Approved?',
+    },
+    requestHandled: {
+        key: 'com.labre.bpmn.example.simple-process.request-handled',
+        fallback: 'Request handled',
+    },
 };
 /**
  * The two worked scenes' and the free-standing "Sequence flow" swatch's own
@@ -67,6 +83,15 @@ export const MESSAGE_EXCHANGE_SEED = {
         key: 'com.labre.bpmn.example.message-exchange.confirm-order',
         fallback: 'Confirm order',
     },
+    // The customer's two events, named since they gravitate (R38).
+    orderNeeded: {
+        key: 'com.labre.bpmn.example.message-exchange.order-needed',
+        fallback: 'Order needed',
+    },
+    orderPlaced: {
+        key: 'com.labre.bpmn.example.message-exchange.order-placed',
+        fallback: 'Order placed',
+    },
 };
 /**
  * One seed's resolved text — the host's catalogue when `std` is a real
@@ -121,6 +146,30 @@ function node(kind, x, y, text) {
         ...(text === undefined ? {} : { text: surfaceText(text) }),
     });
 }
+/**
+ * A scene node whose name GRAVITATES (R38, `bpmnLabelMode`): the symbol with no
+ * inner text, its label centred under it, and the native group that binds the
+ * two — the three elements `createBpmnNode` draws for the same kind, and the
+ * pattern Wardley's shipped maps use (`pair()` in `gfx/wardley`).
+ *
+ * Spread into a scene: `<id>` is the symbol, so connectors keep binding to it,
+ * `<id>Label` its name and `<id>Group` the pair.
+ */
+function named(id, kind, x, y, text) {
+    const { w, h } = NODE_SIZE[kind];
+    const at = bpmnLabelBoxFor(kind, x + w / 2, y + h / 2);
+    const label = `${id}Label`;
+    return {
+        [id]: node(kind, x, y),
+        // A snapshot carries a serialized `Y.Text`, where `addElement` takes a
+        // plain string.
+        [label]: { ...bpmnLabelProps(text, at.x, at.y), text: surfaceText(text) },
+        [`${id}Group`]: {
+            type: 'group',
+            children: surfaceYMap({ [id]: true, [label]: true }),
+        },
+    };
+}
 /** A scene participant, from the same description the toolbox draws from. */
 const pool = (x, y, w, h, name) => defined(bpmnPoolProps({ xywh: `[${x},${y},${w},${h}]`, name }));
 /** Drop the keys a preset left undefined — what `addElement` would store. */
@@ -261,15 +310,24 @@ const scene = (name, preview, build, nameKey) => ({
     content: makeTemplateSnapshot(build(), name),
     localize: std => makeTemplateSnapshot(build(std), name),
 });
+/**
+ * Start, a task, an exclusive split into two tasks, and the end they both reach.
+ *
+ * Laid out for the 180×108 activity (R38) on one horizontal axis at y = 160:
+ * the two branches sit 40 units apart with 32 units of margin to the pool's
+ * edges, and every symbol's gravitating label lands inside the pool as well —
+ * `bpmnPoolOf` judges whole containment, and a name hanging out of its
+ * participant would read as belonging to no one.
+ */
 function process(std) {
     return {
-        pool: pool(0, 0, 640, 200, seedText(std, SIMPLE_PROCESS_SEED.poolName)),
-        start: node('startEvent', 40, 72),
-        task1: node('task', 116, 64, seedText(std, SIMPLE_PROCESS_SEED.submitRequest)),
-        gw: node('gatewayExclusive', 272, 64),
-        task2: node('task', 376, 20, seedText(std, SIMPLE_PROCESS_SEED.fulfil)),
-        task3: node('task', 376, 124, seedText(std, SIMPLE_PROCESS_SEED.reject)),
-        end: node('endEvent', 556, 72),
+        pool: pool(0, 0, 840, 320, seedText(std, SIMPLE_PROCESS_SEED.poolName)),
+        ...named('start', 'startEvent', 72, 132, seedText(std, SIMPLE_PROCESS_SEED.requestReceived)),
+        task1: node('task', 168, 106, seedText(std, SIMPLE_PROCESS_SEED.submitRequest)),
+        ...named('gw', 'gatewayExclusive', 388, 124, seedText(std, SIMPLE_PROCESS_SEED.approved)),
+        task2: node('task', 500, 32, seedText(std, SIMPLE_PROCESS_SEED.fulfil)),
+        task3: node('task', 500, 180, seedText(std, SIMPLE_PROCESS_SEED.reject)),
+        ...named('end', 'endEvent', 720, 132, seedText(std, SIMPLE_PROCESS_SEED.requestHandled)),
         c1: seq('start', 'task1'),
         c2: seq('task1', 'gw'),
         c3: seq('gw', 'task2'),
@@ -288,7 +346,9 @@ function process(std) {
  * way to show that — the solid arrow stays home, the dashed one crosses.
  *
  * Stacked vertically with a 40-unit gutter, so the message flow is a straight
- * orthogonal drop between two tasks that already line up.
+ * orthogonal drop between two tasks that already line up. Each 200-high pool
+ * centres its 108-high activity (R38), and the customer's two events keep
+ * their gravitating names inside the pool.
  *
  * ## The end event, which is not decoration
  *
@@ -304,10 +364,10 @@ function messageExchange(std) {
     return {
         customer: pool(0, 0, 640, 200, seedText(std, MESSAGE_EXCHANGE_SEED.customer)),
         supplier: pool(0, 240, 640, 200, seedText(std, MESSAGE_EXCHANGE_SEED.supplier)),
-        start: node('startEvent', 40, 72),
-        ask: node('taskUser', 140, 64, seedText(std, MESSAGE_EXCHANGE_SEED.placeOrder)),
-        done: node('endEvent', 320, 72),
-        answer: node('taskService', 140, 304, seedText(std, MESSAGE_EXCHANGE_SEED.confirmOrder)),
+        ...named('start', 'startEvent', 72, 72, seedText(std, MESSAGE_EXCHANGE_SEED.orderNeeded)),
+        ask: node('taskUser', 168, 46, seedText(std, MESSAGE_EXCHANGE_SEED.placeOrder)),
+        ...named('done', 'endEvent', 388, 72, seedText(std, MESSAGE_EXCHANGE_SEED.orderPlaced)),
+        answer: node('taskService', 168, 286, seedText(std, MESSAGE_EXCHANGE_SEED.confirmOrder)),
         // Inside the first participant: what happens, and in what order.
         inside: seq('start', 'ask'),
         closes: seq('ask', 'done'),

package/dist/toolbar/config.d.ts

@@ -27,7 +27,7 @@ export declare const bpmnPoolToolbarConfig: {
     }, import("@formicoidea/labre-core/shared/services").ToolbarActionGenerator];
     readonly when: (ctx: ToolbarContext) => boolean;
 };
-export declare const bpmnPoolToolbarExtension: import("@formicoidea/labre-core/store/index.js").ExtensionType;
+export declare const bpmnPoolToolbarExtension: import("@formicoidea/labre-core/_pkgs/store/index.js").ExtensionType;
 /**
  * The pool's FLAG-GATED row: the legend and the validation dropdown, in one
  * module because a flavour may carry exactly one (a second on the same key
@@ -47,4 +47,4 @@ export declare const bpmnPoolToolbarExtension: import("@formicoidea/labre-core/s
  * way.
  */
 export declare const bpmnPoolToolingToolbarConfig: ToolbarModuleConfig;
-export declare const bpmnPoolToolingToolbarExtension: import("@formicoidea/labre-core/store/index.js").ExtensionType;
+export declare const bpmnPoolToolingToolbarExtension: import("@formicoidea/labre-core/_pkgs/store/index.js").ExtensionType;

package/dist/toolbar/node-config.d.ts

@@ -0,0 +1,21 @@
+import { type ToolbarContext, type ToolbarModuleConfig } from '@formicoidea/labre-core/shared/services';
+/**
+ * Every selected BPMN node wears its name INSIDE the shape.
+ *
+ * An event, a gateway or a data shape names itself with a grouped `bpmn:label`
+ * text under the symbol (R38), so "Add text" on one would write a second,
+ * inner name the notation never draws there. The gesture exists for the
+ * inscribed kinds only — the same gate `bpmnNodeEditsInnerText` puts on the
+ * double-click, minus the legacy exception: a legacy event's inner text is
+ * already there, and "Add text" only ever shows on a node with none.
+ */
+export declare function bpmnSelectionIsInscribed(ctx: ToolbarContext): boolean;
+export declare const bpmnNodeToolbarConfig: ToolbarModuleConfig;
+/**
+ * The base shape features on a selected BPMN node, on the BARE flavour key.
+ * Registered from the ALWAYS-ON view extension: recolouring or re-typesetting
+ * a stored element is editing content, not tooling (`docs/adr/0009`). The
+ * "Change type" morph, which IS tooling, takes an owner-suffixed key beside
+ * it (`view.ts`).
+ */
+export declare const bpmnNodeToolbarExtension: import("@formicoidea/labre-core/_pkgs/store/index.js").ExtensionType;