@formicoidea/labre-framework-ddd-context-map 0.31.0 → 0.33.0

package/dist/actions.d.ts

@@ -0,0 +1,38 @@
+import type { GfxController } from '@formicoidea/labre-core/std/gfx';
+import { type ContextMapPatternKind } from './roles.js';
+/** Create the board at the viewport centre, select it, return to the default tool. */
+export declare function createContextMapBoard(gfx: GfxController): void;
+/**
+ * Activate the native connector tool, pre-styled and TYPED for one Context Map
+ * pattern. The user then drags from one bounded context to another and the
+ * endpoints attach.
+ *
+ * ## Why this replaces the old palette entry
+ *
+ * Until WS2 each pattern entry dropped a free-floating GROUP at the viewport
+ * centre: a connector between two points in mid-air, an abbreviation tag and,
+ * for the U/D patterns, two letters. It looked like the notation and said
+ * nothing — the link was attached to nothing, so no rule could read its ends,
+ * and the user still had to drag both endpoints onto the contexts by hand.
+ *
+ * The gesture now IS the statement (`docs/adr/0010`): the tool announces which
+ * way to drag (the role's `gestureHint`), the drawn connector carries the
+ * pattern's role, and the endpoints are real element references — which is what
+ * makes the whole of `rules.ts` possible.
+ *
+ * ## What the style says, and what the role says
+ *
+ * Style is presentation: `dashed` for the two "no real integration" patterns
+ * (Separate Ways, Big Ball of Mud), a rear arrowhead for the five U/D ones so
+ * the sheet still reads at a glance. Meaning is the role, and only the role: a
+ * user restyling a link never changes what it means, and a link drawn before
+ * WS2 keeps its old look and stays neutral.
+ *
+ * The abbreviation TAG is not drawn any more. A label riding on the connector is
+ * `ConnectorToolOptions.label`, which was cut from v1 — the pattern reads from
+ * the hover reveal (M2) and the toolbar until it lands.
+ */
+export declare function activateContextMapRelationship(gfx: GfxController, kind: ContextMapPatternKind, style: {
+    upDown: boolean;
+    dashed: boolean;
+}): void;

package/dist/actions.js

@@ -0,0 +1,84 @@
+import { backgroundSize, DefaultTool } from '@formicoidea/labre-core/blocks/surface';
+import { ConnectorTool } from '@formicoidea/labre-core/gfx/connector';
+import { LABEL_COLOR } from '@formicoidea/labre-ddd-shared';
+import { ConnectorMode, PointStyle, StrokeStyle } from '@formicoidea/labre-core/model';
+import { Bound } from '@formicoidea/labre-core/global/gfx';
+import { CONTEXT_MAP_BACKGROUND } from './background.js';
+import { CM_PATTERN_ROLE } from './roles.js';
+/**
+ * Creation / activation actions for the Context Map toolbox — the BEHAVIOUR
+ * layer, depending on nothing but the {@link GfxController}.
+ *
+ * They emit no telemetry: since PF3 the single emission point is the command
+ * registry's `runCommand` (`docs/adr/0008`).
+ */
+const RELATIONSHIP_STROKE_WIDTH = 2;
+/** Create the board at the viewport centre, select it, return to the default tool. */
+export function createContextMapBoard(gfx) {
+    if (!gfx.surface)
+        return;
+    const { width, height } = backgroundSize(CONTEXT_MAP_BACKGROUND);
+    const { centerX, centerY } = gfx.viewport;
+    const id = gfx.surface.addElement({
+        type: CONTEXT_MAP_BACKGROUND.type,
+        // The board is a first-class role: rules frame contexts against
+        // `context-map:board`, never against the `contextMap` element type. The
+        // declaration owns it, so a templated board and a hand-drawn one agree.
+        role: CONTEXT_MAP_BACKGROUND.role,
+        resizeEnabled: CONTEXT_MAP_BACKGROUND.geometry.resizable,
+        xywh: new Bound(centerX - width / 2, centerY - height / 2, width, height).serialize(),
+    });
+    gfx.doc.captureSync();
+    gfx.tool.setTool(DefaultTool);
+    gfx.selection.set({ elements: [id], editing: false });
+}
+/**
+ * Activate the native connector tool, pre-styled and TYPED for one Context Map
+ * pattern. The user then drags from one bounded context to another and the
+ * endpoints attach.
+ *
+ * ## Why this replaces the old palette entry
+ *
+ * Until WS2 each pattern entry dropped a free-floating GROUP at the viewport
+ * centre: a connector between two points in mid-air, an abbreviation tag and,
+ * for the U/D patterns, two letters. It looked like the notation and said
+ * nothing — the link was attached to nothing, so no rule could read its ends,
+ * and the user still had to drag both endpoints onto the contexts by hand.
+ *
+ * The gesture now IS the statement (`docs/adr/0010`): the tool announces which
+ * way to drag (the role's `gestureHint`), the drawn connector carries the
+ * pattern's role, and the endpoints are real element references — which is what
+ * makes the whole of `rules.ts` possible.
+ *
+ * ## What the style says, and what the role says
+ *
+ * Style is presentation: `dashed` for the two "no real integration" patterns
+ * (Separate Ways, Big Ball of Mud), a rear arrowhead for the five U/D ones so
+ * the sheet still reads at a glance. Meaning is the role, and only the role: a
+ * user restyling a link never changes what it means, and a link drawn before
+ * WS2 keeps its old look and stays neutral.
+ *
+ * The abbreviation TAG is not drawn any more. A label riding on the connector is
+ * `ConnectorToolOptions.label`, which was cut from v1 — the pattern reads from
+ * the hover reveal (M2) and the toolbar until it lands.
+ */
+export function activateContextMapRelationship(gfx, kind, style) {
+    gfx.tool.setTool(ConnectorTool, {
+        mode: ConnectorMode.Straight,
+        role: CM_PATTERN_ROLE[kind],
+        // The look rides on the activation, never through the last-props store:
+        // the plain connector tool must keep the user's own style (#144 M1).
+        style: {
+            stroke: LABEL_COLOR,
+            strokeStyle: style.dashed ? StrokeStyle.Dash : StrokeStyle.Solid,
+            strokeWidth: RELATIONSHIP_STROKE_WIDTH,
+            frontEndpointStyle: PointStyle.None,
+            // The arrow points at the DOWNSTREAM end, which is the target: the
+            // role's verb is "is upstream of", so the source is the upstream
+            // context.
+            rearEndpointStyle: style.upDown ? PointStyle.Arrow : PointStyle.None,
+        },
+    });
+    // The Context Map palette stays open (native sub-menu behaviour): it only
+    // closes on re-click of the senior button, another senior tool, or Escape.
+}

package/dist/background.d.ts

@@ -0,0 +1,19 @@
+import type { FrameworkBackgroundDef } from '@formicoidea/labre-core/blocks/surface';
+/**
+ * The Context Map board, DECLARED (the `FrameworkBackgroundDef` primitive).
+ *
+ * The emptiest declaration in the library, and deliberately so: **no axes, no
+ * zones**. A Context Map is a graph, not a chart — a bounded context drawn top
+ * left says nothing more than one drawn bottom right, and graduating the card
+ * would invent a frame of reference the framework does not have. What the
+ * declaration is for here is the ROLE and the geometry: `context-map:board` is
+ * what a rule frames its subjects against, and it is what a per-map validation
+ * profile is written on.
+ *
+ * The palette carries the notation's two boundary colours even though nothing in
+ * this file paints them. Same precedent as the Wardley tone convention: a
+ * palette entry is a declared REFERENCE, so the day a `tone-convention` rule
+ * asks "is this bubble drawn in the map's own blue" the answer is already
+ * written down, in one place, beside the card it belongs to.
+ */
+export declare const CONTEXT_MAP_BACKGROUND: FrameworkBackgroundDef;

package/dist/background.js

@@ -0,0 +1,51 @@
+import { CLOUD, CM_BUBBLE, FONT_FAMILY } from '@formicoidea/labre-ddd-shared';
+import { CONTEXT_MAP_ROLE } from './roles.js';
+/**
+ * The Context Map board, DECLARED (the `FrameworkBackgroundDef` primitive).
+ *
+ * The emptiest declaration in the library, and deliberately so: **no axes, no
+ * zones**. A Context Map is a graph, not a chart — a bounded context drawn top
+ * left says nothing more than one drawn bottom right, and graduating the card
+ * would invent a frame of reference the framework does not have. What the
+ * declaration is for here is the ROLE and the geometry: `context-map:board` is
+ * what a rule frames its subjects against, and it is what a per-map validation
+ * profile is written on.
+ *
+ * The palette carries the notation's two boundary colours even though nothing in
+ * this file paints them. Same precedent as the Wardley tone convention: a
+ * palette entry is a declared REFERENCE, so the day a `tone-convention` rule
+ * asks "is this bubble drawn in the map's own blue" the answer is already
+ * written down, in one place, beside the card it belongs to.
+ */
+export const CONTEXT_MAP_BACKGROUND = {
+    type: 'contextMap',
+    role: CONTEXT_MAP_ROLE.board,
+    geometry: {
+        // Wide and free: a context map grows sideways as contexts are found, so
+        // neither dimension is locked to the other and the handles are offered from
+        // the start — the opposite call from the Wardley map, which is a frame of
+        // reference you place things on rather than a sheet you spread out.
+        width: 1400,
+        height: 900,
+        lockAspectRatio: false,
+        resizable: true,
+        margin: { top: 24, right: 24, bottom: 24, left: 24 },
+    },
+    chrome: {
+        fontFamily: FONT_FAMILY,
+        palette: {
+            card: '#ffffff',
+            cardBorder: '#d5d9e0',
+            /** The bounded-context pill: the map's own blue. */
+            context: CM_BUBBLE.fill,
+            contextBorder: CM_BUBBLE.stroke,
+            /** The cloud / Big Ball of Mud: the map's own grey-violet. */
+            cloud: CLOUD.fill,
+            cloudBorder: CLOUD.stroke,
+        },
+        surface: {
+            fill: '@card',
+            border: { color: '@cardBorder', width: 1.5, radius: 12 },
+        },
+    },
+};

package/dist/commands.d.ts

@@ -0,0 +1,4 @@
+import type { CommandDescriptor } from '@formicoidea/labre-core/std';
+import { type TemplateResult } from 'lit';
+export declare const contextMapCommands: CommandDescriptor[];
+export declare const contextMapCommandIcons: Record<string, TemplateResult>;

package/dist/commands.js

@@ -0,0 +1,84 @@
+import { addBubble, addCloud, CM_RELATIONSHIPS, placeDddElement, } from '@formicoidea/labre-ddd-shared';
+import { GfxControllerIdentifier } from '@formicoidea/labre-core/std/gfx';
+import { svg } from 'lit';
+import { activateContextMapRelationship, createContextMapBoard, } from './actions.js';
+import { CONTEXT_MAP_ROLE } from './roles.js';
+/**
+ * The Context Map palette as commands: the board, the bounded-context bubble,
+ * the cloud and the nine relationship patterns (`docs/adr/0008`).
+ *
+ * Two entries changed shape in WS2 and neither changed its telemetry: the
+ * bubble now carries the `context-map:context` role, and the nine patterns arm
+ * the connector tool instead of dropping a drawing.
+ *
+ * The notation legend is deliberately NOT a palette entry any more (PO recette,
+ * 27/08/2026): the ONE legend is the automatic one on the selected board's
+ * contextual toolbar (`toolbar/board-config.ts`) — the same call Core Domain
+ * Chart makes. A palette that could also drop a second, static legend was two
+ * answers to one question.
+ */
+const boardSwatch = svg `<svg viewBox="0 0 24 24" fill="none"><rect x="2.5" y="4.5" width="19" height="15" rx="2" fill="#ffffff" stroke="currentColor" stroke-width="1.6"/><rect x="5.5" y="8" width="6" height="3.5" rx="1.75" fill="#e6f0fa" stroke="#2f6fb0" stroke-width="1.1"/><rect x="13" y="13" width="6" height="3.5" rx="1.75" fill="#e6f0fa" stroke="#2f6fb0" stroke-width="1.1"/><path d="M11.5 10.5 L13.5 13.8" stroke="currentColor" stroke-width="1.2"/></svg>`;
+const bubbleSwatch = svg `<svg viewBox="0 0 24 24" fill="none"><rect x="2" y="7" width="20" height="10" rx="5" fill="#e6f0fa" stroke="#2f6fb0" stroke-width="1.6"/></svg>`;
+const cloudSwatch = svg `<svg viewBox="0 0 24 24" fill="none"><path d="M6 17 C3 17 2 14 4.5 12.5 C4 9 8 8 9.5 10 C11 6.5 16 7.5 16 11 C19 10.5 20.5 14 18 16 C18 17 16.5 17 15 17 Z" fill="#f0eef6" stroke="#6d6e71" stroke-width="1.4"/></svg>`;
+const relationSwatch = (dashed, arrow) => svg `<svg viewBox="0 0 24 24" fill="none"><path d="M3 12 H${arrow ? 17 : 21}" stroke="currentColor" stroke-width="2" stroke-dasharray="${dashed ? '3 3' : '0'}"/>${arrow ? svg `<path d="M15 8 L21 12 L15 16" stroke="currentColor" stroke-width="2" fill="none"/>` : ''}</svg>`;
+const SPECS = [
+    {
+        id: 'addBoard',
+        label: 'Context Map board',
+        iconKey: 'ddd-context-map.board',
+        // A NEW telemetry value, and the only one in this file: every other entry
+        // below keeps the `element` string it has emitted since ADR 0008.
+        element: 'board',
+        icon: boardSwatch,
+        run: std => createContextMapBoard(std.get(GfxControllerIdentifier)),
+    },
+    {
+        id: 'addBoundedContext',
+        label: 'Bounded Context',
+        iconKey: 'ddd-context-map.bubble',
+        element: 'bounded-context',
+        icon: bubbleSwatch,
+        run: std => placeDddElement(std, (surface, cx, cy) => 
+        // The role is what makes a bubble a bounded CONTEXT rather than a blue
+        // pill: every rule in `rules.ts` reads it, and a pill drawn before WS2
+        // carries none and is never evaluated (promesse #71).
+        addBubble(surface, cx, cy, 'Bounded Context', CONTEXT_MAP_ROLE.context)),
+    },
+    {
+        id: 'addCloud',
+        label: 'Cloud / System (Big Ball of Mud)',
+        iconKey: 'ddd-context-map.cloud',
+        element: 'cloud',
+        icon: cloudSwatch,
+        run: std => placeDddElement(std, (surface, cx, cy) => addCloud(surface, std, cx, cy, 'System')),
+    },
+    ...CM_RELATIONSHIPS.map((preset) => ({
+        id: `add${preset.kind[0].toUpperCase()}${preset.kind.slice(1)}`,
+        label: preset.label,
+        iconKey: `ddd-context-map.relationship.${preset.kind}`,
+        element: `relationship:${preset.kind}`,
+        icon: relationSwatch(preset.dashed, preset.upDown),
+        // No longer a placement: the nine patterns arm the connector tool and the
+        // user DRAWS the relation between two contexts. See
+        // `activateContextMapRelationship` for why the free-floating group had to
+        // go. The telemetry `element` value is untouched.
+        run: std => activateContextMapRelationship(std.get(GfxControllerIdentifier), preset.kind, { upDown: preset.upDown, dashed: preset.dashed }),
+    })),
+];
+export const contextMapCommands = SPECS.map((spec, order) => ({
+    id: `ddd-context-map.${spec.id}`,
+    owner: 'ddd-context-map',
+    kind: 'artefact',
+    labelKey: `com.labre.commands.ddd-context-map.${spec.id}`,
+    labelFallback: spec.label,
+    category: 'map',
+    iconKey: spec.iconKey,
+    surfaces: ['senior-menu', 'catalogue', 'palette', 'agent'],
+    order,
+    scope: 'edgeless',
+    defaultKeys: { mac: [], other: [] },
+    availability: 'always',
+    run: spec.run,
+    telemetry: { framework: 'ddd-context-map', element: spec.element },
+}));
+export const contextMapCommandIcons = Object.fromEntries(SPECS.map(spec => [spec.iconKey, spec.icon]));

package/dist/descriptor.d.ts

@@ -1,7 +1,12 @@
-import { DddContextMapViewExtension } from './view.js';
+import { DddContextMapRenderViewExtension, DddContextMapViewExtension } from './view.js';
 /** Host wiring for the ddd-context-map framework. */
 export declare const dddContextMapFramework: {
     readonly flag: "ddd-context-map";
-    readonly telemetry: "ddd-context-map";
-    readonly viewExtension: typeof DddContextMapViewExtension;
+    readonly telemetryKey: "context-map";
+    readonly extensions: readonly [{
+        readonly viewExtension: typeof DddContextMapRenderViewExtension;
+    }, {
+        readonly flag: "ddd-context-map";
+        readonly viewExtension: typeof DddContextMapViewExtension;
+    }];
 };

package/dist/descriptor.js

@@ -1,7 +1,10 @@
-import { DddContextMapViewExtension } from './view.js';
+import { DddContextMapRenderViewExtension, DddContextMapViewExtension } from './view.js';
 /** Host wiring for the ddd-context-map framework. */
 export const dddContextMapFramework = {
     flag: 'ddd-context-map',
-    telemetry: 'ddd-context-map',
-    viewExtension: DddContextMapViewExtension,
+    telemetryKey: 'context-map',
+    extensions: [
+        { viewExtension: DddContextMapRenderViewExtension },
+        { flag: 'ddd-context-map', viewExtension: DddContextMapViewExtension },
+    ],
 };

package/dist/element-renderer.d.ts

@@ -0,0 +1,17 @@
+import { type ElementRenderer } from '@formicoidea/labre-core/blocks/surface';
+import type { ContextMapBoardElementModel } from '@formicoidea/labre-core/model';
+/**
+ * Canvas renderer for the Context Map board.
+ *
+ * There is no Context Map drawing code: the board is an INSTANTIATION of the
+ * framework-background primitive, configured by the `CONTEXT_MAP_BACKGROUND`
+ * declaration — which, having no axes and no zones, paints the primitive's own
+ * default: a white card with a hairline border.
+ *
+ * Exported as a function as well as an extension so a test can drive it with a
+ * canvas stub.
+ */
+export declare const contextMap: ElementRenderer<ContextMapBoardElementModel>;
+export declare const ContextMapRendererExtension: import("@formicoidea/labre-core/store").ExtensionType & {
+    identifier: import("@formicoidea/labre-core/_pkgs/global/di").ServiceIdentifier<ElementRenderer<ContextMapBoardElementModel>>;
+};

package/dist/element-renderer.js

@@ -0,0 +1,15 @@
+import { createFrameworkBackgroundRenderer, ElementRendererExtension, } from '@formicoidea/labre-core/blocks/surface';
+import { CONTEXT_MAP_BACKGROUND } from './background.js';
+/**
+ * Canvas renderer for the Context Map board.
+ *
+ * There is no Context Map drawing code: the board is an INSTANTIATION of the
+ * framework-background primitive, configured by the `CONTEXT_MAP_BACKGROUND`
+ * declaration — which, having no axes and no zones, paints the primitive's own
+ * default: a white card with a hairline border.
+ *
+ * Exported as a function as well as an extension so a test can drive it with a
+ * canvas stub.
+ */
+export const contextMap = createFrameworkBackgroundRenderer(CONTEXT_MAP_BACKGROUND);
+export const ContextMapRendererExtension = ElementRendererExtension(CONTEXT_MAP_BACKGROUND.type, contextMap);

package/dist/element-view.d.ts

@@ -0,0 +1,17 @@
+import type { ContextMapBoardElementModel } from '@formicoidea/labre-core/model';
+import { GfxElementModelView } from '@formicoidea/labre-core/std/gfx';
+/**
+ * View for the Context Map board. Registering it ensures `gfx.view.get(model)`
+ * returns a view (required so move / select interactions work).
+ *
+ * No double-click label editor, unlike the Wardley map: the declaration carries
+ * no text at all, so there is nothing on the card to hit-test.
+ */
+export declare class ContextMapView extends GfxElementModelView<ContextMapBoardElementModel> {
+    static type: string;
+}
+/**
+ * Resize gating, from the primitive: the handles follow `resizeEnabled`, which
+ * the declaration seeds to `true` — a board is a sheet you spread out.
+ */
+export declare const ContextMapInteraction: import("@formicoidea/labre-core/store").ExtensionType;

package/dist/element-view.js

@@ -0,0 +1,18 @@
+import { FrameworkBackgroundInteractionExtension } from '@formicoidea/labre-core/blocks/surface';
+import { GfxElementModelView } from '@formicoidea/labre-core/std/gfx';
+import { CONTEXT_MAP_BACKGROUND } from './background.js';
+/**
+ * View for the Context Map board. Registering it ensures `gfx.view.get(model)`
+ * returns a view (required so move / select interactions work).
+ *
+ * No double-click label editor, unlike the Wardley map: the declaration carries
+ * no text at all, so there is nothing on the card to hit-test.
+ */
+export class ContextMapView extends GfxElementModelView {
+    static { this.type = 'contextMap'; }
+}
+/**
+ * Resize gating, from the primitive: the handles follow `resizeEnabled`, which
+ * the declaration seeds to `true` — a board is a sheet you spread out.
+ */
+export const ContextMapInteraction = FrameworkBackgroundInteractionExtension(CONTEXT_MAP_BACKGROUND);

package/dist/index.d.ts

@@ -1,4 +1,11 @@
+export { contextMapCommandIcons, contextMapCommands } from './commands.js';
+export { CONTEXT_MAP_BACKGROUND } from './background.js';
+export { CONTEXT_MAP_NUDGES } from './nudges.js';
+export { CONTEXT_MAP_PROFILES } from './profiles.js';
+export { CM_PATTERN_ROLE, CONTEXT_MAP_ROLE, CONTEXT_MAP_ROLES, type ContextMapPatternKind, type ContextMapRoleId, } from './roles.js';
+export { CONTEXT_MAP_RULES } from './rules.js';
+export { contextMapTranslationEntries } from './translations.js';
 export { contextMapTemplateCategory } from './templates.js';
 export { contextMapSeniorTool } from './toolbar/senior-tool.js';
 export { EdgelessDddContextMapSeniorButton } from './toolbar/senior-button.js';
-export { DddContextMapViewExtension } from './view.js';
+export { DddContextMapRenderViewExtension, DddContextMapViewExtension, } from './view.js';

package/dist/index.js

@@ -1,4 +1,11 @@
+export { contextMapCommandIcons, contextMapCommands } from './commands.js';
+export { CONTEXT_MAP_BACKGROUND } from './background.js';
+export { CONTEXT_MAP_NUDGES } from './nudges.js';
+export { CONTEXT_MAP_PROFILES } from './profiles.js';
+export { CM_PATTERN_ROLE, CONTEXT_MAP_ROLE, CONTEXT_MAP_ROLES, } from './roles.js';
+export { CONTEXT_MAP_RULES } from './rules.js';
+export { contextMapTranslationEntries } from './translations.js';
 export { contextMapTemplateCategory } from './templates.js';
 export { contextMapSeniorTool } from './toolbar/senior-tool.js';
 export { EdgelessDddContextMapSeniorButton } from './toolbar/senior-button.js';
-export { DddContextMapViewExtension } from './view.js';
+export { DddContextMapRenderViewExtension, DddContextMapViewExtension, } from './view.js';

package/dist/legend.d.ts

@@ -0,0 +1,20 @@
+import { type AutoLegendSpec } from '@formicoidea/labre-ddd-shared';
+/**
+ * What the Context Map board'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 itself draws from
+ * ({@link CM_RELATIONSHIPS}, {@link CM_BUBBLE}) and from the role vocabulary's
+ * own labels, never restated. A tenth pattern added to `CM_RELATIONSHIPS` gets
+ * its legend row here with no edit, the same way it gets its role.
+ *
+ * ## What is missing, and why
+ *
+ * The **cloud** (the "System / Big Ball of Mud" blob) carries no role: it is
+ * created neutral by `commands.ts`, deliberately — the endpoint grammar treats a
+ * relationship drawn onto a cloud as a sketch and stays silent on it. Detection
+ * is by role and only by role, so the automatic legend cannot list the cloud and
+ * does not pretend to. The palette's static Legend entry still documents it, and
+ * the day the cloud earns a role its row lands here in one line.
+ */
+export declare const CONTEXT_MAP_AUTO_LEGEND: AutoLegendSpec;

package/dist/legend.js

@@ -0,0 +1,56 @@
+import { CM_BUBBLE, CM_RELATIONSHIPS, LABEL_COLOR, roleLabel, } from '@formicoidea/labre-ddd-shared';
+import { CM_PATTERN_ROLE, CONTEXT_MAP_ROLE, CONTEXT_MAP_ROLES } from './roles.js';
+/**
+ * What the Context Map board'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 itself draws from
+ * ({@link CM_RELATIONSHIPS}, {@link CM_BUBBLE}) and from the role vocabulary's
+ * own labels, never restated. A tenth pattern added to `CM_RELATIONSHIPS` gets
+ * its legend row here with no edit, the same way it gets its role.
+ *
+ * ## What is missing, and why
+ *
+ * The **cloud** (the "System / Big Ball of Mud" blob) carries no role: it is
+ * created neutral by `commands.ts`, deliberately — the endpoint grammar treats a
+ * relationship drawn onto a cloud as a sketch and stays silent on it. Detection
+ * is by role and only by role, so the automatic legend cannot list the cloud and
+ * does not pretend to. The palette's static Legend entry still documents it, and
+ * the day the cloud earns a role its row lands here in one line.
+ */
+export const CONTEXT_MAP_AUTO_LEGEND = {
+    title: 'Legend',
+    width: 290,
+    roles: CONTEXT_MAP_ROLES,
+    sections: [
+        {
+            title: 'Boundaries',
+            entries: [
+                {
+                    role: CONTEXT_MAP_ROLE.context,
+                    row: {
+                        swatch: 'square',
+                        color: CM_BUBBLE.fill,
+                        label: roleLabel(CONTEXT_MAP_ROLES, CONTEXT_MAP_ROLE.context),
+                    },
+                },
+            ],
+        },
+        {
+            title: 'Relationships',
+            // One entry per PATTERN, not one for `context-map:relationship`: a legend
+            // that said "Relationship" would document nothing a reader could use. The
+            // dashed sample marks the two "no real integration" patterns, exactly as
+            // the board draws them.
+            entries: CM_RELATIONSHIPS.map(preset => ({
+                role: CM_PATTERN_ROLE[preset.kind],
+                row: {
+                    swatch: 'line',
+                    color: LABEL_COLOR,
+                    dashed: preset.dashed,
+                    label: `${preset.abbrev} — ${preset.label}`,
+                },
+            })),
+        },
+    ],
+};

package/dist/nudges.d.ts

@@ -0,0 +1,19 @@
+import type { QualityNudge } from '@formicoidea/labre-core/blocks/surface';
+/**
+ * Context Mapping **map quality** — the checklist (WS2, level 2).
+ *
+ * `./rules.ts` is level 1: deterministic, decidable, real time. This file is
+ * everything a context map needs that no algorithm can decide. The split is the
+ * taxonomy's whole point — ticking is assuming, never verifying.
+ *
+ * Every one of the four is about whether a PATTERN WAS CHOSEN rather than
+ * defaulted to. That is the failure mode of context mapping in practice: the
+ * team draws nine links because there are nine integrations, picks the arrow
+ * that looks right, and ships a map that records the current wiring instead of
+ * the relationships. Nothing on the canvas can tell those two maps apart.
+ *
+ * Registered from the flag-gated `DddContextMapViewExtension`: a checklist is
+ * tooling. Switching the flag off takes it away and leaves the ticks written on
+ * the board, unread, until it comes back.
+ */
+export declare const CONTEXT_MAP_NUDGES: readonly QualityNudge[];

package/dist/nudges.js

@@ -0,0 +1,55 @@
+/**
+ * Context Mapping **map quality** — the checklist (WS2, level 2).
+ *
+ * `./rules.ts` is level 1: deterministic, decidable, real time. This file is
+ * everything a context map needs that no algorithm can decide. The split is the
+ * taxonomy's whole point — ticking is assuming, never verifying.
+ *
+ * Every one of the four is about whether a PATTERN WAS CHOSEN rather than
+ * defaulted to. That is the failure mode of context mapping in practice: the
+ * team draws nine links because there are nine integrations, picks the arrow
+ * that looks right, and ships a map that records the current wiring instead of
+ * the relationships. Nothing on the canvas can tell those two maps apart.
+ *
+ * Registered from the flag-gated `DddContextMapViewExtension`: a checklist is
+ * tooling. Switching the flag off takes it away and leaves the ticks written on
+ * the board, unread, until it comes back.
+ */
+export const CONTEXT_MAP_NUDGES = [
+    {
+        id: 'context-map.q1-pattern-discussed',
+        framework: 'ddd-context-map',
+        labelKey: 'com.labre.ddd-context-map.quality.pattern-discussed',
+        fallback: 'Every relationship carries a justified, discussed pattern — not the one that was easiest to draw.',
+        order: 1,
+    },
+    {
+        id: 'context-map.q2-separate-ways-documented',
+        framework: 'ddd-context-map',
+        labelKey: 'com.labre.ddd-context-map.quality.separate-ways',
+        fallback: 'Separate Ways are documented: it is written down why there is no integration.',
+        order: 2,
+    },
+    {
+        /**
+         * The rule this nudge replaces. "Every downstream of a Big Ball of Mud is
+         * protected" is decidable in principle — walk the edges out of the cloud and
+         * look for an ACL — and undecidable in practice on THIS canvas: the cloud
+         * carries no role (a v1 cut), so there is nothing for a rule to walk from,
+         * and a shape somebody drew a mess with is not a claim that it IS one.
+         * Level 2 is the honest home for it until the cloud has a role.
+         */
+        id: 'context-map.q3-bbom-protected',
+        framework: 'ddd-context-map',
+        labelKey: 'com.labre.ddd-context-map.quality.bbom-protected',
+        fallback: 'Every downstream of a Big Ball of Mud is protected by an Anticorruption Layer.',
+        order: 3,
+    },
+    {
+        id: 'context-map.q4-legend',
+        framework: 'ddd-context-map',
+        labelKey: 'com.labre.ddd-context-map.quality.legend',
+        fallback: 'The map has a legend: a reader who does not know the notation can read it.',
+        order: 4,
+    },
+];

package/dist/profiles.d.ts

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