@formicoidea/labre-ddd-shared 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/index.d.ts

@@ -1,6 +1,6 @@
 export * from './shared/consts.js';
-export * from './shared/legend-auto.js';
 export * from './shared/prefabs.js';
 export * from './shared/utils.js';
 export * from './toolbar/icons.js';
 export { DddSeniorButtonBase } from './toolbar/senior-buttons.js';
+export * from './translations.js';

package/dist/index.js

@@ -1,6 +1,6 @@
 export * from './shared/consts.js';
-export * from './shared/legend-auto.js';
 export * from './shared/prefabs.js';
 export * from './shared/utils.js';
 export * from './toolbar/icons.js';
 export { DddSeniorButtonBase } from './toolbar/senior-buttons.js';
+export * from './translations.js';

package/dist/shared/consts.d.ts

@@ -3,6 +3,20 @@
  * (sticky, dot, bubble, connector, label) from these presets — no duplicated
  * component definitions across the Event Storming / Context Map / Core Domain
  * sub-menus.
+ *
+ * ## Where each preset's `label` actually gets a key
+ *
+ * Not here: this file is generic across the three frameworks and declares no
+ * `com.labre.*` key of its own. Every preset below is reused, byte for byte,
+ * as the `labelFallback` of the placement (or connector-arming) command it
+ * feeds in its framework's own `commands.ts` — `ddd-context-map.add<Kind>`,
+ * `ddd-core-domain.<preset>`, `ddd-event-storming.<preset>` — which is where
+ * the command's own `labelKey` (`com.labre.commands.<framework>.<id>`) lives.
+ * `getCommands()` walks registered commands into the translation manifest
+ * automatically ("declared data", see
+ * `packages/affine/shared/src/services/translation-service/README.md`), so a
+ * second key here for the same English word would only be the drift the
+ * manifest guard exists to catch.
  */
 /** Square sticky side (px, canvas reference). */
 export declare const STICKY_SIZE = 120;
@@ -209,7 +223,10 @@ export declare const CD_SUBDOMAINS: readonly [{
 }];
 export declare const DOT_SIZE = 26;
 export declare const MOVEMENT_COLOR = "#ff3333";
-/** Label and legend text: the shared notation scale's artefact ink. */
-export declare const LABEL_COLOR: string;
-export declare const LABEL_FONT = "blocksuite:surface:Inter";
-export declare const LABEL_FONT_SIZE = 14;
+/**
+ * Label text: ink, family and size. Declared by the legend engine
+ * (`@labre/affine-block-surface`), which writes its rows in the very same
+ * three values — one declaration, so a DDD caption and the legend line that
+ * explains it cannot drift apart.
+ */
+export { LABEL_COLOR, LABEL_FONT, LABEL_FONT_SIZE, } from '@formicoidea/labre-core/blocks/surface';

package/dist/shared/consts.js

@@ -4,6 +4,20 @@ import { NOTATION_NEUTRALS } from '@formicoidea/labre-core/shared/consts';
  * (sticky, dot, bubble, connector, label) from these presets — no duplicated
  * component definitions across the Event Storming / Context Map / Core Domain
  * sub-menus.
+ *
+ * ## Where each preset's `label` actually gets a key
+ *
+ * Not here: this file is generic across the three frameworks and declares no
+ * `com.labre.*` key of its own. Every preset below is reused, byte for byte,
+ * as the `labelFallback` of the placement (or connector-arming) command it
+ * feeds in its framework's own `commands.ts` — `ddd-context-map.add<Kind>`,
+ * `ddd-core-domain.<preset>`, `ddd-event-storming.<preset>` — which is where
+ * the command's own `labelKey` (`com.labre.commands.<framework>.<id>`) lives.
+ * `getCommands()` walks registered commands into the translation manifest
+ * automatically ("declared data", see
+ * `packages/affine/shared/src/services/translation-service/README.md`), so a
+ * second key here for the same English word would only be the drift the
+ * manifest guard exists to catch.
  */
 /** Square sticky side (px, canvas reference). */
 export const STICKY_SIZE = 120;
@@ -201,7 +215,10 @@ export const CD_SUBDOMAINS = [
 ];
 export const DOT_SIZE = 26;
 export const MOVEMENT_COLOR = '#ff3333';
-/** Label and legend text: the shared notation scale's artefact ink. */
-export const LABEL_COLOR = NOTATION_NEUTRALS.ink;
-export const LABEL_FONT = 'blocksuite:surface:Inter';
-export const LABEL_FONT_SIZE = 14;
+/**
+ * Label text: ink, family and size. Declared by the legend engine
+ * (`@labre/affine-block-surface`), which writes its rows in the very same
+ * three values — one declaration, so a DDD caption and the legend line that
+ * explains it cannot drift apart.
+ */
+export { LABEL_COLOR, LABEL_FONT, LABEL_FONT_SIZE, } from '@formicoidea/labre-core/blocks/surface';

package/dist/shared/prefabs.d.ts

@@ -121,44 +121,5 @@ export declare function addMarker(surface: Surface, std: BlockStdScope, cx: numb
     role?: string;
 }): string;
 /** A cloud (Big Ball of Mud / general-purpose boundary): a smoothed closed bezier polygon. */
-export declare function addCloud(surface: Surface, std: BlockStdScope, cx: number, cy: number, label?: string): string;
-export interface LegendRow {
-    swatch: 'dot' | 'square' | 'line';
-    color: string;
-    letter?: string;
-    label: string;
-    /**
-     * `line` swatches only: draw the sample as two short segments rather than one
-     * bar, so a dashed pattern (Separate Ways, Big Ball of Mud, a Core Domain
-     * movement) reads in the legend the way it reads on the board. A legend that
-     * showed a solid bar for a dashed link would be telling a small lie about the
-     * notation it documents.
-     */
-    dashed?: boolean;
-}
-export interface LegendSection {
-    title?: string;
-    rows: LegendRow[];
-}
-/**
- * How big the box {@link addLegend} would draw for these sections is — without
- * drawing it. The auto-legend needs the height to drop the box bottom-left of a
- * background, and measuring is the only honest way to get it: the box grows with
- * the number of sub-titles and rows, which is exactly what the detection pass
- * decides.
- */
-export declare function measureLegend(sections: readonly LegendSection[], width?: number): {
-    width: number;
-    height: number;
-};
-/**
- * A boxed legend: a bordered container with a bold "Legend" title and bold
- * section sub-titles, each row a swatch (dot / square+letter / line) + label.
- * Shared by the Core Domain and Context Map tools. Returns the grouped id.
- */
-export declare function addLegend(surface: Surface, std: BlockStdScope, x: number, y: number, opts: {
-    title: string;
-    sections: LegendSection[];
-    width?: number;
-}): string;
+export declare function addCloud(surface: Surface, std: BlockStdScope, cx: number, cy: number, label?: string, role?: string): string;
 export {};

package/dist/shared/prefabs.js

@@ -209,7 +209,7 @@ export function addMarker(surface, std, cx, cy, opts) {
     return groupIds(std, ids);
 }
 /** A cloud (Big Ball of Mud / general-purpose boundary): a smoothed closed bezier polygon. */
-export function addCloud(surface, std, cx, cy, label) {
+export function addCloud(surface, std, cx, cy, label, role) {
     const { w, h, fill, stroke } = CLOUD;
     const cloud = surface.addElement({
         type: 'shape',
@@ -223,111 +223,12 @@ export function addCloud(surface, std, cx, cy, label) {
         shapeStyle: ShapeStyle.General,
         roughness: 0,
         xywh: new Bound(cx - w / 2, cy - h / 2, w, h).serialize(),
+        // On the POLYGON, never on the group: the polygon is what a relationship
+        // binds to and what the legend scan meets.
+        ...(role ? { role } : {}),
     });
     if (!label)
         return cloud;
     const lbl = addText(surface, cx - w / 2 + 12, cy - LABEL_FONT_SIZE / 2, w - 24, label, NOTATION_NEUTRALS.ink, LABEL_FONT, LABEL_FONT_SIZE);
     return groupIds(std, [cloud, lbl]);
 }
-/**
- * The legend box's geometry, in one place because two callers need it: the one
- * that DRAWS the box and the one that has to know how tall it will be before
- * drawing it (see {@link measureLegend}).
- */
-const LEGEND_METRICS = {
-    DEFAULT_W: 260,
-    PAD: 16,
-    TITLE_H: 32,
-    SUB_H: 26,
-    ROW_H: 28,
-    /** Swatch side (a `line` swatch is this long). */
-    SW: 16,
-};
-/**
- * How big the box {@link addLegend} would draw for these sections is — without
- * drawing it. The auto-legend needs the height to drop the box bottom-left of a
- * background, and measuring is the only honest way to get it: the box grows with
- * the number of sub-titles and rows, which is exactly what the detection pass
- * decides.
- */
-export function measureLegend(sections, width) {
-    const { DEFAULT_W, PAD, TITLE_H, SUB_H, ROW_H } = LEGEND_METRICS;
-    let subs = 0;
-    let rows = 0;
-    for (const s of sections) {
-        if (s.title)
-            subs++;
-        rows += s.rows.length;
-    }
-    return {
-        width: width ?? DEFAULT_W,
-        height: PAD * 2 + TITLE_H + subs * SUB_H + rows * ROW_H,
-    };
-}
-/**
- * A boxed legend: a bordered container with a bold "Legend" title and bold
- * section sub-titles, each row a swatch (dot / square+letter / line) + label.
- * Shared by the Core Domain and Context Map tools. Returns the grouped id.
- */
-export function addLegend(surface, std, x, y, opts) {
-    const { PAD, TITLE_H, SUB_H, ROW_H, SW } = LEGEND_METRICS;
-    const { width: W, height: H } = measureLegend(opts.sections, opts.width);
-    const ids = [
-        addShape(surface, x, y, W, H, {
-            fill: NOTATION_NEUTRALS.cardFill,
-            stroke: NOTATION_NEUTRALS.legendBorder,
-            strokeWidth: 1.5,
-            radius: 8,
-        }),
-    ];
-    let cy = y + PAD;
-    ids.push(addText(surface, x + PAD, cy, W - PAD * 2, opts.title, LABEL_COLOR, LABEL_FONT, 18, 'left', true));
-    cy += TITLE_H;
-    for (const sec of opts.sections) {
-        if (sec.title) {
-            ids.push(addText(surface, x + PAD, cy, W - PAD * 2, sec.title, LABEL_COLOR, LABEL_FONT, 14, 'left', true));
-            cy += SUB_H;
-        }
-        for (const row of sec.rows) {
-            const sx = x + PAD;
-            const midY = cy + ROW_H / 2;
-            if (row.swatch === 'dot') {
-                ids.push(addShape(surface, sx, midY - SW / 2, SW, SW, {
-                    shapeType: 'ellipse',
-                    fill: row.color,
-                    stroke: NOTATION_NEUTRALS.ink,
-                    strokeWidth: 1,
-                }));
-            }
-            else if (row.swatch === 'square') {
-                ids.push(addShape(surface, sx, midY - SW / 2, SW, SW, {
-                    fill: row.color,
-                    stroke: NOTATION_NEUTRALS.ink,
-                    strokeWidth: 1,
-                    radius: 3,
-                }));
-                if (row.letter)
-                    ids.push(addText(surface, sx, midY - 8, SW, row.letter, NOTATION_NEUTRALS.ink, LABEL_FONT, 11));
-            }
-            else if (row.dashed) {
-                // Two 6-unit segments with a 4-unit gap: the same 16 units as a solid
-                // bar, read as a dash.
-                const seg = 6;
-                ids.push(addShape(surface, sx, midY - 2, seg, 4, {
-                    fill: row.color,
-                    radius: 1,
-                }));
-                ids.push(addShape(surface, sx + SW - seg, midY - 2, seg, 4, {
-                    fill: row.color,
-                    radius: 1,
-                }));
-            }
-            else {
-                ids.push(addShape(surface, sx, midY - 2, SW, 4, { fill: row.color, radius: 1 }));
-            }
-            ids.push(addText(surface, sx + SW + 10, midY - LABEL_FONT_SIZE / 2, W - PAD * 2 - SW - 10, row.label, LABEL_COLOR, LABEL_FONT, 13, 'left'));
-            cy += ROW_H;
-        }
-    }
-    return groupIds(std, ids);
-}

package/dist/toolbar/icons.d.ts

@@ -1,15 +1,3 @@
-/**
- * Contextual-toolbar glyph — "generate the legend of what is on this
- * background". One icon for the three DDD backgrounds because it is one
- * gesture; the Core Domain chart has drawn this exact box-and-rows since its
- * legend button shipped, and the two boards now borrow it rather than each
- * redrawing a lookalike.
- *
- * `html` rather than `svg`: a toolbar action's `icon` is rendered as a standalone
- * template, unlike the senior-button glyphs above which are interpolated into an
- * outer `<svg>`.
- */
-export declare const dddLegendIcon: import("lit-html").TemplateResult<1>;
 /** Senior-button glyph — Event Storming (overlapping stickies). */
 export declare const eventStormingToolbarIcon: import("lit-html").TemplateResult<2>;
 /** Senior-button glyph — Core Domain Chart (axes + bands). */

package/dist/toolbar/icons.js

@@ -1,36 +1,5 @@
 import { NOTATION_NEUTRALS } from '@formicoidea/labre-core/shared/consts';
-import { html, svg } from 'lit';
-/**
- * Contextual-toolbar glyph — "generate the legend of what is on this
- * background". One icon for the three DDD backgrounds because it is one
- * gesture; the Core Domain chart has drawn this exact box-and-rows since its
- * legend button shipped, and the two boards now borrow it rather than each
- * redrawing a lookalike.
- *
- * `html` rather than `svg`: a toolbar action's `icon` is rendered as a standalone
- * template, unlike the senior-button glyphs above which are interpolated into an
- * outer `<svg>`.
- */
-export const dddLegendIcon = html `<svg
-  width="24"
-  height="24"
-  viewBox="0 0 24 24"
-  fill="none"
-  xmlns="http://www.w3.org/2000/svg"
->
-  <rect
-    x="3"
-    y="4"
-    width="18"
-    height="16"
-    rx="2"
-    stroke="currentColor"
-    stroke-width="1.6"
-  />
-  <circle cx="7" cy="9" r="1.6" fill="currentColor" />
-  <circle cx="7" cy="14" r="1.6" fill="currentColor" />
-  <path d="M11 9 H18 M11 14 H18" stroke="currentColor" stroke-width="1.4" />
-</svg>`;
+import { svg } from 'lit';
 /** Senior-button glyph — Event Storming (overlapping stickies). */
 export const eventStormingToolbarIcon = svg `<svg width="100%" height="100%" viewBox="0 0 56 56" fill="none" xmlns="http://www.w3.org/2000/svg">
   <rect x="10" y="14" width="22" height="22" rx="2" transform="rotate(-6 21 25)" fill="#F5963B"/>

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

@@ -1,4 +1,5 @@
 import { EmptyTool } from '@formicoidea/labre-core/gfx/pointer';
+import type { CommandOwner } from '@formicoidea/labre-core/std';
 import { LitElement, type TemplateResult } from 'lit';
 declare const DddSeniorButtonBase_base: typeof LitElement & import("@formicoidea/labre-core/_pkgs/global/utils").Constructor<import("@formicoidea/labre-core/_pkgs/affine-widget-edgeless-toolbar").EdgelessToolbarToolClass>;
 /**
@@ -16,6 +17,16 @@ export declare abstract class DddSeniorButtonBase extends DddSeniorButtonBase_ba
     /** i18n key resolved through the host catalogue; `label` is the fallback. */
     protected abstract labelKey: string;
     protected abstract icon: TemplateResult;
+    /** Whose artefacts light this button up while one of them is armed. */
+    protected abstract owner: CommandOwner;
+    /**
+     * Lit while one of THIS framework's artefacts is armed under the cursor, as
+     * well as while its menu is open. The menu closes the moment the pointer goes
+     * to the board, so without this the ghost would be traceable to no button at
+     * all — and Shift+S, which walks that ghost along this framework's row, would
+     * read as a keystroke belonging to nothing.
+     */
+    private get _armed();
     private _toggleMenu;
     render(): TemplateResult<1>;
 }

package/dist/toolbar/senior-buttons.js

@@ -1,7 +1,7 @@
 import { DefaultTool } from '@formicoidea/labre-core/blocks/surface';
 import { EmptyTool } from '@formicoidea/labre-core/gfx/pointer';
 import { translateKey } from '@formicoidea/labre-core/shared/services';
-import { EdgelessToolbarToolMixin } from '@formicoidea/labre-core/widgets/edgeless-toolbar';
+import { armedArtefact, EdgelessToolbarToolMixin, } from '@formicoidea/labre-core/widgets/edgeless-toolbar';
 import { SignalWatcher } from '@formicoidea/labre-core/global/lit';
 import { css, html, LitElement } from 'lit';
 /**
@@ -53,6 +53,16 @@ export class DddSeniorButtonBase extends EdgelessToolbarToolMixin(SignalWatcher(
       --s: 1.07;
     }
   `; }
+    /**
+     * Lit while one of THIS framework's artefacts is armed under the cursor, as
+     * well as while its menu is open. The menu closes the moment the pointer goes
+     * to the board, so without this the ghost would be traceable to no button at
+     * all — and Shift+S, which walks that ghost along this framework's row, would
+     * read as a keystroke belonging to nothing.
+     */
+    get _armed() {
+        return armedArtefact(this.gfx)?.owner === this.owner;
+    }
     _toggleMenu() {
         if (this.popper) {
             this.popper.dispose();
@@ -70,7 +80,7 @@ export class DddSeniorButtonBase extends EdgelessToolbarToolMixin(SignalWatcher(
             ? ''
             : translateKey(this.edgeless.std, this.labelKey, this.label)}
       .tooltipOffset=${4}
-      .active=${!!this.popper}
+      .active=${!!this.popper || this._armed}
       @click=${this._toggleMenu}
     >
       <div class="ddd-root">

package/dist/translations.d.ts

@@ -0,0 +1,59 @@
+import type { ChromeWording } from '@formicoidea/labre-core/shared/services';
+import type { TranslationKeyManifestEntry } from '@formicoidea/labre-core/std';
+/**
+ * The i18n key an Event Storming sticky's default label is asked of the
+ * host's catalogue under, for the given `ES_STICKIES` / hotspot kind.
+ * Exported so `ddd-event-storming/commands.ts` derives the SAME key at
+ * placement rather than restating the derivation.
+ */
+export declare const esStickySeedKey: (kind: string) => string;
+/**
+ * The i18n key a Team Topologies marker's default label is asked of the
+ * host's catalogue under, for the given `TEAM_TOPOLOGIES` kind. Exported so
+ * `ddd-core-domain/commands.ts` derives the SAME key at placement.
+ */
+export declare const teamTopologySeedKey: (kind: string) => string;
+/**
+ * The i18n key a Core Domain dot's default label is asked of the host's
+ * catalogue under, for the given `CD_SUBDOMAINS` kind. Exported so
+ * `ddd-core-domain/commands.ts` derives the SAME key at placement.
+ */
+export declare const cdSubdomainSeedKey: (kind: string) => string;
+/**
+ * The seeds baked into an Event Storming sticky at creation
+ * (`ddd-event-storming/commands.ts`), derived from the shared palette rather
+ * than restated — a tenth sticky kind added to {@link ES_STICKIES} gets its
+ * seed key with no edit here.
+ *
+ * This TABLE lives in `ddd-shared` because the palette it is derived from
+ * does; the KEYS still name the framework whose creation action actually
+ * writes the text, matching `com.labre.<framework>.seed.<slug>` — nothing here
+ * invents a "ddd-shared" framework.
+ */
+export declare const ES_STICKY_SEEDS: ChromeWording[];
+/**
+ * The seed baked into a Team Topologies interaction-mode marker at creation
+ * (`ddd-core-domain/commands.ts`), derived from {@link TEAM_TOPOLOGIES}.
+ */
+export declare const TEAM_TOPOLOGY_SEEDS: ChromeWording[];
+/**
+ * The seed baked into a Core Domain sub-domain / bounded-context dot at
+ * creation (`ddd-core-domain/commands.ts`), derived from {@link CD_SUBDOMAINS}.
+ */
+export declare const CD_SUBDOMAIN_SEEDS: ChromeWording[];
+/**
+ * Every seed derived from a palette THIS package owns, regardless of which DDD
+ * framework's creation action writes it. `ddd-shared` carries no
+ * `…TranslationEntries` of its own (it registers no command, no role, nothing
+ * the manifest walks) — each of the frameworks above spreads this WHOLE list
+ * into its own `…TranslationEntries` (`mergeTranslationEntries` de-duplicates
+ * the ones it does not use), which is what keeps a DDD framework from ever
+ * importing another one just to reach a shared table.
+ *
+ * Not `TEAM_TOPOLOGIES` / `CD_SUBDOMAINS`-only or `ES_STICKIES`-only: a
+ * framework that does not use a slice of this table today may tomorrow (a
+ * Context Map that starts drawing Team Topologies markers, say), and the
+ * manifest test only cares that every entry here is used by SOME source file —
+ * never that every framework that lists it also uses it.
+ */
+export declare const dddSharedTranslationEntries: TranslationKeyManifestEntry[];

package/dist/translations.js

@@ -0,0 +1,70 @@
+import { CD_SUBDOMAINS, ES_HOTSPOT, ES_STICKIES, TEAM_TOPOLOGIES, } from './shared/consts.js';
+/**
+ * camelCase → kebab-case, the same WS2 derivation each framework's own role
+ * table uses (see `ddd-event-storming/roles.ts`'s `kebab`).
+ */
+const kebab = (kind) => kind.replace(/[A-Z]/g, letter => `-${letter.toLowerCase()}`);
+/**
+ * The i18n key an Event Storming sticky's default label is asked of the
+ * host's catalogue under, for the given `ES_STICKIES` / hotspot kind.
+ * Exported so `ddd-event-storming/commands.ts` derives the SAME key at
+ * placement rather than restating the derivation.
+ */
+export const esStickySeedKey = (kind) => `com.labre.ddd-event-storming.seed.${kebab(kind)}`;
+/**
+ * The i18n key a Team Topologies marker's default label is asked of the
+ * host's catalogue under, for the given `TEAM_TOPOLOGIES` kind. Exported so
+ * `ddd-core-domain/commands.ts` derives the SAME key at placement.
+ */
+export const teamTopologySeedKey = (kind) => `com.labre.ddd-core-domain.seed.${kind}`;
+/**
+ * The i18n key a Core Domain dot's default label is asked of the host's
+ * catalogue under, for the given `CD_SUBDOMAINS` kind. Exported so
+ * `ddd-core-domain/commands.ts` derives the SAME key at placement.
+ */
+export const cdSubdomainSeedKey = (kind) => `com.labre.ddd-core-domain.seed.${kebab(kind)}`;
+/**
+ * The seeds baked into an Event Storming sticky at creation
+ * (`ddd-event-storming/commands.ts`), derived from the shared palette rather
+ * than restated — a tenth sticky kind added to {@link ES_STICKIES} gets its
+ * seed key with no edit here.
+ *
+ * This TABLE lives in `ddd-shared` because the palette it is derived from
+ * does; the KEYS still name the framework whose creation action actually
+ * writes the text, matching `com.labre.<framework>.seed.<slug>` — nothing here
+ * invents a "ddd-shared" framework.
+ */
+export const ES_STICKY_SEEDS = [
+    ...ES_STICKIES.map((preset) => [esStickySeedKey(preset.kind), preset.label]),
+    [esStickySeedKey('hotspot'), ES_HOTSPOT.label],
+];
+/**
+ * The seed baked into a Team Topologies interaction-mode marker at creation
+ * (`ddd-core-domain/commands.ts`), derived from {@link TEAM_TOPOLOGIES}.
+ */
+export const TEAM_TOPOLOGY_SEEDS = TEAM_TOPOLOGIES.map((preset) => [teamTopologySeedKey(preset.kind), preset.label]);
+/**
+ * The seed baked into a Core Domain sub-domain / bounded-context dot at
+ * creation (`ddd-core-domain/commands.ts`), derived from {@link CD_SUBDOMAINS}.
+ */
+export const CD_SUBDOMAIN_SEEDS = CD_SUBDOMAINS.map((preset) => [cdSubdomainSeedKey(preset.kind), preset.label]);
+/**
+ * Every seed derived from a palette THIS package owns, regardless of which DDD
+ * framework's creation action writes it. `ddd-shared` carries no
+ * `…TranslationEntries` of its own (it registers no command, no role, nothing
+ * the manifest walks) — each of the frameworks above spreads this WHOLE list
+ * into its own `…TranslationEntries` (`mergeTranslationEntries` de-duplicates
+ * the ones it does not use), which is what keeps a DDD framework from ever
+ * importing another one just to reach a shared table.
+ *
+ * Not `TEAM_TOPOLOGIES` / `CD_SUBDOMAINS`-only or `ES_STICKIES`-only: a
+ * framework that does not use a slice of this table today may tomorrow (a
+ * Context Map that starts drawing Team Topologies markers, say), and the
+ * manifest test only cares that every entry here is used by SOME source file —
+ * never that every framework that lists it also uses it.
+ */
+export const dddSharedTranslationEntries = [
+    ...ES_STICKY_SEEDS,
+    ...TEAM_TOPOLOGY_SEEDS,
+    ...CD_SUBDOMAIN_SEEDS,
+].map(([key, fallback]) => ({ key, fallback, source: 'seed' }));

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@formicoidea/labre-ddd-shared",
   "description": "Labre ddd-shared — shared building blocks for @formicoidea/labre-core frameworks.",
-  "version": "0.40.0",
+  "version": "0.42.0",
   "type": "module",
   "sideEffects": false,
   "author": "lajola",
@@ -19,7 +19,7 @@
     "dist"
   ],
   "dependencies": {
-    "@formicoidea/labre-core": "0.40.0",
+    "@formicoidea/labre-core": "0.42.0",
     "lit": "^3.2.0"
   }
 }

package/dist/shared/legend-auto.d.ts

@@ -1,118 +0,0 @@
-import { Bound } from '@formicoidea/labre-core/global/gfx';
-import type { BlockStdScope } from '@formicoidea/labre-core/std';
-import { type GfxController, type RoleDefs, type RoleId } from '@formicoidea/labre-core/std/gfx';
-import { type LegendRow, type LegendSection } from './prefabs.js';
-/**
- * The AUTOMATIC legend, shared by the three DDD backgrounds.
- *
- * Wardley's `createWardleyLegend` is the gesture this replicates — select the
- * background, press one button, get a legend of what is actually drawn on it,
- * dropped bottom-left and grouped so it can be moved and edited like anything
- * else. Two things are deliberately NOT replicated:
- *
- * - **detection is by ROLE, never by `instanceof` or by fill colour.** A role is
- *   the semantic identity of an artefact (`framework/std`'s `role.ts`); a shape
- *   type is not, and a colour is a restyle away from lying. Reading roles also
- *   means a legend and a validation rule agree on what is on the board, because
- *   they read the same field;
- * - **the glyphs are the DDD house prefab** ({@link addLegend}), not hand-drawn
- *   element-by-element replicas of the artefacts. The three DDD frameworks
- *   already document themselves with swatch rows, and a second visual language
- *   for the same job would be one too many.
- *
- * A framework contributes nothing but a TABLE: which role puts which row in the
- * legend. Everything else — scanning the perimeter, resolving specialisations,
- * dropping empty sections, placing and grouping the box — happens here once.
- */
-/**
- * One candidate row: `row` is listed only when `role` — or a role that
- * specialises it — is carried by an element inside the background's perimeter.
- */
-export interface AutoLegendEntry {
-    role: RoleId;
-    row: LegendRow;
-    /**
-     * Match `role` and `role` ALONE, without the specialisation walk.
-     *
-     * The default — an entry lights up for any of its children — is what a legend
-     * usually wants: one "Relation" row covers the twenty-two verbs, one
-     * "Sub-domain" row would cover the five kinds. It is also what a validation
-     * rule wants, and for the same reason: a statement about a family is a
-     * statement about every member of it.
-     *
-     * A legend sometimes wants the opposite, because it documents what is DRAWN
-     * rather than what is meant. EDGY's four base kinds are the case: Content
-     * specialises Object, so an entry on `edgy:object` would put an "Object" row
-     * on a board where nobody ever dropped a bare Object — the row would name a
-     * white square that is nowhere on the diagram. `exact` makes the base and its
-     * specialisations two separate statements, so each is listed when, and only
-     * when, it is the thing the user actually put down.
-     *
-     * Reach for it when a row's swatch would be a lie on a board carrying only
-     * children — a distinct colour, a distinct shape, a distinct wording. Leave it
-     * off when the parent row is a fair summary of the whole family.
-     */
-    exact?: boolean;
-}
-export interface AutoLegendSectionSpec {
-    /** Sub-title, dropped along with the section when none of its rows appear. */
-    title?: string;
-    entries: readonly AutoLegendEntry[];
-}
-export interface AutoLegendSpec {
-    /**
-     * Box title. The three DDD tools all say "Legend" (PO recette, 26/08/2026:
-     * the boxes used to be titled in French, which was the one label in the
-     * library that was — identifiers and fallback wordings are English here, and
-     * the day a host ships a locale pack it translates a key, not a leftover).
-     */
-    title: string;
-    width?: number;
-    /**
-     * The framework's role vocabulary, so a present role is matched against an
-     * entry's role THROUGH the specialisation chain: an entry written on a parent
-     * role lists itself as soon as any of its children is on the board — unless
-     * it asks for {@link AutoLegendEntry.exact}, which is the whole of the
-     * exception.
-     */
-    roles: RoleDefs;
-    sections: readonly AutoLegendSectionSpec[];
-}
-/**
- * The framework's OWN wording for a role, from the vocabulary that declares it.
- *
- * A legend row about `es:flow` says "Flow" because that is what the role def
- * says it is called — the table below never restates a label the vocabulary
- * already owns, so renaming a role renames its legend row.
- */
-export declare function roleLabel(roles: RoleDefs, id: RoleId): string;
-/**
- * Every role carried by an element inside `bound`.
- *
- * Neutral elements (no role) contribute nothing, which is the whole
- * compatibility promise: a board drawn before the vocabularies existed produces
- * an empty set and therefore a legend with no rows, exactly like an empty board.
- */
-export declare function rolesInBound(gfx: GfxController, bound: Bound): Set<RoleId>;
-/**
- * The sections to draw for a given set of present roles: every entry whose role
- * is present (directly or through a specialisation, unless the entry asks for
- * {@link AutoLegendEntry.exact}), in declaration order, with empty sections —
- * sub-title included — dropped.
- *
- * When nothing is recognised the result is an EMPTY array, and the caller still
- * draws the box: that is Wardley's behaviour (an empty map yields a framed
- * "Legend" title and no rows), and it is the honest one — a legend of a board
- * with nothing on it lists nothing, rather than inventing the full notation the
- * user has not used.
- */
-export declare function autoLegendSections(present: ReadonlySet<RoleId>, spec: AutoLegendSpec): LegendSection[];
-/**
- * Build the legend of what is drawn inside `background` and drop it bottom-left
- * of it, grouped and selected.
- *
- * Returns the group id, or `undefined` when there is no surface to draw on.
- */
-export declare function createAutoLegend(std: BlockStdScope, background: {
-    xywh: string;
-}, spec: AutoLegendSpec): string | undefined;

package/dist/shared/legend-auto.js

@@ -1,79 +0,0 @@
-import { Bound } from '@formicoidea/labre-core/global/gfx';
-import { GfxControllerIdentifier, roleIsA, } from '@formicoidea/labre-core/std/gfx';
-import { addLegend, measureLegend, } from './prefabs.js';
-/**
- * The framework's OWN wording for a role, from the vocabulary that declares it.
- *
- * A legend row about `es:flow` says "Flow" because that is what the role def
- * says it is called — the table below never restates a label the vocabulary
- * already owns, so renaming a role renames its legend row.
- */
-export function roleLabel(roles, id) {
-    return roles[id]?.labelFallback ?? id;
-}
-/**
- * Distance from the background's left edge / bottom edge, in model units.
- * Wardley's numbers, kept identical so the two gestures put the box in the same
- * place relative to their backgrounds.
- */
-const INSET_X = 50;
-const INSET_BOTTOM = 56;
-/**
- * Every role carried by an element inside `bound`.
- *
- * Neutral elements (no role) contribute nothing, which is the whole
- * compatibility promise: a board drawn before the vocabularies existed produces
- * an empty set and therefore a legend with no rows, exactly like an empty board.
- */
-export function rolesInBound(gfx, bound) {
-    const present = new Set();
-    for (const el of gfx.getElementsByBound(bound, { type: 'canvas' })) {
-        if (el.role !== undefined)
-            present.add(el.role);
-    }
-    return present;
-}
-/**
- * The sections to draw for a given set of present roles: every entry whose role
- * is present (directly or through a specialisation, unless the entry asks for
- * {@link AutoLegendEntry.exact}), in declaration order, with empty sections —
- * sub-title included — dropped.
- *
- * When nothing is recognised the result is an EMPTY array, and the caller still
- * draws the box: that is Wardley's behaviour (an empty map yields a framed
- * "Legend" title and no rows), and it is the honest one — a legend of a board
- * with nothing on it lists nothing, rather than inventing the full notation the
- * user has not used.
- */
-export function autoLegendSections(present, spec) {
-    const sections = [];
-    for (const section of spec.sections) {
-        const rows = section.entries
-            .filter(entry => entry.exact
-            ? present.has(entry.role)
-            : [...present].some(role => roleIsA(role, entry.role, spec.roles)))
-            .map(entry => entry.row);
-        if (rows.length)
-            sections.push({ title: section.title, rows });
-    }
-    return sections;
-}
-/**
- * Build the legend of what is drawn inside `background` and drop it bottom-left
- * of it, grouped and selected.
- *
- * Returns the group id, or `undefined` when there is no surface to draw on.
- */
-export function createAutoLegend(std, background, spec) {
-    const gfx = std.get(GfxControllerIdentifier);
-    const surface = gfx.surface;
-    if (!surface)
-        return undefined;
-    const bound = Bound.deserialize(background.xywh);
-    const sections = autoLegendSections(rolesInBound(gfx, bound), spec);
-    const { height } = measureLegend(sections, spec.width);
-    std.store.captureSync();
-    const id = addLegend(surface, std, bound.x + INSET_X, bound.y + bound.h - INSET_BOTTOM - height, { title: spec.title, sections, width: spec.width });
-    gfx.selection.set({ elements: [id], editing: false });
-    return id;
-}