@formicoidea/labre-framework-bpmn 0.32.0 → 0.33.0

package/dist/consts.d.ts

@@ -17,25 +17,179 @@ export declare const NODE_FILL = "#ffffff";
 export declare const START_WIDTH = 2;
 export declare const END_WIDTH = 4;
 export declare const NODE_STROKE_WIDTH = 2;
+/**
+ * The call activity's border, which the spec draws THICK — it is the one way to
+ * tell it from the sub-process, since both carry the same `+` marker. Same
+ * weight as the end-event ring, and for the same reason: this is the heaviest
+ * line the notation uses, and it is spent on "this one stands for a whole
+ * process defined somewhere else".
+ */
+export declare const CALL_ACTIVITY_WIDTH = 4;
 /** Task corner radius (absolute px — a lightly rounded rectangle). */
 export declare const TASK_RADIUS = 10;
+/**
+ * The group's corner radius — twice a task's, because it is drawn at three
+ * times the size and a 10-unit corner on a 300-unit box reads as a square one.
+ */
+export declare const GROUP_RADIUS = 20;
+/**
+ * The group's dashed border.
+ *
+ * Grey and not the flow objects' near-black: a group is furniture drawn AROUND
+ * the work, and it is the one artefact on the canvas guaranteed to overlap
+ * several others. At the neutral stroke it out-shouts everything it encloses,
+ * which is the exact opposite of what a lasso is for. Every tool that draws
+ * BPMN makes the same call; the spec prescribes the dash and says nothing about
+ * the colour.
+ */
+export declare const GROUP_STROKE = "#8e8d91";
 /** Inner-text font for the task label. */
 export declare const INNER_FONT_SIZE = 18;
-/** Default node sizes (model units) per kind. */
+/**
+ * Default node sizes (model units) per kind.
+ *
+ * Three sizes carry the whole scale: the 56-unit event, the 120×72 task and the
+ * 72-unit gateway. Everything the descriptive profile adds takes one of them —
+ * a message start is a start event, a user task is a task — except the three
+ * data/artifact shapes, which have no sibling to inherit from:
+ *
+ *  - `dataObject` is a PORTRAIT page (3:4), 64 tall so it stands beside a
+ *    56-unit event without looking like a shrunken task;
+ *  - `dataStore` is the event's own diameter, which is what a cylinder needs to
+ *    read as one rather than as a squashed ellipse;
+ *  - `textAnnotation` is wider than a task and shorter — it holds a sentence,
+ *    not a verb phrase.
+ *
+ * These three are ~1.2–1.4× bpmn.io's normative pixel sizes, which is the ratio
+ * this pack's event and task already sit at against the same reference.
+ *
+ * `group` is on no scale at all: it is a LASSO, so it has to be born big enough
+ * to have something in it. 300×200 holds two tasks and the arrow between them,
+ * which is the smallest thing anybody draws a group around.
+ */
 export declare const NODE_SIZE: Record<BpmnNodeKind, {
     w: number;
     h: number;
 }>;
-/** Default inner text per kind (only the task carries a label). */
+/**
+ * Default inner text per kind.
+ *
+ * The activities carry one, because a rectangle with nothing written in it says
+ * nothing at all. Events and gateways do not: their meaning is the glyph, and
+ * BPMN puts whatever name they have OUTSIDE the symbol.
+ *
+ * `dataObject` and `dataStore` are empty for the same reason plus one of our
+ * own: the spec puts their name under the shape, the native inner text can only
+ * go inside it, and inside is where the folded page and the cylinder already
+ * are. The user can still type — the text simply overflows, which is the
+ * honest failure rather than a label painted over the glyph.
+ */
 export declare const NODE_LABEL: Record<BpmnNodeKind, string>;
-/** Pool (background container) defaults. */
+/**
+ * Pool (background container) defaults — read by the `BPMN_POOL_BACKGROUND`
+ * declaration (`background.ts`), which is the only thing that draws a pool.
+ */
 export declare const POOL_BAND_WIDTH = 28;
 export declare const POOL_FRAME_COLOR = "#262626";
+/**
+ * The card. The same white every framework background paints — it is what
+ * `DEFAULT_BACKGROUND_SURFACE` gives a declaration that names no fill, and what
+ * the Wardley map, the Core Domain Chart and the Context Map board all declare.
+ */
+export declare const POOL_CARD_FILL = "#ffffff";
 export declare const POOL_BAND_FILL = "#f4f4f5";
 export declare const POOL_FRAME_WIDTH = 1.5;
+export declare const POOL_CORNER_RADIUS = 6;
 export declare const POOL_NAME_FONT_SIZE = 15;
 export declare const POOL_NAME_COLOR = "#262626";
 export declare const POOL_FONT_FAMILY = "Inter, sans-serif";
+/**
+ * Lane (couloir) name size — two units under the participant's own.
+ *
+ * The pool names WHO does the work and the lane names which part of them does
+ * it: a subdivision reads as a subdivision when its label is quieter than the
+ * one it sits under. Two units is the smallest difference that survives being
+ * zoomed out, which is the size the distinction has to hold at.
+ */
+export declare const POOL_LANE_NAME_FONT_SIZE = 13;
+/**
+ * Width of a lane's own title band, in model units — the strip immediately
+ * inside the participant band, with the lane name turned on its side.
+ *
+ * Four units narrower than {@link POOL_BAND_WIDTH}, and for the same reason the
+ * font is two points smaller: the two strips sit side by side, so the
+ * subordinate one has to say so. Identical widths read as a single 56-unit
+ * gutter rather than as a participant containing lanes, which is exactly the
+ * relationship the picture has to carry.
+ *
+ * NO fill, divider only — what bpmn.io, Camunda and Visio all draw. A second
+ * grey strip beside the pool's own would double the furniture and leave the
+ * flow area looking inset by two margins.
+ */
+export declare const POOL_LANE_BAND_WIDTH = 24;
+/**
+ * How close to an internal lane boundary a pointer has to be, in MODEL units,
+ * for the gesture to be a separator drag rather than a click on the pool.
+ *
+ * Symmetric, so the zone is 12 units wide. Model units and not view pixels on
+ * purpose: the grab zone then scales with the drawing, exactly like the lane it
+ * belongs to, and a pool zoomed out to a thumbnail does not become a strip of
+ * overlapping hit zones with no lane left between them.
+ */
+export declare const POOL_LANE_GRAB = 6;
+/**
+ * The smallest a lane may be dragged to, in model units of a pool at its
+ * REFERENCE height ({@link POOL_REF_HEIGHT}).
+ *
+ * A floor and not a minimum height: sizes are weights, so this is converted to
+ * a weight against the pool's current total before it is applied. 24 units is
+ * about one line of a lane name plus its inset — below that the band cannot
+ * show what it is, and a lane nothing can be put in and nothing can be read off
+ * is one the user did not mean to make.
+ */
+export declare const POOL_LANE_MIN_HEIGHT = 24;
+/**
+ * The size a fresh pool is created at. Unlike a map, a pool is NOT grown to
+ * cover the ones already on the board: pools sit side by side, one per
+ * participant, and a second lane that matched the first one's height would
+ * claim room the process has not asked for.
+ *
+ * `actions.ts` and the templates still write these two numbers themselves; the
+ * declaration names them so there is somewhere for them to converge.
+ */
+export declare const POOL_REF_WIDTH = 560;
+export declare const POOL_REF_HEIGHT = 200;
 /** Sequence-flow connector preset. */
 export declare const SEQUENCE_STROKE = "#262626";
 export declare const SEQUENCE_WIDTH = 2;
+/**
+ * Message-flow connector preset — the dashed line that crosses between pools.
+ *
+ * Same ink and same weight as the sequence flow: what tells the two apart is
+ * the DASH and the endpoints (an open circle where the message leaves, an open
+ * arrowhead where it lands), which is exactly the distinction BPMN draws.
+ */
+export declare const MESSAGE_STROKE = "#262626";
+export declare const MESSAGE_WIDTH = 2;
+/**
+ * Association connector preset — the line that ties a note or a data object to
+ * the work it is about.
+ *
+ * ## Dashed, not dotted (simplification, and why it is survivable)
+ *
+ * BPMN draws a message flow DASHED and an association DOTTED. This editor's
+ * `StrokeStyle` has three members — `Solid`, `Dash`, `None` — and the dash
+ * pattern is a fixed `[12, 12]` no framework can tighten, so there is no dotted
+ * stroke to ask for. Drawing it thinner instead is not available either: a
+ * connector's `strokeWidth` is a closed enum (`2 | 4 | … | 12`) the props store
+ * validates, and 2 is already the floor.
+ *
+ * So the association ships with the message flow's own line, and carries the
+ * distinction entirely on its ENDPOINTS: a message flow always shows a circle
+ * where it leaves and an arrowhead where it lands, an association shows neither
+ * at either end. That is a difference the eye reads at a glance and, unlike the
+ * dot pattern, it is one the notation itself means — an association has no
+ * direction to point in. A rule reads the `role`, which is exact either way.
+ */
+export declare const ASSOCIATION_STROKE = "#262626";
+export declare const ASSOCIATION_WIDTH = 2;

package/dist/consts.js

@@ -16,32 +16,221 @@ export const NODE_FILL = '#ffffff';
 export const START_WIDTH = 2;
 export const END_WIDTH = 4;
 export const NODE_STROKE_WIDTH = 2;
+/**
+ * The call activity's border, which the spec draws THICK — it is the one way to
+ * tell it from the sub-process, since both carry the same `+` marker. Same
+ * weight as the end-event ring, and for the same reason: this is the heaviest
+ * line the notation uses, and it is spent on "this one stands for a whole
+ * process defined somewhere else".
+ */
+export const CALL_ACTIVITY_WIDTH = END_WIDTH;
 /** Task corner radius (absolute px — a lightly rounded rectangle). */
 export const TASK_RADIUS = 10;
+/**
+ * The group's corner radius — twice a task's, because it is drawn at three
+ * times the size and a 10-unit corner on a 300-unit box reads as a square one.
+ */
+export const GROUP_RADIUS = 20;
+/**
+ * The group's dashed border.
+ *
+ * Grey and not the flow objects' near-black: a group is furniture drawn AROUND
+ * the work, and it is the one artefact on the canvas guaranteed to overlap
+ * several others. At the neutral stroke it out-shouts everything it encloses,
+ * which is the exact opposite of what a lasso is for. Every tool that draws
+ * BPMN makes the same call; the spec prescribes the dash and says nothing about
+ * the colour.
+ */
+export const GROUP_STROKE = '#8e8d91';
 /** Inner-text font for the task label. */
 export const INNER_FONT_SIZE = 18;
-/** Default node sizes (model units) per kind. */
+/**
+ * Default node sizes (model units) per kind.
+ *
+ * Three sizes carry the whole scale: the 56-unit event, the 120×72 task and the
+ * 72-unit gateway. Everything the descriptive profile adds takes one of them —
+ * a message start is a start event, a user task is a task — except the three
+ * data/artifact shapes, which have no sibling to inherit from:
+ *
+ *  - `dataObject` is a PORTRAIT page (3:4), 64 tall so it stands beside a
+ *    56-unit event without looking like a shrunken task;
+ *  - `dataStore` is the event's own diameter, which is what a cylinder needs to
+ *    read as one rather than as a squashed ellipse;
+ *  - `textAnnotation` is wider than a task and shorter — it holds a sentence,
+ *    not a verb phrase.
+ *
+ * These three are ~1.2–1.4× bpmn.io's normative pixel sizes, which is the ratio
+ * this pack's event and task already sit at against the same reference.
+ *
+ * `group` is on no scale at all: it is a LASSO, so it has to be born big enough
+ * to have something in it. 300×200 holds two tasks and the arrow between them,
+ * which is the smallest thing anybody draws a group around.
+ */
 export const NODE_SIZE = {
     startEvent: { w: 56, h: 56 },
+    startEventMessage: { w: 56, h: 56 },
+    startEventTimer: { w: 56, h: 56 },
     endEvent: { w: 56, h: 56 },
+    endEventMessage: { w: 56, h: 56 },
+    endEventTerminate: { w: 56, h: 56 },
     task: { w: 120, h: 72 },
+    taskUser: { w: 120, h: 72 },
+    taskService: { w: 120, h: 72 },
+    subProcess: { w: 120, h: 72 },
+    callActivity: { w: 120, h: 72 },
     gatewayExclusive: { w: 72, h: 72 },
+    gatewayParallel: { w: 72, h: 72 },
+    dataObject: { w: 48, h: 64 },
+    dataStore: { w: 56, h: 56 },
+    textAnnotation: { w: 140, h: 48 },
+    group: { w: 300, h: 200 },
 };
-/** Default inner text per kind (only the task carries a label). */
+/**
+ * Default inner text per kind.
+ *
+ * The activities carry one, because a rectangle with nothing written in it says
+ * nothing at all. Events and gateways do not: their meaning is the glyph, and
+ * BPMN puts whatever name they have OUTSIDE the symbol.
+ *
+ * `dataObject` and `dataStore` are empty for the same reason plus one of our
+ * own: the spec puts their name under the shape, the native inner text can only
+ * go inside it, and inside is where the folded page and the cylinder already
+ * are. The user can still type — the text simply overflows, which is the
+ * honest failure rather than a label painted over the glyph.
+ */
 export const NODE_LABEL = {
     startEvent: '',
+    startEventMessage: '',
+    startEventTimer: '',
     endEvent: '',
+    endEventMessage: '',
+    endEventTerminate: '',
     task: 'Task',
+    taskUser: 'User task',
+    taskService: 'Service task',
+    subProcess: 'Sub-process',
+    callActivity: 'Call activity',
     gatewayExclusive: '',
+    gatewayParallel: '',
+    dataObject: '',
+    dataStore: '',
+    // The one artefact that IS its text.
+    textAnnotation: 'Annotation',
+    // The group's label is a CategoryValue in the spec. A plain editable string
+    // is the v1 of that: it names the lasso, and it is drawn top-left rather than
+    // centred so it does not float over whatever the group encloses.
+    group: 'Group',
 };
-/** Pool (background container) defaults. */
+/**
+ * Pool (background container) defaults — read by the `BPMN_POOL_BACKGROUND`
+ * declaration (`background.ts`), which is the only thing that draws a pool.
+ */
 export const POOL_BAND_WIDTH = 28;
 export const POOL_FRAME_COLOR = '#262626';
+/**
+ * The card. The same white every framework background paints — it is what
+ * `DEFAULT_BACKGROUND_SURFACE` gives a declaration that names no fill, and what
+ * the Wardley map, the Core Domain Chart and the Context Map board all declare.
+ */
+export const POOL_CARD_FILL = '#ffffff';
 export const POOL_BAND_FILL = '#f4f4f5';
 export const POOL_FRAME_WIDTH = 1.5;
+export const POOL_CORNER_RADIUS = 6;
 export const POOL_NAME_FONT_SIZE = 15;
 export const POOL_NAME_COLOR = '#262626';
 export const POOL_FONT_FAMILY = 'Inter, sans-serif';
+/**
+ * Lane (couloir) name size — two units under the participant's own.
+ *
+ * The pool names WHO does the work and the lane names which part of them does
+ * it: a subdivision reads as a subdivision when its label is quieter than the
+ * one it sits under. Two units is the smallest difference that survives being
+ * zoomed out, which is the size the distinction has to hold at.
+ */
+export const POOL_LANE_NAME_FONT_SIZE = 13;
+/**
+ * Width of a lane's own title band, in model units — the strip immediately
+ * inside the participant band, with the lane name turned on its side.
+ *
+ * Four units narrower than {@link POOL_BAND_WIDTH}, and for the same reason the
+ * font is two points smaller: the two strips sit side by side, so the
+ * subordinate one has to say so. Identical widths read as a single 56-unit
+ * gutter rather than as a participant containing lanes, which is exactly the
+ * relationship the picture has to carry.
+ *
+ * NO fill, divider only — what bpmn.io, Camunda and Visio all draw. A second
+ * grey strip beside the pool's own would double the furniture and leave the
+ * flow area looking inset by two margins.
+ */
+export const POOL_LANE_BAND_WIDTH = 24;
+/**
+ * How close to an internal lane boundary a pointer has to be, in MODEL units,
+ * for the gesture to be a separator drag rather than a click on the pool.
+ *
+ * Symmetric, so the zone is 12 units wide. Model units and not view pixels on
+ * purpose: the grab zone then scales with the drawing, exactly like the lane it
+ * belongs to, and a pool zoomed out to a thumbnail does not become a strip of
+ * overlapping hit zones with no lane left between them.
+ */
+export const POOL_LANE_GRAB = 6;
+/**
+ * The smallest a lane may be dragged to, in model units of a pool at its
+ * REFERENCE height ({@link POOL_REF_HEIGHT}).
+ *
+ * A floor and not a minimum height: sizes are weights, so this is converted to
+ * a weight against the pool's current total before it is applied. 24 units is
+ * about one line of a lane name plus its inset — below that the band cannot
+ * show what it is, and a lane nothing can be put in and nothing can be read off
+ * is one the user did not mean to make.
+ */
+export const POOL_LANE_MIN_HEIGHT = 24;
+// The lane-name hit box used to be a corner box declared here
+// (`POOL_LANE_NAME_HIT_WIDTH` / `_HEIGHT`). Since the PO's recette moved the
+// name into a title band, the target IS that band: `element-view.ts` reads it
+// from `backgroundInstanceZoneBand`, so there is nothing left to declare and
+// nothing left that can drift away from what is painted.
+/**
+ * The size a fresh pool is created at. Unlike a map, a pool is NOT grown to
+ * cover the ones already on the board: pools sit side by side, one per
+ * participant, and a second lane that matched the first one's height would
+ * claim room the process has not asked for.
+ *
+ * `actions.ts` and the templates still write these two numbers themselves; the
+ * declaration names them so there is somewhere for them to converge.
+ */
+export const POOL_REF_WIDTH = 560;
+export const POOL_REF_HEIGHT = 200;
 /** Sequence-flow connector preset. */
 export const SEQUENCE_STROKE = '#262626';
 export const SEQUENCE_WIDTH = 2;
+/**
+ * Message-flow connector preset — the dashed line that crosses between pools.
+ *
+ * Same ink and same weight as the sequence flow: what tells the two apart is
+ * the DASH and the endpoints (an open circle where the message leaves, an open
+ * arrowhead where it lands), which is exactly the distinction BPMN draws.
+ */
+export const MESSAGE_STROKE = '#262626';
+export const MESSAGE_WIDTH = 2;
+/**
+ * Association connector preset — the line that ties a note or a data object to
+ * the work it is about.
+ *
+ * ## Dashed, not dotted (simplification, and why it is survivable)
+ *
+ * BPMN draws a message flow DASHED and an association DOTTED. This editor's
+ * `StrokeStyle` has three members — `Solid`, `Dash`, `None` — and the dash
+ * pattern is a fixed `[12, 12]` no framework can tighten, so there is no dotted
+ * stroke to ask for. Drawing it thinner instead is not available either: a
+ * connector's `strokeWidth` is a closed enum (`2 | 4 | … | 12`) the props store
+ * validates, and 2 is already the floor.
+ *
+ * So the association ships with the message flow's own line, and carries the
+ * distinction entirely on its ENDPOINTS: a message flow always shows a circle
+ * where it leaves and an arrowhead where it lands, an association shows neither
+ * at either end. That is a difference the eye reads at a glance and, unlike the
+ * dot pattern, it is one the notation itself means — an association has no
+ * direction to point in. A rule reads the `role`, which is exact either way.
+ */
+export const ASSOCIATION_STROKE = '#262626';
+export const ASSOCIATION_WIDTH = 2;

package/dist/element-renderer.d.ts

@@ -1,10 +1,16 @@
 import { type ElementRenderer } from '@formicoidea/labre-core/blocks/surface';
 import type { BpmnPoolElementModel } from '@formicoidea/labre-core/model';
 /**
- * Canvas renderer for a BPMN pool: a rounded-rect frame with a vertical name
- * band on the left (the participant name is drawn rotated, as in the spec).
- * Drawn directly in element space; the band width and font are fixed so they
- * stay legible at any pool size. Mirrors the other framework backgrounds.
+ * Canvas renderer for the BPMN pool.
+ *
+ * There is no BPMN drawing code any more: the pool is an INSTANTIATION of the
+ * framework-background primitive, configured by the `BPMN_POOL_BACKGROUND`
+ * declaration. What used to be ninety lines of hand-traced rounded rectangle,
+ * filled band and rotated name is now a declaration any other framework can
+ * write for itself.
+ *
+ * Exported as a function as well as an extension because the fidelity suite
+ * drives it directly with a canvas stub.
  */
 export declare const bpmnPool: ElementRenderer<BpmnPoolElementModel>;
 export declare const BpmnPoolRendererExtension: import("@formicoidea/labre-core/store").ExtensionType & {

package/dist/element-renderer.js

@@ -1,57 +1,16 @@
-import { ElementRendererExtension, } from '@formicoidea/labre-core/blocks/surface';
-import { POOL_BAND_FILL, POOL_BAND_WIDTH, POOL_FONT_FAMILY, POOL_FRAME_COLOR, POOL_FRAME_WIDTH, POOL_NAME_COLOR, POOL_NAME_FONT_SIZE, } from './consts.js';
-/** Trace a rounded-rectangle path (no dependency on ctx.roundRect). */
-function roundedRectPath(ctx, x, y, w, h, r) {
-    const rr = Math.min(r, w / 2, h / 2);
-    ctx.beginPath();
-    ctx.moveTo(x + rr, y);
-    ctx.lineTo(x + w - rr, y);
-    ctx.arcTo(x + w, y, x + w, y + rr, rr);
-    ctx.lineTo(x + w, y + h - rr);
-    ctx.arcTo(x + w, y + h, x + w - rr, y + h, rr);
-    ctx.lineTo(x + rr, y + h);
-    ctx.arcTo(x, y + h, x, y + h - rr, rr);
-    ctx.lineTo(x, y + rr);
-    ctx.arcTo(x, y, x + rr, y, rr);
-    ctx.closePath();
-}
+import { createFrameworkBackgroundRenderer, ElementRendererExtension, } from '@formicoidea/labre-core/blocks/surface';
+import { BPMN_POOL_BACKGROUND } from './background.js';
 /**
- * Canvas renderer for a BPMN pool: a rounded-rect frame with a vertical name
- * band on the left (the participant name is drawn rotated, as in the spec).
- * Drawn directly in element space; the band width and font are fixed so they
- * stay legible at any pool size. Mirrors the other framework backgrounds.
+ * Canvas renderer for the BPMN pool.
+ *
+ * There is no BPMN drawing code any more: the pool is an INSTANTIATION of the
+ * framework-background primitive, configured by the `BPMN_POOL_BACKGROUND`
+ * declaration. What used to be ninety lines of hand-traced rounded rectangle,
+ * filled band and rotated name is now a declaration any other framework can
+ * write for itself.
+ *
+ * Exported as a function as well as an extension because the fidelity suite
+ * drives it directly with a canvas stub.
  */
-export const bpmnPool = (model, ctx, matrix) => {
-    const [, , w, h] = model.deserializedXYWH;
-    const cx = w / 2;
-    const cy = h / 2;
-    ctx.setTransform(matrix.translateSelf(cx, cy).rotateSelf(model.rotate).translateSelf(-cx, -cy));
-    const band = Math.min(POOL_BAND_WIDTH, w);
-    const inset = POOL_FRAME_WIDTH / 2;
-    // Name band (left), filled.
-    ctx.fillStyle = POOL_BAND_FILL;
-    ctx.fillRect(0, 0, band, h);
-    // Frame + band divider.
-    ctx.strokeStyle = POOL_FRAME_COLOR;
-    ctx.lineWidth = POOL_FRAME_WIDTH;
-    ctx.lineJoin = 'round';
-    roundedRectPath(ctx, inset, inset, w - POOL_FRAME_WIDTH, h - POOL_FRAME_WIDTH, 6);
-    ctx.stroke();
-    ctx.beginPath();
-    ctx.moveTo(band, 0);
-    ctx.lineTo(band, h);
-    ctx.stroke();
-    // Participant name, rotated to read up the band (skip when empty / too narrow).
-    if (model.name && band > 12) {
-        ctx.save();
-        ctx.translate(band / 2, h / 2);
-        ctx.rotate(-Math.PI / 2);
-        ctx.fillStyle = POOL_NAME_COLOR;
-        ctx.font = `600 ${POOL_NAME_FONT_SIZE}px ${POOL_FONT_FAMILY}`;
-        ctx.textAlign = 'center';
-        ctx.textBaseline = 'middle';
-        ctx.fillText(model.name, 0, 0);
-        ctx.restore();
-    }
-};
-export const BpmnPoolRendererExtension = ElementRendererExtension('bpmnPool', bpmnPool);
+export const bpmnPool = createFrameworkBackgroundRenderer(BPMN_POOL_BACKGROUND);
+export const BpmnPoolRendererExtension = ElementRendererExtension(BPMN_POOL_BACKGROUND.type, bpmnPool);

package/dist/element-view.d.ts

@@ -1,21 +1,113 @@
 import type { BpmnPoolElementModel } from '@formicoidea/labre-core/model';
 import { GfxElementModelView } from '@formicoidea/labre-core/std/gfx';
 /**
- * View for a BPMN pool. A double-click edits the participant name in place
- * (single field — the whole pool is the hit target). Mirrors the inline label
- * editor used by the EDGY / Wardley backgrounds.
+ * View for a BPMN pool. Three direct gestures live here:
+ *
+ * - **dblclick in the pool's own title band** — the left margin strip the
+ *   participant name is written up — edits that name in place;
+ * - **dblclick in a lane's title band** edits THAT lane's name instead. A lane
+ *   name is not in the declaration's hit-test walk (`backgroundLabelHits`,
+ *   which Wardley uses): it is a function of the MODEL, not of the declaration,
+ *   so the box comes from `backgroundInstanceZoneBand` — the very rectangle the
+ *   renderer paints the name in, rather than a second set of metrics that would
+ *   one day disagree with it;
+ * - **drag on an internal lane boundary** moves the separator, taking from one
+ *   lane and giving to the other.
+ *
+ * Both renames are ZONED to their band (PO recette, 2026-08-26). The whole pool
+ * used to open the participant editor, which was right while a pool had one
+ * name; with a name per lane it would mean a double-click in the middle of the
+ * flow area renames the participant — neither of the two things the user could
+ * have meant, and the kind of write nobody notices until it is in a
+ * deliverable. A double-click on open canvas inside the pool now does nothing,
+ * and the `text` cursor over either band is what says where the names are.
+ *
+ * ## How the separator drag takes the gesture
+ *
+ * `GfxElementModelView.dispatch` reports a drag as handled whenever a handler
+ * is REGISTERED, without consulting what the handler returned, and the default
+ * tool stands down on that report. A permanently registered `dragstart` would
+ * therefore make a pool undraggable. So the drag handlers are ARMED — attached
+ * while the pointer is over a boundary of a selected pool, detached the moment
+ * it is not — and the pool moves normally everywhere else.
+ *
+ * Arming happens on `pointermove` AND on `pointerdown`, and neither is a hover
+ * requirement: a touch drag emits its first `pointermove` before the drag
+ * threshold is crossed (the move controller listens on the host, the drag
+ * controller on the document, so the host listener runs first), which is what
+ * makes the grab zone work with no hovering at all. The `ns-resize` cursor is a
+ * bonus for whoever has a mouse, never the affordance itself.
+ *
+ * ## The pool must be selected first
+ *
+ * Both the cursor and the grab are gated on the pool being selected. On an
+ * infinite canvas, dragging over an element means "move it"; silently turning a
+ * twelve-unit strip of an UNSELECTED pool into a resize handle would take that
+ * away from a user who never said they were working on this pool. One click
+ * first, and then the strip is live.
+ *
+ * ponytail: a ROTATED pool is not accounted for — the pointer is converted to
+ * element-local coordinates by subtraction, so every hit box here 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, at the one function
+ * that has the element in hand (`_localPoint`), not a new declared field.
  */
 export declare class BpmnPoolView extends GfxElementModelView<BpmnPoolElementModel> {
     static type: string;
     private _nameEditor;
+    /** The boundary the pointer is over, and the handlers armed for it. */
+    private _armed;
+    /** Everything a separator drag needs, frozen at `dragstart`. */
+    private _drag;
     onCreated(): void;
     onDestroyed(): void;
+    /** Hand the cursor back on the way out; nothing here owns it for long. */
+    private _leave;
+    /** The pointer, in element-local model units. */
+    private _localPoint;
+    /**
+     * The boxes the gestures below aim at, all of them delegated to `pool-hit.ts`.
+     *
+     * That module is pure, so every answer here can be asserted without an
+     * editor, a viewport or a canvas; and it derives each box from
+     * `backgroundInstanceZones` / `backgroundInstanceZoneBand`, the same two
+     * functions the renderer paints from and the audit reports from. The view
+     * supplies the pointer and the zoom and nothing else.
+     */
+    private _bands;
+    private _boundaryAt;
+    /** Which name this point aims at, if any — lane strip first, see `pool-hit`. */
+    private _targetAt;
+    private get _editable();
+    /**
+     * One pass over the pointer, deciding both the cursor and whether a
+     * separator drag is armed.
+     *
+     * The order is the order the gestures win in. A separator sits INSIDE a lane
+     * title band at every lane boundary, so the two overlap and something has to
+     * give: the separator takes it, because it is a twelve-unit strip the user
+     * has to aim at deliberately, while the title band is the whole leading edge
+     * and has plenty left over. It is also already gated on the pool being
+     * selected, so on an unselected pool the band wins uncontested.
+     */
+    private _updateHover;
+    private _disarm;
+    private _onDragStart;
+    private _onDragMove;
+    private _onDragEnd;
+    /**
+     * A double-click renames whatever TITLE BAND it landed in, and nothing
+     * otherwise (PO recette, 2026-08-26).
+     *
+     * The whole pool used to open the participant editor. That was right while a
+     * pool had one name; now that every lane carries one it would mean a
+     * double-click in the middle of the flow area renames the participant — not
+     * one of the things the user could have meant, and the kind of write nobody
+     * notices until it is in a deliverable. A double-click on open canvas inside
+     * the pool now does nothing, which is the honest answer.
+     */
     private _onDblClick;
     private _openEditor;
     private _closeEditor;
 }
-/**
- * Resize gating: the resize handles are hidden unless `model.resizeEnabled` is
- * true (toggled from the toolbar). Moving / selecting stays available.
- */
-export declare const BpmnPoolInteraction: import("@formicoidea/labre-core/store").ExtensionType;