@formicoidea/labre-framework-ddd-event-storming 0.58.0 → 0.60.0

package/dist/actions.d.ts

@@ -1,4 +1,11 @@
 import type { GfxController } from '@formicoidea/labre-core/std/gfx';
+/**
+ * Creation / activation actions for the Event Storming toolbox — the BEHAVIOUR
+ * layer, depending on nothing but the {@link GfxController}.
+ *
+ * They emit no telemetry: since PF3 the single emission point is the command
+ * registry's `runCommand` (`docs/adr/0008`).
+ */
 /** Create the board at the viewport centre, select it, return to the default tool. */
 export declare function createEventStormingBoard(gfx: GfxController): void;
 /**

package/dist/actions.js

@@ -1,10 +1,9 @@
 import { backgroundSize, DefaultTool } from '@formicoidea/labre-core/blocks/surface';
 import { ConnectorTool } from '@formicoidea/labre-core/gfx/connector';
-import { LABEL_COLOR } from '@formicoidea/labre-ddd-shared';
-import { ConnectorMode, PointStyle, StrokeStyle } from '@formicoidea/labre-core/model';
-import { Bound } from '@formicoidea/labre-core/global/gfx';
+import { ConnectorMode } from '@formicoidea/labre-core/model';
 import { EVENT_STORMING_BACKGROUND } from './background.js';
 import { ES_ROLE } from './roles.js';
+import { eventStormingBoardElement, eventStormingFlowStyle } from './toolbox.js';
 /**
  * Creation / activation actions for the Event Storming toolbox — the BEHAVIOUR
  * layer, depending on nothing but the {@link GfxController}.
@@ -12,22 +11,19 @@ import { ES_ROLE } from './roles.js';
  * They emit no telemetry: since PF3 the single emission point is the command
  * registry's `runCommand` (`docs/adr/0008`).
  */
-const FLOW_STROKE_WIDTH = 2;
 /** Create the board at the viewport centre, select it, return to the default tool. */
 export function createEventStormingBoard(gfx) {
     if (!gfx.surface)
         return;
     const { width, height } = backgroundSize(EVENT_STORMING_BACKGROUND);
     const { centerX, centerY } = gfx.viewport;
-    const id = gfx.surface.addElement({
-        type: EVENT_STORMING_BACKGROUND.type,
-        // The board is a first-class role: rules frame stickies against `es:board`,
-        // never against the `eventStorming` element type. The declaration owns it,
-        // so a templated board and a hand-drawn one agree.
-        role: EVENT_STORMING_BACKGROUND.role,
-        resizeEnabled: EVENT_STORMING_BACKGROUND.geometry.resizable,
-        xywh: new Bound(centerX - width / 2, centerY - height / 2, width, height).serialize(),
+    // The board's props come from the toolbox (`docs/adr/0045`), the one
+    // assembly a host with no editor also calls; the viewport centre is ours.
+    const { id: _local, ...props } = eventStormingBoardElement({
+        x: centerX - width / 2,
+        y: centerY - height / 2,
     });
+    const id = gfx.surface.addElement(props);
     gfx.doc.captureSync();
     gfx.tool.setTool(DefaultTool);
     gfx.selection.set({ elements: [id], editing: false });
@@ -62,16 +58,10 @@ export function activateEventStormingFlow(gfx) {
         mode: ConnectorMode.Straight,
         role: ES_ROLE.flow,
         // The look rides on the activation, never through the last-props store:
-        // the plain connector tool must keep the user's own style (#144 M1).
-        style: {
-            stroke: LABEL_COLOR,
-            strokeStyle: StrokeStyle.Solid,
-            strokeWidth: FLOW_STROKE_WIDTH,
-            frontEndpointStyle: PointStyle.None,
-            // The arrow points at what FOLLOWS, which is the target: the role's
-            // verb is "leads to", so the source is what happens first.
-            rearEndpointStyle: PointStyle.Arrow,
-        },
+        // the plain connector tool must keep the user's own style (#144 M1). It is
+        // the toolbox's (`eventStormingFlowStyle`, `docs/adr/0045`), so a flow
+        // drawn here and one built by a host look the same.
+        style: eventStormingFlowStyle(),
     });
     // The Event Storming palette stays open (native sub-menu behaviour): it only
     // closes on re-click of the senior button, another senior tool, or Escape.

package/dist/background.js

@@ -1,5 +1,5 @@
-import { ES_STICKIES, FONT_FAMILY } from '@formicoidea/labre-ddd-shared';
-import { NOTATION_NEUTRALS } from '@formicoidea/labre-core/shared/consts';
+import { ES_STICKIES, FONT_FAMILY, } from '@formicoidea/labre-ddd-shared/headless';
+import { NOTATION_NEUTRALS } from '@formicoidea/labre-core/shared/headless';
 import { ES_ROLE } from './roles.js';
 /**
  * The Event Storming board, DECLARED (the `FrameworkBackgroundDef` primitive).

package/dist/commands.js

@@ -1,10 +1,11 @@
-import { addSticky, esStickySeedKey, ES_HOTSPOT, ES_STICKIES, eventStormingToolbarIcon, LABEL_COLOR, placeDddElement, STICKY_SIZE, } from '@formicoidea/labre-ddd-shared';
+import { addSticky, esStickySeedKey, ES_HOTSPOT, ES_STICKIES, eventStormingToolbarIcon, LABEL_COLOR, placeDddElement, } from '@formicoidea/labre-ddd-shared';
 import { NOTATION_NEUTRALS } from '@formicoidea/labre-core/shared/consts';
 import { translateKey, } from '@formicoidea/labre-core/shared/services';
 import { GfxControllerIdentifier } from '@formicoidea/labre-core/std/gfx';
 import { svg } from 'lit';
 import { activateEventStormingFlow, createEventStormingBoard } from './actions.js';
 import { ES_ROLE, ES_STICKY_ROLE } from './roles.js';
+import { eventStormingStickyOpts } from './toolbox.js';
 /**
  * The automatic legend's own section titles — text stamped onto the board the
  * moment the legend is built, like any other seed, and declared HERE because
@@ -38,16 +39,6 @@ const squareSwatch = (color) => svg `<svg width="24" height="24" viewBox="0 0 24
 const diamondSwatch = (color) => svg `<svg width="24" height="24" viewBox="0 0 24 24"><rect x="6" y="6" width="12" height="12" transform="rotate(45 12 12)" fill="${color}"/></svg>`;
 const flowSwatch = svg `<svg width="24" height="24" viewBox="0 0 24 24" fill="none"><path d="M4 12 H18" stroke="currentColor" stroke-width="2"/><path d="M16 8 L20 12 L16 16" stroke="currentColor" stroke-width="2" fill="none"/></svg>`;
 const boardSwatch = svg `<svg width="24" height="24" viewBox="0 0 24 24" fill="none"><rect x="2.5" y="4" width="19" height="16" rx="2" fill="${NOTATION_NEUTRALS.cardFill}" stroke="currentColor" stroke-width="1.6"/><rect x="5" y="7.5" width="4" height="4" rx="1" fill="#F5963B"/><rect x="10.5" y="7.5" width="4" height="4" rx="1" fill="#5BA3DB"/><rect x="16" y="7.5" width="4" height="4" rx="1" fill="#FAF2C9" stroke="#c9bd7f" stroke-width="0.6"/><path d="M4.5 16.5 H19.5" stroke="currentColor" stroke-width="1.2"/><path d="M17.5 14.8 L19.8 16.5 L17.5 18.2" stroke="currentColor" stroke-width="1.2"/></svg>`;
-/**
- * The aggregate is created BIG — 160 against the standard 120.
- *
- * Size is half of how the notation distinguishes it: on a real wall the
- * aggregate is the large pale sticky a run of commands lands on, and the
- * colour ladder in `ES_STICKIES` carries the other half. Declared here rather
- * than in the shared palette because it is a FORMAT, not a colour: the palette
- * says which yellow, the toolbox says how big.
- */
-const AGGREGATE_SIZE = 160;
 const SPECS = [
     {
         id: 'addBoard',
@@ -66,20 +57,16 @@ const SPECS = [
         iconKey: `ddd-event-storming.sticky.${preset.kind}`,
         element: `sticky:${preset.kind}`,
         icon: squareSwatch(preset.fill),
-        run: std => placeDddElement(std, (surface, cx, cy) => addSticky(surface, std, cx, cy, {
-            fill: preset.fill,
-            text: preset.text,
-            // Translated HERE and once: the caption is document content the
-            // moment it lands (ADR 0023), so the host's catalogue is asked at
-            // placement and never again.
-            label: translateKey(std, esStickySeedKey(preset.kind), preset.label),
-            size: preset.kind === 'aggregate' ? AGGREGATE_SIZE : STICKY_SIZE,
-            // The role is what makes a sticky a domain EVENT rather than an
-            // orange square: every rule in `rules.ts` reads it, and a sticky
-            // placed before WS5 carries none and is never evaluated
-            // (promesse #71).
-            role: ES_STICKY_ROLE[preset.kind],
-        })),
+        run: std => placeDddElement(std, (surface, cx, cy) => addSticky(surface, std, cx, cy, 
+        // Colours, size (the aggregate is bigger) and role come from the
+        // toolbox (`docs/adr/0045`), the one assembly a host with no
+        // editor also calls. A sticky placed before WS5 carries no role
+        // and is never evaluated (promesse #71).
+        eventStormingStickyOpts(preset.kind, 
+        // Translated HERE and once: the caption is document content the
+        // moment it lands (ADR 0023), so the host's catalogue is asked
+        // at placement and never again.
+        translateKey(std, esStickySeedKey(preset.kind), preset.label)))),
         // Row and command out of the SAME preset, so the colour ladder the legend
         // shows is by construction the colour ladder on the wall — and a tenth
         // sticky kind gets its row with no edit.
@@ -95,16 +82,12 @@ const SPECS = [
         iconKey: 'ddd-event-storming.sticky.hotspot',
         element: 'sticky:hotspot',
         icon: diamondSwatch(ES_HOTSPOT.fill),
-        run: std => placeDddElement(std, (surface, cx, cy) => addSticky(surface, std, cx, cy, {
-            fill: ES_HOTSPOT.fill,
-            text: ES_HOTSPOT.text,
-            // Translated HERE and once, like every sticky above (ADR 0023).
-            label: translateKey(std, esStickySeedKey('hotspot'), ES_HOTSPOT.label),
-            shapeType: 'diamond',
-            // Typed like the rest, and cited by no grammar triplet on purpose —
-            // an arc onto a hotspot is a question being parked. See `rules.ts`.
-            role: ES_STICKY_ROLE.hotspot,
-        })),
+        run: std => placeDddElement(std, (surface, cx, cy) => addSticky(surface, std, cx, cy, 
+        // A diamond, typed like the rest and cited by no grammar triplet on
+        // purpose — an arc onto a hotspot is a question being parked. See
+        // `rules.ts`. Translated HERE and once, like every sticky above
+        // (ADR 0023).
+        eventStormingStickyOpts('hotspot', translateKey(std, esStickySeedKey('hotspot'), ES_HOTSPOT.label)))),
         // In its own preset, a diamond rather than a square, and therefore its own
         // row — appended after the eight by its `order` rather than by hand.
         legend: {

package/dist/index.d.ts

@@ -11,3 +11,5 @@ export { eventStormingSeniorTool } from './toolbar/senior-tool.js';
 export { EdgelessDddEventStormingSeniorButton } from './toolbar/senior-button.js';
 export { DddEventStormingRenderViewExtension, DddEventStormingViewExtension, } from './view.js';
 export { EVENT_STORMING_READING } from './reading.js';
+export { AGGREGATE_SIZE } from './sticky-size.js';
+export { EVENT_STORMING_TOOLBOX, eventStormingBoardElement, eventStormingFlowElement, eventStormingFlowStyle, eventStormingStickyElements, eventStormingStickyOpts, } from './toolbox.js';

package/dist/index.js

@@ -14,3 +14,6 @@ export { eventStormingSeniorTool } from './toolbar/senior-tool.js';
 export { EdgelessDddEventStormingSeniorButton } from './toolbar/senior-button.js';
 export { DddEventStormingRenderViewExtension, DddEventStormingViewExtension, } from './view.js';
 export { EVENT_STORMING_READING } from './reading.js';
+// The toolbar as pure builders (`docs/adr/0045`), also on `./interchange`.
+export { AGGREGATE_SIZE } from './sticky-size.js';
+export { EVENT_STORMING_TOOLBOX, eventStormingBoardElement, eventStormingFlowElement, eventStormingFlowStyle, eventStormingStickyElements, eventStormingStickyOpts, } from './toolbox.js';

package/dist/interchange-headless.d.ts

@@ -0,0 +1,10 @@
+/**
+ * `./interchange` — Event Storming with no editor behind it (ADR 0012, P3 as
+ * amended 2026-10-14): its toolbar as pure builders (`docs/adr/0045`), so a
+ * host with no editor (the Labre workspace connector, labre-mcp) places the
+ * very board, stickies, hotspots and flows a user places from the toolbar.
+ * Held by `interchange-headless.unit.spec.ts` in `packages/affine/all`, which
+ * bundles this entry and fails on any editor module in its graph.
+ */
+export { AGGREGATE_SIZE } from './sticky-size.js';
+export { EVENT_STORMING_TOOLBOX, eventStormingBoardElement, eventStormingFlowElement, eventStormingFlowStyle, eventStormingStickyElements, eventStormingStickyOpts, } from './toolbox.js';

package/dist/interchange-headless.js

@@ -0,0 +1,10 @@
+/**
+ * `./interchange` — Event Storming with no editor behind it (ADR 0012, P3 as
+ * amended 2026-10-14): its toolbar as pure builders (`docs/adr/0045`), so a
+ * host with no editor (the Labre workspace connector, labre-mcp) places the
+ * very board, stickies, hotspots and flows a user places from the toolbar.
+ * Held by `interchange-headless.unit.spec.ts` in `packages/affine/all`, which
+ * bundles this entry and fails on any editor module in its graph.
+ */
+export { AGGREGATE_SIZE } from './sticky-size.js';
+export { EVENT_STORMING_TOOLBOX, eventStormingBoardElement, eventStormingFlowElement, eventStormingFlowStyle, eventStormingStickyElements, eventStormingStickyOpts, } from './toolbox.js';

package/dist/roles.d.ts

@@ -1,4 +1,4 @@
-import { ES_STICKIES } from '@formicoidea/labre-ddd-shared';
+import { ES_STICKIES } from '@formicoidea/labre-ddd-shared/headless';
 import type { RoleDefs } from '@formicoidea/labre-core/std/gfx';
 /**
  * Event Storming role vocabulary (WS5).

package/dist/roles.js

@@ -1,4 +1,4 @@
-import { ES_HOTSPOT, ES_STICKIES } from '@formicoidea/labre-ddd-shared';
+import { ES_HOTSPOT, ES_STICKIES } from '@formicoidea/labre-ddd-shared/headless';
 /** camelCase → kebab-case, the WS2 derivation. */
 const kebab = (kind) => kind.replace(/[A-Z]/g, letter => `-${letter.toLowerCase()}`);
 /**

package/dist/sticky-size.d.ts

@@ -0,0 +1,16 @@
+/**
+ * The aggregate is created BIG — 160 against the standard 120.
+ *
+ * Size is half of how the notation distinguishes it: on a real wall the
+ * aggregate is the large pale sticky a run of commands lands on, and the
+ * colour ladder in `ES_STICKIES` carries the other half. Declared here rather
+ * than in the shared palette because it is a FORMAT, not a colour: the palette
+ * says which yellow, the toolbox says how big.
+ *
+ * Its own module, editor-free, so the toolbox (`toolbox.ts`, `docs/adr/0045`)
+ * builds a host's aggregate at the size the toolbar places it at; it lived in
+ * `commands.ts`, which imports the editor.
+ */
+export declare const AGGREGATE_SIZE = 160;
+/** The side of a sticky of `kind` as the toolbar places it. */
+export declare function eventStormingStickySize(kind: string): number;

package/dist/sticky-size.js

@@ -0,0 +1,19 @@
+import { STICKY_SIZE } from '@formicoidea/labre-ddd-shared/headless';
+/**
+ * The aggregate is created BIG — 160 against the standard 120.
+ *
+ * Size is half of how the notation distinguishes it: on a real wall the
+ * aggregate is the large pale sticky a run of commands lands on, and the
+ * colour ladder in `ES_STICKIES` carries the other half. Declared here rather
+ * than in the shared palette because it is a FORMAT, not a colour: the palette
+ * says which yellow, the toolbox says how big.
+ *
+ * Its own module, editor-free, so the toolbox (`toolbox.ts`, `docs/adr/0045`)
+ * builds a host's aggregate at the size the toolbar places it at; it lived in
+ * `commands.ts`, which imports the editor.
+ */
+export const AGGREGATE_SIZE = 160;
+/** The side of a sticky of `kind` as the toolbar places it. */
+export function eventStormingStickySize(kind) {
+    return kind === 'aggregate' ? AGGREGATE_SIZE : STICKY_SIZE;
+}

package/dist/toolbox.d.ts

@@ -0,0 +1,40 @@
+import { type FrameworkToolbox, type SerializedElementProps, type ToolboxPoint } from '@formicoidea/labre-core/interchange';
+import { type StickyOpts } from '@formicoidea/labre-ddd-shared/headless';
+import { PointStyle, StrokeStyle } from '@formicoidea/labre-core/model/headless';
+import { type EventStormingStickyKind } from './roles.js';
+/**
+ * What a sticky of `kind` is, as the prefab's options, its words `label`:
+ * the kind's colours, its size (the aggregate is bigger), its shape (the
+ * hotspot is a diamond) and its role, which is what makes it a domain EVENT
+ * rather than an orange square for every rule in `rules.ts`. The toolbar
+ * passes the seed in the host's language; a host with no editor its own words
+ * or the English seed.
+ */
+export declare function eventStormingStickyOpts(kind: EventStormingStickyKind, label: string): StickyOpts;
+/**
+ * A sticky of `kind` whose face is at `at`, named `name` or the toolbar's
+ * English seed: the shadow, the face carrying the role and the words, and
+ * their group, last.
+ */
+export declare function eventStormingStickyElements(kind: EventStormingStickyKind, at: ToolboxPoint, name?: string, local?: string): SerializedElementProps[];
+/** The board a storm is run on, at `at`. */
+export declare function eventStormingBoardElement(at: ToolboxPoint, local?: string): SerializedElementProps;
+/**
+ * How a flow is drawn: presentation only, the meaning is the role. A plain
+ * straight line with a rear arrowhead pointing at what FOLLOWS, which is the
+ * target: the role's verb is "leads to", so the source is what happens first.
+ */
+export declare function eventStormingFlowStyle(): {
+    stroke: string;
+    strokeStyle: StrokeStyle;
+    strokeWidth: number;
+    frontEndpointStyle: PointStyle;
+    rearEndpointStyle: PointStyle;
+};
+/**
+ * A flow from what happens first to what follows: the connector the Flow
+ * entry arms the tool with.
+ */
+export declare function eventStormingFlowElement(from: string, to: string, label?: string): SerializedElementProps;
+/** Every item of the Event Storming toolbar, in the toolbar's order. */
+export declare const EVENT_STORMING_TOOLBOX: FrameworkToolbox;

package/dist/toolbox.js

@@ -0,0 +1,142 @@
+import { backgroundSize, } from '@formicoidea/labre-core/interchange';
+import { ES_HOTSPOT, ES_STICKIES, LABEL_COLOR, stickyElements, } from '@formicoidea/labre-ddd-shared/headless';
+import { ConnectorMode, PointStyle, StrokeStyle, } from '@formicoidea/labre-core/model/headless';
+import { Bound } from '@formicoidea/labre-core/global/gfx';
+import { EVENT_STORMING_BACKGROUND } from './background.js';
+import { eventStormingCommandsManifest } from './commands-manifest.js';
+import { ES_ROLE, ES_STICKY_ROLE, } from './roles.js';
+import { eventStormingStickySize } from './sticky-size.js';
+/**
+ * The Event Storming toolbar as pure builders (`docs/adr/0045`): the board,
+ * the eight colour-coded stickies, the hotspot and the flow, with no editor
+ * behind them. A sticky is the very builder the palette's prefab writes
+ * (`stickyElements`, `@labre/affine-gfx-ddd-shared/headless`) with the options
+ * `commands.ts` passes it ({@link eventStormingStickyOpts}), and
+ * `createEventStormingBoard` and `activateEventStormingFlow` read the board
+ * and the flow's style from here, so a sticky drawn by a host and one placed
+ * from the toolbar are the same elements.
+ */
+/** Every flow is drawn this wide. */
+const FLOW_STROKE_WIDTH = 2;
+/** Each sticky kind's preset: the eight of the shared table, then the hotspot. */
+const STICKY_PRESETS = {
+    ...Object.fromEntries(ES_STICKIES.map(preset => [preset.kind, preset])),
+    hotspot: ES_HOTSPOT,
+};
+/** The sticky kinds in the toolbar's order: the shared table's, hotspot last. */
+const STICKY_KINDS = [
+    ...ES_STICKIES.map(preset => preset.kind),
+    'hotspot',
+];
+/**
+ * What a sticky of `kind` is, as the prefab's options, its words `label`:
+ * the kind's colours, its size (the aggregate is bigger), its shape (the
+ * hotspot is a diamond) and its role, which is what makes it a domain EVENT
+ * rather than an orange square for every rule in `rules.ts`. The toolbar
+ * passes the seed in the host's language; a host with no editor its own words
+ * or the English seed.
+ */
+export function eventStormingStickyOpts(kind, label) {
+    const { fill, text } = STICKY_PRESETS[kind];
+    return {
+        fill,
+        text,
+        label,
+        size: eventStormingStickySize(kind),
+        ...(kind === 'hotspot' ? { shapeType: 'diamond' } : {}),
+        role: ES_STICKY_ROLE[kind],
+    };
+}
+/** The item id of a sticky kind: its role's own slug (`external-system`…). */
+const stickyItemId = (kind) => ES_STICKY_ROLE[kind].slice('es:'.length);
+/**
+ * A sticky of `kind` whose face is at `at`, named `name` or the toolbar's
+ * English seed: the shadow, the face carrying the role and the words, and
+ * their group, last.
+ */
+export function eventStormingStickyElements(kind, at, name, local = stickyItemId(kind)) {
+    return stickyElements(at, eventStormingStickyOpts(kind, name?.trim() || STICKY_PRESETS[kind].label), local);
+}
+/** The board a storm is run on, at `at`. */
+export function eventStormingBoardElement(at, local = 'board') {
+    const { width, height } = backgroundSize(EVENT_STORMING_BACKGROUND);
+    return {
+        type: EVENT_STORMING_BACKGROUND.type,
+        id: local,
+        // The board is a first-class role: rules frame stickies against
+        // `es:board`, never against the `eventStorming` element type.
+        role: EVENT_STORMING_BACKGROUND.role,
+        resizeEnabled: EVENT_STORMING_BACKGROUND.geometry.resizable,
+        xywh: new Bound(at.x, at.y, width, height).serialize(),
+    };
+}
+/**
+ * How a flow is drawn: presentation only, the meaning is the role. A plain
+ * straight line with a rear arrowhead pointing at what FOLLOWS, which is the
+ * target: the role's verb is "leads to", so the source is what happens first.
+ */
+export function eventStormingFlowStyle() {
+    return {
+        stroke: LABEL_COLOR,
+        strokeStyle: StrokeStyle.Solid,
+        strokeWidth: FLOW_STROKE_WIDTH,
+        frontEndpointStyle: PointStyle.None,
+        rearEndpointStyle: PointStyle.Arrow,
+    };
+}
+/**
+ * A flow from what happens first to what follows: the connector the Flow
+ * entry arms the tool with.
+ */
+export function eventStormingFlowElement(from, to, label) {
+    return {
+        type: 'connector',
+        role: ES_ROLE.flow,
+        mode: ConnectorMode.Straight,
+        ...eventStormingFlowStyle(),
+        source: { id: from },
+        target: { id: to },
+        ...(label?.trim() ? { text: label.trim() } : {}),
+    };
+}
+/** The toolbar command's label, so a host names an item as the toolbar does. */
+function label(command) {
+    const id = `ddd-event-storming.${command}`;
+    const row = eventStormingCommandsManifest.find(r => r.id === id);
+    return {
+        labelKey: row?.labelKey ?? id,
+        labelFallback: row?.labelFallback ?? id,
+    };
+}
+const sticky = (kind) => {
+    const side = eventStormingStickySize(kind);
+    return {
+        id: stickyItemId(kind),
+        ...label(`add${kind[0]?.toUpperCase()}${kind.slice(1)}`),
+        texts: ['name'],
+        size: { w: side, h: side },
+        build: (at, texts, local) => eventStormingStickyElements(kind, at, texts?.name, local),
+    };
+};
+const BOARD_SIZE = backgroundSize(EVENT_STORMING_BACKGROUND);
+/** Every item of the Event Storming toolbar, in the toolbar's order. */
+export const EVENT_STORMING_TOOLBOX = {
+    framework: 'ddd-event-storming',
+    items: [
+        {
+            id: 'board',
+            ...label('addBoard'),
+            texts: [],
+            size: { w: BOARD_SIZE.width, h: BOARD_SIZE.height },
+            build: (at, _texts, local) => [eventStormingBoardElement(at, local)],
+        },
+        ...STICKY_KINDS.map(sticky),
+    ],
+    links: [
+        {
+            id: 'flow',
+            ...label('addFlow'),
+            build: (from, to, text) => eventStormingFlowElement(from, to, text),
+        },
+    ],
+};

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@formicoidea/labre-framework-ddd-event-storming",
   "description": "Labre ddd-event-storming framework for @formicoidea/labre-core.",
-  "version": "0.58.0",
+  "version": "0.60.0",
   "type": "module",
   "sideEffects": false,
   "author": "lajola",
@@ -25,14 +25,18 @@
     "./commands-manifest": {
       "types": "./dist/commands-manifest.d.ts",
       "import": "./dist/commands-manifest.js"
+    },
+    "./interchange": {
+      "types": "./dist/interchange-headless.d.ts",
+      "import": "./dist/interchange-headless.js"
     }
   },
   "files": [
     "dist"
   ],
   "dependencies": {
-    "@formicoidea/labre-core": "0.58.0",
-    "@formicoidea/labre-ddd-shared": "0.58.0",
+    "@formicoidea/labre-core": "0.60.0",
+    "@formicoidea/labre-ddd-shared": "0.60.0",
     "lit": "^3.2.0"
   }
 }