@bpmnkit/core 0.0.25 → 0.0.27

package/dist/bpmn/auto-layout.js

@@ -201,19 +201,38 @@ function buildLaneShapes(lanes, nodes, dx, dy, poolY, poolHeaderWidth, laneConte
         const mB = accB && accB.count > 0 ? accB.sum / accB.count : Number.POSITIVE_INFINITY;
         return mA - mB;
     });
-    const tileH = Math.round(poolHeight / sortedLanes.length);
-    return sortedLanes.map((lane, i) => ({
-        id: `${lane.id}_di`,
-        bpmnElement: lane.id,
-        isHorizontal: true,
-        bounds: {
-            x: Math.round(poolHeaderWidth),
-            y: Math.round(poolY + i * tileH),
-            width: Math.round(laneContentWidth),
-            height: Math.round(i === sortedLanes.length - 1 ? poolHeight - i * tileH : tileH),
-        },
-        unknownAttributes: {},
-    }));
+    // Compute proportional weight per lane: node count × row height, minimum 1 row
+    const MIN_LANE_H = 80;
+    const weights = sortedLanes.map((lane) => {
+        const count = nodes.filter((n) => elemToLane.get(n.id) === lane.id).length;
+        return Math.max(count, 1);
+    });
+    const totalWeight = weights.reduce((a, b) => a + b, 0);
+    // Scale proportionally to poolHeight so all lanes fill the pool exactly
+    const scaledHeights = weights.map((w) => Math.round((w / totalWeight) * poolHeight));
+    // Fix last lane for rounding drift
+    if (scaledHeights.length > 0) {
+        scaledHeights[scaledHeights.length - 1] =
+            poolHeight - scaledHeights.slice(0, -1).reduce((a, b) => a + b, 0);
+    }
+    let cumulativeY = 0;
+    return sortedLanes.map((lane, i) => {
+        const laneH = scaledHeights[i] ?? MIN_LANE_H;
+        const shape = {
+            id: `${lane.id}_di`,
+            bpmnElement: lane.id,
+            isHorizontal: true,
+            bounds: {
+                x: Math.round(poolHeaderWidth),
+                y: Math.round(poolY + cumulativeY),
+                width: Math.round(laneContentWidth),
+                height: Math.round(laneH),
+            },
+            unknownAttributes: {},
+        };
+        cumulativeY += laneH;
+        return shape;
+    });
 }
 function addAnnotationShapes(process, layoutNodes, annLocalBounds, allShapes, allEdges, dx, dy) {
     if (process.textAnnotations.length === 0 && process.associations.length === 0)

package/dist/bpmn/bpmn-builder.d.ts

@@ -5,6 +5,11 @@ export interface ElementOptions {
     name?: string;
     isForCompensation?: boolean;
 }
+/** Options for send/receive task elements. */
+export interface MessageTaskOptions extends ElementOptions {
+    /** Message name — generates or reuses a root <bpmn:message> and sets messageRef. */
+    messageName?: string;
+}
 /** Options for creating a start event. */
 export interface StartEventOptions extends ElementOptions {
     /** Timer duration (ISO 8601) — creates a timer start event. */
@@ -252,6 +257,10 @@ export declare class BranchBuilder {
     readonly _textAnnotations: BpmnTextAnnotation[];
     /** @internal */
     readonly _associations: BpmnAssociation[];
+    /** @internal – ID of the last gateway added in this branch (for nested branch() support). */
+    private currentGatewayId;
+    /** @internal – Open ends of nested branches waiting to auto-connect to the next element. */
+    private openBranchEnds;
     private readonly _annCounters;
     private readonly rootErrors;
     private readonly rootMessages;
@@ -269,8 +278,10 @@ export declare class BranchBuilder {
      * Supports forward references (element created later) and backward references (loops).
      */
     connectTo(targetId: string): this;
-    /** @internal – ID of the last element added (or the gateway if branch is empty) */
-    get _lastNodeId(): string;
+    /** @internal – ID of the last element added (or undefined if branches are open). */
+    get _lastNodeId(): string | undefined;
+    /** @internal – Open ends of nested branches that have not yet been connected. */
+    get _openBranchEnds(): string[];
     /** Attach a text annotation to the element at the current cursor position. */
     textAnnotation(text: string): this;
     /** Attach a text annotation to an element by explicit ID. */
@@ -278,8 +289,8 @@ export declare class BranchBuilder {
     serviceTask(id: string, options: ServiceTaskOptions): this;
     userTask(id: string, options?: UserTaskOptions): this;
     scriptTask(id: string, options: ScriptTaskOptions): this;
-    sendTask(id: string, options?: ElementOptions): this;
-    receiveTask(id: string, options?: ElementOptions): this;
+    sendTask(id: string, options?: MessageTaskOptions): this;
+    receiveTask(id: string, options?: MessageTaskOptions): this;
     businessRuleTask(id: string, options?: BusinessRuleTaskOptions): this;
     callActivity(id: string, options: CallActivityOptions): this;
     /** Add an abstract task with no Zeebe extensions. */
@@ -292,6 +303,32 @@ export declare class BranchBuilder {
     parallelGateway(id: string, options?: ElementOptions): this;
     inclusiveGateway(id: string, options?: GatewayOptions): this;
     eventBasedGateway(id: string, options?: ElementOptions): this;
+    /**
+     * Add a boundary event attached to an existing activity in this branch.
+     *
+     * The boundary event is NOT connected by a sequence flow — it attaches via
+     * `attachedToRef`. The builder cursor advances to the boundary event so
+     * subsequent elements chain from it. Use `withBoundary()` if you want the
+     * cursor to return to the task afterward.
+     */
+    boundaryEvent(id: string, options: BoundaryEventOptions): this;
+    /**
+     * Attach a boundary event to the preceding task and build its outgoing path,
+     * then restore the branch cursor to the preceding task so the main branch flow continues.
+     *
+     * @param id - ID for the boundary event element.
+     * @param options - Boundary event options (without `attachedTo` — inferred from cursor).
+     * @param handler - Callback that chains elements from the boundary event.
+     */
+    withBoundary(id: string, options: Omit<BoundaryEventOptions, "attachedTo">, handler: (b: BranchBuilder) => void): this;
+    /**
+     * Create a named branch from the last gateway added inside this branch.
+     *
+     * Works identically to the top-level `ProcessBuilder.branch()` — use
+     * `.condition(expr)` or `.defaultFlow()` inside the callback, finish with
+     * `.connectTo(id)` or an `.endEvent()` to terminate the nested branch.
+     */
+    branch(name: string, callback: (b: BranchBuilder) => void): this;
 }
 /** Builder for the contents of a sub-process or ad-hoc sub-process. */
 export declare class SubProcessContentBuilder {
@@ -307,6 +344,9 @@ export declare class SubProcessContentBuilder {
     private lastNodeId;
     private currentGatewayId;
     private openBranchEnds;
+    private readonly rootMessages;
+    /** @internal */
+    constructor(rootMessages?: BpmnMessage[]);
     private addElement;
     startEvent(id?: string, options?: StartEventOptions): this;
     endEvent(id?: string, options?: EndEventOptions): this;
@@ -317,8 +357,8 @@ export declare class SubProcessContentBuilder {
     userTask(id: string, options?: UserTaskOptions): this;
     businessRuleTask(id: string, options?: BusinessRuleTaskOptions): this;
     callActivity(id: string, options: CallActivityOptions): this;
-    sendTask(id: string, options?: ElementOptions): this;
-    receiveTask(id: string, options?: ElementOptions): this;
+    sendTask(id: string, options?: MessageTaskOptions): this;
+    receiveTask(id: string, options?: MessageTaskOptions): this;
     /** Add an abstract task with no Zeebe extensions. */
     task(id: string, options?: ElementOptions): this;
     exclusiveGateway(id: string, options?: GatewayOptions): this;
@@ -419,9 +459,9 @@ export declare class ProcessBuilder {
     /** Add a user task with optional form reference. */
     userTask(id: string, options?: UserTaskOptions): this;
     /** Add a send task (aspirational). */
-    sendTask(id: string, options?: ElementOptions): this;
+    sendTask(id: string, options?: MessageTaskOptions): this;
     /** Add a receive task (aspirational). */
-    receiveTask(id: string, options?: ElementOptions): this;
+    receiveTask(id: string, options?: MessageTaskOptions): this;
     /** Add a business rule task. */
     businessRuleTask(id: string, options?: BusinessRuleTaskOptions): this;
     /** Add a call activity referencing another process. */

package/dist/bpmn/bpmn-builder.js

@@ -7,6 +7,14 @@ const EXPORTER_VERSION = "0.0.23";
 // ---------------------------------------------------------------------------
 // Internal helpers
 // ---------------------------------------------------------------------------
+function resolveMessage(messageName, rootMessages) {
+    let existing = rootMessages.find((m) => m.name === messageName);
+    if (!existing) {
+        existing = { id: generateId("Message"), name: messageName, unknownAttributes: {} };
+        rootMessages.push(existing);
+    }
+    return existing.id;
+}
 function buildEventDefinitions(opts, rootErrors, rootMessages, rootSignals, rootEscalations) {
     const defs = [];
     if (opts.timerDuration || opts.timerDate || opts.timerCycle) {
@@ -34,15 +42,9 @@ function buildEventDefinitions(opts, rootErrors, rootMessages, rootSignals, root
         defs.push({ type: "error", errorRef });
     }
     if (opts.messageName !== undefined) {
-        let messageRef = opts.messageName;
-        if (rootMessages) {
-            let existing = rootMessages.find((m) => m.name === opts.messageName);
-            if (!existing) {
-                existing = { id: generateId("Message"), name: opts.messageName, unknownAttributes: {} };
-                rootMessages.push(existing);
-            }
-            messageRef = existing.id;
-        }
+        const messageRef = rootMessages
+            ? resolveMessage(opts.messageName, rootMessages)
+            : opts.messageName;
         defs.push({ type: "message", messageRef });
     }
     if (opts.signalName !== undefined) {
@@ -454,6 +456,10 @@ export class BranchBuilder {
     _textAnnotations = [];
     /** @internal */
     _associations = [];
+    /** @internal – ID of the last gateway added in this branch (for nested branch() support). */
+    currentGatewayId;
+    /** @internal – Open ends of nested branches waiting to auto-connect to the next element. */
+    openBranchEnds = [];
     _annCounters = new Map();
     rootErrors;
     rootMessages;
@@ -481,22 +487,34 @@ export class BranchBuilder {
     }
     addElement(element) {
         this._elements.push(element);
-        const flowId = generateId("Flow");
-        const flow = {
-            id: flowId,
-            sourceRef: this.lastNodeId,
-            targetRef: element.id,
-            name: this.isFirstElement ? this.branchName : undefined,
-            conditionExpression: this.isFirstElement && this.pendingCondition
-                ? makeConditionExpression(this.pendingCondition)
-                : undefined,
-            extensionElements: [],
-            unknownAttributes: {},
-        };
-        this._flows.push(flow);
-        if (this.isFirstElement && this.pendingDefault) {
-            this._defaultFlowId = flowId;
+        if (this.lastNodeId) {
+            const flowId = generateId("Flow");
+            const flow = {
+                id: flowId,
+                sourceRef: this.lastNodeId,
+                targetRef: element.id,
+                name: this.isFirstElement ? this.branchName : undefined,
+                conditionExpression: this.isFirstElement && this.pendingCondition
+                    ? makeConditionExpression(this.pendingCondition)
+                    : undefined,
+                extensionElements: [],
+                unknownAttributes: {},
+            };
+            this._flows.push(flow);
+            if (this.isFirstElement && this.pendingDefault) {
+                this._defaultFlowId = flowId;
+            }
         }
+        for (const branchEnd of this.openBranchEnds) {
+            this._flows.push({
+                id: generateId("Flow"),
+                sourceRef: branchEnd,
+                targetRef: element.id,
+                extensionElements: [],
+                unknownAttributes: {},
+            });
+        }
+        this.openBranchEnds = [];
         this.isFirstElement = false;
         this.lastNodeId = element.id;
         return this;
@@ -509,6 +527,7 @@ export class BranchBuilder {
         const flowId = generateId("Flow");
         const flow = {
             id: flowId,
+            // biome-ignore lint/style/noNonNullAssertion: lastNodeId starts as gatewayId and is always defined in pre-branch context
             sourceRef: this.lastNodeId,
             targetRef: targetId,
             name: this.isFirstElement ? this.branchName : undefined,
@@ -527,13 +546,18 @@ export class BranchBuilder {
         this._connected = true;
         return this;
     }
-    /** @internal – ID of the last element added (or the gateway if branch is empty) */
+    /** @internal – ID of the last element added (or undefined if branches are open). */
     get _lastNodeId() {
         return this.lastNodeId;
     }
+    /** @internal – Open ends of nested branches that have not yet been connected. */
+    get _openBranchEnds() {
+        return this.openBranchEnds;
+    }
     // ---- Annotations ----
     /** Attach a text annotation to the element at the current cursor position. */
     textAnnotation(text) {
+        // biome-ignore lint/style/noNonNullAssertion: lastNodeId starts as gatewayId and is always defined in pre-branch context
         return this.annotate(this.lastNodeId, text);
     }
     /** Attach a text annotation to an element by explicit ID. */
@@ -565,12 +589,16 @@ export class BranchBuilder {
         const el = makeFlowElement(id, "sendTask", options);
         if (options?.isForCompensation)
             el.isForCompensation = true;
+        if (options?.messageName)
+            el.messageRef = resolveMessage(options.messageName, this.rootMessages);
         return this.addElement(el);
     }
     receiveTask(id, options) {
         const el = makeFlowElement(id, "receiveTask", options);
         if (options?.isForCompensation)
             el.isForCompensation = true;
+        if (options?.messageName)
+            el.messageRef = resolveMessage(options.messageName, this.rootMessages);
         return this.addElement(el);
     }
     businessRuleTask(id, options) {
@@ -615,17 +643,121 @@ export class BranchBuilder {
         return this.addElement(el);
     }
     exclusiveGateway(id, options) {
+        this.currentGatewayId = id;
         return this.addElement(makeExclusiveGatewayEl(id, options));
     }
     parallelGateway(id, options) {
+        this.currentGatewayId = id;
         return this.addElement(makeFlowElement(id, "parallelGateway", options));
     }
     inclusiveGateway(id, options) {
+        this.currentGatewayId = id;
         return this.addElement(makeInclusiveGatewayEl(id, options));
     }
     eventBasedGateway(id, options) {
+        this.currentGatewayId = id;
         return this.addElement(makeFlowElement(id, "eventBasedGateway", options));
     }
+    /**
+     * Add a boundary event attached to an existing activity in this branch.
+     *
+     * The boundary event is NOT connected by a sequence flow — it attaches via
+     * `attachedToRef`. The builder cursor advances to the boundary event so
+     * subsequent elements chain from it. Use `withBoundary()` if you want the
+     * cursor to return to the task afterward.
+     */
+    boundaryEvent(id, options) {
+        const element = makeFlowElement(id, "boundaryEvent", options);
+        if (element.type === "boundaryEvent") {
+            element.attachedToRef = options.attachedTo;
+            element.cancelActivity = options.cancelActivity;
+            element.eventDefinitions = buildEventDefinitions(options, this.rootErrors, this.rootMessages, this.rootSignals, this.rootEscalations);
+        }
+        // Push directly — no sequence flow, boundary events attach via attachedToRef
+        this._elements.push(element);
+        this.lastNodeId = element.id;
+        this.isFirstElement = false;
+        return this;
+    }
+    /**
+     * Attach a boundary event to the preceding task and build its outgoing path,
+     * then restore the branch cursor to the preceding task so the main branch flow continues.
+     *
+     * @param id - ID for the boundary event element.
+     * @param options - Boundary event options (without `attachedTo` — inferred from cursor).
+     * @param handler - Callback that chains elements from the boundary event.
+     */
+    withBoundary(id, options, handler) {
+        const attachedTo = this.lastNodeId;
+        if (!attachedTo || attachedTo === this.gatewayId) {
+            throw new Error("withBoundary() must follow a task element inside the branch. Current builder position has no active task.");
+        }
+        const attachedEl = this._elements.find((n) => n.id === attachedTo);
+        if (attachedEl?.type === "boundaryEvent") {
+            throw new Error("withBoundary() cannot attach to a boundary event. It must follow a task or activity element.");
+        }
+        const savedLast = this.lastNodeId;
+        const savedGateway = this.currentGatewayId;
+        const savedConnected = this._connected;
+        const savedOpenEnds = [...this.openBranchEnds];
+        this.openBranchEnds = [];
+        // Create and push the boundary event (no sequence flow)
+        this.boundaryEvent(id, { ...options, attachedTo });
+        // Build the boundary event's outgoing path
+        handler(this);
+        // Restore cursor to the task so the branch main flow continues
+        this.lastNodeId = savedLast;
+        this.currentGatewayId = savedGateway;
+        this._connected = savedConnected;
+        this.openBranchEnds = savedOpenEnds;
+        return this;
+    }
+    /**
+     * Create a named branch from the last gateway added inside this branch.
+     *
+     * Works identically to the top-level `ProcessBuilder.branch()` — use
+     * `.condition(expr)` or `.defaultFlow()` inside the callback, finish with
+     * `.connectTo(id)` or an `.endEvent()` to terminate the nested branch.
+     */
+    branch(name, callback) {
+        if (!this.currentGatewayId) {
+            throw new Error("branch() must be called after a gateway element");
+        }
+        const b = new BranchBuilder(this.currentGatewayId, name, this.rootErrors, this.rootMessages, this.rootSignals, this.rootEscalations);
+        callback(b);
+        for (const el of b._elements) {
+            if (this._elements.some((n) => n.id === el.id)) {
+                throw new Error(`Duplicate element ID "${el.id}"`);
+            }
+            this._elements.push(el);
+        }
+        for (const fl of b._flows)
+            this._flows.push(fl);
+        for (const ann of b._textAnnotations)
+            this._textAnnotations.push(ann);
+        for (const assoc of b._associations)
+            this._associations.push(assoc);
+        if (b._defaultFlowId) {
+            const gw = this._elements.find((n) => n.id === this.currentGatewayId);
+            if (gw && (gw.type === "exclusiveGateway" || gw.type === "inclusiveGateway")) {
+                gw.default = b._defaultFlowId;
+            }
+        }
+        if (!b._connected) {
+            const allEnds = [
+                ...(b._lastNodeId !== undefined ? [b._lastNodeId] : []),
+                ...b._openBranchEnds,
+            ];
+            for (const endId of allEnds) {
+                const endEl = this._elements.find((n) => n.id === endId);
+                if (endEl && endEl.type !== "endEvent") {
+                    this.openBranchEnds.push(endId);
+                }
+            }
+        }
+        this.lastNodeId = undefined;
+        return this;
+    }
 }
 // ---------------------------------------------------------------------------
 // Sub-process content builder
@@ -644,6 +776,11 @@ export class SubProcessContentBuilder {
     lastNodeId;
     currentGatewayId;
     openBranchEnds = [];
+    rootMessages;
+    /** @internal */
+    constructor(rootMessages = []) {
+        this.rootMessages = rootMessages;
+    }
     addElement(element) {
         if (this._elements.some((n) => n.id === element.id)) {
             throw new Error(`Duplicate element ID "${element.id}" in sub-process`);
@@ -719,12 +856,16 @@ export class SubProcessContentBuilder {
         const el = makeFlowElement(id, "sendTask", options);
         if (options?.isForCompensation)
             el.isForCompensation = true;
+        if (options?.messageName)
+            el.messageRef = resolveMessage(options.messageName, this.rootMessages);
         return this.addElement(el);
     }
     receiveTask(id, options) {
         const el = makeFlowElement(id, "receiveTask", options);
         if (options?.isForCompensation)
             el.isForCompensation = true;
+        if (options?.messageName)
+            el.messageRef = resolveMessage(options.messageName, this.rootMessages);
         return this.addElement(el);
     }
     /** Add an abstract task with no Zeebe extensions. */
@@ -799,10 +940,16 @@ export class SubProcessContentBuilder {
                 gw.default = b._defaultFlowId;
             }
         }
-        if (!b._connected && b._elements.length > 0) {
-            const lastEl = b._elements[b._elements.length - 1];
-            if (lastEl && lastEl.type !== "endEvent") {
-                this.openBranchEnds.push(b._lastNodeId);
+        if (!b._connected) {
+            const allEnds = [
+                ...(b._lastNodeId !== undefined ? [b._lastNodeId] : []),
+                ...b._openBranchEnds,
+            ];
+            for (const endId of allEnds) {
+                const endEl = this._elements.find((n) => n.id === endId);
+                if (endEl && endEl.type !== "endEvent") {
+                    this.openBranchEnds.push(endId);
+                }
             }
         }
         this.lastNodeId = undefined;
@@ -1075,6 +1222,8 @@ export class ProcessBuilder {
         const el = makeFlowElement(id, "sendTask", options);
         if (options?.isForCompensation)
             el.isForCompensation = true;
+        if (options?.messageName)
+            el.messageRef = resolveMessage(options.messageName, this.rootMessages);
         this.addFlowElement(el);
         return this;
     }
@@ -1083,6 +1232,8 @@ export class ProcessBuilder {
         const el = makeFlowElement(id, "receiveTask", options);
         if (options?.isForCompensation)
             el.isForCompensation = true;
+        if (options?.messageName)
+            el.messageRef = resolveMessage(options.messageName, this.rootMessages);
         this.addFlowElement(el);
         return this;
     }
@@ -1175,10 +1326,16 @@ export class ProcessBuilder {
         }
         // Track the branch's open end so the next element auto-connects from it.
         // Skip branches that terminated at an end event (those are intentional dead-ends).
-        if (!b._connected && b._elements.length > 0) {
-            const lastEl = b._elements[b._elements.length - 1];
-            if (lastEl && lastEl.type !== "endEvent") {
-                this.openBranchEnds.push(b._lastNodeId);
+        if (!b._connected) {
+            const allEnds = [
+                ...(b._lastNodeId !== undefined ? [b._lastNodeId] : []),
+                ...b._openBranchEnds,
+            ];
+            for (const endId of allEnds) {
+                const endEl = this.flowElements.find((n) => n.id === endId);
+                if (endEl && endEl.type !== "endEvent") {
+                    this.openBranchEnds.push(endId);
+                }
             }
         }
         this.lastNodeId = undefined;
@@ -1217,7 +1374,7 @@ export class ProcessBuilder {
     // ---- Sub-processes ----
     /** Add an ad-hoc sub-process with optional AI agent or multi-instance configuration. */
     adHocSubProcess(id, content, options) {
-        const sub = new SubProcessContentBuilder();
+        const sub = new SubProcessContentBuilder(this.rootMessages);
         content(sub);
         insertJoinGateways(sub._elements, sub._flows);
         recomputeIncomingOutgoing(sub._elements, sub._flows);
@@ -1285,7 +1442,7 @@ export class ProcessBuilder {
     }
     /** Add a sub-process (aspirational). */
     subProcess(id, content, options) {
-        const sub = new SubProcessContentBuilder();
+        const sub = new SubProcessContentBuilder(this.rootMessages);
         content(sub);
         insertJoinGateways(sub._elements, sub._flows);
         recomputeIncomingOutgoing(sub._elements, sub._flows);
@@ -1304,7 +1461,7 @@ export class ProcessBuilder {
     }
     /** Add an event sub-process. Triggered by its start event — no incoming or outgoing sequence flows. */
     eventSubProcess(id, content, options) {
-        const sub = new SubProcessContentBuilder();
+        const sub = new SubProcessContentBuilder(this.rootMessages);
         content(sub);
         insertJoinGateways(sub._elements, sub._flows);
         recomputeIncomingOutgoing(sub._elements, sub._flows);

package/dist/bpmn/bpmn-model.d.ts

@@ -152,10 +152,12 @@ export interface BpmnCallActivity extends BpmnFlowNodeBase {
 }
 export interface BpmnSendTask extends BpmnFlowNodeBase {
     type: "sendTask";
+    messageRef?: string;
     loopCharacteristics?: BpmnMultiInstanceLoopCharacteristics;
 }
 export interface BpmnReceiveTask extends BpmnFlowNodeBase {
     type: "receiveTask";
+    messageRef?: string;
     loopCharacteristics?: BpmnMultiInstanceLoopCharacteristics;
 }
 export interface BpmnAdHocSubProcess extends BpmnFlowNodeBase {

package/dist/bpmn/bpmn-parser.js

@@ -303,8 +303,6 @@ function parseFlowElement(element) {
         case "serviceTask":
         case "scriptTask":
         case "userTask":
-        case "sendTask":
-        case "receiveTask":
         case "businessRuleTask":
         case "manualTask":
         case "callActivity":
@@ -314,6 +312,15 @@ function parseFlowElement(element) {
                 loopCharacteristics: parseLoopCharacteristics(element),
                 isForCompensation: attr(element, "isForCompensation") === "true" ? true : undefined,
             };
+        case "sendTask":
+        case "receiveTask":
+            return {
+                ...base,
+                type: ln,
+                messageRef: attr(element, "messageRef"),
+                loopCharacteristics: parseLoopCharacteristics(element),
+                isForCompensation: attr(element, "isForCompensation") === "true" ? true : undefined,
+            };
         case "adHocSubProcess":
             return {
                 ...base,

package/dist/bpmn/bpmn-serializer.js

@@ -190,13 +190,17 @@ function serializeFlowElement(fe, ns) {
         case "serviceTask":
         case "scriptTask":
         case "userTask":
-        case "sendTask":
-        case "receiveTask":
         case "businessRuleTask":
         case "manualTask":
         case "callActivity":
             children.push(...serializeLoopCharacteristics(fe.loopCharacteristics, bp));
             break;
+        case "sendTask":
+        case "receiveTask":
+            if (fe.messageRef)
+                attrs.messageRef = fe.messageRef;
+            children.push(...serializeLoopCharacteristics(fe.loopCharacteristics, bp));
+            break;
         case "adHocSubProcess":
             children.push(...serializeLoopCharacteristics(fe.loopCharacteristics, bp));
             children.push(...serializeProcessContents(fe, ns));

package/dist/layout/layout-engine.js

@@ -36,10 +36,21 @@ function repositionBoundaryEvents(flowElements, result) {
         ps.add(edge.sourceRef);
         predIds.set(edge.targetRef, ps);
     }
+    const allChainNodes = new Set();
     for (const [hostId, beIds] of boundaryMap) {
         const hostNode = nodeById.get(hostId);
         if (!hostNode)
             continue;
+        // Pre-compute distribution parameters (all boundary events share the same fixed size).
+        // Distribute events evenly along the bottom edge, centered on the task.
+        // effectiveSpacing guarantees events don't overlap (min bW + 4px gap).
+        const firstBeNode = nodeById.get(beIds[0] ?? "");
+        const bW = firstBeNode?.bounds.width ?? 36;
+        const bH = firstBeNode?.bounds.height ?? 36;
+        const n = beIds.length;
+        const effectiveSpacing = Math.max(Math.round(hostNode.bounds.width / (n + 1)), bW + 4);
+        const groupWidth = Math.max(0, n - 1) * effectiveSpacing;
+        const groupStartCenterX = Math.round(hostNode.bounds.x + hostNode.bounds.width / 2 - groupWidth / 2);
         for (let i = 0; i < beIds.length; i++) {
             const beId = beIds[i];
             if (!beId)
@@ -47,11 +58,9 @@ function repositionBoundaryEvents(flowElements, result) {
             const beNode = nodeById.get(beId);
             if (!beNode)
                 continue;
-            const bW = beNode.bounds.width;
-            const bH = beNode.bounds.height;
-            // Place boundary event on the bottom edge of the host task, stacking leftward
-            const rightEdge = hostNode.bounds.x + hostNode.bounds.width;
-            beNode.bounds.x = Math.round(rightEdge - bW / 2 - i * (bW + 4));
+            // bW / bH come from the pre-loop computation (all BEs are fixed 36×36)
+            // Center-bottom distribution: single event → task center; multiple → even spread
+            beNode.bounds.x = Math.round(groupStartCenterX + i * effectiveSpacing - bW / 2);
             beNode.bounds.y = Math.round(hostNode.bounds.y + hostNode.bounds.height - bH / 2);
             if (beNode.labelBounds) {
                 beNode.labelBounds.x = beNode.bounds.x + Math.round(bW / 2 - beNode.labelBounds.width / 2);
@@ -72,6 +81,9 @@ function repositionBoundaryEvents(flowElements, result) {
                     queue.push(...(succIds.get(id) ?? []));
                 }
             }
+            // Record all chain members so the forward pass can identify them.
+            for (const cid of chainSet)
+                allChainNodes.add(cid);
             // Each boundary event's chain gets its own vertical lane
             let maxChainH = 0;
             for (const id of chainOrder) {
@@ -133,6 +145,116 @@ function repositionBoundaryEvents(flowElements, result) {
             }
         }
     }
+    // Forward-placement pass: any node not in any chain but whose predecessor
+    // has been relocated further right must be pushed rightward.
+    // Process in topological order (Kahn's algorithm over the sequenceFlow graph).
+    const inDegree = new Map();
+    for (const id of nodeById.keys()) {
+        inDegree.set(id, (predIds.get(id) ?? new Set()).size);
+    }
+    const topoQueue = [];
+    for (const [id, deg] of inDegree) {
+        if (deg === 0)
+            topoQueue.push(id);
+    }
+    const topoOrder = [];
+    while (topoQueue.length > 0) {
+        const id = topoQueue.shift();
+        if (!id)
+            break;
+        topoOrder.push(id);
+        for (const succId of succIds.get(id) ?? []) {
+            const newDeg = (inDegree.get(succId) ?? 1) - 1;
+            inDegree.set(succId, newDeg);
+            if (newDeg === 0)
+                topoQueue.push(succId);
+        }
+    }
+    const movedInPass = new Set();
+    for (const id of topoOrder) {
+        if (allChainNodes.has(id))
+            continue;
+        const node = nodeById.get(id);
+        if (!node)
+            continue;
+        const preds = predIds.get(id) ?? new Set();
+        if (preds.size === 0)
+            continue;
+        let maxPredRight = 0;
+        for (const predId of preds) {
+            const pred = nodeById.get(predId);
+            if (pred)
+                maxPredRight = Math.max(maxPredRight, pred.bounds.x + pred.bounds.width);
+        }
+        const minX = maxPredRight + CHAIN_GAP;
+        if (minX > node.bounds.x) {
+            const delta = minX - node.bounds.x;
+            node.bounds.x = minX;
+            if (node.labelBounds)
+                node.labelBounds.x += delta;
+            movedInPass.add(id);
+        }
+    }
+    // Spatial bump: if a moved node now overlaps a non-chain node on a parallel
+    // path (no predecessor/successor relationship), push it clear and cascade.
+    let bumped = true;
+    while (bumped) {
+        bumped = false;
+        for (const movedId of movedInPass) {
+            const moved = nodeById.get(movedId);
+            if (!moved)
+                continue;
+            const movedRight = moved.bounds.x + moved.bounds.width;
+            for (const [otherId, other] of nodeById) {
+                if (otherId === movedId)
+                    continue;
+                if (allChainNodes.has(otherId))
+                    continue;
+                if (movedInPass.has(otherId))
+                    continue;
+                // Check y overlap
+                if (other.bounds.y + other.bounds.height <= moved.bounds.y)
+                    continue;
+                if (other.bounds.y >= moved.bounds.y + moved.bounds.height)
+                    continue;
+                // Check x overlap (moved node intrudes into other's space)
+                if (other.bounds.x >= movedRight)
+                    continue;
+                if (other.bounds.x + other.bounds.width <= moved.bounds.x)
+                    continue;
+                // Push other right of moved
+                const newX = movedRight + CHAIN_GAP;
+                if (newX > other.bounds.x) {
+                    const delta = newX - other.bounds.x;
+                    other.bounds.x = newX;
+                    if (other.labelBounds)
+                        other.labelBounds.x += delta;
+                    movedInPass.add(otherId);
+                    bumped = true;
+                }
+            }
+        }
+    }
+    // Re-route edges where a chain source now points at a moved target,
+    // or where the source itself was moved by the forward pass.
+    for (const edge of result.edges) {
+        const srcMoved = movedInPass.has(edge.sourceRef);
+        const tgtMoved = movedInPass.has(edge.targetRef);
+        if (!srcMoved && !tgtMoved)
+            continue;
+        const src = nodeById.get(edge.sourceRef);
+        const tgt = nodeById.get(edge.targetRef);
+        if (!src || !tgt)
+            continue;
+        const srcX = Math.round(src.bounds.x + src.bounds.width);
+        const srcY = Math.round(src.bounds.y + src.bounds.height / 2);
+        const tgtX = Math.round(tgt.bounds.x);
+        const tgtY = Math.round(tgt.bounds.y + tgt.bounds.height / 2);
+        edge.waypoints = [
+            { x: srcX, y: srcY },
+            { x: tgtX, y: tgtY },
+        ];
+    }
 }
 /**
  * Auto-layout a BPMN process using the Sugiyama/layered algorithm.

package/dist/layout/subprocess.js

@@ -1,5 +1,36 @@
 import { layoutFlowNodes } from "./layout-engine.js";
 import { SUBPROCESS_PADDING } from "./types.js";
+const ADHOC_MAX_COLS = 4;
+const ADHOC_H_GAP = 50;
+const ADHOC_V_GAP = 80;
+/**
+ * Rearrange disconnected adHocSubProcess tool nodes into a grid.
+ * Nodes start at (0, 0) so the subprocess padding offset applies cleanly.
+ */
+function applyAdHocGridLayout(nodes) {
+    if (nodes.length === 0)
+        return;
+    const cols = Math.min(nodes.length, ADHOC_MAX_COLS);
+    const cellW = nodes.reduce((max, n) => Math.max(max, n.bounds.width), 0);
+    const cellH = nodes.reduce((max, n) => Math.max(max, n.bounds.height), 0);
+    for (let i = 0; i < nodes.length; i++) {
+        const col = i % cols;
+        const row = Math.floor(i / cols);
+        const n = nodes[i];
+        if (!n)
+            continue;
+        const newX = col * (cellW + ADHOC_H_GAP) + Math.round((cellW - n.bounds.width) / 2);
+        const newY = row * (cellH + ADHOC_V_GAP) + Math.round((cellH - n.bounds.height) / 2);
+        const dx = newX - n.bounds.x;
+        const dy = newY - n.bounds.y;
+        n.bounds.x = newX;
+        n.bounds.y = newY;
+        if (n.labelBounds) {
+            n.labelBounds.x += dx;
+            n.labelBounds.y += dy;
+        }
+    }
+}
 /**
  * Check if a node type is a sub-process container.
  */
@@ -22,6 +53,13 @@ export function layoutSubProcesses(layoutNodes, nodeIndex) {
         if (!subProcess.flowElements || subProcess.flowElements.length === 0)
             continue;
         const childResult = layoutFlowNodes(subProcess.flowElements, subProcess.sequenceFlows ?? []);
+        // For adHocSubProcess with no sequence flows, rearrange into a compact grid
+        // instead of a single long horizontal row.
+        if (bpmnNode.type === "adHocSubProcess" &&
+            (subProcess.sequenceFlows?.length ?? 0) === 0 &&
+            childResult.nodes.length > 0) {
+            applyAdHocGridLayout(childResult.nodes);
+        }
         if (childResult.nodes.length === 0)
             continue;
         // Compute bounding box of child elements

package/dist/layout/types.d.ts

@@ -5,13 +5,13 @@ export declare const ELEMENT_SIZES: Record<string, {
     height: number;
 }>;
 /** Virtual grid cell dimensions for element placement. */
-export declare const GRID_CELL_WIDTH = 130;
+export declare const GRID_CELL_WIDTH = 150;
 export declare const GRID_CELL_HEIGHT = 140;
 /** Minimum spacing between elements (derived from grid). */
 export declare const HORIZONTAL_SPACING: number;
 export declare const VERTICAL_SPACING: number;
 /** Padding inside sub-process containers. */
-export declare const SUBPROCESS_PADDING = 20;
+export declare const SUBPROCESS_PADDING = 50;
 /** Edge-label sizing constants (used for placement & collision detection). */
 export declare const LABEL_CHAR_WIDTH = 7;
 export declare const LABEL_MIN_WIDTH = 40;

package/dist/layout/types.js

@@ -22,13 +22,13 @@ export const ELEMENT_SIZES = {
     eventSubProcess: { width: 100, height: 80 },
 };
 /** Virtual grid cell dimensions for element placement. */
-export const GRID_CELL_WIDTH = 130;
+export const GRID_CELL_WIDTH = 150;
 export const GRID_CELL_HEIGHT = 140;
 /** Minimum spacing between elements (derived from grid). */
 export const HORIZONTAL_SPACING = GRID_CELL_WIDTH - 100; // 100 = max element width
 export const VERTICAL_SPACING = GRID_CELL_HEIGHT - 80; // 80 = max element height
 /** Padding inside sub-process containers. */
-export const SUBPROCESS_PADDING = 20;
+export const SUBPROCESS_PADDING = 50;
 /** Edge-label sizing constants (used for placement & collision detection). */
 export const LABEL_CHAR_WIDTH = 7;
 export const LABEL_MIN_WIDTH = 40;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bpmnkit/core",
-  "version": "0.0.25",
+  "version": "0.0.27",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",