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

package/dist/profiles.js

@@ -0,0 +1,121 @@
+/**
+ * Event Storming validation profiles (WS5).
+ *
+ * DATA owned by the framework, like its rules and its roles. A profile is
+ * chosen per BOARD, not per document, and the choice rides on the board element
+ * itself — a Big Picture and a Process-modelling board coexist on one canvas at
+ * two levels of requirement, which is precisely how the workshop goes.
+ *
+ * ## Three, and why three (PO arbitration, 26/08/2026)
+ *
+ * Every other framework in this library ships two. Event Storming gets three
+ * because it is not one activity, it is a SEQUENCE of them, and the same wall
+ * means different things at each stage:
+ *
+ * 1. **Big Picture (Sketch)** — everything on the wall at once, out of order,
+ *    the grammar not yet decided. The linter must be silent;
+ * 2. **Process modelling** — the frieze gets read left to right and reordered.
+ *    Time starts to mean something; the grammar still does not;
+ * 3. **Software design** — the sentences are supposed to be sentences.
+ *
+ * Two profiles would have forced stage 2 to pick a side: either the timeline
+ * goes unchecked through the very session that is about ordering it, or the
+ * grammar starts firing at a wall that has not been cleaned up yet. The middle
+ * profile exists because the middle stage exists.
+ *
+ * Registered from the flag-gated `DddEventStormingViewExtension`, beside the
+ * rules: switching the flag off takes the choice away with the rest of the
+ * tooling, and a board already set to `design` simply stops being checked until
+ * it comes back — the id stays written, untouched.
+ */
+/**
+ * Sketch — the Big Picture. Every rule demoted to `audit`: findings still reach
+ * `violations$` for a host panel and a conformance report, and the canvas says
+ * nothing.
+ *
+ * Named **"Big Picture (Sketch)"** in the dropdown, both words on purpose (PO
+ * recette, 26/08/2026). "Sketch" is the vocabulary every framework in this
+ * library shares for its quietest level, and it is the word the recette script
+ * uses; "Big Picture" is the word the workshop uses for this stage and the only
+ * one a facilitator would look for. Carrying both is what lets the two readings
+ * meet on one entry instead of the user having to learn which name this
+ * framework chose.
+ *
+ * The DEFAULT, and more deliberately here than anywhere else in the library. A
+ * Big Picture is **supposed to be chaotic**: that is the method, not a failure
+ * of it. Events go up out of order because remembering is not sorting, arcs get
+ * drawn between things nobody has typed yet, and stickies get stacked three
+ * deep while a stack is what somebody means. A tool arguing with that hand is
+ * not strict, it is wrong — it is judging a stage of the workshop by the
+ * criteria of a later one.
+ *
+ * Being the default also means it WRITES NOTHING: a board on `sketch` carries no
+ * profile key, so every board ever stormed is on it, with no migration and no
+ * backfill.
+ */
+const sketch = {
+    id: 'es.sketch',
+    framework: 'ddd-event-storming',
+    labelKey: 'com.labre.event-storming.profile.sketch',
+    fallback: 'Big Picture (Sketch)',
+    isDefault: true,
+    rules: {
+        'es.against-timeline': 'audit',
+        'es.forbidden-arc': 'audit',
+        'es.overlapping-stickies': 'audit',
+    },
+};
+/**
+ * Process — the frieze is being read left to right and reordered.
+ *
+ * The timeline is the ONLY thing promoted, because ordering the frieze is
+ * exactly what this stage is for: an arc running backwards is now the finding
+ * the session is looking for, and the tool pointing at it is the tool helping.
+ *
+ * The grammar stays at `audit`, on purpose. The wall is still full of stickies
+ * whose kind nobody has settled — an event that is going to turn out to be a
+ * command, a read model somebody drew as an aggregate — and firing
+ * `forbidden-arc` at that is arguing about a sentence whose words are still
+ * being chosen. Overlaps stay quiet for the same reason: things are being
+ * MOVED, and everything overlaps while it is being moved.
+ */
+const process = {
+    id: 'es.process',
+    framework: 'ddd-event-storming',
+    labelKey: 'com.labre.event-storming.profile.process',
+    fallback: 'Process modelling',
+    rules: {
+        'es.against-timeline': 'warning',
+        'es.forbidden-arc': 'audit',
+        'es.overlapping-stickies': 'audit',
+    },
+};
+/**
+ * Design — the deliverable level: a board that leaves the room and is read by
+ * somebody who was not in it.
+ *
+ * All three at `warning`. By this stage every sticky has a kind, every arc is a
+ * claim about the model, and a frieze nobody can read is a frieze that will be
+ * misread. Every severity is spelled out rather than left absent, so the answer
+ * is readable in one place.
+ *
+ * Nothing here is `blocking-overridable`: nothing in this library implements
+ * refusal, and declaring it would be data claiming an effect that does not
+ * exist.
+ */
+const design = {
+    id: 'es.design',
+    framework: 'ddd-event-storming',
+    labelKey: 'com.labre.event-storming.profile.design',
+    fallback: 'Software design',
+    rules: {
+        'es.against-timeline': 'warning',
+        'es.forbidden-arc': 'warning',
+        'es.overlapping-stickies': 'warning',
+    },
+};
+export const EVENT_STORMING_PROFILES = [
+    sketch,
+    process,
+    design,
+];

package/dist/roles.d.ts

@@ -0,0 +1,62 @@
+import { ES_STICKIES } from '@formicoidea/labre-ddd-shared';
+import type { RoleDefs } from '@formicoidea/labre-core/std/gfx';
+/**
+ * Event Storming role vocabulary (WS5).
+ *
+ * A role is the semantic identity of an artefact — no rule will ever look at a
+ * shape type or at a fill colour. Three families:
+ *
+ * - the **board** (`es:board`), the paper roll the storm is run on;
+ * - the **sticky** (`es:sticky`), parent of the nine kinds the notation has;
+ * - the **flow** (`es:flow`), the edge that says one thing leads to another.
+ *
+ * ## Why a sticky PARENT
+ *
+ * Because two of the three rules are written on it and neither wants to know
+ * about the nine. `es.overlapping-stickies` is a readability rule — any two
+ * stickies on top of each other are unreadable, whichever kinds they are — and
+ * the day a tenth kind lands it is covered without a line changing.
+ * Specialisation is DATA (`parent`), read by `roleIsA`.
+ *
+ * ## The alphabet is smaller than the vocabulary
+ *
+ * All nine kinds get a role; only seven of them appear in the grammar
+ * (`es.forbidden-arc`). The **hotspot** and the **constraint** are declared here
+ * and cited by no triplet, deliberately: a hotspot is the workshop saying "we do
+ * not know", and a flow drawn onto one is somebody parking a question, not
+ * making a claim. Being outside the alphabet takes the whole edge out of the
+ * conversation (see `RelationEndpointsDef.allowed`), which is exactly the
+ * proportionality the family was built for.
+ *
+ * ## Compat
+ *
+ * Nothing is backfilled. Stickies placed before these roles existed carry none
+ * and are never evaluated (promesse #71): they stay drawings, in the documents
+ * they are in.
+ */
+/** The sticky kinds as used at the creation sites, hotspot included. */
+export type EventStormingStickyKind = (typeof ES_STICKIES)[number]['kind'] | 'hotspot';
+export type EventStormingRoleId = `es:${string}`;
+/**
+ * Role id per sticky kind, DERIVED from the shared preset table rather than
+ * restated — so the day a tenth sticky lands in `ES_STICKIES` it gets its role
+ * here with no edit. The hotspot is appended because it lives in its own preset
+ * (`ES_HOTSPOT`, a diamond rather than a square) and not in the table.
+ */
+export declare const ES_STICKY_ROLE: Record<EventStormingStickyKind, EventStormingRoleId>;
+/** The three roles that are not a sticky kind, plus the nine that are. */
+export declare const ES_ROLE: {
+    readonly domainEvent: `es:${string}`;
+    readonly command: `es:${string}`;
+    readonly aggregate: `es:${string}`;
+    readonly actor: `es:${string}`;
+    readonly constraint: `es:${string}`;
+    readonly policy: `es:${string}`;
+    readonly readModel: `es:${string}`;
+    readonly system: `es:${string}`;
+    readonly hotspot: `es:${string}`;
+    readonly board: "es:board";
+    readonly sticky: "es:sticky";
+    readonly flow: "es:flow";
+};
+export declare const EVENT_STORMING_ROLES: RoleDefs;

package/dist/roles.js

@@ -0,0 +1,84 @@
+import { ES_HOTSPOT, ES_STICKIES } from '@formicoidea/labre-ddd-shared';
+/** camelCase → kebab-case, the WS2 derivation. */
+const kebab = (kind) => kind.replace(/[A-Z]/g, letter => `-${letter.toLowerCase()}`);
+/**
+ * The one kind whose role id is not its kind kebab-cased.
+ *
+ * `system` is what the palette has called the sticky since the tool shipped and
+ * what its telemetry emits; `external-system` is what Event Storming calls the
+ * thing, and it is the word a rule and a hover reveal have to say. Renaming the
+ * kind would move a telemetry value (ADR 0008 forbids it) and renaming the role
+ * would make the grammar read `command → system`, which is not a sentence
+ * anybody says. One entry in a table is the cost of keeping both right.
+ */
+const ROLE_SLUG = {
+    system: 'external-system',
+};
+const slug = (kind) => ROLE_SLUG[kind] ?? kebab(kind);
+/**
+ * Role id per sticky kind, DERIVED from the shared preset table rather than
+ * restated — so the day a tenth sticky lands in `ES_STICKIES` it gets its role
+ * here with no edit. The hotspot is appended because it lives in its own preset
+ * (`ES_HOTSPOT`, a diamond rather than a square) and not in the table.
+ */
+export const ES_STICKY_ROLE = Object.fromEntries([
+    ...ES_STICKIES.map(preset => [preset.kind, `es:${slug(preset.kind)}`]),
+    ['hotspot', 'es:hotspot'],
+]);
+/** The three roles that are not a sticky kind, plus the nine that are. */
+export const ES_ROLE = {
+    board: 'es:board',
+    sticky: 'es:sticky',
+    flow: 'es:flow',
+    ...ES_STICKY_ROLE,
+};
+/** Human label per kind, from the same presets the palette renders. */
+const STICKY_LABEL = {
+    ...Object.fromEntries(ES_STICKIES.map(preset => [preset.kind, preset.label])),
+    hotspot: ES_HOTSPOT.label,
+};
+const DEFS = [
+    // The board: a frame, not a sticky. It specialises nothing, so a rule written
+    // on `es:sticky` can never fall on the roll its subjects are stuck to.
+    {
+        id: ES_ROLE.board,
+        kind: 'node',
+        labelKey: 'com.labre.event-storming.role.board',
+        labelFallback: 'Event Storming board',
+    },
+    {
+        id: ES_ROLE.sticky,
+        kind: 'node',
+        labelKey: 'com.labre.event-storming.role.sticky',
+        labelFallback: 'Sticky',
+    },
+    ...Object.keys(STICKY_LABEL).map((kind) => ({
+        id: ES_STICKY_ROLE[kind],
+        parent: ES_ROLE.sticky,
+        kind: 'node',
+        labelKey: `com.labre.event-storming.role.${slug(kind)}`,
+        labelFallback: STICKY_LABEL[kind],
+    })),
+    /**
+     * The flow. Tier 1 of `docs/adr/0010`: the source is the subject of the verb,
+     * so the source is what happens FIRST. Everything downstream of that sentence
+     * — the tool hint, the hover reveal, the inversion command and
+     * `es.against-timeline` — reads this one declaration and never a framework
+     * name.
+     */
+    {
+        id: ES_ROLE.flow,
+        kind: 'edge',
+        labelKey: 'com.labre.event-storming.role.flow',
+        labelFallback: 'Flow',
+        direction: {
+            verbKey: 'com.labre.event-storming.role.flow.verb',
+            verbFallback: 'leads to',
+            gestureHintKey: 'com.labre.event-storming.role.flow.gesture',
+            gestureHintFallback: 'Drag from what happens first to what follows.',
+        },
+    },
+];
+// Null prototype: this is a lookup table keyed by ids that may one day come
+// from host-supplied packs, so `defs['toString']` must not resolve.
+export const EVENT_STORMING_ROLES = Object.assign(Object.create(null), Object.fromEntries(DEFS.map(def => [def.id, def])));

package/dist/rules.d.ts

@@ -0,0 +1,20 @@
+import type { EndpointTriplet, ValidationRule } from '@formicoidea/labre-core/blocks/surface';
+/**
+ * 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 declare const ES_FLOW_MATRIX: readonly EndpointTriplet[];
+export declare const EVENT_STORMING_RULES: readonly ValidationRule[];

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 tooltip: "Enable / lock resizing";
+        readonly icon: import("lit-html").TemplateResult<1>;
+        readonly active: (ctx: ToolbarContext) => boolean;
+        readonly run: (ctx: ToolbarContext) => void;
+    }, {
+        readonly id: "b.legend";
+        readonly tooltip: "Generate the legend (notation present)";
+        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 { 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',
+            tooltip: 'Enable / lock resizing',
+            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',
+            tooltip: 'Generate the legend (notation present)',
+            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() {