@bpmnkit/core 0.0.21 → 0.0.23

package/README.md

@@ -186,6 +186,7 @@ const outXml = Bpmn.export(restored)
 | [`@bpmnkit/cli`](https://www.npmjs.com/package/@bpmnkit/cli) | Camunda 8 command-line interface (casen) |
 | [`@bpmnkit/proxy`](https://www.npmjs.com/package/@bpmnkit/proxy) | Local AI bridge and Camunda API proxy server |
 | [`@bpmnkit/patterns`](https://www.npmjs.com/package/@bpmnkit/patterns) | Domain process patterns for BPMNKit AIKit |
+| [`@bpmnkit/reebe-wasm`](https://www.npmjs.com/package/@bpmnkit/reebe-wasm) | WebAssembly BPMN engine for browser simulation |
 | [`@bpmnkit/worker-client`](https://www.npmjs.com/package/@bpmnkit/worker-client) | Thin Zeebe REST client for standalone workers |
 | [`@bpmnkit/cli-sdk`](https://www.npmjs.com/package/@bpmnkit/cli-sdk) | Plugin authoring SDK for the casen CLI |
 | [`@bpmnkit/create-casen-plugin`](https://www.npmjs.com/package/@bpmnkit/create-casen-plugin) | Scaffold a new casen CLI plugin in seconds |

package/dist/bpmn/auto-layout.js

@@ -1,9 +1,140 @@
 import { layoutProcess } from "../layout/layout-engine.js";
+import { resolveEdgeCrossings } from "../layout/routing.js";
 const POOL_HEADER = 30;
 const LANE_HEADER = 30;
 const PADDING = 20;
 const POOL_GAP = 30;
-function contentBbox(nodes) {
+const CHAIN_GAP = 30;
+const CHAIN_V_GAP = 20;
+const ANN_H = 50;
+const ANN_GAP = 60;
+const ANN_PADDING = 20;
+/**
+ * Reposition boundary events to the bottom edge of their host task, then walk
+ * each boundary event's exclusive downstream chain and place those nodes
+ * horizontally to the right of the host task.  Re-routes all affected edges.
+ */
+function repositionBoundaryEvents(flowElements, result) {
+    // Collect boundary events grouped by host task id
+    const boundaryMap = new Map();
+    for (const el of flowElements) {
+        if (el.type !== "boundaryEvent")
+            continue;
+        const list = boundaryMap.get(el.attachedToRef) ?? [];
+        list.push(el.id);
+        boundaryMap.set(el.attachedToRef, list);
+    }
+    if (boundaryMap.size === 0)
+        return;
+    const nodeById = new Map(result.nodes.map((n) => [n.id, n]));
+    // Build successor / predecessor maps from edges for chain walking
+    const succIds = new Map();
+    const predIds = new Map();
+    for (const edge of result.edges) {
+        const se = succIds.get(edge.sourceRef) ?? [];
+        se.push(edge.targetRef);
+        succIds.set(edge.sourceRef, se);
+        const ps = predIds.get(edge.targetRef) ?? new Set();
+        ps.add(edge.sourceRef);
+        predIds.set(edge.targetRef, ps);
+    }
+    for (const [hostId, beIds] of boundaryMap) {
+        const hostNode = nodeById.get(hostId);
+        if (!hostNode)
+            continue;
+        for (let i = 0; i < beIds.length; i++) {
+            const beId = beIds[i];
+            if (!beId)
+                continue;
+            const beNode = nodeById.get(beId);
+            if (!beNode)
+                continue;
+            const bW = beNode.bounds.width;
+            const bH = beNode.bounds.height;
+            // Place boundary event at bottom-right of host task, stacking leftward
+            const rightEdge = hostNode.bounds.x + hostNode.bounds.width;
+            beNode.bounds.x = Math.round(rightEdge - bW / 2 - i * (bW + 4));
+            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);
+                beNode.labelBounds.y = beNode.bounds.y + bH + 4;
+            }
+            // Collect nodes exclusively reachable from this boundary event (in BFS order)
+            const chainSet = new Set([beId]);
+            const chainOrder = [];
+            const queue = [...(succIds.get(beId) ?? [])];
+            while (queue.length > 0) {
+                const id = queue.shift();
+                if (!id || chainSet.has(id))
+                    continue;
+                // Include only if every predecessor is already in the chain
+                const preds = predIds.get(id) ?? new Set();
+                if ([...preds].every((p) => chainSet.has(p))) {
+                    chainSet.add(id);
+                    chainOrder.push(id);
+                    queue.push(...(succIds.get(id) ?? []));
+                }
+            }
+            // Find tallest chain element to compute center Y below boundary event.
+            // Each boundary event's chain gets its own vertical lane to avoid overlaps.
+            let maxChainH = 0;
+            for (const id of chainOrder) {
+                const n = nodeById.get(id);
+                if (n)
+                    maxChainH = Math.max(maxChainH, n.bounds.height);
+            }
+            const laneOffset = i * (maxChainH + CHAIN_V_GAP + 10);
+            const chainCenterY = Math.round(beNode.bounds.y + bH + CHAIN_V_GAP + maxChainH / 2 + laneOffset);
+            const chainStartX = Math.max(Math.round(beNode.bounds.x + bW / 2) + CHAIN_GAP, hostNode.bounds.x + hostNode.bounds.width + CHAIN_GAP);
+            let curX = chainStartX;
+            for (const id of chainOrder) {
+                const n = nodeById.get(id);
+                if (!n)
+                    continue;
+                n.bounds.x = curX;
+                n.bounds.y = chainCenterY - Math.round(n.bounds.height / 2);
+                if (n.labelBounds) {
+                    n.labelBounds.x = n.bounds.x + Math.round(n.bounds.width / 2 - n.labelBounds.width / 2);
+                    n.labelBounds.y = n.bounds.y + n.bounds.height + 4;
+                }
+                curX += n.bounds.width + CHAIN_GAP;
+            }
+            // Re-route all edges touching the boundary event or its chain
+            for (const edge of result.edges) {
+                if (!chainSet.has(edge.sourceRef))
+                    continue;
+                const src = nodeById.get(edge.sourceRef);
+                const tgt = nodeById.get(edge.targetRef);
+                if (!src || !tgt)
+                    continue;
+                if (edge.sourceRef === beId) {
+                    // Boundary event → first chain node: route down then right
+                    const srcX = Math.round(src.bounds.x + bW / 2);
+                    const srcY = Math.round(src.bounds.y + bH);
+                    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: srcX, y: tgtY },
+                        { x: tgtX, y: tgtY },
+                    ];
+                }
+                else {
+                    // Within chain: straight horizontal edge
+                    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 },
+                    ];
+                }
+            }
+        }
+    }
+}
+function contentBbox(nodes, extra) {
     let minX = Number.POSITIVE_INFINITY;
     let minY = Number.POSITIVE_INFINITY;
     let maxX = Number.NEGATIVE_INFINITY;
@@ -20,8 +151,107 @@ function contentBbox(nodes) {
             maxY = Math.max(maxY, n.labelBounds.y + n.labelBounds.height);
         }
     }
+    if (extra) {
+        for (const b of extra) {
+            minX = Math.min(minX, b.x);
+            minY = Math.min(minY, b.y);
+            maxX = Math.max(maxX, b.x + b.width);
+            maxY = Math.max(maxY, b.y + b.height);
+        }
+    }
     return { minX, minY, maxX, maxY };
 }
+/** Pre-compute annotation positions in layout space (before dx/dy shift). */
+function computeAnnotationLocalBounds(process, layoutNodes) {
+    const nodeById = new Map(layoutNodes.map((n) => [n.id, n]));
+    const placements = new Map();
+    // Occupied regions for overlap checks (node bounds + label bounds)
+    const occupied = [];
+    for (const n of layoutNodes) {
+        occupied.push({ ...n.bounds });
+        if (n.labelBounds)
+            occupied.push({ ...n.labelBounds });
+    }
+    // Static obstacles for crossing detection (nodes + labels only, not annotations)
+    const obstacles = [...occupied];
+    for (const ta of process.textAnnotations) {
+        const assoc = process.associations.find((a) => a.sourceRef === ta.id || a.targetRef === ta.id);
+        const connId = assoc
+            ? assoc.sourceRef === ta.id
+                ? assoc.targetRef
+                : assoc.sourceRef
+            : undefined;
+        const connNode = connId ? nodeById.get(connId) : undefined;
+        const annW = Math.min(200, Math.max(100, (ta.text?.length ?? 10) * 5));
+        if (!connNode) {
+            const candidate = { x: 0, y: 0, width: annW, height: ANN_H };
+            occupied.push({ ...candidate });
+            placements.set(ta.id, candidate);
+            continue;
+        }
+        const localX = connNode.bounds.x + connNode.bounds.width / 2 - annW / 2;
+        const anchorX = connNode.bounds.x + connNode.bounds.width / 2;
+        const pushStep = ANN_H + ANN_PADDING * 2 + 10;
+        // Try below: start below connected element, push down for overlaps
+        const belowY = connNode.bounds.y + connNode.bounds.height + ANN_GAP;
+        const below = { x: localX, y: belowY, width: annW, height: ANN_H };
+        for (let i = 0; i < 30 && hasOverlapPadded(below, occupied, ANN_PADDING); i++)
+            below.y += pushStep;
+        // Try above: gap scales with text length so longer annotations have more breathing room
+        const aboveGap = ANN_GAP + Math.round(annW * 0.2);
+        const aboveY = connNode.bounds.y - aboveGap - ANN_H;
+        const above = { x: localX, y: aboveY, width: annW, height: ANN_H };
+        for (let i = 0; i < 30 && hasOverlapPadded(above, occupied, ANN_PADDING); i++)
+            above.y -= pushStep;
+        // Count how many obstacles the association line would cross for each candidate
+        const belowCrossings = countLineCrossings(anchorX, connNode.bounds, below, obstacles);
+        const aboveCrossings = countLineCrossings(anchorX, connNode.bounds, above, obstacles);
+        const candidate = belowCrossings <= aboveCrossings ? below : above;
+        occupied.push({ ...candidate });
+        obstacles.push({ ...candidate });
+        placements.set(ta.id, candidate);
+    }
+    return placements;
+}
+/** Count how many obstacles the vertical association line from connNode to annotation crosses. */
+function countLineCrossings(lineX, connBounds, annBounds, obstacles) {
+    const annCY = annBounds.y + annBounds.height / 2;
+    const connCY = connBounds.y + connBounds.height / 2;
+    const top = Math.min(annCY, connCY);
+    const bottom = Math.max(annCY, connCY);
+    const tolerance = 20;
+    let crossings = 0;
+    for (const b of obstacles) {
+        // Skip the connected element itself
+        if (b.x === connBounds.x && b.y === connBounds.y && b.width === connBounds.width)
+            continue;
+        // Obstacle must overlap with the line's X corridor
+        if (b.x + b.width < lineX - tolerance || b.x > lineX + tolerance)
+            continue;
+        // Obstacle must be between connNode and annotation vertically
+        if (b.y + b.height <= top || b.y >= bottom)
+            continue;
+        crossings++;
+    }
+    return crossings;
+}
+function hasOverlap(a, others) {
+    for (const b of others) {
+        if (a.x < b.x + b.width && a.x + a.width > b.x && a.y < b.y + b.height && a.y + a.height > b.y)
+            return true;
+    }
+    return false;
+}
+function hasOverlapPadded(a, others, padding) {
+    for (const b of others) {
+        if (a.x - padding < b.x + b.width &&
+            a.x + a.width + padding > b.x &&
+            a.y - padding < b.y + b.height &&
+            a.y + a.height + padding > b.y)
+            return true;
+    }
+    return false;
+}
 function nodeToShape(node, dx, dy) {
     const shape = {
         id: `${node.id}_di`,
@@ -112,6 +342,70 @@ function buildLaneShapes(lanes, nodes, dx, dy, poolY, poolHeaderWidth, laneConte
         unknownAttributes: {},
     }));
 }
+function addAnnotationShapes(process, layoutNodes, annLocalBounds, allShapes, allEdges, dx, dy) {
+    if (process.textAnnotations.length === 0 && process.associations.length === 0)
+        return;
+    const nodeById = new Map(layoutNodes.map((n) => [n.id, n]));
+    for (const ta of process.textAnnotations) {
+        const b = annLocalBounds.get(ta.id);
+        if (!b)
+            continue;
+        allShapes.push({
+            id: `${ta.id}_di`,
+            bpmnElement: ta.id,
+            bounds: {
+                x: Math.round(b.x + dx),
+                y: Math.round(b.y + dy),
+                width: b.width,
+                height: b.height,
+            },
+            unknownAttributes: {},
+        });
+    }
+    for (const assoc of process.associations) {
+        const annId = annLocalBounds.has(assoc.sourceRef)
+            ? assoc.sourceRef
+            : annLocalBounds.has(assoc.targetRef)
+                ? assoc.targetRef
+                : undefined;
+        const elId = annId === assoc.sourceRef ? assoc.targetRef : assoc.sourceRef;
+        const annB = annId ? annLocalBounds.get(annId) : undefined;
+        const elNode = nodeById.get(elId);
+        if (!annB || !elNode)
+            continue;
+        const elB = elNode.bounds;
+        const annCx = Math.round(annB.x + annB.width / 2 + dx);
+        const elCx = Math.round(elB.x + elB.width / 2 + dx);
+        let waypoints;
+        if (annB.y >= elB.y + elB.height) {
+            // annotation below: element bottom-center → annotation top-center
+            waypoints = [
+                { x: elCx, y: Math.round(elB.y + elB.height + dy) },
+                { x: annCx, y: Math.round(annB.y + dy) },
+            ];
+        }
+        else if (annB.y + annB.height <= elB.y) {
+            // annotation above: element top-center → annotation bottom-center
+            waypoints = [
+                { x: elCx, y: Math.round(elB.y + dy) },
+                { x: annCx, y: Math.round(annB.y + annB.height + dy) },
+            ];
+        }
+        else {
+            // side-by-side: center-to-center
+            waypoints = [
+                { x: Math.round(elB.x + elB.width / 2 + dx), y: Math.round(elB.y + elB.height / 2 + dy) },
+                { x: annCx, y: Math.round(annB.y + annB.height / 2 + dy) },
+            ];
+        }
+        allEdges.push({
+            id: `${assoc.id}_di`,
+            bpmnElement: assoc.id,
+            waypoints,
+            unknownAttributes: {},
+        });
+    }
+}
 /**
  * Apply auto-layout to all processes in a BpmnDefinitions, replacing the
  * diagram interchange (BPMNDi) with freshly computed positions.
@@ -139,27 +433,41 @@ export function applyAutoLayout(defs) {
         const lanes = process.laneSet?.lanes ?? [];
         const hasLanes = lanes.length > 0;
         const result = layoutProcess(process);
+        // Post-process boundary events: reposition each boundary event to the bottom
+        // of its host task, then walk its exclusive downstream chain and reposition
+        // those nodes horizontally to the right of the host task.
+        repositionBoundaryEvents(process.flowElements, result);
+        // Re-resolve edge crossings after boundary events moved shapes
+        const nodeMap = new Map(result.nodes.map((n) => [n.id, n]));
+        resolveEdgeCrossings(result.edges, nodeMap);
         if (result.nodes.length === 0)
             continue;
-        const { minX, minY, maxX, maxY } = contentBbox(result.nodes);
+        // Pre-compute annotation positions in layout space so they're included in the bbox
+        const annBounds = computeAnnotationLocalBounds(process, result.nodes);
+        const { minX, minY, maxX, maxY } = contentBbox(result.nodes, annBounds.values());
         const contentW = maxX - minX;
         const contentH = maxY - minY;
+        let dx;
+        let dy;
         if (participantId) {
-            // Elements sit inside pool content area:
-            // x starts at: POOL_HEADER + optional LANE_HEADER + PADDING
-            // y starts at: poolY + PADDING
             const elemX = POOL_HEADER + (hasLanes ? LANE_HEADER : 0) + PADDING;
             const elemY = poolY + PADDING;
-            const dx = elemX - minX;
-            const dy = elemY - minY;
-            for (const node of result.nodes)
-                allShapes.push(nodeToShape(node, dx, dy));
-            for (const edge of result.edges)
-                allEdges.push(edgeToShape(edge, dx, dy));
+            dx = elemX - minX;
+            dy = elemY - minY;
+        }
+        else {
+            dx = PADDING - minX;
+            dy = PADDING - minY;
+        }
+        for (const node of result.nodes)
+            allShapes.push(nodeToShape(node, dx, dy));
+        for (const edge of result.edges)
+            allEdges.push(edgeToShape(edge, dx, dy));
+        addAnnotationShapes(process, result.nodes, annBounds, allShapes, allEdges, dx, dy);
+        if (participantId) {
             const innerW = (hasLanes ? LANE_HEADER : 0) + contentW + 2 * PADDING;
             const innerH = contentH + 2 * PADDING;
             const poolW = POOL_HEADER + innerW;
-            // Pool (participant) shape
             allShapes.push({
                 id: `${participantId}_di`,
                 bpmnElement: participantId,
@@ -173,15 +481,6 @@ export function applyAutoLayout(defs) {
             }
             poolY += innerH + POOL_GAP;
         }
-        else {
-            // No collaboration — layout at (PADDING, PADDING)
-            const dx = PADDING - minX;
-            const dy = PADDING - minY;
-            for (const node of result.nodes)
-                allShapes.push(nodeToShape(node, dx, dy));
-            for (const edge of result.edges)
-                allEdges.push(edgeToShape(edge, dx, dy));
-        }
     }
     const planeBpmnElement = collab?.id ?? defs.processes[0]?.id ?? "plane";
     const existingDiagram = defs.diagrams[0];

package/dist/bpmn/bpmn-builder.js

@@ -1073,6 +1073,7 @@ export class ProcessBuilder {
             errors: this.rootErrors,
             escalations: [],
             messages: this.rootMessages,
+            signals: [],
             collaborations: [],
             processes: [process],
             diagrams: this._autoLayout ? [this.buildDiagram(process)] : [],

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

@@ -336,6 +336,11 @@ export interface BpmnMessage {
     name?: string;
     unknownAttributes: Record<string, string>;
 }
+/** A root-level BPMN signal definition referenced by signal catch/throw events. */
+export interface BpmnSignal {
+    id: string;
+    name?: string;
+}
 /** Optional label positioning information for a BPMNDi shape or edge. */
 export interface BpmnDiLabel {
     bounds?: BpmnBounds;
@@ -397,6 +402,7 @@ export interface BpmnDefinitions {
     errors: BpmnError[];
     escalations: BpmnEscalation[];
     messages: BpmnMessage[];
+    signals: BpmnSignal[];
     collaborations: BpmnCollaboration[];
     processes: BpmnProcess[];
     diagrams: BpmnDiagram[];

package/dist/bpmn/bpmn-parser.js

@@ -505,6 +505,12 @@ function parseMessage(element) {
         unknownAttributes: unknownAttrs(element),
     };
 }
+function parseSignal(element) {
+    return {
+        id: requiredAttr(element, "id"),
+        name: attr(element, "name"),
+    };
+}
 // ---------------------------------------------------------------------------
 // Diagram interchange
 // ---------------------------------------------------------------------------
@@ -607,6 +613,7 @@ export function parseBpmn(xml) {
     const errors = [];
     const escalations = [];
     const messages = [];
+    const signals = [];
     const collaborations = [];
     const processes = [];
     const diagrams = [];
@@ -618,6 +625,8 @@ export function parseBpmn(xml) {
             escalations.push(parseEscalation(child));
         else if (ln === "message")
             messages.push(parseMessage(child));
+        else if (ln === "signal")
+            signals.push(parseSignal(child));
         else if (ln === "collaboration")
             collaborations.push(parseCollaboration(child));
         else if (ln === "process")
@@ -635,6 +644,7 @@ export function parseBpmn(xml) {
         errors,
         escalations,
         messages,
+        signals,
         collaborations,
         processes,
         diagrams,

package/dist/bpmn/bpmn-serializer.js

@@ -387,6 +387,12 @@ function serializeMessage(m, bp) {
         attrs.name = m.name;
     return el(`${bp}:message`, attrs, []);
 }
+function serializeSignal(s, bp) {
+    const attrs = { id: s.id };
+    if (s.name !== undefined)
+        attrs.name = s.name;
+    return el(`${bp}:signal`, attrs, []);
+}
 // ---------------------------------------------------------------------------
 // Diagram interchange
 // ---------------------------------------------------------------------------
@@ -490,7 +496,7 @@ export function serializeBpmn(definitions) {
         attrs[key] = value;
     }
     const children = [];
-    // Root elements: errors, escalations, messages first
+    // Root elements: errors, escalations, messages, signals first
     for (const e of definitions.escalations) {
         children.push(serializeEscalation(e, bp));
     }
@@ -500,6 +506,9 @@ export function serializeBpmn(definitions) {
     for (const m of definitions.messages) {
         children.push(serializeMessage(m, bp));
     }
+    for (const s of definitions.signals ?? []) {
+        children.push(serializeSignal(s, bp));
+    }
     // Collaborations
     for (const c of definitions.collaborations) {
         children.push(serializeCollaboration(c, ns));

package/dist/bpmn/compact.js

@@ -380,6 +380,7 @@ export function expand(compact) {
         errors: [],
         escalations: [],
         messages: [],
+        signals: [],
         collaborations: [],
         processes,
         diagrams,

package/dist/bpmn/optimize/tasks.js

@@ -204,6 +204,7 @@ function buildExtractedDefs(representative, newProcessId) {
         errors: [],
         escalations: [],
         messages: [],
+        signals: [],
         collaborations: [],
         processes: [extractedProcess],
         diagrams: [diagram],

package/dist/index.d.ts

@@ -5,7 +5,7 @@ export { findElement, findElementInProcess, findProcess, findSequenceFlow, getAl
 export { Bpmn, SAMPLE_BPMN_XML } from "./bpmn/index.js";
 export { applyAutoLayout } from "./bpmn/auto-layout.js";
 export type { ProcessBuilder, BranchBuilder, SubProcessContentBuilder, ServiceTaskOptions, ScriptTaskOptions, UserTaskOptions, CallActivityOptions, BusinessRuleTaskOptions, ElementOptions, GatewayOptions, MultiInstanceOptions, SubProcessOptions, StartEventOptions, IntermediateCatchEventOptions, IntermediateThrowEventOptions, BoundaryEventOptions, AdHocSubProcessOptions, } from "./bpmn/bpmn-builder.js";
-export type { BpmnDefinitions, BpmnProcess, BpmnFlowNode, BpmnFlowElement, BpmnSequenceFlow, BpmnBoundaryEvent, BpmnElementType, BpmnStartEvent, BpmnEndEvent, BpmnIntermediateCatchEvent, BpmnIntermediateThrowEvent, BpmnTask, BpmnServiceTask, BpmnScriptTask, BpmnUserTask, BpmnSendTask, BpmnReceiveTask, BpmnBusinessRuleTask, BpmnManualTask, BpmnCallActivity, BpmnSubProcess, BpmnAdHocSubProcess, BpmnEventSubProcess, BpmnTransaction, BpmnExclusiveGateway, BpmnParallelGateway, BpmnInclusiveGateway, BpmnEventBasedGateway, BpmnComplexGateway, BpmnCollaboration, BpmnParticipant, BpmnMessageFlow, BpmnLane, BpmnLaneSet, BpmnError, BpmnEscalation, BpmnMessage, BpmnTextAnnotation, BpmnAssociation, BpmnConditionExpression, BpmnEventDefinition, BpmnTimerEventDefinition, BpmnErrorEventDefinition, BpmnEscalationEventDefinition, BpmnMessageEventDefinition, BpmnSignalEventDefinition, BpmnConditionalEventDefinition, BpmnLinkEventDefinition, BpmnCancelEventDefinition, BpmnTerminateEventDefinition, BpmnCompensateEventDefinition, BpmnMultiInstanceLoopCharacteristics, BpmnDiagram, BpmnDiPlane, BpmnDiShape, BpmnDiEdge, BpmnDiLabel, BpmnBounds, BpmnWaypoint, } from "./bpmn/bpmn-model.js";
+export type { BpmnDefinitions, BpmnProcess, BpmnFlowNode, BpmnFlowElement, BpmnSequenceFlow, BpmnBoundaryEvent, BpmnElementType, BpmnStartEvent, BpmnEndEvent, BpmnIntermediateCatchEvent, BpmnIntermediateThrowEvent, BpmnTask, BpmnServiceTask, BpmnScriptTask, BpmnUserTask, BpmnSendTask, BpmnReceiveTask, BpmnBusinessRuleTask, BpmnManualTask, BpmnCallActivity, BpmnSubProcess, BpmnAdHocSubProcess, BpmnEventSubProcess, BpmnTransaction, BpmnExclusiveGateway, BpmnParallelGateway, BpmnInclusiveGateway, BpmnEventBasedGateway, BpmnComplexGateway, BpmnCollaboration, BpmnParticipant, BpmnMessageFlow, BpmnLane, BpmnLaneSet, BpmnError, BpmnEscalation, BpmnMessage, BpmnSignal, BpmnTextAnnotation, BpmnAssociation, BpmnConditionExpression, BpmnEventDefinition, BpmnTimerEventDefinition, BpmnErrorEventDefinition, BpmnEscalationEventDefinition, BpmnMessageEventDefinition, BpmnSignalEventDefinition, BpmnConditionalEventDefinition, BpmnLinkEventDefinition, BpmnCancelEventDefinition, BpmnTerminateEventDefinition, BpmnCompensateEventDefinition, BpmnMultiInstanceLoopCharacteristics, BpmnDiagram, BpmnDiPlane, BpmnDiShape, BpmnDiEdge, BpmnDiLabel, BpmnBounds, BpmnWaypoint, } from "./bpmn/bpmn-model.js";
 export type { RestConnectorConfig, RestAuthentication, HttpMethod, } from "./bpmn/rest-connector.js";
 export type { ZeebeExtensions, ZeebeTaskDefinition, ZeebeIoMapping, ZeebeIoMappingEntry, ZeebeTaskHeaders, ZeebeTaskHeaderEntry, ZeebeProperties, ZeebePropertyEntry, ZeebeFormDefinition, ZeebeCalledDecision, } from "./bpmn/zeebe-extensions.js";
 export { zeebeExtensionsToXmlElements } from "./bpmn/zeebe-extensions.js";
@@ -32,7 +32,7 @@ export { layoutProcess, layoutFlowNodes } from "./layout/index.js";
 export { benchmarkLayout, compareLayouts, formatBenchmarkResult, generateAutoLayout, parseReferenceLayout, } from "./layout/index.js";
 export type { BenchmarkResult, BoundingBox, ElementComparison, ElementPosition, FlowOrderViolation, } from "./layout/index.js";
 export type { Bounds, LayoutEdge, LayoutNode, LayoutResult, Waypoint } from "./layout/index.js";
-export { ELEMENT_SIZES, GRID_CELL_HEIGHT } from "./layout/index.js";
+export { ELEMENT_SIZES, GRID_CELL_HEIGHT, GRID_CELL_WIDTH } from "./layout/index.js";
 export { compactify, expand } from "./bpmn/compact.js";
 export { applyOperations } from "./bpmn/operations.js";
 export type { BpmnOperation } from "./bpmn/operations.js";

package/dist/index.js

@@ -15,7 +15,7 @@ export { renderStoryHtml } from "./bpmn/story.js";
 export { analyzeVariableFlow, extractFeelIdentifiers } from "./bpmn/optimize/variable-flow.js";
 export { layoutProcess, layoutFlowNodes } from "./layout/index.js";
 export { benchmarkLayout, compareLayouts, formatBenchmarkResult, generateAutoLayout, parseReferenceLayout, } from "./layout/index.js";
-export { ELEMENT_SIZES, GRID_CELL_HEIGHT } from "./layout/index.js";
+export { ELEMENT_SIZES, GRID_CELL_HEIGHT, GRID_CELL_WIDTH } from "./layout/index.js";
 export { compactify, expand } from "./bpmn/compact.js";
 export { applyOperations } from "./bpmn/operations.js";
 export { buildValidationDmn, findValidationStructure, getValidationInputNames, insertValidationStructure, removeValidationStructure, validationDecisionId, } from "./bpmn/input-validation.js";

package/dist/layout/astar.d.ts

@@ -0,0 +1,15 @@
+import type { Bounds, Waypoint } from "./types.js";
+/**
+ * Route a single edge using A* on a 10px grid.
+ * source/target are center points of source/target nodes.
+ * obstacles are node bounding boxes to avoid (inflated by 6px margin).
+ * Returns simplified orthogonal waypoints.
+ */
+export declare function routeEdgeAstar(source: {
+    x: number;
+    y: number;
+}, target: {
+    x: number;
+    y: number;
+}, obstacles: Bounds[], canvasWidth: number, canvasHeight: number): Waypoint[];
+//# sourceMappingURL=astar.d.ts.map