@formicoidea/labre-framework-ddd-core-domain 0.31.0 → 0.33.0

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

@@ -7,5 +7,10 @@ import { GfxElementModelView } from '@formicoidea/labre-core/std/gfx';
 export declare class CoreDomainView extends GfxElementModelView<CoreDomainChartElementModel> {
     static type: string;
 }
-/** Resize gating: handles hidden unless `model.resizeEnabled` (toolbar toggle). */
+/**
+ * Resize gating, driven by the declaration: the handles are offered while
+ * `model.resizeEnabled` says so (the toolbar toggle), and an element carrying no
+ * such prop falls back to `geometry.resizable` — the same behaviour the
+ * hand-written extension had, minus the hand.
+ */
 export declare const CoreDomainInteraction: import("@formicoidea/labre-core/store").ExtensionType;

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

@@ -1,4 +1,6 @@
-import { GfxElementModelView, GfxViewInteractionExtension, } from '@formicoidea/labre-core/std/gfx';
+import { FrameworkBackgroundInteractionExtension } from '@formicoidea/labre-core/blocks/surface';
+import { GfxElementModelView } from '@formicoidea/labre-core/std/gfx';
+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).
@@ -6,15 +8,10 @@ import { GfxElementModelView, GfxViewInteractionExtension, } from '@formicoidea/
 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: [] });
-                }
-            },
-        };
-    },
-});
+/**
+ * Resize gating, driven by the declaration: the handles are offered while
+ * `model.resizeEnabled` says so (the toolbar toggle), and an element carrying no
+ * such prop falls back to `geometry.resizable` — the same behaviour the
+ * hand-written extension had, minus the hand.
+ */
+export const CoreDomainInteraction = FrameworkBackgroundInteractionExtension(CORE_DOMAIN_BACKGROUND);

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

@@ -1,18 +1,29 @@
-import { type LegendSection } from '@formicoidea/labre-ddd-shared';
-import { type CoreDomainChartElementModel } from '@formicoidea/labre-core/model';
-import type { BlockStdScope } from '@formicoidea/labre-core/std';
+import { type AutoLegendSpec } from '@formicoidea/labre-ddd-shared';
 /**
- * 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.
+ * What the Core Domain Chart's automatic legend can say — a TABLE, and nothing
+ * else: the scan, the placement and the box are `createAutoLegend`'s job.
+ *
+ * Every row is DERIVED from the presets the palette draws its dots with
+ * ({@link CD_SUBDOMAINS}) and from the role vocabulary's own labels, never
+ * restated — which also keeps this table and `core-domain.off-legend-colour`
+ * naming the same five colours by construction.
+ *
+ * ## What changed
+ *
+ * The chart's legend button predates roles: until now it scanned the perimeter
+ * for FILL COLOURS, which is why it fell back to the full notation when it
+ * recognised nothing. Detection is now by role, like every other reader of the
+ * board, with one consequence worth stating: a chart on which nothing is
+ * recognised yields a legend box with a title and no rows, rather than the whole
+ * notation. That is Wardley's behaviour and the honest one — a legend lists what
+ * is drawn, not what could have been.
+ *
+ * The **Team Topologies markers** were the casualty of that change for one
+ * release: `addMarker` stamped no role, so a chart covered in them produced a
+ * legend that mentioned none (PO recette, 26/08/2026). They now carry
+ * `core-domain:marker-*` and their section is here, derived from
+ * `TEAM_TOPOLOGIES` like everything else — swatch, letter and colour from the
+ * preset the palette draws with, wording from the vocabulary that names the
+ * role.
  */
-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;
+export declare const CORE_DOMAIN_AUTO_LEGEND: AutoLegendSpec;

package/dist/core-domain/legend.js

@@ -1,68 +1,78 @@
-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';
+import { CD_SUBDOMAINS, MOVEMENT_COLOR, roleLabel, TEAM_TOPOLOGIES, } from '@formicoidea/labre-ddd-shared';
+import { CORE_DOMAIN_ROLE, CORE_DOMAIN_ROLES } from '../roles.js';
 /**
- * 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.
+ * What the Core Domain Chart's automatic legend can say — a TABLE, and nothing
+ * else: the scan, the placement and the box are `createAutoLegend`'s job.
+ *
+ * Every row is DERIVED from the presets the palette draws its dots with
+ * ({@link CD_SUBDOMAINS}) and from the role vocabulary's own labels, never
+ * restated — which also keeps this table and `core-domain.off-legend-colour`
+ * naming the same five colours by construction.
+ *
+ * ## What changed
+ *
+ * The chart's legend button predates roles: until now it scanned the perimeter
+ * for FILL COLOURS, which is why it fell back to the full notation when it
+ * recognised nothing. Detection is now by role, like every other reader of the
+ * board, with one consequence worth stating: a chart on which nothing is
+ * recognised yields a legend box with a title and no rows, rather than the whole
+ * notation. That is Wardley's behaviour and the honest one — a legend lists what
+ * is drawn, not what could have been.
+ *
+ * The **Team Topologies markers** were the casualty of that change for one
+ * release: `addMarker` stamped no role, so a chart covered in them produced a
+ * legend that mentioned none (PO recette, 26/08/2026). They now carry
+ * `core-domain:marker-*` and their section is here, derived from
+ * `TEAM_TOPOLOGIES` like everything else — swatch, letter and colour from the
+ * preset the palette draws with, wording from the vocabulary that names the
+ * role.
  */
-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({
+export const CORE_DOMAIN_AUTO_LEGEND = {
+    title: 'Legend',
+    roles: CORE_DOMAIN_ROLES,
+    sections: [
+        {
+            title: 'Sub-domains',
+            entries: CD_SUBDOMAINS.map(preset => ({
+                role: CORE_DOMAIN_ROLE[preset.kind],
+                row: {
+                    swatch: 'dot',
+                    color: preset.fill,
+                    label: preset.label,
+                },
+            })),
+        },
+        {
+            // The letter is what identifies a marker on the chart — the squares are
+            // three colours a reader has no key to — so the legend shows the same
+            // square with the same letter in it, which is what `LegendRow.letter`
+            // exists for.
+            title: 'Team interaction modes',
+            entries: TEAM_TOPOLOGIES.map(preset => ({
+                role: CORE_DOMAIN_ROLE[preset.kind],
+                row: {
+                    swatch: 'square',
+                    color: preset.fill,
+                    letter: preset.letter,
+                    label: roleLabel(CORE_DOMAIN_ROLES, CORE_DOMAIN_ROLE[preset.kind]),
+                },
+            })),
+        },
+        {
             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 }),
-    });
-}
+            entries: [
+                {
+                    role: CORE_DOMAIN_ROLE.movement,
+                    row: {
+                        swatch: 'line',
+                        // The style `activateMovement` arms the connector tool with: a red
+                        // dashed line.
+                        color: MOVEMENT_COLOR,
+                        dashed: true,
+                        label: roleLabel(CORE_DOMAIN_ROLES, CORE_DOMAIN_ROLE.movement),
+                    },
+                },
+            ],
+        },
+    ],
+};

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

@@ -1,33 +1,27 @@
+import { createAutoLegend, dddLegendIcon } from '@formicoidea/labre-ddd-shared';
 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.js';
-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>`;
+import { CORE_DOMAIN_AUTO_LEGEND } from './legend.js';
 /** 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,
+            tooltip: 'Generate the legend (notation present)',
+            icon: dddLegendIcon,
             run(ctx) {
                 const bg = ctx.getSurfaceModelsByType(CoreDomainChartElementModel)[0];
                 if (!bg)
                     return;
-                createCoreDomainLegend(ctx.std, bg);
-                ctx.std.getOptional(TelemetryProvider)?.track('FrameworkLegendCreated', {
+                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',

package/dist/descriptor.d.ts

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

package/dist/descriptor.js

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

package/dist/index.d.ts

@@ -1,4 +1,12 @@
+export { activateMovement, createCoreDomainChart } from './actions.js';
+export { coreDomainCommandIcons, coreDomainCommands } from './commands.js';
+export { coreDomainTranslationEntries } from './translations.js';
+export { CORE_DOMAIN_BACKGROUND, CORE_DOMAIN_LEGEND_TONES, } from './core-domain/background.js';
 export { coreDomain } from './core-domain/element-renderer.js';
+export { CORE_DOMAIN_NUDGES } from './nudges.js';
+export { CORE_DOMAIN_PROFILES } from './profiles.js';
+export { CORE_DOMAIN_ROLE, CORE_DOMAIN_ROLES, type CoreDomainRole, type CoreDomainRoleId, subdomainRole, } from './roles.js';
+export { CORE_DOMAIN_RULES } from './rules.js';
 export { coreDomainTemplateCategory } from './templates.js';
 export { coreDomainSeniorTool } from './toolbar/senior-tool.js';
 export { EdgelessDddCoreDomainSeniorButton } from './toolbar/senior-button.js';

package/dist/index.js

@@ -1,4 +1,12 @@
+export { activateMovement, createCoreDomainChart } from './actions.js';
+export { coreDomainCommandIcons, coreDomainCommands } from './commands.js';
+export { coreDomainTranslationEntries } from './translations.js';
+export { CORE_DOMAIN_BACKGROUND, CORE_DOMAIN_LEGEND_TONES, } from './core-domain/background.js';
 export { coreDomain } from './core-domain/element-renderer.js';
+export { CORE_DOMAIN_NUDGES } from './nudges.js';
+export { CORE_DOMAIN_PROFILES } from './profiles.js';
+export { CORE_DOMAIN_ROLE, CORE_DOMAIN_ROLES, subdomainRole, } from './roles.js';
+export { CORE_DOMAIN_RULES } from './rules.js';
 export { coreDomainTemplateCategory } from './templates.js';
 export { coreDomainSeniorTool } from './toolbar/senior-tool.js';
 export { EdgelessDddCoreDomainSeniorButton } from './toolbar/senior-button.js';

package/dist/nudges.d.ts

@@ -0,0 +1,21 @@
+import type { QualityNudge } from '@formicoidea/labre-core/blocks/surface';
+/**
+ * Core Domain Chart **work quality** — the checklist.
+ *
+ * Level 1 is `./rules.ts`: deterministic, decidable, real time. This file is
+ * level 2, and the split is the whole point of the taxonomy — a rule only enters
+ * the deterministic engine if an algorithm can decide it on persisted data
+ * inside the ~16 ms budget. Everything else is a NUDGE: an expectation offered
+ * as a checklist, never evaluated, never blocking anything. Ticking is assuming.
+ *
+ * All three below are about whether the chart can be DISCUSSED, and no
+ * algorithm can check a single one of them. Whether a movement is justified is
+ * a statement about an argument; whether the core was agreed is a statement
+ * about a room. A rule claiming to have verified either would be lying.
+ *
+ * Registered from the flag-gated `DddCoreDomainViewExtension`, beside the rules
+ * and the profiles: a checklist is tooling. Switching the flag off takes it away
+ * and leaves the ticks written on the chart, unread, until it comes back
+ * (PF7.10).
+ */
+export declare const CORE_DOMAIN_NUDGES: readonly QualityNudge[];

package/dist/nudges.js

@@ -0,0 +1,42 @@
+/**
+ * Core Domain Chart **work quality** — the checklist.
+ *
+ * Level 1 is `./rules.ts`: deterministic, decidable, real time. This file is
+ * level 2, and the split is the whole point of the taxonomy — a rule only enters
+ * the deterministic engine if an algorithm can decide it on persisted data
+ * inside the ~16 ms budget. Everything else is a NUDGE: an expectation offered
+ * as a checklist, never evaluated, never blocking anything. Ticking is assuming.
+ *
+ * All three below are about whether the chart can be DISCUSSED, and no
+ * algorithm can check a single one of them. Whether a movement is justified is
+ * a statement about an argument; whether the core was agreed is a statement
+ * about a room. A rule claiming to have verified either would be lying.
+ *
+ * Registered from the flag-gated `DddCoreDomainViewExtension`, beside the rules
+ * and the profiles: a checklist is tooling. Switching the flag off takes it away
+ * and leaves the ticks written on the chart, unread, until it comes back
+ * (PF7.10).
+ */
+export const CORE_DOMAIN_NUDGES = [
+    {
+        id: 'core-domain.q1-legend',
+        framework: 'core-domain',
+        labelKey: 'com.labre.core-domain.quality.legend',
+        fallback: 'The chart has a legend.',
+        order: 1,
+    },
+    {
+        id: 'core-domain.q2-movements',
+        framework: 'core-domain',
+        labelKey: 'com.labre.core-domain.quality.movements',
+        fallback: 'Movements are dated and justified.',
+        order: 2,
+    },
+    {
+        id: 'core-domain.q3-core-agreed',
+        framework: 'core-domain',
+        labelKey: 'com.labre.core-domain.quality.core-agreed',
+        fallback: 'The core has been agreed by the team.',
+        order: 3,
+    },
+];

package/dist/profiles.d.ts

@@ -0,0 +1,2 @@
+import type { ValidationProfile } from '@formicoidea/labre-core/blocks/surface';
+export declare const CORE_DOMAIN_PROFILES: readonly ValidationProfile[];

package/dist/profiles.js

@@ -0,0 +1,68 @@
+/**
+ * Core Domain Chart validation profiles (PF9).
+ *
+ * DATA owned by the framework, like its rules, its roles and its background:
+ * the engine knows how to APPLY a profile, never which ones this framework has.
+ *
+ * A profile is chosen per CHART, not per document (PF9.1) — a rough sketch and
+ * a chart that goes in front of a steering committee coexist on the same canvas
+ * with different requirements, and the choice rides on the background element
+ * itself.
+ *
+ * Registered from the flag-gated `DddCoreDomainViewExtension`, beside the
+ * rules: switching the flag off takes the choice away with the rest of the
+ * tooling, and a chart already set to `strict` simply stops being checked until
+ * it comes back — the id stays written, untouched.
+ */
+/**
+ * Sketch: every rule demoted to `audit`, so findings still reach `violations$`
+ * — a host panel and a conformance report see them — and the canvas says
+ * nothing at all.
+ *
+ * The DEFAULT, and deliberately so: the sketch wins (PRD principle 3). A Core
+ * Domain Chart is drawn in a workshop, in front of people, by dragging dots
+ * around until the room agrees; a tool badging a dot that has been in the core
+ * for eleven seconds is a tool the room switches off. Being the default also
+ * means it is the one profile that WRITES NOTHING: a chart on `sketch` carries
+ * no profile key, so every chart ever drawn is on it, with no migration and no
+ * backfill.
+ */
+const sketch = {
+    id: 'core-domain.sketch',
+    framework: 'core-domain',
+    labelKey: 'com.labre.core-domain.profile.sketch',
+    fallback: 'Sketch',
+    isDefault: true,
+    rules: {
+        'core-domain.outsourced-core': 'audit',
+        'core-domain.malformed-movement': 'audit',
+        'core-domain.overlapping-artefacts': 'audit',
+        'core-domain.off-legend-colour': 'audit',
+    },
+};
+/**
+ * Strict: the deliverable level. Every severity a user gets is spelled out here
+ * rather than left absent — PF9.4 wants the answer readable in one place.
+ *
+ * C4 stays `audit` even here, and that is the one deliberate asymmetry: the
+ * colour of a dot is a NOTATION question, answered when the chart is read back
+ * rather than while it is drawn, and the honest place for it is the conformance
+ * report the audit level already feeds. Promoting it would put a badge on a dot
+ * whose only sin is a shade.
+ */
+const strict = {
+    id: 'core-domain.strict',
+    framework: 'core-domain',
+    labelKey: 'com.labre.core-domain.profile.strict',
+    fallback: 'Strict',
+    rules: {
+        'core-domain.outsourced-core': 'warning',
+        'core-domain.malformed-movement': 'warning',
+        'core-domain.overlapping-artefacts': 'warning',
+        'core-domain.off-legend-colour': 'audit',
+    },
+};
+export const CORE_DOMAIN_PROFILES = [
+    sketch,
+    strict,
+];

package/dist/roles.d.ts

@@ -0,0 +1,66 @@
+import { CD_SUBDOMAINS, TEAM_TOPOLOGIES } from '@formicoidea/labre-ddd-shared';
+import type { RoleDefs, RoleId } from '@formicoidea/labre-core/std/gfx';
+/**
+ * The five dot presets' own `kind`, read off the shared table rather than
+ * restated: a preset added there without a role here is a compile error.
+ */
+export type CdSubdomainKind = (typeof CD_SUBDOMAINS)[number]['kind'];
+/** The three Team Topologies marker kinds, read off their table the same way. */
+export type CdMarkerKind = (typeof TEAM_TOPOLOGIES)[number]['kind'];
+/**
+ * Core Domain Chart role vocabulary.
+ *
+ * Roles are the semantic identity of a chart artefact — no rule will ever look
+ * at a shape type. They mirror the presets the user already picks in the
+ * sub-menu — the five dots ({@link CD_SUBDOMAINS}) and the three Team
+ * Topologies markers ({@link TEAM_TOPOLOGIES}) — plus the chart itself and the
+ * typed MOVEMENT edge.
+ *
+ * Hierarchy is DATA (`parent`), never TS inheritance: the five dots specialise
+ * `core-domain:subdomain`, so a rule written on the parent covers all five for
+ * free (see `roleIsA`), and a rule written on `-outsourced` touches that one
+ * alone. The three markers form a SECOND family under `core-domain:marker`,
+ * deliberately disjoint from the first: they annotate the chart, they are not
+ * plotted on it, and no rule written on sub-domains must ever fall on one.
+ *
+ * ## No backfill, ever
+ *
+ * These values are written by the creation sites from today on. A chart drawn
+ * before they existed carries dots with no role at all, and an element with no
+ * role is never evaluated (proportionality, PRD principle 8) — so an old
+ * document opens exactly as it always did and raises nothing. Same promise every
+ * other framework's vocabulary made (#71).
+ *
+ * The vocabulary is registered from the ALWAYS-ON render extension
+ * (`docs/adr/0009`): a role is written in the document, not in the tooling, and
+ * what reads it back — the direction reveal of a typed edge, the inversion
+ * command — has to keep working on a chart drawn while the flag was on and
+ * opened while it is off.
+ */
+/** Every role this framework declares. */
+export type CoreDomainRole = 'chart' | 'subdomain' | 'subdomain-big-bet' | 'subdomain-platform' | 'subdomain-outsourced' | 'bc-current' | 'bc-future' | 'marker' | 'marker-collaboration' | 'marker-xaas' | 'marker-facilitating' | 'movement';
+export type CoreDomainRoleId = `core-domain:${CoreDomainRole}`;
+/**
+ * Role ids, keyed by the `kind` the creation sites use — camelCased, exactly
+ * like `CD_SUBDOMAINS[].kind`, so `commands.ts` can hand a preset's own kind
+ * straight to this table.
+ */
+export declare const CORE_DOMAIN_ROLE: {
+    readonly chart: "core-domain:chart";
+    readonly subdomain: "core-domain:subdomain";
+    readonly bigBet: "core-domain:subdomain-big-bet";
+    readonly platform: "core-domain:subdomain-platform";
+    readonly outsourced: "core-domain:subdomain-outsourced";
+    readonly bcCurrent: "core-domain:bc-current";
+    readonly bcFuture: "core-domain:bc-future";
+    readonly marker: "core-domain:marker";
+    readonly collaboration: "core-domain:marker-collaboration";
+    readonly xaas: "core-domain:marker-xaas";
+    readonly facilitating: "core-domain:marker-facilitating";
+    readonly movement: "core-domain:movement";
+};
+/** The role of one of the five dot presets. */
+export declare function subdomainRole(kind: CdSubdomainKind): RoleId;
+/** The role of one of the three Team Topologies markers. */
+export declare function markerRole(kind: CdMarkerKind): RoleId;
+export declare const CORE_DOMAIN_ROLES: RoleDefs;