@formicoidea/labre-core 0.41.0 → 0.42.0

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

@@ -0,0 +1,190 @@
+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 { Bound, rotatePoint } from '../../../global/gfx/index.js';
+import { field } from '../../../std/gfx/index.js';
+import { ShapeElementModel } from '../shape/index.js';
+import { umlInLifelineHead, umlLifelineHeadRect } from './lifeline.js';
+/**
+ * A UML 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/uml/src/roles.ts`).
+ *
+ * Mirrors {@link C4NodeElementModel}.
+ */
+let UmlNodeElementModel = (() => {
+    let _classSuper = ShapeElementModel;
+    let _kind_decorators;
+    let _kind_initializers = [];
+    let _kind_extraInitializers = [];
+    return class UmlNodeElementModel extends _classSuper {
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+            _kind_decorators = [field('class')];
+            __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 'umlNode';
+        }
+        /**
+         * Connector anchors are restricted to the centre, as they are for a C4 node
+         * and for a BPMN flow object: a UML relationship attaches to the node centre
+         * and clips at the perimeter, so an association between two classifiers
+         * points at the classifiers rather than at whichever of their twelve anchors
+         * the hand was nearest.
+         *
+         * ONE kind says otherwise, and the notation is why. A message in a sequence
+         * diagram attaches at a HEIGHT on its lifeline's spine — that height is WHEN
+         * it happens, and it is the whole of what a sequence diagram says (§17.4.4).
+         * Snapping every message to a 600-unit column's centre would stack the entire
+         * conversation on one horizontal line. So a `lifeline` keeps its native
+         * perimeter anchors, which lie on the column's left and right edges, 8 units
+         * either side of the spine: exactly where every UML tool draws them.
+         */
+        get centerAnchorOnly() {
+            return this.kind !== 'lifeline';
+        }
+        /**
+         * A lifeline's bound includes its HEAD; every other kind's is its box.
+         *
+         * §17.3.4 draws a lifeline as a named rectangle with a dashed line falling
+         * out of its bottom, and the element is the COLUMN the line runs down — 16
+         * units wide, so that a connector's native anchors land on the spine rather
+         * than 80 units off it. The head is 160 wide, so it hangs 72 units off each
+         * side of the element the platform knows about.
+         *
+         * Everything that measures an element measures `elementBound`: the selection
+         * rectangle, the marquee, "fit to frame", the group's own box. Without this
+         * override all of them would stop at the column, and a user would see a named
+         * box with a selection outline drawn down the middle of it.
+         *
+         * Nothing here is stored — it is derived from the element's own geometry — so
+         * it applies to a lifeline drawn before the override existed as well as
+         * after.
+         */
+        get elementBound() {
+            if (this.kind !== 'lifeline')
+                return super.elementBound;
+            const head = umlLifelineHeadRect(this);
+            if (!head)
+                return super.elementBound;
+            const [x, y, w, h] = this.deserializedXYWH;
+            // The union, in the element's own frame: the column plus the head that
+            // overflows it. The head is flush with the top and centred, so only the two
+            // horizontal edges can move.
+            const left = Math.min(0, head.x);
+            const right = Math.max(w, head.x + head.w);
+            const local = [
+                [x + left, y],
+                [x + right, y],
+                [x + right, y + h],
+                [x + left, y + h],
+            ];
+            const rotate = this.rotate ?? 0;
+            const points = rotate
+                ? local.map(point => rotatePoint(point, [x + w / 2, y + h / 2], rotate))
+                : local;
+            const xs = points.map(point => point[0]);
+            const ys = points.map(point => point[1]);
+            const minX = Math.min(...xs);
+            const minY = Math.min(...ys);
+            return new Bound(minX, minY, Math.max(...xs) - minX, Math.max(...ys) - minY);
+        }
+        /**
+         * A UML node is SOLID whatever its `filled` flag says.
+         *
+         * `rect.includesPoint` (and `ellipse`'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. Several UML kinds are created unfilled and
+         * unstroked on purpose: a `package` is a tabbed folder, a `note` a rectangle
+         * with a folded corner, an `actor` a stick figure, none of which a native
+         * rect can be, so the GLYPH paints the body and the native shape paints
+         * nothing at all.
+         *
+         * The consequence, the one the PO reported against C4 on 27/08/2026, is that
+         * such nodes cannot be double-clicked into their own text editor: the body a
+         * user can plainly see is not a hit target, and only the border and the
+         * handful of characters of the label are. Pointer events reach an element
+         * view through this method (`GfxViewEventHandler`), so selecting, hovering,
+         * dragging and `dblclick` are all affected — the last one visibly.
+         *
+         * Forcing `ignoreTransparent: false` says the one thing that is true of every
+         * UML artefact: 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.
+         */
+        includesPoint(x, y, options) {
+            if (super.includesPoint(x, y, {
+                ...options,
+                ignoreTransparent: false,
+            })) {
+                return true;
+            }
+            // …plus the one carve-out the pack keeps: a lifeline's HEAD, which is the
+            // part of it a user actually aims at (§17.3.4). The column the element is
+            // is 16 units wide — a hair at any realistic zoom — and the named box over
+            // its top is 160. Without this the head would be unclickable, which is the
+            // same failure the diagram frame's heading band would have had.
+            return this.kind === 'lifeline' && umlInLifelineHead(this, x, y);
+        }
+        #kind_accessor_storage = __runInitializers(this, _kind_initializers, 'class');
+        /**
+         * The one field a UML node carries, and the whole of its schema.
+         *
+         * The labels a classifier shows — its name, its attribute compartment, its
+         * operation compartment — 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 (R16, and the PO recette of 28/08/2026
+         * that settled it for C4's type line and description). 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
+         * is — `kind`, on a native shape — however many compartments the component
+         * grows.
+         */
+        get kind() { return this.#kind_accessor_storage; }
+        set kind(value) { this.#kind_accessor_storage = value; }
+        constructor() {
+            super(...arguments);
+            __runInitializers(this, _kind_extraInitializers);
+        }
+    };
+})();
+export { UmlNodeElementModel };

package/dist/_pkgs/affine-model/elements/uml/partition.d.ts

@@ -0,0 +1,106 @@
+import type { SerializedXYWH } from '../../../global/gfx/index.js';
+import type { PointTestOptions } from '../../../std/gfx/index.js';
+import type { FrameworkBackgroundProps } from '../framework-background/index.js';
+import { FrameworkBackgroundElementModel } from '../framework-background/index.js';
+/**
+ * Height of a partition's NAME BAND — the strip its name is written in, in
+ * model units.
+ *
+ * Declared HERE, in the model, and re-exported by `@labre/affine-gfx-uml`, for
+ * the reason {@link UML_FRAME_BAND_HEIGHT} is: the partition's own hit test
+ * reads it (a swimlane is clickable by its header as well as by its border),
+ * and `affine-model` cannot reach into `affine-block-surface` where the
+ * declaration is resolved. One number, owned by the layer that both the
+ * declaration and the hit test can read.
+ *
+ * It is the band's THICKNESS whichever edge the band is on — the top for a
+ * vertical lane, the left for a horizontal one — because §15.6.4 draws one
+ * header strip and turns it with the lane rather than resizing it.
+ *
+ * 36 against the diagram frame's 44: a partition header is a name and not a
+ * `<kind> <name>` heading, and it is written inside a lane that already sits on
+ * a sheet, so it reads as a subdivision rather than as a second sheet.
+ */
+export declare const UML_PARTITION_BAND = 36;
+/**
+ * Which way a partition is sliced — the one thing §15.6.4 lets an author choose
+ * about a swimlane, and the thing that decides which edge the header is on.
+ *
+ * `vertical` is a COLUMN: a tall lane with its name across the top, which is how
+ * nearly every activity diagram anybody draws is laid out (the flow runs down,
+ * the responsibilities run across). `horizontal` is a ROW, name up the left
+ * edge, for the diagrams whose flow runs left to right.
+ *
+ * Two values and no more: §15.6.4 also draws a two-dimensional partition GRID,
+ * and that is a phase-3 refinement — a grid is not a third orientation of one
+ * lane, it is lanes crossed with lanes.
+ */
+export type UmlPartitionOrientation = 'vertical' | 'horizontal';
+export type UmlPartitionProps = FrameworkBackgroundProps & {
+    /** The partition name, written in its band — edited inline on dblclick. */
+    name?: string;
+    /** Which edge the band is on, and therefore which way the lane runs. */
+    orientation?: UmlPartitionOrientation;
+};
+/**
+ * An activity PARTITION — the swimlane of UML 2.5.1 §15.6.4: the strip drawn
+ * across an activity diagram saying who (or what) is responsible for the
+ * actions inside it.
+ *
+ * A framework background, so actions are dropped on it and connectors never
+ * snap to it — but a TRANSPARENT one, like {@link UmlSubjectElementModel} and
+ * for the same reason: a lane is drawn over an activity diagram that is already
+ * there, and an opaque card would hide the very flow it is attributing.
+ * Membership, as for every board in the library, is computed from geometry at
+ * read time (R11) — an action belongs to the lane its CENTRE is in, and nothing
+ * is stored on either element.
+ *
+ * ## Why a partition is an element and not a field on the frame
+ *
+ * Because a frame cannot grow a field without an ADR (the document format is a
+ * red zone), and because the notation does not put it there either: §15.6.4
+ * draws partitions as rectangles ON the diagram, freely positioned, freely
+ * resized, and an activity diagram may carry none, one, or a dozen. A `lanes`
+ * array on `umlDiagram` would have been a second geometry to keep in step with
+ * the one the user drags.
+ *
+ * What it LOOKS like is declared, not coded: see `UML_PARTITION_FRAME_V` and
+ * `UML_PARTITION_FRAME_H` in `@labre/affine-gfx-uml`.
+ */
+export declare class UmlPartitionElementModel extends FrameworkBackgroundElementModel<UmlPartitionProps> {
+    get type(): string;
+    accessor name: string;
+    /**
+     * Which edge the name band is on — REQUIRED, with `vertical` as the default.
+     *
+     * Required for the reason `UmlDiagramElementModel.kind` is: it is part of the
+     * NOTATION rather than a claim an author may decline to make. A partition with
+     * no orientation has no header edge, so there would be nowhere to write its
+     * name and nowhere to double-click to change it.
+     */
+    accessor orientation: UmlPartitionOrientation;
+    accessor resizeEnabled: boolean;
+    accessor rotate: number;
+    /**
+     * Tall and narrow: the default is a COLUMN, because the default orientation
+     * is vertical and a vertical lane is a strip an activity flows DOWN. Wide
+     * enough for an action box (160) with room either side of it, and as tall as
+     * the diagram frame it is dropped on.
+     */
+    accessor xywh: SerializedXYWH;
+    /**
+     * A partition is picked by its BORDER — and by its NAME BAND, the one
+     * carve-out it keeps, on whichever edge its orientation puts it.
+     *
+     * The same carve-out the diagram frame makes and for the same reason: the band
+     * is the only part of the lane that is the LANE rather than the flow drawn in
+     * it. Without it the header would be unreachable, a background being picked by
+     * its border alone — and a transparent lane's border is a thin line round a
+     * region the user thinks of as a column.
+     *
+     * Nothing below the band is claimed, which matters more here than on the sheet:
+     * a partition is drawn OVER actions, so every point that is not its own
+     * furniture has to fall through to whatever is under the pointer.
+     */
+    includesPoint(x: number, y: number, options?: PointTestOptions): boolean;
+}

package/dist/_pkgs/affine-model/elements/uml/partition.js

@@ -0,0 +1,172 @@
+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';
+import { umlInNameBand } from './band.js';
+/**
+ * Height of a partition's NAME BAND — the strip its name is written in, in
+ * model units.
+ *
+ * Declared HERE, in the model, and re-exported by `@labre/affine-gfx-uml`, for
+ * the reason {@link UML_FRAME_BAND_HEIGHT} is: the partition's own hit test
+ * reads it (a swimlane is clickable by its header as well as by its border),
+ * and `affine-model` cannot reach into `affine-block-surface` where the
+ * declaration is resolved. One number, owned by the layer that both the
+ * declaration and the hit test can read.
+ *
+ * It is the band's THICKNESS whichever edge the band is on — the top for a
+ * vertical lane, the left for a horizontal one — because §15.6.4 draws one
+ * header strip and turns it with the lane rather than resizing it.
+ *
+ * 36 against the diagram frame's 44: a partition header is a name and not a
+ * `<kind> <name>` heading, and it is written inside a lane that already sits on
+ * a sheet, so it reads as a subdivision rather than as a second sheet.
+ */
+export const UML_PARTITION_BAND = 36;
+/**
+ * An activity PARTITION — the swimlane of UML 2.5.1 §15.6.4: the strip drawn
+ * across an activity diagram saying who (or what) is responsible for the
+ * actions inside it.
+ *
+ * A framework background, so actions are dropped on it and connectors never
+ * snap to it — but a TRANSPARENT one, like {@link UmlSubjectElementModel} and
+ * for the same reason: a lane is drawn over an activity diagram that is already
+ * there, and an opaque card would hide the very flow it is attributing.
+ * Membership, as for every board in the library, is computed from geometry at
+ * read time (R11) — an action belongs to the lane its CENTRE is in, and nothing
+ * is stored on either element.
+ *
+ * ## Why a partition is an element and not a field on the frame
+ *
+ * Because a frame cannot grow a field without an ADR (the document format is a
+ * red zone), and because the notation does not put it there either: §15.6.4
+ * draws partitions as rectangles ON the diagram, freely positioned, freely
+ * resized, and an activity diagram may carry none, one, or a dozen. A `lanes`
+ * array on `umlDiagram` would have been a second geometry to keep in step with
+ * the one the user drags.
+ *
+ * What it LOOKS like is declared, not coded: see `UML_PARTITION_FRAME_V` and
+ * `UML_PARTITION_FRAME_H` in `@labre/affine-gfx-uml`.
+ */
+let UmlPartitionElementModel = (() => {
+    let _classSuper = FrameworkBackgroundElementModel;
+    let _name_decorators;
+    let _name_initializers = [];
+    let _name_extraInitializers = [];
+    let _orientation_decorators;
+    let _orientation_initializers = [];
+    let _orientation_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 = [];
+    return class UmlPartitionElementModel extends _classSuper {
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+            _name_decorators = [field('Partition')];
+            _orientation_decorators = [field('vertical')];
+            _resizeEnabled_decorators = [field(true)];
+            _rotate_decorators = [field(0)];
+            _xywh_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, _orientation_decorators, { kind: "accessor", name: "orientation", static: false, private: false, access: { has: obj => "orientation" in obj, get: obj => obj.orientation, set: (obj, value) => { obj.orientation = value; } }, metadata: _metadata }, _orientation_initializers, _orientation_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);
+            if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        }
+        get type() {
+            return 'umlPartition';
+        }
+        #name_accessor_storage = __runInitializers(this, _name_initializers, 'Partition');
+        get name() { return this.#name_accessor_storage; }
+        set name(value) { this.#name_accessor_storage = value; }
+        #orientation_accessor_storage = (__runInitializers(this, _name_extraInitializers), __runInitializers(this, _orientation_initializers, 'vertical'));
+        /**
+         * Which edge the name band is on — REQUIRED, with `vertical` as the default.
+         *
+         * Required for the reason `UmlDiagramElementModel.kind` is: it is part of the
+         * NOTATION rather than a claim an author may decline to make. A partition with
+         * no orientation has no header edge, so there would be nowhere to write its
+         * name and nowhere to double-click to change it.
+         */
+        get orientation() { return this.#orientation_accessor_storage; }
+        set orientation(value) { this.#orientation_accessor_storage = value; }
+        #resizeEnabled_accessor_storage = (__runInitializers(this, _orientation_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,360,900]'));
+        /**
+         * Tall and narrow: the default is a COLUMN, because the default orientation
+         * is vertical and a vertical lane is a strip an activity flows DOWN. Wide
+         * enough for an action box (160) with room either side of it, and as tall as
+         * the diagram frame it is dropped on.
+         */
+        get xywh() { return this.#xywh_accessor_storage; }
+        set xywh(value) { this.#xywh_accessor_storage = value; }
+        /**
+         * A partition is picked by its BORDER — and by its NAME BAND, the one
+         * carve-out it keeps, on whichever edge its orientation puts it.
+         *
+         * The same carve-out the diagram frame makes and for the same reason: the band
+         * is the only part of the lane that is the LANE rather than the flow drawn in
+         * it. Without it the header would be unreachable, a background being picked by
+         * its border alone — and a transparent lane's border is a thin line round a
+         * region the user thinks of as a column.
+         *
+         * Nothing below the band is claimed, which matters more here than on the sheet:
+         * a partition is drawn OVER actions, so every point that is not its own
+         * furniture has to fall through to whatever is under the pointer.
+         */
+        includesPoint(x, y, options) {
+            if (super.includesPoint(x, y, options))
+                return true;
+            return umlInNameBand(this, this.orientation === 'horizontal' ? 'left' : 'top', UML_PARTITION_BAND, x, y);
+        }
+        constructor() {
+            super(...arguments);
+            __runInitializers(this, _xywh_extraInitializers);
+        }
+    };
+})();
+export { UmlPartitionElementModel };

package/dist/_pkgs/affine-model/elements/uml/region.d.ts

@@ -0,0 +1,75 @@
+import type { SerializedXYWH } from '../../../global/gfx/index.js';
+import type { PointTestOptions } from '../../../std/gfx/index.js';
+import type { FrameworkBackgroundProps } from '../framework-background/index.js';
+import { FrameworkBackgroundElementModel } from '../framework-background/index.js';
+/**
+ * Height of a region's NAME BAND — the strip its name is written in, in model
+ * units.
+ *
+ * Owned by the model for the reason {@link UML_PARTITION_BAND} is: the region's
+ * own hit test reads it, and `affine-model` cannot reach into the package where
+ * the declaration is resolved. The same 36 the partition uses, and deliberately
+ * so — the two are the same piece of furniture, a name written in a strip along
+ * the top of a transparent frame, and two numbers would drift.
+ */
+export declare const UML_REGION_BAND = 36;
+export type UmlRegionProps = FrameworkBackgroundProps & {
+    /** The state name, written in the band — edited inline on dblclick. */
+    name?: string;
+};
+/**
+ * A COMPOSITE STATE — the region of UML 2.5.1 §14.2.4: the rounded rectangle
+ * drawn round the sub-states of a state that has its own state machine inside
+ * it.
+ *
+ * A framework background, transparent like {@link UmlPartitionElementModel}: it
+ * is drawn OVER states that are already there, and membership is geometry at
+ * read time (R11).
+ *
+ * ## Why a composite state IS the region, rather than a state with regions in it
+ *
+ * The metamodel has two objects — a State that `isComposite`, and the Regions it
+ * owns — and the notation draws ONE: a rounded rectangle with the state's name
+ * at the top and the sub-machine inside (§14.2.4, Figure 14.6). A drawing tool
+ * that made the author place a `state` node and then a `umlRegion` inside it
+ * would be asking them to draw two things to get one picture, and would leave
+ * every rule with two elements to decide which of them the composite state is.
+ *
+ * So this element IS the composite state: it carries the name, it draws the
+ * rounded rectangle, and its sub-states sit inside it by geometry.
+ *
+ * ## The ceiling, stated out loud
+ *
+ * ORTHOGONAL regions — a composite state cut into concurrent regions by dashed
+ * separators (§14.2.4, Figure 14.8) — are NOT drawn. One region per composite
+ * state is what this element is; a second one is a phase-3 refinement, and it
+ * will arrive the way the BPMN pool's lanes did (an instance partition on the
+ * declaration) rather than as a field added here in a hurry.
+ *
+ * What it LOOKS like is declared, not coded: see `UML_REGION_FRAME` in
+ * `@labre/affine-gfx-uml`.
+ */
+export declare class UmlRegionElementModel extends FrameworkBackgroundElementModel<UmlRegionProps> {
+    get type(): string;
+    /**
+     * `State`, not `Region`: this element IS the composite state on the page, and
+     * a fresh one that called itself a Region would be naming the metamodel
+     * object rather than the thing the author drew (see the header).
+     */
+    accessor name: string;
+    accessor resizeEnabled: boolean;
+    accessor rotate: number;
+    /** Room for a small sub-machine — an initial, two states and a final. */
+    accessor xywh: SerializedXYWH;
+    /**
+     * Picked by its BORDER and by its NAME BAND — the carve-out the diagram frame
+     * and the partition both make, and for the same reason: the band is the only
+     * part of the composite state that is the STATE rather than the sub-machine
+     * drawn inside it.
+     *
+     * Always the TOP edge: unlike a partition, a composite state has no
+     * orientation to turn — §14.2.4 writes its name across the top and nowhere
+     * else.
+     */
+    includesPoint(x: number, y: number, options?: PointTestOptions): boolean;
+}