@bpmnkit/core 0.0.26 → 0.1.0

package/dist/bpmn/bpmn-builder.js

@@ -333,6 +333,31 @@ function makeInclusiveGatewayEl(id, options) {
     }
     return el;
 }
+/**
+ * `subProcess`/`eventSubProcess`/`adHocSubProcess` all take a required content
+ * callback as their 2nd argument and an optional options object as their 3rd.
+ * That shape isn't demonstrated anywhere in this SDK's docs/examples, and
+ * callers that only see the parameter *names* (not enforced types — e.g.
+ * generated code run without type-checking) sometimes guess the common
+ * "options before callback" order instead. Detect that by runtime type and
+ * swap, so a reversed call still succeeds instead of throwing on `content`
+ * not being callable.
+ */
+function resolveSubProcessArgs(content, options) {
+    if (typeof content === "function") {
+        return {
+            content: content,
+            options: options,
+        };
+    }
+    if (typeof options === "function") {
+        return {
+            content: options,
+            options: content,
+        };
+    }
+    throw new TypeError("subProcess() requires a content callback function");
+}
 // ---------------------------------------------------------------------------
 // Shared graph helpers — used by ProcessBuilder and SubProcessContentBuilder
 // ---------------------------------------------------------------------------
@@ -712,6 +737,120 @@ export class BranchBuilder {
         this.openBranchEnds = savedOpenEnds;
         return this;
     }
+    // ---- Sub-process ----
+    /** Add a sub-process (mirrors `ProcessBuilder.subProcess`). */
+    subProcess(id, content, options) {
+        const resolved = resolveSubProcessArgs(content, options);
+        const sub = new SubProcessContentBuilder(this.rootMessages);
+        resolved.content(sub);
+        insertJoinGateways(sub._elements, sub._flows);
+        recomputeIncomingOutgoing(sub._elements, sub._flows);
+        const element = makeFlowElement(id, "subProcess", resolved.options);
+        if (element.type === "subProcess") {
+            element.flowElements = sub._elements;
+            element.sequenceFlows = sub._flows;
+            element.textAnnotations = sub._textAnnotations;
+            element.associations = sub._associations;
+            if (resolved.options?.multiInstance) {
+                element.loopCharacteristics = buildMultiInstance(resolved.options.multiInstance);
+            }
+        }
+        return this.addElement(element);
+    }
+    /** Add an ad-hoc sub-process (mirrors `ProcessBuilder.adHocSubProcess`). */
+    adHocSubProcess(id, content, options) {
+        const resolved = resolveSubProcessArgs(content, options);
+        const sub = new SubProcessContentBuilder(this.rootMessages);
+        resolved.content(sub);
+        insertJoinGateways(sub._elements, sub._flows);
+        recomputeIncomingOutgoing(sub._elements, sub._flows);
+        const zeebeExt = {};
+        if (resolved.options?.taskDefinition) {
+            zeebeExt.taskDefinition = resolved.options.taskDefinition;
+        }
+        if (resolved.options?.ioMapping) {
+            zeebeExt.ioMapping = {
+                inputs: resolved.options.ioMapping.inputs ?? [],
+                outputs: resolved.options.ioMapping.outputs ?? [],
+            };
+        }
+        if (resolved.options?.taskHeaders) {
+            zeebeExt.taskHeaders = {
+                headers: Object.entries(resolved.options.taskHeaders).map(([key, value]) => ({
+                    key,
+                    value,
+                })),
+            };
+        }
+        const extensionElements = zeebeExtensionsToXmlElements(zeebeExt);
+        const adHocAttrs = {};
+        if (resolved.options?.activeElementsCollection) {
+            adHocAttrs.activeElementsCollection = resolved.options.activeElementsCollection;
+        }
+        if (resolved.options?.outputCollection) {
+            adHocAttrs.outputCollection = resolved.options.outputCollection;
+        }
+        if (resolved.options?.outputElement) {
+            adHocAttrs.outputElement = resolved.options.outputElement;
+        }
+        if (Object.keys(adHocAttrs).length > 0) {
+            extensionElements.push({
+                name: "zeebe:adHoc",
+                attributes: adHocAttrs,
+                children: [],
+            });
+        }
+        const element = makeFlowElement(id, "adHocSubProcess", {
+            name: resolved.options?.name,
+            extensionElements,
+        });
+        if (resolved.options?.modelerTemplate) {
+            element.unknownAttributes["zeebe:modelerTemplate"] = resolved.options.modelerTemplate;
+        }
+        if (resolved.options?.modelerTemplateVersion) {
+            element.unknownAttributes["zeebe:modelerTemplateVersion"] =
+                resolved.options.modelerTemplateVersion;
+        }
+        if (resolved.options?.modelerTemplateIcon) {
+            element.unknownAttributes["zeebe:modelerTemplateIcon"] = resolved.options.modelerTemplateIcon;
+        }
+        if (element.type === "adHocSubProcess") {
+            element.flowElements = sub._elements;
+            element.sequenceFlows = sub._flows;
+            element.textAnnotations = sub._textAnnotations;
+            element.associations = sub._associations;
+            if (resolved.options?.loopCharacteristics) {
+                element.loopCharacteristics = buildAdHocLoopCharacteristics(resolved.options.loopCharacteristics);
+            }
+            else if (resolved.options?.multiInstance) {
+                element.loopCharacteristics = buildMultiInstance(resolved.options.multiInstance);
+            }
+        }
+        return this.addElement(element);
+    }
+    /** Add an event sub-process. Triggered by its start event — no incoming or outgoing sequence flows. */
+    eventSubProcess(id, content, options) {
+        const resolved = resolveSubProcessArgs(content, options);
+        const sub = new SubProcessContentBuilder(this.rootMessages);
+        resolved.content(sub);
+        insertJoinGateways(sub._elements, sub._flows);
+        recomputeIncomingOutgoing(sub._elements, sub._flows);
+        const element = makeFlowElement(id, "subProcess", resolved.options);
+        if (element.type === "subProcess") {
+            element.triggeredByEvent = true;
+            element.flowElements = sub._elements;
+            element.sequenceFlows = sub._flows;
+            element.textAnnotations = sub._textAnnotations;
+            element.associations = sub._associations;
+        }
+        // Event sub-processes have no incoming/outgoing sequence flows and must not
+        // advance the branch cursor — mirrors ProcessBuilder.eventSubProcess.
+        if (this._elements.some((n) => n.id === element.id)) {
+            throw new Error(`Duplicate element ID "${element.id}"`);
+        }
+        this._elements.push(element);
+        return this;
+    }
     /**
      * Create a named branch from the last gateway added inside this branch.
      *
@@ -976,6 +1115,172 @@ export class SubProcessContentBuilder {
         this.currentGatewayId = undefined;
         return this;
     }
+    // ---- Boundary events ----
+    /**
+     * Add a boundary event attached to an existing activity in this sub-process.
+     *
+     * 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);
+        }
+        // Push directly — no sequence flow, boundary events attach via attachedToRef
+        this._elements.push(element);
+        this.lastNodeId = element.id;
+        return this;
+    }
+    /**
+     * Attach a boundary event to the preceding task and build its outgoing path,
+     * then restore the builder cursor to the preceding task so the main 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) {
+            throw new Error("withBoundary() must follow a task element inside the sub-process. 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 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 sub-process main flow continues
+        this.lastNodeId = savedLast;
+        this.currentGatewayId = savedGateway;
+        this.openBranchEnds = savedOpenEnds;
+        return this;
+    }
+    // ---- Sub-process ----
+    /** Add a sub-process nested inside this sub-process's content. */
+    subProcess(id, content, options) {
+        const resolved = resolveSubProcessArgs(content, options);
+        const sub = new SubProcessContentBuilder(this.rootMessages);
+        resolved.content(sub);
+        insertJoinGateways(sub._elements, sub._flows);
+        recomputeIncomingOutgoing(sub._elements, sub._flows);
+        const element = makeFlowElement(id, "subProcess", resolved.options);
+        if (element.type === "subProcess") {
+            element.flowElements = sub._elements;
+            element.sequenceFlows = sub._flows;
+            element.textAnnotations = sub._textAnnotations;
+            element.associations = sub._associations;
+            if (resolved.options?.multiInstance) {
+                element.loopCharacteristics = buildMultiInstance(resolved.options.multiInstance);
+            }
+        }
+        return this.addElement(element);
+    }
+    /** Add an ad-hoc sub-process nested inside this sub-process's content. */
+    adHocSubProcess(id, content, options) {
+        const resolved = resolveSubProcessArgs(content, options);
+        const sub = new SubProcessContentBuilder(this.rootMessages);
+        resolved.content(sub);
+        insertJoinGateways(sub._elements, sub._flows);
+        recomputeIncomingOutgoing(sub._elements, sub._flows);
+        const zeebeExt = {};
+        if (resolved.options?.taskDefinition) {
+            zeebeExt.taskDefinition = resolved.options.taskDefinition;
+        }
+        if (resolved.options?.ioMapping) {
+            zeebeExt.ioMapping = {
+                inputs: resolved.options.ioMapping.inputs ?? [],
+                outputs: resolved.options.ioMapping.outputs ?? [],
+            };
+        }
+        if (resolved.options?.taskHeaders) {
+            zeebeExt.taskHeaders = {
+                headers: Object.entries(resolved.options.taskHeaders).map(([key, value]) => ({
+                    key,
+                    value,
+                })),
+            };
+        }
+        const extensionElements = zeebeExtensionsToXmlElements(zeebeExt);
+        const adHocAttrs = {};
+        if (resolved.options?.activeElementsCollection) {
+            adHocAttrs.activeElementsCollection = resolved.options.activeElementsCollection;
+        }
+        if (resolved.options?.outputCollection) {
+            adHocAttrs.outputCollection = resolved.options.outputCollection;
+        }
+        if (resolved.options?.outputElement) {
+            adHocAttrs.outputElement = resolved.options.outputElement;
+        }
+        if (Object.keys(adHocAttrs).length > 0) {
+            extensionElements.push({
+                name: "zeebe:adHoc",
+                attributes: adHocAttrs,
+                children: [],
+            });
+        }
+        const element = makeFlowElement(id, "adHocSubProcess", {
+            name: resolved.options?.name,
+            extensionElements,
+        });
+        if (resolved.options?.modelerTemplate) {
+            element.unknownAttributes["zeebe:modelerTemplate"] = resolved.options.modelerTemplate;
+        }
+        if (resolved.options?.modelerTemplateVersion) {
+            element.unknownAttributes["zeebe:modelerTemplateVersion"] =
+                resolved.options.modelerTemplateVersion;
+        }
+        if (resolved.options?.modelerTemplateIcon) {
+            element.unknownAttributes["zeebe:modelerTemplateIcon"] = resolved.options.modelerTemplateIcon;
+        }
+        if (element.type === "adHocSubProcess") {
+            element.flowElements = sub._elements;
+            element.sequenceFlows = sub._flows;
+            element.textAnnotations = sub._textAnnotations;
+            element.associations = sub._associations;
+            if (resolved.options?.loopCharacteristics) {
+                element.loopCharacteristics = buildAdHocLoopCharacteristics(resolved.options.loopCharacteristics);
+            }
+            else if (resolved.options?.multiInstance) {
+                element.loopCharacteristics = buildMultiInstance(resolved.options.multiInstance);
+            }
+        }
+        return this.addElement(element);
+    }
+    /** Add an event sub-process. Triggered by its start event — no incoming or outgoing sequence flows. */
+    eventSubProcess(id, content, options) {
+        const resolved = resolveSubProcessArgs(content, options);
+        const sub = new SubProcessContentBuilder(this.rootMessages);
+        resolved.content(sub);
+        insertJoinGateways(sub._elements, sub._flows);
+        recomputeIncomingOutgoing(sub._elements, sub._flows);
+        const element = makeFlowElement(id, "subProcess", resolved.options);
+        if (element.type === "subProcess") {
+            element.triggeredByEvent = true;
+            element.flowElements = sub._elements;
+            element.sequenceFlows = sub._flows;
+            element.textAnnotations = sub._textAnnotations;
+            element.associations = sub._associations;
+        }
+        // Event sub-processes have no incoming/outgoing sequence flows and must not
+        // advance the cursor — mirrors ProcessBuilder.eventSubProcess.
+        if (this._elements.some((n) => n.id === element.id)) {
+            throw new Error(`Duplicate element ID "${element.id}" in sub-process`);
+        }
+        this._elements.push(element);
+        return this;
+    }
 }
 // ---------------------------------------------------------------------------
 // Process builder (top-level entry point)
@@ -1374,36 +1679,40 @@ export class ProcessBuilder {
     // ---- Sub-processes ----
     /** Add an ad-hoc sub-process with optional AI agent or multi-instance configuration. */
     adHocSubProcess(id, content, options) {
+        const resolved = resolveSubProcessArgs(content, options);
         const sub = new SubProcessContentBuilder(this.rootMessages);
-        content(sub);
+        resolved.content(sub);
         insertJoinGateways(sub._elements, sub._flows);
         recomputeIncomingOutgoing(sub._elements, sub._flows);
         const zeebeExt = {};
-        if (options?.taskDefinition) {
-            zeebeExt.taskDefinition = options.taskDefinition;
+        if (resolved.options?.taskDefinition) {
+            zeebeExt.taskDefinition = resolved.options.taskDefinition;
         }
-        if (options?.ioMapping) {
+        if (resolved.options?.ioMapping) {
             zeebeExt.ioMapping = {
-                inputs: options.ioMapping.inputs ?? [],
-                outputs: options.ioMapping.outputs ?? [],
+                inputs: resolved.options.ioMapping.inputs ?? [],
+                outputs: resolved.options.ioMapping.outputs ?? [],
             };
         }
-        if (options?.taskHeaders) {
+        if (resolved.options?.taskHeaders) {
             zeebeExt.taskHeaders = {
-                headers: Object.entries(options.taskHeaders).map(([key, value]) => ({ key, value })),
+                headers: Object.entries(resolved.options.taskHeaders).map(([key, value]) => ({
+                    key,
+                    value,
+                })),
             };
         }
         const extensionElements = zeebeExtensionsToXmlElements(zeebeExt);
         // zeebe:adHoc element
         const adHocAttrs = {};
-        if (options?.activeElementsCollection) {
-            adHocAttrs.activeElementsCollection = options.activeElementsCollection;
+        if (resolved.options?.activeElementsCollection) {
+            adHocAttrs.activeElementsCollection = resolved.options.activeElementsCollection;
         }
-        if (options?.outputCollection) {
-            adHocAttrs.outputCollection = options.outputCollection;
+        if (resolved.options?.outputCollection) {
+            adHocAttrs.outputCollection = resolved.options.outputCollection;
         }
-        if (options?.outputElement) {
-            adHocAttrs.outputElement = options.outputElement;
+        if (resolved.options?.outputElement) {
+            adHocAttrs.outputElement = resolved.options.outputElement;
         }
         if (Object.keys(adHocAttrs).length > 0) {
             extensionElements.push({
@@ -1413,28 +1722,29 @@ export class ProcessBuilder {
             });
         }
         const element = makeFlowElement(id, "adHocSubProcess", {
-            name: options?.name,
+            name: resolved.options?.name,
             extensionElements,
         });
-        if (options?.modelerTemplate) {
-            element.unknownAttributes["zeebe:modelerTemplate"] = options.modelerTemplate;
+        if (resolved.options?.modelerTemplate) {
+            element.unknownAttributes["zeebe:modelerTemplate"] = resolved.options.modelerTemplate;
         }
-        if (options?.modelerTemplateVersion) {
-            element.unknownAttributes["zeebe:modelerTemplateVersion"] = options.modelerTemplateVersion;
+        if (resolved.options?.modelerTemplateVersion) {
+            element.unknownAttributes["zeebe:modelerTemplateVersion"] =
+                resolved.options.modelerTemplateVersion;
         }
-        if (options?.modelerTemplateIcon) {
-            element.unknownAttributes["zeebe:modelerTemplateIcon"] = options.modelerTemplateIcon;
+        if (resolved.options?.modelerTemplateIcon) {
+            element.unknownAttributes["zeebe:modelerTemplateIcon"] = resolved.options.modelerTemplateIcon;
         }
         if (element.type === "adHocSubProcess") {
             element.flowElements = sub._elements;
             element.sequenceFlows = sub._flows;
             element.textAnnotations = sub._textAnnotations;
             element.associations = sub._associations;
-            if (options?.loopCharacteristics) {
-                element.loopCharacteristics = buildAdHocLoopCharacteristics(options.loopCharacteristics);
+            if (resolved.options?.loopCharacteristics) {
+                element.loopCharacteristics = buildAdHocLoopCharacteristics(resolved.options.loopCharacteristics);
             }
-            else if (options?.multiInstance) {
-                element.loopCharacteristics = buildMultiInstance(options.multiInstance);
+            else if (resolved.options?.multiInstance) {
+                element.loopCharacteristics = buildMultiInstance(resolved.options.multiInstance);
             }
         }
         this.addFlowElement(element);
@@ -1442,18 +1752,19 @@ export class ProcessBuilder {
     }
     /** Add a sub-process (aspirational). */
     subProcess(id, content, options) {
+        const resolved = resolveSubProcessArgs(content, options);
         const sub = new SubProcessContentBuilder(this.rootMessages);
-        content(sub);
+        resolved.content(sub);
         insertJoinGateways(sub._elements, sub._flows);
         recomputeIncomingOutgoing(sub._elements, sub._flows);
-        const element = makeFlowElement(id, "subProcess", options);
+        const element = makeFlowElement(id, "subProcess", resolved.options);
         if (element.type === "subProcess") {
             element.flowElements = sub._elements;
             element.sequenceFlows = sub._flows;
             element.textAnnotations = sub._textAnnotations;
             element.associations = sub._associations;
-            if (options?.multiInstance) {
-                element.loopCharacteristics = buildMultiInstance(options.multiInstance);
+            if (resolved.options?.multiInstance) {
+                element.loopCharacteristics = buildMultiInstance(resolved.options.multiInstance);
             }
         }
         this.addFlowElement(element);
@@ -1461,11 +1772,12 @@ export class ProcessBuilder {
     }
     /** Add an event sub-process. Triggered by its start event — no incoming or outgoing sequence flows. */
     eventSubProcess(id, content, options) {
+        const resolved = resolveSubProcessArgs(content, options);
         const sub = new SubProcessContentBuilder(this.rootMessages);
-        content(sub);
+        resolved.content(sub);
         insertJoinGateways(sub._elements, sub._flows);
         recomputeIncomingOutgoing(sub._elements, sub._flows);
-        const element = makeFlowElement(id, "subProcess", options);
+        const element = makeFlowElement(id, "subProcess", resolved.options);
         if (element.type === "subProcess") {
             element.triggeredByEvent = true;
             element.flowElements = sub._elements;

package/dist/bpmn/di-check.d.ts

@@ -0,0 +1,14 @@
+import type { BpmnDefinitions } from "./bpmn-model.js";
+export interface DiCompleteness {
+    missingShapes: string[];
+    missingEdges: string[];
+}
+/**
+ * Assert the diagram DI is complete: every flow node (recursively, incl.
+ * subprocess children and boundary events) and text annotation has a
+ * BPMNShape; every sequence flow, association and message flow has a
+ * BPMNEdge. Lanes are ignored (no reliable lane DI — matches the
+ * tmp/02-di-check.cjs rule this ports).
+ */
+export declare function checkDiCompleteness(defs: BpmnDefinitions): DiCompleteness;
+//# sourceMappingURL=di-check.d.ts.map

package/dist/bpmn/di-check.js

@@ -0,0 +1,51 @@
+/**
+ * Assert the diagram DI is complete: every flow node (recursively, incl.
+ * subprocess children and boundary events) and text annotation has a
+ * BPMNShape; every sequence flow, association and message flow has a
+ * BPMNEdge. Lanes are ignored (no reliable lane DI — matches the
+ * tmp/02-di-check.cjs rule this ports).
+ */
+export function checkDiCompleteness(defs) {
+    const shapes = new Set();
+    const edges = new Set();
+    for (const d of defs.diagrams) {
+        for (const s of d.plane.shapes)
+            shapes.add(s.bpmnElement);
+        for (const e of d.plane.edges)
+            edges.add(e.bpmnElement);
+    }
+    const missingShapes = [];
+    const missingEdges = [];
+    function walkElements(els, flows) {
+        for (const el of els) {
+            if (!shapes.has(el.id))
+                missingShapes.push(el.id);
+            const sub = el;
+            if (sub.flowElements?.length)
+                walkElements(sub.flowElements, sub.sequenceFlows ?? []);
+        }
+        for (const f of flows) {
+            if (!edges.has(f.id))
+                missingEdges.push(f.id);
+        }
+    }
+    for (const p of defs.processes) {
+        walkElements(p.flowElements, p.sequenceFlows);
+        for (const ta of p.textAnnotations)
+            if (!shapes.has(ta.id))
+                missingShapes.push(ta.id);
+        for (const a of p.associations)
+            if (!edges.has(a.id))
+                missingEdges.push(a.id);
+    }
+    for (const c of defs.collaborations) {
+        for (const part of c.participants)
+            if (!shapes.has(part.id))
+                missingShapes.push(part.id);
+        for (const mf of c.messageFlows)
+            if (!edges.has(mf.id))
+                missingEdges.push(mf.id);
+    }
+    return { missingShapes, missingEdges };
+}
+//# sourceMappingURL=di-check.js.map

package/dist/bpmn/svg.js

@@ -119,6 +119,9 @@ export function exportSvg(defs, options) {
         }
     }
     // ── Shapes ────────────────────────────────────────────────────────────────
+    // Pool/lane backgrounds are opaque and must render first, or they paint over
+    // the flow-node shapes and edges nested inside them.
+    const containerParts = [];
     const shapeParts = [];
     const labelParts = [];
     for (const shape of plane.shapes) {
@@ -126,6 +129,7 @@ export function exportSvg(defs, options) {
         const el = idx.elements.get(shape.bpmnElement);
         const type = el?.type ?? "";
         let inner;
+        let isContainer = false;
         if (isEvent(type)) {
             inner = renderEvent(el, width, height, t);
         }
@@ -140,9 +144,11 @@ export function exportSvg(defs, options) {
             }
             else if (idx.participants.has(shape.bpmnElement)) {
                 inner = renderPool(idx.participants.get(shape.bpmnElement), width, height, t);
+                isContainer = true;
             }
             else if (idx.lanes.has(shape.bpmnElement)) {
                 inner = renderLane(idx.lanes.get(shape.bpmnElement), width, height, t);
+                isContainer = true;
             }
             else {
                 inner = "";
@@ -152,7 +158,13 @@ export function exportSvg(defs, options) {
             inner = renderTask(el, width, height, t);
         }
         if (inner) {
-            shapeParts.push(`<g transform="translate(${x} ${y})">${inner}</g>`);
+            const g = `<g transform="translate(${x} ${y})">${inner}</g>`;
+            if (isContainer) {
+                containerParts.push(g);
+            }
+            else {
+                shapeParts.push(g);
+            }
         }
         // External labels for events and gateways
         const isExtLabel = isEvent(type) || isGateway(type);
@@ -177,6 +189,7 @@ export function exportSvg(defs, options) {
         `    <path d="M0,0 L8,3 L0,6 Z" fill="${arrowFill}"/>`,
         "  </marker>",
         "</defs>",
+        ...containerParts,
         ...edgeParts,
         ...shapeParts,
         ...labelParts,

package/dist/index.d.ts

@@ -4,6 +4,8 @@ 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 { checkDiCompleteness } from "./bpmn/di-check.js";
+export type { DiCompleteness } from "./bpmn/di-check.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";

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 { checkDiCompleteness } from "./bpmn/di-check.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";

package/dist/layout/annotations.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Text-annotation packer. Port of the layout phase of
+ * tmp/01-annotation-layouting.cjs (lines 96-389), adapted to operate on
+ * already-parsed LayoutNode[] / Bounds instead of regex-parsed BPMN DI
+ * shapes. Constants, formulas and control flow match the reference exactly.
+ */
+import type { BpmnProcess } from "../bpmn/bpmn-model.js";
+import type { Bounds, LayoutNode, Waypoint } from "./types.js";
+/**
+ * Sizes and packs text annotations around their linked elements without
+ * overlapping each other or any other layout node (incl. node labels).
+ * Returns final Bounds per annotation id; annotations with no resolvable
+ * association target (no association at all, or the linked element isn't
+ * in `layoutNodes`) still get an entry — they're placed at a fixed fallback
+ * origin and pushed clear of everything else already placed, mirroring the
+ * pre-port fallback in auto-layout.ts's computeAnnotationLocalBounds.
+ */
+export declare function packAnnotations(process: BpmnProcess, layoutNodes: LayoutNode[]): Map<string, Bounds>;
+/**
+ * Edge-to-edge, clamped association waypoints between a linked element and
+ * its annotation. Port of `chooseWaypoints` (tmp/01-annotation-layouting.cjs:365-389).
+ */
+export declare function associationWaypoints(elementBounds: Bounds, annotationBounds: Bounds): {
+    pElem: Waypoint;
+    pAnn: Waypoint;
+};
+//# sourceMappingURL=annotations.d.ts.map