@formicoidea/labre-framework-ddd-core-domain 0.41.0 → 0.43.1

package/dist/core-domain/background.js

@@ -31,8 +31,13 @@ import { CORE_DOMAIN_ROLE } from '../roles.js';
 /**
  * The authoring reference space, kept as documentation of where every ratio
  * below comes from: the chart was drawn at 900 × 820 with its plot inset by the
- * margins declared in {@link CORE_DOMAIN_BACKGROUND}, so the plot is 786 × 746
- * and `(absolute - origin) / span` is the conversion.
+ * ORIGINAL margins `{ top: 24, right: 54, bottom: 50, left: 60 }`, so the plot
+ * is 786 × 746 and `(absolute - origin) / span` is the conversion.
+ *
+ * These numbers are the conversion and nothing else: they are NOT the margins
+ * the chart is drawn with any more (see {@link CORE_DOMAIN_MARGIN}). The ratios
+ * below therefore still describe the same picture — the picture simply fills a
+ * tighter frame.
  */
 const PLOT = { x0: 60, y0: 24, width: 786, height: 746 };
 /** An absolute X of the reference drawing, as a ratio of the plot. */
@@ -94,10 +99,20 @@ const MIGRATION_TEXT = {
     weight: 700,
     color: '@zoneLabelDark',
 };
-/** A centred zone name, gated by `showLabels` like every other word on the chart. */
-function zoneLabel(id, key, fallback, x, y, style) {
+/**
+ * A centred zone name, gated by `showLabels` like every other word on the chart.
+ *
+ * `prop` is what makes it RENAMABLE (issue #355): the model prop the in-place
+ * editor writes to, which `backgroundLabelText` reads BEFORE the catalogue — so
+ * a chart the user has renamed keeps their words, and every other chart keeps
+ * the vocabulary in whatever language the host serves it. The id and the prop
+ * are deliberately two strings: the id names a piece of this declaration, the
+ * prop names a key in somebody's document, and only the first may ever change.
+ */
+function zoneLabel(id, prop, key, fallback, x, y, style) {
     return {
         id,
+        prop,
         labelKey: `com.labre.core-domain.background.zone.${key}`,
         fallback,
         anchor: { x: rx(x), y: ry(y) },
@@ -127,7 +142,7 @@ const CLASSIC_ZONES = [
         rect: { x: rx(70), y: ry(30), w: rw(150), h: rh(720) },
         fill: '@zoneGeneric',
         fillVisibleProp: 'showZones',
-        label: zoneLabel('generic', 'generic', 'Generic', 150, 474, ZONE_TEXT),
+        label: zoneLabel('generic', 'zoneGeneric', 'generic', 'Generic', 150, 474, ZONE_TEXT),
     },
     {
         id: 'supporting-low-diff',
@@ -135,7 +150,7 @@ const CLASSIC_ZONES = [
         rect: { x: rx(220), y: ry(30), w: rw(220), h: rh(720) },
         fill: '@zoneSupporting',
         fillVisibleProp: 'showZones',
-        label: zoneLabel('supporting', 'supporting', 'Supporting', 340, 474, ZONE_TEXT),
+        label: zoneLabel('supporting', 'zoneSupporting', 'supporting', 'Supporting', 340, 474, ZONE_TEXT),
     },
     {
         id: 'core',
@@ -143,7 +158,7 @@ const CLASSIC_ZONES = [
         rect: { x: rx(440), y: ry(30), w: rw(400), h: rh(360) },
         fill: '@zoneCore',
         fillVisibleProp: 'showZones',
-        label: zoneLabel('core', 'core', 'Core', 640, 214, CORE_TEXT),
+        label: zoneLabel('core', 'zoneCore', 'core', 'Core', 640, 214, CORE_TEXT),
     },
     {
         // The template tints this one and writes nothing on it, so neither does the
@@ -173,6 +188,7 @@ const MIGRATION_ZONES = [
         fillVisibleProp: 'showZones',
         label: {
             id: 'lastToothpaste',
+            prop: 'zoneLastToothpaste',
             labelKey: 'com.labre.core-domain.background.zone.last-toothpaste',
             fallback: 'Last toothpaste',
             anchor: { x: 0.25, y: 0.25 },
@@ -189,6 +205,7 @@ const MIGRATION_ZONES = [
         fillVisibleProp: 'showZones',
         label: {
             id: 'riskSeeking',
+            prop: 'zoneRiskSeeking',
             labelKey: 'com.labre.core-domain.background.zone.risk-seeking',
             fallback: 'Risk-seeking',
             anchor: { x: 0.75, y: 0.25 },
@@ -205,6 +222,7 @@ const MIGRATION_ZONES = [
         fillVisibleProp: 'showZones',
         label: {
             id: 'riskAverse',
+            prop: 'zoneRiskAverse',
             labelKey: 'com.labre.core-domain.background.zone.risk-averse',
             fallback: 'Risk-averse',
             anchor: { x: 0.25, y: 0.75 },
@@ -221,6 +239,7 @@ const MIGRATION_ZONES = [
         fillVisibleProp: 'showZones',
         label: {
             id: 'lowHangingFruit',
+            prop: 'zoneLowHangingFruit',
             labelKey: 'com.labre.core-domain.background.zone.lhf',
             fallback: 'Low-hanging fruit',
             anchor: { x: 0.75, y: 0.75 },
@@ -254,6 +273,7 @@ const CORE_DOMAIN_AXES = [
         stroke: { color: '@axis', width: 2 },
         title: {
             id: 'complexityTitle',
+            prop: 'complexityTitle',
             // The classic reading's vertical axis. The migration one relabels it —
             // see `MIGRATION_AXIS_TITLE` below, and why it rides in `endLabels`.
             variants: ['classic'],
@@ -267,6 +287,7 @@ const CORE_DOMAIN_AXES = [
         endLabels: [
             {
                 id: 'complexityLow',
+                prop: 'complexityLow',
                 labelKey: 'com.labre.core-domain.background.complexity.low',
                 fallback: 'Low',
                 anchor: { x: 0, y: ry(758), dx: -12 },
@@ -276,6 +297,7 @@ const CORE_DOMAIN_AXES = [
             },
             {
                 id: 'complexityHigh',
+                prop: 'complexityHigh',
                 labelKey: 'com.labre.core-domain.background.complexity.high',
                 fallback: 'High',
                 anchor: { x: 0, y: ry(44), dx: -22 },
@@ -295,6 +317,7 @@ const CORE_DOMAIN_AXES = [
              */
             {
                 id: 'complexityTitleMigration',
+                prop: 'migrationCostTitle',
                 variants: ['migration'],
                 labelKey: 'com.labre.core-domain.background.axis.migration-cost',
                 fallback: 'Cost of migration',
@@ -314,6 +337,7 @@ const CORE_DOMAIN_AXES = [
         stroke: { color: '@axis', width: 2 },
         title: {
             id: 'differentiationTitle',
+            prop: 'differentiationTitle',
             labelKey: 'com.labre.core-domain.background.axis.differentiation',
             fallback: 'Business differentiation',
             anchor: { x: rx(450), y: 1, dy: 30 },
@@ -324,6 +348,7 @@ const CORE_DOMAIN_AXES = [
         endLabels: [
             {
                 id: 'differentiationLow',
+                prop: 'differentiationLow',
                 labelKey: 'com.labre.core-domain.background.differentiation.low',
                 fallback: 'Low',
                 anchor: { x: rx(84), y: 1, dy: 22 },
@@ -333,6 +358,7 @@ const CORE_DOMAIN_AXES = [
             },
             {
                 id: 'differentiationHigh',
+                prop: 'differentiationHigh',
                 labelKey: 'com.labre.core-domain.background.differentiation.high',
                 fallback: 'High',
                 anchor: { x: rx(838), y: 1, dy: 22 },
@@ -343,6 +369,53 @@ const CORE_DOMAIN_AXES = [
         ],
     },
 ];
+/**
+ * The margins, each one the ink it actually hosts — not a round number.
+ *
+ * The chart used to be inset by `{ top: 24, right: 54, bottom: 50, left: 60 }`,
+ * drawn when the frame was authored and never measured since. Measured on the
+ * canvas at the authoring size, the ink of a default chart stopped 24.1 units
+ * short of the top edge, 50.7 short of the right one, 20.1 short of the bottom
+ * and 17.2 short of the left: about a tenth of the element was empty on every
+ * side, which is exactly what makes a chart hard to grab — a background is
+ * caught by its border (`framework-background/hit-test.ts`), and that border
+ * was nowhere near the drawing.
+ *
+ * So each margin is now the reach of what it hosts, plus room to breathe:
+ *
+ * - `top` hosts the tip of the vertical arrowhead and nothing else — the tip IS
+ *   the top of the plot — so 4 units of gutter is the whole of it;
+ * - `right` hosts the tip of the horizontal arrowhead — which, like the top
+ *   one, IS the edge of the plot — and the right half of the "High" tick, which
+ *   is centred 1.02 % of the plot inside that end and reaches 3.3 units past it
+ *   in English. 8 covers the tick on a chart of the usual width; a locale whose
+ *   word is half again as wide overruns the edge by a few units on a narrow
+ *   chart, which paints fine (the surface clips nothing) and is the same thing
+ *   the arrowheads already do;
+ * - `bottom` hosts the horizontal axis title, whose baseline is 30 below the
+ *   axis (`dy: 30`), plus a descender the English wording happens not to have
+ *   (≈ 3.4 at 14px) and a gutter;
+ * - `left` hosts the rotated vertical title, written 32 left of the axis
+ *   (`dx: -32`); rotated, a word reaches into the margin by its ASCENT, not by
+ *   its length — ≈ 10.8 at 14px, more for an accented capital — hence 48.
+ *
+ * Nothing about the drawing changed: every ratio above is untouched, so the
+ * chart is the same chart. What changed is that the frame now sits on it.
+ */
+const CORE_DOMAIN_MARGIN = {
+    top: 4,
+    right: 8,
+    bottom: 37,
+    left: 48,
+};
+/**
+ * The birth size, chosen so that a NEW chart's plot is the 786 × 746 it has
+ * always been: the tighter margins take room off the element, not off the
+ * drawing. A chart created before this change keeps its `xywh` and sees its
+ * plot grow into the margins instead — the deliberate half of this fix.
+ */
+const BIRTH_WIDTH = PLOT.width + CORE_DOMAIN_MARGIN.left + CORE_DOMAIN_MARGIN.right;
+const BIRTH_HEIGHT = PLOT.height + CORE_DOMAIN_MARGIN.top + CORE_DOMAIN_MARGIN.bottom;
 export const CORE_DOMAIN_BACKGROUND = {
     type: 'coreDomain',
     // The chart is a first-class role: validation rules position artefacts
@@ -350,14 +423,14 @@ export const CORE_DOMAIN_BACKGROUND = {
     role: CORE_DOMAIN_ROLE.chart,
     variantProp: 'variant',
     geometry: {
-        width: 900,
-        height: 820,
+        width: BIRTH_WIDTH,
+        height: BIRTH_HEIGHT,
         lockAspectRatio: true,
         // The chart has always offered its handles (`resizeEnabled` defaults to
         // true on the model); the declaration says so, and the toolbar toggle takes
         // over from there.
         resizable: true,
-        margin: { top: 24, right: 54, bottom: 50, left: 60 },
+        margin: CORE_DOMAIN_MARGIN,
     },
     chrome: {
         fontFamily: FONT_FAMILY,

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

@@ -1,11 +1,20 @@
+import type { FrameworkBackgroundDef } from '@formicoidea/labre-core/blocks/surface';
+import { DeclaredBackgroundView } from '@formicoidea/labre-core/blocks/surface';
 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).
+ *
+ * Extends {@link DeclaredBackgroundView}, so every word the chart writes on
+ * itself — the two axis titles, the four Low/High ticks and the zone names of
+ * both readings — is renamed in place by a double-click, aimed by the very
+ * declaration the renderer paints (issue #355). The chart had no such gesture
+ * before, which is the whole of the bug: the labels were i18n keys and nothing
+ * else, so a team that calls its axis something else had nowhere to say so.
  */
-export declare class CoreDomainView extends GfxElementModelView<CoreDomainChartElementModel> {
+export declare class CoreDomainView extends DeclaredBackgroundView<CoreDomainChartElementModel> {
     static type: string;
+    protected get def(): FrameworkBackgroundDef;
 }
 /**
  * Resize gating, driven by the declaration: the handles are offered while

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

@@ -1,12 +1,21 @@
-import { FrameworkBackgroundInteractionExtension } from '@formicoidea/labre-core/blocks/surface';
-import { GfxElementModelView } from '@formicoidea/labre-core/std/gfx';
+import { DeclaredBackgroundView, FrameworkBackgroundInteractionExtension, } from '@formicoidea/labre-core/blocks/surface';
 import { CORE_DOMAIN_BACKGROUND } from './background.js';
 /**
  * View for the Core Domain Chart background. Registering it ensures
  * `gfx.view.get(model)` returns a view (required so move / select work).
+ *
+ * Extends {@link DeclaredBackgroundView}, so every word the chart writes on
+ * itself — the two axis titles, the four Low/High ticks and the zone names of
+ * both readings — is renamed in place by a double-click, aimed by the very
+ * declaration the renderer paints (issue #355). The chart had no such gesture
+ * before, which is the whole of the bug: the labels were i18n keys and nothing
+ * else, so a team that calls its axis something else had nowhere to say so.
  */
-export class CoreDomainView extends GfxElementModelView {
+export class CoreDomainView extends DeclaredBackgroundView {
     static { this.type = 'coreDomain'; }
+    get def() {
+        return CORE_DOMAIN_BACKGROUND;
+    }
 }
 /**
  * Resize gating, driven by the declaration: the handles are offered while

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

@@ -1 +1,22 @@
-export declare const coreDomainToolbarExtension: import("@formicoidea/labre-core/store").ExtensionType;
+import type { ToolbarModuleConfig } from '@formicoidea/labre-core/shared/services';
+/**
+ * The selected chart's FLAG-GATED row, whole: the legend button and the
+ * Validation dropdown, in one module.
+ *
+ * They cannot be two, and that is a hard constraint rather than a preference:
+ * `ToolbarModuleExtension` binds by DI variant, so a second module claiming
+ * `custom:affine:surface:coreDomain` throws `DuplicateServiceDefinitionError`
+ * before the editor finishes setting up. The C4 board's own row was merged this
+ * way first (`c4BoardToolingToolbarConfig`).
+ *
+ * The chart has no always-on row left at all: the legend was its only entry, and
+ * generating one is a gesture the `ddd-core-domain` flag may take away
+ * (`docs/adr/0026`) — while what the gesture already WROTE is document content,
+ * painted by the always-on renderers whatever the flag says. A stored chart with
+ * the flag off keeps its elements, its handles and its legend boxes; it simply
+ * offers no button.
+ *
+ * The rows themselves are derived from `coreDomainCommands` — this module writes
+ * no table.
+ */
+export declare const coreDomainChartToolingToolbarConfig: ToolbarModuleConfig;

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

@@ -1,39 +1,43 @@
-import { createAutoLegend, dddLegendIcon } from '@formicoidea/labre-ddd-shared';
+import { legendToolbarAction, validationToolbarConfig, } from '@formicoidea/labre-core/blocks/surface';
 import { CoreDomainChartElementModel } from '@formicoidea/labre-core/model';
-import { BOARD_LEGEND_NOTATION, TelemetryProvider, ToolbarModuleExtension, } from '@formicoidea/labre-core/shared/services';
-import { BlockFlavourIdentifier } from '@formicoidea/labre-core/std';
-import { CORE_DOMAIN_AUTO_LEGEND } from './legend.js';
-/** Contextual toolbar for a selected Core Domain background: insert its legend. */
-const coreDomainToolbarConfig = {
+/**
+ * The selected chart's FLAG-GATED row, whole: the legend button and the
+ * Validation dropdown, in one module.
+ *
+ * They cannot be two, and that is a hard constraint rather than a preference:
+ * `ToolbarModuleExtension` binds by DI variant, so a second module claiming
+ * `custom:affine:surface:coreDomain` throws `DuplicateServiceDefinitionError`
+ * before the editor finishes setting up. The C4 board's own row was merged this
+ * way first (`c4BoardToolingToolbarConfig`).
+ *
+ * The chart has no always-on row left at all: the legend was its only entry, and
+ * generating one is a gesture the `ddd-core-domain` flag may take away
+ * (`docs/adr/0026`) — while what the gesture already WROTE is document content,
+ * painted by the always-on renderers whatever the flag says. A stored chart with
+ * the flag off keeps its elements, its handles and its legend boxes; it simply
+ * offers no button.
+ *
+ * The rows themselves are derived from `coreDomainCommands` — this module writes
+ * no table.
+ */
+export const coreDomainChartToolingToolbarConfig = {
     actions: [
-        {
+        legendToolbarAction({
+            // FIRST in the row, as it has been since the chart's legend button
+            // shipped: the toolbar sorts lexicographically by id.
             id: 'a.legend',
-            tooltipWording: BOARD_LEGEND_NOTATION,
-            icon: dddLegendIcon,
-            run(ctx) {
-                const bg = ctx.getSurfaceModelsByType(CoreDomainChartElementModel)[0];
-                if (!bg)
-                    return;
-                createAutoLegend(ctx.std, bg, CORE_DOMAIN_AUTO_LEGEND);
-                ctx.std
-                    .getOptional(TelemetryProvider)
-                    ?.track('FrameworkLegendCreated', {
-                    // The WIRE value, which is not the module id: the framework is
-                    // `ddd-core-domain` in code and `core-domain` in PostHog
-                    // (`frameworks.ts` `telemetryKey`). Unchanged by this rework — the
-                    // button is the same gesture, it just detects by role now.
-                    framework: 'core-domain',
-                    element: 'legend',
-                    page: 'whiteboard editor',
-                    segment: 'element toolbar',
-                    module: 'core-domain toolbar',
-                });
-            },
-        },
+            Model: CoreDomainChartElementModel,
+            owner: 'ddd-core-domain',
+            // The WIRE value, which is not the module id: the framework is
+            // `ddd-core-domain` in code and `core-domain` in PostHog
+            // (`frameworks.ts` `telemetryKey`). Unchanged by the button becoming
+            // shared.
+            framework: 'core-domain',
+        }),
+        // The generic dropdown, not a Core Domain variant of it: the config names no
+        // framework — it reads the registered rules and profiles — so this is the
+        // very same object c4, wardley and bpmn register.
+        ...validationToolbarConfig.actions,
     ],
-    when: ctx => ctx.getSurfaceModelsByType(CoreDomainChartElementModel).length > 0,
+    when: (ctx) => ctx.getSurfaceModelsByType(CoreDomainChartElementModel).length > 0,
 };
-export const coreDomainToolbarExtension = ToolbarModuleExtension({
-    id: BlockFlavourIdentifier('affine:surface:coreDomain'),
-    config: coreDomainToolbarConfig,
-});

package/dist/toolbar/palette.d.ts

@@ -0,0 +1,31 @@
+import type { FrameworkPalette, NamedPalette } from '@formicoidea/labre-core/components/color-picker';
+import type { ChromeWording } from '@formicoidea/labre-core/shared/services';
+/**
+ * The Core Domain Chart swatches' own names, resolved by `resolvePaletteLabel`
+ * (`@labre/affine-components/color-picker`) through each swatch's own
+ * {@link NamedPalette.labelWording} — the mechanism `WARDLEY_PALETTE_WORDINGS`
+ * established, reused here without either package naming the other.
+ *
+ * Exported so `../translations.ts` can list them under source `chrome`: a
+ * swatch's name is toolbar chrome, never seeded into a document. The keys are
+ * this framework's own even though the colours come from `ddd-shared`, which
+ * declares no `com.labre.*` key of its own by design (see its header).
+ */
+export declare const CORE_DOMAIN_PALETTE_WORDING_BIG_BET: ChromeWording;
+export declare const CORE_DOMAIN_PALETTE_WORDING_PLATFORM: ChromeWording;
+export declare const CORE_DOMAIN_PALETTE_WORDING_OUTSOURCED: ChromeWording;
+export declare const CORE_DOMAIN_PALETTE_WORDING_BC_CURRENT: ChromeWording;
+export declare const CORE_DOMAIN_PALETTE_WORDING_BC_FUTURE: ChromeWording;
+export declare const CORE_DOMAIN_PALETTE_WORDINGS: readonly ChromeWording[];
+/**
+ * From the default editor palette we keep ONLY the neutrals — the historical
+ * colours say nothing in this notation.
+ */
+export declare const CORE_DOMAIN_PALETTE_LIST: NamedPalette[];
+/**
+ * The Core Domain Chart's page of the colour pickers' carousel
+ * (`docs/adr/0027`). Registered from the FLAG-GATED view extension, because
+ * offering hues is TOOLING: a chart drawn while the flag was on keeps every
+ * colour it was painted with when the flag goes off (`docs/adr/0009`).
+ */
+export declare const CORE_DOMAIN_FRAMEWORK_PALETTE: FrameworkPalette;

package/dist/toolbar/palette.js

@@ -0,0 +1,104 @@
+import { CD_SUBDOMAINS } from '@formicoidea/labre-ddd-shared';
+import { neutralPalettes } from '@formicoidea/labre-core/gfx/shape';
+/**
+ * The Core Domain Chart swatches' own names, resolved by `resolvePaletteLabel`
+ * (`@labre/affine-components/color-picker`) through each swatch's own
+ * {@link NamedPalette.labelWording} — the mechanism `WARDLEY_PALETTE_WORDINGS`
+ * established, reused here without either package naming the other.
+ *
+ * Exported so `../translations.ts` can list them under source `chrome`: a
+ * swatch's name is toolbar chrome, never seeded into a document. The keys are
+ * this framework's own even though the colours come from `ddd-shared`, which
+ * declares no `com.labre.*` key of its own by design (see its header).
+ */
+export const CORE_DOMAIN_PALETTE_WORDING_BIG_BET = [
+    'com.labre.ddd-core-domain.palette.big-bet-purple',
+    'Big-bet purple',
+];
+export const CORE_DOMAIN_PALETTE_WORDING_PLATFORM = [
+    'com.labre.ddd-core-domain.palette.platform-blue',
+    'Platform blue',
+];
+export const CORE_DOMAIN_PALETTE_WORDING_OUTSOURCED = [
+    'com.labre.ddd-core-domain.palette.outsourced-green',
+    'Outsourced green',
+];
+export const CORE_DOMAIN_PALETTE_WORDING_BC_CURRENT = [
+    'com.labre.ddd-core-domain.palette.bounded-context-red',
+    'Bounded context red',
+];
+export const CORE_DOMAIN_PALETTE_WORDING_BC_FUTURE = [
+    'com.labre.ddd-core-domain.palette.future-position-grey',
+    'Future position grey',
+];
+export const CORE_DOMAIN_PALETTE_WORDINGS = [
+    CORE_DOMAIN_PALETTE_WORDING_BIG_BET,
+    CORE_DOMAIN_PALETTE_WORDING_PLATFORM,
+    CORE_DOMAIN_PALETTE_WORDING_OUTSOURCED,
+    CORE_DOMAIN_PALETTE_WORDING_BC_CURRENT,
+    CORE_DOMAIN_PALETTE_WORDING_BC_FUTURE,
+];
+/**
+ * The sub-domain / bounded-context dot fills, by kind — derived from
+ * {@link CD_SUBDOMAINS} rather than restated.
+ */
+const CD_FILL = Object.fromEntries(CD_SUBDOMAINS.map(subdomain => [subdomain.kind, subdomain.fill]));
+/**
+ * The Core Domain Chart's own five hues: the three sub-domain classes
+ * (big-bet, platform, outsourced), the bounded context as it stands today, and
+ * the grey it is plotted in where it is meant to go next.
+ *
+ * The movement arrow between those last two is drawn in `MOVEMENT_COLOR`,
+ * which IS the current bounded context's red — one statement in one colour —
+ * so it contributes no sixth swatch. `__tests__/palette.unit.spec.ts` pins the
+ * two together, so the day they part the shelf gains its swatch.
+ *
+ * They are SHORTCUTS, never constraints: a dot's class is written in its role,
+ * not read off its fill.
+ */
+const CORE_DOMAIN_PALETTES = [
+    {
+        key: 'Big-bet purple',
+        value: CD_FILL.bigBet,
+        labelWording: CORE_DOMAIN_PALETTE_WORDING_BIG_BET,
+    },
+    {
+        key: 'Platform blue',
+        value: CD_FILL.platform,
+        labelWording: CORE_DOMAIN_PALETTE_WORDING_PLATFORM,
+    },
+    {
+        key: 'Outsourced green',
+        value: CD_FILL.outsourced,
+        labelWording: CORE_DOMAIN_PALETTE_WORDING_OUTSOURCED,
+    },
+    {
+        key: 'Bounded context red',
+        value: CD_FILL.bcCurrent,
+        labelWording: CORE_DOMAIN_PALETTE_WORDING_BC_CURRENT,
+    },
+    {
+        key: 'Future position grey',
+        value: CD_FILL.bcFuture,
+        labelWording: CORE_DOMAIN_PALETTE_WORDING_BC_FUTURE,
+    },
+];
+/**
+ * From the default editor palette we keep ONLY the neutrals — the historical
+ * colours say nothing in this notation.
+ */
+export const CORE_DOMAIN_PALETTE_LIST = [
+    ...CORE_DOMAIN_PALETTES,
+    ...neutralPalettes(),
+];
+/**
+ * The Core Domain Chart's page of the colour pickers' carousel
+ * (`docs/adr/0027`). Registered from the FLAG-GATED view extension, because
+ * offering hues is TOOLING: a chart drawn while the flag was on keeps every
+ * colour it was painted with when the flag goes off (`docs/adr/0009`).
+ */
+export const CORE_DOMAIN_FRAMEWORK_PALETTE = {
+    framework: 'ddd-core-domain',
+    labelWording: ['com.labre.framework.ddd-core-domain', 'Core Domain Chart'],
+    palettes: CORE_DOMAIN_PALETTE_LIST,
+};

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

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

package/dist/toolbar/senior-button.js

@@ -6,5 +6,6 @@ export class EdgelessDddCoreDomainSeniorButton extends DddSeniorButtonBase {
         this.label = 'Core Domain Chart';
         this.labelKey = 'com.labre.framework.ddd-core-domain';
         this.icon = coreDomainToolbarIcon;
+        this.owner = 'ddd-core-domain';
     }
 }

package/dist/translations.d.ts

@@ -1,15 +1,4 @@
-import type { ChromeWording } from '@formicoidea/labre-core/shared/services';
 import { type TranslationKeyManifestEntry } from '@formicoidea/labre-core/std';
-/**
- * The automatic legend's own section titles (`core-domain/legend.ts`) — text
- * stamped onto the chart the moment the legend is built
- * (`createAutoLegend`), like any other seed. The box title itself is NOT
- * here: it says the shared word "Legend", so it reuses `BOARD_LEGEND_TITLE`
- * (`@labre/affine-shared/services`) instead of a key of its own.
- */
-export declare const CORE_DOMAIN_SEED_LEGEND_SUBDOMAINS: ChromeWording;
-export declare const CORE_DOMAIN_SEED_LEGEND_TEAM_MODES: ChromeWording;
-export declare const CORE_DOMAIN_SEED_LEGEND_MOVEMENT: ChromeWording;
 /**
  * THIS framework's contribution to the translation-key manifest — every
  * `com.labre.*` key the Core Domain Chart can hand to `TranslationProvider.t`,

package/dist/translations.js

@@ -1,31 +1,13 @@
 import { dddSharedTranslationEntries } from '@formicoidea/labre-ddd-shared';
 import { collectTranslationKeys, commandCategoryTranslationEntries, commandTranslationEntries, mergeTranslationEntries, } from '@formicoidea/labre-core/std';
-import { coreDomainCommands } from './commands.js';
+import { CORE_DOMAIN_SEED_LEGEND_MOVEMENT, CORE_DOMAIN_SEED_LEGEND_SUBDOMAINS, CORE_DOMAIN_SEED_LEGEND_TEAM_MODES, coreDomainCommands, } from './commands.js';
 import { CORE_DOMAIN_BACKGROUND } from './core-domain/background.js';
 import { CORE_DOMAIN_NUDGES } from './nudges.js';
 import { CORE_DOMAIN_PROFILES } from './profiles.js';
 import { CORE_DOMAIN_READINGS } from './reading.js';
 import { CORE_DOMAIN_ROLES } from './roles.js';
 import { CORE_DOMAIN_RULES } from './rules.js';
-/**
- * The automatic legend's own section titles (`core-domain/legend.ts`) — text
- * stamped onto the chart the moment the legend is built
- * (`createAutoLegend`), like any other seed. The box title itself is NOT
- * here: it says the shared word "Legend", so it reuses `BOARD_LEGEND_TITLE`
- * (`@labre/affine-shared/services`) instead of a key of its own.
- */
-export const CORE_DOMAIN_SEED_LEGEND_SUBDOMAINS = [
-    'com.labre.ddd-core-domain.seed.legend-subdomains',
-    'Sub-domains',
-];
-export const CORE_DOMAIN_SEED_LEGEND_TEAM_MODES = [
-    'com.labre.ddd-core-domain.seed.legend-team-modes',
-    'Team interaction modes',
-];
-export const CORE_DOMAIN_SEED_LEGEND_MOVEMENT = [
-    'com.labre.ddd-core-domain.seed.legend-movement',
-    'Movement',
-];
+import { CORE_DOMAIN_PALETTE_WORDINGS } from './toolbar/palette.js';
 /**
  * THIS framework's contribution to the translation-key manifest — every
  * `com.labre.*` key the Core Domain Chart can hand to `TranslationProvider.t`,
@@ -58,4 +40,12 @@ dddSharedTranslationEntries, [
     CORE_DOMAIN_SEED_LEGEND_SUBDOMAINS,
     CORE_DOMAIN_SEED_LEGEND_TEAM_MODES,
     CORE_DOMAIN_SEED_LEGEND_MOVEMENT,
-].map(([key, fallback]) => ({ key, fallback, source: 'seed' })));
+].map(([key, fallback]) => ({ key, fallback, source: 'seed' })), 
+// The carousel swatches' own names (`toolbar/palette.ts`) — chrome,
+// re-rendered by the colour picker on every locale switch, never seeded
+// into a document. Same treatment as Wardley's and EDGY's.
+CORE_DOMAIN_PALETTE_WORDINGS.map(([key, fallback]) => ({
+    key,
+    fallback,
+    source: 'chrome',
+})));

package/dist/view.d.ts

@@ -1,10 +1,13 @@
 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
+ * Disabling `ddd-core-domain` hides only the tooling (see
  * {@link DddCoreDomainViewExtension}); placed `coreDomain` elements must still
- * paint, stay selectable, and keep their contextual toolbar, and Templates-
- * panel insertion must still render them.
+ * paint, stay selectable and stay movable, and Templates-panel insertion must
+ * still render them.
+ *
+ * The chart claims no always-on toolbar module: the legend button was its only
+ * contextual entry and it moved to the gated half (`docs/adr/0026`).
  */
 export declare class DddCoreDomainRenderViewExtension extends ViewExtensionProvider {
     name: string;