@formicoidea/labre-framework-ddd-event-storming 0.32.0 → 0.34.1

package/dist/rules.js

@@ -0,0 +1,241 @@
+import { EVENT_STORMING_BACKGROUND } from './background.js';
+import { ES_ROLE, EVENT_STORMING_ROLES } from './roles.js';
+/**
+ * Event Storming validation rules (WS5).
+ *
+ * DATA owned by the framework, versioned per rule: the engine
+ * (`@labre/affine-block-surface`) knows how to evaluate a FAMILY, never a
+ * concrete rule. Registered from the flag-gated
+ * `DddEventStormingViewExtension`, so switching the Event Storming flag off
+ * removes them with the rest of the tooling — boards already stormed keep
+ * rendering, they simply stop being checked (`docs/adr/0009`).
+ *
+ * ## Three rules, and the ones that are deliberately absent
+ *
+ * Event Storming's grammar is small and its etiquette is large, and the two
+ * must not be confused. What is decidable here is the DIRECTION of the frieze,
+ * the SHAPE of an arc and whether two stickies are on top of each other.
+ *
+ * What is not, and is a level-2 nudge instead (`./nudges.ts`, PO arbitration of
+ * 26/08/2026): **the past tense**. "Order placed" is a domain event and "Place
+ * order" is a command, and every workshop gets that wrong for the first hour —
+ * but deciding it means parsing a human sentence, in whatever language the room
+ * speaks, written in marker pen by somebody who abbreviates. There are no
+ * linguistic rules in this file, on purpose. A checklist item that says "the
+ * events are named in the past tense" costs a tick and is true; a regular
+ * expression over `Y.Text` costs the tool's credibility and is wrong every
+ * fifth sticky.
+ */
+/**
+ * **ES1** — a flow runs forwards in time.
+ *
+ * The one rule the frame makes possible, and the reason the board declares an
+ * axis at all: the source of a flow is what happens FIRST (tier 1 of
+ * `docs/adr/0010`, the verb is "leads to"), so its target belongs to the RIGHT
+ * of it. A flow drawn the other way says the effect precedes the cause — either
+ * the arc was drawn from the wrong end, or the two stickies need swapping, and
+ * only the room knows which.
+ *
+ * ## The tolerance, and why it is tiny
+ *
+ * `0.01` of the board's width — 32 units on the 3200-wide reference, about a
+ * quarter of a sticky. Much tighter than the Wardley equivalent's 2 %, and for
+ * the opposite reason: on a Wardley map two components drawn level are a chain
+ * waiting to be spread out, whereas on a frieze two stickies drawn level are
+ * two things that happen at the same moment — which is a claim, not a
+ * placeholder — and an arc between them is the one that wants asking about.
+ * The tolerance is here to absorb a hand, not a habit: stickies stacked to
+ * within a few pixels stay silent, anything genuinely to the left does not.
+ *
+ * As with every other position in this engine it is a RATIO, so the verdict
+ * survives the roll being unspooled (the lesson of the 01/08/2026 recette).
+ *
+ * Silent, from the family: an arc with a free end, an arc between two different
+ * boards, an arc carrying no role, and an arc on a board that has no
+ * `es:board` element under it — a frieze stormed on the bare canvas is a
+ * frieze, and it has no timeline to run against.
+ */
+const againstTimeline = {
+    id: 'es.against-timeline',
+    framework: 'ddd-event-storming',
+    family: 'relative-order-along-axis',
+    severity: 'warning',
+    // No `appliesTo`: the subject is a RELATION, and the role that names it is
+    // declared where the family reads it — naming one of the three indicted
+    // elements here would be data that lies.
+    roles: EVENT_STORMING_ROLES,
+    messageKey: 'com.labre.event-storming.validation.against-timeline',
+    messageFallback: 'This flow runs backwards along the timeline.',
+    suggestionKey: 'com.labre.event-storming.validation.against-timeline.suggestion',
+    suggestionFallback: 'Time runs left to right: move what follows to the right of what leads to it — or, if the arc was drawn from the wrong end, reverse it.',
+    version: 1,
+    provenance: {
+        source: 'recommendation',
+        reference: 'Event Storming (Brandolini) — the frieze runs left to right in time',
+    },
+    backgroundRole: ES_ROLE.board,
+    background: EVENT_STORMING_BACKGROUND,
+    relativeOrder: {
+        edgeRole: ES_ROLE.flow,
+        axis: 'time',
+        // The verb is "leads to": the source happens first, so the TARGET is the
+        // one further along the axis' forward sense.
+        expect: 'target-ahead',
+        toleranceRatio: 0.01,
+    },
+};
+/**
+ * The canonical Event Storming sentence, as a matrix.
+ *
+ * Read aloud, which is how it was checked: an actor issues a command; a command
+ * lands on an aggregate, or on an external system; an aggregate raises a domain
+ * event, and so does an external system; a domain event triggers a policy, and
+ * a domain event feeds a read model; a policy issues a command; a read model
+ * informs an actor.
+ *
+ * Nine sentences and no more. Every one of them is in Brandolini's own picture
+ * of the "Big Picture → Process modelling" grammar, and nothing has been added
+ * because it seemed plausible: a matrix that sanctions a sentence the notation
+ * does not say is worse than no matrix, because the sentence it fails to catch
+ * is the one somebody will ship.
+ *
+ * Exported so a test asserts THIS table rather than a copy of it.
+ */
+export const ES_FLOW_MATRIX = [
+    { source: ES_ROLE.actor, edge: ES_ROLE.flow, target: ES_ROLE.command },
+    { source: ES_ROLE.command, edge: ES_ROLE.flow, target: ES_ROLE.aggregate },
+    { source: ES_ROLE.command, edge: ES_ROLE.flow, target: ES_ROLE.system },
+    {
+        source: ES_ROLE.aggregate,
+        edge: ES_ROLE.flow,
+        target: ES_ROLE.domainEvent,
+    },
+    { source: ES_ROLE.system, edge: ES_ROLE.flow, target: ES_ROLE.domainEvent },
+    { source: ES_ROLE.domainEvent, edge: ES_ROLE.flow, target: ES_ROLE.policy },
+    {
+        source: ES_ROLE.domainEvent,
+        edge: ES_ROLE.flow,
+        target: ES_ROLE.readModel,
+    },
+    { source: ES_ROLE.policy, edge: ES_ROLE.flow, target: ES_ROLE.command },
+    { source: ES_ROLE.readModel, edge: ES_ROLE.flow, target: ES_ROLE.actor },
+];
+/**
+ * **ES2** — a flow says one of the nine things the notation can say.
+ *
+ * The grammar rule, and the one that earns the framework its roles: a flow from
+ * a command straight to a domain event skips the aggregate, which is the whole
+ * modelling question Event Storming is run to answer. Reading it off the roles
+ * rather than off the colours means the verdict survives someone restyling a
+ * sticky, and reading it off `source → target` means it survives someone
+ * re-laying-out the wall.
+ *
+ * ## What it stays silent about, and why that is the rule
+ *
+ * **Hotspots and constraints are outside the alphabet.** Neither is cited by a
+ * triplet, so an arc with either at one end takes the whole edge out of the
+ * conversation — not the matrix, not the self-loop, nothing. That is the point
+ * of the family (`RelationEndpointsDef.allowed`) and it is the hard requirement
+ * for Event Storming in particular: a hotspot is a workshop saying "we do not
+ * know", and an arrow drawn at one is somebody parking a question. A tool that
+ * answered "that arc is forbidden" would be indicting the act of storming.
+ *
+ * The same silence covers an arc onto a plain rectangle, onto a note, onto an
+ * artefact of another framework, and every flow drawn before WS5 — those carry
+ * no role at all and are not even looked at.
+ *
+ * ## Self-loops yes, duplicates no
+ *
+ * A sticky leading to itself is not a sentence in this notation at whichever
+ * end you read it, so `forbidSelfLoop` is on.
+ *
+ * `forbidDuplicate` is deliberately OFF. Two flows between the same two
+ * stickies is what a wall looks like when a process has two paths to the same
+ * outcome and the room drew both; the frieze is read by following arcs, not by
+ * counting them, and a workshop is exactly where a line gets drawn twice while
+ * three people talk over each other. Nothing is lost by staying quiet — unlike
+ * a context map, where the same pattern twice between two contexts is a claim
+ * made twice.
+ */
+const forbiddenArc = {
+    id: 'es.forbidden-arc',
+    framework: 'ddd-event-storming',
+    family: 'relation-endpoints',
+    severity: 'warning',
+    roles: EVENT_STORMING_ROLES,
+    messageKey: 'com.labre.event-storming.validation.forbidden-arc',
+    messageFallback: 'This flow is not a sentence Event Storming says.',
+    suggestionKey: 'com.labre.event-storming.validation.forbidden-arc.suggestion',
+    suggestionFallback: 'The frieze reads: an actor issues a command, the command lands on an aggregate or an external system, and that raises a domain event, which triggers a policy or feeds a read model. Re-point the arc onto the sticky that is missing.',
+    version: 1,
+    provenance: {
+        source: 'recommendation',
+        reference: 'Event Storming (Brandolini) — the flow the big-picture notation draws',
+    },
+    backgroundRole: ES_ROLE.board,
+    background: EVENT_STORMING_BACKGROUND,
+    endpoints: {
+        edgeRole: ES_ROLE.flow,
+        allowed: ES_FLOW_MATRIX,
+        forbidSelfLoop: true,
+        // See the header: not on a wall.
+        selfLoop: {
+            messageKey: 'com.labre.event-storming.validation.flow-self-loop',
+            messageFallback: 'This flow loops back onto the sticky it starts from.',
+            suggestionKey: 'com.labre.event-storming.validation.flow-self-loop.suggestion',
+            suggestionFallback: 'Nothing leads to itself on a frieze — drop the loose end on what actually follows, or delete the arc.',
+        },
+    },
+};
+/**
+ * **ES3** — two stickies must not be on top of each other.
+ *
+ * A readability rule, not a semantic one, and the softest thing in the pack: a
+ * frieze you cannot read is useless, but a sticky nudged over its neighbour
+ * while somebody reorders the morning is not a mistake.
+ *
+ * Written on the PARENT role, which is what makes it one rule instead of
+ * thirty-six pairs: any two stickies hide each other, whichever kinds they are,
+ * and the tenth kind is covered on the day it lands.
+ *
+ * ## The threshold, and why it is wide
+ *
+ * **12 model units** — a tenth of the 120-unit sticky, against the 4 units
+ * Wardley uses for a node the size of a full stop. Stickies FRAME each other on
+ * a real wall: a workshop overlaps the corners of a run of events to say they
+ * belong together, tucks a policy under the event that triggers it, and shingles
+ * a stack of read models. At 4 units all of that would be reported, and the rule
+ * would be switched off by lunchtime. At 12 a deliberate tuck stays silent and a
+ * sticky genuinely covering another — half a label hidden — is still reported
+ * with an order of magnitude to spare.
+ */
+const overlappingStickies = {
+    id: 'es.overlapping-stickies',
+    framework: 'ddd-event-storming',
+    family: 'no-overlap',
+    severity: 'warning',
+    // No `appliesTo`: the subject is a PAIR, and naming one half of it here would
+    // be data that lies.
+    roles: EVENT_STORMING_ROLES,
+    messageKey: 'com.labre.event-storming.validation.overlapping-stickies',
+    messageFallback: 'These two stickies cover each other.',
+    suggestionKey: 'com.labre.event-storming.validation.overlapping-stickies.suggestion',
+    suggestionFallback: 'Slide one aside so both can be read.',
+    version: 1,
+    provenance: {
+        source: 'labre-convention',
+        reference: 'Labre readability convention — no Event Storming rule speaks of overlapping ink',
+    },
+    // Not a frame the rule measures against — an overlap is an overlap wherever
+    // it happens — but the board a finding is ATTRIBUTED to, so the arbitration
+    // "ignore this rule on the whole board" has one board to be written on.
+    backgroundRole: ES_ROLE.board,
+    overlap: [[ES_ROLE.sticky, ES_ROLE.sticky]],
+    // How deep a collision has to be before it is one. See the header.
+    minPenetration: 12,
+};
+export const EVENT_STORMING_RULES = [
+    againstTimeline,
+    forbiddenArc,
+    overlappingStickies,
+];

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

@@ -0,0 +1,29 @@
+import { type ToolbarContext } from '@formicoidea/labre-core/shared/services';
+/**
+ * The selected board's contextual toolbar: the resize toggle, and the automatic
+ * legend of the sticky kinds actually stuck to the board. Registered ALWAYS-ON
+ * (`DddEventStormingRenderViewExtension`) — a stored board must stay usable with
+ * the Event Storming button switched off (`docs/adr/0009`), legend included: a
+ * legend is real editable elements, so generating one is authoring a document,
+ * not tooling that a flag may take away.
+ *
+ * This is the module's ONLY legend gesture: the Event Storming palette never had
+ * a static Legend entry, and a wall of colour-coded stickies is exactly the
+ * board a reader needs one for.
+ */
+export declare const eventStormingBoardToolbarConfig: {
+    readonly actions: [{
+        readonly id: "a.toggle-resize";
+        readonly tooltipWording: import("@formicoidea/labre-core/shared/services").ChromeWording;
+        readonly icon: import("lit-html").TemplateResult<1>;
+        readonly active: (ctx: ToolbarContext) => boolean;
+        readonly run: (ctx: ToolbarContext) => void;
+    }, {
+        readonly id: "b.legend";
+        readonly tooltipWording: import("@formicoidea/labre-core/shared/services").ChromeWording;
+        readonly icon: import("lit-html").TemplateResult<1>;
+        readonly run: (ctx: ToolbarContext) => void;
+    }];
+    readonly when: (ctx: ToolbarContext) => boolean;
+};
+export declare const eventStormingBoardToolbarExtension: import("@formicoidea/labre-core/store").ExtensionType;

package/dist/toolbar/board-config.js

@@ -0,0 +1,86 @@
+import { EdgelessCRUDIdentifier } from '@formicoidea/labre-core/blocks/surface';
+import { createAutoLegend, dddLegendIcon } from '@formicoidea/labre-ddd-shared';
+import { EventStormingBoardElementModel } from '@formicoidea/labre-core/model';
+import { BOARD_LEGEND_NOTATION, BOARD_RESIZE_TOGGLE, TelemetryProvider, ToolbarModuleExtension, } from '@formicoidea/labre-core/shared/services';
+import { BlockFlavourIdentifier } from '@formicoidea/labre-core/std';
+import { html } from 'lit';
+import { EVENT_STORMING_AUTO_LEGEND } from '../legend.js';
+const ResizeIcon = html `<svg
+  width="24"
+  height="24"
+  viewBox="0 0 24 24"
+  fill="none"
+  stroke="currentColor"
+  stroke-width="1.6"
+  stroke-linecap="round"
+  stroke-linejoin="round"
+>
+  <path d="M9 5H5v4M15 19h4v-4" />
+  <path d="M5 5l6 6M19 19l-6-6" />
+</svg>`;
+/**
+ * The selected board's contextual toolbar: the resize toggle, and the automatic
+ * legend of the sticky kinds actually stuck to the board. Registered ALWAYS-ON
+ * (`DddEventStormingRenderViewExtension`) — a stored board must stay usable with
+ * the Event Storming button switched off (`docs/adr/0009`), legend included: a
+ * legend is real editable elements, so generating one is authoring a document,
+ * not tooling that a flag may take away.
+ *
+ * This is the module's ONLY legend gesture: the Event Storming palette never had
+ * a static Legend entry, and a wall of colour-coded stickies is exactly the
+ * board a reader needs one for.
+ */
+export const eventStormingBoardToolbarConfig = {
+    actions: [
+        {
+            id: 'a.toggle-resize',
+            tooltipWording: BOARD_RESIZE_TOGGLE,
+            icon: ResizeIcon,
+            active(ctx) {
+                const models = ctx.getSurfaceModelsByType(EventStormingBoardElementModel);
+                return models.length > 0 && models.every(model => model.resizeEnabled);
+            },
+            run(ctx) {
+                const models = ctx.getSurfaceModelsByType(EventStormingBoardElementModel);
+                if (!models.length)
+                    return;
+                const enable = !models.every(model => model.resizeEnabled);
+                ctx.std.store.captureSync();
+                const crud = ctx.std.get(EdgelessCRUDIdentifier);
+                for (const model of models) {
+                    crud.updateElement(model.id, { resizeEnabled: enable });
+                }
+            },
+        },
+        {
+            id: 'b.legend',
+            tooltipWording: BOARD_LEGEND_NOTATION,
+            icon: dddLegendIcon,
+            run(ctx) {
+                const board = ctx.getSurfaceModelsByType(EventStormingBoardElementModel)[0];
+                if (!board)
+                    return;
+                createAutoLegend(ctx.std, board, EVENT_STORMING_AUTO_LEGEND);
+                ctx.std
+                    .getOptional(TelemetryProvider)
+                    ?.track('FrameworkLegendCreated', {
+                    // The WIRE value, which is not the module id: the framework is
+                    // `ddd-event-storming` in code and `event-storming` in PostHog
+                    // (`frameworks.ts` `telemetryKey`, and the only value
+                    // `FrameworkElementEvent` accepts). Same convention as Wardley's own
+                    // legend button, so the two are comparable.
+                    framework: 'event-storming',
+                    element: 'legend',
+                    page: 'whiteboard editor',
+                    segment: 'element toolbar',
+                    module: 'event-storming toolbar',
+                });
+            },
+        },
+    ],
+    when: (ctx) => ctx.getSurfaceModelsByType(EventStormingBoardElementModel).length > 0,
+};
+export const eventStormingBoardToolbarExtension = ToolbarModuleExtension({
+    id: BlockFlavourIdentifier('affine:surface:eventStorming'),
+    config: eventStormingBoardToolbarConfig,
+});

package/dist/toolbar/event-storming-menu.d.ts

@@ -7,7 +7,7 @@ import { EdgelessCommandMenu } from '@formicoidea/labre-core/widgets/edgeless-to
  * helper — is gone with the duplication it carried (`docs/adr/0008`).
  *
  * The DDD palettes keep their tighter gap: they carry more buttons than the
- * other frameworks (Context Map: 12).
+ * other frameworks (Event Storming: 11, Context Map: 13).
  */
 export declare class EdgelessDddEventStormingMenu extends EdgelessCommandMenu {
     static styles: import("lit").CSSResultGroup[];

package/dist/toolbar/event-storming-menu.js

@@ -8,7 +8,7 @@ import { css } from 'lit';
  * helper — is gone with the duplication it carried (`docs/adr/0008`).
  *
  * The DDD palettes keep their tighter gap: they carry more buttons than the
- * other frameworks (Context Map: 12).
+ * other frameworks (Event Storming: 11, Context Map: 13).
  */
 export class EdgelessDddEventStormingMenu extends EdgelessCommandMenu {
     constructor() {

package/dist/toolbar/senior-button.d.ts

@@ -2,5 +2,6 @@ import { DddSeniorButtonBase } from '@formicoidea/labre-ddd-shared';
 export declare class EdgelessDddEventStormingSeniorButton extends DddSeniorButtonBase {
     protected menuTag: "edgeless-ddd-event-storming-menu";
     protected label: string;
+    protected labelKey: string;
     protected icon: import("lit-html").TemplateResult<2>;
 }

package/dist/toolbar/senior-button.js

@@ -4,6 +4,7 @@ export class EdgelessDddEventStormingSeniorButton extends DddSeniorButtonBase {
         super(...arguments);
         this.menuTag = 'edgeless-ddd-event-storming-menu';
         this.label = 'Event Storming';
+        this.labelKey = 'com.labre.framework.ddd-event-storming';
         this.icon = eventStormingToolbarIcon;
     }
 }

package/dist/toolbar/senior-tool.js

@@ -3,6 +3,7 @@ import { html } from 'lit';
 /** Independent senior tool — Event Storming. */
 export const eventStormingSeniorTool = SeniorToolExtension('ddd-event-storming', ({ block }) => ({
     name: 'Event Storming',
+    labelKey: 'com.labre.framework.ddd-event-storming',
     content: html `<edgeless-ddd-event-storming-senior-button
       .edgeless=${block}
     ></edgeless-ddd-event-storming-senior-button>`,

package/dist/translations.d.ts

@@ -1,12 +1,14 @@
 import { type TranslationKeyManifestEntry } from '@formicoidea/labre-core/std';
 /**
- * THIS framework's contribution to the translation-key manifest.
+ * THIS framework's contribution to the translation-key manifest — every
+ * `com.labre.*` key Event Storming can hand to `TranslationProvider.t`,
+ * derived from the very declarations the editor registers (never restated).
  *
  * Its command labels and descriptions are built from a TEMPLATE, so the
- * concrete keys exist nowhere but in the declarations themselves and the
- * core manifest could not restate them even if it wanted to. The
- * contribution therefore ships WITH the framework: in the bundled
- * distribution `@formicoidea/labre-framework-ddd-event-storming` carries it, and a host
+ * concrete keys exist nowhere but in the declarations themselves and the core
+ * manifest could not restate them even if it wanted to. The contribution
+ * therefore ships WITH the framework: in the bundled distribution
+ * `@formicoidea/labre-framework-ddd-event-storming` carries it, and a host
  * composes it into its catalogue exactly as it already composes
  * `eventStormingCommands` into the command registry. See
  * `packages/affine/all/src/translations.ts`.

package/dist/translations.js

@@ -1,15 +1,28 @@
-import { commandTranslationEntries, } from '@formicoidea/labre-core/std';
+import { collectTranslationKeys, commandCategoryTranslationEntries, commandTranslationEntries, mergeTranslationEntries, } from '@formicoidea/labre-core/std';
+import { EVENT_STORMING_BACKGROUND } from './background.js';
 import { eventStormingCommands } from './commands.js';
+import { EVENT_STORMING_NUDGES } from './nudges.js';
+import { EVENT_STORMING_PROFILES } from './profiles.js';
+import { EVENT_STORMING_ROLES } from './roles.js';
+import { EVENT_STORMING_RULES } from './rules.js';
 /**
- * THIS framework's contribution to the translation-key manifest.
+ * THIS framework's contribution to the translation-key manifest — every
+ * `com.labre.*` key Event Storming can hand to `TranslationProvider.t`,
+ * derived from the very declarations the editor registers (never restated).
  *
  * Its command labels and descriptions are built from a TEMPLATE, so the
- * concrete keys exist nowhere but in the declarations themselves and the
- * core manifest could not restate them even if it wanted to. The
- * contribution therefore ships WITH the framework: in the bundled
- * distribution `@formicoidea/labre-framework-ddd-event-storming` carries it, and a host
+ * concrete keys exist nowhere but in the declarations themselves and the core
+ * manifest could not restate them even if it wanted to. The contribution
+ * therefore ships WITH the framework: in the bundled distribution
+ * `@formicoidea/labre-framework-ddd-event-storming` carries it, and a host
  * composes it into its catalogue exactly as it already composes
  * `eventStormingCommands` into the command registry. See
  * `packages/affine/all/src/translations.ts`.
  */
-export const eventStormingTranslationEntries = commandTranslationEntries(eventStormingCommands);
+export const eventStormingTranslationEntries = mergeTranslationEntries(commandTranslationEntries(eventStormingCommands), 
+// 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(eventStormingCommands), collectTranslationKeys('role', EVENT_STORMING_ROLES), collectTranslationKeys('background', EVENT_STORMING_BACKGROUND), collectTranslationKeys('rule', EVENT_STORMING_RULES), collectTranslationKeys('nudge', EVENT_STORMING_NUDGES), collectTranslationKeys('profile', EVENT_STORMING_PROFILES));

package/dist/view.d.ts

@@ -1,6 +1,22 @@
 import { type ViewExtensionContext, ViewExtensionProvider } from '@formicoidea/labre-core/ext-loader';
 /**
- * Event Storming — independently flag-gated (`ddd-event-storming`).
+ * Event Storming rendering — ALWAYS registered, independent of any flag.
+ * Disabling `ddd-event-storming` hides only the creation tooling (see
+ * {@link DddEventStormingViewExtension}); boards already stormed must still
+ * paint, stay selectable, stay movable and keep their contextual toolbar. See
+ * `docs/adr/0009`.
+ */
+export declare class DddEventStormingRenderViewExtension extends ViewExtensionProvider {
+    name: string;
+    setup(context: ViewExtensionContext): void;
+}
+/**
+ * Event Storming creation tooling — independently flag-gated
+ * (`ddd-event-storming`): the senior toolbar button, its palette and the
+ * validation rules, profiles and quality nudges. Both halves are tooling: a
+ * board stormed while the flag was on keeps rendering when it goes off, it just
+ * stops being checked — and the profile it was put on stays written, unread,
+ * until the flag comes back.
  *
  * Note: its Templates-panel category is registered by the aggregate package's
  * {@link DddTemplatesViewExtension} (gated by `ddd-templates`), so templates

package/dist/view.js

@@ -1,10 +1,54 @@
+import { QualityNudgeExtension, validationToolbarConfig, ValidationProfileExtension, ValidationRuleExtension, } from '@formicoidea/labre-core/blocks/surface';
 import { ViewExtensionProvider, } from '@formicoidea/labre-core/ext-loader';
-import { CommandExtension } from '@formicoidea/labre-core/std';
-import { eventStormingCommandIcons, eventStormingCommands, } from './commands.js';
+import { ToolbarModuleExtension } from '@formicoidea/labre-core/shared/services';
+import { BlockFlavourIdentifier, CommandExtension } from '@formicoidea/labre-core/std';
+import { RoleVocabularyExtension } from '@formicoidea/labre-core/std/gfx';
+import { eventStormingCommandIcons, eventStormingCommands } from './commands.js';
 import { eventStormingEffects } from './effects.js';
+import { EventStormingRendererExtension } from './element-renderer.js';
+import { EventStormingInteraction, EventStormingView } from './element-view.js';
+import { EVENT_STORMING_NUDGES } from './nudges.js';
+import { EVENT_STORMING_PROFILES } from './profiles.js';
+import { EVENT_STORMING_ROLES } from './roles.js';
+import { EVENT_STORMING_RULES } from './rules.js';
+import { eventStormingBoardToolbarExtension } from './toolbar/board-config.js';
 import { eventStormingSeniorTool } from './toolbar/senior-tool.js';
 /**
- * Event Storming — independently flag-gated (`ddd-event-storming`).
+ * Event Storming rendering — ALWAYS registered, independent of any flag.
+ * Disabling `ddd-event-storming` hides only the creation tooling (see
+ * {@link DddEventStormingViewExtension}); boards already stormed must still
+ * paint, stay selectable, stay movable and keep their contextual toolbar. See
+ * `docs/adr/0009`.
+ */
+export class DddEventStormingRenderViewExtension extends ViewExtensionProvider {
+    constructor() {
+        super(...arguments);
+        this.name = 'affine-ddd-event-storming-render-gfx';
+    }
+    setup(context) {
+        super.setup(context);
+        context.register(EventStormingView);
+        context.register(EventStormingRendererExtension);
+        // The role VOCABULARY, always on. A role is written in the DOCUMENT, not in
+        // the tooling: the direction reveal of a typed flow, the inversion command
+        // and the toolbar entry that must not lie about one all read this, and they
+        // have to keep working on a board stormed while the flag was on and opened
+        // while it is off (`docs/adr/0009`, `docs/adr/0010`). The rules that JUDGE
+        // those roles stay in the flag-gated extension below.
+        context.register(RoleVocabularyExtension(EVENT_STORMING_ROLES));
+        if (this.isEdgeless(context.scope)) {
+            context.register(EventStormingInteraction);
+            context.register(eventStormingBoardToolbarExtension);
+        }
+    }
+}
+/**
+ * Event Storming creation tooling — independently flag-gated
+ * (`ddd-event-storming`): the senior toolbar button, its palette and the
+ * validation rules, profiles and quality nudges. Both halves are tooling: a
+ * board stormed while the flag was on keeps rendering when it goes off, it just
+ * stops being checked — and the profile it was put on stays written, unread,
+ * until the flag comes back.
  *
  * Note: its Templates-panel category is registered by the aggregate package's
  * {@link DddTemplatesViewExtension} (gated by `ddd-templates`), so templates
@@ -22,6 +66,20 @@ export class DddEventStormingViewExtension extends ViewExtensionProvider {
     setup(context) {
         super.setup(context);
         if (this.isEdgeless(context.scope)) {
+            context.register(ValidationRuleExtension(EVENT_STORMING_RULES));
+            context.register(ValidationProfileExtension(EVENT_STORMING_PROFILES));
+            context.register(QualityNudgeExtension(EVENT_STORMING_NUDGES));
+            // The Validation dropdown on a selected board's contextual toolbar. A
+            // SECOND module on the same element, through the `custom:` flavour slot:
+            // `eventStormingBoardToolbarExtension` is registered always-on because a
+            // stored board must keep its resize toggle, while choosing how hard to
+            // check it is tooling and belongs here. The config names no framework —
+            // it reads roles and profiles — so it is the very same object Wardley
+            // registers on its own flavour.
+            context.register(ToolbarModuleExtension({
+                id: BlockFlavourIdentifier('custom:affine:surface:eventStorming'),
+                config: validationToolbarConfig,
+            }));
             context.register(eventStormingSeniorTool);
             context.register(CommandExtension(eventStormingCommands, eventStormingCommandIcons));
         }

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.32.0",
+  "version": "0.34.1",
   "type": "module",
   "sideEffects": false,
   "author": "lajola",
@@ -21,14 +21,18 @@
     "./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.32.0",
-    "@formicoidea/labre-ddd-shared": "0.32.0",
+    "@formicoidea/labre-core": "0.34.1",
+    "@formicoidea/labre-ddd-shared": "0.34.1",
     "lit": "^3.2.0"
   }
 }