@formicoidea/labre-core 0.40.0 → 0.42.0

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

@@ -0,0 +1,161 @@
+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 combined fragment's OPERATOR BAND — the strip across its top the
+ * pentagon tag is drawn in, in model units.
+ *
+ * Owned by the model for the reason {@link UML_FRAME_BAND_HEIGHT} is: the
+ * fragment's own hit test reads it (a fragment is clickable by its tag strip as
+ * well as by its border), and `affine-model` cannot reach into
+ * `affine-block-surface` where the declaration is resolved.
+ *
+ * The diagram frame's own 44, and deliberately: §17.6.4 draws the operator in
+ * the very same cut-corner pentagon Annex A draws a frame heading in — it IS a
+ * frame, nested in another one — and two numbers for one piece of furniture
+ * would drift.
+ */
+export declare const UML_FRAGMENT_BAND = 44;
+/**
+ * The INTERACTION OPERATOR of a combined fragment — the word written in its
+ * pentagon, and the whole of what the fragment says (UML 2.5.1 §17.6.4).
+ *
+ * The twelve operators of §17.6.4 plus `ref`, and the thirteenth is the one
+ * that is not an operator at all: §17.7.4's InteractionUse is a different
+ * metaclass drawn as the same rectangle with the same pentagon, and every tool
+ * offers it from the same menu. Keeping it here is what lets one element, one
+ * renderer and one toolbar cover both — the alternative being a second
+ * background that differs from this one by a string.
+ *
+ * Widened the way every other UML union is: appended, never reordered, and read
+ * back as whatever string the document carries. A fragment whose operator this
+ * build has never heard of still paints its rectangle and still writes its own
+ * word in the tag.
+ */
+export type UmlFragmentOperator = 'alt' | 'opt' | 'loop' | 'par' | 'break' | 'critical' | 'seq' | 'strict' | 'neg' | 'assert' | 'ignore' | 'consider' | 'ref';
+/**
+ * One OPERAND of a combined fragment — a horizontal band of it, separated from
+ * the next by a dashed line (§17.6.4).
+ *
+ * The shape of a `BackgroundInstanceZoneItem` in `@labre/affine-block-surface`,
+ * and deliberately the same three fields as {@link BpmnLane}: the primitive
+ * paints an instance partition from that structure, the audit reports it from
+ * that structure, and an operand with a shape of its own would be a fourth
+ * place the two have to agree.
+ *
+ * `name` is the operand's GUARD — `[x > 0]`, `[else]` — because that is the
+ * only thing §17.6.4 writes in an operand's own corner. `size` is a relative
+ * WEIGHT and not a height in model units: a fragment dragged taller
+ * redistributes the space between its operands instead of leaving a gap under
+ * the last one.
+ */
+export interface UmlFragmentOperand {
+    /** Stable id, generated at creation. Never the guard: a guard is rewritten. */
+    id: string;
+    /** The operand's guard, written in its top-left corner. */
+    name?: string;
+    /** Relative weight — see above. Must be a finite number greater than zero. */
+    size: number;
+}
+export type UmlFragmentProps = FrameworkBackgroundProps & {
+    /** Which operator the pentagon writes. */
+    operator?: UmlFragmentOperator;
+    /** The first operand's guard, or a `ref`'s interaction name. */
+    name?: string;
+    /** The fragment's partition into operands. Absent until a second is added. */
+    operands?: UmlFragmentOperand[];
+};
+/**
+ * A COMBINED FRAGMENT — the rectangle drawn round part of a sequence diagram
+ * with an operator in its corner (UML 2.5.1 §17.6.4), and, under the `ref`
+ * operator, the InteractionUse of §17.7.4.
+ *
+ * A framework background, and a TRANSPARENT one, like
+ * {@link UmlSubjectElementModel} and {@link UmlPartitionElementModel}: it is
+ * drawn OVER lifelines and messages that are already there, and an opaque card
+ * would hide the very conversation it is qualifying. Membership — which
+ * messages are inside the `alt`, which lifelines it covers — is geometry at
+ * read time (R11), never a stored list.
+ *
+ * ## Why the operator is a field and the operands are not elements
+ *
+ * The operator IS the fragment: `alt` and `loop` are the same rectangle saying
+ * two entirely different things, and nothing in the picture distinguishes them
+ * but the word. So it is stored, with `alt` as the default — the fragment an
+ * architect reaches for first, and the one §17.6.4 opens with.
+ *
+ * The operands are bands of that one rectangle, and they follow the BPMN pool's
+ * lanes exactly: an optional flat array, `undefined` rather than `[]` until the
+ * first one is added, so a fragment with a single operand stays byte-identical
+ * to one written before the field existed. The trade the pool's own note
+ * states applies here unchanged — two peers reordering the operands at the same
+ * moment resolve last-write-wins, one whole list winning over the other — and
+ * it is stated so it is reviewed rather than discovered.
+ *
+ * What it LOOKS like is declared, not coded: see `UML_FRAGMENT_FRAME` in
+ * `@labre/affine-gfx-uml`.
+ */
+export declare class UmlFragmentElementModel extends FrameworkBackgroundElementModel<UmlFragmentProps> {
+    get type(): string;
+    /**
+     * The operator — REQUIRED, with `alt` as the default, for the reason
+     * `UmlDiagramElementModel.kind` is required: it is part of the NOTATION
+     * rather than a claim an author may decline to make. A fragment with no
+     * operator has no word to write in its pentagon, and a pentagon with nothing
+     * in it is a rectangle with a bitten corner.
+     */
+    accessor operator: UmlFragmentOperator;
+    /**
+     * The first operand's guard, or — under `ref` — the name of the interaction
+     * being referred to.
+     *
+     * Seeded EMPTY, unlike every other UML frame's name: §17.6.4 draws a guard
+     * only where there is one to draw, and `[alt]` with an empty bracket under it
+     * would be the notation inventing a condition the author has not written. An
+     * empty string keeps the field in the document (the `@field` default is
+     * written) without putting words on the page.
+     */
+    accessor name: string;
+    accessor resizeEnabled: boolean;
+    accessor rotate: number;
+    /**
+     * Wide enough to cover three lifelines at the 200-unit spacing a sequence
+     * diagram is laid out on, and tall enough for three or four exchanges — the
+     * size an `alt` is actually drawn round.
+     */
+    accessor xywh: SerializedXYWH;
+    /**
+     * The fragment's partition into operands, top to bottom.
+     *
+     * `undefined`, not `[]`, and for the three reasons `BpmnPoolElementModel
+     * .lanes` states in full: `@field()` writes nothing for an undefined default,
+     * so a fragment with a single operand — which is every `opt`, every `loop`
+     * and every `ref` — is byte-identical to one created before this field
+     * existed; the value is flat JSON because a list of operands is one atomic
+     * choice about how one fragment is cut; and it is declared here rather than
+     * on the base class because an operand is a subdivision of a combined
+     * fragment and of nothing else.
+     *
+     * What it MEANS is declared, not coded: `UML_FRAGMENT_FRAME.instanceZones`
+     * in `@labre/affine-gfx-uml` names this prop, and the framework-background
+     * primitive paints the separators and the guards from it.
+     */
+    accessor operands: UmlFragmentOperand[] | undefined;
+    /**
+     * Picked by its BORDER — and by its OPERATOR BAND, the one carve-out it
+     * keeps.
+     *
+     * The same carve-out the diagram frame, the partition and the composite state
+     * all make, and for the same reason: the band is the only part of the
+     * fragment that is the FRAGMENT rather than the conversation drawn inside it.
+     * Without it the pentagon would be unreachable, a background being picked by
+     * its border alone — and a transparent fragment's border is a thin line round
+     * a region full of other people's messages.
+     *
+     * Nothing below the band is claimed, which matters here as much as on a
+     * partition: a fragment is drawn OVER lifelines, 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/fragment.js

@@ -0,0 +1,205 @@
+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 combined fragment's OPERATOR BAND — the strip across its top the
+ * pentagon tag is drawn in, in model units.
+ *
+ * Owned by the model for the reason {@link UML_FRAME_BAND_HEIGHT} is: the
+ * fragment's own hit test reads it (a fragment is clickable by its tag strip as
+ * well as by its border), and `affine-model` cannot reach into
+ * `affine-block-surface` where the declaration is resolved.
+ *
+ * The diagram frame's own 44, and deliberately: §17.6.4 draws the operator in
+ * the very same cut-corner pentagon Annex A draws a frame heading in — it IS a
+ * frame, nested in another one — and two numbers for one piece of furniture
+ * would drift.
+ */
+export const UML_FRAGMENT_BAND = 44;
+/**
+ * A COMBINED FRAGMENT — the rectangle drawn round part of a sequence diagram
+ * with an operator in its corner (UML 2.5.1 §17.6.4), and, under the `ref`
+ * operator, the InteractionUse of §17.7.4.
+ *
+ * A framework background, and a TRANSPARENT one, like
+ * {@link UmlSubjectElementModel} and {@link UmlPartitionElementModel}: it is
+ * drawn OVER lifelines and messages that are already there, and an opaque card
+ * would hide the very conversation it is qualifying. Membership — which
+ * messages are inside the `alt`, which lifelines it covers — is geometry at
+ * read time (R11), never a stored list.
+ *
+ * ## Why the operator is a field and the operands are not elements
+ *
+ * The operator IS the fragment: `alt` and `loop` are the same rectangle saying
+ * two entirely different things, and nothing in the picture distinguishes them
+ * but the word. So it is stored, with `alt` as the default — the fragment an
+ * architect reaches for first, and the one §17.6.4 opens with.
+ *
+ * The operands are bands of that one rectangle, and they follow the BPMN pool's
+ * lanes exactly: an optional flat array, `undefined` rather than `[]` until the
+ * first one is added, so a fragment with a single operand stays byte-identical
+ * to one written before the field existed. The trade the pool's own note
+ * states applies here unchanged — two peers reordering the operands at the same
+ * moment resolve last-write-wins, one whole list winning over the other — and
+ * it is stated so it is reviewed rather than discovered.
+ *
+ * What it LOOKS like is declared, not coded: see `UML_FRAGMENT_FRAME` in
+ * `@labre/affine-gfx-uml`.
+ */
+let UmlFragmentElementModel = (() => {
+    let _classSuper = FrameworkBackgroundElementModel;
+    let _operator_decorators;
+    let _operator_initializers = [];
+    let _operator_extraInitializers = [];
+    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 _operands_decorators;
+    let _operands_initializers = [];
+    let _operands_extraInitializers = [];
+    return class UmlFragmentElementModel extends _classSuper {
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+            _operator_decorators = [field('alt')];
+            _name_decorators = [field('')];
+            _resizeEnabled_decorators = [field(true)];
+            _rotate_decorators = [field(0)];
+            _xywh_decorators = [field()];
+            _operands_decorators = [field()];
+            __esDecorate(this, null, _operator_decorators, { kind: "accessor", name: "operator", static: false, private: false, access: { has: obj => "operator" in obj, get: obj => obj.operator, set: (obj, value) => { obj.operator = value; } }, metadata: _metadata }, _operator_initializers, _operator_extraInitializers);
+            __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, _operands_decorators, { kind: "accessor", name: "operands", static: false, private: false, access: { has: obj => "operands" in obj, get: obj => obj.operands, set: (obj, value) => { obj.operands = value; } }, metadata: _metadata }, _operands_initializers, _operands_extraInitializers);
+            if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        }
+        get type() {
+            return 'umlFragment';
+        }
+        #operator_accessor_storage = __runInitializers(this, _operator_initializers, 'alt');
+        /**
+         * The operator — REQUIRED, with `alt` as the default, for the reason
+         * `UmlDiagramElementModel.kind` is required: it is part of the NOTATION
+         * rather than a claim an author may decline to make. A fragment with no
+         * operator has no word to write in its pentagon, and a pentagon with nothing
+         * in it is a rectangle with a bitten corner.
+         */
+        get operator() { return this.#operator_accessor_storage; }
+        set operator(value) { this.#operator_accessor_storage = value; }
+        #name_accessor_storage = (__runInitializers(this, _operator_extraInitializers), __runInitializers(this, _name_initializers, ''));
+        /**
+         * The first operand's guard, or — under `ref` — the name of the interaction
+         * being referred to.
+         *
+         * Seeded EMPTY, unlike every other UML frame's name: §17.6.4 draws a guard
+         * only where there is one to draw, and `[alt]` with an empty bracket under it
+         * would be the notation inventing a condition the author has not written. An
+         * empty string keeps the field in the document (the `@field` default is
+         * written) without putting words on the page.
+         */
+        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,600,260]'));
+        /**
+         * Wide enough to cover three lifelines at the 200-unit spacing a sequence
+         * diagram is laid out on, and tall enough for three or four exchanges — the
+         * size an `alt` is actually drawn round.
+         */
+        get xywh() { return this.#xywh_accessor_storage; }
+        set xywh(value) { this.#xywh_accessor_storage = value; }
+        #operands_accessor_storage = (__runInitializers(this, _xywh_extraInitializers), __runInitializers(this, _operands_initializers, undefined));
+        /**
+         * The fragment's partition into operands, top to bottom.
+         *
+         * `undefined`, not `[]`, and for the three reasons `BpmnPoolElementModel
+         * .lanes` states in full: `@field()` writes nothing for an undefined default,
+         * so a fragment with a single operand — which is every `opt`, every `loop`
+         * and every `ref` — is byte-identical to one created before this field
+         * existed; the value is flat JSON because a list of operands is one atomic
+         * choice about how one fragment is cut; and it is declared here rather than
+         * on the base class because an operand is a subdivision of a combined
+         * fragment and of nothing else.
+         *
+         * What it MEANS is declared, not coded: `UML_FRAGMENT_FRAME.instanceZones`
+         * in `@labre/affine-gfx-uml` names this prop, and the framework-background
+         * primitive paints the separators and the guards from it.
+         */
+        get operands() { return this.#operands_accessor_storage; }
+        set operands(value) { this.#operands_accessor_storage = value; }
+        /**
+         * Picked by its BORDER — and by its OPERATOR BAND, the one carve-out it
+         * keeps.
+         *
+         * The same carve-out the diagram frame, the partition and the composite state
+         * all make, and for the same reason: the band is the only part of the
+         * fragment that is the FRAGMENT rather than the conversation drawn inside it.
+         * Without it the pentagon would be unreachable, a background being picked by
+         * its border alone — and a transparent fragment's border is a thin line round
+         * a region full of other people's messages.
+         *
+         * Nothing below the band is claimed, which matters here as much as on a
+         * partition: a fragment is drawn OVER lifelines, 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, 'top', UML_FRAGMENT_BAND, x, y);
+        }
+        constructor() {
+            super(...arguments);
+            __runInitializers(this, _operands_extraInitializers);
+        }
+    };
+})();
+export { UmlFragmentElementModel };

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

@@ -0,0 +1,8 @@
+export * from './band.js';
+export * from './diagram.js';
+export * from './fragment.js';
+export * from './lifeline.js';
+export * from './node.js';
+export * from './partition.js';
+export * from './region.js';
+export * from './subject.js';

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

@@ -0,0 +1,8 @@
+export * from './band.js';
+export * from './diagram.js';
+export * from './fragment.js';
+export * from './lifeline.js';
+export * from './node.js';
+export * from './partition.js';
+export * from './region.js';
+export * from './subject.js';

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

@@ -0,0 +1,77 @@
+/**
+ * The LIFELINE's geometry — the two numbers a lifeline is drawn, selected and
+ * hit-tested from (UML 2.5.1 §17.3.4).
+ *
+ * Declared HERE, in the model, and re-exported by `@labre/affine-gfx-uml`, for
+ * the reason {@link UML_FRAME_BAND_HEIGHT} and {@link UML_PARTITION_BAND} are:
+ * the element's own `elementBound` and `includesPoint` read them (a lifeline's
+ * HEAD overflows the column the element actually is), and `affine-model` cannot
+ * reach into the package where the renderer lives. One pair of numbers, owned by
+ * the layer that the model, the renderer and the label layout can all read.
+ *
+ * ## Why a lifeline is a narrow column and not a head-shaped box
+ *
+ * §17.3.4 draws a lifeline as a named rectangle with a dashed vertical line
+ * falling out of its bottom edge, down the whole height of the interaction. The
+ * thing a message ATTACHES to is that line, never the rectangle — so the element
+ * is the COLUMN (16 wide, {@link UML_LIFELINE_SPINE} tall), whose native
+ * perimeter puts every connector anchor on the spine's own x, and the head is
+ * painted over its top by the glyph layer.
+ *
+ * The consequence is the one thing this module exists to fix: the head is 160
+ * wide against a 16-wide element, so it hangs 72 units off each side of the box
+ * the platform knows about. Selection, hit testing and frame fitting would all
+ * stop at the column — a user would see a named box and be unable to click it.
+ * {@link umlLifelineHeadRect} is the shared answer, read by the model's two
+ * overrides and by the renderer alike.
+ */
+export declare const UML_LIFELINE_HEAD: {
+    readonly w: 160;
+    readonly h: 48;
+};
+/**
+ * How tall a fresh lifeline's COLUMN is — the head plus the dashed spine under
+ * it, in model units.
+ *
+ * 600 is a sheet's worth of conversation: at the 40-unit rhythm a sequence
+ * diagram's messages are drawn on, it holds a dozen or so exchanges before the
+ * author has to drag it longer. Which is the resize a lifeline ever WANTS — the
+ * column is only ever wanted taller. It is not the only resize it accepts:
+ * nothing constrains the handles, and a wider column simply widens the painted
+ * head, which {@link umlLifelineHeadRect} sizes at `max(160, w)`.
+ */
+export declare const UML_LIFELINE_SPINE = 600;
+/** What a lifeline geometry question needs of an element: its box. */
+export interface UmlLifelineGeometry {
+    deserializedXYWH: readonly number[];
+    rotate?: number;
+}
+/** A rectangle in the element's own (unrotated) local frame. */
+export interface UmlLifelineRect {
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+}
+/**
+ * The head box, in ELEMENT-LOCAL model units — the named rectangle §17.3.4
+ * draws at the top of the lifeline, centred on the column and flush with its
+ * top.
+ *
+ * `null` when there is nothing to draw: a column dragged to nothing.
+ *
+ * Never NARROWER than the column: a lifeline dragged wider than 160 units is a
+ * lifeline whose head is the whole of it, which is the only reading that keeps
+ * the head a box round the spine rather than a stripe down the middle of one.
+ * Clamped in height for the same reason the frame's heading band is — a column
+ * shorter than its own head keeps a head, cut down to what there is.
+ */
+export declare function umlLifelineHeadRect(model: UmlLifelineGeometry): UmlLifelineRect | null;
+/**
+ * Whether a CANVAS point lies in the lifeline's head.
+ *
+ * The rotation is undone about the element's centre before anything is
+ * measured, exactly as {@link umlInNameBand} does it: the head is axis-aligned
+ * INSIDE the lifeline, never on the canvas.
+ */
+export declare function umlInLifelineHead(model: UmlLifelineGeometry, x: number, y: number): boolean;

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

@@ -0,0 +1,89 @@
+import { rotatePoint } from '../../../global/gfx/index.js';
+/**
+ * The LIFELINE's geometry — the two numbers a lifeline is drawn, selected and
+ * hit-tested from (UML 2.5.1 §17.3.4).
+ *
+ * Declared HERE, in the model, and re-exported by `@labre/affine-gfx-uml`, for
+ * the reason {@link UML_FRAME_BAND_HEIGHT} and {@link UML_PARTITION_BAND} are:
+ * the element's own `elementBound` and `includesPoint` read them (a lifeline's
+ * HEAD overflows the column the element actually is), and `affine-model` cannot
+ * reach into the package where the renderer lives. One pair of numbers, owned by
+ * the layer that the model, the renderer and the label layout can all read.
+ *
+ * ## Why a lifeline is a narrow column and not a head-shaped box
+ *
+ * §17.3.4 draws a lifeline as a named rectangle with a dashed vertical line
+ * falling out of its bottom edge, down the whole height of the interaction. The
+ * thing a message ATTACHES to is that line, never the rectangle — so the element
+ * is the COLUMN (16 wide, {@link UML_LIFELINE_SPINE} tall), whose native
+ * perimeter puts every connector anchor on the spine's own x, and the head is
+ * painted over its top by the glyph layer.
+ *
+ * The consequence is the one thing this module exists to fix: the head is 160
+ * wide against a 16-wide element, so it hangs 72 units off each side of the box
+ * the platform knows about. Selection, hit testing and frame fitting would all
+ * stop at the column — a user would see a named box and be unable to click it.
+ * {@link umlLifelineHeadRect} is the shared answer, read by the model's two
+ * overrides and by the renderer alike.
+ */
+export const UML_LIFELINE_HEAD = { w: 160, h: 48 };
+/**
+ * How tall a fresh lifeline's COLUMN is — the head plus the dashed spine under
+ * it, in model units.
+ *
+ * 600 is a sheet's worth of conversation: at the 40-unit rhythm a sequence
+ * diagram's messages are drawn on, it holds a dozen or so exchanges before the
+ * author has to drag it longer. Which is the resize a lifeline ever WANTS — the
+ * column is only ever wanted taller. It is not the only resize it accepts:
+ * nothing constrains the handles, and a wider column simply widens the painted
+ * head, which {@link umlLifelineHeadRect} sizes at `max(160, w)`.
+ */
+export const UML_LIFELINE_SPINE = 600;
+/**
+ * The head box, in ELEMENT-LOCAL model units — the named rectangle §17.3.4
+ * draws at the top of the lifeline, centred on the column and flush with its
+ * top.
+ *
+ * `null` when there is nothing to draw: a column dragged to nothing.
+ *
+ * Never NARROWER than the column: a lifeline dragged wider than 160 units is a
+ * lifeline whose head is the whole of it, which is the only reading that keeps
+ * the head a box round the spine rather than a stripe down the middle of one.
+ * Clamped in height for the same reason the frame's heading band is — a column
+ * shorter than its own head keeps a head, cut down to what there is.
+ */
+export function umlLifelineHeadRect(model) {
+    const [, , w, h] = model.deserializedXYWH;
+    if (!(w > 0) || !(h > 0))
+        return null;
+    const width = Math.max(UML_LIFELINE_HEAD.w, w);
+    const height = Math.min(UML_LIFELINE_HEAD.h, h);
+    if (!(width > 0) || !(height > 0))
+        return null;
+    return { x: (w - width) / 2, y: 0, w: width, h: height };
+}
+/**
+ * Whether a CANVAS point lies in the lifeline's head.
+ *
+ * The rotation is undone about the element's centre before anything is
+ * measured, exactly as {@link umlInNameBand} does it: the head is axis-aligned
+ * INSIDE the lifeline, never on the canvas.
+ */
+export function umlInLifelineHead(model, x, y) {
+    const head = umlLifelineHeadRect(model);
+    if (!head)
+        return false;
+    const [ex, ey, w, h] = model.deserializedXYWH;
+    let lx = x - ex;
+    let ly = y - ey;
+    const rotate = model.rotate ?? 0;
+    if (rotate) {
+        const [ux, uy] = rotatePoint([x, y], [ex + w / 2, ey + h / 2], -rotate);
+        lx = ux - ex;
+        ly = uy - ey;
+    }
+    return (lx >= head.x &&
+        lx <= head.x + head.w &&
+        ly >= head.y &&
+        ly <= head.y + head.h);
+}