@formicoidea/labre-framework-bpmn 0.33.0 → 0.34.1

package/dist/actions.js

@@ -5,7 +5,7 @@ import { NotificationProvider, translateKey, } from '@formicoidea/labre-core/sha
 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 { ASSOCIATION_STROKE, ASSOCIATION_WIDTH, MESSAGE_STROKE, MESSAGE_WIDTH, NODE_LABEL, NODE_SIZE, SEQUENCE_STROKE, SEQUENCE_WIDTH, } from './consts.js';
+import { ASSOCIATION_STROKE, ASSOCIATION_WIDTH, MESSAGE_STROKE, MESSAGE_WIDTH, NODE_LABEL, nodeLabelKey, NODE_SIZE, SEQUENCE_STROKE, SEQUENCE_WIDTH, } from './consts.js';
 import { BPMN_FORMAT_ID } from './export.js';
 import { BPMN_SVG_IMPORT, BPMN_XML_EXPORT, BPMN_XML_FORMAT, BPMN_XML_IMPORT, bpmnBoardFrom, bpmnSafeFilename, } from './interchange.js';
 import { bpmnNodeProps } from './presets.js';
@@ -37,7 +37,13 @@ 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(),
-        text: NODE_LABEL[kind] || undefined,
+        // 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,
     }));
     finish(gfx, id);
 }

package/dist/commands-manifest.d.ts

@@ -0,0 +1,18 @@
+import type { ShortcutManifestEntry } from '@formicoidea/labre-core/std';
+/**
+ * The BPMN commands as SHORTCUT-MANIFEST rows — id, label, chord, scope,
+ * owner — and nothing else.
+ *
+ * DATA ONLY, and that is the whole point (`docs/adr/0008` § Packaging). A
+ * `CommandDescriptor` carries its `run`, so a host settings pane that imports
+ * the package entry to list names and chords drags the entire action graph —
+ * the import/export machinery, the surface and gfx deep paths — into its
+ * chunk. This module has type-only imports, so the published bundle exposes it
+ * as `./commands-manifest`: a few hundred bytes that reference nothing.
+ *
+ * GENERATED-SHAPED, hand-committed: `commands-manifest.unit.spec.ts` asserts
+ * row-for-row equality with `toShortcutManifestEntry` over {@link bpmnCommands},
+ * so this file cannot drift from the commands it projects. Add a command and
+ * the test says exactly what to add here.
+ */
+export declare const bpmnCommandsManifest: ShortcutManifestEntry[];

package/dist/commands-manifest.js

@@ -0,0 +1,226 @@
+/**
+ * The BPMN commands as SHORTCUT-MANIFEST rows — id, label, chord, scope,
+ * owner — and nothing else.
+ *
+ * DATA ONLY, and that is the whole point (`docs/adr/0008` § Packaging). A
+ * `CommandDescriptor` carries its `run`, so a host settings pane that imports
+ * the package entry to list names and chords drags the entire action graph —
+ * the import/export machinery, the surface and gfx deep paths — into its
+ * chunk. This module has type-only imports, so the published bundle exposes it
+ * as `./commands-manifest`: a few hundred bytes that reference nothing.
+ *
+ * GENERATED-SHAPED, hand-committed: `commands-manifest.unit.spec.ts` asserts
+ * row-for-row equality with `toShortcutManifestEntry` over {@link bpmnCommands},
+ * so this file cannot drift from the commands it projects. Add a command and
+ * the test says exactly what to add here.
+ */
+export const bpmnCommandsManifest = [
+    {
+        id: 'bpmn.addStartEvent',
+        owner: 'bpmn',
+        labelKey: 'com.labre.commands.bpmn.addStartEvent',
+        labelFallback: 'Start event',
+        scope: 'edgeless',
+        defaultKeys: { mac: [], other: [] },
+    },
+    {
+        id: 'bpmn.addEndEvent',
+        owner: 'bpmn',
+        labelKey: 'com.labre.commands.bpmn.addEndEvent',
+        labelFallback: 'End event',
+        scope: 'edgeless',
+        defaultKeys: { mac: [], other: [] },
+    },
+    {
+        id: 'bpmn.addTask',
+        owner: 'bpmn',
+        labelKey: 'com.labre.commands.bpmn.addTask',
+        labelFallback: 'Task',
+        scope: 'edgeless',
+        defaultKeys: { mac: [], other: [] },
+    },
+    {
+        id: 'bpmn.addExclusiveGateway',
+        owner: 'bpmn',
+        labelKey: 'com.labre.commands.bpmn.addExclusiveGateway',
+        labelFallback: 'Exclusive gateway',
+        scope: 'edgeless',
+        defaultKeys: { mac: [], other: [] },
+    },
+    {
+        id: 'bpmn.sequenceFlowTool',
+        owner: 'bpmn',
+        labelKey: 'com.labre.commands.bpmn.sequenceFlowTool',
+        labelFallback: 'Sequence flow',
+        scope: 'edgeless',
+        defaultKeys: { mac: [], other: [] },
+    },
+    {
+        id: 'bpmn.addPool',
+        owner: 'bpmn',
+        labelKey: 'com.labre.commands.bpmn.addPool',
+        labelFallback: 'Pool',
+        scope: 'edgeless',
+        defaultKeys: { mac: [], other: [] },
+    },
+    {
+        id: 'bpmn.messageFlowTool',
+        owner: 'bpmn',
+        labelKey: 'com.labre.commands.bpmn.messageFlowTool',
+        labelFallback: 'Message flow',
+        scope: 'edgeless',
+        defaultKeys: { mac: [], other: [] },
+    },
+    {
+        id: 'bpmn.addUserTask',
+        owner: 'bpmn',
+        labelKey: 'com.labre.commands.bpmn.addUserTask',
+        labelFallback: 'User task',
+        scope: 'edgeless',
+        defaultKeys: { mac: [], other: [] },
+    },
+    {
+        id: 'bpmn.addServiceTask',
+        owner: 'bpmn',
+        labelKey: 'com.labre.commands.bpmn.addServiceTask',
+        labelFallback: 'Service task',
+        scope: 'edgeless',
+        defaultKeys: { mac: [], other: [] },
+    },
+    {
+        id: 'bpmn.addSubProcess',
+        owner: 'bpmn',
+        labelKey: 'com.labre.commands.bpmn.addSubProcess',
+        labelFallback: 'Sub-process',
+        scope: 'edgeless',
+        defaultKeys: { mac: [], other: [] },
+    },
+    {
+        id: 'bpmn.addCallActivity',
+        owner: 'bpmn',
+        labelKey: 'com.labre.commands.bpmn.addCallActivity',
+        labelFallback: 'Call activity',
+        scope: 'edgeless',
+        defaultKeys: { mac: [], other: [] },
+    },
+    {
+        id: 'bpmn.addParallelGateway',
+        owner: 'bpmn',
+        labelKey: 'com.labre.commands.bpmn.addParallelGateway',
+        labelFallback: 'Parallel gateway',
+        scope: 'edgeless',
+        defaultKeys: { mac: [], other: [] },
+    },
+    {
+        id: 'bpmn.addMessageStartEvent',
+        owner: 'bpmn',
+        labelKey: 'com.labre.commands.bpmn.addMessageStartEvent',
+        labelFallback: 'Message start event',
+        scope: 'edgeless',
+        defaultKeys: { mac: [], other: [] },
+    },
+    {
+        id: 'bpmn.addTimerStartEvent',
+        owner: 'bpmn',
+        labelKey: 'com.labre.commands.bpmn.addTimerStartEvent',
+        labelFallback: 'Timer start event',
+        scope: 'edgeless',
+        defaultKeys: { mac: [], other: [] },
+    },
+    {
+        id: 'bpmn.addMessageEndEvent',
+        owner: 'bpmn',
+        labelKey: 'com.labre.commands.bpmn.addMessageEndEvent',
+        labelFallback: 'Message end event',
+        scope: 'edgeless',
+        defaultKeys: { mac: [], other: [] },
+    },
+    {
+        id: 'bpmn.addTerminateEndEvent',
+        owner: 'bpmn',
+        labelKey: 'com.labre.commands.bpmn.addTerminateEndEvent',
+        labelFallback: 'Terminate end event',
+        scope: 'edgeless',
+        defaultKeys: { mac: [], other: [] },
+    },
+    {
+        id: 'bpmn.associationTool',
+        owner: 'bpmn',
+        labelKey: 'com.labre.commands.bpmn.associationTool',
+        labelFallback: 'Association',
+        scope: 'edgeless',
+        defaultKeys: { mac: [], other: [] },
+    },
+    {
+        id: 'bpmn.addDataObject',
+        owner: 'bpmn',
+        labelKey: 'com.labre.commands.bpmn.addDataObject',
+        labelFallback: 'Data object',
+        scope: 'edgeless',
+        defaultKeys: { mac: [], other: [] },
+    },
+    {
+        id: 'bpmn.addDataStore',
+        owner: 'bpmn',
+        labelKey: 'com.labre.commands.bpmn.addDataStore',
+        labelFallback: 'Data store',
+        scope: 'edgeless',
+        defaultKeys: { mac: [], other: [] },
+    },
+    {
+        id: 'bpmn.addTextAnnotation',
+        owner: 'bpmn',
+        labelKey: 'com.labre.commands.bpmn.addTextAnnotation',
+        labelFallback: 'Text annotation',
+        scope: 'edgeless',
+        defaultKeys: { mac: [], other: [] },
+    },
+    {
+        id: 'bpmn.addGroup',
+        owner: 'bpmn',
+        labelKey: 'com.labre.commands.bpmn.addGroup',
+        labelFallback: 'Group',
+        scope: 'edgeless',
+        defaultKeys: { mac: [], other: [] },
+    },
+    {
+        id: 'bpmn.addLane',
+        owner: 'bpmn',
+        labelKey: 'com.labre.commands.bpmn.addLane',
+        labelFallback: 'Add lane',
+        scope: 'edgeless',
+        defaultKeys: { mac: [], other: [] },
+    },
+    {
+        id: 'bpmn.removeLane',
+        owner: 'bpmn',
+        labelKey: 'com.labre.commands.bpmn.removeLane',
+        labelFallback: 'Remove lane',
+        scope: 'edgeless',
+        defaultKeys: { mac: [], other: [] },
+    },
+    {
+        id: 'bpmn.exportXml',
+        owner: 'bpmn',
+        labelKey: 'com.labre.commands.bpmn.exportXml',
+        labelFallback: 'Export BPMN XML',
+        scope: 'edgeless',
+        defaultKeys: { mac: [], other: [] },
+    },
+    {
+        id: 'bpmn.importXml',
+        owner: 'bpmn',
+        labelKey: 'com.labre.commands.bpmn.importXml',
+        labelFallback: 'Import BPMN XML',
+        scope: 'edgeless',
+        defaultKeys: { mac: [], other: [] },
+    },
+    {
+        id: 'bpmn.importSvg',
+        owner: 'bpmn',
+        labelKey: 'com.labre.commands.bpmn.importSvg',
+        labelFallback: 'Import SVG sketch',
+        scope: 'edgeless',
+        defaultKeys: { mac: [], other: [] },
+    },
+];

package/dist/consts.d.ts

@@ -45,6 +45,38 @@ export declare const GROUP_RADIUS = 20;
 export declare const GROUP_STROKE = "#8e8d91";
 /** Inner-text font for the task label. */
 export declare const INNER_FONT_SIZE = 18;
+/**
+ * The smallest font a FITTED label is asked for — the importer's floor, and
+ * only its (`bpmnLabelFit` in `presets.ts`).
+ *
+ * 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
+ * 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.
+ *
+ * It is a floor on what is ASKED for, not on what is painted: the shape
+ * renderer's own `TextFitMode.Contained` pass shrinks further, to its own floor
+ * of 8 (`MIN_CONTAINED_FONT_SIZE`), when even this does not fit. Kept here as a
+ * number of our own rather than imported from `@labre/affine-gfx-shape`, so the
+ * reader stays a pure function of a string with no renderer behind it (ADR
+ * 0012, P3).
+ */
+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.
+ */
+export declare const LABEL_INSET_RATIO: number;
 /**
  * Default node sizes (model units) per kind.
  *
@@ -83,13 +115,25 @@ export declare const NODE_SIZE: Record<BpmnNodeKind, {
  * 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.
+ *
+ * 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 declare const NODE_LABEL: Record<BpmnNodeKind, string>;
+/**
+ * The i18n key {@link NODE_LABEL} is the English default of.
+ *
+ * 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.
+ */
+export declare const nodeLabelKey: (kind: BpmnNodeKind) => string;
 /**
  * Pool (background container) defaults — read by the `BPMN_POOL_BACKGROUND`
  * declaration (`background.ts`), which is the only thing that draws a pool.
  */
-export declare const POOL_BAND_WIDTH = 28;
 export declare const POOL_FRAME_COLOR = "#262626";
 /**
  * The card. The same white every framework background paints — it is what
@@ -113,20 +157,13 @@ export declare const POOL_FONT_FAMILY = "Inter, sans-serif";
  */
 export declare const POOL_LANE_NAME_FONT_SIZE = 13;
 /**
- * Width of a lane's own title band, in model units — the strip immediately
- * inside the participant band, with the lane name turned on its side.
- *
- * Four units narrower than {@link POOL_BAND_WIDTH}, and for the same reason the
- * font is two points smaller: the two strips sit side by side, so the
- * subordinate one has to say so. Identical widths read as a single 56-unit
- * gutter rather than as a participant containing lanes, which is exactly the
- * relationship the picture has to carry.
- *
- * NO fill, divider only — what bpmn.io, Camunda and Visio all draw. A second
- * grey strip beside the pool's own would double the furniture and leave the
- * flow area looking inset by two margins.
+ * The two band widths live in `@labre/affine-model`, beside the pool model that
+ * hit-tests against them (a pool is clickable by its title bands as well as by
+ * its border — the bpmn.io convention, issue #194). They are re-exported here
+ * so this file stays the one place a reader looks for a pool's metrics, and so
+ * the declaration keeps reading them from where it always did.
  */
-export declare const POOL_LANE_BAND_WIDTH = 24;
+export { POOL_BAND_WIDTH, POOL_LANE_BAND_WIDTH } from '@formicoidea/labre-core/model';
 /**
  * How close to an internal lane boundary a pointer has to be, in MODEL units,
  * for the gesture to be a separator drag rather than a click on the pool.

package/dist/consts.js

@@ -44,6 +44,38 @@ export const GROUP_RADIUS = 20;
 export const GROUP_STROKE = '#8e8d91';
 /** Inner-text font for the task label. */
 export const INNER_FONT_SIZE = 18;
+/**
+ * The smallest font a FITTED label is asked for — the importer's floor, and
+ * only its (`bpmnLabelFit` in `presets.ts`).
+ *
+ * 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
+ * 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.
+ *
+ * It is a floor on what is ASKED for, not on what is painted: the shape
+ * renderer's own `TextFitMode.Contained` pass shrinks further, to its own floor
+ * of 8 (`MIN_CONTAINED_FONT_SIZE`), when even this does not fit. Kept here as a
+ * number of our own rather than imported from `@labre/affine-gfx-shape`, so the
+ * reader stays a pure function of a string with no renderer behind it (ADR
+ * 0012, P3).
+ */
+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.
+ */
+export const LABEL_INSET_RATIO = 1 / 6;
 /**
  * Default node sizes (model units) per kind.
  *
@@ -97,6 +129,9 @@ export const NODE_SIZE = {
  * 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.
+ *
+ * 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: '',
@@ -121,11 +156,20 @@ export const NODE_LABEL = {
     // centred so it does not float over whatever the group encloses.
     group: 'Group',
 };
+/**
+ * The i18n key {@link NODE_LABEL} is the English default of.
+ *
+ * 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.
+ */
+export const nodeLabelKey = (kind) => `com.labre.bpmn.seed.${kind}`;
 /**
  * Pool (background container) defaults — read by the `BPMN_POOL_BACKGROUND`
  * declaration (`background.ts`), which is the only thing that draws a pool.
  */
-export const POOL_BAND_WIDTH = 28;
 export const POOL_FRAME_COLOR = '#262626';
 /**
  * The card. The same white every framework background paints — it is what
@@ -149,20 +193,13 @@ export const POOL_FONT_FAMILY = 'Inter, sans-serif';
  */
 export const POOL_LANE_NAME_FONT_SIZE = 13;
 /**
- * Width of a lane's own title band, in model units — the strip immediately
- * inside the participant band, with the lane name turned on its side.
- *
- * Four units narrower than {@link POOL_BAND_WIDTH}, and for the same reason the
- * font is two points smaller: the two strips sit side by side, so the
- * subordinate one has to say so. Identical widths read as a single 56-unit
- * gutter rather than as a participant containing lanes, which is exactly the
- * relationship the picture has to carry.
- *
- * NO fill, divider only — what bpmn.io, Camunda and Visio all draw. A second
- * grey strip beside the pool's own would double the furniture and leave the
- * flow area looking inset by two margins.
+ * The two band widths live in `@labre/affine-model`, beside the pool model that
+ * hit-tests against them (a pool is clickable by its title bands as well as by
+ * its border — the bpmn.io convention, issue #194). They are re-exported here
+ * so this file stays the one place a reader looks for a pool's metrics, and so
+ * the declaration keeps reading them from where it always did.
  */
-export const POOL_LANE_BAND_WIDTH = 24;
+export { POOL_BAND_WIDTH, POOL_LANE_BAND_WIDTH } from '@formicoidea/labre-core/model';
 /**
  * How close to an internal lane boundary a pointer has to be, in MODEL units,
  * for the gesture to be a separator drag rather than a click on the pool.

package/dist/element-view.d.ts

@@ -1,4 +1,6 @@
 import type { BpmnPoolElementModel } from '@formicoidea/labre-core/model';
+import type { EditorHost } from '@formicoidea/labre-core/std';
+import type { PointTestOptions } from '@formicoidea/labre-core/std/gfx';
 import { GfxElementModelView } from '@formicoidea/labre-core/std/gfx';
 /**
  * View for a BPMN pool. Three direct gestures live here:
@@ -80,6 +82,23 @@ export declare class BpmnPoolView extends GfxElementModelView<BpmnPoolElementMod
     /** Which name this point aims at, if any — lane strip first, see `pool-hit`. */
     private _targetAt;
     private get _editable();
+    /**
+     * A pool is SELECTED by its border and its painted title bands
+     * (`BpmnPoolElementModel.includesPoint`) — but two of this view's gestures
+     * live elsewhere on it and must still receive their pointer events:
+     *
+     * - the internal LANE SEPARATORS, twelve-unit strips in the middle of the
+     *   flow area, which arm the drag that moves them;
+     * - the zoom-GROWN rename targets, which reach past the painted bands when
+     *   the board is small on screen so a fingertip can still land on one.
+     *
+     * Neither is a selection zone — a click in the flow area still goes to
+     * whatever the user dropped there, because picking asks the MODEL. This
+     * override only decides where the pool's own gestures are heard, which is why
+     * it is declared here, beside the code that draws and handles them, rather
+     * than in `affine-model` where none of this geometry is reachable.
+     */
+    includesPoint(x: number, y: number, options: PointTestOptions, host: EditorHost): boolean;
     /**
      * One pass over the pointer, deciding both the cursor and whether a
      * separator drag is armed.

package/dist/element-view.js

@@ -113,6 +113,31 @@ export class BpmnPoolView extends GfxElementModelView {
     get _editable() {
         return !this.gfx.std.store.readonly && !this.model.isLocked();
     }
+    /**
+     * A pool is SELECTED by its border and its painted title bands
+     * (`BpmnPoolElementModel.includesPoint`) — but two of this view's gestures
+     * live elsewhere on it and must still receive their pointer events:
+     *
+     * - the internal LANE SEPARATORS, twelve-unit strips in the middle of the
+     *   flow area, which arm the drag that moves them;
+     * - the zoom-GROWN rename targets, which reach past the painted bands when
+     *   the board is small on screen so a fingertip can still land on one.
+     *
+     * Neither is a selection zone — a click in the flow area still goes to
+     * whatever the user dropped there, because picking asks the MODEL. This
+     * override only decides where the pool's own gestures are heard, which is why
+     * it is declared here, beside the code that draws and handles them, rather
+     * than in `affine-model` where none of this geometry is reachable.
+     */
+    includesPoint(x, y, options, host) {
+        if (super.includesPoint(x, y, options, host))
+            return true;
+        // Element-local by subtraction, like every other box in this view — see the
+        // rotation reserve in the class comment.
+        const [ex, ey] = this.model.deserializedXYWH;
+        const local = [x - ex, y - ey];
+        return this._boundaryAt(local) !== null || this._targetAt(local) !== null;
+    }
     /* ── Hover: what this point would do ───────────────────────────────── */
     /**
      * One pass over the pointer, deciding both the cursor and whether a

package/dist/import.d.ts

@@ -1,6 +1,31 @@
 import type { InterchangeImportContext, 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.
+ *
+ * A reader is a pure function of text (`docs/adr/0012`, P3) and has no `std`,
+ * so it cannot ask the host's catalogue for anything: it declares the key on
+ * the note and `reportInterchangeImport` resolves it when it draws the report
+ * (`InterchangeNote.messageKey`). The English string stays here and stays the
+ * fallback, so the console table and a playground with no catalogue read
+ * exactly what they read before.
+ *
+ * These three and no others, and the line is not arbitrary: every remaining
+ * remark NAMES something out of the file — `<boundaryEvent>`, an id, a count of
+ * lanes — and the seam has neither interpolation nor pluralisation. A key for
+ * one of those would be a sentence with holes in it that a translator cannot
+ * see the shape of, which is the same refusal the interchange count labels
+ * already make (`interchange-import.ts`).
+ *
+ * They are contributed to the manifest by `./translations.ts`, with the
+ * framework, because they ship in the BPMN bundle rather than in core.
+ */
+export declare const BPMN_IMPORT_REMARKS: {
+    readonly inventedPool: readonly ["com.labre.bpmn.import.remark.invented-pool", "This file names no participant, so its process was drawn in a pool of Labre's own. The pool is not the file's: exporting writes the process back without one."];
+    readonly laneGap: readonly ["com.labre.bpmn.import.remark.lane-gap", "The lanes of this pool are drawn with a gap or an overlap between them. Labre lays its bands end to end, so their heights were kept in proportion and the space between them was closed."];
+    readonly mustUnderstand: readonly ["com.labre.bpmn.import.remark.must-understand", "The file declares an extension that it says MUST be understood to read the model correctly. Labre does not understand it: the import went ahead, and this reading of the process may be wrong."];
+};
 /**
  * `startEvent` + `messageEventDefinition` → `startEventMessage`, and the
  * sixteen other answers.

package/dist/import.js

@@ -4,6 +4,40 @@ import { ASSOCIATION_STROKE, ASSOCIATION_WIDTH, MESSAGE_STROKE, MESSAGE_WIDTH, N
 import { BPMN_FORMAT_ID, BPMN_NS, BPMN_OWN_DECLARATIONS, BPMN_SCOPE, BPMN_XML_OF_KIND, escapeAttr, escapeText, } from './export.js';
 import { bpmnNodeProps } from './presets.js';
 import { BPMN_ROLE } from './roles.js';
+/**
+ * The remarks whose wording is FIXED, as `[key, English]` pairs.
+ *
+ * A reader is a pure function of text (`docs/adr/0012`, P3) and has no `std`,
+ * so it cannot ask the host's catalogue for anything: it declares the key on
+ * the note and `reportInterchangeImport` resolves it when it draws the report
+ * (`InterchangeNote.messageKey`). The English string stays here and stays the
+ * fallback, so the console table and a playground with no catalogue read
+ * exactly what they read before.
+ *
+ * These three and no others, and the line is not arbitrary: every remaining
+ * remark NAMES something out of the file — `<boundaryEvent>`, an id, a count of
+ * lanes — and the seam has neither interpolation nor pluralisation. A key for
+ * one of those would be a sentence with holes in it that a translator cannot
+ * see the shape of, which is the same refusal the interchange count labels
+ * already make (`interchange-import.ts`).
+ *
+ * They are contributed to the manifest by `./translations.ts`, with the
+ * framework, because they ship in the BPMN bundle rather than in core.
+ */
+export const BPMN_IMPORT_REMARKS = {
+    inventedPool: [
+        'com.labre.bpmn.import.remark.invented-pool',
+        "This file names no participant, so its process was drawn in a pool of Labre's own. The pool is not the file's: exporting writes the process back without one.",
+    ],
+    laneGap: [
+        'com.labre.bpmn.import.remark.lane-gap',
+        'The lanes of this pool are drawn with a gap or an overlap between them. Labre lays its bands end to end, so their heights were kept in proportion and the space between them was closed.',
+    ],
+    mustUnderstand: [
+        'com.labre.bpmn.import.remark.must-understand',
+        'The file declares an extension that it says MUST be understood to read the model correctly. Labre does not understand it: the import went ahead, and this reading of the process may be wrong.',
+    ],
+};
 /**
  * A BPMN 2.0 interchange document, read as a board — the inverse of `export.ts`
  * on the vocabulary Labre draws, and an honest accounting of everything else
@@ -814,9 +848,8 @@ export function importBpmnXml(source, context = {}) {
             kind: 'invented-layout',
             sourceId,
             element: 'process',
-            message: `This file names no participant, so its process was drawn in a pool of ` +
-                `Labre's own. The pool is not the file's: exporting writes the process ` +
-                `back without one.`,
+            messageKey: BPMN_IMPORT_REMARKS.inventedPool[0],
+            message: BPMN_IMPORT_REMARKS.inventedPool[1],
         });
     }
     /**
@@ -945,9 +978,8 @@ export function importBpmnXml(source, context = {}) {
                     kind: 'invented-layout',
                     sourceId: attrOf(laneSet, 'id'),
                     element: 'laneSet',
-                    message: `The lanes of this pool are drawn with a gap or an overlap between ` +
-                        `them. Labre lays its bands end to end, so their heights were kept ` +
-                        `in proportion and the space between them was closed.`,
+                    messageKey: BPMN_IMPORT_REMARKS.laneGap[0],
+                    message: BPMN_IMPORT_REMARKS.laneGap[1],
                 });
             }
         }
@@ -1102,6 +1134,11 @@ export function importBpmnXml(source, context = {}) {
                     ? new Bound(bounds.x, bounds.y, bounds.w, bounds.h)
                     : new Bound(0, 0, size.w, size.h)).serialize(),
                 text: text || undefined,
+                // The file's own box, which this reader may not rewrite — so the label
+                // is fitted to it rather than painted past it (#184). A shape the file
+                // did not draw is laid out at the pack's own size below, and wants the
+                // pack's own type: no fit, and an element identical to a drawn one.
+                ...(bounds ? { fitLabel: true } : {}),
             }),
             payload,
             order: shape?.index ?? Number.POSITIVE_INFINITY,
@@ -1314,9 +1351,8 @@ export function importBpmnXml(source, context = {}) {
                 note({
                     kind: 'warning',
                     element: 'extension',
-                    message: `The file declares an extension that it says MUST be understood to ` +
-                        `read the model correctly. Labre does not understand it: the import ` +
-                        `went ahead, and this reading of the process may be wrong.`,
+                    messageKey: BPMN_IMPORT_REMARKS.mustUnderstand[0],
+                    message: BPMN_IMPORT_REMARKS.mustUnderstand[1],
                 });
             }
             carryChild(host.payload, BPMN_SCOPE.definitions, root, attrOf(definitions, 'id'));

package/dist/index.d.ts

@@ -4,7 +4,7 @@ export { materializeBpmnImport, reportBpmnImport } from './actions.js';
 export { bpmnCommandIcons, bpmnCommands } from './commands.js';
 export { BPMN_FORMAT_ID, BPMN_NS, BPMN_XML_OF_KIND, type BpmnExportBoard, type BpmnExportOptions, type BpmnExportOutcome, type BpmnXmlMapping, exportBpmnXml, exportBpmnXmlWithWarnings, isNcName, toNcName, } from './export.js';
 export { BPMN_KIND_OF_XML, BPMN_QUARANTINE_REASON, importBpmnXml, } from './import.js';
-export { bpmnMorphClears, bpmnMorphProps, bpmnNodeProps, type BpmnNodePreset, NODE_PRESETS, } from './presets.js';
+export { bpmnLabelFit, type BpmnLabelFit, bpmnMorphClears, bpmnMorphProps, bpmnNodeProps, type BpmnNodePreset, NODE_PRESETS, } from './presets.js';
 export { BPMN_MORPH_FAMILIES, BPMN_MORPH_SPEC } from './morph.js';
 export { BPMN_INTERCHANGE, BPMN_SVG_FORMAT, BPMN_SVG_IMPORT, BPMN_XML_EXPORT, BPMN_XML_EXTENSION, BPMN_XML_IMPORT, BPMN_XML_FORMAT, BPMN_XML_MIME, bpmnBoardFrom, bpmnSafeFilename, } from './interchange.js';
 export { bpmnLaneOf, bpmnPoolOf } from './facts.js';

package/dist/index.js

@@ -26,7 +26,10 @@ export { BPMN_KIND_OF_XML, BPMN_QUARANTINE_REASON, importBpmnXml, } from './impo
 // What an artefact is BORN as, shared by the palette and the importer so a task
 // read out of a file and a task drawn by hand are one element in the document —
 // and, since the morph, by the toolbar that says one artefact more precisely.
-export { bpmnMorphClears, bpmnMorphProps, bpmnNodeProps, NODE_PRESETS, } from './presets.js';
+// `bpmnLabelFit` rides along with it: a host that materializes artefacts from a
+// geometry of its own — a file, a generator, another editor's board — fits their
+// labels the way the importer does, rather than reinventing the arithmetic.
+export { bpmnLabelFit, bpmnMorphClears, bpmnMorphProps, bpmnNodeProps, NODE_PRESETS, } from './presets.js';
 // What an artefact may BECOME: the declared families, and the spec the generic
 // morph module is registered with. Data a host can read without an editor.
 export { BPMN_MORPH_FAMILIES, BPMN_MORPH_SPEC } from './morph.js';

package/dist/presets.d.ts

@@ -1,5 +1,5 @@
 import type { BpmnNodeKind } from '@formicoidea/labre-core/model';
-import { StrokeStyle, TextAlign, TextVerticalAlign } from '@formicoidea/labre-core/model';
+import { StrokeStyle, TextAlign, TextFitMode, TextVerticalAlign } from '@formicoidea/labre-core/model';
 /**
  * What a BPMN artefact is BORN as — the one description of a node's props, read
  * by every site that creates one.
@@ -52,6 +52,51 @@ export interface BpmnNodePreset {
 }
 /** Per-kind native shape + accent presets (style C). */
 export declare const NODE_PRESETS: Record<BpmnNodeKind, BpmnNodePreset>;
+/** The label typography a foreign box asks for. See {@link bpmnLabelFit}. */
+export interface BpmnLabelFit {
+    fontSize: number;
+    /** `[vertical, horizontal]`, as `ShapeElementModel.padding` is written. */
+    padding: [number, number];
+    textFitMode: TextFitMode;
+}
+/**
+ * The typography a label needs to sit INSIDE a box this pack did not choose —
+ * which in practice means a box an interchange file chose (`import.ts`).
+ *
+ * ## Why an imported label misbehaves and a drawn one does not
+ *
+ * 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.
+ * 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
+ * less than the word "Étudier" is wide at 18 units, so the label breaks in the
+ * middle of a word; in a 36-unit event it leaves NEGATIVE room, and the name
+ * sprawls across the canvas. Both are issue #184, and neither is reachable from
+ * the palette.
+ *
+ * So the three props that decide how a label sits are derived from the box:
+ *
+ *  - **`fontSize`** shrinks with the box, proportionally, and never grows past
+ *    {@link INNER_FONT_SIZE} — a file that draws BIGGER than this pack gets the
+ *    pack's own type, not inflated type — with {@link LABEL_MIN_FONT_SIZE} as
+ *    the floor;
+ *  - **`padding`** becomes {@link LABEL_INSET_RATIO} of the box, capped at the
+ *    shape's native inset, so the margin follows the artefact down instead of
+ *    eating it;
+ *  - **`textFitMode`** becomes `Contained`, which is the honest statement of
+ *    what an imported artefact IS: the file fixed the box — re-exporting a
+ *    different one would rewrite the author's diagram — so the TEXT is what
+ *    yields. The renderer then shrinks the font further, per frame, whenever a
+ *    long name still does not fit.
+ *
+ * Pure arithmetic on two numbers: no measuring, no canvas, no renderer. The
+ * fit does not have to be exact, because `Contained` finishes it at paint time
+ * with the real font metrics; what this has to do is stop asking for type the
+ * box was never going to hold.
+ */
+export declare function bpmnLabelFit(kind: BpmnNodeKind, w: number, h: number): BpmnLabelFit;
 /**
  * One BPMN node, as the props `surface.addElement` takes.
  *
@@ -63,10 +108,19 @@ export declare const NODE_PRESETS: Record<BpmnNodeKind, BpmnNodePreset>;
  * label the source left empty gets no `text` key at all rather than an empty
  * one, which is what keeps an imported node byte-comparable with a drawn one
  * that was never typed into.
+ *
+ * `fitLabel` says the box is NOT the pack's own — the caller took it from a
+ * file it may not rewrite — so the label is fitted to it
+ * ({@link bpmnLabelFit}). It is asked for explicitly rather than inferred from
+ * the box's size for two reasons: an importer knows whether it read a
+ * `dc:Bounds` and a guess never would, and {@link bpmnMorphProps} calls this
+ * builder with a throwaway box whose numbers must not be allowed to mean
+ * anything.
  */
 export declare function bpmnNodeProps(kind: BpmnNodeKind, box: {
     xywh: string;
     text?: string;
+    fitLabel?: boolean;
 }): Record<string, unknown> & {
     type: string;
 };

package/dist/presets.js

@@ -1,5 +1,6 @@
-import { FontFamily, ShapeStyle, StrokeStyle, TextAlign, TextFitMode, TextVerticalAlign, } from '@formicoidea/labre-core/model';
-import { CALL_ACTIVITY_WIDTH, END_WIDTH, EVENT_END, EVENT_START, GROUP_RADIUS, GROUP_STROKE, INNER_FONT_SIZE, NEUTRAL_STROKE, NODE_FILL, NODE_STROKE_WIDTH, START_WIDTH, TASK_RADIUS, } from './consts.js';
+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 { BPMN_ROLE_OF_KIND } from './roles.js';
 /** Per-kind native shape + accent presets (style C). */
 export const NODE_PRESETS = {
@@ -105,6 +106,81 @@ export const NODE_PRESETS = {
         textVerticalAlign: TextVerticalAlign.Top,
     },
 };
+/**
+ * `[w, h]` off a serialized box.
+ *
+ * A `Bound` and not a hand-rolled `split(',')`: the same deserializer the store
+ * reads an element's geometry with, so a box this builder measures and a box
+ * the canvas draws can never be two different rectangles.
+ */
+function boxExtent(xywh) {
+    const bound = Bound.deserialize(xywh);
+    return [bound.w, bound.h];
+}
+/**
+ * How big a box is against the pack's own — and `1`, meaning "the pack's own",
+ * for an extent that says nothing.
+ *
+ * A `dc:Bounds` of zeros, of negatives or of `NaN` (which is what a
+ * non-numeric attribute parses to) reaches an importer on its first afternoon
+ * in the wild. The answer for a box that says nothing is the DRAWN artefact's
+ * type, not a shrunken guess at a size nobody gave — and never `NaN`, which is
+ * not a number the store can hold.
+ */
+const ratioOf = (extent, standard) => Number.isFinite(extent) && extent > 0 ? extent / standard : 1;
+/** One side's margin: the ratio of the extent, never more than the native inset. */
+const insetOf = (extent, native) => Number.isFinite(extent) && extent > 0
+    ? Math.round(Math.min(native, extent * LABEL_INSET_RATIO))
+    : native;
+/**
+ * The typography a label needs to sit INSIDE a box this pack did not choose —
+ * which in practice means a box an interchange file chose (`import.ts`).
+ *
+ * ## Why an imported label misbehaves and a drawn one does not
+ *
+ * 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.
+ * 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
+ * less than the word "Étudier" is wide at 18 units, so the label breaks in the
+ * middle of a word; in a 36-unit event it leaves NEGATIVE room, and the name
+ * sprawls across the canvas. Both are issue #184, and neither is reachable from
+ * the palette.
+ *
+ * So the three props that decide how a label sits are derived from the box:
+ *
+ *  - **`fontSize`** shrinks with the box, proportionally, and never grows past
+ *    {@link INNER_FONT_SIZE} — a file that draws BIGGER than this pack gets the
+ *    pack's own type, not inflated type — with {@link LABEL_MIN_FONT_SIZE} as
+ *    the floor;
+ *  - **`padding`** becomes {@link LABEL_INSET_RATIO} of the box, capped at the
+ *    shape's native inset, so the margin follows the artefact down instead of
+ *    eating it;
+ *  - **`textFitMode`** becomes `Contained`, which is the honest statement of
+ *    what an imported artefact IS: the file fixed the box — re-exporting a
+ *    different one would rewrite the author's diagram — so the TEXT is what
+ *    yields. The renderer then shrinks the font further, per frame, whenever a
+ *    long name still does not fit.
+ *
+ * Pure arithmetic on two numbers: no measuring, no canvas, no renderer. The
+ * fit does not have to be exact, because `Contained` finishes it at paint time
+ * with the real font metrics; what this has to do is stop asking for type the
+ * box was never going to hold.
+ */
+export function bpmnLabelFit(kind, w, h) {
+    const size = 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)),
+        padding: [
+            insetOf(h, SHAPE_TEXT_VERTICAL_PADDING),
+            insetOf(w, SHAPE_TEXT_PADDING),
+        ],
+        textFitMode: TextFitMode.Contained,
+    };
+}
 /**
  * One BPMN node, as the props `surface.addElement` takes.
  *
@@ -116,9 +192,22 @@ export const NODE_PRESETS = {
  * label the source left empty gets no `text` key at all rather than an empty
  * one, which is what keeps an imported node byte-comparable with a drawn one
  * that was never typed into.
+ *
+ * `fitLabel` says the box is NOT the pack's own — the caller took it from a
+ * file it may not rewrite — so the label is fitted to it
+ * ({@link bpmnLabelFit}). It is asked for explicitly rather than inferred from
+ * the box's size for two reasons: an importer knows whether it read a
+ * `dc:Bounds` and a guess never would, and {@link bpmnMorphProps} calls this
+ * builder with a throwaway box whose numbers must not be allowed to mean
+ * anything.
  */
 export function bpmnNodeProps(kind, box) {
     const preset = NODE_PRESETS[kind];
+    // Nothing to fit without a label: an artefact whose name the file left empty
+    // stays byte-identical to a drawn one, which is what `presets.ts` is for.
+    const fit = box.fitLabel && box.text
+        ? bpmnLabelFit(kind, ...boxExtent(box.xywh))
+        : undefined;
     return {
         type: 'bpmnNode',
         kind,
@@ -145,7 +234,7 @@ export function bpmnNodeProps(kind, box) {
         text: box.text,
         color: NEUTRAL_STROKE,
         fontFamily: FontFamily.Inter,
-        fontSize: INNER_FONT_SIZE,
+        fontSize: fit?.fontSize ?? INNER_FONT_SIZE,
         textAlign: preset.textAlign ?? TextAlign.Center,
         // Spread, never a defaulted key: the model's own default is already
         // `Center`, so writing it here would put a new key in the Y.Map of every
@@ -155,8 +244,14 @@ export function bpmnNodeProps(kind, box) {
             ? { textVerticalAlign: preset.textVerticalAlign }
             : {}),
         // BPMN symbols have normative sizes: a long label overflows rather
-        // than deforming the node
-        textFitMode: TextFitMode.Overflow,
+        // than deforming the node. An imported artefact is the one case where that
+        // is not enough — its box is the FILE's and its label is the file's too, so
+        // the text is fitted to the box instead of painted past it (#184).
+        textFitMode: fit?.textFitMode ?? TextFitMode.Overflow,
+        // Spread, never a defaulted key, for the reason `textVerticalAlign` is: a
+        // drawn artefact keeps the shape's own inset and puts nothing of its own in
+        // the Y.Map.
+        ...(fit ? { padding: fit.padding } : {}),
         xywh: box.xywh,
     };
 }

package/dist/toolbar/config.d.ts

@@ -1,9 +1,10 @@
-import { ActionPlacement, type ToolbarContext } from '@formicoidea/labre-core/shared/services';
+import { ActionPlacement, type ChromeWording, type ToolbarContext } from '@formicoidea/labre-core/shared/services';
 import { type TemplateResult } from 'lit';
 export declare const bpmnPoolToolbarConfig: {
     readonly actions: [{
         id: string;
         tooltip: string;
+        tooltipWording: ChromeWording | undefined;
         icon: TemplateResult;
         active(ctx: ToolbarContext): boolean;
         run(ctx: ToolbarContext): void;

package/dist/toolbar/config.js

@@ -1,6 +1,6 @@
 import { EdgelessCRUDIdentifier } from '@formicoidea/labre-core/blocks/surface';
 import { BpmnPoolElementModel } from '@formicoidea/labre-core/model';
-import { ActionPlacement, ToolbarModuleExtension, translateKey, } from '@formicoidea/labre-core/shared/services';
+import { ActionPlacement, BOARD_RESIZE_TOGGLE, ToolbarModuleExtension, translateKey, } from '@formicoidea/labre-core/shared/services';
 import { BlockFlavourIdentifier, getRegisteredCommands, runCommand, } from '@formicoidea/labre-core/std';
 import { html } from 'lit';
 import { bpmnExportXmlIcon, bpmnLaneAddIcon, bpmnLaneRemoveIcon, } from './icons.js';
@@ -24,7 +24,12 @@ const ResizeIcon = html `<svg
 function booleanToggle(id, tooltip, icon, prop) {
     return {
         id,
-        tooltip,
+        tooltip: typeof tooltip === 'string' ? tooltip : tooltip[1],
+        // The declared wording, when the caller gave one instead of a literal:
+        // `combine` resolves it against the host's catalogue and writes it over
+        // the English default above, so a playground with no catalogue reads
+        // exactly what it read before (#183).
+        tooltipWording: typeof tooltip === 'string' ? undefined : tooltip,
         icon,
         active(ctx) {
             const models = ctx.getSurfaceModelsByType(BpmnPoolElementModel);
@@ -119,7 +124,7 @@ function commandMoreAction(id, commandId, labelKey, labelFallback, icon) {
 const findCommand = (ctx, id) => getRegisteredCommands(ctx.std).find(candidate => candidate.id === id);
 export const bpmnPoolToolbarConfig = {
     actions: [
-        booleanToggle('a.toggle-resize', 'Enable / lock resizing', ResizeIcon, 'resizeEnabled'),
+        booleanToggle('a.toggle-resize', BOARD_RESIZE_TOGGLE, ResizeIcon, 'resizeEnabled'),
         // The two lane gestures, next to the resize toggle: everything on this row
         // is about the SHAPE of the pool rather than about what is drawn in it.
         // Add before remove, because that is the order they can be used in — a pool

package/dist/translations.js

@@ -1,8 +1,32 @@
-import { collectTranslationKeys, commandTranslationEntries, mergeTranslationEntries, } from '@formicoidea/labre-core/std';
+import { collectTranslationKeys, commandCategoryTranslationEntries, commandTranslationEntries, mergeTranslationEntries, } from '@formicoidea/labre-core/std';
 import { bpmnCommands } from './commands.js';
+import { NODE_LABEL, nodeLabelKey } from './consts.js';
+import { BPMN_IMPORT_REMARKS } from './import.js';
 import { BPMN_PROFILES } from './profiles.js';
 import { BPMN_ROLES } from './roles.js';
 import { BPMN_RULES } from './rules.js';
+/**
+ * The captions a placed artefact is seeded with, and the fixed-wording remarks
+ * an import can produce — the two families of BPMN prose that live in tables
+ * rather than in a declaration the walker can reach.
+ *
+ * Derived from those tables, never restated: the fallback IS `NODE_LABEL[kind]`
+ * and `BPMN_IMPORT_REMARKS[…][1]`, so the wording a host is offered and the
+ * wording the library writes cannot drift. The kinds with no caption
+ * contribute no key — there is nothing to translate.
+ */
+const seedEntries = () => Object.entries(NODE_LABEL)
+    .filter(([, label]) => label !== '')
+    .map(([kind, label]) => ({
+    key: nodeLabelKey(kind),
+    fallback: label,
+    source: 'seed',
+}));
+const importRemarkEntries = () => Object.values(BPMN_IMPORT_REMARKS).map(([key, english]) => ({
+    key,
+    fallback: english,
+    source: 'chrome',
+}));
 /**
  * THIS framework's contribution to the translation-key manifest — every
  * `com.labre.*` key BPMN can hand to `TranslationProvider.t`, derived from the
@@ -17,4 +41,10 @@ import { BPMN_RULES } from './rules.js';
  * `bpmnCommands` into the command registry. See
  * `packages/affine/all/src/translations.ts`.
  */
-export const bpmnTranslationEntries = mergeTranslationEntries(commandTranslationEntries(bpmnCommands), collectTranslationKeys('role', BPMN_ROLES), collectTranslationKeys('rule', BPMN_RULES), collectTranslationKeys('profile', BPMN_PROFILES));
+export const bpmnTranslationEntries = mergeTranslationEntries(commandTranslationEntries(bpmnCommands), 
+// The catalogue's own group headers, derived from the very categories
+// these commands declare. They ship WITH the framework because core's
+// registry names no framework category in the bundled distribution, so a
+// host that composed core's manifest alone drew translated entries under
+// English headers (#183).
+commandCategoryTranslationEntries(bpmnCommands), collectTranslationKeys('role', BPMN_ROLES), collectTranslationKeys('rule', BPMN_RULES), collectTranslationKeys('profile', BPMN_PROFILES), seedEntries(), importRemarkEntries());

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@formicoidea/labre-framework-bpmn",
   "description": "Labre bpmn framework for @formicoidea/labre-core.",
-  "version": "0.33.0",
+  "version": "0.34.1",
   "type": "module",
   "sideEffects": false,
   "author": "lajola",
@@ -21,13 +21,17 @@
     "./descriptor": {
       "types": "./dist/descriptor.d.ts",
       "import": "./dist/descriptor.js"
+    },
+    "./commands-manifest": {
+      "types": "./dist/commands-manifest.d.ts",
+      "import": "./dist/commands-manifest.js"
     }
   },
   "files": [
     "dist"
   ],
   "dependencies": {
-    "@formicoidea/labre-core": "0.33.0",
+    "@formicoidea/labre-core": "0.34.1",
     "lit": "^3.2.0"
   }
 }