@formicoidea/labre-framework-ddd-context-map 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/commands.d.ts

@@ -1,4 +1,30 @@
+import { type ChromeWording } from '@formicoidea/labre-core/shared/services';
 import type { CommandDescriptor } from '@formicoidea/labre-core/std';
 import { type TemplateResult } from 'lit';
+/**
+ * The seeds baked into a placed artefact: the bounded-context bubble's
+ * default caption, and the general-purpose cloud's. The nine relationship
+ * patterns carry no seed of their own — since WS2 the palette ARMS the
+ * connector tool rather than dropping a labelled group, so no word is
+ * written into the document for them any more
+ * (`activateContextMapRelationship`). Declared here, beside the commands that
+ * write them, and imported by `translations.ts` — never the other way, which
+ * would cycle back into `contextMapCommands`.
+ */
+export declare const CONTEXT_MAP_SEED_BOUNDED_CONTEXT: ChromeWording;
+export declare const CONTEXT_MAP_SEED_CLOUD: ChromeWording;
+/**
+ * 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 twelve commands all sit in ONE category:
+ * `section` is what keeps "Boundaries" and "Relationships" apart where the
+ * category would say "Map" once (`docs/adr/0026`).
+ */
+export declare const CONTEXT_MAP_SEED_LEGEND_BOUNDARIES: ChromeWording;
+export declare const CONTEXT_MAP_SEED_LEGEND_RELATIONSHIPS: ChromeWording;
 export declare const contextMapCommands: CommandDescriptor[];
 export declare const contextMapCommandIcons: Record<string, TemplateResult>;

package/dist/commands.js

@@ -1,9 +1,47 @@
-import { addBubble, addCloud, CLOUD, CM_RELATIONSHIPS, placeDddElement, } from '@formicoidea/labre-ddd-shared';
+import { addBubble, addCloud, CLOUD, CM_BUBBLE, CM_RELATIONSHIPS, contextMapToolbarIcon, LABEL_COLOR, placeDddElement, } from '@formicoidea/labre-ddd-shared';
 import { NOTATION_NEUTRALS } from '@formicoidea/labre-core/shared/consts';
+import { translateKey, } from '@formicoidea/labre-core/shared/services';
 import { GfxControllerIdentifier } from '@formicoidea/labre-core/std/gfx';
 import { svg } from 'lit';
 import { activateContextMapRelationship, createContextMapBoard, } from './actions.js';
-import { CONTEXT_MAP_ROLE } from './roles.js';
+import { CM_PATTERN_ROLE, CONTEXT_MAP_ROLE } from './roles.js';
+/**
+ * The seeds baked into a placed artefact: the bounded-context bubble's
+ * default caption, and the general-purpose cloud's. The nine relationship
+ * patterns carry no seed of their own — since WS2 the palette ARMS the
+ * connector tool rather than dropping a labelled group, so no word is
+ * written into the document for them any more
+ * (`activateContextMapRelationship`). Declared here, beside the commands that
+ * write them, and imported by `translations.ts` — never the other way, which
+ * would cycle back into `contextMapCommands`.
+ */
+export const CONTEXT_MAP_SEED_BOUNDED_CONTEXT = [
+    'com.labre.ddd-context-map.seed.bounded-context',
+    'Bounded Context',
+];
+export const CONTEXT_MAP_SEED_CLOUD = [
+    'com.labre.ddd-context-map.seed.cloud',
+    'System',
+];
+/**
+ * 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 twelve commands all sit in ONE category:
+ * `section` is what keeps "Boundaries" and "Relationships" apart where the
+ * category would say "Map" once (`docs/adr/0026`).
+ */
+export const CONTEXT_MAP_SEED_LEGEND_BOUNDARIES = [
+    'com.labre.ddd-context-map.seed.legend-boundaries',
+    'Boundaries',
+];
+export const CONTEXT_MAP_SEED_LEGEND_RELATIONSHIPS = [
+    'com.labre.ddd-context-map.seed.legend-relationships',
+    'Relationships',
+];
 /**
  * The Context Map palette as commands: the board, the bounded-context bubble,
  * the cloud and the nine relationship patterns (`docs/adr/0008`).
@@ -33,6 +71,9 @@ const SPECS = [
         board: true,
         icon: boardSwatch,
         run: std => createContextMapBoard(std.get(GfxControllerIdentifier)),
+        // Wider than the shared 260: nine pattern rows carry an abbreviation in
+        // front of their wording ("OHS — Open Host Service") and wrapped at 260.
+        legendBox: { width: 290 },
     },
     {
         id: 'addBoundedContext',
@@ -41,10 +82,17 @@ const SPECS = [
         element: 'bounded-context',
         icon: bubbleSwatch,
         run: std => placeDddElement(std, (surface, cx, cy) => 
-        // The role is what makes a bubble a bounded CONTEXT rather than a blue
-        // pill: every rule in `rules.ts` reads it, and a pill drawn before WS2
-        // carries none and is never evaluated (promesse #71).
-        addBubble(surface, cx, cy, 'Bounded Context', CONTEXT_MAP_ROLE.context)),
+        // Translated HERE and once: the caption is document content the
+        // moment it lands (ADR 0023). The role is what makes a bubble a
+        // bounded CONTEXT rather than a blue pill: every rule in `rules.ts`
+        // reads it, and a pill drawn before WS2 carries none and is never
+        // evaluated (promesse #71).
+        addBubble(surface, cx, cy, translateKey(std, ...CONTEXT_MAP_SEED_BOUNDED_CONTEXT), CONTEXT_MAP_ROLE.context)),
+        legend: {
+            role: CONTEXT_MAP_ROLE.context,
+            section: CONTEXT_MAP_SEED_LEGEND_BOUNDARIES,
+            row: { swatch: 'square', color: CM_BUBBLE.fill },
+        },
     },
     {
         id: 'addCloud',
@@ -52,25 +100,50 @@ const SPECS = [
         iconKey: 'ddd-context-map.cloud',
         element: 'cloud',
         icon: cloudSwatch,
-        run: std => placeDddElement(std, (surface, cx, cy) => addCloud(surface, std, cx, cy, 'System')),
+        run: std => placeDddElement(std, (surface, cx, cy) => 
+        // Translated HERE and once, like the bubble above (ADR 0023). The
+        // role is what lets the automatic legend list the cloud; no rule's
+        // matrix cites it, so a relationship drawn onto one stays unjudged.
+        addCloud(surface, std, cx, cy, translateKey(std, ...CONTEXT_MAP_SEED_CLOUD), CONTEXT_MAP_ROLE.system)),
+        // Beside the bounded context, in the cloud's own lilac. A cloud placed
+        // before `context-map:system` existed carries no role and stays out: the
+        // scan reads roles and nothing else, and telling a legacy cloud from any
+        // other lilac polygon would mean detecting by shape or fill.
+        legend: {
+            role: CONTEXT_MAP_ROLE.system,
+            section: CONTEXT_MAP_SEED_LEGEND_BOUNDARIES,
+            row: { swatch: 'square', color: CLOUD.fill },
+        },
     },
     ...CM_RELATIONSHIPS.map((preset) => ({
         id: `add${preset.kind[0].toUpperCase()}${preset.kind.slice(1)}`,
         label: preset.label,
         iconKey: `ddd-context-map.relationship.${preset.kind}`,
         element: `relationship:${preset.kind}`,
+        kind: 'tool',
         icon: relationSwatch(preset.dashed, preset.upDown),
         // No longer a placement: the nine patterns arm the connector tool and the
         // user DRAWS the relation between two contexts. See
         // `activateContextMapRelationship` for why the free-floating group had to
         // go. The telemetry `element` value is untouched.
         run: std => activateContextMapRelationship(std.get(GfxControllerIdentifier), preset.kind, { upDown: preset.upDown, dashed: preset.dashed }),
+        // One row per PATTERN, not one for `context-map:relationship`: a legend
+        // that said "Relationship" would document nothing a reader could use. Both
+        // the row and the command come out of the same preset, so the dashed
+        // sample marks the two "no real integration" patterns exactly as the board
+        // draws them, and a tenth pattern gets its row with no edit.
+        legend: {
+            role: CM_PATTERN_ROLE[preset.kind],
+            section: CONTEXT_MAP_SEED_LEGEND_RELATIONSHIPS,
+            labelPrefix: preset.abbrev,
+            row: { swatch: 'line', color: LABEL_COLOR, dashed: preset.dashed },
+        },
     })),
 ];
 export const contextMapCommands = SPECS.map((spec, order) => ({
     id: `ddd-context-map.${spec.id}`,
     owner: 'ddd-context-map',
-    kind: 'artefact',
+    kind: spec.kind ?? 'artefact',
     labelKey: `com.labre.commands.ddd-context-map.${spec.id}`,
     labelFallback: spec.label,
     category: 'map',
@@ -86,5 +159,12 @@ export const contextMapCommands = SPECS.map((spec, order) => ({
         element: spec.element,
         board: spec.board,
     },
+    legend: spec.legend,
+    legendBox: spec.legendBox,
 }));
-export const contextMapCommandIcons = Object.fromEntries(SPECS.map(spec => [spec.iconKey, spec.icon]));
+export const contextMapCommandIcons = {
+    ...Object.fromEntries(SPECS.map(spec => [spec.iconKey, spec.icon])),
+    // The senior button's 56×56 glyph, so `FrameworkDescriptor.iconKey` resolves
+    // through `getCommandIcon`.
+    'ddd-context-map.toolbar': contextMapToolbarIcon,
+};

package/dist/nudges.js

@@ -34,10 +34,10 @@ export const CONTEXT_MAP_NUDGES = [
         /**
          * The rule this nudge replaces. "Every downstream of a Big Ball of Mud is
          * protected" is decidable in principle — walk the edges out of the cloud and
-         * look for an ACL — and undecidable in practice on THIS canvas: the cloud
-         * carries no role (a v1 cut), so there is nothing for a rule to walk from,
-         * and a shape somebody drew a mess with is not a claim that it IS one.
-         * Level 2 is the honest home for it until the cloud has a role.
+         * look for an ACL — and undecidable in practice on THIS canvas: the cloud's
+         * role is `context-map:system`, which says "a system", not "a mess", and a
+         * shape somebody drew a mess with is not a claim that it IS one. Level 2 is
+         * the honest home for it.
          */
         id: 'context-map.q3-bbom-protected',
         framework: 'ddd-context-map',

package/dist/reading.d.ts

@@ -16,7 +16,10 @@ import type { ReadingProfile } from '@formicoidea/labre-core/blocks/surface';
  *
  * `context-map:context` is the only artefact this notation places; the board is
  * the FRAME and specialises nothing, exactly so that what is written about the
- * contexts never falls on the card they sit on.
+ * contexts never falls on the card they sit on. The cloud
+ * (`context-map:system`) is not a subject either: its role is there for the
+ * legend, the map does not model what is inside it, and it is read exactly as
+ * much as when it carried no role — not at all.
  *
  * ## The nine patterns are read through their parent
  *

package/dist/reading.js

@@ -16,7 +16,10 @@ import { CONTEXT_MAP_ROLE, CONTEXT_MAP_ROLES } from './roles.js';
  *
  * `context-map:context` is the only artefact this notation places; the board is
  * the FRAME and specialises nothing, exactly so that what is written about the
- * contexts never falls on the card they sit on.
+ * contexts never falls on the card they sit on. The cloud
+ * (`context-map:system`) is not a subject either: its role is there for the
+ * legend, the map does not model what is inside it, and it is read exactly as
+ * much as when it carried no role — not at all.
  *
  * ## The nine patterns are read through their parent
  *

package/dist/roles.d.ts

@@ -4,10 +4,11 @@ import type { RoleDefs } from '@formicoidea/labre-core/std/gfx';
  * Context Mapping role vocabulary (WS2).
  *
  * Roles are the semantic identity of a Context Map artefact — no rule will ever
- * look at a shape type. Three families:
+ * look at a shape type. Four families:
  *
  * - the **board** (`context-map:board`), the white card the map is drawn on;
  * - the **bounded context** (`context-map:context`), the blue pill;
+ * - the **system** (`context-map:system`), the cloud — see below;
  * - the **relationship** (`context-map:relationship`), the edge parent, with
  *   one child per DDD pattern.
  *
@@ -37,9 +38,27 @@ import type { RoleDefs } from '@formicoidea/labre-core/std/gfx';
  * would show a sentence the framework does not say. They therefore declare none,
  * which is exactly what an untyped edge already did.
  *
+ * ## The cloud is a `system`, not a Big Ball of Mud
+ *
+ * DDD Crew's cheat sheet defines Big Ball of Mud as "a (part of a) system which
+ * is a mess" — a DEMARCATION of a system's quality, not a kind of node. The
+ * cloud is the thing being demarcated: something out there the map integrates
+ * with and does not model as a bounded context (a legacy, a vendor package, a
+ * mess). Naming the role `big-ball-of-mud` would make every cloud a quality
+ * claim the user never made, and the id `context-map:bbom` is the PATTERN's
+ * already. So the role is the neutral `context-map:system`, and its label keeps
+ * the Big Ball of Mud reading in sight because that is what the palette entry
+ * has always said.
+ *
+ * The role exists so the automatic legend can SEE a cloud (detection is by role
+ * only). It is deliberately absent from every rule's endpoint matrix: a
+ * relationship drawn onto a cloud stays outside the alphabet, hence unjudged
+ * (`rules.ts`, CM1).
+ *
  * ## Compat
  *
- * Nothing is backfilled. Relationships drawn before these roles existed — the
+ * Nothing is backfilled. A cloud placed before `context-map:system` existed
+ * carries no role, stays out of the legend, and is otherwise the same drawing. Relationships drawn before these roles existed — the
  * old free connector + tag + U/D markers group — carry no role and are never
  * evaluated (promesse #71): they stay drawings, in the documents they are in.
  */
@@ -47,7 +66,7 @@ import type { RoleDefs } from '@formicoidea/labre-core/std/gfx';
 export type ContextMapPatternKind = (typeof CM_RELATIONSHIPS)[number]['kind'];
 export type ContextMapRoleId = `context-map:${string}`;
 export declare const CM_PATTERN_ROLE: Record<ContextMapPatternKind, ContextMapRoleId>;
-/** The three roles that are not a pattern, plus the pattern ids. */
+/** The four roles that are not a pattern, plus the pattern ids. */
 export declare const CONTEXT_MAP_ROLE: {
     readonly partnership: `context-map:${string}`;
     readonly sharedKernel: `context-map:${string}`;
@@ -60,6 +79,7 @@ export declare const CONTEXT_MAP_ROLE: {
     readonly bbom: `context-map:${string}`;
     readonly board: "context-map:board";
     readonly context: "context-map:context";
+    readonly system: "context-map:system";
     readonly relationship: "context-map:relationship";
 };
 export declare const CONTEXT_MAP_ROLES: RoleDefs;

package/dist/roles.js

@@ -10,10 +10,11 @@ export const CM_PATTERN_ROLE = Object.fromEntries(CM_RELATIONSHIPS.map(preset =>
     preset.kind,
     `context-map:${kebab(preset.kind)}`,
 ]));
-/** The three roles that are not a pattern, plus the pattern ids. */
+/** The four roles that are not a pattern, plus the pattern ids. */
 export const CONTEXT_MAP_ROLE = {
     board: 'context-map:board',
     context: 'context-map:context',
+    system: 'context-map:system',
     relationship: 'context-map:relationship',
     ...CM_PATTERN_ROLE,
 };
@@ -40,6 +41,14 @@ const DEFS = [
         labelKey: 'com.labre.ddd-context-map.role.context',
         labelFallback: 'Bounded context',
     },
+    // The cloud. Specialises nothing — above all not `context-map:context`, which
+    // would pull it into the endpoint alphabet and the off-board rule.
+    {
+        id: CONTEXT_MAP_ROLE.system,
+        kind: 'node',
+        labelKey: 'com.labre.ddd-context-map.role.system',
+        labelFallback: 'System / Big Ball of Mud',
+    },
     // The edge parent. Carries no `direction` of its own: five of its nine
     // children have one and four do not, and a verb on the parent would be
     // inherited by the symmetric patterns that deny having one.

package/dist/rules.js

@@ -59,10 +59,12 @@ import { CONTEXT_MAP_ROLE, CONTEXT_MAP_ROLES } from './roles.js';
  * tolerable but the correct notation. Judging it would be indicting the act of
  * sketching (PRD principle 8).
  *
- * The branch becomes reachable the day a second NODE role lands — a role on the
- * cloud, say — and on that day this declaration already says what to do with it
- * without a line changing. Until then `offMatrix` carries no words of its own
- * and the rule's own sentence stands behind it, unused.
+ * The cloud has a role of its own since 17/09/2026 (`context-map:system`, there
+ * so the legend can list it) and that changes nothing here: the alphabet is the
+ * roles the MATRIX cites, not the roles the vocabulary declares, and `system`
+ * is cited by no triplet. The branch becomes reachable only the day a second
+ * node role is written INTO a triplet. Until then `offMatrix` carries no words
+ * of its own and the rule's own sentence stands behind it, unused.
  */
 const relationshipEndpoints = {
     id: 'context-map.relationship-endpoints',

package/dist/templates.js

@@ -30,8 +30,13 @@ const BUBBLE_PREVIEW = `<svg ${ATTRS} fill="none"><rect x="20" y="25" width="95"
 const CLOUD_PREVIEW = `<svg ${ATTRS} fill="none"><path d="M30 52 C18 52 16 40 26 37 C24 25 42 24 46 32 C50 22 70 24 70 35 C84 32 90 46 78 50 Z" fill="${CLOUD.fill}" stroke="${CLOUD.stroke}" stroke-width="1.4"/></svg>`;
 export const contextMapTemplateCategory = {
     name: 'Context Map',
+    // Reuses the senior button's own key — see `TemplateCategory.nameKey`.
+    nameKey: 'com.labre.framework.ddd-context-map',
     templates: [
-        templateFromCommand(byLabel('Context Map board'), BOARD_PREVIEW, 'Context Map board'),
+        // No name override: it would only restate `addBoard`'s own
+        // `labelFallback` as a second literal the panel could not translate — see
+        // `resolveTemplateName`, which reads the command's `labelKey` instead.
+        templateFromCommand(byLabel('Context Map board'), BOARD_PREVIEW),
         templateFromCommand(byLabel('Bounded Context'), BUBBLE_PREVIEW, 'Context Map — Bounded Context'),
         templateFromCommand(byLabel('Cloud / System (Big Ball of Mud)'), CLOUD_PREVIEW, 'Context Map — Cloud / System'),
     ],

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

@@ -1,16 +1,13 @@
-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 what is actually drawn on the board. Registered ALWAYS-ON
- * (`DddContextMapRenderViewExtension`) — a stored board must stay usable with
- * the Context Map 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 Context Map button switched off
+ * (`docs/adr/0009`) — it keeps its handles, and everything already drawn on it,
+ * legend boxes included, keeps being painted.
  *
- * This is THE legend of the module. The palette used to also offer a static,
- * full-notation one; the PO's recette (27/08/2026) removed it — two legends were
- * two answers to one question, and the honest answer is what is actually drawn.
- * Same single-gesture shape as Core Domain Chart.
+ * The legend BUTTON moved out of here to {@link contextMapBoardToolingToolbarConfig}
+ * (`docs/adr/0026`): generating one is a gesture the flag may take away, even
+ * though what it writes is document content.
  */
 export declare const contextMapBoardToolbarConfig: {
     readonly actions: [{
@@ -19,12 +16,24 @@ export declare const contextMapBoardToolbarConfig: {
         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 contextMapBoardToolbarExtension: 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:contextMap` 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-context-map` 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 map, and leaves the stored board its handles and
+ * everything already written on it. The legend rows themselves are derived from
+ * `contextMapCommands` — the module writes no table (`docs/adr/0026`).
+ */
+export declare const contextMapBoardToolingToolbarConfig: 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 { ContextMapBoardElementModel } 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 { CONTEXT_MAP_AUTO_LEGEND } from '../legend.js';
 const ResizeIcon = html `<svg
   width="24"
   height="24"
@@ -19,17 +17,14 @@ 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 what is actually drawn on the board. Registered ALWAYS-ON
- * (`DddContextMapRenderViewExtension`) — a stored board must stay usable with
- * the Context Map 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 Context Map button switched off
+ * (`docs/adr/0009`) — it keeps its handles, and everything already drawn on it,
+ * legend boxes included, keeps being painted.
  *
- * This is THE legend of the module. The palette used to also offer a static,
- * full-notation one; the PO's recette (27/08/2026) removed it — two legends were
- * two answers to one question, and the honest answer is what is actually drawn.
- * Same single-gesture shape as Core Domain Chart.
+ * The legend BUTTON moved out of here to {@link contextMapBoardToolingToolbarConfig}
+ * (`docs/adr/0026`): generating one is a gesture the flag may take away, even
+ * though what it writes is document content.
  */
 export const contextMapBoardToolbarConfig = {
     actions: [
@@ -53,31 +48,6 @@ export const contextMapBoardToolbarConfig = {
                 }
             },
         },
-        {
-            id: 'b.legend',
-            tooltipWording: BOARD_LEGEND_NOTATION,
-            icon: dddLegendIcon,
-            run(ctx) {
-                const board = ctx.getSurfaceModelsByType(ContextMapBoardElementModel)[0];
-                if (!board)
-                    return;
-                createAutoLegend(ctx.std, board, CONTEXT_MAP_AUTO_LEGEND);
-                ctx.std
-                    .getOptional(TelemetryProvider)
-                    ?.track('FrameworkLegendCreated', {
-                    // The WIRE value, which is not the module id: the framework is
-                    // `ddd-context-map` in code and `context-map` 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: 'context-map',
-                    element: 'legend',
-                    page: 'whiteboard editor',
-                    segment: 'element toolbar',
-                    module: 'context-map toolbar',
-                });
-            },
-        },
     ],
     when: (ctx) => ctx.getSurfaceModelsByType(ContextMapBoardElementModel).length > 0,
 };
@@ -85,3 +55,36 @@ export const contextMapBoardToolbarExtension = ToolbarModuleExtension({
     id: BlockFlavourIdentifier('affine:surface:contextMap'),
     config: contextMapBoardToolbarConfig,
 });
+/**
+ * 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:contextMap` 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-context-map` 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 map, and leaves the stored board its handles and
+ * everything already written on it. The legend rows themselves are derived from
+ * `contextMapCommands` — the module writes no table (`docs/adr/0026`).
+ */
+export const contextMapBoardToolingToolbarConfig = {
+    actions: [
+        legendToolbarAction({
+            Model: ContextMapBoardElementModel,
+            owner: 'ddd-context-map',
+            // The WIRE value, which is not the module id: the framework is
+            // `ddd-context-map` in code and `context-map` in PostHog (`frameworks.ts`
+            // `telemetryKey`). Unchanged by the button becoming shared.
+            framework: 'context-map',
+        }),
+        // The generic dropdown, not a Context Map 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: contextMapBoardToolbarConfig.when,
+};

package/dist/toolbar/palette.d.ts

@@ -0,0 +1,32 @@
+import type { FrameworkPalette, NamedPalette } from '@formicoidea/labre-core/components/color-picker';
+import type { ChromeWording } from '@formicoidea/labre-core/shared/services';
+/**
+ * The Context Map 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, never seeded into a document. The keys are
+ * this framework's own even though the colours come from `ddd-shared`, which
+ * declares no `com.labre.*` key of its own by design (see its header).
+ */
+export declare const CONTEXT_MAP_PALETTE_WORDING_BUBBLE: ChromeWording;
+export declare const CONTEXT_MAP_PALETTE_WORDING_BUBBLE_OUTLINE: ChromeWording;
+export declare const CONTEXT_MAP_PALETTE_WORDING_CLOUD: ChromeWording;
+export declare const CONTEXT_MAP_PALETTE_WORDING_COLLABORATION: ChromeWording;
+export declare const CONTEXT_MAP_PALETTE_WORDING_XAAS: ChromeWording;
+export declare const CONTEXT_MAP_PALETTE_WORDING_FACILITATING: ChromeWording;
+export declare const CONTEXT_MAP_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 CONTEXT_MAP_PALETTE_LIST: NamedPalette[];
+/**
+ * The Context Map's page of the colour pickers' carousel (`docs/adr/0027`).
+ * Registered from the FLAG-GATED view extension, because offering hues is
+ * TOOLING: a map drawn while the flag was on keeps every colour it was painted
+ * with when the flag goes off (`docs/adr/0009`).
+ */
+export declare const CONTEXT_MAP_FRAMEWORK_PALETTE: FrameworkPalette;

package/dist/toolbar/palette.js

@@ -0,0 +1,112 @@
+import { CLOUD, CM_BUBBLE, TEAM_TOPOLOGIES, } from '@formicoidea/labre-ddd-shared';
+import { neutralPalettes } from '@formicoidea/labre-core/gfx/shape';
+/**
+ * The Context Map 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, never seeded into a document. The keys are
+ * this framework's own even though the colours come from `ddd-shared`, which
+ * declares no `com.labre.*` key of its own by design (see its header).
+ */
+export const CONTEXT_MAP_PALETTE_WORDING_BUBBLE = [
+    'com.labre.ddd-context-map.palette.bounded-context-blue',
+    'Bounded context blue',
+];
+export const CONTEXT_MAP_PALETTE_WORDING_BUBBLE_OUTLINE = [
+    'com.labre.ddd-context-map.palette.bounded-context-outline',
+    'Bounded context outline',
+];
+export const CONTEXT_MAP_PALETTE_WORDING_CLOUD = [
+    'com.labre.ddd-context-map.palette.big-ball-of-mud-lilac',
+    'Big ball of mud lilac',
+];
+export const CONTEXT_MAP_PALETTE_WORDING_COLLABORATION = [
+    'com.labre.ddd-context-map.palette.collaboration-green',
+    'Collaboration green',
+];
+export const CONTEXT_MAP_PALETTE_WORDING_XAAS = [
+    'com.labre.ddd-context-map.palette.x-as-a-service-blue',
+    'X-as-a-Service blue',
+];
+export const CONTEXT_MAP_PALETTE_WORDING_FACILITATING = [
+    'com.labre.ddd-context-map.palette.facilitating-yellow',
+    'Facilitating yellow',
+];
+export const CONTEXT_MAP_PALETTE_WORDINGS = [
+    CONTEXT_MAP_PALETTE_WORDING_BUBBLE,
+    CONTEXT_MAP_PALETTE_WORDING_BUBBLE_OUTLINE,
+    CONTEXT_MAP_PALETTE_WORDING_CLOUD,
+    CONTEXT_MAP_PALETTE_WORDING_COLLABORATION,
+    CONTEXT_MAP_PALETTE_WORDING_XAAS,
+    CONTEXT_MAP_PALETTE_WORDING_FACILITATING,
+];
+/**
+ * The Team Topologies interaction-mode fills, by kind — derived from
+ * {@link TEAM_TOPOLOGIES} rather than restated.
+ */
+const TEAM_MODE_FILL = Object.fromEntries(TEAM_TOPOLOGIES.map(mode => [mode.kind, mode.fill]));
+/**
+ * What a Context Map is drawn in: the bounded-context bubble (its wash and the
+ * blue it is outlined in), the Big-Ball-of-Mud cloud's lilac, and the three
+ * Team Topologies interaction modes — collaboration, X-as-a-Service,
+ * facilitating — whose LETTER is the notation and whose colour is the
+ * shorthand a reader picks up first.
+ *
+ * Every value is read off the shared DDD tables rather than restated, so the
+ * shelf and the notation cannot drift apart. They are SHORTCUTS, never
+ * constraints: no rule of this pack reads a colour.
+ */
+const CONTEXT_MAP_PALETTES = [
+    {
+        key: 'Bounded context blue',
+        value: CM_BUBBLE.fill,
+        labelWording: CONTEXT_MAP_PALETTE_WORDING_BUBBLE,
+    },
+    {
+        key: 'Bounded context outline',
+        value: CM_BUBBLE.stroke,
+        labelWording: CONTEXT_MAP_PALETTE_WORDING_BUBBLE_OUTLINE,
+    },
+    {
+        key: 'Big ball of mud lilac',
+        value: CLOUD.fill,
+        labelWording: CONTEXT_MAP_PALETTE_WORDING_CLOUD,
+    },
+    {
+        key: 'Collaboration green',
+        value: TEAM_MODE_FILL.collaboration,
+        labelWording: CONTEXT_MAP_PALETTE_WORDING_COLLABORATION,
+    },
+    {
+        key: 'X-as-a-Service blue',
+        value: TEAM_MODE_FILL.xaas,
+        labelWording: CONTEXT_MAP_PALETTE_WORDING_XAAS,
+    },
+    {
+        key: 'Facilitating yellow',
+        value: TEAM_MODE_FILL.facilitating,
+        labelWording: CONTEXT_MAP_PALETTE_WORDING_FACILITATING,
+    },
+];
+/**
+ * From the default editor palette we keep ONLY the neutrals — the historical
+ * colours say nothing in this notation.
+ */
+export const CONTEXT_MAP_PALETTE_LIST = [
+    ...CONTEXT_MAP_PALETTES,
+    ...neutralPalettes(),
+];
+/**
+ * The Context Map's page of the colour pickers' carousel (`docs/adr/0027`).
+ * Registered from the FLAG-GATED view extension, because offering hues is
+ * TOOLING: a map drawn while the flag was on keeps every colour it was painted
+ * with when the flag goes off (`docs/adr/0009`).
+ */
+export const CONTEXT_MAP_FRAMEWORK_PALETTE = {
+    framework: 'ddd-context-map',
+    labelWording: ['com.labre.framework.ddd-context-map', 'Context Map'],
+    palettes: CONTEXT_MAP_PALETTE_LIST,
+};

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

@@ -4,4 +4,5 @@ export declare class EdgelessDddContextMapSeniorButton extends DddSeniorButtonBa
     protected label: string;
     protected labelKey: string;
     protected icon: import("lit-html").TemplateResult<2>;
+    protected owner: "ddd-context-map";
 }

package/dist/toolbar/senior-button.js

@@ -6,5 +6,6 @@ export class EdgelessDddContextMapSeniorButton extends DddSeniorButtonBase {
         this.label = 'Context Map';
         this.labelKey = 'com.labre.framework.ddd-context-map';
         this.icon = contextMapToolbarIcon;
+        this.owner = 'ddd-context-map';
     }
 }

package/dist/translations.js

@@ -1,11 +1,12 @@
 import { collectTranslationKeys, commandCategoryTranslationEntries, commandTranslationEntries, mergeTranslationEntries, } from '@formicoidea/labre-core/std';
 import { CONTEXT_MAP_BACKGROUND } from './background.js';
-import { contextMapCommands } from './commands.js';
+import { CONTEXT_MAP_SEED_BOUNDED_CONTEXT, CONTEXT_MAP_SEED_CLOUD, CONTEXT_MAP_SEED_LEGEND_BOUNDARIES, CONTEXT_MAP_SEED_LEGEND_RELATIONSHIPS, contextMapCommands, } from './commands.js';
 import { CONTEXT_MAP_NUDGES } from './nudges.js';
 import { CONTEXT_MAP_PROFILES } from './profiles.js';
 import { CONTEXT_MAP_READING } from './reading.js';
 import { CONTEXT_MAP_ROLES } from './roles.js';
 import { CONTEXT_MAP_RULES } from './rules.js';
+import { CONTEXT_MAP_PALETTE_WORDINGS } from './toolbar/palette.js';
 /**
  * THIS framework's contribution to the translation-key manifest — every
  * `com.labre.*` key Context Mapping can hand to `TranslationProvider.t`,
@@ -29,4 +30,17 @@ commandCategoryTranslationEntries(contextMapCommands), collectTranslationKeys('r
 // 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', CONTEXT_MAP_READING));
+collectTranslationKeys('reading', CONTEXT_MAP_READING), [
+    CONTEXT_MAP_SEED_BOUNDED_CONTEXT,
+    CONTEXT_MAP_SEED_CLOUD,
+    CONTEXT_MAP_SEED_LEGEND_BOUNDARIES,
+    CONTEXT_MAP_SEED_LEGEND_RELATIONSHIPS,
+].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.
+CONTEXT_MAP_PALETTE_WORDINGS.map(([key, fallback]) => ({
+    key,
+    fallback,
+    source: 'chrome',
+})));

package/dist/view.js

@@ -1,4 +1,5 @@
-import { QualityNudgeExtension, ReadingProfileExtension, validationToolbarConfig, ValidationProfileExtension, ValidationRuleExtension, } from '@formicoidea/labre-core/blocks/surface';
+import { 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 } from '@formicoidea/labre-core/shared/services';
 import { TemplateCategoryExtension } from '@formicoidea/labre-core/gfx/template';
@@ -14,7 +15,8 @@ import { CONTEXT_MAP_PROFILES } from './profiles.js';
 import { CONTEXT_MAP_READING } from './reading.js';
 import { CONTEXT_MAP_ROLES } from './roles.js';
 import { CONTEXT_MAP_RULES } from './rules.js';
-import { contextMapBoardToolbarExtension } from './toolbar/board-config.js';
+import { contextMapBoardToolbarExtension, contextMapBoardToolingToolbarConfig, } from './toolbar/board-config.js';
+import { CONTEXT_MAP_FRAMEWORK_PALETTE } from './toolbar/palette.js';
 import { contextMapSeniorTool } from './toolbar/senior-tool.js';
 /**
  * Context Map rendering — ALWAYS registered, independent of any flag.
@@ -70,16 +72,16 @@ export class DddContextMapViewExtension extends ViewExtensionProvider {
             context.register(ValidationRuleExtension(CONTEXT_MAP_RULES));
             context.register(ValidationProfileExtension(CONTEXT_MAP_PROFILES));
             context.register(QualityNudgeExtension(CONTEXT_MAP_NUDGES));
-            // The Validation dropdown on a selected board's contextual toolbar. A
-            // SECOND module on the same element, through the `custom:` flavour slot:
-            // `contextMapBoardToolbarExtension` 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: `contextMapBoardToolbarExtension` is registered
+            // always-on because a stored board must keep its resize toggle, while
+            // generating a legend and choosing how hard to check the map are tooling
+            // and belong here.
             context.register(ToolbarModuleExtension({
                 id: BlockFlavourIdentifier('custom:affine:surface:contextMap'),
-                config: validationToolbarConfig,
+                config: contextMapBoardToolingToolbarConfig,
             }));
             // The reversed reading (MF3): what the map says about a bounded context,
             // on demand. One declaration — the roles and the relationship edge, both
@@ -88,6 +90,11 @@ export class DddContextMapViewExtension extends ViewExtensionProvider {
             // profile, so it goes with the flag without either side naming the other.
             context.register(ReadingProfileExtension(CONTEXT_MAP_READING));
             context.register(contextMapSeniorTool);
+            // The Context Map'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 map are content
+            // and do not move (`docs/adr/0009`).
+            context.register(FrameworkPaletteExtension(CONTEXT_MAP_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-context-map",
   "description": "Labre ddd-context-map 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,20 +0,0 @@
-import { type AutoLegendSpec } from '@formicoidea/labre-ddd-shared';
-/**
- * What the Context Map 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 presets the palette itself draws from
- * ({@link CM_RELATIONSHIPS}, {@link CM_BUBBLE}) and from the role vocabulary's
- * own labels, never restated. A tenth pattern added to `CM_RELATIONSHIPS` gets
- * its legend row here with no edit, the same way it gets its role.
- *
- * ## What is missing, and why
- *
- * The **cloud** (the "System / Big Ball of Mud" blob) carries no role: it is
- * created neutral by `commands.ts`, deliberately — the endpoint grammar treats a
- * relationship drawn onto a cloud as a sketch and stays silent on it. Detection
- * is by role and only by role, so the automatic legend cannot list the cloud and
- * does not pretend to. The palette's static Legend entry still documents it, and
- * the day the cloud earns a role its row lands here in one line.
- */
-export declare const CONTEXT_MAP_AUTO_LEGEND: AutoLegendSpec;

package/dist/legend.js

@@ -1,56 +0,0 @@
-import { CM_BUBBLE, CM_RELATIONSHIPS, LABEL_COLOR, roleLabel, } from '@formicoidea/labre-ddd-shared';
-import { CM_PATTERN_ROLE, CONTEXT_MAP_ROLE, CONTEXT_MAP_ROLES } from './roles.js';
-/**
- * What the Context Map 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 presets the palette itself draws from
- * ({@link CM_RELATIONSHIPS}, {@link CM_BUBBLE}) and from the role vocabulary's
- * own labels, never restated. A tenth pattern added to `CM_RELATIONSHIPS` gets
- * its legend row here with no edit, the same way it gets its role.
- *
- * ## What is missing, and why
- *
- * The **cloud** (the "System / Big Ball of Mud" blob) carries no role: it is
- * created neutral by `commands.ts`, deliberately — the endpoint grammar treats a
- * relationship drawn onto a cloud as a sketch and stays silent on it. Detection
- * is by role and only by role, so the automatic legend cannot list the cloud and
- * does not pretend to. The palette's static Legend entry still documents it, and
- * the day the cloud earns a role its row lands here in one line.
- */
-export const CONTEXT_MAP_AUTO_LEGEND = {
-    title: 'Legend',
-    width: 290,
-    roles: CONTEXT_MAP_ROLES,
-    sections: [
-        {
-            title: 'Boundaries',
-            entries: [
-                {
-                    role: CONTEXT_MAP_ROLE.context,
-                    row: {
-                        swatch: 'square',
-                        color: CM_BUBBLE.fill,
-                        label: roleLabel(CONTEXT_MAP_ROLES, CONTEXT_MAP_ROLE.context),
-                    },
-                },
-            ],
-        },
-        {
-            title: 'Relationships',
-            // One entry per PATTERN, not one for `context-map:relationship`: a legend
-            // that said "Relationship" would document nothing a reader could use. The
-            // dashed sample marks the two "no real integration" patterns, exactly as
-            // the board draws them.
-            entries: CM_RELATIONSHIPS.map(preset => ({
-                role: CM_PATTERN_ROLE[preset.kind],
-                row: {
-                    swatch: 'line',
-                    color: LABEL_COLOR,
-                    dashed: preset.dashed,
-                    label: `${preset.abbrev} — ${preset.label}`,
-                },
-            })),
-        },
-    ],
-};