@formicoidea/labre-framework-bpmn 0.41.0 → 0.43.1

package/dist/commands.js

@@ -1,5 +1,25 @@
+import { StrokeStyle } from '@formicoidea/labre-core/model';
 import { activateBpmnAssociation, activateBpmnMessageFlow, activateBpmnSequenceFlow, addBpmnLane, bpmnLanesOf, bpmnPoolsForLaneEdit, bpmnPoolsSelected, createBpmnNode, createBpmnPool, exportBpmnXmlFile, importBpmnSvgFile, importBpmnXmlFile, removeBpmnLane, } from './actions.js';
-import { bpmnAssociationIcon, bpmnCallActivityIcon, bpmnDataObjectIcon, bpmnDataStoreIcon, bpmnEndIcon, bpmnEndMessageIcon, bpmnEndTerminateIcon, bpmnExportXmlIcon, bpmnGatewayIcon, bpmnGatewayParallelIcon, bpmnGroupIcon, bpmnImportSvgIcon, bpmnImportXmlIcon, bpmnLaneAddIcon, bpmnLaneRemoveIcon, bpmnMessageIcon, bpmnPoolIcon, bpmnSequenceIcon, bpmnStartIcon, bpmnStartMessageIcon, bpmnStartTimerIcon, bpmnSubProcessIcon, bpmnTaskIcon, bpmnTaskServiceIcon, bpmnTaskUserIcon, bpmnTextAnnotationIcon, } from './toolbar/icons.js';
+import { BPMN_EDGE_STYLE, NODE_FILL, NODE_SIZE, } from './consts.js';
+import { bpmnNodeProps } from './presets.js';
+import { BPMN_ROLE, BPMN_ROLE_OF_KIND } from './roles.js';
+import { bpmnAssociationIcon, bpmnCallActivityIcon, bpmnDataObjectIcon, bpmnDataStoreIcon, bpmnEndIcon, bpmnEndMessageIcon, bpmnEndTerminateIcon, bpmnExportXmlIcon, bpmnGatewayIcon, bpmnGatewayParallelIcon, bpmnGroupIcon, bpmnImportSvgIcon, bpmnImportXmlIcon, bpmnLaneAddIcon, bpmnLaneRemoveIcon, bpmnMessageIcon, bpmnPoolIcon, bpmnSequenceIcon, bpmnStartIcon, bpmnStartMessageIcon, bpmnStartTimerIcon, bpmnSubProcessIcon, bpmnTaskIcon, bpmnTaskServiceIcon, bpmnTaskUserIcon, bpmnTextAnnotationIcon, bpmnToolbarIcon, } from './toolbar/icons.js';
+/**
+ * What a spec DOES — its own gesture, or the one its {@link Spec.node} implies.
+ *
+ * Total over {@link SPECS} by inspection, and loud rather than silent if it
+ * ever stops being: a spec that drew nothing would be a button that does
+ * nothing, which is worse than a module that refuses to load.
+ */
+function gestureOf(spec) {
+    if (spec.run)
+        return spec.run;
+    const kind = spec.node;
+    if (!kind) {
+        throw new Error(`bpmn: "${spec.id}" declares neither a node kind nor a run`);
+    }
+    return std => createBpmnNode(std, kind);
+}
 /**
  * Declaration order is DISPLAY order, and past the cap it is also the COLD
  * START — which is why it leads with the canonical core rather than with the
@@ -40,7 +60,7 @@ const SPECS = [
         category: 'events',
         senior: true,
         element: 'node:startEvent',
-        run: std => createBpmnNode(std, 'startEvent'),
+        node: 'startEvent',
     },
     {
         id: 'addEndEvent',
@@ -50,7 +70,7 @@ const SPECS = [
         category: 'events',
         senior: true,
         element: 'node:endEvent',
-        run: std => createBpmnNode(std, 'endEvent'),
+        node: 'endEvent',
     },
     {
         id: 'addTask',
@@ -60,7 +80,7 @@ const SPECS = [
         category: 'activities',
         senior: true,
         element: 'node:task',
-        run: std => createBpmnNode(std, 'task'),
+        node: 'task',
     },
     {
         id: 'addExclusiveGateway',
@@ -70,7 +90,7 @@ const SPECS = [
         category: 'gateways',
         senior: true,
         element: 'node:gatewayExclusive',
-        run: std => createBpmnNode(std, 'gatewayExclusive'),
+        node: 'gatewayExclusive',
     },
     {
         id: 'sequenceFlowTool',
@@ -80,6 +100,7 @@ const SPECS = [
         category: 'flows',
         senior: true,
         element: 'connector:sequence',
+        edge: 'sequenceFlow',
         run: activateBpmnSequenceFlow,
     },
     {
@@ -104,6 +125,7 @@ const SPECS = [
         category: 'flows',
         senior: true,
         element: 'connector:message',
+        edge: 'messageFlow',
         run: activateBpmnMessageFlow,
     },
     /* ── Activities: the typed tasks and the two that stand for a process ─ */
@@ -115,7 +137,7 @@ const SPECS = [
         category: 'activities',
         senior: true,
         element: 'node:taskUser',
-        run: std => createBpmnNode(std, 'taskUser'),
+        node: 'taskUser',
     },
     {
         id: 'addServiceTask',
@@ -125,7 +147,7 @@ const SPECS = [
         category: 'activities',
         senior: true,
         element: 'node:taskService',
-        run: std => createBpmnNode(std, 'taskService'),
+        node: 'taskService',
     },
     {
         id: 'addSubProcess',
@@ -135,7 +157,7 @@ const SPECS = [
         category: 'activities',
         senior: true,
         element: 'node:subProcess',
-        run: std => createBpmnNode(std, 'subProcess'),
+        node: 'subProcess',
     },
     {
         id: 'addCallActivity',
@@ -145,7 +167,7 @@ const SPECS = [
         category: 'activities',
         senior: true,
         element: 'node:callActivity',
-        run: std => createBpmnNode(std, 'callActivity'),
+        node: 'callActivity',
     },
     /* ── The other gateway ──────────────────────────────────────────────── */
     {
@@ -159,7 +181,7 @@ const SPECS = [
         category: 'gateways',
         senior: true,
         element: 'node:gatewayParallel',
-        run: std => createBpmnNode(std, 'gatewayParallel'),
+        node: 'gatewayParallel',
     },
     /* ── Event variants: what TRIGGERS a start, what an end does on the way
          out. Refinements of the two plain events above, so they follow them. ─ */
@@ -171,7 +193,7 @@ const SPECS = [
         category: 'events',
         senior: false,
         element: 'node:startEventMessage',
-        run: std => createBpmnNode(std, 'startEventMessage'),
+        node: 'startEventMessage',
     },
     {
         id: 'addTimerStartEvent',
@@ -181,7 +203,7 @@ const SPECS = [
         category: 'events',
         senior: false,
         element: 'node:startEventTimer',
-        run: std => createBpmnNode(std, 'startEventTimer'),
+        node: 'startEventTimer',
     },
     {
         id: 'addMessageEndEvent',
@@ -191,7 +213,7 @@ const SPECS = [
         category: 'events',
         senior: false,
         element: 'node:endEventMessage',
-        run: std => createBpmnNode(std, 'endEventMessage'),
+        node: 'endEventMessage',
     },
     {
         id: 'addTerminateEndEvent',
@@ -201,7 +223,7 @@ const SPECS = [
         category: 'events',
         senior: false,
         element: 'node:endEventTerminate',
-        run: std => createBpmnNode(std, 'endEventTerminate'),
+        node: 'endEventTerminate',
     },
     /* ── The last connecting object ─────────────────────────────────────── */
     {
@@ -212,6 +234,7 @@ const SPECS = [
         category: 'flows',
         senior: false,
         element: 'connector:association',
+        edge: 'association',
         run: activateBpmnAssociation,
     },
     /* ── Data ───────────────────────────────────────────────────────────── */
@@ -223,7 +246,7 @@ const SPECS = [
         category: 'data',
         senior: true,
         element: 'node:dataObject',
-        run: std => createBpmnNode(std, 'dataObject'),
+        node: 'dataObject',
     },
     {
         id: 'addDataStore',
@@ -233,7 +256,7 @@ const SPECS = [
         category: 'data',
         senior: false,
         element: 'node:dataStore',
-        run: std => createBpmnNode(std, 'dataStore'),
+        node: 'dataStore',
     },
     /* ── Artifacts: what an author writes ON the picture ────────────────── */
     {
@@ -244,7 +267,7 @@ const SPECS = [
         category: 'annotations',
         senior: true,
         element: 'node:textAnnotation',
-        run: std => createBpmnNode(std, 'textAnnotation'),
+        node: 'textAnnotation',
     },
     {
         // Filed with the annotation and not in a section of its own: both are
@@ -261,29 +284,160 @@ const SPECS = [
         // senior row is a shortcut to.
         senior: false,
         element: 'node:group',
-        run: std => createBpmnNode(std, 'group'),
+        node: 'group',
     },
 ];
-const toolboxCommands = SPECS.map((spec, order) => ({
-    id: `bpmn.${spec.id}`,
-    owner: 'bpmn',
-    kind: spec.kind,
-    labelKey: `com.labre.commands.bpmn.${spec.id}`,
-    labelFallback: spec.label,
-    category: spec.category,
-    iconKey: spec.iconKey,
-    // The catalogue holds all of them; `senior` decides which fourteen the
-    // sub-menu opens on before this user has reached for anything.
-    surfaces: spec.senior
-        ? ['senior-menu', 'catalogue', 'palette', 'agent']
-        : ['catalogue', 'palette', 'agent'],
-    order,
-    scope: 'edgeless',
-    defaultKeys: { mac: [], other: [] },
-    availability: 'always',
-    run: spec.run,
-    telemetry: { framework: 'bpmn', element: spec.element, board: spec.board },
-}));
+/* ── The legend, subscribed rather than tabulated ──────────────────────── */
+/**
+ * The legend of a pool is not a table: every row below is DERIVED from the
+ * command that draws the artefact, from the same preset the gesture creates it
+ * with, and it is listed only when the pool actually contains one (ADR 0026,
+ * `legendFromCommands`).
+ *
+ * ## The swatch box, and why BPMN asks for a bigger one than UML
+ *
+ * UML tells its figures apart by full-box silhouettes (a stick figure, a
+ * divided box, an ellipse) and is comfortable at 34 × 24. BPMN puts its
+ * distinctions in CORNER MARKERS — the person and the cog are `0.24 × unit` in
+ * the top-left (`node/node-renderer.ts`) — so it needs about 30 % more: at
+ * 44 × 30 a task's marker is ~6 px and a gateway's arms ~6 px, which is the
+ * floor at which they read at all.
+ *
+ * ## The one known visual limit
+ *
+ * The group's dashed lasso uses the renderer's fixed `[12, 12]` dash pattern
+ * (`consts.ts` says why there is no dotted stroke to ask for): across 44 units
+ * that is about two dashes, and down 29 it is none. The row is still
+ * distinguishable from the text annotation — which draws no closed rectangle —
+ * but it does not READ as dotted, and nothing in this file can change that.
+ */
+const SWATCH_W = 44;
+const SWATCH_H = 30;
+const BPMN_LEGEND_BOX = {
+    // No `titleWording`: every board that has a legend says the same generic
+    // "Legend", which is what the platform falls back to (`BOARD_LEGEND_TITLE`).
+    width: 300,
+    rowHeight: 36,
+    swatchWidth: SWATCH_W,
+    swatchHeight: SWATCH_H,
+};
+/**
+ * The three roles whose row must match EXACTLY, and no others.
+ *
+ * `bpmn:start-event`, `bpmn:end-event` and `bpmn:task` are the three roles with
+ * a row that also have children (`roles.ts`). Without `exact`, a pool holding
+ * only a message start event would light the plain "Start event" row too — a
+ * bare circle nobody drew. The families that have no row at all
+ * (`bpmn:event`, `bpmn:activity`, `bpmn:gateway`, `bpmn:data`,
+ * `bpmn:flow-object`) need no such care: they are never stamped.
+ */
+const EXACT_ROLES = new Set([
+    BPMN_ROLE.startEvent,
+    BPMN_ROLE.endEvent,
+    BPMN_ROLE.task,
+]);
+/**
+ * A glyph row: the artefact itself, painted at swatch size by the very renderer
+ * that paints it on the board — the creation preset minus three keys.
+ *
+ *  - `role`, because the legend is drawn IN the pool it documents and the scan
+ *    detects by role: a swatch carrying one would list itself the next time,
+ *    and all 21 validation rules would count it (`rules.ts`);
+ *  - `xywh`, because the box belongs to the layout, which fits {@link
+ *    CommandLegendRow.aspect} inside the swatch column;
+ *  - `text`, because `bpmnNodeProps` writes the artefact's default caption at
+ *    18 px with `TextFitMode.Overflow`: a "Task" that size would spill across
+ *    the whole box. Without it `fontSize` / `textAlign` / `textFitMode` are
+ *    inert, so there is no reason to strip those too.
+ *
+ * `radius` is the one prop SCALED to the swatch, and it has to be: it is an
+ * absolute, unbounded value (`drawRect` calls `arcTo` with it), so the group's
+ * 20 and the task's 10 would both round a 44 × 30 box into a pill.
+ * `strokeWidth` is deliberately NOT scaled — the thin ring against the thick
+ * one, and the call activity's heavy border against the sub-process's, IS the
+ * notation, and at 30 units the 2-against-4 ratio reads better than at 56.
+ */
+function nodeRow(kind) {
+    const { role: _role, xywh: _xywh, text: _text, ...props } = bpmnNodeProps(kind, { xywh: '[0,0,0,0]' });
+    const size = NODE_SIZE[kind];
+    return {
+        swatch: 'glyph',
+        // Read by nothing for a glyph row — the element carries its own fill and
+        // stroke — and written all the same, because `CommandLegendRow` asks for a
+        // colour and the paper is the honest answer. UML does the same.
+        color: NODE_FILL,
+        props: {
+            ...props,
+            radius: Math.round((Number(props.radius) || 0) * (SWATCH_H / size.h)),
+        },
+        aspect: size.h > 0 ? size.w / size.h : 1,
+    };
+}
+/**
+ * An edge row: the line the tool actually arms, endpoints and all, drawn by the
+ * connector renderer at swatch width rather than approximated by a bar.
+ *
+ * `dashed` is kept beside the props although the connector carries its own
+ * `strokeStyle`: it is the one fact about an edge row a pure test can read
+ * without a renderer, and it is DERIVED from the same table, so the two can
+ * never disagree.
+ */
+function edgeRow(key) {
+    const style = BPMN_EDGE_STYLE[key];
+    return {
+        swatch: 'edge',
+        color: style.stroke,
+        dashed: style.strokeStyle === StrokeStyle.Dash,
+        props: { ...style },
+    };
+}
+/**
+ * The row a spec subscribes, or none.
+ *
+ * The pool subscribes nothing on purpose: it is the SHEET the legend is drawn
+ * on, and listing it would be listing the paper — the same call C4's board and
+ * UML's frame make about themselves.
+ */
+function legendOf(spec) {
+    if (spec.edge) {
+        return { role: BPMN_ROLE[spec.edge], row: edgeRow(spec.edge) };
+    }
+    if (!spec.node)
+        return undefined;
+    const role = BPMN_ROLE_OF_KIND[spec.node];
+    return {
+        role,
+        row: nodeRow(spec.node),
+        ...(EXACT_ROLES.has(role) ? { exact: true } : {}),
+    };
+}
+const toolboxCommands = SPECS.map((spec, order) => {
+    const legend = legendOf(spec);
+    return {
+        id: `bpmn.${spec.id}`,
+        owner: 'bpmn',
+        kind: spec.kind,
+        labelKey: `com.labre.commands.bpmn.${spec.id}`,
+        labelFallback: spec.label,
+        category: spec.category,
+        iconKey: spec.iconKey,
+        // The catalogue holds all of them; `senior` decides which fourteen the
+        // sub-menu opens on before this user has reached for anything.
+        surfaces: spec.senior
+            ? ['senior-menu', 'catalogue', 'palette', 'agent']
+            : ['catalogue', 'palette', 'agent'],
+        order,
+        scope: 'edgeless',
+        defaultKeys: { mac: [], other: [] },
+        availability: 'always',
+        run: gestureOf(spec),
+        telemetry: { framework: 'bpmn', element: spec.element, board: spec.board },
+        ...(legend ? { legend } : {}),
+        // The board carries the BOX the rows are laid out in, and only the board:
+        // exactly one command per framework may declare it.
+        ...(spec.board ? { legendBox: BPMN_LEGEND_BOX } : {}),
+    };
+});
 /**
  * The LANE commands (B4) — the first BPMN entries that are not a toolbox slot.
  *
@@ -379,7 +533,12 @@ const exportCommand = {
     labelKey: 'com.labre.commands.bpmn.exportXml',
     labelFallback: 'Export BPMN XML',
     descriptionKey: 'com.labre.commands.bpmn.exportXml.description',
-    descriptionFallback: 'Download the whole board as a BPMN 2.0 XML file, ready to open in any BPMN tool.',
+    // The second sentence is the PO's ruling of 2026-09-17 said BEFORE the click
+    // rather than after it: only artefacts carrying a BPMN role are written, and
+    // the board's generic SVG export (ADR 0025, R34) is what takes the drawing.
+    // The export also SAYS what it left out, once, in its own report — but a
+    // promise a command makes in the catalogue is cheaper than a surprise.
+    descriptionFallback: 'Download the whole board as a BPMN 2.0 XML file, ready to open in any BPMN tool. Only BPMN artefacts are written; export SVG to get everything drawn in the pool.',
     // Filed with the import it is the other half of — see {@link INTERCHANGE}.
     // It shipped filed under `swimlanes`, because the pool's "⋮" is where it is
     // REACHED from and there was no better section for a command with no sibling;
@@ -565,4 +724,7 @@ export const bpmnCommandIcons = {
     'bpmn.export-xml': bpmnExportXmlIcon,
     'bpmn.import-xml': bpmnImportXmlIcon,
     'bpmn.import-svg': bpmnImportSvgIcon,
+    // The senior button's 56×56 glyph, so `FrameworkDescriptor.iconKey` resolves
+    // through `getCommandIcon`.
+    'bpmn.toolbar': bpmnToolbarIcon,
 };

package/dist/consts.d.ts

@@ -1,4 +1,5 @@
 import type { BpmnNodeKind } from '@formicoidea/labre-core/model';
+import { PointStyle, StrokeStyle } from '@formicoidea/labre-core/model';
 /**
  * Visual constants for the BPMN basics. Style "C" (hybrid): spec-accurate
  * shapes and line weights, with accent colour only on the event rings — the
@@ -23,8 +24,9 @@ export declare const START_WIDTH = 2;
 export declare const END_WIDTH = 4;
 export declare const NODE_STROKE_WIDTH = 2;
 /**
- * The call activity's border, which the spec draws THICK — it is the one way to
- * tell it from the sub-process, since both carry the same `+` marker. Same
+ * The call activity's border, which the spec draws THICK — and here it is the
+ * ONLY way to tell it from the sub-process, since Labre draws neither of them
+ * with the notation's collapsed `+` (`node/node-renderer.ts`). Same
  * weight as the end-event ring, and for the same reason: this is the heaviest
  * line the notation uses, and it is spent on "this one stands for a whole
  * process defined somewhere else".
@@ -260,3 +262,33 @@ export declare const MESSAGE_WIDTH = 2;
  */
 export declare const ASSOCIATION_STROKE: string;
 export declare const ASSOCIATION_WIDTH = 2;
+/** The three connecting objects, keyed the way {@link BPMN_EDGE_STYLE} is. */
+export type BpmnEdgeKey = 'sequenceFlow' | 'messageFlow' | 'association';
+/**
+ * What a BPMN connecting object LOOKS like — the five props, and never a sixth.
+ *
+ * `mode` is deliberately absent. The toolbox arms the connector tool
+ * orthogonally, but that is a property of the DRAWING gesture, not of the line:
+ * a legend swatch draws the same notation across 44 units in a straight
+ * segment, and an orthogonal mode there would put a right angle in a sample
+ * that has nothing to route around.
+ */
+export interface BpmnEdgeStyle {
+    stroke: string;
+    strokeStyle: StrokeStyle;
+    strokeWidth: number;
+    frontEndpointStyle: PointStyle;
+    rearEndpointStyle: PointStyle;
+}
+/**
+ * The whole BPMN line notation, in one table — read by the tool that ARMS the
+ * connector (`actions.ts`) and by the legend row that PICTURES it
+ * (`commands.ts`).
+ *
+ * One table for the same reason `presets.ts` is one builder for the nodes: two
+ * spellings of the same line agree the day they are written and drift on the
+ * first restyle, and the drift shows up as a legend that documents a notation
+ * the board does not use. Same argument, and the same shape, as UML's
+ * `UML_EDGE_STYLE`.
+ */
+export declare const BPMN_EDGE_STYLE: Record<BpmnEdgeKey, BpmnEdgeStyle>;

package/dist/consts.js

@@ -1,3 +1,4 @@
+import { PointStyle, StrokeStyle } from '@formicoidea/labre-core/model';
 import { NOTATION_NEUTRALS } from '@formicoidea/labre-core/shared/consts';
 /**
  * Visual constants for the BPMN basics. Style "C" (hybrid): spec-accurate
@@ -23,8 +24,9 @@ export const START_WIDTH = 2;
 export const END_WIDTH = 4;
 export const NODE_STROKE_WIDTH = 2;
 /**
- * The call activity's border, which the spec draws THICK — it is the one way to
- * tell it from the sub-process, since both carry the same `+` marker. Same
+ * The call activity's border, which the spec draws THICK — and here it is the
+ * ONLY way to tell it from the sub-process, since Labre draws neither of them
+ * with the notation's collapsed `+` (`node/node-renderer.ts`). Same
  * weight as the end-event ring, and for the same reason: this is the heaviest
  * line the notation uses, and it is spent on "this one stands for a whole
  * process defined somewhere else".
@@ -302,3 +304,37 @@ export const MESSAGE_WIDTH = 2;
  */
 export const ASSOCIATION_STROKE = NOTATION_NEUTRALS.ink;
 export const ASSOCIATION_WIDTH = 2;
+/**
+ * The whole BPMN line notation, in one table — read by the tool that ARMS the
+ * connector (`actions.ts`) and by the legend row that PICTURES it
+ * (`commands.ts`).
+ *
+ * One table for the same reason `presets.ts` is one builder for the nodes: two
+ * spellings of the same line agree the day they are written and drift on the
+ * first restyle, and the drift shows up as a legend that documents a notation
+ * the board does not use. Same argument, and the same shape, as UML's
+ * `UML_EDGE_STYLE`.
+ */
+export const BPMN_EDGE_STYLE = {
+    sequenceFlow: {
+        stroke: SEQUENCE_STROKE,
+        strokeStyle: StrokeStyle.Solid,
+        strokeWidth: SEQUENCE_WIDTH,
+        frontEndpointStyle: PointStyle.None,
+        rearEndpointStyle: PointStyle.Triangle,
+    },
+    messageFlow: {
+        stroke: MESSAGE_STROKE,
+        strokeStyle: StrokeStyle.Dash,
+        strokeWidth: MESSAGE_WIDTH,
+        frontEndpointStyle: PointStyle.Circle,
+        rearEndpointStyle: PointStyle.Arrow,
+    },
+    association: {
+        stroke: ASSOCIATION_STROKE,
+        strokeStyle: StrokeStyle.Dash,
+        strokeWidth: ASSOCIATION_WIDTH,
+        frontEndpointStyle: PointStyle.None,
+        rearEndpointStyle: PointStyle.None,
+    },
+};

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[];
+    /**
+     * 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
+     * existed (2026-08-26).
+     *
+     * Counted by whoever picked the board (`bpmnBoardFrom`), because that is the
+     * only place that ever sees what was NOT picked. The behaviour is the PO's
+     * ruling of 2026-09-17 and does not change: a `.bpmn` carries the author's
+     * statements, and the board's generic SVG export (ADR 0025, R34) carries the
+     * drawing. What was missing was SAYING so, which is what this number buys.
+     */
+    leftOut?: number;
 }
 export interface BpmnExportOptions {
     /** Names the `collaboration` / lone `process` and the `BPMNDiagram`. */
@@ -237,7 +249,7 @@ export interface BpmnExportWarning {
     /** Values for the fallback's placeholders — a count, a list of names. */
     params?: Record<string, string | number>;
 }
-/** All nine, for `translations.ts`'s manifest contribution. */
+/** All ten, for `translations.ts`'s manifest contribution. */
 export declare const BPMN_EXPORT_WARNING_KEYS: readonly (readonly [string, string])[];
 /**
  * The document, plus what writing it could not say.

package/dist/export.js

@@ -764,7 +764,7 @@ class IdMinter {
     }
 }
 /**
- * The nine export-warning keys, each paired with its English fallback
+ * The ten export-warning keys, each paired with its English fallback
  * (`{{name}}` placeholders included) — declared ONCE, here, and read both by
  * the `if` blocks below (which add the live `params`) and by
  * `translations.ts`'s manifest (which needs the pair with no board to run
@@ -812,7 +812,11 @@ const UNWRITABLE_EDGES_WARNING = [
     'com.labre.bpmn.export.warning.unwritable-edges',
     '{{count}} arrow(s) were left out: BPMN requires both ends of a flow to be named, and they have an end that is loose or attached to something that is not a BPMN artefact.',
 ];
-/** All nine, for `translations.ts`'s manifest contribution. */
+const LEFT_OUT_WARNING = [
+    'com.labre.bpmn.export.warning.left-out',
+    '{{count}} element(s) inside the pool are not BPMN elements and were left out of the .bpmn file. Export SVG to get everything drawn in the pool.',
+];
+/** All ten, for `translations.ts`'s manifest contribution. */
 export const BPMN_EXPORT_WARNING_KEYS = [
     UNDRAWN_ARTEFACTS_WARNING,
     DROPPED_MESSAGE_FLOWS_WARNING,
@@ -823,6 +827,7 @@ export const BPMN_EXPORT_WARNING_KEYS = [
     CONFLICTING_IDS_WARNING,
     REFUSED_ATTRIBUTE_NAMES_WARNING,
     UNWRITABLE_EDGES_WARNING,
+    LEFT_OUT_WARNING,
 ];
 /* ── The plan ─────────────────────────────────────────────────────────── */
 /**
@@ -1425,9 +1430,11 @@ export function exportBpmnXmlWithWarnings(board, options = {}) {
             id: minter.mint('Shape', node.id),
             bpmnElement: node.id,
         };
-        // The pack draws the COLLAPSED sub-process only — a task-sized box with a
-        // `+` — and `isExpanded="false"` is how DI says exactly that. Without it a
-        // tool is free to draw an expanded container the author never made.
+        // The pack draws the COLLAPSED sub-process only — a task-sized box, with
+        // no body folded open inside it — and `isExpanded="false"` is how DI says
+        // exactly that. Without it a tool is free to draw an expanded container the
+        // author never made. (Labre leaves the `+` marker itself off the box, which
+        // is a drawing choice and says nothing about the DI flag.)
         if (node.model.kind === 'subProcess' ||
             node.model.kind === 'callActivity') {
             attrs.isExpanded = 'false';
@@ -1621,6 +1628,13 @@ export function exportBpmnXmlWithWarnings(board, options = {}) {
         const [key, fallback] = UNWRITABLE_EDGES_WARNING;
         warnings.push({ key, fallback, params: { count: unwritableEdges } });
     }
+    // What the PICKING left behind (see {@link BpmnExportBoard.leftOut}). One
+    // line for the whole pool, because the point is not which shape it was: it is
+    // that the file is the process and the SVG is the picture.
+    if (board.leftOut !== undefined && board.leftOut > 0) {
+        const [key, fallback] = LEFT_OUT_WARNING;
+        warnings.push({ key, fallback, params: { count: board.leftOut } });
+    }
     return {
         text: `<?xml version="1.0" encoding="UTF-8"?>\n${serializeElement(definitions, '')}\n`,
         warnings,

package/dist/import.d.ts

@@ -62,6 +62,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."];
 };
 /**

package/dist/import.js

@@ -120,6 +120,19 @@ export const BPMN_IMPORT_ERRORS = {
         '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.
+     */
+    missingNamespace: [
+        '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.',
+    ],
     declinedRootKind: [
         '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.',
@@ -469,7 +482,19 @@ function parseDefinitions(source) {
     // Without this a `.dmn` imports as an empty board, which is exactly the
     // "three zeroes claiming an empty process" this reader refuses to return.
     if (root.namespaceURI !== BPMN_NS.model) {
-        const namespace = root.namespaceURI ?? 'no namespace';
+        // Two facts, two refusals: a namespace this reader can quote back, and no
+        // namespace at all. The second used to borrow the first's sentence with
+        // the English words "no namespace" poured into its `{{namespace}}` hole,
+        // which put a fragment of English inside a translated sentence (#390).
+        const namespace = root.namespaceURI;
+        if (namespace === null) {
+            throw new InterchangeImportError(`This <definitions> declares no namespace, so it does not say it is ` +
+                `BPMN 2.0 ("${BPMN_NS.model}"). A DMN decision model and a BPMN ` +
+                `process open on the same element name and are not the same file.`, {
+                messageKey: BPMN_IMPORT_ERRORS.missingNamespace[0],
+                messageParams: { bpmnNamespace: BPMN_NS.model },
+            });
+        }
         throw new InterchangeImportError(`This <definitions> is in "${namespace}", not ` +
             `in BPMN 2.0's ("${BPMN_NS.model}"). A DMN decision model and a BPMN ` +
             `process open on the same element name and are not the same file.`, {