@formicoidea/labre-ddd-shared 0.25.0

package/dist/index.d.ts

@@ -0,0 +1,8 @@
+export * from './shared/consts.js';
+export * from './shared/prefabs.js';
+export * from './shared/utils.js';
+export { DddMenuBase } from './toolbar/menu-base.js';
+export * from './toolbar/icons.js';
+export { DddSeniorButtonBase } from './toolbar/senior-buttons.js';
+export { CD_TEMPLATES, CM_TEMPLATES, ES_TEMPLATES, } from './templates/components.js';
+export { contextMapTemplateCategory, coreDomainTemplateCategory, eventStormingTemplateCategory, } from './templates/categories.js';

package/dist/index.js

@@ -0,0 +1,8 @@
+export * from './shared/consts.js';
+export * from './shared/prefabs.js';
+export * from './shared/utils.js';
+export { DddMenuBase } from './toolbar/menu-base.js';
+export * from './toolbar/icons.js';
+export { DddSeniorButtonBase } from './toolbar/senior-buttons.js';
+export { CD_TEMPLATES, CM_TEMPLATES, ES_TEMPLATES, } from './templates/components.js';
+export { contextMapTemplateCategory, coreDomainTemplateCategory, eventStormingTemplateCategory, } from './templates/categories.js';

package/dist/shared/consts.d.ts

@@ -0,0 +1,180 @@
+/**
+ * Shared DDD palette and sizes. Every tool composes the same irreducible units
+ * (sticky, dot, bubble, connector, label) from these presets — no duplicated
+ * component definitions across the Event Storming / Context Map / Core Domain
+ * sub-menus.
+ */
+/** Square sticky side (px, canvas reference). */
+export declare const STICKY_SIZE = 120;
+/** Faux drop-shadow offset + colour (a plain offset rect behind the sticky). */
+export declare const SHADOW_OFFSET = 7;
+export declare const SHADOW_COLOR = "#0000002e";
+/** Handwriting marker font, already shipped in the canvas font set. */
+export declare const STICKY_FONT = "blocksuite:surface:Kalam";
+export declare const STICKY_FONT_SIZE = 20;
+export declare const STICKY_RADIUS = 6;
+/** Event Storming sticky palette — DDD Crew / Brandolini colour code. */
+export declare const ES_STICKIES: readonly [{
+    readonly kind: "domainEvent";
+    readonly label: "Domain event";
+    readonly fill: "#F5963B";
+    readonly text: "#5a3000";
+}, {
+    readonly kind: "command";
+    readonly label: "Command";
+    readonly fill: "#5BA3DB";
+    readonly text: "#06304d";
+}, {
+    readonly kind: "actor";
+    readonly label: "Actor";
+    readonly fill: "#FFF1A8";
+    readonly text: "#5a4b00";
+}, {
+    readonly kind: "constraint";
+    readonly label: "Constraint";
+    readonly fill: "#FFD84D";
+    readonly text: "#5a4b00";
+}, {
+    readonly kind: "policy";
+    readonly label: "Policy";
+    readonly fill: "#C9A8E0";
+    readonly text: "#3d1f57";
+}, {
+    readonly kind: "readModel";
+    readonly label: "Read model";
+    readonly fill: "#7ED38A";
+    readonly text: "#14502a";
+}, {
+    readonly kind: "system";
+    readonly label: "External system";
+    readonly fill: "#F6A6C0";
+    readonly text: "#5e1230";
+}];
+/** Hotspot — neon-pink diamond. */
+export declare const ES_HOTSPOT: {
+    label: string;
+    fill: string;
+    text: string;
+};
+/** Context Map bounded-context bubble. */
+export declare const CM_BUBBLE: {
+    fill: string;
+    stroke: string;
+    text: string;
+    w: number;
+    h: number;
+    radius: number;
+};
+/**
+ * Context Map relationship presets (DDD Crew notation). Each is the SAME
+ * connector unit + an abbreviation tag; `upDown` adds U/D markers (upstream →
+ * downstream); `dashed` marks the "no real integration" patterns (Separate
+ * Ways, Big Ball of Mud).
+ */
+export declare const CM_RELATIONSHIPS: readonly [{
+    readonly kind: "partnership";
+    readonly label: "Partnership";
+    readonly abbrev: "PS";
+    readonly upDown: false;
+    readonly dashed: false;
+}, {
+    readonly kind: "sharedKernel";
+    readonly label: "Shared Kernel";
+    readonly abbrev: "SK";
+    readonly upDown: false;
+    readonly dashed: false;
+}, {
+    readonly kind: "customerSupplier";
+    readonly label: "Customer / Supplier";
+    readonly abbrev: "C/S";
+    readonly upDown: true;
+    readonly dashed: false;
+}, {
+    readonly kind: "conformist";
+    readonly label: "Conformist";
+    readonly abbrev: "CF";
+    readonly upDown: true;
+    readonly dashed: false;
+}, {
+    readonly kind: "acl";
+    readonly label: "Anticorruption Layer";
+    readonly abbrev: "ACL";
+    readonly upDown: true;
+    readonly dashed: false;
+}, {
+    readonly kind: "ohs";
+    readonly label: "Open Host Service";
+    readonly abbrev: "OHS";
+    readonly upDown: true;
+    readonly dashed: false;
+}, {
+    readonly kind: "publishedLanguage";
+    readonly label: "Published Language";
+    readonly abbrev: "PL";
+    readonly upDown: true;
+    readonly dashed: false;
+}, {
+    readonly kind: "separateWays";
+    readonly label: "Separate Ways";
+    readonly abbrev: "SW";
+    readonly upDown: false;
+    readonly dashed: true;
+}, {
+    readonly kind: "bbom";
+    readonly label: "Big Ball of Mud";
+    readonly abbrev: "BBoM";
+    readonly upDown: false;
+    readonly dashed: true;
+}];
+export declare const CLOUD_VERTICES: number[][];
+export declare const CLOUD: {
+    w: number;
+    h: number;
+    fill: string;
+    stroke: string;
+};
+/** Team Topologies interaction modes (placeable markers + Notation legend). */
+export declare const TEAM_TOPOLOGIES: readonly [{
+    readonly kind: "collaboration";
+    readonly label: "Collaboration";
+    readonly letter: "C";
+    readonly fill: "#99ff99";
+}, {
+    readonly kind: "xaas";
+    readonly label: "X-as-a-Service";
+    readonly letter: "X";
+    readonly fill: "#66b2ff";
+}, {
+    readonly kind: "facilitating";
+    readonly label: "Facilitating";
+    readonly letter: "F";
+    readonly fill: "#ffd84d";
+}];
+export declare const MARKER_SIZE = 30;
+/** Core Domain sub-domain / bounded-context dot presets (colours from template). */
+export declare const CD_SUBDOMAINS: readonly [{
+    readonly kind: "bigBet";
+    readonly label: "Big-bet sub-domain";
+    readonly fill: "#9933ff";
+}, {
+    readonly kind: "platform";
+    readonly label: "Platform sub-domain";
+    readonly fill: "#66b2ff";
+}, {
+    readonly kind: "outsourced";
+    readonly label: "Outsourced / purchased";
+    readonly fill: "#99ff99";
+}, {
+    readonly kind: "bcCurrent";
+    readonly label: "Bounded context";
+    readonly fill: "#ff3333";
+}, {
+    readonly kind: "bcFuture";
+    readonly label: "Future position";
+    readonly fill: "#cccccc";
+}];
+export declare const DOT_SIZE = 26;
+export declare const MOVEMENT_COLOR = "#ff3333";
+export declare const LABEL_COLOR = "#1f2328";
+export declare const LABEL_FONT = "blocksuite:surface:Inter";
+export declare const LABEL_FONT_SIZE = 14;

package/dist/shared/consts.js

@@ -0,0 +1,92 @@
+/**
+ * Shared DDD palette and sizes. Every tool composes the same irreducible units
+ * (sticky, dot, bubble, connector, label) from these presets — no duplicated
+ * component definitions across the Event Storming / Context Map / Core Domain
+ * sub-menus.
+ */
+/** Square sticky side (px, canvas reference). */
+export const STICKY_SIZE = 120;
+/** Faux drop-shadow offset + colour (a plain offset rect behind the sticky). */
+export const SHADOW_OFFSET = 7;
+export const SHADOW_COLOR = '#0000002e';
+/** Handwriting marker font, already shipped in the canvas font set. */
+export const STICKY_FONT = 'blocksuite:surface:Kalam';
+export const STICKY_FONT_SIZE = 20;
+export const STICKY_RADIUS = 6;
+/** Event Storming sticky palette — DDD Crew / Brandolini colour code. */
+export const ES_STICKIES = [
+    { kind: 'domainEvent', label: 'Domain event', fill: '#F5963B', text: '#5a3000' },
+    { kind: 'command', label: 'Command', fill: '#5BA3DB', text: '#06304d' },
+    { kind: 'actor', label: 'Actor', fill: '#FFF1A8', text: '#5a4b00' },
+    { kind: 'constraint', label: 'Constraint', fill: '#FFD84D', text: '#5a4b00' },
+    { kind: 'policy', label: 'Policy', fill: '#C9A8E0', text: '#3d1f57' },
+    { kind: 'readModel', label: 'Read model', fill: '#7ED38A', text: '#14502a' },
+    { kind: 'system', label: 'External system', fill: '#F6A6C0', text: '#5e1230' },
+];
+/** Hotspot — neon-pink diamond. */
+export const ES_HOTSPOT = { label: 'Hotspot', fill: '#FF1E8E', text: '#ffffff' };
+/** Context Map bounded-context bubble. */
+export const CM_BUBBLE = {
+    fill: '#e6f0fa',
+    stroke: '#2f6fb0',
+    text: '#06304d',
+    w: 150,
+    h: 70,
+    radius: 30,
+};
+/**
+ * Context Map relationship presets (DDD Crew notation). Each is the SAME
+ * connector unit + an abbreviation tag; `upDown` adds U/D markers (upstream →
+ * downstream); `dashed` marks the "no real integration" patterns (Separate
+ * Ways, Big Ball of Mud).
+ */
+export const CM_RELATIONSHIPS = [
+    { kind: 'partnership', label: 'Partnership', abbrev: 'PS', upDown: false, dashed: false },
+    { kind: 'sharedKernel', label: 'Shared Kernel', abbrev: 'SK', upDown: false, dashed: false },
+    { kind: 'customerSupplier', label: 'Customer / Supplier', abbrev: 'C/S', upDown: true, dashed: false },
+    { kind: 'conformist', label: 'Conformist', abbrev: 'CF', upDown: true, dashed: false },
+    { kind: 'acl', label: 'Anticorruption Layer', abbrev: 'ACL', upDown: true, dashed: false },
+    { kind: 'ohs', label: 'Open Host Service', abbrev: 'OHS', upDown: true, dashed: false },
+    { kind: 'publishedLanguage', label: 'Published Language', abbrev: 'PL', upDown: true, dashed: false },
+    { kind: 'separateWays', label: 'Separate Ways', abbrev: 'SW', upDown: false, dashed: true },
+    { kind: 'bbom', label: 'Big Ball of Mud', abbrev: 'BBoM', upDown: false, dashed: true },
+];
+/**
+ * Context Map cloud (Big Ball of Mud / general-purpose boundary). The canvas
+ * polygon renderer draws straight segments (it ignores `smoothFlags`), so the
+ * cloud is a DENSE lumpy closed outline — enough points that the lineTo edges
+ * read as smooth curves. Normalized [0-1] coordinates relative to the bound.
+ */
+function buildCloud() {
+    const N = 56;
+    const clamp = (v) => Math.min(0.98, Math.max(0.02, v));
+    const pts = [];
+    for (let i = 0; i < N; i++) {
+        const t = (i / N) * Math.PI * 2;
+        const r = 0.4 + 0.05 * Math.sin(6 * t) + 0.03 * Math.sin(3 * t + 0.8);
+        pts.push([clamp(0.5 + r * Math.cos(t)), clamp(0.5 + r * 0.6 * Math.sin(t))]);
+    }
+    return pts;
+}
+export const CLOUD_VERTICES = buildCloud();
+export const CLOUD = { w: 180, h: 120, fill: '#f0eef6', stroke: '#6d6e71' };
+/** Team Topologies interaction modes (placeable markers + Notation legend). */
+export const TEAM_TOPOLOGIES = [
+    { kind: 'collaboration', label: 'Collaboration', letter: 'C', fill: '#99ff99' },
+    { kind: 'xaas', label: 'X-as-a-Service', letter: 'X', fill: '#66b2ff' },
+    { kind: 'facilitating', label: 'Facilitating', letter: 'F', fill: '#ffd84d' },
+];
+export const MARKER_SIZE = 30;
+/** Core Domain sub-domain / bounded-context dot presets (colours from template). */
+export const CD_SUBDOMAINS = [
+    { kind: 'bigBet', label: 'Big-bet sub-domain', fill: '#9933ff' },
+    { kind: 'platform', label: 'Platform sub-domain', fill: '#66b2ff' },
+    { kind: 'outsourced', label: 'Outsourced / purchased', fill: '#99ff99' },
+    { kind: 'bcCurrent', label: 'Bounded context', fill: '#ff3333' },
+    { kind: 'bcFuture', label: 'Future position', fill: '#cccccc' },
+];
+export const DOT_SIZE = 26;
+export const MOVEMENT_COLOR = '#ff3333';
+export const LABEL_COLOR = '#1f2328';
+export const LABEL_FONT = 'blocksuite:surface:Inter';
+export const LABEL_FONT_SIZE = 14;

package/dist/shared/prefabs.d.ts

@@ -0,0 +1,71 @@
+import type { BlockStdScope } from '@formicoidea/labre-core/std';
+import type { GfxController } from '@formicoidea/labre-core/std/gfx';
+/**
+ * Irreducible reusable units composed by all three DDD sub-menus. Each helper
+ * wraps native `surface.addElement` (shape / text / connector / group); nothing
+ * here defines a new element type, so the same builders back Event Storming
+ * stickies, Context Map bubbles + relationships and Core Domain dots + arrows.
+ */
+type Surface = NonNullable<GfxController['surface']>;
+/** Group several element ids; returns the group id (or the first id on failure). */
+export declare function groupIds(std: BlockStdScope, ids: string[]): string;
+/** A post-it: faux-shadow rect + coloured face + centred handwriting label, grouped. */
+export declare function addSticky(surface: Surface, std: BlockStdScope, cx: number, cy: number, opts: {
+    fill: string;
+    text: string;
+    label: string;
+    shapeType?: 'rect' | 'diamond';
+    size?: number;
+}): string;
+/** A Context Map bounded-context bubble (rounded pill + centred label). */
+export declare function addBubble(surface: Surface, std: BlockStdScope, cx: number, cy: number, label: string): string;
+/** A Core Domain dot (sub-domain / bounded context); optional label to its right. */
+export declare function addDot(surface: Surface, std: BlockStdScope, cx: number, cy: number, fill: string, label?: string): string;
+/** A free-floating label. */
+export declare function addLabel(surface: Surface, cx: number, cy: number, label: string, align?: 'left' | 'center', color?: string): string;
+/** A relationship connector (the single connector unit reused for all patterns). */
+export declare function addConnector(surface: Surface, x1: number, y1: number, x2: number, y2: number, opts?: {
+    rearArrow?: boolean;
+    dashed?: boolean;
+    stroke?: string;
+    strokeWidth?: number;
+}): string;
+/** A Team Topologies interaction-mode marker: a coloured square + centred letter. */
+export declare function addMarker(surface: Surface, std: BlockStdScope, cx: number, cy: number, opts: {
+    fill: string;
+    letter: string;
+    label?: 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;
+/**
+ * A Context Map relationship in DDD Crew notation: the connector, the pattern
+ * abbreviation in a small tag, and (for upstream/downstream patterns) the U / D
+ * markers — grouped so the whole pattern reads as one unit.
+ */
+export declare function addRelationship(surface: Surface, std: BlockStdScope, cx: number, cy: number, preset: {
+    abbrev: string;
+    upDown: boolean;
+    dashed: boolean;
+}): string;
+export interface LegendRow {
+    swatch: 'dot' | 'square' | 'line';
+    color: string;
+    letter?: string;
+    label: string;
+}
+export interface LegendSection {
+    title?: string;
+    rows: LegendRow[];
+}
+/**
+ * A boxed legend: a bordered container with a bold "Légende" 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 {};

package/dist/shared/prefabs.js

@@ -0,0 +1,214 @@
+import { createGroupCommand } from '@formicoidea/labre-core/gfx/group';
+import { ConnectorMode, FontWeight, PointStyle, ShapeStyle, StrokeStyle, } from '@formicoidea/labre-core/model';
+import { Bound } from '@formicoidea/labre-core/global/gfx';
+import { CLOUD, CLOUD_VERTICES, CM_BUBBLE, DOT_SIZE, LABEL_COLOR, LABEL_FONT, LABEL_FONT_SIZE, MARKER_SIZE, SHADOW_COLOR, SHADOW_OFFSET, STICKY_FONT, STICKY_FONT_SIZE, STICKY_RADIUS, STICKY_SIZE, } from './consts';
+const NO_STROKE = '#00000000';
+/** Group several element ids; returns the group id (or the first id on failure). */
+export function groupIds(std, ids) {
+    const [, result] = std.command.exec(createGroupCommand, { elements: ids });
+    return result.groupId || ids[0];
+}
+function addShape(surface, x, y, w, h, opts) {
+    const { shapeType = 'rect', fill, stroke = NO_STROKE, strokeWidth = 0, radius = 0 } = opts;
+    return surface.addElement({
+        type: 'shape',
+        shapeType,
+        filled: true,
+        fillColor: fill,
+        strokeColor: stroke,
+        strokeWidth,
+        shapeStyle: ShapeStyle.General,
+        roughness: 0,
+        radius,
+        xywh: new Bound(x, y, w, h).serialize(),
+    });
+}
+function addText(surface, x, y, w, text, color, fontFamily, fontSize, textAlign = 'center', bold = false) {
+    return surface.addElement({
+        type: 'text',
+        text,
+        color,
+        fontFamily,
+        fontSize,
+        textAlign,
+        fontWeight: bold ? FontWeight.SemiBold : FontWeight.Regular,
+        xywh: new Bound(x, y, w, fontSize + 10).serialize(),
+    });
+}
+/** A post-it: faux-shadow rect + coloured face + centred handwriting label, grouped. */
+export function addSticky(surface, std, cx, cy, opts) {
+    const { fill, text, label, shapeType = 'rect', size = STICKY_SIZE } = opts;
+    const half = size / 2;
+    const radius = shapeType === 'rect' ? STICKY_RADIUS : 0;
+    const shadow = addShape(surface, cx - half + SHADOW_OFFSET, cy - half + SHADOW_OFFSET, size, size, {
+        shapeType,
+        fill: SHADOW_COLOR,
+        radius,
+    });
+    const face = addShape(surface, cx - half, cy - half, size, size, { shapeType, fill, radius });
+    const lbl = addText(surface, cx - half + 10, cy - STICKY_FONT_SIZE / 2, size - 20, label, text, STICKY_FONT, STICKY_FONT_SIZE);
+    return groupIds(std, [shadow, face, lbl]);
+}
+/** A Context Map bounded-context bubble (rounded pill + centred label). */
+export function addBubble(surface, std, cx, cy, label) {
+    const { w, h, radius, fill, stroke, text } = CM_BUBBLE;
+    const box = addShape(surface, cx - w / 2, cy - h / 2, w, h, {
+        fill,
+        stroke,
+        strokeWidth: 1.5,
+        radius,
+    });
+    const lbl = addText(surface, cx - w / 2 + 8, cy - LABEL_FONT_SIZE / 2, w - 16, label, text, LABEL_FONT, LABEL_FONT_SIZE);
+    return groupIds(std, [box, lbl]);
+}
+/** A Core Domain dot (sub-domain / bounded context); optional label to its right. */
+export function addDot(surface, std, cx, cy, fill, label) {
+    const d = DOT_SIZE;
+    const dot = addShape(surface, cx - d / 2, cy - d / 2, d, d, {
+        shapeType: 'ellipse',
+        fill,
+        stroke: '#1f2328',
+        strokeWidth: 1.5,
+    });
+    if (!label)
+        return dot;
+    const lbl = addText(surface, cx + d / 2 + 6, cy - LABEL_FONT_SIZE / 2, 170, label, LABEL_COLOR, LABEL_FONT, LABEL_FONT_SIZE, 'left');
+    return groupIds(std, [dot, lbl]);
+}
+/** A free-floating label. */
+export function addLabel(surface, cx, cy, label, align = 'center', color = LABEL_COLOR) {
+    return addText(surface, cx, cy, 200, label, color, LABEL_FONT, LABEL_FONT_SIZE, align);
+}
+/** A relationship connector (the single connector unit reused for all patterns). */
+export function addConnector(surface, x1, y1, x2, y2, opts = {}) {
+    const { rearArrow = false, dashed = false, stroke = LABEL_COLOR, strokeWidth = 2 } = opts;
+    return surface.addElement({
+        type: 'connector',
+        mode: ConnectorMode.Straight,
+        stroke,
+        strokeWidth,
+        strokeStyle: dashed ? StrokeStyle.Dash : StrokeStyle.Solid,
+        frontEndpointStyle: PointStyle.None,
+        rearEndpointStyle: rearArrow ? PointStyle.Arrow : PointStyle.None,
+        source: { position: [x1, y1] },
+        target: { position: [x2, y2] },
+    });
+}
+/** A Team Topologies interaction-mode marker: a coloured square + centred letter. */
+export function addMarker(surface, std, cx, cy, opts) {
+    const { fill, letter, label } = opts;
+    const s = MARKER_SIZE;
+    const box = addShape(surface, cx - s / 2, cy - s / 2, s, s, {
+        fill,
+        stroke: '#1f2328',
+        strokeWidth: 1.5,
+        radius: 4,
+    });
+    const glyph = addText(surface, cx - s / 2, cy - 9, s, letter, '#1f2328', LABEL_FONT, 15);
+    const ids = [box, glyph];
+    if (label) {
+        ids.push(addText(surface, cx + s / 2 + 6, cy - LABEL_FONT_SIZE / 2, 150, label, LABEL_COLOR, LABEL_FONT, LABEL_FONT_SIZE, 'left'));
+    }
+    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) {
+    const { w, h, fill, stroke } = CLOUD;
+    const cloud = surface.addElement({
+        type: 'shape',
+        shapeType: 'polygon',
+        vertices: CLOUD_VERTICES,
+        isClosed: true,
+        filled: true,
+        fillColor: fill,
+        strokeColor: stroke,
+        strokeWidth: 1.5,
+        shapeStyle: ShapeStyle.General,
+        roughness: 0,
+        xywh: new Bound(cx - w / 2, cy - h / 2, w, h).serialize(),
+    });
+    if (!label)
+        return cloud;
+    const lbl = addText(surface, cx - w / 2 + 12, cy - LABEL_FONT_SIZE / 2, w - 24, label, '#3d3d3d', LABEL_FONT, LABEL_FONT_SIZE);
+    return groupIds(std, [cloud, lbl]);
+}
+/**
+ * A Context Map relationship in DDD Crew notation: the connector, the pattern
+ * abbreviation in a small tag, and (for upstream/downstream patterns) the U / D
+ * markers — grouped so the whole pattern reads as one unit.
+ */
+export function addRelationship(surface, std, cx, cy, preset) {
+    const conn = addConnector(surface, cx - 130, cy, cx + 130, cy, {
+        rearArrow: preset.upDown,
+        dashed: preset.dashed,
+    });
+    const tag = addShape(surface, cx - 26, cy - 42, 52, 24, {
+        fill: '#ffffff',
+        stroke: '#6d6e71',
+        strokeWidth: 1,
+        radius: 4,
+    });
+    const tagText = addText(surface, cx - 26, cy - 36, 52, preset.abbrev, LABEL_COLOR, LABEL_FONT, 13);
+    const ids = [conn, tag, tagText];
+    if (preset.upDown) {
+        ids.push(addText(surface, cx - 150, cy - 30, 24, 'U', LABEL_COLOR, LABEL_FONT, 13));
+        ids.push(addText(surface, cx + 126, cy - 30, 24, 'D', LABEL_COLOR, LABEL_FONT, 13));
+    }
+    return groupIds(std, ids);
+}
+/**
+ * A boxed legend: a bordered container with a bold "Légende" 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 W = opts.width ?? 260;
+    const PAD = 16;
+    const TITLE_H = 32;
+    const SUB_H = 26;
+    const ROW_H = 28;
+    const SW = 16;
+    let subs = 0;
+    let rows = 0;
+    for (const s of opts.sections) {
+        if (s.title)
+            subs++;
+        rows += s.rows.length;
+    }
+    const H = PAD * 2 + TITLE_H + subs * SUB_H + rows * ROW_H;
+    const ids = [
+        addShape(surface, x, y, W, H, {
+            fill: '#ffffff',
+            stroke: '#6d6e71',
+            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: '#1f2328', strokeWidth: 1 }));
+            }
+            else if (row.swatch === 'square') {
+                ids.push(addShape(surface, sx, midY - SW / 2, SW, SW, { fill: row.color, stroke: '#1f2328', strokeWidth: 1, radius: 3 }));
+                if (row.letter)
+                    ids.push(addText(surface, sx, midY - 8, SW, row.letter, '#1f2328', LABEL_FONT, 11));
+            }
+            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/shared/utils.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Uniform fit of a fixed reference design (`refW × refH`) into an element of
+ * size `w × h`: scale factor + centring offsets (letterboxed), undistorted.
+ */
+export declare function refScale(w: number, h: number, refW: number, refH: number): {
+    s: number;
+    ox: number;
+    oy: number;
+};
+export declare const FONT_FAMILY = "Inter, sans-serif";

package/dist/shared/utils.js

@@ -0,0 +1,9 @@
+/**
+ * Uniform fit of a fixed reference design (`refW × refH`) into an element of
+ * size `w × h`: scale factor + centring offsets (letterboxed), undistorted.
+ */
+export function refScale(w, h, refW, refH) {
+    const s = Math.min(w / refW, h / refH);
+    return { s, ox: (w - refW * s) / 2, oy: (h - refH * s) / 2 };
+}
+export const FONT_FAMILY = 'Inter, sans-serif';

package/dist/templates/categories.d.ts

@@ -0,0 +1,11 @@
+import type { TemplateCategory } from '@formicoidea/labre-core/gfx/template';
+/**
+ * One Templates-panel section per senior button. These are gated by
+ * `ddd-templates` only — never by a senior-button flag — so the catalogue stays
+ * available even when a senior button is hidden. They live in the shared
+ * package so the aggregate package can register all DDD categories under the
+ * single `ddd-templates` flag.
+ */
+export declare const eventStormingTemplateCategory: TemplateCategory;
+export declare const coreDomainTemplateCategory: TemplateCategory;
+export declare const contextMapTemplateCategory: TemplateCategory;

package/dist/templates/categories.js

@@ -0,0 +1,20 @@
+import { CD_TEMPLATES, CM_TEMPLATES, ES_TEMPLATES } from './components.js';
+/**
+ * One Templates-panel section per senior button. These are gated by
+ * `ddd-templates` only — never by a senior-button flag — so the catalogue stays
+ * available even when a senior button is hidden. They live in the shared
+ * package so the aggregate package can register all DDD categories under the
+ * single `ddd-templates` flag.
+ */
+export const eventStormingTemplateCategory = {
+    name: 'Event Storming',
+    templates: ES_TEMPLATES,
+};
+export const coreDomainTemplateCategory = {
+    name: 'Core Domain Chart',
+    templates: CD_TEMPLATES,
+};
+export const contextMapTemplateCategory = {
+    name: 'Context Map',
+    templates: CM_TEMPLATES,
+};

package/dist/templates/components.d.ts

@@ -0,0 +1,7 @@
+import { type Template } from '@formicoidea/labre-core/gfx/template';
+/** Event Storming: one template per sticky kind + the hotspot. */
+export declare const ES_TEMPLATES: Template[];
+/** Core Domain: the chart background, the sub-domain dots, the team-topology markers, the movement arrow. */
+export declare const CD_TEMPLATES: Template[];
+/** Context Map: the bounded-context bubble, the cloud, the nine relationship patterns. */
+export declare const CM_TEMPLATES: Template[];

package/dist/templates/components.js

@@ -0,0 +1,158 @@
+import { makeTemplateSnapshot, surfaceText, } from '@formicoidea/labre-core/gfx/template';
+import { ConnectorMode, FontFamily, PointStyle, ShapeStyle, StrokeStyle, TextAlign, } from '@formicoidea/labre-core/model';
+import { CD_SUBDOMAINS, CLOUD, CLOUD_VERTICES, CM_BUBBLE, CM_RELATIONSHIPS, ES_HOTSPOT, ES_STICKIES, MOVEMENT_COLOR, TEAM_TOPOLOGIES, } from '../shared/consts';
+/**
+ * Every DDD component (the things the three senior menus create) re-expressed as
+ * an insertable Template, so the whole toolbox is also available from the
+ * Templates panel. Authored as static surface-element JSON from the SAME consts
+ * the live prefabs use, so colours/labels stay in sync.
+ */
+const ATTRS = 'width="100%" height="100%" viewBox="0 0 135 80" xmlns="http://www.w3.org/2000/svg"';
+const NO_STROKE = '#00000000';
+function tpl(name, preview, elements) {
+    return { name, type: 'template', preview, content: makeTemplateSnapshot(elements, name) };
+}
+function stickyEl(fill, text, label, shapeType) {
+    return {
+        type: 'shape',
+        shapeType,
+        filled: true,
+        fillColor: fill,
+        strokeColor: NO_STROKE,
+        strokeWidth: 0,
+        shapeStyle: ShapeStyle.General,
+        roughness: 0,
+        radius: shapeType === 'rect' ? 6 : 0,
+        text: surfaceText(label),
+        color: text,
+        fontFamily: FontFamily.Kalam,
+        fontSize: 20,
+        textAlign: TextAlign.Center,
+        xywh: '[0,0,120,120]',
+    };
+}
+const sq = (c) => `<svg ${ATTRS}><rect x="38" y="13" width="60" height="54" rx="5" fill="${c}"/></svg>`;
+const dia = (c) => `<svg ${ATTRS}><rect x="48" y="20" width="40" height="40" transform="rotate(45 68 40)" fill="${c}"/></svg>`;
+const circ = (c) => `<svg ${ATTRS}><circle cx="68" cy="40" r="22" fill="${c}" stroke="#1f2328" stroke-width="1.5"/></svg>`;
+const mk = (c, l) => `<svg ${ATTRS}><rect x="48" y="20" width="40" height="40" rx="5" fill="${c}" stroke="#1f2328" stroke-width="1.5"/><text x="68" y="47" text-anchor="middle" font-size="20" fill="#1f2328">${l}</text></svg>`;
+const line = (dashed, arrow) => `<svg ${ATTRS} fill="none"><path d="M20 40 H${arrow ? 100 : 115}" stroke="#1f2328" stroke-width="2" stroke-dasharray="${dashed ? '5 4' : '0'}"/>${arrow ? '<path d="M98 32 L114 40 L98 48" stroke="#1f2328" stroke-width="2"/>' : ''}</svg>`;
+/** Event Storming: one template per sticky kind + the hotspot. */
+export const ES_TEMPLATES = [
+    ...ES_STICKIES.map(p => tpl(`Event Storming — ${p.label}`, sq(p.fill), { s: stickyEl(p.fill, p.text, p.label, 'rect') })),
+    tpl('Event Storming — Hotspot', dia(ES_HOTSPOT.fill), {
+        s: stickyEl(ES_HOTSPOT.fill, ES_HOTSPOT.text, ES_HOTSPOT.label, 'diamond'),
+    }),
+];
+/** Core Domain: the chart background, the sub-domain dots, the team-topology markers, the movement arrow. */
+export const CD_TEMPLATES = [
+    tpl('Core Domain Chart', `<svg ${ATTRS} fill="none"><rect x="10" y="6" width="115" height="62" fill="#4d9900" fill-opacity="0.5"/><rect x="10" y="6" width="22" height="62" fill="#9933ff" fill-opacity="0.5"/><path d="M10 68 V6 M10 68 H125" stroke="#1f2328" stroke-width="1.6"/></svg>`, { bg: { type: 'coreDomain', xywh: '[0,0,900,820]' } }),
+    ...CD_SUBDOMAINS.map(d => tpl(`Core Domain — ${d.label}`, circ(d.fill), {
+        dot: {
+            type: 'shape',
+            shapeType: 'ellipse',
+            filled: true,
+            fillColor: d.fill,
+            strokeColor: '#1f2328',
+            strokeWidth: 1.5,
+            shapeStyle: ShapeStyle.General,
+            roughness: 0,
+            xywh: '[0,0,26,26]',
+        },
+    })),
+    ...TEAM_TOPOLOGIES.map(t => tpl(`Team topology — ${t.label}`, mk(t.fill, t.letter), {
+        m: {
+            type: 'shape',
+            shapeType: 'rect',
+            filled: true,
+            fillColor: t.fill,
+            strokeColor: '#1f2328',
+            strokeWidth: 1.5,
+            shapeStyle: ShapeStyle.General,
+            roughness: 0,
+            radius: 4,
+            text: surfaceText(t.letter),
+            color: '#1f2328',
+            fontFamily: FontFamily.Inter,
+            fontSize: 15,
+            textAlign: TextAlign.Center,
+            xywh: '[0,0,30,30]',
+        },
+    })),
+    tpl('Core Domain — Movement over time', line(true, true), {
+        c: {
+            type: 'connector',
+            mode: ConnectorMode.Straight,
+            stroke: MOVEMENT_COLOR,
+            strokeWidth: 2,
+            strokeStyle: StrokeStyle.Dash,
+            frontEndpointStyle: PointStyle.None,
+            rearEndpointStyle: PointStyle.Arrow,
+            source: { position: [0, 80] },
+            target: { position: [160, 0] },
+        },
+    }),
+];
+/** Context Map: the bounded-context bubble, the cloud, the nine relationship patterns. */
+export const CM_TEMPLATES = [
+    tpl('Context Map — Bounded Context', `<svg ${ATTRS} fill="none"><rect x="20" y="25" width="95" height="30" rx="15" fill="${CM_BUBBLE.fill}" stroke="${CM_BUBBLE.stroke}" stroke-width="1.6"/></svg>`, {
+        b: {
+            type: 'shape',
+            shapeType: 'rect',
+            filled: true,
+            fillColor: CM_BUBBLE.fill,
+            strokeColor: CM_BUBBLE.stroke,
+            strokeWidth: 1.5,
+            shapeStyle: ShapeStyle.General,
+            roughness: 0,
+            radius: CM_BUBBLE.radius,
+            text: surfaceText('Bounded Context'),
+            color: CM_BUBBLE.text,
+            fontFamily: FontFamily.Inter,
+            fontSize: 14,
+            textAlign: TextAlign.Center,
+            xywh: `[0,0,${CM_BUBBLE.w},${CM_BUBBLE.h}]`,
+        },
+    }),
+    tpl('Context Map — Cloud / System', `<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>`, {
+        c: {
+            type: 'shape',
+            shapeType: 'polygon',
+            vertices: CLOUD_VERTICES,
+            isClosed: true,
+            filled: true,
+            fillColor: CLOUD.fill,
+            strokeColor: CLOUD.stroke,
+            strokeWidth: 1.5,
+            shapeStyle: ShapeStyle.General,
+            roughness: 0,
+            text: surfaceText('System'),
+            color: '#3d3d3d',
+            fontFamily: FontFamily.Inter,
+            fontSize: 14,
+            textAlign: TextAlign.Center,
+            xywh: `[0,0,${CLOUD.w},${CLOUD.h}]`,
+        },
+    }),
+    ...CM_RELATIONSHIPS.map(r => tpl(`Context Map — ${r.label}`, line(r.dashed, r.upDown), {
+        c: {
+            type: 'connector',
+            mode: ConnectorMode.Straight,
+            stroke: '#1f2328',
+            strokeWidth: 2,
+            strokeStyle: r.dashed ? StrokeStyle.Dash : StrokeStyle.Solid,
+            frontEndpointStyle: PointStyle.None,
+            rearEndpointStyle: r.upDown ? PointStyle.Arrow : PointStyle.None,
+            source: { position: [0, 0] },
+            target: { position: [240, 0] },
+        },
+        t: {
+            type: 'text',
+            text: surfaceText(r.abbrev),
+            color: '#1f2328',
+            fontFamily: FontFamily.Inter,
+            fontSize: 13,
+            textAlign: TextAlign.Center,
+            xywh: '[94,-30,52,22]',
+        },
+    })),
+];

package/dist/toolbar/icons.d.ts

@@ -0,0 +1,6 @@
+/** Senior-button glyph — Event Storming (overlapping stickies). */
+export declare const eventStormingToolbarIcon: import("lit-html").TemplateResult<2>;
+/** Senior-button glyph — Core Domain Chart (axes + bands). */
+export declare const coreDomainToolbarIcon: import("lit-html").TemplateResult<2>;
+/** Senior-button glyph — Context Map (two bubbles + relation). */
+export declare const contextMapToolbarIcon: import("lit-html").TemplateResult<2>;

package/dist/toolbar/icons.js

@@ -0,0 +1,20 @@
+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"/>
+  <rect x="24" y="18" width="22" height="22" rx="2" transform="rotate(5 35 29)" fill="#5BA3DB"/>
+  <rect x="17" y="26" width="22" height="22" rx="2" transform="rotate(-3 28 37)" fill="#FFD84D"/>
+</svg>`;
+/** Senior-button glyph — Core Domain Chart (axes + bands). */
+export const coreDomainToolbarIcon = svg `<svg width="100%" height="100%" viewBox="0 0 56 56" fill="none" xmlns="http://www.w3.org/2000/svg">
+  <rect x="10" y="8" width="38" height="38" fill="#4d9900" fill-opacity="0.55"/>
+  <rect x="10" y="8" width="14" height="38" fill="#9933ff" fill-opacity="0.55"/>
+  <path d="M10 46 V8 M10 46 H48" stroke="#1f2328" stroke-width="2.4" stroke-linecap="round"/>
+  <circle cx="38" cy="18" r="4" fill="#9933ff"/>
+</svg>`;
+/** Senior-button glyph — Context Map (two bubbles + relation). */
+export const contextMapToolbarIcon = svg `<svg width="100%" height="100%" viewBox="0 0 56 56" fill="none" xmlns="http://www.w3.org/2000/svg">
+  <rect x="6" y="10" width="22" height="14" rx="7" fill="#e6f0fa" stroke="#2f6fb0" stroke-width="1.6"/>
+  <rect x="28" y="32" width="22" height="14" rx="7" fill="#e6f0fa" stroke="#2f6fb0" stroke-width="1.6"/>
+  <path d="M20 24 L34 32" stroke="#1f2328" stroke-width="1.8"/>
+</svg>`;

package/dist/toolbar/menu-base.d.ts

@@ -0,0 +1,23 @@
+import { EmptyTool } from '@formicoidea/labre-core/gfx/pointer';
+import { LitElement } from 'lit';
+declare const DddMenuBase_base: typeof LitElement & import("@formicoidea/labre-core/_pkgs/global/utils").Constructor<import("@formicoidea/labre-core/_pkgs/affine-widget-edgeless-toolbar").EdgelessToolbarToolClass>;
+/**
+ * Shared base for the three DDD popover menus: the menu shell styles, the
+ * "create then return to selection (palette stays open)" finish helper and
+ * the telemetry track helper. Each subclass adds its own create* methods (built
+ * from the shared prefab builders) and its own render().
+ */
+export declare abstract class DddMenuBase extends DddMenuBase_base {
+    static styles: import("lit").CSSResult;
+    type: typeof EmptyTool;
+    /** Framework id for telemetry. */
+    protected abstract framework: 'event-storming' | 'core-domain' | 'context-map';
+    protected get surface(): import("@formicoidea/labre-core/std/gfx").SurfaceBlockModel | null;
+    protected get center(): {
+        cx: number;
+        cy: number;
+    };
+    protected finish(id: string): void;
+    protected track(event: 'FrameworkElementAdded' | 'FrameworkToolPicked', element: string): void;
+}
+export {};

package/dist/toolbar/menu-base.js

@@ -0,0 +1,62 @@
+import { DefaultTool } from '@formicoidea/labre-core/blocks/surface';
+import { EmptyTool } from '@formicoidea/labre-core/gfx/pointer';
+import { TelemetryProvider } from '@formicoidea/labre-core/shared/services';
+import { EdgelessToolbarToolMixin } from '@formicoidea/labre-core/widgets/edgeless-toolbar';
+import { css, LitElement } from 'lit';
+/**
+ * Shared base for the three DDD popover menus: the menu shell styles, the
+ * "create then return to selection (palette stays open)" finish helper and
+ * the telemetry track helper. Each subclass adds its own create* methods (built
+ * from the shared prefab builders) and its own render().
+ */
+export class DddMenuBase extends EdgelessToolbarToolMixin(LitElement) {
+    constructor() {
+        super(...arguments);
+        this.type = EmptyTool;
+    }
+    static { this.styles = css `
+    :host {
+      position: absolute;
+      display: flex;
+      z-index: -1;
+    }
+    .menu-content {
+      display: flex;
+      align-items: center;
+      justify-content: center;
+    }
+    .button-group-container {
+      display: flex;
+      align-items: center;
+      gap: 10px;
+      fill: var(--affine-icon-color);
+    }
+    .button-group-container svg {
+      width: 24px;
+      height: 24px;
+    }
+  `; }
+    get surface() {
+        return this.gfx.surface;
+    }
+    get center() {
+        const { centerX, centerY } = this.gfx.viewport;
+        return { cx: centerX, cy: centerY };
+    }
+    finish(id) {
+        const { gfx } = this;
+        gfx.doc.captureSync();
+        gfx.tool.setTool(DefaultTool);
+        gfx.selection.set({ elements: [id], editing: false });
+        // Palette stays open so several objects can be added in a row.
+    }
+    track(event, element) {
+        this.edgeless.std.getOptional(TelemetryProvider)?.track(event, {
+            framework: this.framework,
+            element,
+            page: 'whiteboard editor',
+            segment: 'ddd toolbox',
+            module: `${this.framework} menu`,
+        });
+    }
+}

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

@@ -0,0 +1,20 @@
+import { EmptyTool } from '@formicoidea/labre-core/gfx/pointer';
+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>;
+/**
+ * Shared base for the three DDD senior buttons. Each subclass only differs by
+ * the popover menu it opens, its tooltip and its glyph — the toggle / popper
+ * wiring is identical (mirrors the Cynefin senior button). The concrete
+ * subclasses live in their respective tool packages.
+ */
+export declare abstract class DddSeniorButtonBase extends DddSeniorButtonBase_base {
+    static styles: import("lit").CSSResult;
+    enableActiveBackground: boolean;
+    type: typeof EmptyTool;
+    protected abstract menuTag: keyof HTMLElementTagNameMap;
+    protected abstract label: string;
+    protected abstract icon: TemplateResult;
+    private _toggleMenu;
+    render(): TemplateResult<1>;
+}
+export {};

package/dist/toolbar/senior-buttons.js

@@ -0,0 +1,90 @@
+import { DefaultTool } from '@formicoidea/labre-core/blocks/surface';
+import { EmptyTool } from '@formicoidea/labre-core/gfx/pointer';
+import { EdgelessToolbarToolMixin } from '@formicoidea/labre-core/widgets/edgeless-toolbar';
+import { SignalWatcher } from '@formicoidea/labre-core/global/lit';
+import { css, html, LitElement } from 'lit';
+/**
+ * Shared base for the three DDD senior buttons. Each subclass only differs by
+ * the popover menu it opens, its tooltip and its glyph — the toggle / popper
+ * wiring is identical (mirrors the Cynefin senior button). The concrete
+ * subclasses live in their respective tool packages.
+ */
+export class DddSeniorButtonBase extends EdgelessToolbarToolMixin(SignalWatcher(LitElement)) {
+    constructor() {
+        super(...arguments);
+        this.enableActiveBackground = true;
+        this.type = EmptyTool;
+    }
+    static { this.styles = css `
+    :host,
+    .ddd-button {
+      display: block;
+      width: 100%;
+      height: 100%;
+    }
+    :host {
+      position: relative;
+    }
+    .ddd-root {
+      width: 100%;
+      height: 64px;
+      cursor: pointer;
+      display: flex;
+      align-items: flex-end;
+      justify-content: center;
+    }
+    .ddd-card {
+      --y: -4px;
+      --s: 1;
+      width: 50px;
+      height: 50px;
+      margin-bottom: 4px;
+      transform: translateY(var(--y)) scale(var(--s));
+      transition: transform 0.3s ease;
+    }
+    .ddd-card svg {
+      display: block;
+      width: 100%;
+      height: 100%;
+    }
+    .ddd-root:hover .ddd-card {
+      --y: -10px;
+      --s: 1.07;
+    }
+  `; }
+    _toggleMenu() {
+        if (this.popper) {
+            this.popper.dispose();
+            this.popper = null;
+            return;
+        }
+        this.setEdgelessTool(DefaultTool);
+        const menu = this.createPopper(this.menuTag, this);
+        menu.element.edgeless = this.edgeless;
+        const el = menu.element;
+        const wrap = el.parentElement;
+        if (wrap) {
+            wrap.style.overflow = 'visible';
+            wrap.style.justifyContent = 'flex-end';
+        }
+        Object.assign(el.style, {
+            position: 'static',
+            width: 'max-content',
+            maxWidth: 'calc(100vw - 16px)',
+            marginLeft: '0',
+        });
+    }
+    render() {
+        return html `<edgeless-toolbar-button
+      class="ddd-button"
+      .tooltip=${this.popper ? '' : this.label}
+      .tooltipOffset=${4}
+      .active=${!!this.popper}
+      @click=${this._toggleMenu}
+    >
+      <div class="ddd-root">
+        <div class="ddd-card">${this.icon}</div>
+      </div>
+    </edgeless-toolbar-button>`;
+    }
+}

package/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "@formicoidea/labre-ddd-shared",
+  "description": "Labre ddd-shared — shared building blocks for @formicoidea/labre-core frameworks.",
+  "version": "0.25.0",
+  "type": "module",
+  "sideEffects": false,
+  "author": "lajola",
+  "contributors": [
+    "toeverything"
+  ],
+  "license": "MPL-2.0",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "@formicoidea/labre-core": "0.25.0",
+    "lit": "^3.2.0"
+  }
+}