@formicoidea/labre-framework-ddd-event-storming 0.31.0 → 0.33.0

package/dist/actions.d.ts

@@ -0,0 +1,29 @@
+import type { GfxController } from '@formicoidea/labre-core/std/gfx';
+/** Create the board at the viewport centre, select it, return to the default tool. */
+export declare function createEventStormingBoard(gfx: GfxController): void;
+/**
+ * Activate the native connector tool, pre-styled and TYPED as a flow. The user
+ * then drags from what happens first to what follows, and the endpoints attach.
+ *
+ * ## Why this replaces the old palette entry
+ *
+ * Until WS5 the Flow entry dropped a 220-unit arrow at the viewport centre: a
+ * line between two points in mid-air, attached to nothing. It looked like the
+ * notation and said nothing — no rule could read its ends, and the user still
+ * had to drag both endpoints onto the stickies by hand.
+ *
+ * The gesture now IS the statement (`docs/adr/0010`): the tool announces which
+ * way to drag (the role's `gestureHint` — "drag from what happens first to what
+ * follows"), the drawn connector carries `es:flow`, and its endpoints are real
+ * element references. That is what makes both `es.against-timeline` and
+ * `es.forbidden-arc` possible at all.
+ *
+ * ## What the style says, and what the role says
+ *
+ * Style is presentation: a plain straight line with a rear arrowhead, which is
+ * exactly what the old drawing looked like, so a board mixing arcs drawn before
+ * and after WS5 still reads as one board. Meaning is the role, and only the
+ * role: restyling an arc never changes what it means, and an arc drawn before
+ * WS5 keeps its look and stays neutral.
+ */
+export declare function activateEventStormingFlow(gfx: GfxController): void;

package/dist/actions.js

@@ -0,0 +1,78 @@
+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 { EVENT_STORMING_BACKGROUND } from './background.js';
+import { ES_ROLE } from './roles.js';
+/**
+ * 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`).
+ */
+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(),
+    });
+    gfx.doc.captureSync();
+    gfx.tool.setTool(DefaultTool);
+    gfx.selection.set({ elements: [id], editing: false });
+}
+/**
+ * Activate the native connector tool, pre-styled and TYPED as a flow. The user
+ * then drags from what happens first to what follows, and the endpoints attach.
+ *
+ * ## Why this replaces the old palette entry
+ *
+ * Until WS5 the Flow entry dropped a 220-unit arrow at the viewport centre: a
+ * line between two points in mid-air, attached to nothing. It looked like the
+ * notation and said nothing — no rule could read its ends, and the user still
+ * had to drag both endpoints onto the stickies by hand.
+ *
+ * The gesture now IS the statement (`docs/adr/0010`): the tool announces which
+ * way to drag (the role's `gestureHint` — "drag from what happens first to what
+ * follows"), the drawn connector carries `es:flow`, and its endpoints are real
+ * element references. That is what makes both `es.against-timeline` and
+ * `es.forbidden-arc` possible at all.
+ *
+ * ## What the style says, and what the role says
+ *
+ * Style is presentation: a plain straight line with a rear arrowhead, which is
+ * exactly what the old drawing looked like, so a board mixing arcs drawn before
+ * and after WS5 still reads as one board. Meaning is the role, and only the
+ * role: restyling an arc never changes what it means, and an arc drawn before
+ * WS5 keeps its look and stays neutral.
+ */
+export function activateEventStormingFlow(gfx) {
+    gfx.tool.setTool(ConnectorTool, {
+        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 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.d.ts

@@ -0,0 +1,2 @@
+import type { FrameworkBackgroundDef } from '@formicoidea/labre-core/blocks/surface';
+export declare const EVENT_STORMING_BACKGROUND: FrameworkBackgroundDef;

package/dist/background.js

@@ -0,0 +1,138 @@
+import { ES_STICKIES, FONT_FAMILY } from '@formicoidea/labre-ddd-shared';
+import { ES_ROLE } from './roles.js';
+/**
+ * The Event Storming board, DECLARED (the `FrameworkBackgroundDef` primitive).
+ *
+ * ## One axis, and only one
+ *
+ * Time, running left to right along the bottom. That is the entire frame of
+ * reference Event Storming has, and declaring exactly it — no second axis, no
+ * zones, no graduations — is what makes `es.against-timeline` a real rule
+ * rather than a guess: a flow whose target sits to the LEFT of its source runs
+ * against the only direction this board means anything in.
+ *
+ * The vertical is deliberately unnamed. On a real wall it is where a workshop
+ * parks what it cannot place yet — a stack of hotspots above the frieze, a row
+ * of read models below it — and a tool that quietly turned "higher" into a
+ * scale would be inventing a semantic the framework does not have and then
+ * judging people against it.
+ *
+ * ## Swimlanes: cut from v1
+ *
+ * The v2 shape is written down in `EventStormingBoardElementModel`: lanes are a
+ * variant declaration plus a rule family that measures membership per band.
+ * Painting the bands without the rule would be the vertical semantic above,
+ * arrived at by accident.
+ *
+ * ## The palette
+ *
+ * The eight sticky colours, named. Nothing here paints them — the board is a
+ * white card with an axis on it — and that is what a declared REFERENCE looks
+ * like: the same precedent as the Wardley tone convention, so the day a
+ * `tone-convention` rule asks "is this sticky drawn in one of the notation's
+ * own colours" the answer is already written down, in one place, beside the
+ * card it belongs to.
+ */
+/** Ink for the frame itself: the axis line and the word beside it. */
+const AXIS_COLOR = '#6d6e71';
+const CARD_BORDER = '#d5d9e0';
+/**
+ * The one word this board writes on itself, and it is written BIG: 64 units
+ * (PO recette, 26/08/2026).
+ *
+ * Sixteen was chart-label size — right for a graduation, wrong for the only
+ * thing a 3200-wide roll declares. At the zoom where a whole Big Picture fits on
+ * screen the word vanished exactly like the hairline trait did before it was
+ * drawn at six; the title now reads at the same distance as the axis it names.
+ * Sized WITH the trait rather than beside it, and everything that has to make
+ * room for it — the bottom margin, the title's own offset — is derived from this
+ * number below.
+ */
+const AXIS_TEXT = { size: 64, color: '@axis' };
+/** The eight sticky fills, keyed by the kind the palette creates them under. */
+const STICKY_PALETTE = Object.fromEntries(ES_STICKIES.map(preset => [preset.kind, preset.fill]));
+export const EVENT_STORMING_BACKGROUND = {
+    type: 'eventStorming',
+    // The board is a first-class role: rules frame stickies against `es:board`,
+    // never against the `eventStorming` element type.
+    role: ES_ROLE.board,
+    geometry: {
+        // A Big Picture is WIDE — the timeline is the point — and it grows sideways
+        // all morning as events are remembered. Neither dimension is locked to the
+        // other and the handles are offered from the start, the opposite call from
+        // the Wardley map, which is a frame you place things on rather than a roll
+        // you unspool.
+        width: 3200,
+        height: 1400,
+        lockAspectRatio: false,
+        resizable: true,
+        // Room under the plot for the axis line and its word; the same inset
+        // elsewhere, so the roll reads as paper rather than as a chart.
+        //
+        // The bottom is the exception, and it is the WORD that sets it: a 64-unit
+        // title cannot be hung under a six-unit trait inside 56 units of paper —
+        // its cap height alone eats some 47 of them and its descender wants a dozen
+        // more. 104 is the title's offset below the trait plus a descender's worth
+        // of air, so the word sits between the trait and the card edge touching
+        // neither. Nothing else reads this number: the board declares no zones, and
+        // the stickies are placed by hand.
+        margin: { top: 32, right: 32, bottom: 104, left: 32 },
+    },
+    chrome: {
+        fontFamily: FONT_FAMILY,
+        palette: {
+            card: '#ffffff',
+            cardBorder: CARD_BORDER,
+            axis: AXIS_COLOR,
+            ...STICKY_PALETTE,
+        },
+        surface: {
+            fill: '@card',
+            border: { color: '@cardBorder', width: 1.5, radius: 12 },
+        },
+    },
+    axes: [
+        {
+            id: 'time',
+            orientation: 'horizontal',
+            // Along the bottom of the plot, under the frieze rather than through it.
+            at: 1,
+            // Forward is RIGHT: later. The one fact `es.against-timeline` reads.
+            arrow: 'forward',
+            // Drawn HEAVY, and deliberately heavier than any other axis in the
+            // library (PO recette, 26/08/2026). On a 3200-wide roll the timeline is
+            // not decoration beside the plot, it IS the frame of reference — the one
+            // thing the board declares and the one thing a rule measures against —
+            // and at the zoom where a whole Big Picture fits on screen a hairline
+            // simply disappears under the frieze. Six model units survive that.
+            //
+            // The head is sized WITH the line rather than left at its default: the
+            // renderer takes `arrowSize` as the head's LENGTH and spreads the base
+            // half that either side, so head width tracks head length. At 6× the
+            // stroke the triangle still reads as the end of this line and not as a
+            // separate mark — the same register as Wardley's 11-on-2, given room to
+            // scale up with the stroke.
+            arrowSize: 36,
+            stroke: { color: '@axis', width: 6 },
+            title: {
+                id: 'timeAxisTitle',
+                labelKey: 'com.labre.event-storming.background.axis.time',
+                fallback: 'Time',
+                // Pushed down with the SIZE, not just with the stroke.
+                //
+                // The renderer draws every background text on an `alphabetic`
+                // baseline, so `dy` positions the foot of the word and everything
+                // above it has to fit between the trait and that baseline: the trait
+                // grows three units below its centre (half of six) and the cap height
+                // of a 64-unit Inter is about 47. 72 clears both and leaves roughly the
+                // 23 units of air the 16-unit title used to have — the gap reads the
+                // same, it is simply no longer proportional to a word four times
+                // bigger. Below the baseline, the descender (~16) stops 16 units short
+                // of the 104-unit bottom margin, so the card edge is clear too.
+                anchor: { x: 1, y: 1, dx: -8, dy: 72 },
+                style: AXIS_TEXT,
+                align: 'right',
+            },
+        },
+    ],
+};

package/dist/commands.d.ts

@@ -0,0 +1,4 @@
+import type { CommandDescriptor } from '@formicoidea/labre-core/std';
+import { type TemplateResult } from 'lit';
+export declare const eventStormingCommands: CommandDescriptor[];
+export declare const eventStormingCommandIcons: Record<string, TemplateResult>;

package/dist/commands.js

@@ -0,0 +1,103 @@
+import { addSticky, ES_HOTSPOT, ES_STICKIES, placeDddElement, STICKY_SIZE, } from '@formicoidea/labre-ddd-shared';
+import { GfxControllerIdentifier } from '@formicoidea/labre-core/std/gfx';
+import { svg } from 'lit';
+import { activateEventStormingFlow, createEventStormingBoard } from './actions.js';
+import { ES_STICKY_ROLE } from './roles.js';
+/**
+ * The Event Storming palette as commands: the board, the eight colour-coded
+ * stickies, the hotspot and the flow. Declared once and read by the sub-menu,
+ * the keymap, Settings › Shortcuts, the catalogue and the agent
+ * (`docs/adr/0008`).
+ *
+ * Three entries changed shape in WS5 and not one telemetry value moved: the
+ * stickies now carry their role, the flow arms the connector tool instead of
+ * dropping a drawing, and the board is a new entry with a new `element` value.
+ */
+const squareSwatch = (color) => svg `<svg viewBox="0 0 24 24"><rect x="3" y="3" width="18" height="18" rx="3" fill="${color}"/></svg>`;
+const diamondSwatch = (color) => svg `<svg 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 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 viewBox="0 0 24 24" fill="none"><rect x="2.5" y="4" width="19" height="16" rx="2" fill="#ffffff" 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',
+        label: 'Event Storming board',
+        iconKey: 'ddd-event-storming.board',
+        // A NEW telemetry value: every other entry below keeps the `element` string
+        // it has emitted since ADR 0008.
+        element: 'board',
+        icon: boardSwatch,
+        run: std => createEventStormingBoard(std.get(GfxControllerIdentifier)),
+    },
+    ...ES_STICKIES.map((preset) => ({
+        id: `add${preset.kind[0].toUpperCase()}${preset.kind.slice(1)}`,
+        label: preset.label,
+        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,
+            label: 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],
+        })),
+    })),
+    {
+        id: 'addHotspot',
+        label: ES_HOTSPOT.label,
+        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,
+            label: 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,
+        })),
+    },
+    {
+        id: 'addFlow',
+        label: 'Flow',
+        iconKey: 'ddd-event-storming.flow',
+        element: 'flow',
+        icon: flowSwatch,
+        // No longer a placement: the entry arms the connector tool and the user
+        // DRAWS the flow between two stickies. See `activateEventStormingFlow` for
+        // why the free-floating arrow had to go. The telemetry value is untouched.
+        run: std => activateEventStormingFlow(std.get(GfxControllerIdentifier)),
+    },
+];
+export const eventStormingCommands = SPECS.map((spec, order) => ({
+    id: `ddd-event-storming.${spec.id}`,
+    owner: 'ddd-event-storming',
+    kind: 'artefact',
+    labelKey: `com.labre.commands.ddd-event-storming.${spec.id}`,
+    labelFallback: spec.label,
+    category: 'stickies',
+    iconKey: spec.iconKey,
+    surfaces: ['senior-menu', 'catalogue', 'palette', 'agent'],
+    order,
+    scope: 'edgeless',
+    defaultKeys: { mac: [], other: [] },
+    availability: 'always',
+    run: spec.run,
+    telemetry: { framework: 'ddd-event-storming', element: spec.element },
+}));
+export const eventStormingCommandIcons = Object.fromEntries(SPECS.map(spec => [spec.iconKey, spec.icon]));

package/dist/descriptor.d.ts

@@ -1,7 +1,12 @@
-import { DddEventStormingViewExtension } from './view.js';
+import { DddEventStormingRenderViewExtension, DddEventStormingViewExtension } from './view.js';
 /** Host wiring for the ddd-event-storming framework. */
 export declare const dddEventStormingFramework: {
     readonly flag: "ddd-event-storming";
-    readonly telemetry: "ddd-event-storming";
-    readonly viewExtension: typeof DddEventStormingViewExtension;
+    readonly telemetryKey: "event-storming";
+    readonly extensions: readonly [{
+        readonly viewExtension: typeof DddEventStormingRenderViewExtension;
+    }, {
+        readonly flag: "ddd-event-storming";
+        readonly viewExtension: typeof DddEventStormingViewExtension;
+    }];
 };

package/dist/descriptor.js

@@ -1,7 +1,10 @@
-import { DddEventStormingViewExtension } from './view.js';
+import { DddEventStormingRenderViewExtension, DddEventStormingViewExtension } from './view.js';
 /** Host wiring for the ddd-event-storming framework. */
 export const dddEventStormingFramework = {
     flag: 'ddd-event-storming',
-    telemetry: 'ddd-event-storming',
-    viewExtension: DddEventStormingViewExtension,
+    telemetryKey: 'event-storming',
+    extensions: [
+        { viewExtension: DddEventStormingRenderViewExtension },
+        { flag: 'ddd-event-storming', viewExtension: DddEventStormingViewExtension },
+    ],
 };

package/dist/element-renderer.d.ts

@@ -0,0 +1,17 @@
+import { type ElementRenderer } from '@formicoidea/labre-core/blocks/surface';
+import type { EventStormingBoardElementModel } from '@formicoidea/labre-core/model';
+/**
+ * Canvas renderer for the Event Storming board.
+ *
+ * There is no Event Storming drawing code: the board is an INSTANTIATION of the
+ * framework-background primitive, configured by the
+ * {@link EVENT_STORMING_BACKGROUND} declaration — a white card with one axis
+ * along the bottom.
+ *
+ * Exported as a function as well as an extension so a test can drive it with a
+ * canvas stub.
+ */
+export declare const eventStorming: ElementRenderer<EventStormingBoardElementModel>;
+export declare const EventStormingRendererExtension: import("@formicoidea/labre-core/store").ExtensionType & {
+    identifier: import("@formicoidea/labre-core/_pkgs/global/di").ServiceIdentifier<ElementRenderer<EventStormingBoardElementModel>>;
+};

package/dist/element-renderer.js

@@ -0,0 +1,15 @@
+import { createFrameworkBackgroundRenderer, ElementRendererExtension, } from '@formicoidea/labre-core/blocks/surface';
+import { EVENT_STORMING_BACKGROUND } from './background.js';
+/**
+ * Canvas renderer for the Event Storming board.
+ *
+ * There is no Event Storming drawing code: the board is an INSTANTIATION of the
+ * framework-background primitive, configured by the
+ * {@link EVENT_STORMING_BACKGROUND} declaration — a white card with one axis
+ * along the bottom.
+ *
+ * Exported as a function as well as an extension so a test can drive it with a
+ * canvas stub.
+ */
+export const eventStorming = createFrameworkBackgroundRenderer(EVENT_STORMING_BACKGROUND);
+export const EventStormingRendererExtension = ElementRendererExtension(EVENT_STORMING_BACKGROUND.type, eventStorming);

package/dist/element-view.d.ts

@@ -0,0 +1,18 @@
+import type { EventStormingBoardElementModel } from '@formicoidea/labre-core/model';
+import { GfxElementModelView } from '@formicoidea/labre-core/std/gfx';
+/**
+ * View for the Event Storming board. Registering it ensures `gfx.view.get(model)`
+ * returns a view (required so move / select interactions work).
+ *
+ * No double-click label editor, unlike the Wardley map: the only text on the
+ * card is the axis word, which the declaration owns and the model carries no
+ * prop for — there is nothing here the user edits in place.
+ */
+export declare class EventStormingView extends GfxElementModelView<EventStormingBoardElementModel> {
+    static type: string;
+}
+/**
+ * Resize gating, from the primitive: the handles follow `resizeEnabled`, which
+ * the declaration seeds to `true` — the roll is unspooled as the morning goes.
+ */
+export declare const EventStormingInteraction: import("@formicoidea/labre-core/store").ExtensionType;

package/dist/element-view.js

@@ -0,0 +1,19 @@
+import { FrameworkBackgroundInteractionExtension } from '@formicoidea/labre-core/blocks/surface';
+import { GfxElementModelView } from '@formicoidea/labre-core/std/gfx';
+import { EVENT_STORMING_BACKGROUND } from './background.js';
+/**
+ * View for the Event Storming board. Registering it ensures `gfx.view.get(model)`
+ * returns a view (required so move / select interactions work).
+ *
+ * No double-click label editor, unlike the Wardley map: the only text on the
+ * card is the axis word, which the declaration owns and the model carries no
+ * prop for — there is nothing here the user edits in place.
+ */
+export class EventStormingView extends GfxElementModelView {
+    static { this.type = 'eventStorming'; }
+}
+/**
+ * Resize gating, from the primitive: the handles follow `resizeEnabled`, which
+ * the declaration seeds to `true` — the roll is unspooled as the morning goes.
+ */
+export const EventStormingInteraction = FrameworkBackgroundInteractionExtension(EVENT_STORMING_BACKGROUND);

package/dist/index.d.ts

@@ -1,4 +1,11 @@
+export { eventStormingCommandIcons, eventStormingCommands, } from './commands.js';
+export { EVENT_STORMING_BACKGROUND } from './background.js';
+export { EVENT_STORMING_NUDGES } from './nudges.js';
+export { EVENT_STORMING_PROFILES } from './profiles.js';
+export { ES_ROLE, ES_STICKY_ROLE, EVENT_STORMING_ROLES, type EventStormingRoleId, type EventStormingStickyKind, } from './roles.js';
+export { ES_FLOW_MATRIX, EVENT_STORMING_RULES } from './rules.js';
+export { eventStormingTranslationEntries } from './translations.js';
 export { eventStormingTemplateCategory } from './templates.js';
 export { eventStormingSeniorTool } from './toolbar/senior-tool.js';
 export { EdgelessDddEventStormingSeniorButton } from './toolbar/senior-button.js';
-export { DddEventStormingViewExtension } from './view.js';
+export { DddEventStormingRenderViewExtension, DddEventStormingViewExtension, } from './view.js';

package/dist/index.js

@@ -1,4 +1,11 @@
+export { eventStormingCommandIcons, eventStormingCommands, } from './commands.js';
+export { EVENT_STORMING_BACKGROUND } from './background.js';
+export { EVENT_STORMING_NUDGES } from './nudges.js';
+export { EVENT_STORMING_PROFILES } from './profiles.js';
+export { ES_ROLE, ES_STICKY_ROLE, EVENT_STORMING_ROLES, } from './roles.js';
+export { ES_FLOW_MATRIX, EVENT_STORMING_RULES } from './rules.js';
+export { eventStormingTranslationEntries } from './translations.js';
 export { eventStormingTemplateCategory } from './templates.js';
 export { eventStormingSeniorTool } from './toolbar/senior-tool.js';
 export { EdgelessDddEventStormingSeniorButton } from './toolbar/senior-button.js';
-export { DddEventStormingViewExtension } from './view.js';
+export { DddEventStormingRenderViewExtension, DddEventStormingViewExtension, } from './view.js';

package/dist/legend.d.ts

@@ -0,0 +1,16 @@
+import { type AutoLegendSpec } from '@formicoidea/labre-ddd-shared';
+/**
+ * What the Event Storming board's automatic legend can say — a TABLE, and
+ * nothing else: the scan, the placement and the box are `createAutoLegend`'s
+ * job.
+ *
+ * Every row is DERIVED from the palette the stickies are drawn with
+ * ({@link ES_STICKIES}, {@link ES_HOTSPOT}) and from the role vocabulary's own
+ * labels, never restated — so the colour ladder the legend shows is by
+ * construction the colour ladder on the wall, and a tenth sticky kind added to
+ * `ES_STICKIES` gets its legend row with no edit.
+ *
+ * The hotspot is appended for the same reason `roles.ts` appends it: it lives in
+ * its own preset (a diamond, not a square) rather than in the table.
+ */
+export declare const EVENT_STORMING_AUTO_LEGEND: AutoLegendSpec;

package/dist/legend.js

@@ -0,0 +1,58 @@
+import { ES_HOTSPOT, ES_STICKIES, LABEL_COLOR, roleLabel, } from '@formicoidea/labre-ddd-shared';
+import { ES_ROLE, ES_STICKY_ROLE, EVENT_STORMING_ROLES } from './roles.js';
+/**
+ * What the Event Storming board's automatic legend can say — a TABLE, and
+ * nothing else: the scan, the placement and the box are `createAutoLegend`'s
+ * job.
+ *
+ * Every row is DERIVED from the palette the stickies are drawn with
+ * ({@link ES_STICKIES}, {@link ES_HOTSPOT}) and from the role vocabulary's own
+ * labels, never restated — so the colour ladder the legend shows is by
+ * construction the colour ladder on the wall, and a tenth sticky kind added to
+ * `ES_STICKIES` gets its legend row with no edit.
+ *
+ * The hotspot is appended for the same reason `roles.ts` appends it: it lives in
+ * its own preset (a diamond, not a square) rather than in the table.
+ */
+export const EVENT_STORMING_AUTO_LEGEND = {
+    title: 'Legend',
+    roles: EVENT_STORMING_ROLES,
+    sections: [
+        {
+            title: 'Stickies',
+            entries: [
+                ...ES_STICKIES.map(preset => ({
+                    role: ES_STICKY_ROLE[preset.kind],
+                    row: {
+                        swatch: 'square',
+                        color: preset.fill,
+                        label: preset.label,
+                    },
+                })),
+                {
+                    role: ES_STICKY_ROLE.hotspot,
+                    row: {
+                        swatch: 'square',
+                        color: ES_HOTSPOT.fill,
+                        label: ES_HOTSPOT.label,
+                    },
+                },
+            ],
+        },
+        {
+            title: 'Flow',
+            entries: [
+                {
+                    role: ES_ROLE.flow,
+                    row: {
+                        swatch: 'line',
+                        // The style `activateEventStormingFlow` arms the connector tool
+                        // with: a solid line in the label colour.
+                        color: LABEL_COLOR,
+                        label: roleLabel(EVENT_STORMING_ROLES, ES_ROLE.flow),
+                    },
+                },
+            ],
+        },
+    ],
+};

package/dist/nudges.d.ts

@@ -0,0 +1,26 @@
+import type { QualityNudge } from '@formicoidea/labre-core/blocks/surface';
+/**
+ * Event Storming **board quality** — the checklist (WS5, level 2).
+ *
+ * `./rules.ts` is level 1: deterministic, decidable, real time. This file is
+ * everything a board needs that no algorithm can decide. The split is the
+ * taxonomy's whole point — ticking is assuming, never verifying.
+ *
+ * ## The past tense lives HERE, and that was an arbitration
+ *
+ * "Order placed" is a domain event; "Place order" is a command. It is the first
+ * thing a facilitator corrects and the most tempting rule in the whole plan —
+ * and it is a nudge, by PO arbitration of 26/08/2026, because deciding it means
+ * parsing a human sentence. In whatever language the room speaks. Written in
+ * marker pen. By somebody who abbreviates. A regular expression over `Y.Text`
+ * would be wrong every fifth sticky, and a validation platform gets exactly one
+ * chance to be wrong about something the user can see is right.
+ *
+ * So it is a tick, and the tick is honest: it says the room LOOKED, which is
+ * what the facilitator wanted anyway.
+ *
+ * Registered from the flag-gated `DddEventStormingViewExtension`: a checklist
+ * is tooling. Switching the flag off takes it away and leaves the ticks written
+ * on the board, unread, until it comes back.
+ */
+export declare const EVENT_STORMING_NUDGES: readonly QualityNudge[];