@bpmnkit/core 0.0.22 → 0.0.24

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/index.d.ts

@@ -1,4 +1,4 @@
-import { ProcessBuilder } from "./bpmn-builder.js";
+import { DiagramBuilder, ProcessBuilder } from "./bpmn-builder.js";
 import type { BpmnDefinitions } from "./bpmn-model.js";
 /** A minimal 3-element BPMN diagram useful for first-launch or "New Diagram" defaults. */
 export declare const SAMPLE_BPMN_XML = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<bpmn:definitions xmlns:bpmn=\"http://www.omg.org/spec/BPMN/20100524/MODEL\"\n  xmlns:bpmndi=\"http://www.omg.org/spec/BPMN/20100524/DI\"\n  xmlns:dc=\"http://www.omg.org/spec/DD/20100524/DC\"\n  xmlns:di=\"http://www.omg.org/spec/DD/20100524/DI\"\n  id=\"Definitions_1\" targetNamespace=\"http://bpmn.io/schema/bpmn\">\n  <bpmn:process id=\"proc\" isExecutable=\"true\">\n    <bpmn:startEvent id=\"start\" name=\"Start\">\n      <bpmn:outgoing>flow1</bpmn:outgoing>\n    </bpmn:startEvent>\n    <bpmn:serviceTask id=\"task1\" name=\"Process Order\">\n      <bpmn:incoming>flow1</bpmn:incoming>\n      <bpmn:outgoing>flow2</bpmn:outgoing>\n    </bpmn:serviceTask>\n    <bpmn:endEvent id=\"end\" name=\"End\">\n      <bpmn:incoming>flow2</bpmn:incoming>\n    </bpmn:endEvent>\n    <bpmn:sequenceFlow id=\"flow1\" sourceRef=\"start\" targetRef=\"task1\"/>\n    <bpmn:sequenceFlow id=\"flow2\" sourceRef=\"task1\" targetRef=\"end\"/>\n  </bpmn:process>\n  <bpmndi:BPMNDiagram id=\"diagram1\">\n    <bpmndi:BPMNPlane id=\"plane1\" bpmnElement=\"proc\">\n      <bpmndi:BPMNShape id=\"start_di\" bpmnElement=\"start\">\n        <dc:Bounds x=\"152\" y=\"202\" width=\"36\" height=\"36\"/>\n      </bpmndi:BPMNShape>\n      <bpmndi:BPMNShape id=\"task1_di\" bpmnElement=\"task1\">\n        <dc:Bounds x=\"260\" y=\"180\" width=\"100\" height=\"80\"/>\n      </bpmndi:BPMNShape>\n      <bpmndi:BPMNShape id=\"end_di\" bpmnElement=\"end\">\n        <dc:Bounds x=\"432\" y=\"202\" width=\"36\" height=\"36\"/>\n      </bpmndi:BPMNShape>\n      <bpmndi:BPMNEdge id=\"flow1_di\" bpmnElement=\"flow1\">\n        <di:waypoint x=\"188\" y=\"220\"/>\n        <di:waypoint x=\"260\" y=\"220\"/>\n      </bpmndi:BPMNEdge>\n      <bpmndi:BPMNEdge id=\"flow2_di\" bpmnElement=\"flow2\">\n        <di:waypoint x=\"360\" y=\"220\"/>\n        <di:waypoint x=\"432\" y=\"220\"/>\n      </bpmndi:BPMNEdge>\n    </bpmndi:BPMNPlane>\n  </bpmndi:BPMNDiagram>\n</bpmn:definitions>";
@@ -41,6 +41,20 @@ export declare const Bpmn: {
      * ```
      */
     readonly createProcess: (processId: string) => ProcessBuilder;
+    /**
+     * Create a multi-process BPMN definitions document using the fluent builder API.
+     *
+     * @param id - Unique identifier for the definitions element (defaults to `"Definitions_1"`).
+     *
+     * @example
+     * ```typescript
+     * const defs = Bpmn.createDiagram("OrderSystem")
+     *   .process("caller", (p) => p.startEvent("s").callActivity("call", { processId: "callee" }).endEvent("e"))
+     *   .process("callee", (p) => p.startEvent("s2").serviceTask("work", { name: "Work", taskType: "work" }).endEvent("e2"))
+     *   .build()
+     * ```
+     */
+    readonly createDiagram: (id?: string) => DiagramBuilder;
     /**
      * Parse a BPMN 2.0 XML string into a typed {@link BpmnDefinitions} model.
      *

package/dist/bpmn/index.js

@@ -1,5 +1,5 @@
 import { applyAutoLayout } from "./auto-layout.js";
-import { ProcessBuilder } from "./bpmn-builder.js";
+import { DiagramBuilder, ProcessBuilder } from "./bpmn-builder.js";
 import { parseBpmn } from "./bpmn-parser.js";
 import { serializeBpmn } from "./bpmn-serializer.js";
 /** A minimal 3-element BPMN diagram useful for first-launch or "New Diagram" defaults. */
@@ -86,6 +86,22 @@ export const Bpmn = {
     createProcess(processId) {
         return new ProcessBuilder(processId);
     },
+    /**
+     * Create a multi-process BPMN definitions document using the fluent builder API.
+     *
+     * @param id - Unique identifier for the definitions element (defaults to `"Definitions_1"`).
+     *
+     * @example
+     * ```typescript
+     * const defs = Bpmn.createDiagram("OrderSystem")
+     *   .process("caller", (p) => p.startEvent("s").callActivity("call", { processId: "callee" }).endEvent("e"))
+     *   .process("callee", (p) => p.startEvent("s2").serviceTask("work", { name: "Work", taskType: "work" }).endEvent("e2"))
+     *   .build()
+     * ```
+     */
+    createDiagram(id = "Definitions_1") {
+        return new DiagramBuilder(id);
+    },
     /**
      * Parse a BPMN 2.0 XML string into a typed {@link BpmnDefinitions} model.
      *

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/bpmn/zeebe-extensions.d.ts

@@ -64,6 +64,8 @@ export interface ZeebeExtensions {
     formDefinition?: ZeebeFormDefinition;
     /** DMN decision invoked by a business rule task (zeebe:calledDecision). */
     calledDecision?: ZeebeCalledDecision;
+    /** Marks this as a Camunda 8 native user task (zeebe:userTask). */
+    userTask?: true;
     /** Unrecognized extension elements preserved for roundtrip. */
     unknownElements?: XmlElement[];
 }

package/dist/bpmn/zeebe-extensions.js

@@ -71,6 +71,9 @@ export function zeebeExtensionsToXmlElements(extensions) {
             attrs.activeElementsCollection = activeElementsCollection;
         elements.push({ name: "zeebe:adHoc", attributes: attrs, children: [] });
     }
+    if (extensions.userTask) {
+        elements.push({ name: "zeebe:userTask", attributes: {}, children: [] });
+    }
     if (extensions.formDefinition) {
         elements.push({
             name: "zeebe:formDefinition",

package/dist/index.d.ts

@@ -4,8 +4,9 @@ export { isBpmnActivity, isBpmnAdHocSubProcess, isBpmnBoundaryEvent, isBpmnBusin
 export { findElement, findElementInProcess, findProcess, findSequenceFlow, getAllElements, getElementType, getZeebeExtensions, } from "./bpmn/utils.js";
 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 { DiagramBuilder } from "./bpmn/bpmn-builder.js";
+export type { ProcessBuilder, BranchBuilder, SubProcessContentBuilder, ServiceTaskOptions, ScriptTaskOptions, UserTaskOptions, CallActivityOptions, BusinessRuleTaskOptions, ElementOptions, GatewayOptions, MultiInstanceOptions, SubProcessOptions, StartEventOptions, IntermediateCatchEventOptions, IntermediateThrowEventOptions, EndEventOptions, 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, 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 +33,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

@@ -3,6 +3,7 @@ export { isBpmnActivity, isBpmnAdHocSubProcess, isBpmnBoundaryEvent, isBpmnBusin
 export { findElement, findElementInProcess, findProcess, findSequenceFlow, getAllElements, getElementType, getZeebeExtensions, } from "./bpmn/utils.js";
 export { Bpmn, SAMPLE_BPMN_XML } from "./bpmn/index.js";
 export { applyAutoLayout } from "./bpmn/auto-layout.js";
+export { DiagramBuilder } from "./bpmn/bpmn-builder.js";
 export { zeebeExtensionsToXmlElements } from "./bpmn/zeebe-extensions.js";
 export { Dmn, layoutDmn, benchmarkDmnLayout, compactifyDmn, expandDmn } from "./dmn/index.js";
 export { Form, compactifyForm, expandForm } from "./form/index.js";
@@ -15,7 +16,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

package/dist/layout/astar.js

@@ -0,0 +1,191 @@
+const GRID_RES = 10;
+const OBSTACLE_MARGIN = 6;
+const TURN_PENALTY = 5;
+const CANVAS_EXTEND = 80;
+const DX = [1, 0, -1, 0];
+const DY = [0, 1, 0, -1];
+/** Minimal binary min-heap keyed by f-score. */
+class MinHeap {
+    data = [];
+    push(f, key) {
+        this.data.push({ f, key });
+        this.bubbleUp(this.data.length - 1);
+    }
+    pop() {
+        const top = this.data[0];
+        const last = this.data.pop();
+        if (this.data.length > 0 && last !== undefined) {
+            this.data[0] = last;
+            this.sinkDown(0);
+        }
+        return top;
+    }
+    get size() {
+        return this.data.length;
+    }
+    bubbleUp(startIdx) {
+        let i = startIdx;
+        while (i > 0) {
+            const parent = (i - 1) >> 1;
+            const d = this.data[i];
+            const p = this.data[parent];
+            if (!d || !p || p.f <= d.f)
+                break;
+            this.data[i] = p;
+            this.data[parent] = d;
+            i = parent;
+        }
+    }
+    sinkDown(startIdx) {
+        let i = startIdx;
+        for (;;) {
+            const left = 2 * i + 1;
+            const right = 2 * i + 2;
+            let smallest = i;
+            const d = this.data[smallest];
+            const l = this.data[left];
+            const r = this.data[right];
+            if (l && l.f < (d?.f ?? Number.POSITIVE_INFINITY))
+                smallest = left;
+            const s = this.data[smallest];
+            if (r && r.f < (s?.f ?? Number.POSITIVE_INFINITY))
+                smallest = right;
+            if (smallest === i)
+                break;
+            const tmp = this.data[i];
+            const sm = this.data[smallest];
+            if (!tmp || !sm)
+                break;
+            this.data[i] = sm;
+            this.data[smallest] = tmp;
+            i = smallest;
+        }
+    }
+}
+/**
+ * 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 function routeEdgeAstar(source, target, obstacles, canvasWidth, canvasHeight) {
+    // Extend canvas to allow routing around edges
+    const minX = Math.max(0, Math.min(source.x, target.x) - CANVAS_EXTEND);
+    const minY = Math.max(0, Math.min(source.y, target.y) - CANVAS_EXTEND);
+    const maxX = Math.max(source.x, target.x) + CANVAS_EXTEND + canvasWidth;
+    const maxY = Math.max(source.y, target.y) + CANVAS_EXTEND + canvasHeight;
+    const cols = Math.ceil((maxX - minX) / GRID_RES) + 1;
+    const rows = Math.ceil((maxY - minY) / GRID_RES) + 1;
+    // Snap source and target to grid
+    const sx = Math.round((source.x - minX) / GRID_RES);
+    const sy = Math.round((source.y - minY) / GRID_RES);
+    const tx = Math.round((target.x - minX) / GRID_RES);
+    const ty = Math.round((target.y - minY) / GRID_RES);
+    // If they're at the same grid cell, return straight line
+    if (sx === tx && sy === ty) {
+        return [source, target];
+    }
+    // Build blocked grid
+    const blocked = new Uint8Array(cols * rows);
+    for (const ob of obstacles) {
+        const ox1 = Math.floor((ob.x - OBSTACLE_MARGIN - minX) / GRID_RES);
+        const oy1 = Math.floor((ob.y - OBSTACLE_MARGIN - minY) / GRID_RES);
+        const ox2 = Math.ceil((ob.x + ob.width + OBSTACLE_MARGIN - minX) / GRID_RES);
+        const oy2 = Math.ceil((ob.y + ob.height + OBSTACLE_MARGIN - minY) / GRID_RES);
+        for (let gy = Math.max(0, oy1); gy <= Math.min(rows - 1, oy2); gy++) {
+            for (let gx = Math.max(0, ox1); gx <= Math.min(cols - 1, ox2); gx++) {
+                blocked[gy * cols + gx] = 1;
+            }
+        }
+    }
+    // Unblock source and target cells (they're inside nodes)
+    blocked[sy * cols + sx] = 0;
+    blocked[ty * cols + tx] = 0;
+    // A* with direction-aware state: state = cell * 4 + dir
+    const INF = Number.MAX_SAFE_INTEGER;
+    // g-scores per (cell, dir)
+    const g = new Float32Array(cols * rows * 4).fill(INF);
+    const parent = new Int32Array(cols * rows * 4).fill(-1);
+    const parentDir = new Int8Array(cols * rows * 4).fill(-1);
+    const heap = new MinHeap();
+    // Initialize: try all 4 directions from source
+    for (let d = 0; d < 4; d++) {
+        const key = (sy * cols + sx) * 4 + d;
+        g[key] = 0;
+        const h = Math.abs(tx - sx) + Math.abs(ty - sy);
+        heap.push(h, key);
+    }
+    let found = false;
+    while (heap.size > 0) {
+        const item = heap.pop();
+        if (!item)
+            break;
+        const { key } = item;
+        const dir = key % 4;
+        const cell = (key - dir) / 4;
+        const cx = cell % cols;
+        const cy = (cell - cx) / cols;
+        if (cx === tx && cy === ty) {
+            found = true;
+            // Reconstruct path
+            const path = [];
+            let k = key;
+            while (k !== -1) {
+                const kDir = k % 4;
+                const kCell = (k - kDir) / 4;
+                const kx = kCell % cols;
+                const ky = (kCell - kx) / cols;
+                path.push({ x: kx * GRID_RES + minX, y: ky * GRID_RES + minY });
+                k = parent[k] ?? -1;
+            }
+            path.reverse();
+            // Simplify collinear points
+            return simplifyPath(path);
+        }
+        const gCur = g[key] ?? INF;
+        for (let nd = 0; nd < 4; nd++) {
+            const nx = cx + (DX[nd] ?? 0);
+            const ny = cy + (DY[nd] ?? 0);
+            if (nx < 0 || nx >= cols || ny < 0 || ny >= rows)
+                continue;
+            const ncell = ny * cols + nx;
+            if (blocked[ncell])
+                continue;
+            const nkey = ncell * 4 + nd;
+            const turnCost = nd !== dir ? TURN_PENALTY : 0;
+            const ng = gCur + 1 + turnCost;
+            const prevG = g[nkey] ?? INF;
+            if (ng < prevG) {
+                g[nkey] = ng;
+                parent[nkey] = key;
+                parentDir[nkey] = dir;
+                const h = Math.abs(tx - nx) + Math.abs(ty - ny);
+                heap.push(ng + h, nkey);
+            }
+        }
+    }
+    if (!found) {
+        // Fall back to straight line
+        return [source, target];
+    }
+    return [source, target];
+}
+/** Remove collinear intermediate waypoints. */
+function simplifyPath(path) {
+    if (path.length <= 2)
+        return path;
+    const result = [path[0]];
+    for (let i = 1; i < path.length - 1; i++) {
+        const prev = path[i - 1];
+        const curr = path[i];
+        const next = path[i + 1];
+        const isCollinear = (Math.abs(prev.x - curr.x) < 0.5 && Math.abs(curr.x - next.x) < 0.5) ||
+            (Math.abs(prev.y - curr.y) < 0.5 && Math.abs(curr.y - next.y) < 0.5);
+        if (!isCollinear) {
+            result.push(curr);
+        }
+    }
+    result.push(path[path.length - 1]);
+    return result;
+}
+//# sourceMappingURL=astar.js.map

package/dist/layout/block-builder.d.ts

@@ -0,0 +1,37 @@
+import type { BpmnElementType, BpmnFlowElement } from "../bpmn/bpmn-model.js";
+import type { DirectedGraph } from "./graph.js";
+export type FlowBlock = NodeBlock | GatewayBlock | SequenceBlock;
+export interface NodeBlock {
+    kind: "node";
+    id: string;
+    type: BpmnElementType;
+    label?: string;
+    width: number;
+    height: number;
+    x: number;
+    y: number;
+}
+export interface SequenceBlock {
+    kind: "sequence";
+    items: FlowBlock[];
+    width: number;
+    height: number;
+    x: number;
+    y: number;
+}
+export interface GatewayBlock {
+    kind: "gateway";
+    split: NodeBlock;
+    join: NodeBlock;
+    branches: SequenceBlock[];
+    branchColumnWidth: number;
+    width: number;
+    height: number;
+    x: number;
+    y: number;
+}
+/**
+ * Attempt to build block tree. Returns null if process is unstructured.
+ */
+export declare function buildBlockTree(dag: DirectedGraph, nodeIndex: Map<string, BpmnFlowElement>): SequenceBlock | null;
+//# sourceMappingURL=block-builder.d.ts.map

package/dist/layout/block-builder.js

@@ -0,0 +1,154 @@
+import { topologicalSort } from "./graph.js";
+import { ELEMENT_SIZES } from "./types.js";
+const GATEWAY_TYPES = new Set([
+    "exclusiveGateway",
+    "parallelGateway",
+    "inclusiveGateway",
+    "eventBasedGateway",
+    "complexGateway",
+]);
+/** Make a NodeBlock for the given element. */
+function makeNodeBlock(id, nodeIndex) {
+    const el = nodeIndex.get(id);
+    const type = el?.type ?? "serviceTask";
+    const size = ELEMENT_SIZES[type] ?? { width: 100, height: 80 };
+    return {
+        kind: "node",
+        id,
+        type,
+        label: el?.name,
+        width: size.width,
+        height: size.height,
+        x: 0,
+        y: 0,
+    };
+}
+/**
+ * Find the matching join gateway for a split gateway.
+ * Uses a depth counter across the topoOrder of provided node IDs:
+ * +1 for each split (outDegree≥2), -1 for each join (inDegree≥2).
+ * First time depth returns to 0 → that's the matching join.
+ */
+function findMatchingJoin(splitId, orderedIds, splitPos, dag, nodeIndex) {
+    let depth = 1;
+    for (let j = splitPos + 1; j < orderedIds.length; j++) {
+        const id = orderedIds[j];
+        if (!id)
+            continue;
+        const el = nodeIndex.get(id);
+        if (!el || !GATEWAY_TYPES.has(el.type))
+            continue;
+        const outDegree = (dag.successors.get(id) ?? []).length;
+        const inDegree = (dag.predecessors.get(id) ?? []).length;
+        if (outDegree >= 2)
+            depth++;
+        if (inDegree >= 2) {
+            depth--;
+            if (depth === 0)
+                return id;
+        }
+    }
+    return undefined;
+}
+/**
+ * Collect all node IDs reachable from startId before reaching stopId (exclusive).
+ * Uses BFS over DAG successors. The stop node is not included.
+ */
+function collectBranchNodes(startId, stopId, dag) {
+    const result = [];
+    const seen = new Set();
+    const queue = [startId];
+    while (queue.length > 0) {
+        const id = queue.shift();
+        if (!id || seen.has(id) || id === stopId)
+            continue;
+        seen.add(id);
+        result.push(id);
+        for (const succ of dag.successors.get(id) ?? []) {
+            if (!seen.has(succ) && succ !== stopId) {
+                queue.push(succ);
+            }
+        }
+    }
+    return result;
+}
+/**
+ * Build a SequenceBlock for the given ordered list of node IDs.
+ * Recursively handles nested gateways.
+ * Throws if the structure is unstructured (no matching join found).
+ */
+function buildSequenceFromIds(orderedIds, dag, nodeIndex, topoPos) {
+    const items = [];
+    let i = 0;
+    while (i < orderedIds.length) {
+        const id = orderedIds[i];
+        if (!id) {
+            i++;
+            continue;
+        }
+        const el = nodeIndex.get(id);
+        const outDegree = (dag.successors.get(id) ?? []).length;
+        const isSplit = outDegree >= 2 && el !== undefined && GATEWAY_TYPES.has(el.type);
+        if (isSplit) {
+            // This is a split gateway — find its matching join within orderedIds
+            const joinId = findMatchingJoin(id, orderedIds, i, dag, nodeIndex);
+            if (!joinId)
+                throw new Error(`No matching join for split gateway ${id}`);
+            const joinPos = orderedIds.indexOf(joinId);
+            if (joinPos < 0)
+                throw new Error(`Join ${joinId} not in current sequence`);
+            // For each successor of split, collect branch nodes (up to join)
+            const successors = dag.successors.get(id) ?? [];
+            const branches = [];
+            for (const succId of successors) {
+                // Collect nodes in this branch (BFS stopping at join)
+                const branchNodes = collectBranchNodes(succId, joinId, dag);
+                // Filter to only nodes that appear in orderedIds (safety)
+                const branchSet = new Set(branchNodes);
+                // Sort by topo position
+                const branchOrdered = orderedIds.filter((nid) => branchSet.has(nid));
+                branches.push(buildSequenceFromIds(branchOrdered, dag, nodeIndex, topoPos));
+            }
+            const splitBlock = makeNodeBlock(id, nodeIndex);
+            const joinBlock = makeNodeBlock(joinId, nodeIndex);
+            const gatewayBlock = {
+                kind: "gateway",
+                split: splitBlock,
+                join: joinBlock,
+                branches,
+                branchColumnWidth: 0,
+                width: 0,
+                height: 0,
+                x: 0,
+                y: 0,
+            };
+            items.push(gatewayBlock);
+            // Skip past the join gateway
+            i = joinPos + 1;
+        }
+        else {
+            items.push(makeNodeBlock(id, nodeIndex));
+            i++;
+        }
+    }
+    return { kind: "sequence", items, width: 0, height: 0, x: 0, y: 0 };
+}
+/**
+ * Attempt to build block tree. Returns null if process is unstructured.
+ */
+export function buildBlockTree(dag, nodeIndex) {
+    try {
+        const topoOrder = topologicalSort(dag);
+        const topoPos = new Map();
+        for (let i = 0; i < topoOrder.length; i++) {
+            const id = topoOrder[i];
+            if (id)
+                topoPos.set(id, i);
+        }
+        return buildSequenceFromIds(topoOrder, dag, nodeIndex, topoPos);
+    }
+    catch {
+        return null;
+    }
+}
+//# sourceMappingURL=block-builder.js.map

package/dist/layout/block-layout.d.ts

@@ -0,0 +1,9 @@
+import type { BpmnFlowElement } from "../bpmn/bpmn-model.js";
+import type { SequenceBlock } from "./block-builder.js";
+import type { LayoutNode } from "./types.js";
+/**
+ * Apply block-based layout: size (bottom-up) then position (top-down).
+ * Returns LayoutNode[] with absolute positions.
+ */
+export declare function applyBlockLayout(root: SequenceBlock, nodeIndex: Map<string, BpmnFlowElement>): LayoutNode[];
+//# sourceMappingURL=block-layout.d.ts.map