@formicoidea/labre-framework-c4 0.33.0

package/dist/node/type-line-watcher.d.ts

@@ -0,0 +1,70 @@
+import { InteractivityExtension } from '@formicoidea/labre-core/std/gfx';
+/**
+ * Keeps a component's type line SEMI-DERIVED: the author owns the technology,
+ * the notation owns the word.
+ *
+ * ## The rule, and where it is applied
+ *
+ * `[Container: Java]` is two statements in one line. Which of the four levels
+ * this box is, is the diagram's — it comes from `kind`, it is what the renderer
+ * paints and what the exporter maps, and an author retyping it would let the
+ * words disagree with the picture. What it is built with is theirs, and it is
+ * the only half the notation leaves to them (PO arbitration, 28/08/2026).
+ *
+ * Since the tier is a real canvas text element that half is typed IN PLACE, on
+ * the picture, with nothing standing between the keyboard and the document. So
+ * this watcher reads back what was typed, keeps the technology, and rewrites the
+ * canonical line: `Java` becomes `[Container: Java]`, `[Person: Java]` on a
+ * container becomes `[Container: Java]`, an emptied line becomes `[Container]`.
+ *
+ * ## Why the seam is the SELECTION and not `elementUpdated`
+ *
+ * The obvious hook is `surface.elementUpdated` filtered on `props.text`, which
+ * is how every other reaction in this library is wired. It is the wrong one
+ * here, and visibly so: a canvas text editor binds its inline editor straight
+ * onto the element's `Y.Text`, so that signal fires once per KEYSTROKE. A
+ * normalizer on it would rewrite the line under the cursor while somebody was
+ * still typing into it — an author who has got as far as `[Container: Ja` would
+ * have their caret thrown by a rewrite of the very text they are editing.
+ *
+ * "The edit committed" is therefore read where the editor actually says so: the
+ * text editor holds an EDITING selection for as long as it is mounted and drops
+ * it when it closes, so an id leaving the editing set is a commit and nothing
+ * else is. One rewrite per edit, after the editor is gone, and a single undo
+ * entry for it.
+ *
+ * ## Always-on, and local-only
+ *
+ * Registered by the RENDER half, not the flag-gated one (`docs/adr/0009`): this
+ * does not author anything: it keeps an element that is ALREADY in the document
+ * readable while somebody edits it, and a diagram drawn while the C4 button was
+ * on must stay editable when it goes off. It is also inherently local — a
+ * selection is this peer's own, so there is no fleet of observers to filter out
+ * the way `EdgyRelationResolver` has to.
+ */
+export declare class C4TypeLineWatcher extends InteractivityExtension {
+    static key: string;
+    private _subscription;
+    private _editing;
+    mounted(): void;
+    unmounted(): void;
+    /** The kind of the C4 shape this element is grouped with, if there is one. */
+    private _kindOf;
+    private _normalize;
+}
+/**
+ * Which ids just stopped being edited, and what is being edited now.
+ *
+ * Split out as a pure function because it is the whole of the seam's logic and
+ * the only part of it worth being wrong about: an id that appears in the new
+ * editing set has merely started, an id in both is still going, and only one
+ * that has LEFT is a commit. Kept total over an empty selection, which is what
+ * arrives when the editor closes onto bare canvas.
+ */
+export declare function c4EditingTransition(previous: ReadonlySet<string>, selections: readonly {
+    elements: readonly string[];
+    editing?: boolean;
+}[]): {
+    editing: Set<string>;
+    left: string[];
+};

package/dist/node/type-line-watcher.js

@@ -0,0 +1,142 @@
+import { C4NodeElementModel, GroupElementModel, TextElementModel, } from '@formicoidea/labre-core/model';
+import { InteractivityExtension } from '@formicoidea/labre-core/std/gfx';
+import { c4ComponentSiblings } from '../component.js';
+import { C4_ROLE } from '../roles.js';
+import { normalizeC4TypeLine } from '../type-line.js';
+/**
+ * Keeps a component's type line SEMI-DERIVED: the author owns the technology,
+ * the notation owns the word.
+ *
+ * ## The rule, and where it is applied
+ *
+ * `[Container: Java]` is two statements in one line. Which of the four levels
+ * this box is, is the diagram's — it comes from `kind`, it is what the renderer
+ * paints and what the exporter maps, and an author retyping it would let the
+ * words disagree with the picture. What it is built with is theirs, and it is
+ * the only half the notation leaves to them (PO arbitration, 28/08/2026).
+ *
+ * Since the tier is a real canvas text element that half is typed IN PLACE, on
+ * the picture, with nothing standing between the keyboard and the document. So
+ * this watcher reads back what was typed, keeps the technology, and rewrites the
+ * canonical line: `Java` becomes `[Container: Java]`, `[Person: Java]` on a
+ * container becomes `[Container: Java]`, an emptied line becomes `[Container]`.
+ *
+ * ## Why the seam is the SELECTION and not `elementUpdated`
+ *
+ * The obvious hook is `surface.elementUpdated` filtered on `props.text`, which
+ * is how every other reaction in this library is wired. It is the wrong one
+ * here, and visibly so: a canvas text editor binds its inline editor straight
+ * onto the element's `Y.Text`, so that signal fires once per KEYSTROKE. A
+ * normalizer on it would rewrite the line under the cursor while somebody was
+ * still typing into it — an author who has got as far as `[Container: Ja` would
+ * have their caret thrown by a rewrite of the very text they are editing.
+ *
+ * "The edit committed" is therefore read where the editor actually says so: the
+ * text editor holds an EDITING selection for as long as it is mounted and drops
+ * it when it closes, so an id leaving the editing set is a commit and nothing
+ * else is. One rewrite per edit, after the editor is gone, and a single undo
+ * entry for it.
+ *
+ * ## Always-on, and local-only
+ *
+ * Registered by the RENDER half, not the flag-gated one (`docs/adr/0009`): this
+ * does not author anything: it keeps an element that is ALREADY in the document
+ * readable while somebody edits it, and a diagram drawn while the C4 button was
+ * on must stay editable when it goes off. It is also inherently local — a
+ * selection is this peer's own, so there is no fleet of observers to filter out
+ * the way `EdgyRelationResolver` has to.
+ */
+export class C4TypeLineWatcher extends InteractivityExtension {
+    constructor() {
+        super(...arguments);
+        this._subscription = null;
+        this._editing = new Set();
+    }
+    static { this.key = 'c4-type-line-watcher'; }
+    mounted() {
+        this._subscription = this.gfx.selection.slots.updated.subscribe(selections => {
+            const { editing, left } = c4EditingTransition(this._editing, selections);
+            this._editing = editing;
+            for (const id of left)
+                this._normalize(id);
+        });
+    }
+    unmounted() {
+        this._subscription?.unsubscribe();
+        this._subscription = null;
+        this._editing = new Set();
+        super.unmounted();
+    }
+    /** The kind of the C4 shape this element is grouped with, if there is one. */
+    _kindOf(elementId) {
+        const surface = this.gfx.surface;
+        if (!surface)
+            return null;
+        const groups = surface.elementModels.filter((element) => element instanceof GroupElementModel);
+        for (const siblingId of c4ComponentSiblings(elementId, groups)) {
+            const sibling = surface.getElementById(siblingId);
+            if (sibling instanceof C4NodeElementModel)
+                return sibling.kind;
+        }
+        return null;
+    }
+    _normalize(elementId) {
+        // A read-only document is READ: every write below would be refused, and the
+        // author cannot have typed anything to normalize in the first place.
+        if (this.std.store.readonly)
+            return;
+        const surface = this.gfx.surface;
+        if (!surface)
+            return;
+        const element = surface.getElementById(elementId);
+        if (!(element instanceof TextElementModel))
+            return;
+        if (element.role !== C4_ROLE['type-line'])
+            return;
+        if (element.isLocked())
+            return;
+        const kind = this._kindOf(elementId);
+        // A type line whose shape is gone — the node deleted, the group released
+        // and the text dragged away — has no kind to derive a word from. Left
+        // exactly as the author typed it: guessing at a level would be this watcher
+        // asserting something nobody drew.
+        if (!kind)
+            return;
+        const raw = element.text.toString();
+        const canonical = normalizeC4TypeLine(kind, raw);
+        if (canonical === raw)
+            return;
+        this.std.store.captureSync();
+        // Mutated IN PLACE rather than replaced: the `Y.Text` instance is what the
+        // element's own change watcher and any bound view hold, and swapping it for
+        // a fresh one would leave both pointing at a text nobody is editing. One
+        // transaction, so the rewrite is one undo entry and not two.
+        this.std.store.transact(() => {
+            element.text.delete(0, element.text.length);
+            element.text.insert(0, canonical);
+        });
+    }
+}
+/**
+ * Which ids just stopped being edited, and what is being edited now.
+ *
+ * Split out as a pure function because it is the whole of the seam's logic and
+ * the only part of it worth being wrong about: an id that appears in the new
+ * editing set has merely started, an id in both is still going, and only one
+ * that has LEFT is a commit. Kept total over an empty selection, which is what
+ * arrives when the editor closes onto bare canvas.
+ */
+export function c4EditingTransition(previous, selections) {
+    const editing = new Set();
+    for (const selection of selections) {
+        if (!selection.editing)
+            continue;
+        for (const id of selection.elements)
+            editing.add(id);
+    }
+    const left = [];
+    for (const id of previous)
+        if (!editing.has(id))
+            left.push(id);
+    return { editing, left };
+}

package/dist/presets.d.ts

@@ -0,0 +1,84 @@
+import { type C4NodeKind } from '@formicoidea/labre-core/model';
+/**
+ * What a C4 shape IS, as props — the ONE description the creation site and the
+ * morph both read.
+ *
+ * Split out of `actions.ts` when the morph landed, for the reason BPMN's
+ * `presets.ts` gives about `bpmnNodeProps`: a kind's appearance is written by
+ * the preset of the kind it was created as and nothing else ever rewrites it,
+ * so a morph that restated the table would agree with the palette the day it
+ * was written and drift on the first restyle. Derived, they cannot: a morphed
+ * component and one freshly drawn from the sub-menu are the same element.
+ */
+/**
+ * The kinds whose GLYPH draws the body, so the native shape underneath paints
+ * nothing at all.
+ *
+ * Five of nine, and the renderer is the authority on which. A person is a head
+ * fused into a rounded body and a database is a cylinder, neither of which a
+ * native rect can be. `mobile` and `browser` joined them with the PO's recette
+ * of 27/08/2026: the reference stencil paints their OUTER rectangle in the
+ * node's darker colour — the bezel — and insets a lighter SCREEN in it, which is
+ * the reverse of a band painted over a body, so there is nothing left for a
+ * native rect to contribute. Same call BPMN makes for `dataObject` /
+ * `dataStore`.
+ *
+ * They stay hit-testable across their whole area all the same:
+ * `C4NodeElementModel.includesPoint` forces the interior test regardless of
+ * `filled` — which is the fix for the PO's second report, that these nodes could
+ * not be double-clicked into their text editor.
+ *
+ * This is also the one table the container FAMILY morphs across: a `container`
+ * is a plain filled rect and a `database`, a `mobile` and a `browser` are not,
+ * so `filled` and `strokeStyle` genuinely flip on the way between them — which
+ * is exactly why {@link c4MorphProps} is the whole preset and not `{kind, role}`.
+ */
+export declare const GLYPH_BODY_KINDS: ReadonlySet<C4NodeKind>;
+/**
+ * Every prop a C4 shape is created with, for one kind and one box.
+ *
+ * `index` is deliberately NOT here: it is a layering statement the creation
+ * site makes about the five elements it is about to write in painting order,
+ * and it means nothing to an element that already exists.
+ *
+ * No `text` either, and that is the arrangement rather than an omission: since
+ * the PO's recette of 28/08/2026 the name is a `c4:title` CHILD, and the shape
+ * is a body and nothing else. Its text COLOUR is still seeded — an element
+ * drawn before that change carries its name here, and the node view routes a
+ * double-click to that editor for exactly those, so the words have to stay
+ * legible.
+ */
+export declare function c4NodeProps(kind: C4NodeKind, box: {
+    xywh: string;
+}): Record<string, unknown> & {
+    type: string;
+};
+/**
+ * What a kind is worth to a shape that ALREADY EXISTS — {@link c4NodeProps}
+ * minus the three things a morph has no business touching.
+ *
+ * ## Why the whole preset, and not `{kind, role}`
+ *
+ * Because on this pack's own table it is visibly not enough. The container
+ * family — `container`, `database`, `mobile`, `browser` — is four kinds where
+ * one paints its body natively and three hand it to the renderer, so `filled`
+ * and `strokeStyle` flip between them, and two of them round their corners
+ * where the others do not ({@link NODE_RADIUS}). Morph a container to a
+ * database with two keys and the cylinder arrives with the rectangle still
+ * painted behind it. The `-ext` families are the same argument in colour: grey
+ * IS what "somebody else owns this" means, and it lives in `fillColor` /
+ * `strokeColor`.
+ */
+export declare function c4MorphProps(kind: C4NodeKind): Record<string, unknown>;
+/**
+ * The fields to DELETE after morphing to `kind` — the keys some other kind
+ * writes and this one does not.
+ *
+ * EMPTY for every kind today, because no C4 preset spreads anything
+ * conditionally: all nine write the same key set with different values. Kept
+ * anyway, and derived rather than hard-coded to `[]`, for the reason BPMN's
+ * equivalent exists at all — a patch cannot express absence, and the day one
+ * kind stops writing a key the previous kind's value would otherwise stay in
+ * the Y.Map, silently in force.
+ */
+export declare function c4MorphClears(kind: C4NodeKind): readonly string[];

package/dist/presets.js

@@ -0,0 +1,149 @@
+import { FontFamily, ShapeStyle, StrokeStyle, TextAlign, } from '@formicoidea/labre-core/model';
+import { NODE_PALETTE, NODE_RADIUS, NODE_STROKE_WIDTH, TITLE_FONT_SIZE, } from './consts.js';
+import { C4_ROLE_OF_KIND } from './roles.js';
+/**
+ * What a C4 shape IS, as props — the ONE description the creation site and the
+ * morph both read.
+ *
+ * Split out of `actions.ts` when the morph landed, for the reason BPMN's
+ * `presets.ts` gives about `bpmnNodeProps`: a kind's appearance is written by
+ * the preset of the kind it was created as and nothing else ever rewrites it,
+ * so a morph that restated the table would agree with the palette the day it
+ * was written and drift on the first restyle. Derived, they cannot: a morphed
+ * component and one freshly drawn from the sub-menu are the same element.
+ */
+/**
+ * The kinds whose GLYPH draws the body, so the native shape underneath paints
+ * nothing at all.
+ *
+ * Five of nine, and the renderer is the authority on which. A person is a head
+ * fused into a rounded body and a database is a cylinder, neither of which a
+ * native rect can be. `mobile` and `browser` joined them with the PO's recette
+ * of 27/08/2026: the reference stencil paints their OUTER rectangle in the
+ * node's darker colour — the bezel — and insets a lighter SCREEN in it, which is
+ * the reverse of a band painted over a body, so there is nothing left for a
+ * native rect to contribute. Same call BPMN makes for `dataObject` /
+ * `dataStore`.
+ *
+ * They stay hit-testable across their whole area all the same:
+ * `C4NodeElementModel.includesPoint` forces the interior test regardless of
+ * `filled` — which is the fix for the PO's second report, that these nodes could
+ * not be double-clicked into their text editor.
+ *
+ * This is also the one table the container FAMILY morphs across: a `container`
+ * is a plain filled rect and a `database`, a `mobile` and a `browser` are not,
+ * so `filled` and `strokeStyle` genuinely flip on the way between them — which
+ * is exactly why {@link c4MorphProps} is the whole preset and not `{kind, role}`.
+ */
+export const GLYPH_BODY_KINDS = new Set([
+    'person',
+    'person-ext',
+    'database',
+    'mobile',
+    'browser',
+]);
+/**
+ * Every prop a C4 shape is created with, for one kind and one box.
+ *
+ * `index` is deliberately NOT here: it is a layering statement the creation
+ * site makes about the five elements it is about to write in painting order,
+ * and it means nothing to an element that already exists.
+ *
+ * No `text` either, and that is the arrangement rather than an omission: since
+ * the PO's recette of 28/08/2026 the name is a `c4:title` CHILD, and the shape
+ * is a body and nothing else. Its text COLOUR is still seeded — an element
+ * drawn before that change carries its name here, and the node view routes a
+ * double-click to that editor for exactly those, so the words have to stay
+ * legible.
+ */
+export function c4NodeProps(kind, box) {
+    const paint = NODE_PALETTE[kind];
+    const glyphBody = GLYPH_BODY_KINDS.has(kind);
+    return {
+        type: 'c4Node',
+        kind,
+        // Semantic identity, posted next to `kind` — which stays untouched and keeps
+        // driving the rendering. The role is the authority on what the box MEANS,
+        // and it is the only thing that can say so: three of the four levels are the
+        // same rounded rectangle (see `./roles.ts`).
+        role: C4_ROLE_OF_KIND[kind],
+        shapeType: 'rect',
+        // A glyph-bodied kind paints nothing natively: the head, the block and the
+        // cylinder are drawn by the renderer, which reads `fillColor` /
+        // `strokeColor` off this same model — so both stay editable from the shape
+        // toolbar exactly like every other node's.
+        filled: !glyphBody,
+        fillColor: paint.fill,
+        strokeColor: paint.border,
+        strokeWidth: NODE_STROKE_WIDTH,
+        strokeStyle: glyphBody ? StrokeStyle.None : StrokeStyle.Solid,
+        shapeStyle: ShapeStyle.General,
+        roughness: 0,
+        // Per kind, and mostly ZERO: the stencil draws the boxed levels as plain
+        // square-cornered rectangles, and rounds only the two devices. Harmless on a
+        // glyph-bodied kind, whose native shape is invisible.
+        radius: NODE_RADIUS[kind],
+        color: paint.text,
+        fontFamily: FontFamily.Inter,
+        fontSize: TITLE_FONT_SIZE,
+        textAlign: TextAlign.Center,
+        xywh: box.xywh,
+    };
+}
+/**
+ * The box {@link c4MorphProps} hands {@link c4NodeProps} and then throws away.
+ * Never written to a document: a morph keeps the geometry the element already
+ * has, and this exists only because the one builder takes a box.
+ */
+const DISCARDED_BOX = '[0,0,0,0]';
+/** What a morph must never rewrite: identity, geometry, and the user's words. */
+const NOT_A_MORPH = ['type', 'xywh', 'text'];
+/**
+ * What a kind is worth to a shape that ALREADY EXISTS — {@link c4NodeProps}
+ * minus the three things a morph has no business touching.
+ *
+ * ## Why the whole preset, and not `{kind, role}`
+ *
+ * Because on this pack's own table it is visibly not enough. The container
+ * family — `container`, `database`, `mobile`, `browser` — is four kinds where
+ * one paints its body natively and three hand it to the renderer, so `filled`
+ * and `strokeStyle` flip between them, and two of them round their corners
+ * where the others do not ({@link NODE_RADIUS}). Morph a container to a
+ * database with two keys and the cylinder arrives with the rectangle still
+ * painted behind it. The `-ext` families are the same argument in colour: grey
+ * IS what "somebody else owns this" means, and it lives in `fillColor` /
+ * `strokeColor`.
+ */
+export function c4MorphProps(kind) {
+    // Widened to the plain record on the way in: `type` is required on what the
+    // creation builder returns, and `delete` may only take an optional key.
+    const props = {
+        ...c4NodeProps(kind, { xywh: DISCARDED_BOX }),
+    };
+    for (const key of NOT_A_MORPH)
+        delete props[key];
+    return props;
+}
+/**
+ * Every key ANY kind's props may carry — the union over the whole pack.
+ *
+ * Computed rather than listed, so a preset that starts spreading a key
+ * conditionally is covered on the day it is added rather than on the day
+ * somebody notices.
+ */
+const EVERY_MORPH_KEY = new Set(Object.keys(NODE_PALETTE).flatMap(kind => Object.keys(c4MorphProps(kind))));
+/**
+ * The fields to DELETE after morphing to `kind` — the keys some other kind
+ * writes and this one does not.
+ *
+ * EMPTY for every kind today, because no C4 preset spreads anything
+ * conditionally: all nine write the same key set with different values. Kept
+ * anyway, and derived rather than hard-coded to `[]`, for the reason BPMN's
+ * equivalent exists at all — a patch cannot express absence, and the day one
+ * kind stops writing a key the previous kind's value would otherwise stay in
+ * the Y.Map, silently in force.
+ */
+export function c4MorphClears(kind) {
+    const present = new Set(Object.keys(c4MorphProps(kind)));
+    return [...EVERY_MORPH_KEY].filter(key => !present.has(key));
+}

package/dist/profiles.d.ts

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

package/dist/profiles.js

@@ -0,0 +1,177 @@
+/**
+ * C4 validation profiles.
+ *
+ * DATA owned by the framework, like its rules and its roles. A profile is
+ * chosen per FRAME — the board, and the boundary, which are the two elements
+ * this framework's rules measure against — and the choice rides on the element
+ * itself, so two diagrams at two levels of requirement coexist on one canvas:
+ * the board somebody is still sketching stays a sketch while the one that is
+ * being handed over is held to the checklist.
+ *
+ * Registered from the flag-gated `C4ViewExtension`, beside the rules:
+ * switching the `c4` 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.
+ *
+ * ## Both tables spell out all SIXTEEN ids
+ *
+ * Every severity a user can get is either the one its rule declares or one of
+ * these lines — nothing is raised implicitly (PF9.4). Spelling them all out is
+ * what makes the level READABLE: a reviewer asking what `c4.strict` actually
+ * requires reads sixteen lines here instead of one file per rule, and a rule
+ * shipped later cannot join a level in silence.
+ */
+/**
+ * Sketch: every rule at `audit`. Findings still reach `violations$` — a host
+ * panel, a check-up and a conformance report see them — and the canvas says
+ * nothing.
+ *
+ * The DEFAULT, and deliberately so (PRD principle 3), and more deliberately
+ * here than anywhere else in the library: a C4 diagram is drawn from the
+ * outside in. The boxes go down, then the arrows, then the words, and for the
+ * whole of that every element is isolated, every arrow is unlabelled, every box
+ * is unnamed and half the links are still plain connectors somebody
+ * quick-dragged. A tool arguing with that hand is a tool switched off within
+ * the hour, and it would be arguing about a diagram the author already knows is
+ * unfinished.
+ *
+ * The sketch PRIMES: the findings are computed, collected and available the
+ * moment the author asks — through the panel, through a check-up, through the
+ * profile switch — so nothing has to be re-derived when they decide the drawing
+ * is a deliverable. Being the default also means it WRITES NOTHING: a board on
+ * `sketch` carries no profile key, so every C4 diagram ever drawn is on it,
+ * with no migration and no backfill.
+ */
+const sketch = {
+    id: 'c4.sketch',
+    framework: 'c4',
+    labelKey: 'com.labre.c4.profile.sketch',
+    fallback: 'Sketch',
+    isDefault: true,
+    rules: {
+        'c4.unlabeled-relationship': 'audit',
+        'c4.unnamed-element': 'audit',
+        'c4.untyped-link': 'audit',
+        'c4.relationship-endpoints': 'audit',
+        'c4.relationship-self-loop': 'audit',
+        'c4.isolated-system': 'audit',
+        'c4.isolated-container': 'audit',
+        'c4.isolated-component': 'audit',
+        'c4.database-initiates': 'audit',
+        'c4.homeless-component': 'audit',
+        'c4.person-in-boundary': 'audit',
+        'c4.system-in-boundary': 'audit',
+        'c4.container-in-container-boundary': 'audit',
+        'c4.component-level-skip': 'audit',
+        'c4.context-diagram-level': 'audit',
+        'c4.container-diagram-level': 'audit',
+    },
+};
+/**
+ * Strict: the diagram is a DELIVERABLE, and it is held to the review checklist.
+ *
+ * The level somebody chooses when a diagram stops being a thinking aid and
+ * becomes something another team will be handed. ELEVEN rules move to
+ * `warning`.
+ *
+ * Three of them read a question from the checklist itself (c4model.com): is
+ * every element named, is every relationship labelled, is every arrow one the
+ * model can state.
+ *
+ * Two are the LEVEL rules — `c4.context-diagram-level` and
+ * `c4.container-diagram-level` — and they are the easiest promotion in the
+ * table, because the user has already spoken: a board declaring a level is an
+ * author saying which sheet this is, and a container drawn on a sheet its own
+ * author called a context diagram is a contradiction inside one document. There
+ * is no reading under which the drawing meant it — and the one reading under
+ * which nothing should be said, a sheet whose level was never stated, is silence
+ * from the rules themselves rather than from this table.
+ *
+ * Three more are the ZOOM rules — `c4.system-in-boundary`,
+ * `c4.container-in-container-boundary` and `c4.component-level-skip`. They are
+ * promoted on the same test as everything else here: whether the diagram might
+ * honestly have meant it. None of the three can be meant. A boundary is a system
+ * or a container, so nothing inside one is a system; a container boundary IS its
+ * container, so no container goes in it; and a component framed by no container
+ * is a sheet with a level missing. Each is a drawing whose author will change it
+ * once they see it, which is the definition of a `warning` at the level where
+ * somebody has said the diagram is a deliverable.
+ *
+ * The other three — `c4.untyped-link`, `c4.relationship-self-loop` and
+ * `c4.homeless-component` — are OURS, and they are promoted anyway. Provenance
+ * and severity are ORTHOGONAL, and this table is where that shows: what decides
+ * whether a house reading bites is not where it came from but whether the
+ * diagram might honestly have meant it. A connector the model never recorded, a
+ * box drawn as using itself, a component belonging to no container — none of
+ * the three has a second reading, so at the level where somebody has said the
+ * drawing is a deliverable, saying so is the point. Each message names the rule
+ * as our convention rather than implying C4 forbids it, which is what keeps the
+ * promotion honest.
+ *
+ * Note the partition here is NOT the provenance one — eleven promoted against
+ * eleven `recommendation` rules is a coincidence of arithmetic and nothing else,
+ * since the two elevens do not hold the same rules: the three `c4.isolated-*`
+ * come from the checklist and stay remarks, while three of ours are promoted.
+ * The spec constant is called `PROMOTED` for exactly that reason.
+ *
+ * ## The five that do NOT move, and why the table spells them out
+ *
+ * Five out of sixteen, still — the two rules this slice added both moved.
+ *
+ * `c4.isolated-system`, `c4.isolated-container`, `c4.isolated-component`,
+ * `c4.database-initiates` and `c4.person-in-boundary` stay `audit` here too.
+ *
+ * The three isolation rules report a diagram that is UNFINISHED rather than
+ * wrong: an element with no arrow on it is a box whose author has not got to
+ * the arrows yet, and "not done" is what a panel is for. Promoting them would
+ * put a bracket on every box for the first minutes of every drawing, at the one
+ * level where the user has explicitly said the drawing matters.
+ *
+ * The other two are OURS rather than the checklist's — idioms of the notation,
+ * not requirements of it — and, unlike the self-loop promoted above, each has a
+ * reading under which the author is right. A store with a change feed really
+ * does push, and a person really can be drawn inside a boundary by somebody
+ * making a point about an operator embedded in a process. Both are worth
+ * remarking on and neither is something the tool should claim is a mistake, at
+ * any level. That is the line between a convention that bites and one that does
+ * not: whether the diagram might have meant it.
+ *
+ * ## Nothing is `blocking-overridable`, and nothing ever will be here
+ *
+ * Nothing in this library implements refusal — no gesture is declined anywhere
+ * — so declaring the level would be data claiming an effect that does not exist
+ * (the `wardley/rules.ts:30` promise, kept). Unlike BPMN, C4 has no rule that
+ * would move there the day refusal lands: a review checklist is a set of
+ * questions asked of a finished drawing, not a grammar that can refuse a
+ * gesture while it is being made.
+ */
+const strict = {
+    id: 'c4.strict',
+    framework: 'c4',
+    labelKey: 'com.labre.c4.profile.strict',
+    fallback: 'Review checklist',
+    rules: {
+        'c4.unlabeled-relationship': 'warning',
+        'c4.unnamed-element': 'warning',
+        'c4.untyped-link': 'warning',
+        'c4.relationship-endpoints': 'warning',
+        'c4.relationship-self-loop': 'warning',
+        'c4.homeless-component': 'warning',
+        // The three zoom rules: a drawing that contradicts the model's own levels
+        // has no second reading — see the header.
+        'c4.system-in-boundary': 'warning',
+        'c4.container-in-container-boundary': 'warning',
+        'c4.component-level-skip': 'warning',
+        // The two LEVEL rules: the author has SAID which sheet this is, and the
+        // sheet shows something that sheet does not show — see the header.
+        'c4.context-diagram-level': 'warning',
+        'c4.container-diagram-level': 'warning',
+        // The five that do not move — see the header.
+        'c4.isolated-system': 'audit',
+        'c4.isolated-container': 'audit',
+        'c4.isolated-component': 'audit',
+        'c4.database-initiates': 'audit',
+        'c4.person-in-boundary': 'audit',
+    },
+};
+export const C4_PROFILES = [sketch, strict];