@formicoidea/labre-core 0.40.0 → 0.42.0

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

@@ -0,0 +1,142 @@
+import { Bound } from '../../../global/gfx/index.js';
+import type { PointTestOptions } from '../../../std/gfx/index.js';
+import { ShapeElementModel } from '../shape/index.js';
+/**
+ * The UML artefacts the pack draws. Each maps onto a native shape, decorated by
+ * a glyph where the notation asks for one:
+ *
+ *  - classifiers  — `class`, `interface` and `enumeration`, the compartmented
+ *    rectangle of UML 2.5.1 §11.4, distinguished by the keyword above the name;
+ *  - instances    — `object`, the same rectangle with an underlined
+ *    `name : Type` (§11.6);
+ *  - containers   — `package`, the tabbed folder (§12.2);
+ *  - annotations  — `note`, the folded-corner rectangle of Annex A;
+ *  - use cases    — `actor`, the stick figure, and `use-case`, the ellipse
+ *    (§18.1);
+ *  - components   — `component`, the rectangle with the two-tabbed icon in its
+ *    corner (§11.6.4), its `port` (§11.3.4), and the two interface glyphs that
+ *    hang off it: `provided-interface`, the lollipop, and `required-interface`,
+ *    the socket (§10.4.4);
+ *  - deployments  — `artifact`, the document icon (§19.3.4), and the three
+ *    cubes: `node`, `device` and `execution-environment` (§19.4.4);
+ *  - activities   — `action`, the round-cornered rectangle of §15.3.4, the five
+ *    control nodes that route its flow (`initial`, `activity-final`,
+ *    `flow-final`, `decision`, `fork`), the `object-node` of §15.4.4 and the
+ *    three signal and event shapes of §16.3.4 / §16.10.4 (`send-signal`,
+ *    `accept-event`, `time-event`);
+ *  - state machines — `state` and `final-state` (§14.2.4), and the seven
+ *    pseudostates that route transitions: `choice`, `junction`,
+ *    `shallow-history`, `deep-history`, `entry-point`, `exit-point` and
+ *    `terminate`;
+ *  - interactions — `lifeline`, the named head over a dashed spine (§17.3.4),
+ *    the `execution` bar that sits on it (§17.2.4) and the `destruction` X that
+ *    ends it.
+ *
+ * ## Compatibility
+ *
+ * This union is only ever WIDENED — appended to, never reordered — and it is
+ * widened with new VALUES of the existing `kind` string field: no new field, no
+ * schema change, no migration and no backfill. The same promise `C4NodeKind`
+ * and `BpmnNodeKind` make: a diagram drawn today carries one of the values
+ * below, loads unchanged on a build that ships more of them, and paints exactly
+ * as it always did.
+ *
+ * What an OLDER build does with a kind it has never heard of is the other half
+ * of that promise: the element is a native shape, so it still paints its own
+ * box, its own colours and its own words — it simply gets no glyph, because the
+ * renderer draws pictures for the kinds it knows and nothing for the rest.
+ *
+ * The phases that widen it are named in ADR 0017: phase 1 drew the first eight,
+ * phase 2 appended the eight structural ones below them and then the nineteen
+ * behaviour ones below those, and lifelines come in phase 3.
+ */
+export type UmlNodeKind = 'class' | 'interface' | 'enumeration' | 'object' | 'package' | 'note' | 'actor' | 'use-case' | 'component' | 'port' | 'provided-interface' | 'required-interface' | 'artifact' | 'node' | 'device' | 'execution-environment' | 'action' | 'initial' | 'activity-final' | 'flow-final' | 'decision' | 'fork' | 'object-node' | 'send-signal' | 'accept-event' | 'time-event' | 'state' | 'final-state' | 'choice' | 'junction' | 'shallow-history' | 'deep-history' | 'entry-point' | 'exit-point' | 'terminate' | 'lifeline' | 'execution' | 'destruction';
+/**
+ * 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}.
+ */
+export declare class UmlNodeElementModel extends ShapeElementModel {
+    get type(): string;
+    /**
+     * 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(): boolean;
+    /**
+     * 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(): Bound;
+    /**
+     * 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: number, y: number, options: PointTestOptions): boolean;
+    /**
+     * 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.
+     */
+    accessor kind: UmlNodeKind;
+}

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 };