@formicoidea/labre-framework-ddd-event-storming 0.40.0 → 0.42.0

package/LICENSE

@@ -0,0 +1,384 @@
+# Mozilla Public License Version 2.0
+
+Copyright (c) TOEVERYTHING PTE. LTD. and its affiliates.
+
+1. Definitions
+
+---
+
+1.1. "Contributor"
+means each individual or legal entity that creates, contributes to
+the creation of, or owns Covered Software.
+
+1.2. "Contributor Version"
+means the combination of the Contributions of others (if any) used
+by a Contributor and that particular Contributor's Contribution.
+
+1.3. "Contribution"
+means Covered Software of a particular Contributor.
+
+1.4. "Covered Software"
+means Source Code Form to which the initial Contributor has attached
+the notice in Exhibit A, the Executable Form of such Source Code
+Form, and Modifications of such Source Code Form, in each case
+including portions thereof.
+
+1.5. "Incompatible With Secondary Licenses"
+means
+
+    (a) that the initial Contributor has attached the notice described
+        in Exhibit B to the Covered Software; or
+
+    (b) that the Covered Software was made available under the terms of
+        version 1.1 or earlier of the License, but not also under the
+        terms of a Secondary License.
+
+1.6. "Executable Form"
+means any form of the work other than Source Code Form.
+
+1.7. "Larger Work"
+means a work that combines Covered Software with other material, in
+a separate file or files, that is not Covered Software.
+
+1.8. "License"
+means this document.
+
+1.9. "Licensable"
+means having the right to grant, to the maximum extent possible,
+whether at the time of the initial grant or subsequently, any and
+all of the rights conveyed by this License.
+
+1.10. "Modifications"
+means any of the following:
+
+    (a) any file in Source Code Form that results from an addition to,
+        deletion from, or modification of the contents of Covered
+        Software; or
+
+    (b) any new file in Source Code Form that contains any Covered
+        Software.
+
+1.11. "Patent Claims" of a Contributor
+means any patent claim(s), including without limitation, method,
+process, and apparatus claims, in any patent Licensable by such
+Contributor that would be infringed, but for the grant of the
+License, by the making, using, selling, offering for sale, having
+made, import, or transfer of either its Contributions or its
+Contributor Version.
+
+1.12. "Secondary License"
+means either the GNU General Public License, Version 2.0, the GNU
+Lesser General Public License, Version 2.1, the GNU Affero General
+Public License, Version 3.0, or any later versions of those
+licenses.
+
+1.13. "Source Code Form"
+means the form of the work preferred for making modifications.
+
+1.14. "You" (or "Your")
+means an individual or a legal entity exercising rights under this
+License. For legal entities, "You" includes any entity that
+controls, is controlled by, or is under common control with You. For
+purposes of this definition, "control" means (a) the power, direct
+or indirect, to cause the direction or management of such entity,
+whether by contract or otherwise, or (b) ownership of more than
+fifty percent (50%) of the outstanding shares or beneficial
+ownership of such entity.
+
+2. License Grants and Conditions
+
+---
+
+2.1. Grants
+
+Each Contributor hereby grants You a world-wide, royalty-free,
+non-exclusive license:
+
+(a) under intellectual property rights (other than patent or trademark)
+Licensable by such Contributor to use, reproduce, make available,
+modify, display, perform, distribute, and otherwise exploit its
+Contributions, either on an unmodified basis, with Modifications, or
+as part of a Larger Work; and
+
+(b) under Patent Claims of such Contributor to make, use, sell, offer
+for sale, have made, import, and otherwise transfer either its
+Contributions or its Contributor Version.
+
+2.2. Effective Date
+
+The licenses granted in Section 2.1 with respect to any Contribution
+become effective for each Contribution on the date the Contributor first
+distributes such Contribution.
+
+2.3. Limitations on Grant Scope
+
+The licenses granted in this Section 2 are the only rights granted under
+this License. No additional rights or licenses will be implied from the
+distribution or licensing of Covered Software under this License.
+Notwithstanding Section 2.1(b) above, no patent license is granted by a
+Contributor:
+
+(a) for any code that a Contributor has removed from Covered Software;
+or
+
+(b) for infringements caused by: (i) Your and any other third party's
+modifications of Covered Software, or (ii) the combination of its
+Contributions with other software (except as part of its Contributor
+Version); or
+
+(c) under Patent Claims infringed by Covered Software in the absence of
+its Contributions.
+
+This License does not grant any rights in the trademarks, service marks,
+or logos of any Contributor (except as may be necessary to comply with
+the notice requirements in Section 3.4).
+
+2.4. Subsequent Licenses
+
+No Contributor makes additional grants as a result of Your choice to
+distribute the Covered Software under a subsequent version of this
+License (see Section 10.2) or under the terms of a Secondary License (if
+permitted under the terms of Section 3.3).
+
+2.5. Representation
+
+Each Contributor represents that the Contributor believes its
+Contributions are its original creation(s) or it has sufficient rights
+to grant the rights to its Contributions conveyed by this License.
+
+2.6. Fair Use
+
+This License is not intended to limit any rights You have under
+applicable copyright doctrines of fair use, fair dealing, or other
+equivalents.
+
+2.7. Conditions
+
+Sections 3.1, 3.2, 3.3, and 3.4 are conditions of the licenses granted
+in Section 2.1.
+
+3. Responsibilities
+
+---
+
+3.1. Distribution of Source Form
+
+All distribution of Covered Software in Source Code Form, including any
+Modifications that You create or to which You contribute, must be under
+the terms of this License. You must inform recipients that the Source
+Code Form of the Covered Software is governed by the terms of this
+License, and how they can obtain a copy of this License. You may not
+attempt to alter or restrict the recipients' rights in the Source Code
+Form.
+
+3.2. Distribution of Executable Form
+
+If You distribute Covered Software in Executable Form then:
+
+(a) such Covered Software must also be made available in Source Code
+Form, as described in Section 3.1, and You must inform recipients of
+the Executable Form how they can obtain a copy of such Source Code
+Form by reasonable means in a timely manner, at a charge no more
+than the cost of distribution to the recipient; and
+
+(b) You may distribute such Executable Form under the terms of this
+License, or sublicense it under different terms, provided that the
+license for the Executable Form does not attempt to limit or alter
+the recipients' rights in the Source Code Form under this License.
+
+3.3. Distribution of a Larger Work
+
+You may create and distribute a Larger Work under terms of Your choice,
+provided that You also comply with the requirements of this License for
+the Covered Software. If the Larger Work is a combination of Covered
+Software with a work governed by one or more Secondary Licenses, and the
+Covered Software is not Incompatible With Secondary Licenses, this
+License permits You to additionally distribute such Covered Software
+under the terms of such Secondary License(s), so that the recipient of
+the Larger Work may, at their option, further distribute the Covered
+Software under the terms of either this License or such Secondary
+License(s).
+
+3.4. Notices
+
+You may not remove or alter the substance of any license notices
+(including copyright notices, patent notices, disclaimers of warranty,
+or limitations of liability) contained within the Source Code Form of
+the Covered Software, except that You may alter any license notices to
+the extent required to remedy known factual inaccuracies.
+
+3.5. Application of Additional Terms
+
+You may choose to offer, and to charge a fee for, warranty, support,
+indemnity or liability obligations to one or more recipients of Covered
+Software. However, You may do so only on Your own behalf, and not on
+behalf of any Contributor. You must make it absolutely clear that any
+such warranty, support, indemnity, or liability obligation is offered by
+You alone, and You hereby agree to indemnify every Contributor for any
+liability incurred by such Contributor as a result of warranty, support,
+indemnity or liability terms You offer. You may include additional
+disclaimers of warranty and limitations of liability specific to any
+jurisdiction.
+
+4. Inability to Comply Due to Statute or Regulation
+
+---
+
+If it is impossible for You to comply with any of the terms of this
+License with respect to some or all of the Covered Software due to
+statute, judicial order, or regulation then You must: (a) comply with
+the terms of this License to the maximum extent possible; and (b)
+describe the limitations and the code they affect. Such description must
+be placed in a text file included with all distributions of the Covered
+Software under this License. Except to the extent prohibited by statute
+or regulation, such description must be sufficiently detailed for a
+recipient of ordinary skill to be able to understand it.
+
+5. Termination
+
+---
+
+5.1. The rights granted under this License will terminate automatically
+if You fail to comply with any of its terms. However, if You become
+compliant, then the rights granted under this License from a particular
+Contributor are reinstated (a) provisionally, unless and until such
+Contributor explicitly and finally terminates Your grants, and (b) on an
+ongoing basis, if such Contributor fails to notify You of the
+non-compliance by some reasonable means prior to 60 days after You have
+come back into compliance. Moreover, Your grants from a particular
+Contributor are reinstated on an ongoing basis if such Contributor
+notifies You of the non-compliance by some reasonable means, this is the
+first time You have received notice of non-compliance with this License
+from such Contributor, and You become compliant prior to 30 days after
+Your receipt of the notice.
+
+5.2. If You initiate litigation against any entity by asserting a patent
+infringement claim (excluding declaratory judgment actions,
+counter-claims, and cross-claims) alleging that a Contributor Version
+directly or indirectly infringes any patent, then the rights granted to
+You by any and all Contributors for the Covered Software under Section
+2.1 of this License shall terminate.
+
+5.3. In the event of termination under Sections 5.1 or 5.2 above, all
+end user license agreements (excluding distributors and resellers) which
+have been validly granted by You or Your distributors under this License
+prior to termination shall survive termination.
+
+---
+
+-                                                                      *
+- 6.  Disclaimer of Warranty \*
+- ------------------------- \*
+-                                                                      *
+- Covered Software is provided under this License on an "as is" \*
+- basis, without warranty of any kind, either expressed, implied, or \*
+- statutory, including, without limitation, warranties that the \*
+- Covered Software is free of defects, merchantable, fit for a \*
+- particular purpose or non-infringing. The entire risk as to the \*
+- quality and performance of the Covered Software is with You. \*
+- Should any Covered Software prove defective in any respect, You \*
+- (not any Contributor) assume the cost of any necessary servicing, \*
+- repair, or correction. This disclaimer of warranty constitutes an \*
+- essential part of this License. No use of any Covered Software is \*
+- authorized under this License except under this disclaimer. \*
+-                                                                      *
+
+---
+
+---
+
+-                                                                      *
+- 7.  Limitation of Liability \*
+- -------------------------- \*
+-                                                                      *
+- Under no circumstances and under no legal theory, whether tort \*
+- (including negligence), contract, or otherwise, shall any \*
+- Contributor, or anyone who distributes Covered Software as \*
+- permitted above, be liable to You for any direct, indirect, \*
+- special, incidental, or consequential damages of any character \*
+- including, without limitation, damages for lost profits, loss of \*
+- goodwill, work stoppage, computer failure or malfunction, or any \*
+- and all other commercial damages or losses, even if such party \*
+- shall have been informed of the possibility of such damages. This \*
+- limitation of liability shall not apply to liability for death or \*
+- personal injury resulting from such party's negligence to the \*
+- extent applicable law prohibits such limitation. Some \*
+- jurisdictions do not allow the exclusion or limitation of \*
+- incidental or consequential damages, so this exclusion and \*
+- limitation may not apply to You. \*
+-                                                                      *
+
+---
+
+8. Litigation
+
+---
+
+Any litigation relating to this License may be brought only in the
+courts of a jurisdiction where the defendant maintains its principal
+place of business and such litigation shall be governed by laws of that
+jurisdiction, without reference to its conflict-of-law provisions.
+Nothing in this Section shall prevent a party's ability to bring
+cross-claims or counter-claims.
+
+9. Miscellaneous
+
+---
+
+This License represents the complete agreement concerning the subject
+matter hereof. If any provision of this License is held to be
+unenforceable, such provision shall be reformed only to the extent
+necessary to make it enforceable. Any law or regulation which provides
+that the language of a contract shall be construed against the drafter
+shall not be used to construe this License against a Contributor.
+
+10. Versions of the License
+
+---
+
+10.1. New Versions
+
+Mozilla Foundation is the license steward. Except as provided in Section
+10.3, no one other than the license steward has the right to modify or
+publish new versions of this License. Each version will be given a
+distinguishing version number.
+
+10.2. Effect of New Versions
+
+You may distribute the Covered Software under the terms of the version
+of the License under which You originally received the Covered Software,
+or under the terms of any subsequent version published by the license
+steward.
+
+10.3. Modified Versions
+
+If you create software not governed by this License, and you want to
+create a new license for such software, you may create and use a
+modified version of this License if you rename the license and remove
+any references to the name of the license steward (except to note that
+such modified license differs from this License).
+
+10.4. Distributing Source Code Form that is Incompatible With Secondary
+Licenses
+
+If You choose to distribute Source Code Form that is Incompatible With
+Secondary Licenses under the terms of this version of the License, the
+notice described in Exhibit B of this License must be attached.
+
+## Exhibit A - Source Code Form License Notice
+
+This Source Code Form is subject to the terms of the Mozilla Public
+License, v. 2.0. If a copy of the MPL was not distributed with this
+file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+If it is not possible or desirable to put the notice in a particular
+file, then You may include the notice in a location (such as a LICENSE
+file in a relevant directory) where a recipient would be likely to look
+for such a notice.
+
+You may add additional accurate notices of copyright ownership.
+
+## Exhibit B - "Incompatible With Secondary Licenses" Notice
+
+This Source Code Form is "Incompatible With Secondary Licenses", as
+defined by the Mozilla Public License, v. 2.0.

package/dist/background.js

@@ -120,6 +120,10 @@ export const EVENT_STORMING_BACKGROUND = {
             stroke: { color: '@axis', width: 6 },
             title: {
                 id: 'timeAxisTitle',
+                // Renamable in place (issue #355): a workshop that storms a release
+                // rather than a day writes its own word under the arrow, and the
+                // catalogue keeps serving "Time" to every board that has not.
+                prop: 'timeAxisTitle',
                 labelKey: 'com.labre.event-storming.background.axis.time',
                 fallback: 'Time',
                 // Pushed down with the SIZE, not just with the stroke.

package/dist/commands.d.ts

@@ -1,4 +1,18 @@
+import { type ChromeWording } from '@formicoidea/labre-core/shared/services';
 import type { CommandDescriptor } from '@formicoidea/labre-core/std';
 import { type TemplateResult } from 'lit';
+/**
+ * The automatic legend's own section titles — text stamped onto the board the
+ * moment the legend is built, like any other seed, and declared HERE because
+ * the rows that file themselves under them are subscribed by the commands
+ * below. The box title itself is not one of them: it says the shared word
+ * "Legend" and reuses `BOARD_LEGEND_TITLE`.
+ *
+ * Two sub-titles for a framework whose eleven commands all sit in ONE category:
+ * `section` is what keeps the Flow — a line, not a post-it — out of the
+ * stickies where the category would file it (`docs/adr/0026`).
+ */
+export declare const ES_SEED_LEGEND_STICKIES: ChromeWording;
+export declare const ES_SEED_LEGEND_FLOW: ChromeWording;
 export declare const eventStormingCommands: CommandDescriptor[];
 export declare const eventStormingCommandIcons: Record<string, TemplateResult>;

package/dist/commands.js

@@ -1,9 +1,29 @@
-import { addSticky, ES_HOTSPOT, ES_STICKIES, placeDddElement, STICKY_SIZE, } from '@formicoidea/labre-ddd-shared';
+import { addSticky, esStickySeedKey, ES_HOTSPOT, ES_STICKIES, eventStormingToolbarIcon, LABEL_COLOR, placeDddElement, STICKY_SIZE, } from '@formicoidea/labre-ddd-shared';
 import { NOTATION_NEUTRALS } from '@formicoidea/labre-core/shared/consts';
+import { translateKey, } from '@formicoidea/labre-core/shared/services';
 import { GfxControllerIdentifier } from '@formicoidea/labre-core/std/gfx';
 import { svg } from 'lit';
 import { activateEventStormingFlow, createEventStormingBoard } from './actions.js';
-import { ES_STICKY_ROLE } from './roles.js';
+import { ES_ROLE, ES_STICKY_ROLE } from './roles.js';
+/**
+ * The automatic legend's own section titles — text stamped onto the board the
+ * moment the legend is built, like any other seed, and declared HERE because
+ * the rows that file themselves under them are subscribed by the commands
+ * below. The box title itself is not one of them: it says the shared word
+ * "Legend" and reuses `BOARD_LEGEND_TITLE`.
+ *
+ * Two sub-titles for a framework whose eleven commands all sit in ONE category:
+ * `section` is what keeps the Flow — a line, not a post-it — out of the
+ * stickies where the category would file it (`docs/adr/0026`).
+ */
+export const ES_SEED_LEGEND_STICKIES = [
+    'com.labre.ddd-event-storming.seed.legend-stickies',
+    'Stickies',
+];
+export const ES_SEED_LEGEND_FLOW = [
+    'com.labre.ddd-event-storming.seed.legend-flow',
+    'Flow',
+];
 /**
  * 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,
@@ -49,7 +69,10 @@ const SPECS = [
         run: std => placeDddElement(std, (surface, cx, cy) => addSticky(surface, std, cx, cy, {
             fill: preset.fill,
             text: preset.text,
-            label: preset.label,
+            // Translated HERE and once: the caption is document content the
+            // moment it lands (ADR 0023), so the host's catalogue is asked at
+            // placement and never again.
+            label: translateKey(std, esStickySeedKey(preset.kind), preset.label),
             size: preset.kind === 'aggregate' ? AGGREGATE_SIZE : STICKY_SIZE,
             // The role is what makes a sticky a domain EVENT rather than an
             // orange square: every rule in `rules.ts` reads it, and a sticky
@@ -57,6 +80,14 @@ const SPECS = [
             // (promesse #71).
             role: ES_STICKY_ROLE[preset.kind],
         })),
+        // Row and command out of the SAME preset, so the colour ladder the legend
+        // shows is by construction the colour ladder on the wall — and a tenth
+        // sticky kind gets its row with no edit.
+        legend: {
+            role: ES_STICKY_ROLE[preset.kind],
+            section: ES_SEED_LEGEND_STICKIES,
+            row: { swatch: 'square', color: preset.fill },
+        },
     })),
     {
         id: 'addHotspot',
@@ -67,29 +98,45 @@ const SPECS = [
         run: std => placeDddElement(std, (surface, cx, cy) => addSticky(surface, std, cx, cy, {
             fill: ES_HOTSPOT.fill,
             text: ES_HOTSPOT.text,
-            label: ES_HOTSPOT.label,
+            // Translated HERE and once, like every sticky above (ADR 0023).
+            label: translateKey(std, esStickySeedKey('hotspot'), ES_HOTSPOT.label),
             shapeType: 'diamond',
             // Typed like the rest, and cited by no grammar triplet on purpose —
             // an arc onto a hotspot is a question being parked. See `rules.ts`.
             role: ES_STICKY_ROLE.hotspot,
         })),
+        // In its own preset, a diamond rather than a square, and therefore its own
+        // row — appended after the eight by its `order` rather than by hand.
+        legend: {
+            role: ES_STICKY_ROLE.hotspot,
+            section: ES_SEED_LEGEND_STICKIES,
+            row: { swatch: 'square', color: ES_HOTSPOT.fill },
+        },
     },
     {
         id: 'addFlow',
         label: 'Flow',
         iconKey: 'ddd-event-storming.flow',
         element: 'flow',
+        kind: 'tool',
         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)),
+        legend: {
+            role: ES_ROLE.flow,
+            section: ES_SEED_LEGEND_FLOW,
+            // The style `activateEventStormingFlow` arms the connector tool with: a
+            // solid line in the label colour.
+            row: { swatch: 'line', color: LABEL_COLOR },
+        },
     },
 ];
 export const eventStormingCommands = SPECS.map((spec, order) => ({
     id: `ddd-event-storming.${spec.id}`,
     owner: 'ddd-event-storming',
-    kind: 'artefact',
+    kind: spec.kind ?? 'artefact',
     labelKey: `com.labre.commands.ddd-event-storming.${spec.id}`,
     labelFallback: spec.label,
     category: 'stickies',
@@ -105,5 +152,11 @@ export const eventStormingCommands = SPECS.map((spec, order) => ({
         element: spec.element,
         board: spec.board,
     },
+    legend: spec.legend,
 }));
-export const eventStormingCommandIcons = Object.fromEntries(SPECS.map(spec => [spec.iconKey, spec.icon]));
+export const eventStormingCommandIcons = {
+    ...Object.fromEntries(SPECS.map(spec => [spec.iconKey, spec.icon])),
+    // The senior button's 56×56 glyph, so `FrameworkDescriptor.iconKey` resolves
+    // through `getCommandIcon`.
+    'ddd-event-storming.toolbar': eventStormingToolbarIcon,
+};

package/dist/element-view.d.ts

@@ -1,15 +1,19 @@
+import type { FrameworkBackgroundDef } from '@formicoidea/labre-core/blocks/surface';
+import { DeclaredBackgroundView } from '@formicoidea/labre-core/blocks/surface';
 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.
+ * Extends {@link DeclaredBackgroundView}, so the one word the board writes on
+ * itself — the time axis title — is renamed in place by a double-click, like
+ * every other framework background (issue #355). This file used to say the
+ * board had nothing to edit because the declaration bound no prop; binding one
+ * is the fix, and the gesture then comes for free.
  */
-export declare class EventStormingView extends GfxElementModelView<EventStormingBoardElementModel> {
+export declare class EventStormingView extends DeclaredBackgroundView<EventStormingBoardElementModel> {
     static type: string;
+    protected get def(): FrameworkBackgroundDef;
 }
 /**
  * Resize gating, from the primitive: the handles follow `resizeEnabled`, which

package/dist/element-view.js

@@ -1,16 +1,20 @@
-import { FrameworkBackgroundInteractionExtension } from '@formicoidea/labre-core/blocks/surface';
-import { GfxElementModelView } from '@formicoidea/labre-core/std/gfx';
+import { DeclaredBackgroundView, FrameworkBackgroundInteractionExtension, } from '@formicoidea/labre-core/blocks/surface';
 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.
+ * Extends {@link DeclaredBackgroundView}, so the one word the board writes on
+ * itself — the time axis title — is renamed in place by a double-click, like
+ * every other framework background (issue #355). This file used to say the
+ * board had nothing to edit because the declaration bound no prop; binding one
+ * is the fix, and the gesture then comes for free.
  */
-export class EventStormingView extends GfxElementModelView {
+export class EventStormingView extends DeclaredBackgroundView {
     static { this.type = 'eventStorming'; }
+    get def() {
+        return EVENT_STORMING_BACKGROUND;
+    }
 }
 /**
  * Resize gating, from the primitive: the handles follow `resizeEnabled`, which

package/dist/templates.js

@@ -31,8 +31,13 @@ const dia = (c) => `<svg ${ATTRS}><rect x="48" y="20" width="40" height="40" tra
 const BOARD_PREVIEW = `<svg ${ATTRS} fill="none"><rect x="4" y="6" width="127" height="68" rx="6" fill="${NOTATION_NEUTRALS.cardFill}" stroke="${NOTATION_NEUTRALS.cardBorder}" stroke-width="1.5"/><rect x="14" y="18" width="18" height="18" rx="3" fill="${ES_STICKIES[0].fill}"/><rect x="38" y="18" width="18" height="18" rx="3" fill="${ES_STICKIES[1].fill}"/><rect x="62" y="18" width="18" height="18" rx="3" fill="${ES_STICKIES[2].fill}"/><rect x="86" y="18" width="18" height="18" rx="3" fill="${ES_STICKIES[3].fill}"/><path d="M12 58 H114" stroke="${NOTATION_NEUTRALS.frameInk}" stroke-width="3"/><path d="M112 53 L122 58 L112 63 Z" fill="${NOTATION_NEUTRALS.frameInk}"/></svg>`;
 export const eventStormingTemplateCategory = {
     name: 'Event Storming',
+    // Reuses the senior button's own key — see `TemplateCategory.nameKey`.
+    nameKey: 'com.labre.framework.ddd-event-storming',
     templates: [
-        templateFromCommand(byLabel('Event Storming board'), BOARD_PREVIEW, 'Event Storming board'),
+        // No name override: it would only restate the command's own
+        // `labelFallback` as a second literal the panel could not translate — see
+        // `resolveTemplateName`, which reads the command's `labelKey` instead.
+        templateFromCommand(byLabel('Event Storming board'), BOARD_PREVIEW),
         ...ES_STICKIES.map(preset => templateFromCommand(byLabel(preset.label), sq(preset.fill), `Event Storming — ${preset.label}`)),
         templateFromCommand(byLabel(ES_HOTSPOT.label), dia(ES_HOTSPOT.fill), `Event Storming — ${ES_HOTSPOT.label}`),
     ],

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

@@ -1,15 +1,14 @@
-import { type ToolbarContext } from '@formicoidea/labre-core/shared/services';
+import { type ToolbarContext, type ToolbarModuleConfig } 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.
+ * The selected board's ALWAYS-ON row: the resize toggle, and nothing else. A
+ * stored board must stay usable with the Event Storming button switched off
+ * (`docs/adr/0009`) — it keeps its handles, and everything already stuck to it,
+ * legend boxes included, keeps being painted.
  *
- * 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.
+ * The legend BUTTON moved out of here to
+ * {@link eventStormingBoardToolingToolbarConfig} (`docs/adr/0026`): generating
+ * one is a gesture the flag may take away, even though what it writes is
+ * document content.
  */
 export declare const eventStormingBoardToolbarConfig: {
     readonly actions: [{
@@ -18,12 +17,25 @@ export declare const eventStormingBoardToolbarConfig: {
         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;
+/**
+ * The board's FLAG-GATED row, whole: the legend button and the Validation
+ * dropdown, in one module.
+ *
+ * They cannot be two, and that is a hard constraint rather than a preference:
+ * `ToolbarModuleExtension` binds by DI variant, so a second module claiming
+ * `custom:affine:surface:eventStorming` throws
+ * `DuplicateServiceDefinitionError` before the editor finishes setting up. The
+ * C4 board's own row was merged this way first
+ * (`c4BoardToolingToolbarConfig`).
+ *
+ * Both entries go with the `ddd-event-storming` flag for the same reason:
+ * turning it off takes away the gesture that GENERATES legend elements and the
+ * choice of how hard to check the board, and leaves the stored board its handles
+ * and everything already stuck to it. The legend rows themselves are derived
+ * from `eventStormingCommands` — the module writes no table (`docs/adr/0026`).
+ */
+export declare const eventStormingBoardToolingToolbarConfig: ToolbarModuleConfig;

package/dist/toolbar/board-config.js

@@ -1,10 +1,8 @@
-import { EdgelessCRUDIdentifier } from '@formicoidea/labre-core/blocks/surface';
-import { createAutoLegend, dddLegendIcon } from '@formicoidea/labre-ddd-shared';
+import { EdgelessCRUDIdentifier, legendToolbarAction, validationToolbarConfig, } from '@formicoidea/labre-core/blocks/surface';
 import { EventStormingBoardElementModel } from '@formicoidea/labre-core/model';
-import { BOARD_LEGEND_NOTATION, BOARD_RESIZE_TOGGLE, TelemetryProvider, ToolbarModuleExtension, } from '@formicoidea/labre-core/shared/services';
+import { BOARD_RESIZE_TOGGLE, 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"
@@ -19,16 +17,15 @@ const ResizeIcon = html `<svg
   <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.
+ * The selected board's ALWAYS-ON row: the resize toggle, and nothing else. A
+ * stored board must stay usable with the Event Storming button switched off
+ * (`docs/adr/0009`) — it keeps its handles, and everything already stuck to it,
+ * legend boxes included, keeps being painted.
  *
- * 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.
+ * The legend BUTTON moved out of here to
+ * {@link eventStormingBoardToolingToolbarConfig} (`docs/adr/0026`): generating
+ * one is a gesture the flag may take away, even though what it writes is
+ * document content.
  */
 export const eventStormingBoardToolbarConfig = {
     actions: [
@@ -52,31 +49,6 @@ export const eventStormingBoardToolbarConfig = {
                 }
             },
         },
-        {
-            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,
 };
@@ -84,3 +56,38 @@ export const eventStormingBoardToolbarExtension = ToolbarModuleExtension({
     id: BlockFlavourIdentifier('affine:surface:eventStorming'),
     config: eventStormingBoardToolbarConfig,
 });
+/**
+ * The board's FLAG-GATED row, whole: the legend button and the Validation
+ * dropdown, in one module.
+ *
+ * They cannot be two, and that is a hard constraint rather than a preference:
+ * `ToolbarModuleExtension` binds by DI variant, so a second module claiming
+ * `custom:affine:surface:eventStorming` throws
+ * `DuplicateServiceDefinitionError` before the editor finishes setting up. The
+ * C4 board's own row was merged this way first
+ * (`c4BoardToolingToolbarConfig`).
+ *
+ * Both entries go with the `ddd-event-storming` flag for the same reason:
+ * turning it off takes away the gesture that GENERATES legend elements and the
+ * choice of how hard to check the board, and leaves the stored board its handles
+ * and everything already stuck to it. The legend rows themselves are derived
+ * from `eventStormingCommands` — the module writes no table (`docs/adr/0026`).
+ */
+export const eventStormingBoardToolingToolbarConfig = {
+    actions: [
+        legendToolbarAction({
+            Model: EventStormingBoardElementModel,
+            owner: 'ddd-event-storming',
+            // 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`). Unchanged by the button becoming
+            // shared.
+            framework: 'event-storming',
+        }),
+        // The generic dropdown, not an Event Storming variant of it: the config
+        // names no framework — it reads the registered rules and profiles — so this
+        // is the very same object c4, wardley and bpmn register.
+        ...validationToolbarConfig.actions,
+    ],
+    when: eventStormingBoardToolbarConfig.when,
+};

package/dist/toolbar/palette.d.ts

@@ -0,0 +1,36 @@
+import type { FrameworkPalette, NamedPalette } from '@formicoidea/labre-core/components/color-picker';
+import type { ChromeWording } from '@formicoidea/labre-core/shared/services';
+/**
+ * The Event Storming swatches' own names, resolved by `resolvePaletteLabel`
+ * (`@labre/affine-components/color-picker`) through each swatch's own
+ * {@link NamedPalette.labelWording} — the mechanism `WARDLEY_PALETTE_WORDINGS`
+ * established, reused here without either package naming the other.
+ *
+ * Exported so `../translations.ts` can list them under source `chrome`: a
+ * swatch's name is toolbar chrome, re-rendered on every locale switch, never
+ * seeded into a document. They are this framework's OWN keys even though the
+ * colours come from `ddd-shared` — the shared file declares no `com.labre.*`
+ * key of its own, by design (see its header).
+ */
+export declare const ES_PALETTE_WORDING_DOMAIN_EVENT: ChromeWording;
+export declare const ES_PALETTE_WORDING_COMMAND: ChromeWording;
+export declare const ES_PALETTE_WORDING_AGGREGATE: ChromeWording;
+export declare const ES_PALETTE_WORDING_ACTOR: ChromeWording;
+export declare const ES_PALETTE_WORDING_CONSTRAINT: ChromeWording;
+export declare const ES_PALETTE_WORDING_POLICY: ChromeWording;
+export declare const ES_PALETTE_WORDING_READ_MODEL: ChromeWording;
+export declare const ES_PALETTE_WORDING_SYSTEM: ChromeWording;
+export declare const ES_PALETTE_WORDING_HOTSPOT: ChromeWording;
+export declare const ES_PALETTE_WORDINGS: readonly ChromeWording[];
+/**
+ * From the default editor palette we keep ONLY the neutrals — the historical
+ * colours say nothing in this notation.
+ */
+export declare const ES_PALETTE_LIST: NamedPalette[];
+/**
+ * Event Storming's page of the colour pickers' carousel (`docs/adr/0027`).
+ * Registered from the FLAG-GATED view extension, because offering hues is
+ * TOOLING: a board drawn while the flag was on keeps every colour it was
+ * painted with when the flag goes off (`docs/adr/0009`).
+ */
+export declare const EVENT_STORMING_FRAMEWORK_PALETTE: FrameworkPalette;

package/dist/toolbar/palette.js

@@ -0,0 +1,145 @@
+import { ES_HOTSPOT, ES_STICKIES } from '@formicoidea/labre-ddd-shared';
+import { neutralPalettes } from '@formicoidea/labre-core/gfx/shape';
+/**
+ * The Event Storming swatches' own names, resolved by `resolvePaletteLabel`
+ * (`@labre/affine-components/color-picker`) through each swatch's own
+ * {@link NamedPalette.labelWording} — the mechanism `WARDLEY_PALETTE_WORDINGS`
+ * established, reused here without either package naming the other.
+ *
+ * Exported so `../translations.ts` can list them under source `chrome`: a
+ * swatch's name is toolbar chrome, re-rendered on every locale switch, never
+ * seeded into a document. They are this framework's OWN keys even though the
+ * colours come from `ddd-shared` — the shared file declares no `com.labre.*`
+ * key of its own, by design (see its header).
+ */
+export const ES_PALETTE_WORDING_DOMAIN_EVENT = [
+    'com.labre.ddd-event-storming.palette.domain-event-orange',
+    'Domain event orange',
+];
+export const ES_PALETTE_WORDING_COMMAND = [
+    'com.labre.ddd-event-storming.palette.command-blue',
+    'Command blue',
+];
+export const ES_PALETTE_WORDING_AGGREGATE = [
+    'com.labre.ddd-event-storming.palette.aggregate-cream',
+    'Aggregate cream',
+];
+export const ES_PALETTE_WORDING_ACTOR = [
+    'com.labre.ddd-event-storming.palette.actor-yellow',
+    'Actor yellow',
+];
+export const ES_PALETTE_WORDING_CONSTRAINT = [
+    'com.labre.ddd-event-storming.palette.constraint-yellow',
+    'Constraint yellow',
+];
+export const ES_PALETTE_WORDING_POLICY = [
+    'com.labre.ddd-event-storming.palette.policy-lilac',
+    'Policy lilac',
+];
+export const ES_PALETTE_WORDING_READ_MODEL = [
+    'com.labre.ddd-event-storming.palette.read-model-green',
+    'Read model green',
+];
+export const ES_PALETTE_WORDING_SYSTEM = [
+    'com.labre.ddd-event-storming.palette.external-system-pink',
+    'External system pink',
+];
+export const ES_PALETTE_WORDING_HOTSPOT = [
+    'com.labre.ddd-event-storming.palette.hotspot-magenta',
+    'Hotspot magenta',
+];
+export const ES_PALETTE_WORDINGS = [
+    ES_PALETTE_WORDING_DOMAIN_EVENT,
+    ES_PALETTE_WORDING_COMMAND,
+    ES_PALETTE_WORDING_AGGREGATE,
+    ES_PALETTE_WORDING_ACTOR,
+    ES_PALETTE_WORDING_CONSTRAINT,
+    ES_PALETTE_WORDING_POLICY,
+    ES_PALETTE_WORDING_READ_MODEL,
+    ES_PALETTE_WORDING_SYSTEM,
+    ES_PALETTE_WORDING_HOTSPOT,
+];
+/**
+ * The sticky fills, by kind — derived from {@link ES_STICKIES} rather than
+ * restated, so a hue changed in the shared table changes the shelf with it.
+ */
+const ES_FILL = Object.fromEntries(ES_STICKIES.map(sticky => [sticky.kind, sticky.fill]));
+/**
+ * The DDD Crew / Brandolini **colour code**, surfaced as ready-made swatches.
+ *
+ * Event Storming is the one notation here where the colour IS the vocabulary:
+ * an orange sticky is a domain event and a blue one a command, and that holds
+ * on a wall, in a book and on this canvas. The shelf is therefore the sticky
+ * table itself, in the order the grammar reads it (`ES_STICKIES`: an actor
+ * issues a command, a command lands on an aggregate, an aggregate raises an
+ * event), with the hotspot's neon diamond last.
+ *
+ * They are SHORTCUTS, never constraints: a sticky's KIND is written in its
+ * role, not read off its fill, so nothing breaks when an author repaints one.
+ */
+const ES_PALETTES = [
+    {
+        key: 'Domain event orange',
+        value: ES_FILL.domainEvent,
+        labelWording: ES_PALETTE_WORDING_DOMAIN_EVENT,
+    },
+    {
+        key: 'Command blue',
+        value: ES_FILL.command,
+        labelWording: ES_PALETTE_WORDING_COMMAND,
+    },
+    {
+        key: 'Aggregate cream',
+        value: ES_FILL.aggregate,
+        labelWording: ES_PALETTE_WORDING_AGGREGATE,
+    },
+    {
+        key: 'Actor yellow',
+        value: ES_FILL.actor,
+        labelWording: ES_PALETTE_WORDING_ACTOR,
+    },
+    {
+        key: 'Constraint yellow',
+        value: ES_FILL.constraint,
+        labelWording: ES_PALETTE_WORDING_CONSTRAINT,
+    },
+    {
+        key: 'Policy lilac',
+        value: ES_FILL.policy,
+        labelWording: ES_PALETTE_WORDING_POLICY,
+    },
+    {
+        key: 'Read model green',
+        value: ES_FILL.readModel,
+        labelWording: ES_PALETTE_WORDING_READ_MODEL,
+    },
+    {
+        key: 'External system pink',
+        value: ES_FILL.system,
+        labelWording: ES_PALETTE_WORDING_SYSTEM,
+    },
+    {
+        key: 'Hotspot magenta',
+        value: ES_HOTSPOT.fill,
+        labelWording: ES_PALETTE_WORDING_HOTSPOT,
+    },
+];
+/**
+ * From the default editor palette we keep ONLY the neutrals — the historical
+ * colours say nothing in this notation.
+ */
+export const ES_PALETTE_LIST = [
+    ...ES_PALETTES,
+    ...neutralPalettes(),
+];
+/**
+ * Event Storming's page of the colour pickers' carousel (`docs/adr/0027`).
+ * Registered from the FLAG-GATED view extension, because offering hues is
+ * TOOLING: a board drawn while the flag was on keeps every colour it was
+ * painted with when the flag goes off (`docs/adr/0009`).
+ */
+export const EVENT_STORMING_FRAMEWORK_PALETTE = {
+    framework: 'ddd-event-storming',
+    labelWording: ['com.labre.framework.ddd-event-storming', 'Event Storming'],
+    palettes: ES_PALETTE_LIST,
+};

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

@@ -4,4 +4,5 @@ export declare class EdgelessDddEventStormingSeniorButton extends DddSeniorButto
     protected label: string;
     protected labelKey: string;
     protected icon: import("lit-html").TemplateResult<2>;
+    protected owner: "ddd-event-storming";
 }

package/dist/toolbar/senior-button.js

@@ -6,5 +6,6 @@ export class EdgelessDddEventStormingSeniorButton extends DddSeniorButtonBase {
         this.label = 'Event Storming';
         this.labelKey = 'com.labre.framework.ddd-event-storming';
         this.icon = eventStormingToolbarIcon;
+        this.owner = 'ddd-event-storming';
     }
 }

package/dist/translations.js

@@ -1,11 +1,13 @@
+import { dddSharedTranslationEntries } from '@formicoidea/labre-ddd-shared';
 import { collectTranslationKeys, commandCategoryTranslationEntries, commandTranslationEntries, mergeTranslationEntries, } from '@formicoidea/labre-core/std';
 import { EVENT_STORMING_BACKGROUND } from './background.js';
-import { eventStormingCommands } from './commands.js';
+import { ES_SEED_LEGEND_FLOW, ES_SEED_LEGEND_STICKIES, eventStormingCommands, } from './commands.js';
 import { EVENT_STORMING_NUDGES } from './nudges.js';
 import { EVENT_STORMING_PROFILES } from './profiles.js';
 import { EVENT_STORMING_READING } from './reading.js';
 import { EVENT_STORMING_ROLES } from './roles.js';
 import { EVENT_STORMING_RULES } from './rules.js';
+import { ES_PALETTE_WORDINGS } from './toolbar/palette.js';
 /**
  * THIS framework's contribution to the translation-key manifest — every
  * `com.labre.*` key Event Storming can hand to `TranslationProvider.t`,
@@ -31,4 +33,21 @@ commandCategoryTranslationEntries(eventStormingCommands), collectTranslationKeys
 // framework's own `roles`, so walking it reaches every role key the `role`
 // line above already named. `mergeTranslationEntries` keeps the FIRST
 // occurrence, which is what makes each key report the source it comes from.
-collectTranslationKeys('reading', EVENT_STORMING_READING));
+collectTranslationKeys('reading', EVENT_STORMING_READING), 
+// The seeds baked into a placed sticky (`commands.ts`), derived from the
+// shared palette in `ddd-shared` rather than restated — spread whole
+// rather than imported from a sibling DDD framework (never allowed), and
+// de-duplicated with whatever this framework already listed.
+dddSharedTranslationEntries, [ES_SEED_LEGEND_STICKIES, ES_SEED_LEGEND_FLOW].map(([key, fallback]) => ({
+    key,
+    fallback,
+    source: 'seed',
+})), 
+// The carousel swatches' own names (`toolbar/palette.ts`) — chrome,
+// re-rendered by the colour picker on every locale switch, never seeded
+// into a document. Same treatment as Wardley's and EDGY's.
+ES_PALETTE_WORDINGS.map(([key, fallback]) => ({
+    key,
+    fallback,
+    source: 'chrome',
+})));

package/dist/view.js

@@ -1,4 +1,5 @@
-import { morphToolbarConfig, QualityNudgeExtension, ReadingProfileExtension, validationToolbarConfig, ValidationProfileExtension, ValidationRuleExtension, } from '@formicoidea/labre-core/blocks/surface';
+import { morphToolbarConfig, QualityNudgeExtension, ReadingProfileExtension, ValidationProfileExtension, ValidationRuleExtension, } from '@formicoidea/labre-core/blocks/surface';
+import { FrameworkPaletteExtension } from '@formicoidea/labre-core/components/color-picker';
 import { ViewExtensionProvider, } from '@formicoidea/labre-core/ext-loader';
 import { ToolbarModuleExtension, toolbarModuleKey, } from '@formicoidea/labre-core/shared/services';
 import { TemplateCategoryExtension } from '@formicoidea/labre-core/gfx/template';
@@ -15,7 +16,8 @@ import { EVENT_STORMING_PROFILES } from './profiles.js';
 import { EVENT_STORMING_READING } from './reading.js';
 import { EVENT_STORMING_ROLES } from './roles.js';
 import { EVENT_STORMING_RULES } from './rules.js';
-import { eventStormingBoardToolbarExtension } from './toolbar/board-config.js';
+import { eventStormingBoardToolbarExtension, eventStormingBoardToolingToolbarConfig, } from './toolbar/board-config.js';
+import { EVENT_STORMING_FRAMEWORK_PALETTE } from './toolbar/palette.js';
 import { eventStormingSeniorTool } from './toolbar/senior-tool.js';
 /**
  * Event Storming rendering — ALWAYS registered, independent of any flag.
@@ -71,16 +73,16 @@ export class DddEventStormingViewExtension extends ViewExtensionProvider {
             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.
+            // The board's gated row — the Legend button and the Validation dropdown,
+            // merged into ONE module because a flavour may carry exactly one
+            // (`board-config.ts`). 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 generating a legend and choosing how hard to check the
+            // board are tooling and belong here.
             context.register(ToolbarModuleExtension({
                 id: BlockFlavourIdentifier('custom:affine:surface:eventStorming'),
-                config: validationToolbarConfig,
+                config: eventStormingBoardToolingToolbarConfig,
             }));
             // The reversed reading (MF3): what the board says about a sticky, on
             // demand. One declaration — the roles and the flow edge, both already
@@ -89,6 +91,11 @@ export class DddEventStormingViewExtension extends ViewExtensionProvider {
             // profile, so it goes with the flag without either side naming the other.
             context.register(ReadingProfileExtension(EVENT_STORMING_READING));
             context.register(eventStormingSeniorTool);
+            // Event Storming's page of the colour pickers' carousel
+            // (`docs/adr/0027`). Here, beside the senior tool, because offering hues
+            // is TOOLING — the colours already painted on a stored board are content
+            // and do not move (`docs/adr/0009`).
+            context.register(FrameworkPaletteExtension(EVENT_STORMING_FRAMEWORK_PALETTE));
             // The Templates-panel category, gated by this framework's own flag like
             // every other framework's: a template is tooling (`docs/adr/0009`), and it
             // is DERIVED from this package's commands, so it registers where they do.

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.40.0",
+  "version": "0.42.0",
   "type": "module",
   "sideEffects": false,
   "author": "lajola",
@@ -31,8 +31,8 @@
     "dist"
   ],
   "dependencies": {
-    "@formicoidea/labre-core": "0.40.0",
-    "@formicoidea/labre-ddd-shared": "0.40.0",
+    "@formicoidea/labre-core": "0.42.0",
+    "@formicoidea/labre-ddd-shared": "0.42.0",
     "lit": "^3.2.0"
   }
 }

package/dist/legend.d.ts

@@ -1,16 +0,0 @@
-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

@@ -1,58 +0,0 @@
-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),
-                    },
-                },
-            ],
-        },
-    ],
-};