@formicoidea/labre-framework-ddd-core-domain 0.25.0

package/dist/core-domain/consts.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Visual constants for the Core Domain Chart background (DDD Crew). Authored in
+ * a fixed reference space (900 × 820) and scaled uniformly to the element bounds
+ * by the renderer. Reproduces the supplied template: two axes (Complexity ×
+ * Business differentiation), Low/High ticks and the translucent Generic /
+ * Supporting / Core zone bands. The "Notation" legend is a separate prefab group.
+ */
+export declare const REF_W = 900;
+export declare const REF_H = 820;
+export declare const COLORS: {
+    readonly axis: "#000000";
+    readonly zoneLabel: "#ffffff";
+    readonly tick: "#777777";
+    readonly title: "#000000";
+};
+/** Translucent zone bands (drawn at 0.6 alpha), back-to-front. */
+export declare const ZONES: ReadonlyArray<{
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+    fill: string;
+}>;
+/** Zone names (centred): [text, x, y, fontSize]. */
+export declare const ZONE_LABELS: ReadonlyArray<readonly [string, number, number, number]>;
+/** Axis frame: origin (ox, oy) bottom-left, up to `top`, right to `right`. */
+export declare const AXIS: {
+    readonly ox: 60;
+    readonly oy: 770;
+    readonly top: 24;
+    readonly right: 846;
+};

package/dist/core-domain/consts.js

@@ -0,0 +1,30 @@
+/**
+ * Visual constants for the Core Domain Chart background (DDD Crew). Authored in
+ * a fixed reference space (900 × 820) and scaled uniformly to the element bounds
+ * by the renderer. Reproduces the supplied template: two axes (Complexity ×
+ * Business differentiation), Low/High ticks and the translucent Generic /
+ * Supporting / Core zone bands. The "Notation" legend is a separate prefab group.
+ */
+export const REF_W = 900;
+export const REF_H = 820;
+export const COLORS = {
+    axis: '#000000',
+    zoneLabel: '#ffffff',
+    tick: '#777777',
+    title: '#000000',
+};
+/** Translucent zone bands (drawn at 0.6 alpha), back-to-front. */
+export const ZONES = [
+    { x: 70, y: 30, w: 150, h: 720, fill: '#b3b3b3' },
+    { x: 220, y: 30, w: 220, h: 720, fill: '#9933ff' },
+    { x: 440, y: 30, w: 400, h: 360, fill: '#4d9900' },
+    { x: 440, y: 390, w: 400, h: 360, fill: '#9933ff' },
+];
+/** Zone names (centred): [text, x, y, fontSize]. */
+export const ZONE_LABELS = [
+    ['Core', 640, 214, 26],
+    ['Supporting', 340, 474, 20],
+    ['Generic', 150, 474, 20],
+];
+/** Axis frame: origin (ox, oy) bottom-left, up to `top`, right to `right`. */
+export const AXIS = { ox: 60, oy: 770, top: 24, right: 846 };

package/dist/core-domain/element-renderer.d.ts

@@ -0,0 +1,12 @@
+import { type ElementRenderer } from '@formicoidea/labre-core/blocks/surface';
+import type { CoreDomainChartElementModel } from '@formicoidea/labre-core/model';
+/**
+ * Canvas renderer for the Core Domain Chart background — the translucent
+ * Generic / Supporting / Core zone bands, the two axes with arrow heads and the
+ * Low/High ticks + zone names. Drawn in the fixed reference space and scaled
+ * uniformly to the element bounds.
+ */
+export declare const coreDomain: ElementRenderer<CoreDomainChartElementModel>;
+export declare const CoreDomainRendererExtension: import("@formicoidea/labre-core/store").ExtensionType & {
+    identifier: import("@formicoidea/labre-core/_pkgs/global/di").ServiceIdentifier<ElementRenderer<CoreDomainChartElementModel>>;
+};

package/dist/core-domain/element-renderer.js

@@ -0,0 +1,93 @@
+import { ElementRendererExtension, } from '@formicoidea/labre-core/blocks/surface';
+import { FONT_FAMILY, refScale } from '@formicoidea/labre-ddd-shared';
+import { AXIS, COLORS, REF_H, REF_W, ZONE_LABELS, ZONES } from './consts';
+/**
+ * Canvas renderer for the Core Domain Chart background — the translucent
+ * Generic / Supporting / Core zone bands, the two axes with arrow heads and the
+ * Low/High ticks + zone names. Drawn in the fixed reference space and scaled
+ * uniformly to the element bounds.
+ */
+export const coreDomain = (model, ctx, matrix) => {
+    const [, , w, h] = model.deserializedXYWH;
+    const cx = w / 2;
+    const cy = h / 2;
+    ctx.setTransform(matrix.translateSelf(cx, cy).rotateSelf(model.rotate).translateSelf(-cx, -cy));
+    const { s, ox, oy } = refScale(w, h, REF_W, REF_H);
+    ctx.translate(ox, oy);
+    ctx.scale(s, s);
+    // ── Translucent zone bands ──────────────────────────────────────────
+    if (model.showZones) {
+        ctx.globalAlpha = 0.6;
+        for (const z of ZONES) {
+            ctx.fillStyle = z.fill;
+            ctx.fillRect(z.x, z.y, z.w, z.h);
+        }
+        ctx.globalAlpha = 1;
+    }
+    // ── Axes with arrow heads ───────────────────────────────────────────
+    ctx.strokeStyle = COLORS.axis;
+    ctx.fillStyle = COLORS.axis;
+    ctx.lineWidth = 2;
+    ctx.lineJoin = 'round';
+    // Y axis (up)
+    ctx.beginPath();
+    ctx.moveTo(AXIS.ox, AXIS.oy);
+    ctx.lineTo(AXIS.ox, AXIS.top + 6);
+    ctx.stroke();
+    arrow(ctx, AXIS.ox, AXIS.top, 0);
+    // X axis (right)
+    ctx.beginPath();
+    ctx.moveTo(AXIS.ox, AXIS.oy);
+    ctx.lineTo(AXIS.right - 6, AXIS.oy);
+    ctx.stroke();
+    arrow(ctx, AXIS.right, AXIS.oy, 90);
+    ctx.textBaseline = 'alphabetic';
+    // ── Zone names ──────────────────────────────────────────────────────
+    ctx.textAlign = 'center';
+    for (const [text, x, y, size] of ZONE_LABELS) {
+        ctx.fillStyle = COLORS.zoneLabel;
+        ctx.font = `700 ${size}px ${FONT_FAMILY}`;
+        ctx.fillText(text, x, y);
+    }
+    // ── Axis titles + Low/High ticks ────────────────────────────────────
+    if (model.showLabels) {
+        ctx.fillStyle = COLORS.title;
+        ctx.font = `600 14px ${FONT_FAMILY}`;
+        ctx.save();
+        ctx.translate(28, 400);
+        ctx.rotate(-Math.PI / 2);
+        ctx.fillText('Complexity', 0, 0);
+        ctx.restore();
+        ctx.fillText('Business differentiation', 450, 800);
+        ctx.fillStyle = COLORS.tick;
+        ctx.font = `12px ${FONT_FAMILY}`;
+        // X ticks
+        ctx.fillText('Low', 84, 792);
+        ctx.fillText('High', 838, 792);
+        // Y ticks
+        ctx.save();
+        ctx.translate(48, 758);
+        ctx.rotate(-Math.PI / 2);
+        ctx.fillText('Low', 0, 0);
+        ctx.restore();
+        ctx.save();
+        ctx.translate(38, 44);
+        ctx.rotate(-Math.PI / 2);
+        ctx.fillText('High', 0, 0);
+        ctx.restore();
+    }
+};
+/** Filled triangular arrow head at (x, y); `deg` rotates it (0 = pointing up). */
+function arrow(ctx, x, y, deg) {
+    ctx.save();
+    ctx.translate(x, y);
+    ctx.rotate((deg * Math.PI) / 180);
+    ctx.beginPath();
+    ctx.moveTo(0, 0);
+    ctx.lineTo(-5, 9);
+    ctx.lineTo(5, 9);
+    ctx.closePath();
+    ctx.fill();
+    ctx.restore();
+}
+export const CoreDomainRendererExtension = ElementRendererExtension('coreDomain', coreDomain);

package/dist/core-domain/element-view.d.ts

@@ -0,0 +1,11 @@
+import type { CoreDomainChartElementModel } from '@formicoidea/labre-core/model';
+import { GfxElementModelView } from '@formicoidea/labre-core/std/gfx';
+/**
+ * View for the Core Domain Chart background. Registering it ensures
+ * `gfx.view.get(model)` returns a view (required so move / select work).
+ */
+export declare class CoreDomainView extends GfxElementModelView<CoreDomainChartElementModel> {
+    static type: string;
+}
+/** Resize gating: handles hidden unless `model.resizeEnabled` (toolbar toggle). */
+export declare const CoreDomainInteraction: import("@formicoidea/labre-core/store").ExtensionType;

package/dist/core-domain/element-view.js

@@ -0,0 +1,20 @@
+import { GfxElementModelView, GfxViewInteractionExtension, } from '@formicoidea/labre-core/std/gfx';
+/**
+ * View for the Core Domain Chart background. Registering it ensures
+ * `gfx.view.get(model)` returns a view (required so move / select work).
+ */
+export class CoreDomainView extends GfxElementModelView {
+    static { this.type = 'coreDomain'; }
+}
+/** Resize gating: handles hidden unless `model.resizeEnabled` (toolbar toggle). */
+export const CoreDomainInteraction = GfxViewInteractionExtension(CoreDomainView.type, {
+    handleResize({ model }) {
+        return {
+            beforeResize({ set }) {
+                if (!model.resizeEnabled) {
+                    set({ allowedHandlers: [] });
+                }
+            },
+        };
+    },
+});

package/dist/core-domain/legend.d.ts

@@ -0,0 +1,18 @@
+import { type LegendSection } from '@formicoidea/labre-ddd-shared';
+import { type CoreDomainChartElementModel } from '@formicoidea/labre-core/model';
+import type { BlockStdScope } from '@formicoidea/labre-core/std';
+/**
+ * Build the Notation legend sections. When `present` is given (a content-aware
+ * scan of the background), only the sub-domain types / team-topology modes /
+ * movement actually used are listed; otherwise the full notation is shown.
+ */
+export declare function coreDomainLegendSections(present?: {
+    fills: Set<string>;
+    movement: boolean;
+}): LegendSection[];
+/**
+ * Insert a content-aware legend next to a Core Domain background: scans the
+ * shapes/connectors inside the background's perimeter and lists only the
+ * notation actually present. Triggered from the element's contextual toolbar.
+ */
+export declare function createCoreDomainLegend(std: BlockStdScope, bg: CoreDomainChartElementModel): void;

package/dist/core-domain/legend.js

@@ -0,0 +1,68 @@
+import { addLegend, CD_SUBDOMAINS, MOVEMENT_COLOR, TEAM_TOPOLOGIES, } from '@formicoidea/labre-ddd-shared';
+import { ConnectorElementModel, ShapeElementModel, StrokeStyle, } from '@formicoidea/labre-core/model';
+import { Bound } from '@formicoidea/labre-core/global/gfx';
+import { GfxControllerIdentifier } from '@formicoidea/labre-core/std/gfx';
+/**
+ * Build the Notation legend sections. When `present` is given (a content-aware
+ * scan of the background), only the sub-domain types / team-topology modes /
+ * movement actually used are listed; otherwise the full notation is shown.
+ */
+export function coreDomainLegendSections(present) {
+    const has = (c) => !present || present.fills.has(c.toLowerCase());
+    const subRows = CD_SUBDOMAINS.filter(s => has(s.fill)).map(s => ({
+        swatch: 'dot',
+        color: s.fill,
+        label: s.label,
+    }));
+    const ttRows = TEAM_TOPOLOGIES.filter(t => has(t.fill)).map(t => ({
+        swatch: 'square',
+        color: t.fill,
+        letter: t.letter,
+        label: t.label,
+    }));
+    const sections = [];
+    if (subRows.length)
+        sections.push({ title: 'Sub-domains', rows: subRows });
+    if (ttRows.length)
+        sections.push({ title: 'Team topologies', rows: ttRows });
+    if (!present || present.movement) {
+        sections.push({
+            title: 'Movement',
+            rows: [{ swatch: 'line', color: MOVEMENT_COLOR, label: 'Movement over time' }],
+        });
+    }
+    // Content-aware scan found nothing recognizable → fall back to the full legend.
+    if (present && sections.length === 0)
+        return coreDomainLegendSections();
+    return sections;
+}
+/**
+ * Insert a content-aware legend next to a Core Domain background: scans the
+ * shapes/connectors inside the background's perimeter and lists only the
+ * notation actually present. Triggered from the element's contextual toolbar.
+ */
+export function createCoreDomainLegend(std, bg) {
+    const gfx = std.get(GfxControllerIdentifier);
+    const surface = gfx.surface;
+    if (!surface)
+        return;
+    const fills = new Set();
+    let movement = false;
+    for (const el of gfx.getElementsByBound(Bound.deserialize(bg.xywh), {
+        type: 'canvas',
+    })) {
+        if (el instanceof ConnectorElementModel) {
+            if (el.strokeStyle === StrokeStyle.Dash)
+                movement = true;
+        }
+        else if (el instanceof ShapeElementModel) {
+            if (typeof el.fillColor === 'string')
+                fills.add(el.fillColor.toLowerCase());
+        }
+    }
+    const [bx, by, bw] = bg.deserializedXYWH;
+    addLegend(surface, std, bx + bw + 30, by, {
+        title: 'Légende',
+        sections: coreDomainLegendSections({ fills, movement }),
+    });
+}

package/dist/core-domain/toolbar-config.d.ts

@@ -0,0 +1 @@
+export declare const coreDomainToolbarExtension: import("@formicoidea/labre-core/store").ExtensionType;

package/dist/core-domain/toolbar-config.js

@@ -0,0 +1,45 @@
+import { CoreDomainChartElementModel } from '@formicoidea/labre-core/model';
+import { TelemetryProvider, ToolbarModuleExtension, } from '@formicoidea/labre-core/shared/services';
+import { BlockFlavourIdentifier } from '@formicoidea/labre-core/std';
+import { html } from 'lit';
+import { createCoreDomainLegend } from './legend';
+const legendIcon = 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>`;
+/** Contextual toolbar for a selected Core Domain background: insert its legend. */
+const coreDomainToolbarConfig = {
+    actions: [
+        {
+            id: 'a.legend',
+            tooltip: 'Insert legend (notation present in the chart)',
+            icon: legendIcon,
+            run(ctx) {
+                const bg = ctx.getSurfaceModelsByType(CoreDomainChartElementModel)[0];
+                if (!bg)
+                    return;
+                createCoreDomainLegend(ctx.std, bg);
+                ctx.std.getOptional(TelemetryProvider)?.track('FrameworkLegendCreated', {
+                    framework: 'core-domain',
+                    element: 'legend',
+                    page: 'whiteboard editor',
+                    segment: 'element toolbar',
+                    module: 'core-domain toolbar',
+                });
+            },
+        },
+    ],
+    when: ctx => ctx.getSurfaceModelsByType(CoreDomainChartElementModel).length > 0,
+};
+export const coreDomainToolbarExtension = ToolbarModuleExtension({
+    id: BlockFlavourIdentifier('affine:surface:coreDomain'),
+    config: coreDomainToolbarConfig,
+});

package/dist/descriptor.d.ts

@@ -0,0 +1,11 @@
+import { DddCoreDomainRenderViewExtension, DddCoreDomainViewExtension } from './view.js';
+/** Host wiring for the ddd-core-domain framework. */
+export declare const dddCoreDomainFramework: {
+    readonly telemetry: "ddd-core-domain";
+    readonly extensions: readonly [{
+        readonly viewExtension: typeof DddCoreDomainRenderViewExtension;
+    }, {
+        readonly flag: "ddd-core-domain";
+        readonly viewExtension: typeof DddCoreDomainViewExtension;
+    }];
+};

package/dist/descriptor.js

@@ -0,0 +1,9 @@
+import { DddCoreDomainRenderViewExtension, DddCoreDomainViewExtension } from './view.js';
+/** Host wiring for the ddd-core-domain framework. */
+export const dddCoreDomainFramework = {
+    telemetry: 'ddd-core-domain',
+    extensions: [
+        { viewExtension: DddCoreDomainRenderViewExtension },
+        { flag: 'ddd-core-domain', viewExtension: DddCoreDomainViewExtension },
+    ],
+};

package/dist/effects.d.ts

@@ -0,0 +1,9 @@
+import { EdgelessDddCoreDomainMenu } from './toolbar/core-domain-menu';
+import { EdgelessDddCoreDomainSeniorButton } from './toolbar/senior-button';
+export declare function coreDomainEffects(): void;
+declare global {
+    interface HTMLElementTagNameMap {
+        'edgeless-ddd-core-domain-menu': EdgelessDddCoreDomainMenu;
+        'edgeless-ddd-core-domain-senior-button': EdgelessDddCoreDomainSeniorButton;
+    }
+}

package/dist/effects.js

@@ -0,0 +1,11 @@
+import { EdgelessDddCoreDomainMenu } from './toolbar/core-domain-menu';
+import { EdgelessDddCoreDomainSeniorButton } from './toolbar/senior-button';
+/** Define a custom element once (each tool's effect may run more than once). */
+function define(tag, ctor) {
+    if (!customElements.get(tag))
+        customElements.define(tag, ctor);
+}
+export function coreDomainEffects() {
+    define('edgeless-ddd-core-domain-menu', EdgelessDddCoreDomainMenu);
+    define('edgeless-ddd-core-domain-senior-button', EdgelessDddCoreDomainSeniorButton);
+}

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export { coreDomain } from './core-domain/element-renderer.js';
+export { coreDomainTemplateCategory } from './templates.js';
+export { coreDomainSeniorTool } from './toolbar/senior-tool.js';
+export { EdgelessDddCoreDomainSeniorButton } from './toolbar/senior-button.js';
+export { DddCoreDomainRenderViewExtension, DddCoreDomainViewExtension, } from './view.js';

package/dist/index.js

@@ -0,0 +1,5 @@
+export { coreDomain } from './core-domain/element-renderer.js';
+export { coreDomainTemplateCategory } from './templates.js';
+export { coreDomainSeniorTool } from './toolbar/senior-tool.js';
+export { EdgelessDddCoreDomainSeniorButton } from './toolbar/senior-button.js';
+export { DddCoreDomainRenderViewExtension, DddCoreDomainViewExtension, } from './view.js';

package/dist/templates.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Core Domain Chart Templates-panel category. The builder lives in the shared
+ * package so the aggregate package can register all DDD categories under the
+ * single `ddd-templates` flag; re-exported here for a stable per-package API.
+ */
+export { coreDomainTemplateCategory } from '@formicoidea/labre-ddd-shared';

package/dist/templates.js

@@ -0,0 +1,6 @@
+/**
+ * Core Domain Chart Templates-panel category. The builder lives in the shared
+ * package so the aggregate package can register all DDD categories under the
+ * single `ddd-templates` flag; re-exported here for a stable per-package API.
+ */
+export { coreDomainTemplateCategory } from '@formicoidea/labre-ddd-shared';

package/dist/toolbar/core-domain-menu.d.ts

@@ -0,0 +1,11 @@
+import { DddMenuBase } from '@formicoidea/labre-ddd-shared';
+/** Core Domain Chart palette: the background, sub-domain dots, movement arrow, Notation legend. */
+export declare class EdgelessDddCoreDomainMenu extends DddMenuBase {
+    protected framework: "core-domain";
+    private _createBackground;
+    private _createDot;
+    private _createMarker;
+    private _createMovement;
+    private _createLegend;
+    render(): import("lit-html").TemplateResult<1>;
+}

package/dist/toolbar/core-domain-menu.js

@@ -0,0 +1,116 @@
+import { addConnector, addDot, addLegend, addMarker, CD_SUBDOMAINS, DddMenuBase, MOVEMENT_COLOR, TEAM_TOPOLOGIES, } from '@formicoidea/labre-ddd-shared';
+import { Bound } from '@formicoidea/labre-core/global/gfx';
+import { html, svg } from 'lit';
+import { REF_H, REF_W } from '../core-domain/consts';
+import { coreDomainLegendSections } from '../core-domain/legend';
+const chartSwatch = svg `<svg viewBox="0 0 24 24" fill="none"><rect x="4" y="3" width="17" height="17" fill="#4d9900" fill-opacity="0.5"/><rect x="4" y="3" width="6" height="17" fill="#9933ff" fill-opacity="0.5"/><path d="M4 20 V3 M4 20 H21" stroke="currentColor" stroke-width="1.8"/></svg>`;
+const dotSwatch = (color) => svg `<svg viewBox="0 0 24 24"><circle cx="12" cy="12" r="7" fill="${color}" stroke="#1f2328" stroke-width="1.2"/></svg>`;
+const movementSwatch = svg `<svg viewBox="0 0 24 24" fill="none"><path d="M3 18 L16 7" stroke="${MOVEMENT_COLOR}" stroke-width="2" stroke-dasharray="3 3"/><path d="M12 6 L18 5 L17 11" stroke="${MOVEMENT_COLOR}" stroke-width="2" fill="none"/></svg>`;
+const legendSwatch = svg `<svg viewBox="0 0 24 24" fill="none"><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>`;
+const markerSwatch = (fill, letter) => svg `<svg viewBox="0 0 24 24"><rect x="4" y="4" width="16" height="16" rx="3" fill="${fill}" stroke="#1f2328" stroke-width="1.2"/><text x="12" y="16" text-anchor="middle" font-size="11" font-family="sans-serif" fill="#1f2328">${letter}</text></svg>`;
+/** Core Domain Chart palette: the background, sub-domain dots, movement arrow, Notation legend. */
+export class EdgelessDddCoreDomainMenu extends DddMenuBase {
+    constructor() {
+        super(...arguments);
+        this.framework = 'core-domain';
+    }
+    _createBackground() {
+        const surface = this.surface;
+        if (!surface)
+            return;
+        const { cx, cy } = this.center;
+        const id = surface.addElement({
+            type: 'coreDomain',
+            xywh: new Bound(cx - REF_W / 2, cy - REF_H / 2, REF_W, REF_H).serialize(),
+        });
+        this.track('FrameworkElementAdded', 'background');
+        this.finish(id);
+    }
+    _createDot(preset) {
+        const surface = this.surface;
+        if (!surface)
+            return;
+        const { cx, cy } = this.center;
+        const id = addDot(surface, this.edgeless.std, cx, cy, preset.fill, preset.label);
+        this.track('FrameworkElementAdded', `subdomain:${preset.kind}`);
+        this.finish(id);
+    }
+    _createMarker(preset) {
+        const surface = this.surface;
+        if (!surface)
+            return;
+        const { cx, cy } = this.center;
+        const id = addMarker(surface, this.edgeless.std, cx, cy, {
+            fill: preset.fill,
+            letter: preset.letter,
+            label: preset.label,
+        });
+        this.track('FrameworkElementAdded', `team-topology:${preset.kind}`);
+        this.finish(id);
+    }
+    _createMovement() {
+        const surface = this.surface;
+        if (!surface)
+            return;
+        const { cx, cy } = this.center;
+        const id = addConnector(surface, cx - 80, cy + 60, cx + 80, cy - 60, {
+            rearArrow: true,
+            dashed: true,
+            stroke: MOVEMENT_COLOR,
+        });
+        this.track('FrameworkElementAdded', 'movement');
+        this.finish(id);
+    }
+    _createLegend() {
+        const surface = this.surface;
+        if (!surface)
+            return;
+        const { cx, cy } = this.center;
+        const id = addLegend(surface, this.edgeless.std, cx - 130, cy - 170, {
+            title: 'Légende',
+            sections: coreDomainLegendSections(),
+        });
+        this.track('FrameworkElementAdded', 'legend');
+        this.finish(id);
+    }
+    render() {
+        return html `
+      <edgeless-slide-menu>
+        <div class="menu-content">
+          <div class="button-group-container">
+            <edgeless-tool-icon-button
+              .tooltip=${'Core Domain Chart'}
+              @click=${() => this._createBackground()}
+            >
+              ${chartSwatch}
+            </edgeless-tool-icon-button>
+            ${CD_SUBDOMAINS.map(preset => html `<edgeless-tool-icon-button
+                .tooltip=${preset.label}
+                @click=${() => this._createDot(preset)}
+              >
+                ${dotSwatch(preset.fill)}
+              </edgeless-tool-icon-button>`)}
+            ${TEAM_TOPOLOGIES.map(preset => html `<edgeless-tool-icon-button
+                .tooltip=${preset.label}
+                @click=${() => this._createMarker(preset)}
+              >
+                ${markerSwatch(preset.fill, preset.letter)}
+              </edgeless-tool-icon-button>`)}
+            <edgeless-tool-icon-button
+              .tooltip=${'Movement over time'}
+              @click=${() => this._createMovement()}
+            >
+              ${movementSwatch}
+            </edgeless-tool-icon-button>
+            <edgeless-tool-icon-button
+              .tooltip=${'Notation legend'}
+              @click=${() => this._createLegend()}
+            >
+              ${legendSwatch}
+            </edgeless-tool-icon-button>
+          </div>
+        </div>
+      </edgeless-slide-menu>
+    `;
+    }
+}

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

@@ -0,0 +1,6 @@
+import { DddSeniorButtonBase } from '@formicoidea/labre-ddd-shared';
+export declare class EdgelessDddCoreDomainSeniorButton extends DddSeniorButtonBase {
+    protected menuTag: "edgeless-ddd-core-domain-menu";
+    protected label: string;
+    protected icon: import("lit-html").TemplateResult<2>;
+}

package/dist/toolbar/senior-button.js

@@ -0,0 +1,9 @@
+import { coreDomainToolbarIcon, DddSeniorButtonBase, } from '@formicoidea/labre-ddd-shared';
+export class EdgelessDddCoreDomainSeniorButton extends DddSeniorButtonBase {
+    constructor() {
+        super(...arguments);
+        this.menuTag = 'edgeless-ddd-core-domain-menu';
+        this.label = 'Core Domain Chart';
+        this.icon = coreDomainToolbarIcon;
+    }
+}

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

@@ -0,0 +1,2 @@
+/** Independent senior tool — Core Domain Chart. */
+export declare const coreDomainSeniorTool: import("@formicoidea/labre-core/store").ExtensionType;

package/dist/toolbar/senior-tool.js

@@ -0,0 +1,9 @@
+import { SeniorToolExtension } from '@formicoidea/labre-core/widgets/edgeless-toolbar';
+import { html } from 'lit';
+/** Independent senior tool — Core Domain Chart. */
+export const coreDomainSeniorTool = SeniorToolExtension('ddd-core-domain', ({ block }) => ({
+    name: 'Core Domain Chart',
+    content: html `<edgeless-ddd-core-domain-senior-button
+      .edgeless=${block}
+    ></edgeless-ddd-core-domain-senior-button>`,
+}));

package/dist/view.d.ts

@@ -0,0 +1,24 @@
+import { type ViewExtensionContext, ViewExtensionProvider } from '@formicoidea/labre-core/ext-loader';
+/**
+ * Core Domain Chart rendering — ALWAYS registered, independent of any flag.
+ * Disabling `ddd-core-domain` hides only the senior toolbar button (see
+ * {@link DddCoreDomainViewExtension}); placed `coreDomain` elements must still
+ * paint, stay selectable, and keep their contextual toolbar, and Templates-
+ * panel insertion must still render them.
+ */
+export declare class DddCoreDomainRenderViewExtension extends ViewExtensionProvider {
+    name: string;
+    setup(context: ViewExtensionContext): void;
+}
+/**
+ * Core Domain Chart senior button — independently flag-gated (`ddd-core-domain`).
+ *
+ * Note: its Templates-panel category is registered by the aggregate package's
+ * {@link DddTemplatesViewExtension} (gated by `ddd-templates`), so templates
+ * stay available even when this senior button is disabled.
+ */
+export declare class DddCoreDomainViewExtension extends ViewExtensionProvider {
+    name: string;
+    effect(): void;
+    setup(context: ViewExtensionContext): void;
+}

package/dist/view.js

@@ -0,0 +1,51 @@
+import { ViewExtensionProvider, } from '@formicoidea/labre-core/ext-loader';
+import { CoreDomainRendererExtension } from './core-domain/element-renderer';
+import { CoreDomainInteraction, CoreDomainView } from './core-domain/element-view';
+import { coreDomainToolbarExtension } from './core-domain/toolbar-config';
+import { coreDomainEffects } from './effects';
+import { coreDomainSeniorTool } from './toolbar/senior-tool';
+/**
+ * Core Domain Chart rendering — ALWAYS registered, independent of any flag.
+ * Disabling `ddd-core-domain` hides only the senior toolbar button (see
+ * {@link DddCoreDomainViewExtension}); placed `coreDomain` elements must still
+ * paint, stay selectable, and keep their contextual toolbar, and Templates-
+ * panel insertion must still render them.
+ */
+export class DddCoreDomainRenderViewExtension extends ViewExtensionProvider {
+    constructor() {
+        super(...arguments);
+        this.name = 'affine-ddd-core-domain-render-gfx';
+    }
+    setup(context) {
+        super.setup(context);
+        context.register(CoreDomainView);
+        context.register(CoreDomainRendererExtension);
+        if (this.isEdgeless(context.scope)) {
+            context.register(CoreDomainInteraction);
+            context.register(coreDomainToolbarExtension);
+        }
+    }
+}
+/**
+ * Core Domain Chart senior button — independently flag-gated (`ddd-core-domain`).
+ *
+ * Note: its Templates-panel category is registered by the aggregate package's
+ * {@link DddTemplatesViewExtension} (gated by `ddd-templates`), so templates
+ * stay available even when this senior button is disabled.
+ */
+export class DddCoreDomainViewExtension extends ViewExtensionProvider {
+    constructor() {
+        super(...arguments);
+        this.name = 'affine-ddd-core-domain-gfx';
+    }
+    effect() {
+        super.effect();
+        coreDomainEffects();
+    }
+    setup(context) {
+        super.setup(context);
+        if (this.isEdgeless(context.scope)) {
+            context.register(coreDomainSeniorTool);
+        }
+    }
+}

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "@formicoidea/labre-framework-ddd-core-domain",
+  "description": "Labre ddd-core-domain framework for @formicoidea/labre-core.",
+  "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"
+    },
+    "./view": {
+      "types": "./dist/view.d.ts",
+      "import": "./dist/view.js"
+    },
+    "./descriptor": {
+      "types": "./dist/descriptor.d.ts",
+      "import": "./dist/descriptor.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "@formicoidea/labre-core": "0.25.0",
+    "@formicoidea/labre-ddd-shared": "0.25.0",
+    "lit": "^3.2.0"
+  }
+}