@formicoidea/labre-core 0.32.0 → 0.33.0

package/dist/_pkgs/affine-model/elements/c4/boundary.js

@@ -0,0 +1,134 @@
+var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+    function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
+    var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+    var _, done = false;
+    for (var i = decorators.length - 1; i >= 0; i--) {
+        var context = {};
+        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
+        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
+        if (kind === "accessor") {
+            if (result === void 0) continue;
+            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+            if (_ = accept(result.get)) descriptor.get = _;
+            if (_ = accept(result.set)) descriptor.set = _;
+            if (_ = accept(result.init)) initializers.unshift(_);
+        }
+        else if (_ = accept(result)) {
+            if (kind === "field") initializers.unshift(_);
+            else descriptor[key] = _;
+        }
+    }
+    if (target) Object.defineProperty(target, contextIn.name, descriptor);
+    done = true;
+};
+var __runInitializers = (this && this.__runInitializers) || function (thisArg, initializers, value) {
+    var useValue = arguments.length > 2;
+    for (var i = 0; i < initializers.length; i++) {
+        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+    }
+    return useValue ? value : void 0;
+};
+import { field } from '../../../std/gfx/index.js';
+import { FrameworkBackgroundElementModel } from '../framework-background/index.js';
+/**
+ * A C4 boundary: the dashed rectangle drawn AROUND a group of elements to say
+ * "all of this is one system" (or one container). A framework background, so
+ * nodes are dropped on it and connectors never snap to it — but a transparent
+ * one, unlike every other background in the library: a boundary is drawn over
+ * the board it sits on, and an opaque card would hide the diagram it encloses.
+ *
+ * What it LOOKS like is declared, not coded: see `C4_BOUNDARY_BACKGROUND` in
+ * `@labre/affine-gfx-c4`.
+ */
+let C4BoundaryElementModel = (() => {
+    let _classSuper = FrameworkBackgroundElementModel;
+    let _name_decorators;
+    let _name_initializers = [];
+    let _name_extraInitializers = [];
+    let _resizeEnabled_decorators;
+    let _resizeEnabled_initializers = [];
+    let _resizeEnabled_extraInitializers = [];
+    let _rotate_decorators;
+    let _rotate_initializers = [];
+    let _rotate_extraInitializers = [];
+    let _xywh_decorators;
+    let _xywh_initializers = [];
+    let _xywh_extraInitializers = [];
+    let _variant_decorators;
+    let _variant_initializers = [];
+    let _variant_extraInitializers = [];
+    return class C4BoundaryElementModel extends _classSuper {
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+            _name_decorators = [field('Boundary')];
+            _resizeEnabled_decorators = [field(true)];
+            _rotate_decorators = [field(0)];
+            _xywh_decorators = [field()];
+            _variant_decorators = [field()];
+            __esDecorate(this, null, _name_decorators, { kind: "accessor", name: "name", static: false, private: false, access: { has: obj => "name" in obj, get: obj => obj.name, set: (obj, value) => { obj.name = value; } }, metadata: _metadata }, _name_initializers, _name_extraInitializers);
+            __esDecorate(this, null, _resizeEnabled_decorators, { kind: "accessor", name: "resizeEnabled", static: false, private: false, access: { has: obj => "resizeEnabled" in obj, get: obj => obj.resizeEnabled, set: (obj, value) => { obj.resizeEnabled = value; } }, metadata: _metadata }, _resizeEnabled_initializers, _resizeEnabled_extraInitializers);
+            __esDecorate(this, null, _rotate_decorators, { kind: "accessor", name: "rotate", static: false, private: false, access: { has: obj => "rotate" in obj, get: obj => obj.rotate, set: (obj, value) => { obj.rotate = value; } }, metadata: _metadata }, _rotate_initializers, _rotate_extraInitializers);
+            __esDecorate(this, null, _xywh_decorators, { kind: "accessor", name: "xywh", static: false, private: false, access: { has: obj => "xywh" in obj, get: obj => obj.xywh, set: (obj, value) => { obj.xywh = value; } }, metadata: _metadata }, _xywh_initializers, _xywh_extraInitializers);
+            __esDecorate(this, null, _variant_decorators, { kind: "accessor", name: "variant", static: false, private: false, access: { has: obj => "variant" in obj, get: obj => obj.variant, set: (obj, value) => { obj.variant = value; } }, metadata: _metadata }, _variant_initializers, _variant_extraInitializers);
+            if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        }
+        get type() {
+            return 'c4Boundary';
+        }
+        #name_accessor_storage = __runInitializers(this, _name_initializers, 'Boundary');
+        get name() { return this.#name_accessor_storage; }
+        set name(value) { this.#name_accessor_storage = value; }
+        #resizeEnabled_accessor_storage = (__runInitializers(this, _name_extraInitializers), __runInitializers(this, _resizeEnabled_initializers, true));
+        get resizeEnabled() { return this.#resizeEnabled_accessor_storage; }
+        set resizeEnabled(value) { this.#resizeEnabled_accessor_storage = value; }
+        #rotate_accessor_storage = (__runInitializers(this, _resizeEnabled_extraInitializers), __runInitializers(this, _rotate_initializers, 0));
+        get rotate() { return this.#rotate_accessor_storage; }
+        set rotate(value) { this.#rotate_accessor_storage = value; }
+        #xywh_accessor_storage = (__runInitializers(this, _rotate_extraInitializers), __runInitializers(this, _xywh_initializers, '[0,0,520,360]'));
+        get xywh() { return this.#xywh_accessor_storage; }
+        set xywh(value) { this.#xywh_accessor_storage = value; }
+        #variant_accessor_storage = (__runInitializers(this, _xywh_extraInitializers), __runInitializers(this, _variant_initializers, undefined));
+        /**
+         * The level enclosed — the only OPTIONAL field of this element, and optional
+         * on purpose.
+         *
+         * `@field()`'s `init` writes nothing for an `undefined` default, so a boundary
+         * that never states its level stays byte-identical to one created before this
+         * value existed: no schema version bump, no migration, and every document
+         * already on disk opens and paints exactly as it did. The same call
+         * `BpmnPoolElementModel.lanes` makes, for the same reason.
+         *
+         * Absent reads as `'system'` everywhere — the outermost boundary, which is the
+         * one a reader draws first and the one the default wording names.
+         */
+        get variant() { return this.#variant_accessor_storage; }
+        set variant(value) { this.#variant_accessor_storage = value; }
+        /**
+         * The variant every reader of this element should use — `variant` with its
+         * documented default already applied.
+         *
+         * Derived, not stored: nothing here reaches the document, and an element that
+         * never stated a level is untouched by the existence of this getter.
+         *
+         * It is what lets the declaration gate a piece of itself on the level
+         * (`variantProp`), which a raw optional field cannot do: an unstated `variant`
+         * stringifies to `"undefined"`, matches no declared variant, and would paint
+         * NOTHING — the trap the boundary declaration used to avoid by declaring no
+         * `variantProp` at all. Reading the default here removes the trap instead of
+         * routing round it, so the frame can finally write the bracket line the
+         * stencil puts under a boundary's name.
+         */
+        get variantOrDefault() {
+            return this.variant ?? 'system';
+        }
+        constructor() {
+            super(...arguments);
+            __runInitializers(this, _variant_extraInitializers);
+        }
+    };
+})();
+export { C4BoundaryElementModel };

package/dist/_pkgs/affine-model/elements/c4/index.d.ts

@@ -0,0 +1,3 @@
+export * from './board.js';
+export * from './boundary.js';
+export * from './node.js';

package/dist/_pkgs/affine-model/elements/c4/index.js

@@ -0,0 +1,3 @@
+export * from './board.js';
+export * from './boundary.js';
+export * from './node.js';

package/dist/_pkgs/affine-model/elements/c4/node.d.ts

@@ -0,0 +1,97 @@
+import type { PointTestOptions } from '../../../std/gfx/index.js';
+import { ShapeElementModel } from '../shape/index.js';
+/**
+ * The C4 artefacts the pack draws — the four levels of the model, plus the
+ * container flavours the official stencil gives a silhouette of their own:
+ *
+ *  - people        — `person` and `person-ext`, a head over a rounded body;
+ *  - systems       — `system` and `system-ext`, a plain rounded rectangle;
+ *  - containers    — `container`, plus `database` (a cylinder), `mobile` (a
+ *    phone bezel down the leading edge) and `browser` (a chrome band across the
+ *    top). All four are CONTAINERS: what differs is the picture, never the
+ *    level;
+ *  - components    — `component`, the innermost level C4 draws.
+ *
+ * ## Why "external" is a KIND and not a flag
+ *
+ * `person-ext` and `system-ext` are separate values rather than an `external`
+ * boolean, mirroring {@link BpmnNodeKind}'s message and timer starts: the C4
+ * stencil greys an external element out entirely — fill, border and label — so
+ * externality is a different picture, not a modifier on one. One discriminant
+ * keeps the renderer's switch total and the size / palette tables keyed the same
+ * way; a second, orthogonal flag would multiply both by two and let a
+ * combination exist that the notation has no drawing for.
+ *
+ * ## Compatibility
+ *
+ * This union is only ever WIDENED, and it is widened with new VALUES of the
+ * existing `kind` string field — no new field, no schema change, no migration
+ * and no backfill. Same promise `wardley` and `bpmn` already make.
+ */
+export type C4NodeKind = 'person' | 'person-ext' | 'system' | 'system-ext' | 'container' | 'database' | 'mobile' | 'browser' | 'component';
+/**
+ * A C4 node. Extends {@link ShapeElementModel} (a native shape) so it inherits
+ * ALL shape behaviour — editable stroke width / colours, inner text, native
+ * resize, the shape context toolbar — for free. `kind` discriminates the
+ * artefacts and drives the RENDERING alone; what a node MEANS is the `role`
+ * stamped on it at creation (`gfx/c4/src/roles.ts`).
+ *
+ * Mirrors {@link BpmnNodeElementModel}.
+ */
+export declare class C4NodeElementModel extends ShapeElementModel {
+    get type(): string;
+    /**
+     * Connector anchors are restricted to the centre, as they are for a BPMN flow
+     * object: a C4 relationship attaches to the node centre and clips at the
+     * perimeter, so an arrow between two boxes points at the boxes rather than at
+     * whichever of their twelve anchors the hand was nearest.
+     */
+    get centerAnchorOnly(): boolean;
+    /**
+     * A C4 node is SOLID whatever its `filled` flag says.
+     *
+     * `rect.includesPoint` (and `ellipse`'s, and `diamond`'s) skips the interior
+     * test for an unfilled shape and falls back to the stroke plus the tight
+     * bounding box of the text run — the behaviour that makes a hollow group let
+     * clicks through to the work it encloses. Three of the nine C4 kinds are
+     * created unfilled and unstroked on purpose (`person`, `person-ext`,
+     * `database`, and the two decorated containers): their silhouette is a head
+     * over a body, a cylinder, a phone or a browser window, none of which a native
+     * rect can be, so the GLYPH paints the body and the native shape paints
+     * nothing at all.
+     *
+     * The consequence, reported by the PO on 27/08/2026, is that those nodes could
+     * not be double-clicked into their own text editor: the body a user can
+     * plainly see was not a hit target, and only the border and the handful of
+     * characters of the label were. Pointer events reach an element view through
+     * this method (`GfxViewEventHandler`), so selecting, hovering, dragging and
+     * `dblclick` were all affected — the last one visibly.
+     *
+     * Forcing `ignoreTransparent: false` says the one thing that is true of every
+     * C4 artefact and of no BPMN group: it is a BOX, and its whole area belongs to
+     * it. Nothing here is stored — the override changes hit testing, never the
+     * document — so it applies to nodes drawn before it existed as well as after.
+     *
+     * The same latent gap exists for BPMN's `dataObject` / `dataStore`; it is not
+     * fixed there because a BPMN artifact's own answer may well be different (its
+     * `hollow` kinds want the click-through), and guessing on another pack's
+     * behalf is how a fix becomes a regression.
+     */
+    includesPoint(x: number, y: number, options: PointTestOptions): boolean;
+    /**
+     * The one field a C4 node carries, and the whole of its schema.
+     *
+     * The two other tiers of the notation — the type line and the description —
+     * are deliberately NOT fields here. They are canvas TEXT elements, grouped
+     * with the shape, and they are edited in place exactly like any other words on
+     * the canvas (PO recette, 28/08/2026). A field would have been a second place
+     * to write the same sentence, reachable only through a form, and the form is
+     * the mechanism the recette rejected: an architect writes on the picture.
+     *
+     * What that buys the document format is that this model stays exactly what it
+     * was — `kind`, on a native shape — while the component grows two more tiers.
+     * See `gfx/c4/src/actions.ts` for how the group is assembled and
+     * `gfx/c4/src/export.ts` for how it is read back.
+     */
+    accessor kind: C4NodeKind;
+}

package/dist/_pkgs/affine-model/elements/c4/node.js

@@ -0,0 +1,130 @@
+var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+    function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
+    var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+    var _, done = false;
+    for (var i = decorators.length - 1; i >= 0; i--) {
+        var context = {};
+        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
+        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
+        if (kind === "accessor") {
+            if (result === void 0) continue;
+            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+            if (_ = accept(result.get)) descriptor.get = _;
+            if (_ = accept(result.set)) descriptor.set = _;
+            if (_ = accept(result.init)) initializers.unshift(_);
+        }
+        else if (_ = accept(result)) {
+            if (kind === "field") initializers.unshift(_);
+            else descriptor[key] = _;
+        }
+    }
+    if (target) Object.defineProperty(target, contextIn.name, descriptor);
+    done = true;
+};
+var __runInitializers = (this && this.__runInitializers) || function (thisArg, initializers, value) {
+    var useValue = arguments.length > 2;
+    for (var i = 0; i < initializers.length; i++) {
+        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+    }
+    return useValue ? value : void 0;
+};
+import { field } from '../../../std/gfx/index.js';
+import { ShapeElementModel } from '../shape/index.js';
+/**
+ * A C4 node. Extends {@link ShapeElementModel} (a native shape) so it inherits
+ * ALL shape behaviour — editable stroke width / colours, inner text, native
+ * resize, the shape context toolbar — for free. `kind` discriminates the
+ * artefacts and drives the RENDERING alone; what a node MEANS is the `role`
+ * stamped on it at creation (`gfx/c4/src/roles.ts`).
+ *
+ * Mirrors {@link BpmnNodeElementModel}.
+ */
+let C4NodeElementModel = (() => {
+    let _classSuper = ShapeElementModel;
+    let _kind_decorators;
+    let _kind_initializers = [];
+    let _kind_extraInitializers = [];
+    return class C4NodeElementModel extends _classSuper {
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+            _kind_decorators = [field('system')];
+            __esDecorate(this, null, _kind_decorators, { kind: "accessor", name: "kind", static: false, private: false, access: { has: obj => "kind" in obj, get: obj => obj.kind, set: (obj, value) => { obj.kind = value; } }, metadata: _metadata }, _kind_initializers, _kind_extraInitializers);
+            if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        }
+        get type() {
+            return 'c4Node';
+        }
+        /**
+         * Connector anchors are restricted to the centre, as they are for a BPMN flow
+         * object: a C4 relationship attaches to the node centre and clips at the
+         * perimeter, so an arrow between two boxes points at the boxes rather than at
+         * whichever of their twelve anchors the hand was nearest.
+         */
+        get centerAnchorOnly() {
+            return true;
+        }
+        /**
+         * A C4 node is SOLID whatever its `filled` flag says.
+         *
+         * `rect.includesPoint` (and `ellipse`'s, and `diamond`'s) skips the interior
+         * test for an unfilled shape and falls back to the stroke plus the tight
+         * bounding box of the text run — the behaviour that makes a hollow group let
+         * clicks through to the work it encloses. Three of the nine C4 kinds are
+         * created unfilled and unstroked on purpose (`person`, `person-ext`,
+         * `database`, and the two decorated containers): their silhouette is a head
+         * over a body, a cylinder, a phone or a browser window, none of which a native
+         * rect can be, so the GLYPH paints the body and the native shape paints
+         * nothing at all.
+         *
+         * The consequence, reported by the PO on 27/08/2026, is that those nodes could
+         * not be double-clicked into their own text editor: the body a user can
+         * plainly see was not a hit target, and only the border and the handful of
+         * characters of the label were. Pointer events reach an element view through
+         * this method (`GfxViewEventHandler`), so selecting, hovering, dragging and
+         * `dblclick` were all affected — the last one visibly.
+         *
+         * Forcing `ignoreTransparent: false` says the one thing that is true of every
+         * C4 artefact and of no BPMN group: it is a BOX, and its whole area belongs to
+         * it. Nothing here is stored — the override changes hit testing, never the
+         * document — so it applies to nodes drawn before it existed as well as after.
+         *
+         * The same latent gap exists for BPMN's `dataObject` / `dataStore`; it is not
+         * fixed there because a BPMN artifact's own answer may well be different (its
+         * `hollow` kinds want the click-through), and guessing on another pack's
+         * behalf is how a fix becomes a regression.
+         */
+        includesPoint(x, y, options) {
+            return super.includesPoint(x, y, {
+                ...options,
+                ignoreTransparent: false,
+            });
+        }
+        #kind_accessor_storage = __runInitializers(this, _kind_initializers, 'system');
+        /**
+         * The one field a C4 node carries, and the whole of its schema.
+         *
+         * The two other tiers of the notation — the type line and the description —
+         * are deliberately NOT fields here. They are canvas TEXT elements, grouped
+         * with the shape, and they are edited in place exactly like any other words on
+         * the canvas (PO recette, 28/08/2026). A field would have been a second place
+         * to write the same sentence, reachable only through a form, and the form is
+         * the mechanism the recette rejected: an architect writes on the picture.
+         *
+         * What that buys the document format is that this model stays exactly what it
+         * was — `kind`, on a native shape — while the component grows two more tiers.
+         * See `gfx/c4/src/actions.ts` for how the group is assembled and
+         * `gfx/c4/src/export.ts` for how it is read back.
+         */
+        get kind() { return this.#kind_accessor_storage; }
+        set kind(value) { this.#kind_accessor_storage = value; }
+        constructor() {
+            super(...arguments);
+            __runInitializers(this, _kind_extraInitializers);
+        }
+    };
+})();
+export { C4NodeElementModel };

package/dist/_pkgs/affine-model/elements/connector/connector.js

@@ -33,7 +33,7 @@ var __runInitializers = (this && this.__runInitializers) || function (thisArg, i
     return useValue ? value : void 0;
 };
 import { Bound, curveIntersects, getBezierNearestPoint, getBezierNearestTime, getBezierParameters, getBezierPoint, linePolylineIntersects, PointLocation, Polyline, polyLineNearestPoint, Vec, } from '../../../global/gfx/index.js';
-import { derive, field, GfxPrimitiveElementModel, local, } from '../../../std/gfx/index.js';
+import { derive, field, GfxPrimitiveElementModel, local } from '../../../std/gfx/index.js';
 import * as Y from 'yjs';
 import { CONNECTOR_LABEL_MAX_WIDTH, ConnectorLabelOffsetAnchor, ConnectorMode, DEFAULT_CONNECTOR_MODE, DEFAULT_ROUGHNESS, FontFamily, FontStyle, FontWeight, StrokeStyle, TextAlign, } from '../../consts/index.js';
 import { DefaultTheme } from '../../themes/index.js';

package/dist/_pkgs/affine-model/elements/context-map/context-map.d.ts

@@ -0,0 +1,27 @@
+import type { SerializedXYWH } from '../../../global/gfx/index.js';
+import { FrameworkBackgroundElementModel } from '../framework-background/index.js';
+import type { FrameworkBackgroundProps } from '../framework-background/index.js';
+export type ContextMapBoardProps = FrameworkBackgroundProps;
+/**
+ * The Context Map board: the white card a Context Map is drawn ON.
+ *
+ * Deliberately the emptiest background in the library — no axis, no zone, no
+ * label. A Context Map has no frame of reference: nothing about where a bounded
+ * context sits on the sheet means anything, and drawing graduations would invent
+ * a semantic the framework does not have. What the board IS for is the FRAME:
+ * it carries the `context-map:board` role, which is what lets a rule say "this
+ * context is off the map" and what gives a per-map validation profile something
+ * to be written on.
+ *
+ * Adds no field of its own beyond the primitive's `resizeEnabled`, so a board is
+ * byte-identical to what {@link FrameworkBackgroundElementModel} already
+ * persists. It is created 1400 × 900 and freely resizable in both directions —
+ * a context map grows sideways as contexts are found, and locking its
+ * proportion would fight the hand.
+ */
+export declare class ContextMapBoardElementModel extends FrameworkBackgroundElementModel<ContextMapBoardProps> {
+    get type(): string;
+    accessor resizeEnabled: boolean;
+    accessor rotate: number;
+    accessor xywh: SerializedXYWH;
+}

package/dist/_pkgs/affine-model/elements/context-map/context-map.js

@@ -0,0 +1,94 @@
+var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+    function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
+    var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+    var _, done = false;
+    for (var i = decorators.length - 1; i >= 0; i--) {
+        var context = {};
+        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
+        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
+        if (kind === "accessor") {
+            if (result === void 0) continue;
+            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+            if (_ = accept(result.get)) descriptor.get = _;
+            if (_ = accept(result.set)) descriptor.set = _;
+            if (_ = accept(result.init)) initializers.unshift(_);
+        }
+        else if (_ = accept(result)) {
+            if (kind === "field") initializers.unshift(_);
+            else descriptor[key] = _;
+        }
+    }
+    if (target) Object.defineProperty(target, contextIn.name, descriptor);
+    done = true;
+};
+var __runInitializers = (this && this.__runInitializers) || function (thisArg, initializers, value) {
+    var useValue = arguments.length > 2;
+    for (var i = 0; i < initializers.length; i++) {
+        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+    }
+    return useValue ? value : void 0;
+};
+import { field } from '../../../std/gfx/index.js';
+import { FrameworkBackgroundElementModel } from '../framework-background/index.js';
+/**
+ * The Context Map board: the white card a Context Map is drawn ON.
+ *
+ * Deliberately the emptiest background in the library — no axis, no zone, no
+ * label. A Context Map has no frame of reference: nothing about where a bounded
+ * context sits on the sheet means anything, and drawing graduations would invent
+ * a semantic the framework does not have. What the board IS for is the FRAME:
+ * it carries the `context-map:board` role, which is what lets a rule say "this
+ * context is off the map" and what gives a per-map validation profile something
+ * to be written on.
+ *
+ * Adds no field of its own beyond the primitive's `resizeEnabled`, so a board is
+ * byte-identical to what {@link FrameworkBackgroundElementModel} already
+ * persists. It is created 1400 × 900 and freely resizable in both directions —
+ * a context map grows sideways as contexts are found, and locking its
+ * proportion would fight the hand.
+ */
+let ContextMapBoardElementModel = (() => {
+    let _classSuper = FrameworkBackgroundElementModel;
+    let _resizeEnabled_decorators;
+    let _resizeEnabled_initializers = [];
+    let _resizeEnabled_extraInitializers = [];
+    let _rotate_decorators;
+    let _rotate_initializers = [];
+    let _rotate_extraInitializers = [];
+    let _xywh_decorators;
+    let _xywh_initializers = [];
+    let _xywh_extraInitializers = [];
+    return class ContextMapBoardElementModel extends _classSuper {
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+            _resizeEnabled_decorators = [field(true)];
+            _rotate_decorators = [field(0)];
+            _xywh_decorators = [field()];
+            __esDecorate(this, null, _resizeEnabled_decorators, { kind: "accessor", name: "resizeEnabled", static: false, private: false, access: { has: obj => "resizeEnabled" in obj, get: obj => obj.resizeEnabled, set: (obj, value) => { obj.resizeEnabled = value; } }, metadata: _metadata }, _resizeEnabled_initializers, _resizeEnabled_extraInitializers);
+            __esDecorate(this, null, _rotate_decorators, { kind: "accessor", name: "rotate", static: false, private: false, access: { has: obj => "rotate" in obj, get: obj => obj.rotate, set: (obj, value) => { obj.rotate = value; } }, metadata: _metadata }, _rotate_initializers, _rotate_extraInitializers);
+            __esDecorate(this, null, _xywh_decorators, { kind: "accessor", name: "xywh", static: false, private: false, access: { has: obj => "xywh" in obj, get: obj => obj.xywh, set: (obj, value) => { obj.xywh = value; } }, metadata: _metadata }, _xywh_initializers, _xywh_extraInitializers);
+            if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        }
+        get type() {
+            return 'contextMap';
+        }
+        #resizeEnabled_accessor_storage = __runInitializers(this, _resizeEnabled_initializers, true);
+        get resizeEnabled() { return this.#resizeEnabled_accessor_storage; }
+        set resizeEnabled(value) { this.#resizeEnabled_accessor_storage = value; }
+        #rotate_accessor_storage = (__runInitializers(this, _resizeEnabled_extraInitializers), __runInitializers(this, _rotate_initializers, 0));
+        get rotate() { return this.#rotate_accessor_storage; }
+        set rotate(value) { this.#rotate_accessor_storage = value; }
+        #xywh_accessor_storage = (__runInitializers(this, _rotate_extraInitializers), __runInitializers(this, _xywh_initializers, '[0,0,1400,900]'));
+        get xywh() { return this.#xywh_accessor_storage; }
+        set xywh(value) { this.#xywh_accessor_storage = value; }
+        constructor() {
+            super(...arguments);
+            __runInitializers(this, _xywh_extraInitializers);
+        }
+    };
+})();
+export { ContextMapBoardElementModel };

package/dist/_pkgs/affine-model/elements/context-map/index.d.ts

@@ -0,0 +1 @@
+export * from './context-map.js';

package/dist/_pkgs/affine-model/elements/context-map/index.js

@@ -0,0 +1 @@
+export * from './context-map.js';

package/dist/_pkgs/affine-model/elements/core-domain/core-domain.d.ts

@@ -1,14 +1,23 @@
-import type { IVec, SerializedXYWH } from '../../../global/gfx/index.js';
-import { Bound } from '../../../global/gfx/index.js';
-import type { BaseElementProps } from '../../../std/gfx/index.js';
-import { GfxPrimitiveElementModel } from '../../../std/gfx/index.js';
-export type CoreDomainChartProps = BaseElementProps & {
-    /** When false the resize handles are hidden — toggled from the toolbar. */
-    resizeEnabled?: boolean;
+import type { SerializedXYWH } from '../../../global/gfx/index.js';
+import { FrameworkBackgroundElementModel } from '../framework-background/index.js';
+import type { FrameworkBackgroundProps } from '../framework-background/index.js';
+/**
+ * Which READING of the chart this instance is turned to.
+ *
+ * `classic` is the DDD Crew chart everybody knows — Generic / Supporting / Core
+ * over Complexity × Business differentiation. `migration` keeps the very same
+ * frame and names its four quadrants after the migration conversation instead
+ * (low-hanging fruit, risk-seeking, risk-averse, last toothpaste), which is why
+ * it is a variant of one background and not a second element type.
+ */
+export type CoreDomainVariant = 'classic' | 'migration';
+export type CoreDomainChartProps = FrameworkBackgroundProps & {
     /** When false the translucent Core / Supporting / Generic zone bands are hidden. */
     showZones?: boolean;
     /** When false the axis titles, Low/High ticks and zone names are hidden. */
     showLabels?: boolean;
+    /** Which reading of the chart is drawn. */
+    variant?: CoreDomainVariant;
 };
 /**
  * The Core Domain Chart background (DDD Crew): the two axes (Complexity ×
@@ -16,21 +25,29 @@ export type CoreDomainChartProps = BaseElementProps & {
  * Generic / Supporting / Core zone bands. The user places sub-domain dots,
  * movement arrows and the Notation legend on top of it.
  *
- * Mirrors the Wardley / EDGY / Cynefin backgrounds: extends
- * {@link GfxPrimitiveElementModel} so it inherits selection, move, copy/paste,
- * duplicate, align and undo/redo. Authored in a fixed reference space and scaled
- * uniformly to the element bounds by the renderer.
+ * An INSTANCE of the framework-background primitive
+ * ({@link FrameworkBackgroundElementModel}): the geometry and the passive-canvas
+ * behaviour come from the primitive — which declares the very same
+ * `connectable` getter and the very same four geometry overrides this class
+ * used to spell out — and what the chart LOOKS like comes from the
+ * `CORE_DOMAIN_BACKGROUND` declaration in `@labre/affine-gfx-ddd-core-domain`.
+ *
+ * The fields below are the persisted document and are NOT the primitive's
+ * business: the base swap adds no field, renames none and changes no default,
+ * so a chart authored before it is byte-identical to one authored after.
  */
-export declare class CoreDomainChartElementModel extends GfxPrimitiveElementModel<CoreDomainChartProps> {
+export declare class CoreDomainChartElementModel extends FrameworkBackgroundElementModel<CoreDomainChartProps> {
     get type(): string;
-    get connectable(): boolean;
-    containsBound(bounds: Bound): boolean;
-    getLineIntersections(start: IVec, end: IVec): import("../../../global/gfx/index.js").PointLocation[] | null;
-    getNearestPoint(point: IVec): IVec;
-    includesPoint(x: number, y: number): boolean;
     accessor resizeEnabled: boolean;
     accessor showZones: boolean;
     accessor showLabels: boolean;
+    /**
+     * A HARD default, on the Wardley `variant` pattern: `classic` is written into
+     * the Y.Map at creation and is also what an older chart — which carries no
+     * such key at all — reads back as. Both roads lead to the chart the user has
+     * always seen, so the field ships with no migration and no backfill.
+     */
+    accessor variant: CoreDomainVariant;
     accessor rotate: number;
     accessor xywh: SerializedXYWH;
 }