@bpmnkit/core 0.1.0 → 0.1.2

package/dist/bpmn/optimize/feel-syntax.js

@@ -0,0 +1,87 @@
+import { parseExpression } from "@bpmnkit/feel";
+import { readZeebeIoMapping } from "./utils.js";
+/** Recursively yields every flow element in a process, including inside sub-processes/ad-hoc sub-processes. */
+function* walkElements(elements) {
+    for (const el of elements) {
+        yield el;
+        if (el.type === "subProcess" ||
+            el.type === "adHocSubProcess" ||
+            el.type === "eventSubProcess" ||
+            el.type === "transaction") {
+            yield* walkElements(el.flowElements);
+        }
+    }
+}
+/** Recursively yields every sequence flow, including inside sub-processes/ad-hoc sub-processes. */
+function* walkFlows(elements, topLevel) {
+    yield* topLevel;
+    for (const el of elements) {
+        if (el.type === "subProcess" ||
+            el.type === "adHocSubProcess" ||
+            el.type === "eventSubProcess" ||
+            el.type === "transaction") {
+            yield* walkFlows(el.flowElements, el.sequenceFlows);
+        }
+    }
+}
+function checkFeel(text, elementId, processId, surface, findings) {
+    const trimmed = text.trim();
+    if (!trimmed.startsWith("="))
+        return;
+    const { errors } = parseExpression(trimmed.slice(1));
+    for (const err of errors) {
+        findings.push({
+            id: "feel-syntax/parse-error",
+            category: "feel-syntax",
+            severity: "error",
+            message: `Invalid FEEL expression on ${surface} of "${elementId}": ${err.message}`,
+            suggestion: "Fix the FEEL syntax — see the error position for the offending token.",
+            processId,
+            elementIds: [elementId],
+        });
+    }
+}
+/**
+ * Parse-validates every FEEL-looking expression (leading "=") in the process:
+ * sequence-flow conditions, zeebe:input/output sources, script task
+ * expressions, and ad-hoc sub-process completion conditions/outputElement —
+ * including inside nested sub-processes. Unlike `feel.ts` (heuristic
+ * complexity scoring), this uses the real `@bpmnkit/feel` parser and reports
+ * genuine syntax errors, not style suggestions.
+ */
+export function analyzeFeelSyntax(p) {
+    const findings = [];
+    const processId = p.id;
+    for (const flow of walkFlows(p.flowElements, p.sequenceFlows)) {
+        if (flow.conditionExpression?.text) {
+            checkFeel(flow.conditionExpression.text, flow.id, processId, "condition", findings);
+        }
+    }
+    for (const el of walkElements(p.flowElements)) {
+        const io = readZeebeIoMapping(el.extensionElements);
+        if (io) {
+            for (const input of io.inputs)
+                checkFeel(input.source, el.id, processId, `input "${input.target}"`, findings);
+            for (const output of io.outputs)
+                checkFeel(output.source, el.id, processId, `output "${output.target}"`, findings);
+        }
+        const scriptExt = el.extensionElements.find((e) => e.name === "zeebe:script");
+        if (scriptExt?.attributes.expression) {
+            checkFeel(scriptExt.attributes.expression, el.id, processId, "script expression", findings);
+        }
+        if (el.type === "adHocSubProcess") {
+            if (el.completionCondition?.text) {
+                checkFeel(el.completionCondition.text, el.id, processId, "completion condition", findings);
+            }
+            const adHocExt = el.extensionElements.find((e) => e.name === "zeebe:adHoc");
+            if (adHocExt?.attributes.outputElement) {
+                checkFeel(adHocExt.attributes.outputElement, el.id, processId, "outputElement", findings);
+            }
+            if (adHocExt?.attributes.activeElementsCollection) {
+                checkFeel(adHocExt.attributes.activeElementsCollection, el.id, processId, "activeElementsCollection", findings);
+            }
+        }
+    }
+    return findings;
+}
+//# sourceMappingURL=feel-syntax.js.map

package/dist/bpmn/optimize/feel.js

@@ -63,10 +63,13 @@ export function analyzeFeel(p, opts) {
     // Track FEEL expressions across all sequence flows for duplicate detection
     const exprToFlowIds = new Map();
     for (const flow of p.sequenceFlows) {
-        // Determine if source is an exclusive/inclusive gateway
+        // Determine if source is an exclusive/inclusive gateway with more than one
+        // outgoing flow — a join (single outgoing flow) makes no decision, so its
+        // one outgoing flow needs neither a condition nor a default marker.
         const srcEl = p.flowElements.find((e) => e.id === flow.sourceRef);
         const srcIsDecisionGateway = srcEl !== undefined &&
-            (srcEl.type === "exclusiveGateway" || srcEl.type === "inclusiveGateway");
+            (srcEl.type === "exclusiveGateway" || srcEl.type === "inclusiveGateway") &&
+            (bySource.get(srcEl.id)?.length ?? 0) > 1;
         if (srcIsDecisionGateway && srcEl !== undefined) {
             const defaultFlowId = srcEl.type === "exclusiveGateway" || srcEl.type === "inclusiveGateway"
                 ? srcEl.default

package/dist/bpmn/optimize/flow.js

@@ -32,8 +32,28 @@ export function analyzeFlow(p, _opts) {
             elementIds: [],
         });
     }
-    // BFS reachability from start events
-    const reachable = reachableFrom(startIds, bySource);
+    // BFS reachability from start events. Boundary events have no incoming
+    // sequence flow by design (they attach via `attachedToRef`), so add a
+    // synthetic edge from each host element to its boundary event(s) —
+    // otherwise every boundary event (and everything chained after it) would
+    // always be flagged as unreachable.
+    const reachabilityEdges = new Map(bySource);
+    for (const el of p.flowElements) {
+        if (el.type !== "boundaryEvent")
+            continue;
+        const hostEdges = reachabilityEdges.get(el.attachedToRef) ?? [];
+        reachabilityEdges.set(el.attachedToRef, [
+            ...hostEdges,
+            {
+                id: `synthetic-attachment-${el.id}`,
+                sourceRef: el.attachedToRef,
+                targetRef: el.id,
+                extensionElements: [],
+                unknownAttributes: {},
+            },
+        ]);
+    }
+    const reachable = reachableFrom(startIds, reachabilityEdges);
     for (const el of p.flowElements) {
         // flow/unreachable
         if (!reachable.has(el.id)) {

package/dist/bpmn/optimize/index.js

@@ -1,3 +1,6 @@
+import { analyzeAgentic } from "./agentic.js";
+import { analyzeDeploy } from "./deploy.js";
+import { analyzeFeelSyntax } from "./feel-syntax.js";
 import { analyzeFeel } from "./feel.js";
 import { analyzeFlow } from "./flow.js";
 import { analyzeNaming } from "./naming.js";
@@ -6,12 +9,16 @@ import { analyzeTasks } from "./tasks.js";
 import { analyzeVariableFlow } from "./variable-flow.js";
 const ALL_CATEGORIES = [
     "feel",
+    "feel-syntax",
     "flow",
     "naming",
     "task-reuse",
     "extract",
     "pattern",
     "data-flow",
+    "deploy",
+    "agentic",
+    "connector",
 ];
 function resolveOptions(opts) {
     return {
@@ -21,6 +28,7 @@ function resolveOptions(opts) {
         feelVariableThreshold: opts?.feelVariableThreshold ?? 4,
         reuseThreshold: opts?.reuseThreshold ?? 2,
         categories: opts?.categories ?? [...ALL_CATEGORIES],
+        resolveConnectorRequirements: opts?.resolveConnectorRequirements,
     };
 }
 /** Run static analysis on a BPMN definitions object. */
@@ -31,6 +39,9 @@ export function optimize(defs, options) {
         if (resolved.categories.includes("feel")) {
             findings.push(...analyzeFeel(process, resolved));
         }
+        if (resolved.categories.includes("feel-syntax")) {
+            findings.push(...analyzeFeelSyntax(process));
+        }
         if (resolved.categories.includes("flow")) {
             findings.push(...analyzeFlow(process, resolved));
         }
@@ -46,16 +57,16 @@ export function optimize(defs, options) {
         if (resolved.categories.includes("data-flow")) {
             findings.push(...analyzeVariableFlow(process));
         }
+        if (resolved.categories.includes("deploy") || resolved.categories.includes("connector")) {
+            const deployFindings = analyzeDeploy(process, resolved.resolveConnectorRequirements);
+            findings.push(...deployFindings.filter((f) => (f.category === "deploy" && resolved.categories.includes("deploy")) ||
+                (f.category === "connector" && resolved.categories.includes("connector"))));
+        }
+        if (resolved.categories.includes("agentic")) {
+            findings.push(...analyzeAgentic(process));
+        }
     }
-    const byCategory = Object.fromEntries([
-        "feel",
-        "flow",
-        "naming",
-        "task-reuse",
-        "extract",
-        "pattern",
-        "data-flow",
-    ].map((c) => [c, findings.filter((f) => f.category === c).length]));
+    const byCategory = Object.fromEntries(ALL_CATEGORIES.map((c) => [c, findings.filter((f) => f.category === c).length]));
     const bySeverity = Object.fromEntries(["info", "warning", "error"].map((s) => [
         s,
         findings.filter((f) => f.severity === s).length,

package/dist/bpmn/optimize/tasks.js

@@ -148,6 +148,7 @@ function buildExtractedDefs(representative, newProcessId) {
         ],
         textAnnotations: [],
         associations: [],
+        groups: [],
         unknownAttributes: {},
     };
     // Layout: start @ x=152, task @ x=260, end @ x=432, all y=100

package/dist/bpmn/optimize/types.d.ts

@@ -1,6 +1,6 @@
 import type { BpmnDefinitions } from "../bpmn-model.js";
 export type OptimizationSeverity = "info" | "warning" | "error";
-export type OptimizationCategory = "feel" | "flow" | "naming" | "task-reuse" | "extract" | "pattern" | "data-flow";
+export type OptimizationCategory = "feel" | "feel-syntax" | "flow" | "naming" | "task-reuse" | "extract" | "pattern" | "data-flow" | "deploy" | "agentic" | "connector";
 export interface ApplyFixResult {
     description: string;
     /** New BpmnDefinitions generated by the fix (e.g. extracted reusable sub-process). */
@@ -36,6 +36,14 @@ export interface OptimizeOptions {
     feelVariableThreshold?: number;
     reuseThreshold?: number;
     categories?: OptimizationCategory[];
+    /**
+     * Resolves a bundled connector template's missing required value keys —
+     * pass `(templateId, boundKeys) => applyConnectorTemplate(templateId,
+     * Object.fromEntries(boundKeys.map(k => [k, "x"]))).problems...` or an
+     * equivalent from `@bpmnkit/connectors`. Without it, `connector/*` findings
+     * are skipped (core has no dependency on the connector catalog).
+     */
+    resolveConnectorRequirements?: (templateId: string, boundKeys: string[]) => string[];
 }
 export interface ResolvedOptions {
     feelLengthThreshold: number;
@@ -44,5 +52,6 @@ export interface ResolvedOptions {
     feelVariableThreshold: number;
     reuseThreshold: number;
     categories: OptimizationCategory[];
+    resolveConnectorRequirements?: (templateId: string, boundKeys: string[]) => string[];
 }
 //# sourceMappingURL=types.d.ts.map

package/dist/bpmn/svg.js

@@ -155,7 +155,18 @@ export function exportSvg(defs, options) {
             }
         }
         else {
-            inner = renderTask(el, width, height, t);
+            // An expanded sub-process/transaction draws an opaque body rect that must
+            // render before (under) its own internal edges and child shapes, the same
+            // reason pools/lanes are treated as containers above — otherwise the body
+            // paints over everything nested inside it.
+            const isExpandedContainer = (type === "subProcess" ||
+                type === "adHocSubProcess" ||
+                type === "eventSubProcess" ||
+                type === "transaction") &&
+                shape.isExpanded === true;
+            inner = renderTask(el, width, height, t, { expanded: isExpandedContainer });
+            if (isExpandedContainer)
+                isContainer = true;
         }
         if (inner) {
             const g = `<g transform="translate(${x} ${y})">${inner}</g>`;
@@ -442,7 +453,7 @@ function renderEvent(el, width, height, t) {
     }
     return out;
 }
-function renderTask(el, width, height, t) {
+function renderTask(el, width, height, t, options) {
     const type = el?.type ?? "";
     let sw = 1.5;
     let dash;
@@ -461,7 +472,15 @@ function renderTask(el, width, height, t) {
         out += iconGroup(icon, 4, 4, t);
     }
     if (el?.name) {
-        out += labelSvg(el.name, width / 2, height / 2, width - 16, t);
+        // An expanded container's name sits in a top label, like a modeler's pool/
+        // subprocess header, so it doesn't collide with the child shapes drawn
+        // inside it (a centered label would land right where children are placed).
+        if (options?.expanded) {
+            out += labelSvg(el.name, width / 2, 14, width - 16, t, true);
+        }
+        else {
+            out += labelSvg(el.name, width / 2, height / 2, width - 16, t);
+        }
     }
     if (type === "subProcess" ||
         type === "adHocSubProcess" ||

package/dist/bpmn/type-guards.d.ts

@@ -1,4 +1,4 @@
-import type { BpmnAdHocSubProcess, BpmnBoundaryEvent, BpmnBusinessRuleTask, BpmnCallActivity, BpmnComplexGateway, BpmnEndEvent, BpmnEventBasedGateway, BpmnEventSubProcess, BpmnExclusiveGateway, BpmnFlowElement, BpmnInclusiveGateway, BpmnIntermediateCatchEvent, BpmnIntermediateThrowEvent, BpmnManualTask, BpmnParallelGateway, BpmnReceiveTask, BpmnScriptTask, BpmnSendTask, BpmnServiceTask, BpmnStartEvent, BpmnSubProcess, BpmnTask, BpmnTransaction, BpmnUserTask } from "./bpmn-model.js";
+import type { BpmnAdHocSubProcess, BpmnBoundaryEvent, BpmnBusinessRuleTask, BpmnCallActivity, BpmnComplexGateway, BpmnDataObject, BpmnDataObjectReference, BpmnDataStoreReference, BpmnEndEvent, BpmnEventBasedGateway, BpmnEventSubProcess, BpmnExclusiveGateway, BpmnFlowElement, BpmnInclusiveGateway, BpmnIntermediateCatchEvent, BpmnIntermediateThrowEvent, BpmnManualTask, BpmnParallelGateway, BpmnReceiveTask, BpmnScriptTask, BpmnSendTask, BpmnServiceTask, BpmnStartEvent, BpmnSubProcess, BpmnTask, BpmnTransaction, BpmnUserTask } from "./bpmn-model.js";
 /**
  * Narrows a flow element to {@link BpmnStartEvent}.
  *
@@ -133,4 +133,10 @@ export declare function isBpmnComplexGateway(el: BpmnFlowElement): el is BpmnCom
  * ```
  */
 export declare function isBpmnGateway(el: BpmnFlowElement): el is BpmnExclusiveGateway | BpmnParallelGateway | BpmnInclusiveGateway | BpmnEventBasedGateway | BpmnComplexGateway;
+/** Narrows a flow element to {@link BpmnDataObject}. */
+export declare function isBpmnDataObject(el: BpmnFlowElement): el is BpmnDataObject;
+/** Narrows a flow element to {@link BpmnDataObjectReference}. */
+export declare function isBpmnDataObjectReference(el: BpmnFlowElement): el is BpmnDataObjectReference;
+/** Narrows a flow element to {@link BpmnDataStoreReference}. */
+export declare function isBpmnDataStoreReference(el: BpmnFlowElement): el is BpmnDataStoreReference;
 //# sourceMappingURL=type-guards.d.ts.map

package/dist/bpmn/type-guards.js

@@ -208,4 +208,17 @@ export function isBpmnGateway(el) {
         el.type === "eventBasedGateway" ||
         el.type === "complexGateway");
 }
+// ── Data ──────────────────────────────────────────────────────────────────────
+/** Narrows a flow element to {@link BpmnDataObject}. */
+export function isBpmnDataObject(el) {
+    return el.type === "dataObject";
+}
+/** Narrows a flow element to {@link BpmnDataObjectReference}. */
+export function isBpmnDataObjectReference(el) {
+    return el.type === "dataObjectReference";
+}
+/** Narrows a flow element to {@link BpmnDataStoreReference}. */
+export function isBpmnDataStoreReference(el) {
+    return el.type === "dataStoreReference";
+}
 //# sourceMappingURL=type-guards.js.map

package/dist/bpmn/zeebe-extensions.d.ts

@@ -53,6 +53,25 @@ export interface ZeebeCalledDecision {
     /** Process variable that receives the decision result. */
     resultVariable: string;
 }
+/** Zeebe user task assignment (assignee / candidate groups / candidate users). */
+export interface ZeebeAssignmentDefinition {
+    assignee?: string;
+    candidateGroups?: string;
+    candidateUsers?: string;
+}
+/** Zeebe user task scheduling (due date / follow-up date). */
+export interface ZeebeTaskSchedule {
+    dueDate?: string;
+    followUpDate?: string;
+}
+/** Zeebe user task priority (0-100, default 50). */
+export interface ZeebePriorityDefinition {
+    priority: string;
+}
+/** Zeebe message correlation key for a message catch/boundary/receive element. */
+export interface ZeebeSubscription {
+    correlationKey: string;
+}
 /** Collected Zeebe extensions on a service task. */
 export interface ZeebeExtensions {
     taskDefinition?: ZeebeTaskDefinition;
@@ -66,6 +85,14 @@ export interface ZeebeExtensions {
     calledDecision?: ZeebeCalledDecision;
     /** Marks this as a Camunda 8 native user task (zeebe:userTask). */
     userTask?: true;
+    /** User task assignee/candidates (zeebe:assignmentDefinition). */
+    assignmentDefinition?: ZeebeAssignmentDefinition;
+    /** User task due/follow-up dates (zeebe:taskSchedule). */
+    taskSchedule?: ZeebeTaskSchedule;
+    /** User task priority (zeebe:priorityDefinition). */
+    priorityDefinition?: ZeebePriorityDefinition;
+    /** Message correlation key for a message catch/boundary/receive element (zeebe:subscription). */
+    subscription?: ZeebeSubscription;
     /** Unrecognized extension elements preserved for roundtrip. */
     unknownElements?: XmlElement[];
 }

package/dist/bpmn/zeebe-extensions.js

@@ -91,6 +91,44 @@ export function zeebeExtensionsToXmlElements(extensions) {
             children: [],
         });
     }
+    if (extensions.assignmentDefinition) {
+        const attrs = {};
+        const { assignee, candidateGroups, candidateUsers } = extensions.assignmentDefinition;
+        if (assignee)
+            attrs.assignee = assignee;
+        if (candidateGroups)
+            attrs.candidateGroups = candidateGroups;
+        if (candidateUsers)
+            attrs.candidateUsers = candidateUsers;
+        if (Object.keys(attrs).length > 0) {
+            elements.push({ name: "zeebe:assignmentDefinition", attributes: attrs, children: [] });
+        }
+    }
+    if (extensions.taskSchedule) {
+        const attrs = {};
+        if (extensions.taskSchedule.dueDate)
+            attrs.dueDate = extensions.taskSchedule.dueDate;
+        if (extensions.taskSchedule.followUpDate) {
+            attrs.followUpDate = extensions.taskSchedule.followUpDate;
+        }
+        if (Object.keys(attrs).length > 0) {
+            elements.push({ name: "zeebe:taskSchedule", attributes: attrs, children: [] });
+        }
+    }
+    if (extensions.priorityDefinition) {
+        elements.push({
+            name: "zeebe:priorityDefinition",
+            attributes: { priority: extensions.priorityDefinition.priority },
+            children: [],
+        });
+    }
+    if (extensions.subscription) {
+        elements.push({
+            name: "zeebe:subscription",
+            attributes: { correlationKey: extensions.subscription.correlationKey },
+            children: [],
+        });
+    }
     if (extensions.unknownElements) {
         elements.push(...extensions.unknownElements);
     }

package/dist/index.d.ts

@@ -1,17 +1,20 @@
 export { BpmnSdkError, ParseError, ValidationError } from "./errors.js";
 export type { ErrorCode } from "./errors.js";
-export { isBpmnActivity, isBpmnAdHocSubProcess, isBpmnBoundaryEvent, isBpmnBusinessRuleTask, isBpmnCallActivity, isBpmnComplexGateway, isBpmnEndEvent, isBpmnEvent, isBpmnEventBasedGateway, isBpmnEventSubProcess, isBpmnExclusiveGateway, isBpmnGateway, isBpmnInclusiveGateway, isBpmnIntermediateCatchEvent, isBpmnIntermediateThrowEvent, isBpmnManualTask, isBpmnParallelGateway, isBpmnReceiveTask, isBpmnScriptTask, isBpmnSendTask, isBpmnServiceTask, isBpmnStartEvent, isBpmnSubProcess, isBpmnTask, isBpmnTransaction, isBpmnUserTask, } from "./bpmn/type-guards.js";
+export { isBpmnActivity, isBpmnAdHocSubProcess, isBpmnBoundaryEvent, isBpmnBusinessRuleTask, isBpmnCallActivity, isBpmnComplexGateway, isBpmnDataObject, isBpmnDataObjectReference, isBpmnDataStoreReference, isBpmnEndEvent, isBpmnEvent, isBpmnEventBasedGateway, isBpmnEventSubProcess, isBpmnExclusiveGateway, isBpmnGateway, isBpmnInclusiveGateway, isBpmnIntermediateCatchEvent, isBpmnIntermediateThrowEvent, isBpmnManualTask, isBpmnParallelGateway, isBpmnReceiveTask, isBpmnScriptTask, isBpmnSendTask, isBpmnServiceTask, isBpmnStartEvent, isBpmnSubProcess, isBpmnTask, isBpmnTransaction, isBpmnUserTask, } from "./bpmn/type-guards.js";
 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 { planeForElement, listPlaneElementIds } from "./bpmn/di-planes.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 { 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, BpmnGroup, BpmnDataObject, BpmnDataObjectReference, BpmnDataStoreReference, 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 type { ZeebeExtensions, ZeebeTaskDefinition, ZeebeIoMapping, ZeebeIoMappingEntry, ZeebeTaskHeaders, ZeebeTaskHeaderEntry, ZeebeProperties, ZeebePropertyEntry, ZeebeFormDefinition, ZeebeCalledDecision, ZeebeAssignmentDefinition, ZeebeTaskSchedule, ZeebePriorityDefinition, ZeebeSubscription, } from "./bpmn/zeebe-extensions.js";
 export { zeebeExtensionsToXmlElements } from "./bpmn/zeebe-extensions.js";
+export { buildAiAgentSubProcess, AI_AGENT_JOB_WORKER_TASK_TYPE, AI_AGENT_DEFAULT_OUTPUT_ELEMENT, } from "./bpmn/agentic.js";
+export type { AiAgentOptions, AiAgentModelConfig, AiAgentToolSpec, AiAgentToolParam, AiAgentToolParamType, AiAgentBuild, } from "./bpmn/agentic.js";
 export { Dmn, layoutDmn, benchmarkDmnLayout, compactifyDmn, expandDmn } from "./dmn/index.js";
 export type { DmnBenchmarkResult, DmnElementPosition, CompactDmn, CompactDmnDecision, CompactDmnInput, CompactDmnOutput, CompactDmnRule, } from "./dmn/index.js";
 export { Form, compactifyForm, expandForm } from "./form/index.js";
@@ -32,6 +35,7 @@ export type { StoryRenderOptions } from "./bpmn/story.js";
 export { analyzeVariableFlow, extractFeelIdentifiers } from "./bpmn/optimize/variable-flow.js";
 export type { OptimizationReport, OptimizationFinding, OptimizationSeverity, OptimizationCategory, ApplyFixResult, OptimizeOptions, } from "./bpmn/optimize/types.js";
 export { layoutProcess, layoutFlowNodes } from "./layout/index.js";
+export type { LayoutEngine } 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";
@@ -44,4 +48,6 @@ export type { InputVariableDef, ValidationStructure, ValidationVariableType, } f
 export { exportSvg } from "./bpmn/svg.js";
 export type { SvgExportOptions } from "./bpmn/svg.js";
 export type { CompactDiagram, CompactElement, CompactFlow, CompactProcess, } from "./bpmn/compact.js";
+export { compilePlan, extractPlan, mergePlan, slugify, uniqueId, } from "./plan/index.js";
+export type { CompilePlanOptions, ConnectorApplyResult, ConnectorResolver, ExtractResult, PlanAgentTool, PlanAiAgentStep, PlanBranch, PlanBusinessRuleTaskStep, PlanCallActivityStep, PlanConnectorRef, PlanConnectorStep, PlanEndStep, PlanErrorBoundary, PlanGatewayStep, PlanInputVariable, PlanProblem, PlanRawStep, PlanReceiveTaskStep, PlanScenario, PlanScriptTaskStep, PlanSendTaskStep, PlanServiceTaskStep, PlanStartStep, PlanStep, PlanSubProcessStep, PlanTimerBoundary, PlanUserTaskStep, PlanWaitStep, ProcessPlan, SynthResult, UnsupportedElement, } from "./plan/index.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -1,11 +1,13 @@
 export { BpmnSdkError, ParseError, ValidationError } from "./errors.js";
-export { isBpmnActivity, isBpmnAdHocSubProcess, isBpmnBoundaryEvent, isBpmnBusinessRuleTask, isBpmnCallActivity, isBpmnComplexGateway, isBpmnEndEvent, isBpmnEvent, isBpmnEventBasedGateway, isBpmnEventSubProcess, isBpmnExclusiveGateway, isBpmnGateway, isBpmnInclusiveGateway, isBpmnIntermediateCatchEvent, isBpmnIntermediateThrowEvent, isBpmnManualTask, isBpmnParallelGateway, isBpmnReceiveTask, isBpmnScriptTask, isBpmnSendTask, isBpmnServiceTask, isBpmnStartEvent, isBpmnSubProcess, isBpmnTask, isBpmnTransaction, isBpmnUserTask, } from "./bpmn/type-guards.js";
+export { isBpmnActivity, isBpmnAdHocSubProcess, isBpmnBoundaryEvent, isBpmnBusinessRuleTask, isBpmnCallActivity, isBpmnComplexGateway, isBpmnDataObject, isBpmnDataObjectReference, isBpmnDataStoreReference, isBpmnEndEvent, isBpmnEvent, isBpmnEventBasedGateway, isBpmnEventSubProcess, isBpmnExclusiveGateway, isBpmnGateway, isBpmnInclusiveGateway, isBpmnIntermediateCatchEvent, isBpmnIntermediateThrowEvent, isBpmnManualTask, isBpmnParallelGateway, isBpmnReceiveTask, isBpmnScriptTask, isBpmnSendTask, isBpmnServiceTask, isBpmnStartEvent, isBpmnSubProcess, isBpmnTask, isBpmnTransaction, isBpmnUserTask, } from "./bpmn/type-guards.js";
 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 { planeForElement, listPlaneElementIds } from "./bpmn/di-planes.js";
 export { DiagramBuilder } from "./bpmn/bpmn-builder.js";
 export { zeebeExtensionsToXmlElements } from "./bpmn/zeebe-extensions.js";
+export { buildAiAgentSubProcess, AI_AGENT_JOB_WORKER_TASK_TYPE, AI_AGENT_DEFAULT_OUTPUT_ELEMENT, } from "./bpmn/agentic.js";
 export { Dmn, layoutDmn, benchmarkDmnLayout, compactifyDmn, expandDmn } from "./dmn/index.js";
 export { Form, compactifyForm, expandForm } from "./form/index.js";
 export { FormBuilder, GroupBuilder } from "./form/form-builder.js";
@@ -22,4 +24,5 @@ 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";
 export { exportSvg } from "./bpmn/svg.js";
+export { compilePlan, extractPlan, mergePlan, slugify, uniqueId, } from "./plan/index.js";
 //# sourceMappingURL=index.js.map

package/dist/layout/annotations.js

@@ -8,6 +8,8 @@ const ELEMENT_GAP = 30; // min gap between annotation and a non-annotation shape
 const PREFERRED_OFFSET = 50; // preferred gap to associated element
 const MIN_HEIGHT = 30;
 const HORIZONTAL_SHIFTS = [0, 60, -60, 120, -120, 180, -180, 240, -240];
+/** Cost added to a candidate whose association line would cross a shape. */
+const BLOCKED_LINE_COST = 10_000;
 function computeHeight(text, width) {
     if (!text || !text.trim())
         return MIN_HEIGHT;
@@ -189,7 +191,17 @@ export function packAnnotations(process, layoutNodes) {
                         }
                     }
                 }
-                const cost = Math.hypot(candidateX - naturalX, y - naturalY);
+                // A clear box is not enough: the association line drawn back to the
+                // element must not cut through anything either.
+                const candidate = {
+                    x: candidateX,
+                    y,
+                    width: item.bounds.width,
+                    height: item.bounds.height,
+                };
+                const { pElem, pAnn } = associationWaypoints(linked.bounds, candidate);
+                const crosses = obstacles.some((sh) => sh !== linked.bounds && segmentHitsBox(pElem, pAnn, sh));
+                const cost = Math.hypot(candidateX - naturalX, y - naturalY) + (crosses ? BLOCKED_LINE_COST : 0);
                 if (cost < best.cost)
                     best = { x: candidateX, y, cost };
             }
@@ -218,6 +230,29 @@ export function packAnnotations(process, layoutNodes) {
     }
     return result;
 }
+/** Whether a straight segment passes through a box. */
+function segmentHitsBox(a, b, box) {
+    const minX = Math.min(a.x, b.x);
+    const maxX = Math.max(a.x, b.x);
+    const minY = Math.min(a.y, b.y);
+    const maxY = Math.max(a.y, b.y);
+    if (maxX <= box.x || box.x + box.width <= minX)
+        return false;
+    if (maxY <= box.y || box.y + box.height <= minY)
+        return false;
+    if (a.x === b.x || a.y === b.y)
+        return true;
+    // Diagonal: the box is hit unless all four corners fall on one side of it.
+    const side = (p) => Math.sign((b.x - a.x) * (p.y - a.y) - (b.y - a.y) * (p.x - a.x));
+    const corners = [
+        { x: box.x, y: box.y },
+        { x: box.x + box.width, y: box.y },
+        { x: box.x + box.width, y: box.y + box.height },
+        { x: box.x, y: box.y + box.height },
+    ];
+    const first = side(corners[0] ?? { x: 0, y: 0 });
+    return corners.some((corner) => side(corner) !== first);
+}
 /**
  * Edge-to-edge, clamped association waypoints between a linked element and
  * its annotation. Port of `chooseWaypoints` (tmp/01-annotation-layouting.cjs:365-389).

package/dist/layout/collaboration/alignment.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Horizontal alignment between the pools of a collaboration.
+ *
+ * Each process is laid out on its own, so two elements that exchange a message
+ * usually end up at unrelated x positions and the message has to travel sideways
+ * to reach its partner. Sliding a whole process sideways costs nothing — the
+ * pool grows with it — and a message that leaves straight down crosses far less
+ * than one that wanders across two pools first.
+ */
+/** One message flow, as the two element centres it connects. */
+export interface MessageLink {
+    fromPool: number;
+    toPool: number;
+    /** x centre of the source element within its pool's content. */
+    fromX: number;
+    /** x centre of the target element within its pool's content. */
+    toX: number;
+}
+/**
+ * Choose a horizontal offset per pool. The widest pool anchors the diagram and
+ * the rest slide to meet it, largest first, so the biggest process never moves
+ * to chase a small one. Offsets are normalised to keep every pool at or right of
+ * the origin.
+ */
+export declare function alignPools(count: number, widths: readonly number[], links: readonly MessageLink[]): number[];
+//# sourceMappingURL=alignment.d.ts.map

package/dist/layout/collaboration/alignment.js

@@ -0,0 +1,66 @@
+/**
+ * Horizontal alignment between the pools of a collaboration.
+ *
+ * Each process is laid out on its own, so two elements that exchange a message
+ * usually end up at unrelated x positions and the message has to travel sideways
+ * to reach its partner. Sliding a whole process sideways costs nothing — the
+ * pool grows with it — and a message that leaves straight down crosses far less
+ * than one that wanders across two pools first.
+ */
+/**
+ * Choose a horizontal offset per pool. The widest pool anchors the diagram and
+ * the rest slide to meet it, largest first, so the biggest process never moves
+ * to chase a small one. Offsets are normalised to keep every pool at or right of
+ * the origin.
+ */
+export function alignPools(count, widths, links) {
+    const offsets = new Array(count).fill(0);
+    if (count < 2 || links.length === 0)
+        return offsets;
+    const order = Array.from({ length: count }, (_, i) => i).sort((a, b) => (widths[b] ?? 0) - (widths[a] ?? 0) || a - b);
+    const placed = new Set();
+    const anchor = order[0];
+    if (anchor === undefined)
+        return offsets;
+    placed.add(anchor);
+    for (let i = 1; i < order.length; i++) {
+        const pool = order[i];
+        if (pool === undefined)
+            continue;
+        const connected = links.filter((link) => (link.fromPool === pool && placed.has(link.toPool)) ||
+            (link.toPool === pool && placed.has(link.fromPool)));
+        if (connected.length === 0) {
+            placed.add(pool);
+            continue;
+        }
+        // Every connected message suggests the shift that would make it vertical;
+        // staying put is always in the running.
+        const candidates = new Set([0]);
+        for (const link of connected) {
+            const mine = link.fromPool === pool ? link.fromX : link.toX;
+            const theirs = link.fromPool === pool ? link.toX : link.fromX;
+            const otherPool = link.fromPool === pool ? link.toPool : link.fromPool;
+            candidates.add(theirs + (offsets[otherPool] ?? 0) - mine);
+        }
+        let best = 0;
+        let bestCost = Number.POSITIVE_INFINITY;
+        for (const candidate of [...candidates].sort((a, b) => Math.abs(a) - Math.abs(b) || a - b)) {
+            let cost = 0;
+            for (const link of connected) {
+                const mine = link.fromPool === pool ? link.fromX : link.toX;
+                const theirs = link.fromPool === pool ? link.toX : link.fromX;
+                const otherPool = link.fromPool === pool ? link.toPool : link.fromPool;
+                cost += Math.abs(mine + candidate - (theirs + (offsets[otherPool] ?? 0)));
+            }
+            if (cost < bestCost) {
+                bestCost = cost;
+                best = candidate;
+            }
+        }
+        offsets[pool] = Math.round(best);
+        placed.add(pool);
+    }
+    const min = Math.min(...offsets);
+    return min === 0 ? offsets : offsets.map((offset) => offset - min);
+}
+//# sourceMappingURL=alignment.js.map