@formicoidea/labre-framework-ddd-context-map 0.32.0 → 0.34.1

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[];

package/dist/profiles.js

@@ -0,0 +1,73 @@
+/**
+ * Context Mapping validation profiles (WS2).
+ *
+ * DATA owned by the framework, like its rules and its roles. A profile is
+ * chosen per BOARD, not per document, and the choice rides on the board element
+ * itself — two maps at two levels of requirement coexist on one canvas.
+ *
+ * Registered from the flag-gated `DddContextMapViewExtension`, beside the
+ * rules: switching the Context Map flag off takes the choice away with the rest
+ * of the tooling, and a board already set to `strict` simply stops being checked
+ * until it comes back — the id stays written, untouched.
+ */
+/**
+ * Sketch: every rule demoted to `audit`. Findings still reach `violations$` —
+ * a host panel and a conformance report see them — and the canvas says nothing.
+ *
+ * The DEFAULT, and deliberately so (PRD principle 3). A context map is drawn in
+ * a workshop, at speed, with half the links pointing the wrong way while
+ * somebody remembers which team is upstream; a tool arguing with that hand is a
+ * tool switched off within the hour. Being the default also means it WRITES
+ * NOTHING: a board on `sketch` carries no profile key, so every map ever drawn
+ * is on it, with no migration and no backfill.
+ */
+const sketch = {
+    id: 'context-map.sketch',
+    framework: 'ddd-context-map',
+    labelKey: 'com.labre.ddd-context-map.profile.sketch',
+    fallback: 'Sketch',
+    isDefault: true,
+    rules: {
+        'context-map.relationship-endpoints': 'audit',
+        'context-map.acl-conformist-exclusive': 'audit',
+        'context-map.pattern-on-customer-supplier': 'audit',
+        'context-map.acl-on-customer-supplier': 'audit',
+        'context-map.context-off-board': 'audit',
+    },
+};
+/**
+ * Strict: the deliverable level — a map that leaves the room. Every severity is
+ * spelled out rather than left absent, so the answer is readable in one place.
+ *
+ * ## The one that does not move
+ *
+ * `acl-on-customer-supplier` stays `audit` HERE TOO, and it is the reason a
+ * profile spells everything out. It is not a softer version of a contradiction,
+ * it is a different KIND of statement: the combination is legitimate — a team
+ * negotiating its needs upstream while still translating a model that is being
+ * retired — and only the team knows which case they are in. Promoting it with
+ * the others would turn a good question into a false accusation on every mature
+ * map in the corpus.
+ *
+ * Nothing here is `blocking-overridable`: nothing in this library implements
+ * refusal, and declaring it would be data claiming an effect that does not
+ * exist.
+ */
+const strict = {
+    id: 'context-map.strict',
+    framework: 'ddd-context-map',
+    labelKey: 'com.labre.ddd-context-map.profile.strict',
+    fallback: 'Strict',
+    rules: {
+        'context-map.relationship-endpoints': 'warning',
+        'context-map.acl-conformist-exclusive': 'warning',
+        'context-map.pattern-on-customer-supplier': 'warning',
+        // See the header: a judgement the map cannot make at any level.
+        'context-map.acl-on-customer-supplier': 'audit',
+        'context-map.context-off-board': 'warning',
+    },
+};
+export const CONTEXT_MAP_PROFILES = [
+    sketch,
+    strict,
+];

package/dist/roles.d.ts

@@ -0,0 +1,65 @@
+import { CM_RELATIONSHIPS } from '@formicoidea/labre-ddd-shared';
+import type { RoleDefs } from '@formicoidea/labre-core/std/gfx';
+/**
+ * Context Mapping role vocabulary (WS2).
+ *
+ * Roles are the semantic identity of a Context Map artefact — no rule will ever
+ * look at a shape type. Three families:
+ *
+ * - the **board** (`context-map:board`), the white card the map is drawn on;
+ * - the **bounded context** (`context-map:context`), the blue pill;
+ * - the **relationship** (`context-map:relationship`), the edge parent, with
+ *   one child per DDD pattern.
+ *
+ * ## One role per pattern, and why
+ *
+ * The PO arbitration of 26/08/2026: a relationship is not a connector with a
+ * `pattern` property, it is nine different edges. Two reasons, both of them
+ * about what the rules can then say. A pattern-per-role means a rule is written
+ * on the pattern it is about (`acl` and `conformist` may not coexist) without
+ * the engine growing a way to read a property; and it means a combination the
+ * notation genuinely allows — C/S plus OHS plus PL on the same couple, which is
+ * DDD Crew's own example — is drawn as PARALLEL LINKS, each a statement of its
+ * own, rather than as a bag of flags nobody can point at.
+ *
+ * Hierarchy is DATA (`parent`): every pattern specialises
+ * `context-map:relationship`, so a rule written on the parent — the endpoint
+ * grammar, the self-loop ban — covers all nine for free (see `roleIsA`).
+ *
+ * ## `direction` only on the U/D patterns
+ *
+ * Tier 1 of `docs/adr/0010` says an edge's source is the subject of its verb.
+ * That only MEANS something for the five upstream/downstream patterns, where
+ * the notation itself has a direction: the source is the upstream context. The
+ * four symmetric ones (Partnership, Shared Kernel, Separate Ways, Big Ball of
+ * Mud) relate two contexts as equals — declaring a verb on them would announce a
+ * gesture ("drag from the upstream one") that means nothing, and the reveal (M2)
+ * would show a sentence the framework does not say. They therefore declare none,
+ * which is exactly what an untyped edge already did.
+ *
+ * ## Compat
+ *
+ * Nothing is backfilled. Relationships drawn before these roles existed — the
+ * old free connector + tag + U/D markers group — carry no role and are never
+ * evaluated (promesse #71): they stay drawings, in the documents they are in.
+ */
+/** The nine DDD Crew patterns, by the `kind` used at the creation sites. */
+export type ContextMapPatternKind = (typeof CM_RELATIONSHIPS)[number]['kind'];
+export type ContextMapRoleId = `context-map:${string}`;
+export declare const CM_PATTERN_ROLE: Record<ContextMapPatternKind, ContextMapRoleId>;
+/** The three roles that are not a pattern, plus the pattern ids. */
+export declare const CONTEXT_MAP_ROLE: {
+    readonly partnership: `context-map:${string}`;
+    readonly sharedKernel: `context-map:${string}`;
+    readonly customerSupplier: `context-map:${string}`;
+    readonly conformist: `context-map:${string}`;
+    readonly acl: `context-map:${string}`;
+    readonly ohs: `context-map:${string}`;
+    readonly publishedLanguage: `context-map:${string}`;
+    readonly separateWays: `context-map:${string}`;
+    readonly bbom: `context-map:${string}`;
+    readonly board: "context-map:board";
+    readonly context: "context-map:context";
+    readonly relationship: "context-map:relationship";
+};
+export declare const CONTEXT_MAP_ROLES: RoleDefs;

package/dist/roles.js

@@ -0,0 +1,64 @@
+import { CM_RELATIONSHIPS } from '@formicoidea/labre-ddd-shared';
+/**
+ * Role id per pattern kind, DERIVED from the shared preset table rather than
+ * restated: the kinds are camelCase (`sharedKernel`) and the role ids are
+ * kebab-case (`context-map:shared-kernel`), and the day a tenth pattern lands in
+ * `CM_RELATIONSHIPS` it gets its role here with no edit.
+ */
+const kebab = (kind) => kind.replace(/[A-Z]/g, letter => `-${letter.toLowerCase()}`);
+export const CM_PATTERN_ROLE = Object.fromEntries(CM_RELATIONSHIPS.map(preset => [
+    preset.kind,
+    `context-map:${kebab(preset.kind)}`,
+]));
+/** The three roles that are not a pattern, plus the pattern ids. */
+export const CONTEXT_MAP_ROLE = {
+    board: 'context-map:board',
+    context: 'context-map:context',
+    relationship: 'context-map:relationship',
+    ...CM_PATTERN_ROLE,
+};
+/** The DDD Crew wording, verbatim: `Upstream` is the source of the relation. */
+const UPSTREAM_DIRECTION = {
+    verbKey: 'com.labre.ddd-context-map.role.relationship.verb',
+    verbFallback: 'is upstream of',
+    gestureHintKey: 'com.labre.ddd-context-map.role.relationship.gesture',
+    gestureHintFallback: 'Drag from the upstream context to the downstream one.',
+};
+const DEFS = [
+    // The board: a frame, not a context. It specialises nothing, so a rule
+    // written on `context-map:context` can never match the card its subjects
+    // sit on.
+    {
+        id: CONTEXT_MAP_ROLE.board,
+        kind: 'node',
+        labelKey: 'com.labre.ddd-context-map.role.board',
+        labelFallback: 'Context map',
+    },
+    {
+        id: CONTEXT_MAP_ROLE.context,
+        kind: 'node',
+        labelKey: 'com.labre.ddd-context-map.role.context',
+        labelFallback: 'Bounded context',
+    },
+    // The edge parent. Carries no `direction` of its own: five of its nine
+    // children have one and four do not, and a verb on the parent would be
+    // inherited by the symmetric patterns that deny having one.
+    {
+        id: CONTEXT_MAP_ROLE.relationship,
+        kind: 'edge',
+        labelKey: 'com.labre.ddd-context-map.role.relationship',
+        labelFallback: 'Relationship',
+    },
+    ...CM_RELATIONSHIPS.map((preset) => ({
+        id: CM_PATTERN_ROLE[preset.kind],
+        parent: CONTEXT_MAP_ROLE.relationship,
+        kind: 'edge',
+        labelKey: `com.labre.ddd-context-map.role.${kebab(preset.kind)}`,
+        labelFallback: preset.label,
+        // See the header: only the upstream/downstream patterns have a subject.
+        ...(preset.upDown ? { direction: UPSTREAM_DIRECTION } : {}),
+    })),
+];
+// Null prototype: this is a lookup table keyed by ids that may one day come
+// from host-supplied packs, so `defs['toString']` must not resolve.
+export const CONTEXT_MAP_ROLES = Object.assign(Object.create(null), Object.fromEntries(DEFS.map(def => [def.id, def])));

package/dist/rules.d.ts

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

package/dist/rules.js

@@ -0,0 +1,264 @@
+import { CONTEXT_MAP_BACKGROUND } from './background.js';
+import { CONTEXT_MAP_ROLE, CONTEXT_MAP_ROLES } from './roles.js';
+/**
+ * Context Mapping validation rules (WS2).
+ *
+ * DATA owned by the framework, versioned per rule: the engine
+ * (`@labre/affine-block-surface`) knows how to evaluate a FAMILY, never a
+ * concrete rule. Registered from the flag-gated `DddContextMapViewExtension`,
+ * so switching the Context Map flag off removes them with the rest of the
+ * tooling — maps already drawn keep rendering, they simply stop being checked
+ * (`docs/adr/0009`).
+ *
+ * ## What the grammar of a context map actually is
+ *
+ * Very little, and that is the point. A context map has no axes: nothing about
+ * WHERE a context sits means anything, so there is no order rule, no zone rule
+ * and no orientation rule to write. What it does have is a notation with
+ * CONTRADICTIONS in it — patterns that cannot both be true of the same couple —
+ * and those are exactly what the `relation-endpoints` family arbitrates.
+ *
+ * Four of the five rules below are therefore one family with four different
+ * questions, and every one of them stays silent on a sketch: an end that is not
+ * a bounded context (a cloud, a note, a plain rectangle) is outside the
+ * alphabet, and the whole edge goes unjudged.
+ */
+/**
+ * **CM1** — a relationship runs between two bounded contexts, once, and never
+ * onto itself.
+ *
+ * The base grammar, written on the PARENT edge role, which is what makes it one
+ * rule instead of nine: `roleIsA` resolves a triplet declared on
+ * `context-map:relationship` for every pattern that specialises it, so the
+ * single sanctioned sentence below — a context relates to a context — covers
+ * Partnership and Big Ball of Mud alike, and a tenth pattern inherits it on the
+ * day it is added.
+ *
+ * The two things it says:
+ *
+ * - **self-loop** — a context is not related to itself. Whatever the hand meant,
+ *   the notation has no sentence for it;
+ * - **duplicate** — the same pattern drawn twice between the same two contexts,
+ *   the same way round. Not two DIFFERENT patterns, which is legitimate and how
+ *   C/S + OHS + PL is drawn; the same one, twice, which is one link too many on
+ *   a map that is read by counting links.
+ *
+ * ## What `allowed` does here, and what it deliberately does NOT
+ *
+ * The matrix holds ONE sentence, and `context-map:context` is therefore the
+ * whole alphabet of this rule. That makes the off-matrix branch structurally
+ * unreachable — an end that is a context passes, and an end that is anything
+ * else is outside the alphabet, which is TOTAL silence for the edge (see
+ * {@link RelationEndpointsDef.allowed}).
+ *
+ * That is the intent, not an oversight. The matrix is here to declare the
+ * alphabet, and the alphabet is what makes the whole rule proportionate: a
+ * relationship drawn onto a CLOUD, onto a note, onto a rectangle somebody
+ * dropped on the board to think with, is a draft — the user is saying "there is
+ * something out there we integrate with", which on a context map is not merely
+ * tolerable but the correct notation. Judging it would be indicting the act of
+ * sketching (PRD principle 8).
+ *
+ * The branch becomes reachable the day a second NODE role lands — a role on the
+ * cloud, say — and on that day this declaration already says what to do with it
+ * without a line changing. Until then `offMatrix` carries no words of its own
+ * and the rule's own sentence stands behind it, unused.
+ */
+const relationshipEndpoints = {
+    id: 'context-map.relationship-endpoints',
+    framework: 'ddd-context-map',
+    family: 'relation-endpoints',
+    severity: 'warning',
+    // No `appliesTo`: the subject is a RELATION, and the role that names it is
+    // declared where the family reads it — naming one of the three indicted
+    // elements here would be data that lies.
+    roles: CONTEXT_MAP_ROLES,
+    messageKey: 'com.labre.ddd-context-map.validation.relationship-endpoints',
+    messageFallback: 'This relationship does not run between two bounded contexts.',
+    suggestionKey: 'com.labre.ddd-context-map.validation.relationship-endpoints.suggestion',
+    suggestionFallback: 'A context map relates bounded contexts — re-point the loose end onto one, or delete the link.',
+    version: 1,
+    provenance: {
+        source: 'recommendation',
+        reference: 'Context Mapping (DDD) — the relationship grammar of the notation',
+    },
+    backgroundRole: CONTEXT_MAP_ROLE.board,
+    background: CONTEXT_MAP_BACKGROUND,
+    endpoints: {
+        edgeRole: CONTEXT_MAP_ROLE.relationship,
+        allowed: [
+            {
+                source: CONTEXT_MAP_ROLE.context,
+                edge: CONTEXT_MAP_ROLE.relationship,
+                target: CONTEXT_MAP_ROLE.context,
+            },
+        ],
+        forbidSelfLoop: true,
+        forbidDuplicate: true,
+        selfLoop: {
+            messageKey: 'com.labre.ddd-context-map.validation.relationship-self-loop',
+            messageFallback: 'This relationship loops back onto its own context.',
+            suggestionKey: 'com.labre.ddd-context-map.validation.relationship-self-loop.suggestion',
+            suggestionFallback: 'A bounded context integrates with OTHER contexts — drop the loose end on the context it actually relates to, or delete the link.',
+        },
+        duplicate: {
+            messageKey: 'com.labre.ddd-context-map.validation.relationship-duplicate',
+            messageFallback: 'This pattern is already drawn between these two contexts.',
+            suggestionKey: 'com.labre.ddd-context-map.validation.relationship-duplicate.suggestion',
+            suggestionFallback: 'Delete the copy. Two DIFFERENT patterns on one couple are fine — C/S with OHS and PL is the notation working — but the same one twice says nothing new.',
+        },
+    },
+};
+/**
+ * **CM2** — a context does not both conform to its upstream and protect itself
+ * from it.
+ *
+ * The textbook contradiction, and the one every context map workshop produces
+ * at least once. Conformist means "we take their model as it is"; an
+ * Anticorruption Layer means "we translate their model into ours because we
+ * refuse to take it as it is". Both are legitimate answers to the same pressure
+ * and they are opposite answers, so a couple carrying both has not decided —
+ * which is the finding.
+ *
+ * A `warning` and never a refusal: the map is a discussion aid, and the pair
+ * showing up on it is usually the moment the discussion starts. The user
+ * resolves it by deleting one, and only they know which.
+ */
+const aclConformistExclusive = {
+    id: 'context-map.acl-conformist-exclusive',
+    framework: 'ddd-context-map',
+    family: 'relation-endpoints',
+    severity: 'warning',
+    roles: CONTEXT_MAP_ROLES,
+    messageKey: 'com.labre.ddd-context-map.validation.acl-conformist',
+    messageFallback: 'These two contexts are related by both a Conformist and an Anticorruption Layer.',
+    suggestionKey: 'com.labre.ddd-context-map.validation.acl-conformist.suggestion',
+    suggestionFallback: 'Conforming means taking the upstream model as it is; an ACL means refusing to. Keep the one the team actually does.',
+    version: 1,
+    provenance: {
+        source: 'recommendation',
+        reference: 'Context Mapping (DDD) — the pattern canon: an anticorruption layer and a conformist are opposite answers',
+    },
+    backgroundRole: CONTEXT_MAP_ROLE.board,
+    background: CONTEXT_MAP_BACKGROUND,
+    endpoints: {
+        edgeRole: CONTEXT_MAP_ROLE.relationship,
+        // No `allowed`: CM1 already judges the sentences, and repeating the matrix
+        // here would report one mistake twice. This rule asks the pair question and
+        // nothing else.
+        exclusivePairs: [[CONTEXT_MAP_ROLE.acl, CONTEXT_MAP_ROLE.conformist]],
+    },
+};
+/**
+ * **CM3** — Customer/Supplier already says how the two teams work; Conformist
+ * and Open Host Service say something else.
+ *
+ * C/S is a RELATIONSHIP OF NEGOTIATION: downstream is a customer whose needs
+ * enter the upstream team's backlog. Conformist is its negation — downstream
+ * has no say and takes what comes. OHS is a different answer again: upstream
+ * serves all comers through a published protocol precisely so it does NOT have
+ * to negotiate per consumer. Either one drawn on top of a C/S says the couple
+ * has not settled which conversation it is having.
+ *
+ * ACL is NOT in this pair list, on purpose — see {@link aclOnCustomerSupplier},
+ * where it is an audit finding rather than a warning.
+ */
+const patternOnCustomerSupplier = {
+    id: 'context-map.pattern-on-customer-supplier',
+    framework: 'ddd-context-map',
+    family: 'relation-endpoints',
+    severity: 'warning',
+    roles: CONTEXT_MAP_ROLES,
+    messageKey: 'com.labre.ddd-context-map.validation.pattern-on-customer-supplier',
+    messageFallback: 'This Customer/Supplier relationship carries a second pattern that contradicts it.',
+    suggestionKey: 'com.labre.ddd-context-map.validation.pattern-on-customer-supplier.suggestion',
+    suggestionFallback: 'Customer/Supplier means the downstream needs are negotiated into the upstream backlog. Conformist says they are not; Open Host Service says the upstream serves everyone the same way. Keep one.',
+    version: 1,
+    provenance: {
+        source: 'recommendation',
+        reference: 'Context Mapping (DDD) — Customer/Supplier is a relationship of negotiation',
+    },
+    backgroundRole: CONTEXT_MAP_ROLE.board,
+    background: CONTEXT_MAP_BACKGROUND,
+    endpoints: {
+        edgeRole: CONTEXT_MAP_ROLE.relationship,
+        exclusivePairs: [
+            [CONTEXT_MAP_ROLE.customerSupplier, CONTEXT_MAP_ROLE.conformist],
+            [CONTEXT_MAP_ROLE.customerSupplier, CONTEXT_MAP_ROLE.ohs],
+        ],
+    },
+};
+/**
+ * **CM4** — an Anticorruption Layer on a Customer/Supplier is worth a second
+ * look, and nothing more.
+ *
+ * Deliberately `audit`, alone among the four. The combination is not wrong: a
+ * downstream team can perfectly well negotiate its needs upstream AND still
+ * translate the upstream model at its border, and mature teams do exactly that
+ * while a legacy model is being retired. But it is also, often, the trace of a
+ * negotiation that has stopped working — the customer built a translation layer
+ * because the supplier stopped listening.
+ *
+ * A tool cannot tell those two apart, so it does not get to interrupt: the
+ * finding reaches `violations$` for a host panel and a conformance report, and
+ * the canvas says nothing. `strict` leaves it at `audit` too, which is the whole
+ * reason a profile spells every severity out — this one is a judgement the map
+ * cannot make at any level of requirement.
+ */
+const aclOnCustomerSupplier = {
+    id: 'context-map.acl-on-customer-supplier',
+    framework: 'ddd-context-map',
+    family: 'relation-endpoints',
+    severity: 'audit',
+    roles: CONTEXT_MAP_ROLES,
+    messageKey: 'com.labre.ddd-context-map.validation.acl-on-customer-supplier',
+    messageFallback: 'This Customer/Supplier relationship also carries an Anticorruption Layer.',
+    suggestionKey: 'com.labre.ddd-context-map.validation.acl-on-customer-supplier.suggestion',
+    suggestionFallback: 'Legitimate while a model is being retired — worth asking whether the negotiation still works if it is not.',
+    version: 1,
+    provenance: {
+        source: 'labre-convention',
+        reference: 'Labre convention — the notation forbids nothing here; a tool cannot tell the two readings apart',
+    },
+    backgroundRole: CONTEXT_MAP_ROLE.board,
+    background: CONTEXT_MAP_BACKGROUND,
+    endpoints: {
+        edgeRole: CONTEXT_MAP_ROLE.relationship,
+        exclusivePairs: [[CONTEXT_MAP_ROLE.customerSupplier, CONTEXT_MAP_ROLE.acl]],
+    },
+};
+/**
+ * **CM5** — a bounded context belongs on the map.
+ *
+ * The one geometric rule the framework has, and it is about membership rather
+ * than position: a context parked beside the card is not on the map, so nothing
+ * the map says covers it. Silent when the board carries no board element at all
+ * — a context map sketched on the bare canvas is a sketch, not an error, and so
+ * is one drawn before the board existed.
+ */
+const contextOffBoard = {
+    id: 'context-map.context-off-board',
+    framework: 'ddd-context-map',
+    family: 'element-in-background',
+    severity: 'warning',
+    appliesTo: CONTEXT_MAP_ROLE.context,
+    roles: CONTEXT_MAP_ROLES,
+    messageKey: 'com.labre.ddd-context-map.validation.context-off-board',
+    messageFallback: 'This bounded context sits outside the map.',
+    suggestionKey: 'com.labre.ddd-context-map.validation.context-off-board.suggestion',
+    suggestionFallback: 'Drag it onto the board, or grow the board to take it in.',
+    version: 1,
+    provenance: {
+        source: 'labre-convention',
+        reference: 'Labre convention — membership on this canvas, not a Context Mapping rule',
+    },
+    backgroundRole: CONTEXT_MAP_ROLE.board,
+    background: CONTEXT_MAP_BACKGROUND,
+};
+export const CONTEXT_MAP_RULES = [
+    relationshipEndpoints,
+    aclConformistExclusive,
+    patternOnCustomerSupplier,
+    aclOnCustomerSupplier,
+    contextOffBoard,
+];

package/dist/toolbar/board-config.d.ts

@@ -0,0 +1,30 @@
+import { type ToolbarContext } from '@formicoidea/labre-core/shared/services';
+/**
+ * The selected board's contextual toolbar: the resize toggle, and the automatic
+ * legend of what is actually drawn on the board. Registered ALWAYS-ON
+ * (`DddContextMapRenderViewExtension`) — a stored board must stay usable with
+ * the Context Map button switched off (`docs/adr/0009`), legend included: a
+ * legend is real editable elements, so generating one is authoring a document,
+ * not tooling that a flag may take away.
+ *
+ * This is THE legend of the module. The palette used to also offer a static,
+ * full-notation one; the PO's recette (27/08/2026) removed it — two legends were
+ * two answers to one question, and the honest answer is what is actually drawn.
+ * Same single-gesture shape as Core Domain Chart.
+ */
+export declare const contextMapBoardToolbarConfig: {
+    readonly actions: [{
+        readonly id: "a.toggle-resize";
+        readonly tooltipWording: import("@formicoidea/labre-core/shared/services").ChromeWording;
+        readonly icon: import("lit-html").TemplateResult<1>;
+        readonly active: (ctx: ToolbarContext) => boolean;
+        readonly run: (ctx: ToolbarContext) => void;
+    }, {
+        readonly id: "b.legend";
+        readonly tooltipWording: import("@formicoidea/labre-core/shared/services").ChromeWording;
+        readonly icon: import("lit-html").TemplateResult<1>;
+        readonly run: (ctx: ToolbarContext) => void;
+    }];
+    readonly when: (ctx: ToolbarContext) => boolean;
+};
+export declare const contextMapBoardToolbarExtension: import("@formicoidea/labre-core/store").ExtensionType;