@formicoidea/labre-framework-bpmn 0.32.0 → 0.33.0

package/dist/node/node-renderer.js

@@ -1,15 +1,70 @@
 import { ElementRendererExtension, } from '@formicoidea/labre-core/blocks/surface';
 import { shape as shapeRenderer } from '@formicoidea/labre-core/gfx/shape';
-import { DefaultTheme } from '@formicoidea/labre-core/model';
+import { DefaultTheme, } from '@formicoidea/labre-core/model';
 /**
- * Renderer for a BPMN flow-object node. The shape body (ellipse / rounded rect
- * / diamond) is drawn by REUSING the native shape renderer — so stroke width,
- * colors, inner text and theme behave exactly like a native shape. Only
- * `gatewayExclusive` is decorated: an X drawn on top in the node's (editable)
- * stroke color. Events and task are plain native shapes.
+ * Renderer for a BPMN flow-object node.
+ *
+ * The shape body (ellipse / rounded rect / diamond) is drawn by REUSING the
+ * native shape renderer — so stroke width, colors, inner text and theme behave
+ * exactly like a native shape. On top of it, this file paints the MARKERS the
+ * notation asks for, all of them stroke-based, scale-aware and drawn in the
+ * node's own (editable) stroke colour:
+ *
+ *  - events    — envelope (message), clock (timer), solid disc (terminate);
+ *  - tasks     — a person (user) or a gear (service) in the top-left corner;
+ *  - activity  — the `+` box at the bottom edge (sub-process, call activity);
+ *  - gateway   — the X (exclusive) or the `+` (parallel);
+ *  - data      — folded page, cylinder, open bracket.
+ *
+ * The `group` is the one artefact of the profile this file does NOT touch: its
+ * dashed, rounded, unfilled rectangle is entirely a native shape's own doing.
+ *
+ * The last three are different in kind from the rest: their silhouette is not a
+ * native shape, so the glyph draws the BODY too — fill and outline — and the
+ * native rect underneath is created unfilled and unstroked (see `NODE_PRESETS`
+ * in `actions.ts`). It is still what carries the inner text, the selection
+ * bounds and the connector anchors.
+ *
+ * ## Simplifications against bpmn.io, deliberately
+ *
+ * - **Message start vs message end**: the spec fills the end event's envelope
+ *   solid and leaves the start event's hollow. Both are drawn hollow here, and
+ *   the distinction is carried by the ring weight the two already have — thin
+ *   green for a start, thick red for an end — which is the louder signal of the
+ *   two and the one that is legible zoomed out.
+ * - The **timer** has no hour ticks and the **data store** no shelf lines: at
+ *   the sizes this canvas draws them, both read as noise around the shape.
  *
  * Mirrors the EDGY node renderer.
  */
+/**
+ * The artefacts BPMN draws BARE — a plain native shape with nothing on it.
+ * Everything else in the union is decorated here.
+ *
+ * `group` is bare for a different reason from the other three. They are
+ * undecorated because the notation puts no marker on them; the group has a
+ * distinctive look — a dashed, rounded, unfilled rectangle — and it is here
+ * because that look is expressible as a native shape's own properties
+ * (`strokeStyle: dash`, `radius`, `filled: false`). Drawing it by hand would
+ * have meant re-implementing dashes the shape renderer already does, and losing
+ * the editability that comes free with them.
+ *
+ * Written as the short list rather than the long one, so that the glyph kinds
+ * are DERIVED from the model's union instead of restated beside it: a kind
+ * added to `BpmnNodeKind` is a glyph kind by default, and the exhaustiveness
+ * check at the bottom of this file then refuses to compile until it is drawn.
+ * The alternative — a hand-maintained set of the thirteen decorated kinds — is
+ * the one per-kind table in this pack that could not be made compile-total, and
+ * a kind missing from it paints the WRONG picture rather than none.
+ */
+const UNDECORATED_KINDS = {
+    startEvent: true,
+    endEvent: true,
+    task: true,
+    group: true,
+};
+const isUndecorated = (kind) => Object.hasOwn(UNDECORATED_KINDS, kind);
+const TAU = Math.PI * 2;
 export const bpmnNode = (model, ctx, matrix, renderer, rc, bound) => {
     const [, , w, h] = model.deserializedXYWH;
     const cx = w / 2;
@@ -22,21 +77,243 @@ export const bpmnNode = (model, ctx, matrix, renderer, rc, bound) => {
         .translateSelf(-cx, -cy);
     // Native shape (fill / stroke / inner text / theme handled natively).
     shapeRenderer(model, ctx, matrix, renderer, rc, bound);
-    if (model.kind !== 'gatewayExclusive')
+    const kind = model.kind;
+    if (isUndecorated(kind))
         return;
     const color = renderer.getColorValue(model.strokeColor, DefaultTheme.shapeStrokeColor, true);
-    // ── Exclusive-gateway X, centred and sized to the diamond ───────────
-    const r = Math.min(w, h) * 0.2;
+    const strokeWidth = model.strokeWidth || 1;
+    /**
+     * The smaller half-extent, the unit every glyph is sized against — and the
+     * floor under every radius derived from it.
+     *
+     * An element can be dragged to nothing: the resize manager takes the absolute
+     * value of the dragged extents but sets no minimum size. `arc` and `ellipse`
+     * THROW on a negative radius (`IndexSizeError`) rather than clamping, and the
+     * surface render loop wraps no renderer in a `try`, so one such throw aborts
+     * the rest of the frame with an unbalanced save stack. Clamping at the source
+     * covers every arc in this file at once; the two radii that do not come from
+     * here — the data store's, which subtract the stroke first — are clamped
+     * where they are computed. Same guard, same reason, as the native ellipse
+     * renderer's (`gfx/shape/src/element-renderer/shape/ellipse.ts`), the one
+     * native shape that draws a real ellipse and the one that already does this.
+     */
+    const unit = Math.max(0, Math.min(w, h));
     ctx.setTransform(glyphMatrix);
-    ctx.translate(cx, cy);
     ctx.strokeStyle = color;
-    ctx.lineWidth = Math.max(2, Math.min(w, h) * 0.06);
     ctx.lineCap = 'round';
-    ctx.beginPath();
-    ctx.moveTo(-r, -r);
-    ctx.lineTo(r, r);
-    ctx.moveTo(-r, r);
-    ctx.lineTo(r, -r);
-    ctx.stroke();
+    ctx.lineJoin = 'round';
+    // ── Gateways: X (exclusive) or + (parallel), centred on the diamond ──
+    if (kind === 'gatewayExclusive' || kind === 'gatewayParallel') {
+        const r = unit * 0.2;
+        ctx.translate(cx, cy);
+        ctx.lineWidth = Math.max(2, unit * 0.06);
+        ctx.beginPath();
+        if (kind === 'gatewayExclusive') {
+            ctx.moveTo(-r, -r);
+            ctx.lineTo(r, r);
+            ctx.moveTo(-r, r);
+            ctx.lineTo(r, -r);
+        }
+        else {
+            ctx.moveTo(-r, 0);
+            ctx.lineTo(r, 0);
+            ctx.moveTo(0, -r);
+            ctx.lineTo(0, r);
+        }
+        ctx.stroke();
+        return;
+    }
+    // ── Events ───────────────────────────────────────────────────────────
+    if (kind === 'startEventMessage' || kind === 'endEventMessage') {
+        // Envelope: a rectangle a little under half the ring's diameter, with the
+        // flap folded down to just past its middle.
+        const ew = unit * 0.44;
+        const eh = ew * 0.7;
+        const x = cx - ew / 2;
+        const y = cy - eh / 2;
+        ctx.lineWidth = Math.max(1, unit * 0.04);
+        ctx.beginPath();
+        ctx.moveTo(x, y);
+        ctx.lineTo(x + ew, y);
+        ctx.lineTo(x + ew, y + eh);
+        ctx.lineTo(x, y + eh);
+        ctx.lineTo(x, y);
+        ctx.moveTo(x, y);
+        ctx.lineTo(cx, y + eh * 0.62);
+        ctx.lineTo(x + ew, y);
+        ctx.stroke();
+        return;
+    }
+    if (kind === 'startEventTimer') {
+        // Clock: a rim and two hands, at twelve and at four.
+        const r = unit * 0.24;
+        ctx.lineWidth = Math.max(1, unit * 0.04);
+        ctx.beginPath();
+        ctx.arc(cx, cy, r, 0, TAU);
+        ctx.stroke();
+        ctx.beginPath();
+        ctx.moveTo(cx, cy);
+        ctx.lineTo(cx, cy - r * 0.72);
+        ctx.moveTo(cx, cy);
+        ctx.lineTo(cx + r * 0.52, cy + r * 0.38);
+        ctx.stroke();
+        return;
+    }
+    if (kind === 'endEventTerminate') {
+        // Terminate: a solid disc — the process stops here and nothing else runs.
+        ctx.fillStyle = color;
+        ctx.beginPath();
+        ctx.arc(cx, cy, unit * 0.28, 0, TAU);
+        ctx.fill();
+        return;
+    }
+    // ── Activities ───────────────────────────────────────────────────────
+    if (kind === 'taskUser' || kind === 'taskService') {
+        // Both markers sit in the top-left corner, inside a square of the same
+        // side, so a row of tasks reads as a column of markers down the left.
+        const side = unit * 0.24;
+        const inset = unit * 0.1;
+        const ox = inset + side / 2;
+        const oy = inset + side / 2;
+        ctx.lineWidth = Math.max(1, unit * 0.028);
+        if (kind === 'taskUser') {
+            // A head over a pair of shoulders.
+            ctx.beginPath();
+            ctx.arc(ox, oy - side * 0.2, side * 0.2, 0, TAU);
+            ctx.stroke();
+            ctx.beginPath();
+            ctx.arc(ox, oy + side * 0.42, side * 0.36, Math.PI, TAU);
+            ctx.stroke();
+            return;
+        }
+        // A gear: hub, body and eight teeth.
+        const rOuter = side * 0.5;
+        const rBody = rOuter * 0.72;
+        ctx.beginPath();
+        ctx.arc(ox, oy, rBody, 0, TAU);
+        ctx.stroke();
+        ctx.beginPath();
+        ctx.arc(ox, oy, rOuter * 0.28, 0, TAU);
+        ctx.stroke();
+        ctx.beginPath();
+        for (let i = 0; i < 8; i++) {
+            const a = (i * Math.PI) / 4;
+            ctx.moveTo(ox + Math.cos(a) * rBody, oy + Math.sin(a) * rBody);
+            ctx.lineTo(ox + Math.cos(a) * rOuter, oy + Math.sin(a) * rOuter);
+        }
+        ctx.stroke();
+        return;
+    }
+    if (kind === 'subProcess' || kind === 'callActivity') {
+        // The collapsed marker: a small boxed `+` on the bottom edge, saying
+        // "there is a whole process folded up in here". The call activity carries
+        // the SAME marker — what tells the two apart is its thick border, which is
+        // a creation-time preset rather than anything drawn here.
+        const side = unit * 0.2;
+        const bx = cx;
+        const by = h - unit * 0.1 - side / 2;
+        const half = side / 2;
+        const arm = side * 0.3;
+        ctx.lineWidth = Math.max(1, unit * 0.028);
+        ctx.beginPath();
+        ctx.moveTo(bx - half, by - half);
+        ctx.lineTo(bx + half, by - half);
+        ctx.lineTo(bx + half, by + half);
+        ctx.lineTo(bx - half, by + half);
+        ctx.lineTo(bx - half, by - half);
+        ctx.moveTo(bx - arm, by);
+        ctx.lineTo(bx + arm, by);
+        ctx.moveTo(bx, by - arm);
+        ctx.lineTo(bx, by + arm);
+        ctx.stroke();
+        return;
+    }
+    // ── Data and artifacts: the glyph IS the body ────────────────────────
+    // The native rect under these three is unfilled and unstroked, so both the
+    // fill and the outline are drawn here — off the model's own colours, which
+    // keeps them editable from the shape toolbar like every other node's.
+    const fill = renderer.getColorValue(model.fillColor, DefaultTheme.shapeFillColor, true);
+    const half = strokeWidth / 2;
+    const x0 = half;
+    const y0 = half;
+    const x1 = w - half;
+    const y1 = h - half;
+    ctx.lineWidth = strokeWidth;
+    ctx.fillStyle = fill;
+    if (kind === 'dataObject') {
+        // A page with its top-right corner turned down.
+        const fold = Math.min(w, h) * 0.28;
+        ctx.beginPath();
+        ctx.moveTo(x0, y0);
+        ctx.lineTo(x1 - fold, y0);
+        ctx.lineTo(x1, y0 + fold);
+        ctx.lineTo(x1, y1);
+        ctx.lineTo(x0, y1);
+        ctx.lineTo(x0, y0);
+        ctx.fill();
+        ctx.stroke();
+        // The fold itself, drawn after the body so it is not painted over.
+        ctx.beginPath();
+        ctx.moveTo(x1 - fold, y0);
+        ctx.lineTo(x1 - fold, y0 + fold);
+        ctx.lineTo(x1, y0 + fold);
+        ctx.stroke();
+        return;
+    }
+    if (kind === 'dataStore') {
+        // A cylinder: an elliptical lid, two straight sides and a bulging floor.
+        // Clamped: both subtract the stroke width first, so both go NEGATIVE on an
+        // element dragged narrower (or shorter) than its own border — and a
+        // negative radius is the one thing `ellipse` throws on. See the note on
+        // `unit` above.
+        const rx = Math.max(0, (x1 - x0) / 2);
+        const ry = Math.max(0, (y1 - y0) * 0.16);
+        const mx = (x0 + x1) / 2;
+        const top = y0 + ry;
+        const bottom = y1 - ry;
+        ctx.beginPath();
+        ctx.moveTo(x0, top);
+        ctx.lineTo(x0, bottom);
+        // Floor, left to right through the lowest point.
+        ctx.ellipse(mx, bottom, rx, ry, 0, Math.PI, 0, true);
+        ctx.lineTo(x1, top);
+        // Back up the front of the lid, right to left.
+        ctx.ellipse(mx, top, rx, ry, 0, 0, Math.PI, false);
+        ctx.closePath();
+        ctx.fill();
+        ctx.stroke();
+        // The lid's own far edge, which the body path does not include.
+        ctx.beginPath();
+        ctx.ellipse(mx, top, rx, ry, 0, 0, TAU);
+        ctx.stroke();
+        return;
+    }
+    if (kind === 'textAnnotation') {
+        // An open bracket down the leading edge and nothing else — no fill, no
+        // closing edge. A note is attached to the picture, not framed in it, and
+        // the three missing sides are what say so.
+        const arm = Math.min(w * 0.18, h * 0.35);
+        ctx.beginPath();
+        ctx.moveTo(x0 + arm, y0);
+        ctx.lineTo(x0, y0);
+        ctx.lineTo(x0, y1);
+        ctx.lineTo(x0 + arm, y1);
+        ctx.stroke();
+        return;
+    }
+    /**
+     * Every glyph kind is drawn above, and this is what keeps that true: `kind`
+     * is narrowed to `never` here only if the branches are exhaustive over
+     * {@link BpmnGlyphKind}, so a kind added to the model's union without a
+     * marker of its own stops the build.
+     *
+     * Which is the whole point of closing the last branch rather than letting it
+     * fall through. A renderer that silently paints an annotation bracket on
+     * somebody's new artefact is worse than one that does not paint it at all:
+     * the first is a wrong picture nobody is told about, the second is a missing
+     * one everybody can see.
+     */
+    const unhandled = kind;
+    void unhandled;
 };
 export const BpmnNodeRendererExtension = ElementRendererExtension('bpmnNode', bpmnNode);

package/dist/pool-hit.d.ts

@@ -0,0 +1,98 @@
+import { type BackgroundRect, backgroundPlot } from '@formicoidea/labre-core/blocks/surface';
+/**
+ * Where a pointer is on a pool, in ELEMENT-LOCAL model units.
+ *
+ * Pure, and lifted out of `element-view.ts` so the answers can be asserted
+ * without an editor, a viewport or a canvas around them. The view converts the
+ * pointer and hands it here; everything about WHICH gesture a point means is
+ * decided in this file.
+ *
+ * Every box is derived from `backgroundInstanceZones` /
+ * `backgroundInstanceZoneBand` — the same two functions the renderer paints
+ * from and the audit reports from. Nothing here restates a coordinate, so a
+ * target cannot drift away from the thing it is a target for.
+ *
+ * ponytail: a ROTATED pool is not accounted for — the caller converts by
+ * subtraction, so every box assumes an upright pool. Same reserve
+ * `backgroundAxisFacts` documents, for the same reason: nothing rotates a
+ * framework background today. Upgrade: rotate the local point by
+ * `-model.rotate` about the element centre, in the caller that has the element.
+ */
+/** What these functions need of a pool: its box and its lanes. */
+export interface BpmnPoolGeometry {
+    deserializedXYWH: readonly number[];
+    lanes?: unknown;
+}
+/** A lane band and, when the declaration asks for one, its title strip. */
+export interface BpmnLaneBand {
+    top: number;
+    height: number;
+    strip: BackgroundRect | null;
+}
+export interface BpmnPoolBands {
+    plot: ReturnType<typeof backgroundPlot>;
+    bands: BpmnLaneBand[];
+}
+/** The lane bands of this pool, or `null` when it has no usable partition. */
+export declare function bpmnPoolBands(model: BpmnPoolGeometry): BpmnPoolBands | null;
+/**
+ * A hit box's width, grown to stay reachable when the board is zoomed out.
+ *
+ * 44 view pixels is the touch-target floor, converted to model units so the box
+ * is at least a fingertip wide however far out the pool is drawn; the painted
+ * width wins once the pool is large enough on screen for it to. The growth is
+ * CAPPED, because a target that swallows the thing it sits next to is its own
+ * kind of broken — at 0.2 zoom an uncapped floor would make a lane's title band
+ * wider than the flow area it titles.
+ */
+export declare function bpmnReachable(painted: number, cap: number, zoom: number): number;
+/**
+ * The INTERNAL lane boundary the point is on, as the index of the lane BELOW
+ * it — so `i` separates lane `i - 1` from lane `i`. `null` for anywhere else.
+ *
+ * Internal only: the outer edges belong to the plot, and dragging one would be
+ * a resize of the pool, which the handles already do.
+ */
+export declare function bpmnLaneBoundaryAt(model: BpmnPoolGeometry, local: readonly [number, number]): number | null;
+/**
+ * The lane whose TITLE BAND the point is in, or `null`.
+ *
+ * The band, not a corner box (PO recette, 2026-08-26): a lane name is written
+ * down a strip at the lane's leading edge, so that strip is what you aim at to
+ * change it. Its whole height is live — the name is centred in it, and a band
+ * you may only click the top of would be a target that lies about where it is.
+ */
+export declare function bpmnLaneTitleBandAt(model: BpmnPoolGeometry, local: readonly [number, number], zoom: number): number | null;
+/**
+ * Whether the point is in the POOL's own title band — the left margin strip the
+ * participant name is written up.
+ *
+ * The whole pool used to open the participant editor. That was right while a
+ * pool held one name; with a name per lane it would mean a double-click in the
+ * middle of the flow area renames the participant, which is neither of the two
+ * things a user double-clicking there could have meant.
+ */
+export declare function bpmnInPoolTitleBand(model: BpmnPoolGeometry, local: readonly [number, number], zoom: number): boolean;
+/** What a double-click at this point would rename. */
+export type BpmnPoolTarget = {
+    kind: 'lane';
+    index: number;
+} | {
+    kind: 'participant';
+};
+/**
+ * THE arbiter: which name, if any, a point on a pool is aiming at.
+ *
+ * The two title bands are adjacent, and both grow when the board is zoomed out
+ * (`bpmnReachable`), so on a small pool they OVERLAP — at zoom 1 a 560-unit
+ * pool already has a 28-unit participant band grown to 44, which reaches into
+ * the lane strip beside it. Something has to arbitrate, and it is this
+ * function rather than the view, so the answer can be asserted without an
+ * editor and so there is exactly one of it.
+ *
+ * The LANE wins the overlap. The strip is painted with the lane's name written
+ * down it, so it is the name a user is looking at when they aim there; handing
+ * their double-click to the participant instead would rename the one thing they
+ * demonstrably were not pointing at.
+ */
+export declare function bpmnPoolTargetAt(model: BpmnPoolGeometry, local: readonly [number, number], zoom: number): BpmnPoolTarget | null;

package/dist/pool-hit.js

@@ -0,0 +1,130 @@
+import { backgroundInstanceZoneBand, backgroundInstanceZones, backgroundPlot, } from '@formicoidea/labre-core/blocks/surface';
+import { BPMN_POOL_BACKGROUND } from './background.js';
+import { POOL_LANE_GRAB } from './consts.js';
+/** The lane bands of this pool, or `null` when it has no usable partition. */
+export function bpmnPoolBands(model) {
+    const [, , w, h] = model.deserializedXYWH;
+    const plot = backgroundPlot(BPMN_POOL_BACKGROUND, w, h);
+    if (!(plot.width > 0) || !(plot.height > 0))
+        return null;
+    const zones = backgroundInstanceZones(BPMN_POOL_BACKGROUND, model);
+    if (zones.length === 0)
+        return null;
+    return {
+        plot,
+        bands: zones.map(zone => ({
+            top: plot.y0 + zone.rect.y * plot.height,
+            height: zone.rect.h * plot.height,
+            strip: backgroundInstanceZoneBand(BPMN_POOL_BACKGROUND, zone, plot),
+        })),
+    };
+}
+/**
+ * A hit box's width, grown to stay reachable when the board is zoomed out.
+ *
+ * 44 view pixels is the touch-target floor, converted to model units so the box
+ * is at least a fingertip wide however far out the pool is drawn; the painted
+ * width wins once the pool is large enough on screen for it to. The growth is
+ * CAPPED, because a target that swallows the thing it sits next to is its own
+ * kind of broken — at 0.2 zoom an uncapped floor would make a lane's title band
+ * wider than the flow area it titles.
+ */
+export function bpmnReachable(painted, cap, zoom) {
+    return Math.max(painted, Math.min(44 / (zoom || 1), cap));
+}
+/**
+ * The INTERNAL lane boundary the point is on, as the index of the lane BELOW
+ * it — so `i` separates lane `i - 1` from lane `i`. `null` for anywhere else.
+ *
+ * Internal only: the outer edges belong to the plot, and dragging one would be
+ * a resize of the pool, which the handles already do.
+ */
+export function bpmnLaneBoundaryAt(model, local) {
+    const geometry = bpmnPoolBands(model);
+    if (!geometry)
+        return null;
+    const { plot, bands } = geometry;
+    // The strip on the left is the participant's name, not the flow area: a
+    // separator does not run through it, so neither does its grab zone.
+    if (local[0] < plot.x0 || local[0] > plot.x1)
+        return null;
+    for (let i = 1; i < bands.length; i++) {
+        if (Math.abs(local[1] - bands[i].top) <= POOL_LANE_GRAB)
+            return i;
+    }
+    return null;
+}
+/**
+ * The lane whose TITLE BAND the point is in, or `null`.
+ *
+ * The band, not a corner box (PO recette, 2026-08-26): a lane name is written
+ * down a strip at the lane's leading edge, so that strip is what you aim at to
+ * change it. Its whole height is live — the name is centred in it, and a band
+ * you may only click the top of would be a target that lies about where it is.
+ */
+export function bpmnLaneTitleBandAt(model, local, zoom) {
+    const geometry = bpmnPoolBands(model);
+    if (!geometry)
+        return null;
+    const { plot, bands } = geometry;
+    for (let i = 0; i < bands.length; i++) {
+        const strip = bands[i].strip;
+        if (!strip)
+            continue;
+        // Grown across the strip only; along it, a lane is already as tall as it
+        // is. Capped at half the plot so the target never covers the flow area.
+        const width = bpmnReachable(strip.w, plot.width / 2, zoom);
+        if (local[0] >= strip.x &&
+            local[0] <= strip.x + width &&
+            local[1] >= strip.y &&
+            local[1] <= strip.y + strip.h) {
+            return i;
+        }
+    }
+    return null;
+}
+/**
+ * Whether the point is in the POOL's own title band — the left margin strip the
+ * participant name is written up.
+ *
+ * The whole pool used to open the participant editor. That was right while a
+ * pool held one name; with a name per lane it would mean a double-click in the
+ * middle of the flow area renames the participant, which is neither of the two
+ * things a user double-clicking there could have meant.
+ */
+export function bpmnInPoolTitleBand(model, local, zoom) {
+    const [, , w, h] = model.deserializedXYWH;
+    const plot = backgroundPlot(BPMN_POOL_BACKGROUND, w, h);
+    // The band IS the margin, clamped to a pool narrower than its own margin —
+    // the same degenerate case the renderer clamps.
+    const painted = Math.min(plot.x0, w);
+    if (!(painted > 0))
+        return false;
+    // Grown rightwards, capped at twice the margin: past that lies the lane
+    // strip, which has its own claim on those units — see `bpmnPoolTargetAt`.
+    const width = bpmnReachable(painted, painted * 2, zoom);
+    return local[0] >= 0 && local[0] <= width && local[1] >= 0 && local[1] <= h;
+}
+/**
+ * THE arbiter: which name, if any, a point on a pool is aiming at.
+ *
+ * The two title bands are adjacent, and both grow when the board is zoomed out
+ * (`bpmnReachable`), so on a small pool they OVERLAP — at zoom 1 a 560-unit
+ * pool already has a 28-unit participant band grown to 44, which reaches into
+ * the lane strip beside it. Something has to arbitrate, and it is this
+ * function rather than the view, so the answer can be asserted without an
+ * editor and so there is exactly one of it.
+ *
+ * The LANE wins the overlap. The strip is painted with the lane's name written
+ * down it, so it is the name a user is looking at when they aim there; handing
+ * their double-click to the participant instead would rename the one thing they
+ * demonstrably were not pointing at.
+ */
+export function bpmnPoolTargetAt(model, local, zoom) {
+    const index = bpmnLaneTitleBandAt(model, local, zoom);
+    if (index !== null)
+        return { kind: 'lane', index };
+    if (bpmnInPoolTitleBand(model, local, zoom))
+        return { kind: 'participant' };
+    return null;
+}

package/dist/presets.d.ts

@@ -0,0 +1,114 @@
+import type { BpmnNodeKind } from '@formicoidea/labre-core/model';
+import { StrokeStyle, TextAlign, TextVerticalAlign } from '@formicoidea/labre-core/model';
+/**
+ * What a BPMN artefact is BORN as — the one description of a node's props, read
+ * by every site that creates one.
+ *
+ * Lifted out of `actions.ts` when the importer arrived, and lifted rather than
+ * copied for the reason the copy would have failed: a task read out of a
+ * `.bpmn` file and a task drawn from the palette must be the same element in
+ * the document, down to the stroke width and the text fit mode. Two builders
+ * would agree on the day they were written and drift on the first restyle,
+ * and the drift would show up as an imported board that looks subtly unlike a
+ * drawn one — the kind of difference nobody reports and everybody notices.
+ *
+ * Pure data and one pure function: no `BlockStdScope`, no surface, no viewport.
+ * The creation gesture supplies the box, the importer supplies the box the file
+ * gave it, and neither knows anything the other does not.
+ */
+/**
+ * The native shape and accent a kind is born with (style C).
+ *
+ * `glyphBody` is the one non-obvious field: the three data/artifact shapes have
+ * a silhouette a native rect cannot make — a folded page, a cylinder, an open
+ * bracket — so for those the renderer's glyph paints the BODY as well as the
+ * decoration, and the native shape is created unfilled and unstroked. It still
+ * earns its keep: it is what carries the inner text, the selection bounds, the
+ * resize handles and the connector anchors.
+ */
+export interface BpmnNodePreset {
+    shapeType: 'ellipse' | 'rect' | 'diamond';
+    stroke: string;
+    width: number;
+    /** Corner radius, `rect` only. Absent means a square corner. */
+    radius?: number;
+    /** Border style. Absent means a solid line, which is what BPMN mostly draws. */
+    strokeStyle?: StrokeStyle;
+    /**
+     * No fill — an OUTLINE, not a body. It also decides what the artefact does to
+     * a click: an unfilled shape is hit near its border and on its label only, so
+     * the group never steals a click from the work it encloses.
+     */
+    hollow?: true;
+    /** The glyph draws the body; the native shape paints nothing. */
+    glyphBody?: true;
+    /**
+     * Where the inner text sits. Absent means centred, which is what every
+     * artefact whose label names the artefact itself wants. The group is the
+     * exception: its label names a region, so it goes in the corner of it.
+     */
+    textAlign?: TextAlign;
+    textVerticalAlign?: TextVerticalAlign;
+}
+/** Per-kind native shape + accent presets (style C). */
+export declare const NODE_PRESETS: Record<BpmnNodeKind, BpmnNodePreset>;
+/**
+ * One BPMN node, as the props `surface.addElement` takes.
+ *
+ * The single description of what a `bpmnNode` IS in a document: the palette
+ * hands it a box centred on the viewport, the importer hands it the box the
+ * file's `dc:Bounds` gave, and the element that lands is the same either way.
+ *
+ * `text` is passed through unchanged, `undefined` included — an artefact whose
+ * label the source left empty gets no `text` key at all rather than an empty
+ * one, which is what keeps an imported node byte-comparable with a drawn one
+ * that was never typed into.
+ */
+export declare function bpmnNodeProps(kind: BpmnNodeKind, box: {
+    xywh: string;
+    text?: string;
+}): Record<string, unknown> & {
+    type: string;
+};
+/**
+ * What a node's kind is worth to an element that ALREADY EXISTS — the same
+ * description as {@link bpmnNodeProps}, minus the three things a morph has no
+ * business touching.
+ *
+ * Derived from the creation builder rather than restated beside it, and that is
+ * the whole point of the function.
+ *
+ * ## Why a `{kind, role}` patch is not enough
+ *
+ * Because the appearance of a BPMN artefact lives in props the CREATING kind's
+ * preset wrote, and nothing else ever rewrites them. One shipped morph pair
+ * shows it today: `subProcess` and `callActivity` are the same rounded
+ * rectangle and differ only in `strokeWidth` — 2 against 4 — and that thick
+ * border IS how a reader tells "this box stands for a process defined
+ * elsewhere" from "this box stands for one defined inline". Morph between them
+ * with two keys and the call activity arrives wearing the sub-process's thin
+ * border, which is a drawing that says the wrong thing.
+ *
+ * Every other family declared in `./morph.ts` currently shares one preset
+ * across its members, so for those the full patch changes nothing — and that is
+ * the second reason to write it this way rather than to trim it. A family is
+ * DATA (`BPMN_MORPH_FAMILIES`) and grows by declaration, with no code change to
+ * prompt anyone to ask whether the presets still agree; deriving the patch from
+ * the creation builder means the answer is right in advance. It is also what
+ * guarantees that a morphed artefact and one drawn fresh from the palette are
+ * the same element — two builders would agree the day they were written and
+ * drift on the first restyle, which is the argument this file already makes for
+ * having one creation builder at all.
+ */
+export declare function bpmnMorphProps(kind: BpmnNodeKind): Record<string, unknown>;
+/**
+ * The fields to DELETE from an element after morphing it to `kind` — the keys
+ * some other kind writes and this one does not.
+ *
+ * A patch cannot express absence. `textVerticalAlign` is spread conditionally
+ * (see {@link bpmnNodeProps}), so morphing away from the group would leave
+ * `Top` sitting in the Y.Map and silently in force over a preset that means
+ * "centred". `clearField` removes the key, which is the same call `writeLanes`
+ * makes when a pool loses its last lane.
+ */
+export declare function bpmnMorphClears(kind: BpmnNodeKind): readonly string[];