@formicoidea/labre-framework-bpmn 0.58.0 → 0.60.0

package/dist/actions.d.ts

@@ -19,7 +19,9 @@ export declare function createBpmnPool(std: BlockStdScope): void;
 /**
  * Arm the native connector tool, pre-styled for a BPMN sequence flow:
  * orthogonal, solid, with a filled triangle head. The user then draws from
- * one node to another (endpoints attach to centers).
+ * one node to another, attaching at the anchor of each outline they pick (a
+ * gateway's corners, an activity's side midpoints, an event's cardinal points;
+ * `BPMN_CENTRE_ANCHORED`).
  */
 export declare function activateBpmnSequenceFlow(std: BlockStdScope): void;
 /**
@@ -102,12 +104,14 @@ export declare function bpmnPoolsForLaneEdit(std: BlockStdScope): BpmnPoolElemen
  */
 export declare function addBpmnLane(std: BlockStdScope): void;
 /**
- * Remove the LAST lane of every selected pool.
+ * Remove the FOCUSED lane of every selected pool, or its LAST lane when none is
+ * focused.
  *
- * The last one and not the selected one, because a lane is not selectable: it
- * is a slice of the pool's plot, painted by the background primitive, with no
- * element of its own. Removing from the end is the gesture that undoes the one
- * that added it.
+ * Focused and not selected, because a lane is not selectable: it is a slice of
+ * the pool's plot, painted by the background primitive, with no element of its
+ * own. A single click on its title strip, in a selected pool, focuses it
+ * ({@link bpmnFocusedLaneIndex}). With nothing focused, removing from the end
+ * is the gesture that undoes the one that added it.
  *
  * ## Nothing moves
  *
@@ -221,3 +225,69 @@ export declare function importBpmnSvgFile(std: BlockStdScope): Promise<void>;
  * same thing that only the bytes can tell apart.
  */
 export declare function renameBpmnLane(std: BlockStdScope, model: BpmnPoolElementModel, index: number, name: string): void;
+/**
+ * Move the lane at `from` to `to` inside `pool`, carrying what is drawn in it.
+ *
+ * A lane is a slice of the pool's plot, and what is "in" it is decided by
+ * geometry: the centre of an artefact, read by {@link bpmnLaneOf}. Reordering
+ * the `lanes` array alone would leave every task where it was on the canvas and
+ * silently hand it to whichever lane now covers that spot — the user moves the
+ * Sales lane up and finds their sales tasks filed under Ops. So the gesture
+ * moves both: the array is reordered, and every unlocked artefact wholly inside
+ * the pool is translated by the vertical shift of the lane its centre was in.
+ * Connectors attached to them follow through the connector watcher, as on any
+ * other move.
+ *
+ * A GESTURE-time write, not a cascade: it runs once, on the author's client,
+ * from a command, and a peer receives the reorder and the moves as ordinary
+ * updates. No stored-format change either: the same `lanes` array, the same
+ * `xywh` props.
+ *
+ * One `captureSync`, then one `transact`, so the reorder and every move are ONE
+ * undo step. Refused — and nothing written, so no empty undo entry — on a
+ * read-only document, a locked pool, an index that names no lane, or a move to
+ * where the lane already is. Returns whether it wrote.
+ *
+ * ponytail: a connector attached to nothing, drawn inside a lane, stays where
+ * it is, and a locked artefact is left behind; the upgrade is to translate the
+ * free endpoints too, here and nowhere else.
+ */
+export declare function moveBpmnLane(std: BlockStdScope, pool: BpmnPoolElementModel, from: number, to: number): boolean;
+/**
+ * Something that knows which lane of a pool is FOCUSED — the pool's view
+ * (`BpmnPoolView`) in an editor, a plain object in a test.
+ *
+ * A lane is not an element, so it cannot be selected; the lane commands need
+ * another way to know which lane the user means. The focus is set by a single
+ * click on a lane's title strip in a selected pool, and it is on-screen state
+ * and nothing more: held by the view, never stored, never synced, dropped when
+ * the pool is deselected. Another viewer of the same document has their own or
+ * none. An id rather than an index, so the focus follows the lane it names
+ * through a move.
+ */
+export interface BpmnLaneFocusHolder {
+    readonly focusedLaneId: string | null;
+}
+/**
+ * The index of `pool`'s focused lane in this editor, or `null` when none is
+ * focused or the focused one is gone (removed by a peer, undone away).
+ *
+ * Read through {@link BpmnLaneFocusHolder} rather than the view class, so the
+ * commands do not import the view.
+ */
+export declare function bpmnFocusedLaneIndex(std: BlockStdScope, pool: BpmnPoolElementModel): number | null;
+/**
+ * The selected pool whose focused lane can move one step `by` (`-1` up, `1`
+ * down), and the lane's index — `null` when no such pool is selected.
+ *
+ * The first one that qualifies: a lane is focused by clicking it, on one pool
+ * at a time, so a selection holding two pools still names at most one lane.
+ */
+export declare function bpmnLaneToMove(std: BlockStdScope, by: -1 | 1): {
+    pool: BpmnPoolElementModel;
+    index: number;
+} | null;
+/** Move the focused lane of the selected pool one step up. */
+export declare function moveBpmnLaneUp(std: BlockStdScope): void;
+/** Move the focused lane of the selected pool one step down. */
+export declare function moveBpmnLaneDown(std: BlockStdScope): void;

package/dist/actions.js

@@ -1,16 +1,18 @@
-import { DefaultTool, EdgelessCRUDIdentifier, generateElementId, materializeInterchangeImport, reportInterchangeImport, runInterchangeImportFile, } from '@formicoidea/labre-core/blocks/surface';
+import { backgroundInstanceZones, backgroundPlot, DefaultTool, EdgelessCRUDIdentifier, generateElementId, materializeInterchangeImport, reportInterchangeImport, runInterchangeImportFile, } from '@formicoidea/labre-core/blocks/surface';
 import { ConnectorTool } from '@formicoidea/labre-core/gfx/connector';
 import { createGroupCommand } from '@formicoidea/labre-core/gfx/group';
-import { BpmnPoolElementModel, ConnectorMode, } from '@formicoidea/labre-core/model';
+import { BpmnPoolElementModel, ConnectorElementModel, ConnectorMode, } from '@formicoidea/labre-core/model';
 import { NotificationProvider, translateKey, } from '@formicoidea/labre-core/shared/services';
 import { downloadBlob } from '@formicoidea/labre-core/shared/utils';
 import { Bound } from '@formicoidea/labre-core/global/gfx';
-import { GfxControllerIdentifier } from '@formicoidea/labre-core/std/gfx';
-import { BPMN_EDGE_STYLE, bpmnLabelMode, LANE_NAME_FALLBACK, LANE_NAME_KEY, NODE_LABEL, nodeLabelKey, NODE_SIZE, POOL_NAME_FALLBACK, POOL_NAME_KEY, } from './consts.js';
+import { GfxControllerIdentifier, GfxGroupLikeElementModel, } from '@formicoidea/labre-core/std/gfx';
+import { BPMN_POOL_BACKGROUND } from './background.js';
+import { BPMN_EDGE_STYLE, LANE_NAME_FALLBACK, LANE_NAME_KEY, NODE_LABEL, nodeLabelKey, NODE_SIZE, POOL_NAME_FALLBACK, POOL_NAME_KEY, POOL_REF_HEIGHT, POOL_REF_WIDTH, } from './consts.js';
 import { BPMN_FORMAT_ID, exportBpmnXmlWithWarnings, } from './export.js';
+import { bpmnLaneOf } from './facts.js';
 import { BPMN_SVG_IMPORT, BPMN_XML_EXPORT, BPMN_XML_FORMAT, BPMN_XML_IMPORT, bpmnBoardFrom, bpmnSafeFilename, } from './interchange.js';
-import { bpmnLabelBoxFor, bpmnLabelProps, bpmnNodeProps, bpmnPoolProps, } from './presets.js';
 import { BPMN_ROLE } from './roles.js';
+import { bpmnNodeElements, bpmnPoolElement } from './toolbox.js';
 /**
  * Standalone creation/activation actions for the BPMN toolbox — lifted out of
  * `toolbar/bpmn-menu.ts` by PF3 so the menu becomes a pure renderer over the
@@ -52,30 +54,29 @@ export function createBpmnNode(std, kind) {
         return;
     const { w, h } = NODE_SIZE[kind];
     const { centerX: cx, centerY: cy } = gfx.viewport;
-    // Translated HERE and once: the caption is document content the moment it
-    // lands, so the host's catalogue is asked at placement and never again
-    // (`nodeLabelKey`, and #183 on why a French board should not start in
-    // English).
-    const seed = NODE_LABEL[kind]
-        ? translateKey(std, nodeLabelKey(kind), NODE_LABEL[kind])
-        : undefined;
-    const external = bpmnLabelMode(kind) === 'external';
-    // What a node IS lives in one place (`./presets.ts`), because the importer
-    // creates the same artefacts out of a `.bpmn` file and the two must not
-    // drift: a task read from a file and a task drawn here are one element type
-    // in the document, down to the stroke width. The gesture owns the BOX and
-    // nothing else.
-    const id = surface.addElement(bpmnNodeProps(kind, {
-        xywh: new Bound(cx - w / 2, cy - h / 2, w, h).serialize(),
-        text: external ? undefined : seed,
-    }));
-    if (!external || seed === undefined) {
-        finish(gfx, id);
-        return;
+    // The elements come from the ONE assembly a host with no editor also calls
+    // (`toolbox.ts`, `docs/adr/0045`), on the presets the importer reads too
+    // (`presets.ts`): a task drawn here, one read from a `.bpmn` file and one a
+    // host places are one element type in the document, down to the stroke
+    // width. What only an editor has stays here: the viewport centre, and the
+    // caption translated HERE and once (`nodeLabelKey`, and #183 on why a French
+    // board should not start in English).
+    const elements = bpmnNodeElements(kind, { x: cx - w / 2, y: cy - h / 2 }, { name: translateKey(std, nodeLabelKey(kind), NODE_LABEL[kind]) });
+    const minted = new Map();
+    for (const { id: local, ...props } of elements) {
+        if (props.type === 'group') {
+            // Through the native group command and not `addElement`: the group's
+            // seed title is numbered against the groups already on the board, and
+            // its user layer is its highest member's (ADR 0031) — both the editor's.
+            const children = Object.keys(props.children);
+            finish(gfx, group(gfx, children.map(child => minted.get(child) ?? child)));
+            return;
+        }
+        minted.set(local, surface.addElement(props));
     }
-    const { x, y } = bpmnLabelBoxFor(kind, cx, cy);
-    const labelId = surface.addElement(bpmnLabelProps(seed, x, y));
-    finish(gfx, group(gfx, [id, labelId]));
+    const id = minted.get(`${kind}:node`);
+    if (id)
+        finish(gfx, id);
 }
 /** Create a pool (background container) centred on the viewport. */
 export function createBpmnPool(std) {
@@ -83,29 +84,27 @@ export function createBpmnPool(std) {
     const surface = gfx.surface;
     if (!surface)
         return;
-    const w = 560;
-    const h = 200;
     const { centerX: cx, centerY: cy } = gfx.viewport;
-    // What a pool IS lives in one place (`./presets.ts`), beside what a node is
-    // and for the same reason: the shipped cards build their participants from it
-    // too, so a pool laid out by a template and one dropped from the toolbox
-    // cannot say different things. The gesture owns the BOX and nothing else.
+    // What a pool IS lives in one place (`bpmnPoolElement`, `toolbox.ts`, over
+    // `bpmnPoolProps`), beside what a node is and for the same reason: the
+    // shipped cards and a host build their participants from it too, so a pool
+    // laid out by a template, one a host places and one dropped from the toolbox
+    // cannot say different things. The gesture owns the centre and nothing else.
     //
     // The NAME is the one exception, and it is written HERE rather than left to
     // the model's default (`BpmnPoolElementModel.name = 'Pool'`, a red-zone
     // field: a document created before this key existed keeps its literal
     // 'Pool' verbatim). Resolved at placement and never again — content from
     // the moment it lands, exactly like a node's caption.
-    const id = surface.addElement(bpmnPoolProps({
-        xywh: new Bound(cx - w / 2, cy - h / 2, w, h).serialize(),
-        name: translateKey(std, POOL_NAME_KEY, POOL_NAME_FALLBACK),
-    }));
-    finish(gfx, id);
+    const { id: _local, ...props } = bpmnPoolElement({ x: cx - POOL_REF_WIDTH / 2, y: cy - POOL_REF_HEIGHT / 2 }, { name: translateKey(std, POOL_NAME_KEY, POOL_NAME_FALLBACK) });
+    finish(gfx, surface.addElement(props));
 }
 /**
  * Arm the native connector tool, pre-styled for a BPMN sequence flow:
  * orthogonal, solid, with a filled triangle head. The user then draws from
- * one node to another (endpoints attach to centers).
+ * one node to another, attaching at the anchor of each outline they pick (a
+ * gateway's corners, an activity's side midpoints, an event's cardinal points;
+ * `BPMN_CENTRE_ANCHORED`).
  */
 export function activateBpmnSequenceFlow(std) {
     gfxOf(std).tool.setTool(ConnectorTool, {
@@ -280,12 +279,14 @@ export function addBpmnLane(std) {
     }
 }
 /**
- * Remove the LAST lane of every selected pool.
+ * Remove the FOCUSED lane of every selected pool, or its LAST lane when none is
+ * focused.
  *
- * The last one and not the selected one, because a lane is not selectable: it
- * is a slice of the pool's plot, painted by the background primitive, with no
- * element of its own. Removing from the end is the gesture that undoes the one
- * that added it.
+ * Focused and not selected, because a lane is not selectable: it is a slice of
+ * the pool's plot, painted by the background primitive, with no element of its
+ * own. A single click on its title strip, in a selected pool, focuses it
+ * ({@link bpmnFocusedLaneIndex}). With nothing focused, removing from the end
+ * is the gesture that undoes the one that added it.
  *
  * ## Nothing moves
  *
@@ -304,7 +305,13 @@ export function removeBpmnLane(std) {
         return;
     std.store.captureSync();
     for (const model of withLanes) {
-        writeLanes(std, model, bpmnLanesOf(model).slice(0, -1));
+        const lanes = bpmnLanesOf(model);
+        // The FOCUSED lane when the user picked one (a click on its title strip),
+        // the last one otherwise — which is still the one the previous "Add lane"
+        // added.
+        const focused = bpmnFocusedLaneIndex(std, model);
+        const gone = focused ?? lanes.length - 1;
+        writeLanes(std, model, lanes.filter((_, i) => i !== gone));
     }
 }
 /* ── Export (BPMN 2.0 XML) ────────────────────────────────────────────── */
@@ -510,3 +517,126 @@ export function renameBpmnLane(std, model, index, name) {
     std.store.captureSync();
     writeLanes(std, model, next);
 }
+/**
+ * Move the lane at `from` to `to` inside `pool`, carrying what is drawn in it.
+ *
+ * A lane is a slice of the pool's plot, and what is "in" it is decided by
+ * geometry: the centre of an artefact, read by {@link bpmnLaneOf}. Reordering
+ * the `lanes` array alone would leave every task where it was on the canvas and
+ * silently hand it to whichever lane now covers that spot — the user moves the
+ * Sales lane up and finds their sales tasks filed under Ops. So the gesture
+ * moves both: the array is reordered, and every unlocked artefact wholly inside
+ * the pool is translated by the vertical shift of the lane its centre was in.
+ * Connectors attached to them follow through the connector watcher, as on any
+ * other move.
+ *
+ * A GESTURE-time write, not a cascade: it runs once, on the author's client,
+ * from a command, and a peer receives the reorder and the moves as ordinary
+ * updates. No stored-format change either: the same `lanes` array, the same
+ * `xywh` props.
+ *
+ * One `captureSync`, then one `transact`, so the reorder and every move are ONE
+ * undo step. Refused — and nothing written, so no empty undo entry — on a
+ * read-only document, a locked pool, an index that names no lane, or a move to
+ * where the lane already is. Returns whether it wrote.
+ *
+ * ponytail: a connector attached to nothing, drawn inside a lane, stays where
+ * it is, and a locked artefact is left behind; the upgrade is to translate the
+ * free endpoints too, here and nowhere else.
+ */
+export function moveBpmnLane(std, pool, from, to) {
+    if (std.store.readonly || pool.isLocked())
+        return false;
+    if (from === to)
+        return false;
+    const lanes = bpmnLanesOf(pool);
+    if (!lanes[from] || !lanes[to])
+        return false;
+    const next = [...lanes];
+    const [moved] = next.splice(from, 1);
+    next.splice(to, 0, moved);
+    // Each band's top, before and after, read off the painted partition: the
+    // normalisation the renderer and the audit use, so an artefact moves by
+    // exactly the distance its lane moves on the canvas.
+    const frame = pool.elementBound;
+    const plot = backgroundPlot(BPMN_POOL_BACKGROUND, frame.w, frame.h);
+    const topsOf = (rows) => new Map(backgroundInstanceZones(BPMN_POOL_BACKGROUND, { lanes: rows }).map(zone => [zone.id, zone.rect.y * plot.height]));
+    const before = topsOf(lanes);
+    const after = topsOf(next);
+    const prefix = BPMN_POOL_BACKGROUND.instanceZones?.idPrefix ?? 'lane';
+    // Membership BEFORE the write: once the array is reordered the bands are
+    // where the lanes are going, and a centre would read the wrong lane.
+    const moves = [];
+    for (const element of gfxOf(std).grid.search(frame, { strict: true })) {
+        if (element === pool || element.isLocked())
+            continue;
+        // A connector follows its endpoints; a group or a mind map derives its
+        // bound from its children, which are moved on their own.
+        if (element instanceof ConnectorElementModel)
+            continue;
+        if (element instanceof GfxGroupLikeElementModel)
+            continue;
+        const bound = Bound.deserialize(element.xywh);
+        const lane = bpmnLaneOf(pool, bound);
+        if (!lane)
+            continue;
+        const key = `${prefix}:${lane.id}`;
+        const dy = (after.get(key) ?? 0) - (before.get(key) ?? 0);
+        if (dy === 0)
+            continue;
+        moves.push({ id: element.id, xywh: bound.moveDelta(0, dy).serialize() });
+    }
+    std.store.captureSync();
+    std.store.transact(() => {
+        writeLanes(std, pool, next);
+        const crud = std.get(EdgelessCRUDIdentifier);
+        for (const { id, xywh } of moves)
+            crud.updateElement(id, { xywh });
+    });
+    return true;
+}
+/**
+ * The index of `pool`'s focused lane in this editor, or `null` when none is
+ * focused or the focused one is gone (removed by a peer, undone away).
+ *
+ * Read through {@link BpmnLaneFocusHolder} rather than the view class, so the
+ * commands do not import the view.
+ */
+export function bpmnFocusedLaneIndex(std, pool) {
+    const holder = gfxOf(std).view?.get(pool.id);
+    const id = holder?.focusedLaneId;
+    if (!id)
+        return null;
+    const index = bpmnLanesOf(pool).findIndex(lane => lane.id === id);
+    return index < 0 ? null : index;
+}
+/**
+ * The selected pool whose focused lane can move one step `by` (`-1` up, `1`
+ * down), and the lane's index — `null` when no such pool is selected.
+ *
+ * The first one that qualifies: a lane is focused by clicking it, on one pool
+ * at a time, so a selection holding two pools still names at most one lane.
+ */
+export function bpmnLaneToMove(std, by) {
+    for (const pool of bpmnPoolsForLaneEdit(std)) {
+        const index = bpmnFocusedLaneIndex(std, pool);
+        if (index === null)
+            continue;
+        if (!bpmnLanesOf(pool)[index + by])
+            continue;
+        return { pool, index };
+    }
+    return null;
+}
+/** Move the focused lane of the selected pool one step up. */
+export function moveBpmnLaneUp(std) {
+    const target = bpmnLaneToMove(std, -1);
+    if (target)
+        moveBpmnLane(std, target.pool, target.index, target.index - 1);
+}
+/** Move the focused lane of the selected pool one step down. */
+export function moveBpmnLaneDown(std) {
+    const target = bpmnLaneToMove(std, 1);
+    if (target)
+        moveBpmnLane(std, target.pool, target.index, target.index + 1);
+}

package/dist/background.js

@@ -26,7 +26,15 @@ import { BPMN_ROLE } from './roles.js';
  *
  * The left margin IS the name band: `margin.left` is both the room the flow
  * area gives up and the width of the strip the participant name is written in
- * (see `BackgroundSideBandDef`).
+ * (see `BackgroundSideBandDef`) — its MINIMUM width. The name WRAPS up the band
+ * (`fit: 'wrap'`), on words, into as many as three lines side by side, and the
+ * band thickens to hold them: one line fits the declared 28 units, every
+ * further line adds one line height. The PO preferred this to the ellipsis cut
+ * PR #532 shipped (2026-10-27): a band that grows with its name reads as a
+ * title, a name cut short reads as a bug. A name past three lines is still cut
+ * with "…" on the last one, so a pasted paragraph does not eat the pool. The
+ * thickness is derived at paint time (`backgroundBandWidths`) and never
+ * stored, and the stored name stays whole.
  *
  * ## The lanes
  *
@@ -43,6 +51,10 @@ import { BPMN_ROLE } from './roles.js';
  *
  * Each lane wears its own title band inside the pool's — a narrower strip, no
  * fill, one divider, the name turned on its side, exactly as BPMN 2.0 draws it.
+ * A lane name wraps the same way, up to two lines, and every lane's strip takes
+ * the thickness the most demanding name needs (PO, 2026-10-27): strips of
+ * different widths would stagger the lanes' leading edges, and lanes of one
+ * pool are siblings, so they share one edge.
  * The strip is CHROME inside the lane and not a smaller lane: a task dropped on
  * a lane's title band is in that lane, because in BPMN the band belongs to it.
  */
@@ -99,6 +111,13 @@ export const BPMN_POOL_BACKGROUND = {
                 // pool is the same stroke, so the lanes read as the frame continued.
                 divider: { color: '@frame', width: POOL_FRAME_WIDTH },
             },
+            // Wrapped across the strip, which grows to hold the lines — every lane's
+            // strip to the same thickness. Two lines at most: a lane title is a
+            // label, and past two a third line would cost the flow area more than
+            // the name gains; past that it is cut with "…". The stored name stays
+            // whole, and the rename editor shows it in full.
+            fit: 'wrap',
+            maxLines: 2,
             style: {
                 size: POOL_LANE_NAME_FONT_SIZE,
                 color: '@name',
@@ -151,6 +170,12 @@ export const BPMN_POOL_BACKGROUND = {
                     },
                     // Read bottom-to-top, as the spec draws a vertical pool name.
                     vertical: true,
+                    // Wrapped up the band, which grows to hold the lines (three at
+                    // most, the last cut with "…" if the name is longer still). The
+                    // anchor stays half the DECLARED width in from the plot edge; the
+                    // primitive keeps it in the middle of the grown band.
+                    fit: 'wrap',
+                    maxLines: 3,
                 },
             },
         ],

package/dist/commands-manifest.js

@@ -199,6 +199,22 @@ export const bpmnCommandsManifest = [
         scope: 'edgeless',
         defaultKeys: { mac: [], other: [] },
     },
+    {
+        id: 'bpmn.moveLaneUp',
+        owner: 'bpmn',
+        labelKey: 'com.labre.commands.bpmn.moveLaneUp',
+        labelFallback: 'Move lane up',
+        scope: 'edgeless',
+        defaultKeys: { mac: [], other: [] },
+    },
+    {
+        id: 'bpmn.moveLaneDown',
+        owner: 'bpmn',
+        labelKey: 'com.labre.commands.bpmn.moveLaneDown',
+        labelFallback: 'Move lane down',
+        scope: 'edgeless',
+        defaultKeys: { mac: [], other: [] },
+    },
     {
         id: 'bpmn.exportXml',
         owner: 'bpmn',

package/dist/commands.js

@@ -1,9 +1,9 @@
 import { StrokeStyle } from '@formicoidea/labre-core/model';
-import { activateBpmnAssociation, activateBpmnMessageFlow, activateBpmnSequenceFlow, addBpmnLane, bpmnLanesOf, bpmnPoolsForLaneEdit, bpmnPoolsSelected, createBpmnNode, createBpmnPool, exportBpmnXmlFile, importBpmnSvgFile, importBpmnXmlFile, removeBpmnLane, } from './actions.js';
+import { activateBpmnAssociation, activateBpmnMessageFlow, activateBpmnSequenceFlow, addBpmnLane, bpmnLanesOf, bpmnPoolsForLaneEdit, bpmnPoolsSelected, createBpmnNode, createBpmnPool, exportBpmnXmlFile, importBpmnSvgFile, importBpmnXmlFile, bpmnLaneToMove, moveBpmnLaneDown, moveBpmnLaneUp, removeBpmnLane, } from './actions.js';
 import { BPMN_EDGE_STYLE, NODE_FILL, NODE_SIZE, } from './consts.js';
 import { bpmnNodeProps } from './presets.js';
 import { BPMN_ROLE, BPMN_ROLE_OF_KIND } from './roles.js';
-import { bpmnAssociationIcon, bpmnCallActivityIcon, bpmnDataObjectIcon, bpmnDataStoreIcon, bpmnEndIcon, bpmnEndMessageIcon, bpmnEndTerminateIcon, bpmnExportXmlIcon, bpmnGatewayIcon, bpmnGatewayParallelIcon, bpmnGroupIcon, bpmnImportSvgIcon, bpmnImportXmlIcon, bpmnLaneAddIcon, bpmnLaneRemoveIcon, bpmnMessageIcon, bpmnPoolIcon, bpmnSequenceIcon, bpmnStartIcon, bpmnStartMessageIcon, bpmnStartTimerIcon, bpmnSubProcessIcon, bpmnTaskIcon, bpmnTaskServiceIcon, bpmnTaskUserIcon, bpmnTextAnnotationIcon, bpmnToolbarIcon, } from './toolbar/icons.js';
+import { bpmnAssociationIcon, bpmnCallActivityIcon, bpmnDataObjectIcon, bpmnDataStoreIcon, bpmnEndIcon, bpmnEndMessageIcon, bpmnEndTerminateIcon, bpmnExportXmlIcon, bpmnGatewayIcon, bpmnGatewayParallelIcon, bpmnGroupIcon, bpmnImportSvgIcon, bpmnImportXmlIcon, bpmnLaneAddIcon, bpmnLaneDownIcon, bpmnLaneRemoveIcon, bpmnLaneUpIcon, bpmnMessageIcon, bpmnPoolIcon, bpmnSequenceIcon, bpmnStartIcon, bpmnStartMessageIcon, bpmnStartTimerIcon, bpmnSubProcessIcon, bpmnTaskIcon, bpmnTaskServiceIcon, bpmnTaskUserIcon, bpmnTextAnnotationIcon, bpmnToolbarIcon, } from './toolbar/icons.js';
 /**
  * What a spec DOES — its own gesture, or the one its {@link Spec.node} implies.
  *
@@ -493,7 +493,7 @@ const laneCommands = [
         labelKey: 'com.labre.commands.bpmn.removeLane',
         labelFallback: 'Remove lane',
         descriptionKey: 'com.labre.commands.bpmn.removeLane.description',
-        descriptionFallback: 'Remove the last lane of the selected pool. Nothing drawn in it moves.',
+        descriptionFallback: 'Remove the focused lane of the selected pool, or its last lane. Nothing drawn in it moves.',
         iconKey: 'bpmn.lane-remove',
         order: SPECS.length + 1,
         run: removeBpmnLane,
@@ -501,6 +501,36 @@ const laneCommands = [
         // …and additionally: a pool with no lane has none to remove.
         when: std => bpmnPoolsForLaneEdit(std).some(model => bpmnLanesOf(model).length > 0),
     },
+    // The two REORDER commands act on the FOCUSED lane — the one a single click
+    // on its title strip picked in the selected pool (`bpmnFocusedLaneIndex`).
+    // A lane is not an element and cannot be selected, so without a focus there
+    // is no lane to move and the commands are not offered at all.
+    {
+        ...LANE_COMMON,
+        id: 'bpmn.moveLaneUp',
+        labelKey: 'com.labre.commands.bpmn.moveLaneUp',
+        labelFallback: 'Move lane up',
+        descriptionKey: 'com.labre.commands.bpmn.moveLaneUp.description',
+        descriptionFallback: 'Move the focused lane above the one before it, with everything drawn in it.',
+        iconKey: 'bpmn.lane-up',
+        order: SPECS.length + 5,
+        run: moveBpmnLaneUp,
+        telemetry: { framework: 'bpmn', element: 'pool:lane-move-up' },
+        when: std => bpmnLaneToMove(std, -1) !== null,
+    },
+    {
+        ...LANE_COMMON,
+        id: 'bpmn.moveLaneDown',
+        labelKey: 'com.labre.commands.bpmn.moveLaneDown',
+        labelFallback: 'Move lane down',
+        descriptionKey: 'com.labre.commands.bpmn.moveLaneDown.description',
+        descriptionFallback: 'Move the focused lane below the one after it, with everything drawn in it.',
+        iconKey: 'bpmn.lane-down',
+        order: SPECS.length + 6,
+        run: moveBpmnLaneDown,
+        telemetry: { framework: 'bpmn', element: 'pool:lane-move-down' },
+        when: std => bpmnLaneToMove(std, 1) !== null,
+    },
 ];
 /**
  * The EXPORT — the first BPMN command whose subject is the whole board.
@@ -721,6 +751,8 @@ export const bpmnCommandIcons = {
     'bpmn.pool': bpmnPoolIcon,
     'bpmn.lane-add': bpmnLaneAddIcon,
     'bpmn.lane-remove': bpmnLaneRemoveIcon,
+    'bpmn.lane-up': bpmnLaneUpIcon,
+    'bpmn.lane-down': bpmnLaneDownIcon,
     'bpmn.export-xml': bpmnExportXmlIcon,
     'bpmn.import-xml': bpmnImportXmlIcon,
     'bpmn.import-svg': bpmnImportSvgIcon,

package/dist/consts.d.ts

@@ -268,8 +268,8 @@ export declare const POOL_LANE_MIN_HEIGHT = 24;
  * 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.
+ * The toolbox draws its pool at them (`bpmnPoolElement`, which `createBpmnPool`
+ * calls); the templates lay their pools out at sizes of their own.
  */
 export declare const POOL_REF_WIDTH = 560;
 export declare const POOL_REF_HEIGHT = 200;

package/dist/consts.js

@@ -329,8 +329,8 @@ export const POOL_LANE_MIN_HEIGHT = 24;
  * 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.
+ * The toolbox draws its pool at them (`bpmnPoolElement`, which `createBpmnPool`
+ * calls); the templates lay their pools out at sizes of their own.
  */
 export const POOL_REF_WIDTH = 560;
 export const POOL_REF_HEIGHT = 200;

package/dist/element-renderer.d.ts

@@ -1,18 +1,26 @@
 import { type ElementRenderer } from '@formicoidea/labre-core/blocks/surface';
 import type { BpmnPoolElementModel } from '@formicoidea/labre-core/model';
 /**
- * Canvas renderer for the BPMN pool.
+ * Canvas renderer for the BPMN pool: the declared background, then the outline
+ * of the FOCUSED lane, if this editor has one (`BpmnLaneFocusHolder`, held by
+ * the pool's view and never stored).
  *
- * 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.
+ * The outline is the editor talking about the drawing — "this is the lane the
+ * reorder commands will move" — not part of it, so it is the theme's accent
+ * (`--affine-primary-color`, resolved through the renderer) rather than a
+ * notation colour. It is painted only onto the editor's OWN canvases: the SVG
+ * and PNG exports paint through this same renderer into a context of their
+ * own, and a file must not carry an on-screen focus. A renderer with no editor
+ * behind it (a bare unit test) paints none either, and a host that defines no
+ * accent gets none.
+ *
+ * Painted in the transform the primitive left on the context — element-local
+ * units, rotated about the centre like the rest of the pool.
  *
  * 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/_pkgs/store").ExtensionType & {
-    identifier: import("@formicoidea/labre-core/_pkgs/global/di").ServiceIdentifier<ElementRenderer<BpmnPoolElementModel>>;
+export declare const BpmnPoolRendererExtension: import("@formicoidea/labre-core/_pkgs/store/index.js").ExtensionType & {
+    identifier: import("@formicoidea/labre-core/_pkgs/global/di/types.js").ServiceIdentifier<ElementRenderer<BpmnPoolElementModel>>;
 };