@bpmnkit/core 0.1.0 → 0.1.2

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

@@ -5,7 +5,7 @@ import type { XmlElement } from "../types/xml-element.js";
  * exhaustive `switch` statements and type-narrowing with the type guard helpers
  * exported from `@bpmnkit/core`.
  */
-export type BpmnElementType = "startEvent" | "endEvent" | "intermediateThrowEvent" | "intermediateCatchEvent" | "boundaryEvent" | "task" | "serviceTask" | "scriptTask" | "userTask" | "sendTask" | "receiveTask" | "businessRuleTask" | "manualTask" | "callActivity" | "exclusiveGateway" | "parallelGateway" | "inclusiveGateway" | "eventBasedGateway" | "complexGateway" | "subProcess" | "adHocSubProcess" | "eventSubProcess" | "transaction";
+export type BpmnElementType = "startEvent" | "endEvent" | "intermediateThrowEvent" | "intermediateCatchEvent" | "boundaryEvent" | "task" | "serviceTask" | "scriptTask" | "userTask" | "sendTask" | "receiveTask" | "businessRuleTask" | "manualTask" | "callActivity" | "exclusiveGateway" | "parallelGateway" | "inclusiveGateway" | "eventBasedGateway" | "complexGateway" | "subProcess" | "adHocSubProcess" | "eventSubProcess" | "transaction" | "dataObject" | "dataObjectReference" | "dataStoreReference";
 /** Axis-aligned bounding box used by BPMN diagram interchange (BPMNDi). */
 export interface BpmnBounds {
     x: number;
@@ -150,6 +150,26 @@ export interface BpmnCallActivity extends BpmnFlowNodeBase {
     type: "callActivity";
     loopCharacteristics?: BpmnMultiInstanceLoopCharacteristics;
 }
+/** A data object — a piece of information flowing through the process. */
+export interface BpmnDataObject extends BpmnFlowNodeBase {
+    type: "dataObject";
+    /** When true, represents a collection of items. */
+    isCollection?: boolean;
+}
+/** A visual reference to a {@link BpmnDataObject} (the shape drawn on the canvas). */
+export interface BpmnDataObjectReference extends BpmnFlowNodeBase {
+    type: "dataObjectReference";
+    /** Id of the referenced `dataObject`. */
+    dataObjectRef?: string;
+    /** When true, drawn with the collection (parallel-bars) marker. */
+    isCollection?: boolean;
+}
+/** A visual reference to a data store (drawn as a cylinder). */
+export interface BpmnDataStoreReference extends BpmnFlowNodeBase {
+    type: "dataStoreReference";
+    /** Id of the referenced `dataStore`. */
+    dataStoreRef?: string;
+}
 export interface BpmnSendTask extends BpmnFlowNodeBase {
     type: "sendTask";
     messageRef?: string;
@@ -163,10 +183,15 @@ export interface BpmnReceiveTask extends BpmnFlowNodeBase {
 export interface BpmnAdHocSubProcess extends BpmnFlowNodeBase {
     type: "adHocSubProcess";
     loopCharacteristics?: BpmnMultiInstanceLoopCharacteristics;
+    /** FEEL expression evaluated after each tool activity completes; ends the ad-hoc scope when true. */
+    completionCondition?: BpmnConditionExpression;
+    /** Whether still-running inner activity instances are cancelled once the completion condition is met (default true). */
+    cancelRemainingInstances?: boolean;
     flowElements: BpmnFlowElement[];
     sequenceFlows: BpmnSequenceFlow[];
     textAnnotations: BpmnTextAnnotation[];
     associations: BpmnAssociation[];
+    groups: BpmnGroup[];
 }
 export interface BpmnSubProcess extends BpmnFlowNodeBase {
     type: "subProcess";
@@ -176,6 +201,7 @@ export interface BpmnSubProcess extends BpmnFlowNodeBase {
     sequenceFlows: BpmnSequenceFlow[];
     textAnnotations: BpmnTextAnnotation[];
     associations: BpmnAssociation[];
+    groups: BpmnGroup[];
 }
 export interface BpmnEventSubProcess extends BpmnFlowNodeBase {
     type: "eventSubProcess";
@@ -183,6 +209,7 @@ export interface BpmnEventSubProcess extends BpmnFlowNodeBase {
     sequenceFlows: BpmnSequenceFlow[];
     textAnnotations: BpmnTextAnnotation[];
     associations: BpmnAssociation[];
+    groups: BpmnGroup[];
 }
 export interface BpmnExclusiveGateway extends BpmnFlowNodeBase {
     type: "exclusiveGateway";
@@ -217,6 +244,7 @@ export interface BpmnTransaction extends BpmnFlowNodeBase {
     sequenceFlows: BpmnSequenceFlow[];
     textAnnotations: BpmnTextAnnotation[];
     associations: BpmnAssociation[];
+    groups: BpmnGroup[];
 }
 /**
  * Discriminated union of every BPMN flow node that can appear inside a
@@ -233,7 +261,7 @@ export interface BpmnTransaction extends BpmnFlowNodeBase {
  * }
  * ```
  */
-export type BpmnFlowElement = BpmnStartEvent | BpmnEndEvent | BpmnIntermediateCatchEvent | BpmnIntermediateThrowEvent | BpmnBoundaryEvent | BpmnTask | BpmnServiceTask | BpmnScriptTask | BpmnUserTask | BpmnSendTask | BpmnReceiveTask | BpmnBusinessRuleTask | BpmnManualTask | BpmnCallActivity | BpmnSubProcess | BpmnAdHocSubProcess | BpmnEventSubProcess | BpmnTransaction | BpmnExclusiveGateway | BpmnParallelGateway | BpmnInclusiveGateway | BpmnEventBasedGateway | BpmnComplexGateway;
+export type BpmnFlowElement = BpmnStartEvent | BpmnEndEvent | BpmnIntermediateCatchEvent | BpmnIntermediateThrowEvent | BpmnBoundaryEvent | BpmnTask | BpmnServiceTask | BpmnScriptTask | BpmnUserTask | BpmnSendTask | BpmnReceiveTask | BpmnBusinessRuleTask | BpmnManualTask | BpmnCallActivity | BpmnSubProcess | BpmnAdHocSubProcess | BpmnEventSubProcess | BpmnTransaction | BpmnExclusiveGateway | BpmnParallelGateway | BpmnInclusiveGateway | BpmnEventBasedGateway | BpmnComplexGateway | BpmnDataObject | BpmnDataObjectReference | BpmnDataStoreReference;
 /** Backward-compat alias used by the layout module. */
 export type BpmnFlowNode = BpmnFlowElement;
 /**
@@ -264,6 +292,13 @@ export interface BpmnAssociation {
     associationDirection?: string;
     unknownAttributes: Record<string, string>;
 }
+/** A group artifact — a dashed rounded rectangle visually grouping elements. */
+export interface BpmnGroup {
+    id: string;
+    /** Id of the `categoryValue` supplying the group's label, if any. */
+    categoryValueRef?: string;
+    unknownAttributes: Record<string, string>;
+}
 /** A swim lane within a pool (organises flow nodes visually). */
 export interface BpmnLane {
     id: string;
@@ -294,6 +329,7 @@ export interface BpmnProcess {
     sequenceFlows: BpmnSequenceFlow[];
     textAnnotations: BpmnTextAnnotation[];
     associations: BpmnAssociation[];
+    groups: BpmnGroup[];
     laneSet?: BpmnLaneSet;
     unknownAttributes: Record<string, string>;
 }
@@ -319,6 +355,7 @@ export interface BpmnCollaboration {
     messageFlows: BpmnMessageFlow[];
     textAnnotations: BpmnTextAnnotation[];
     associations: BpmnAssociation[];
+    groups: BpmnGroup[];
     extensionElements: XmlElement[];
     unknownAttributes: Record<string, string>;
 }

package/dist/bpmn/bpmn-parser.js

@@ -59,6 +59,10 @@ const KNOWN_ATTRS = new Set([
     "exporter",
     "exporterVersion",
     "processRef",
+    "dataObjectRef",
+    "dataStoreRef",
+    "isCollection",
+    "categoryValueRef",
 ]);
 /** Extract unknown (namespace-qualified) attributes from an element. */
 function unknownAttrs(element) {
@@ -261,6 +265,9 @@ const FLOW_ELEMENT_TYPES = new Set([
     "inclusiveGateway",
     "eventBasedGateway",
     "complexGateway",
+    "dataObject",
+    "dataObjectReference",
+    "dataStoreReference",
 ]);
 function parseFlowElement(element) {
     const ln = localName(element.name);
@@ -321,13 +328,21 @@ function parseFlowElement(element) {
                 loopCharacteristics: parseLoopCharacteristics(element),
                 isForCompensation: attr(element, "isForCompensation") === "true" ? true : undefined,
             };
-        case "adHocSubProcess":
+        case "adHocSubProcess": {
+            const completionEl = findChild(element, "completionCondition");
             return {
                 ...base,
                 type: "adHocSubProcess",
                 loopCharacteristics: parseLoopCharacteristics(element),
+                completionCondition: completionEl
+                    ? { text: completionEl.text ?? "", attributes: { ...completionEl.attributes } }
+                    : undefined,
+                cancelRemainingInstances: attr(element, "cancelRemainingInstances") !== undefined
+                    ? attr(element, "cancelRemainingInstances") === "true"
+                    : undefined,
                 ...parseProcessContents(element),
             };
+        }
         case "subProcess":
             return {
                 ...base,
@@ -361,6 +376,25 @@ function parseFlowElement(element) {
             return { ...base, type: "eventBasedGateway" };
         case "complexGateway":
             return { ...base, type: "complexGateway", default: attr(element, "default") };
+        case "dataObject":
+            return {
+                ...base,
+                type: "dataObject",
+                ...(attr(element, "isCollection") === "true" ? { isCollection: true } : {}),
+            };
+        case "dataObjectReference":
+            return {
+                ...base,
+                type: "dataObjectReference",
+                dataObjectRef: attr(element, "dataObjectRef"),
+                ...(attr(element, "isCollection") === "true" ? { isCollection: true } : {}),
+            };
+        case "dataStoreReference":
+            return {
+                ...base,
+                type: "dataStoreReference",
+                dataStoreRef: attr(element, "dataStoreRef"),
+            };
         default:
             return undefined;
     }
@@ -407,6 +441,13 @@ function parseAssociation(element) {
         unknownAttributes: unknownAttrs(element),
     };
 }
+function parseGroup(element) {
+    return {
+        id: requiredAttr(element, "id"),
+        categoryValueRef: attr(element, "categoryValueRef"),
+        unknownAttributes: unknownAttrs(element),
+    };
+}
 // ---------------------------------------------------------------------------
 // Process contents (shared between process and adHocSubProcess)
 // ---------------------------------------------------------------------------
@@ -415,6 +456,7 @@ function parseProcessContents(element) {
     const sequenceFlows = [];
     const textAnnotations = [];
     const associations = [];
+    const groups = [];
     for (const child of element.children) {
         const ln = localName(child.name);
         if (FLOW_ELEMENT_TYPES.has(ln)) {
@@ -431,8 +473,11 @@ function parseProcessContents(element) {
         else if (ln === "association") {
             associations.push(parseAssociation(child));
         }
+        else if (ln === "group") {
+            groups.push(parseGroup(child));
+        }
     }
-    return { flowElements, sequenceFlows, textAnnotations, associations };
+    return { flowElements, sequenceFlows, textAnnotations, associations, groups };
 }
 // ---------------------------------------------------------------------------
 // Lanes
@@ -498,6 +543,7 @@ function parseCollaboration(element) {
         messageFlows: findChildren(element, "messageFlow").map(parseMessageFlow),
         textAnnotations: findChildren(element, "textAnnotation").map(parseTextAnnotation),
         associations: findChildren(element, "association").map(parseAssociation),
+        groups: findChildren(element, "group").map(parseGroup),
         extensionElements: parseExtensionElements(element),
         unknownAttributes: unknownAttrs(element),
     };

package/dist/bpmn/bpmn-serializer.js

@@ -202,8 +202,14 @@ function serializeFlowElement(fe, ns) {
             children.push(...serializeLoopCharacteristics(fe.loopCharacteristics, bp));
             break;
         case "adHocSubProcess":
+            if (fe.cancelRemainingInstances !== undefined) {
+                attrs.cancelRemainingInstances = String(fe.cancelRemainingInstances);
+            }
             children.push(...serializeLoopCharacteristics(fe.loopCharacteristics, bp));
             children.push(...serializeProcessContents(fe, ns));
+            if (fe.completionCondition) {
+                children.push(el(`${bp}:completionCondition`, fe.completionCondition.attributes, [], fe.completionCondition.text));
+            }
             break;
         case "subProcess":
             if (fe.triggeredByEvent !== undefined)
@@ -233,6 +239,20 @@ function serializeFlowElement(fe, ns) {
         case "parallelGateway":
         case "eventBasedGateway":
             break;
+        case "dataObject":
+            if (fe.isCollection)
+                attrs.isCollection = "true";
+            break;
+        case "dataObjectReference":
+            if (fe.dataObjectRef !== undefined)
+                attrs.dataObjectRef = fe.dataObjectRef;
+            if (fe.isCollection)
+                attrs.isCollection = "true";
+            break;
+        case "dataStoreReference":
+            if (fe.dataStoreRef !== undefined)
+                attrs.dataStoreRef = fe.dataStoreRef;
+            break;
     }
     return el(`${bp}:${fe.type}`, attrs, children);
 }
@@ -276,6 +296,12 @@ function serializeAssociation(a, bp) {
         attrs.associationDirection = a.associationDirection;
     return el(`${bp}:association`, attrs, []);
 }
+function serializeGroup(g, bp) {
+    const attrs = { id: g.id, ...g.unknownAttributes };
+    if (g.categoryValueRef !== undefined)
+        attrs.categoryValueRef = g.categoryValueRef;
+    return el(`${bp}:group`, attrs, []);
+}
 // ---------------------------------------------------------------------------
 // Process contents
 // ---------------------------------------------------------------------------
@@ -294,6 +320,10 @@ function serializeProcessContents(p, ns) {
     for (const a of p.associations) {
         children.push(serializeAssociation(a, bp));
     }
+    // `groups` may be absent on hand-constructed partial models.
+    for (const g of p.groups ?? []) {
+        children.push(serializeGroup(g, bp));
+    }
     return children;
 }
 // ---------------------------------------------------------------------------
@@ -370,6 +400,9 @@ function serializeCollaboration(c, ns) {
     for (const a of c.associations) {
         children.push(serializeAssociation(a, bp));
     }
+    for (const g of c.groups ?? []) {
+        children.push(serializeGroup(g, bp));
+    }
     return el(`${bp}:collaboration`, { id: c.id, ...c.unknownAttributes }, children);
 }
 // ---------------------------------------------------------------------------

package/dist/bpmn/compact.js

@@ -192,7 +192,13 @@ function makeExtensions(el) {
 }
 function buildSubContent(children) {
     if (!children || children.elements.length === 0) {
-        return { flowElements: [], sequenceFlows: [], textAnnotations: [], associations: [] };
+        return {
+            flowElements: [],
+            sequenceFlows: [],
+            textAnnotations: [],
+            associations: [],
+            groups: [],
+        };
     }
     const inc = new Map();
     const out = new Map();
@@ -217,6 +223,7 @@ function buildSubContent(children) {
         })),
         textAnnotations: [],
         associations: [],
+        groups: [],
     };
 }
 function buildFlowElement(el, incoming, outgoing) {
@@ -284,6 +291,8 @@ function buildFlowElement(el, incoming, outgoing) {
             return { ...base, type: "eventBasedGateway" };
         case "complexGateway":
             return { ...base, type: "complexGateway" };
+        default:
+            return { ...base, type: "task" };
     }
 }
 function buildDiagram(processId, process) {
@@ -342,6 +351,7 @@ function expandProcess(compact) {
         sequenceFlows,
         textAnnotations: [],
         associations: [],
+        groups: [],
         unknownAttributes: {},
     };
     return { process, diagram: buildDiagram(compact.id, process) };

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

@@ -0,0 +1,13 @@
+import type { BpmnDefinitions, BpmnDiPlane } from "./bpmn-model.js";
+/**
+ * Returns the DI plane whose `bpmnElement` matches `elementId`, if any.
+ *
+ * The primary plane's `bpmnElement` is a process or collaboration id; a
+ * collapsed sub-process that carries its own layout has a separate
+ * `BPMNDiagram` whose plane `bpmnElement` is the sub-process id. This resolves
+ * either.
+ */
+export declare function planeForElement(defs: BpmnDefinitions, elementId: string): BpmnDiPlane | undefined;
+/** Lists every DI plane's `bpmnElement` id, in document order. */
+export declare function listPlaneElementIds(defs: BpmnDefinitions): string[];
+//# sourceMappingURL=di-planes.d.ts.map

package/dist/bpmn/di-planes.js

@@ -0,0 +1,20 @@
+/**
+ * Returns the DI plane whose `bpmnElement` matches `elementId`, if any.
+ *
+ * The primary plane's `bpmnElement` is a process or collaboration id; a
+ * collapsed sub-process that carries its own layout has a separate
+ * `BPMNDiagram` whose plane `bpmnElement` is the sub-process id. This resolves
+ * either.
+ */
+export function planeForElement(defs, elementId) {
+    for (const diagram of defs.diagrams) {
+        if (diagram.plane.bpmnElement === elementId)
+            return diagram.plane;
+    }
+    return undefined;
+}
+/** Lists every DI plane's `bpmnElement` id, in document order. */
+export function listPlaneElementIds(defs) {
+    return defs.diagrams.map((d) => d.plane.bpmnElement);
+}
+//# sourceMappingURL=di-planes.js.map

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

@@ -0,0 +1,10 @@
+import type { BpmnProcess } from "../bpmn-model.js";
+import type { OptimizationFinding } from "./types.js";
+/**
+ * Agentic-specific checks for the Camunda 8 AI Agent Sub-process pattern:
+ * tools must be root nodes with a description the LLM can read, every
+ * `fromAi()` call must reference `toolCall.*`, and the agent should aggregate
+ * tool results and cap its model-call budget.
+ */
+export declare function analyzeAgentic(p: BpmnProcess): OptimizationFinding[];
+//# sourceMappingURL=agentic.d.ts.map

package/dist/bpmn/optimize/agentic.js

@@ -0,0 +1,88 @@
+import { AI_AGENT_JOB_WORKER_TASK_TYPE } from "../agentic.js";
+import { readZeebeIoMapping, readZeebeTaskType } from "./utils.js";
+const FROM_AI_CALL = /fromAi\(\s*([^,)]+)/g;
+function isAiAgentSubProcess(el) {
+    return readZeebeTaskType(el.extensionElements) === AI_AGENT_JOB_WORKER_TASK_TYPE;
+}
+/**
+ * Agentic-specific checks for the Camunda 8 AI Agent Sub-process pattern:
+ * tools must be root nodes with a description the LLM can read, every
+ * `fromAi()` call must reference `toolCall.*`, and the agent should aggregate
+ * tool results and cap its model-call budget.
+ */
+export function analyzeAgentic(p) {
+    const findings = [];
+    const processId = p.id;
+    for (const el of p.flowElements) {
+        if (el.type !== "adHocSubProcess" || !isAiAgentSubProcess(el))
+            continue;
+        const adHocExt = el.extensionElements.find((e) => e.name === "zeebe:adHoc");
+        if (!adHocExt?.attributes.outputCollection) {
+            findings.push({
+                id: "agentic/no-output-collection",
+                category: "agentic",
+                severity: "warning",
+                message: `AI Agent "${el.name ?? el.id}" has no outputCollection — tool call results won't be aggregated.`,
+                suggestion: 'Set zeebe:adHoc outputCollection (e.g. "toolCallResults").',
+                processId,
+                elementIds: [el.id],
+            });
+        }
+        const io = readZeebeIoMapping(el.extensionElements);
+        const hasLimit = io?.inputs.some((i) => i.target === "data.limits.maxModelCalls") ?? false;
+        if (!hasLimit) {
+            findings.push({
+                id: "agentic/limits-missing",
+                category: "agentic",
+                severity: "info",
+                message: `AI Agent "${el.name ?? el.id}" has no data.limits.maxModelCalls binding.`,
+                suggestion: "Set a model-call limit as a safety net against infinite tool loops.",
+                processId,
+                elementIds: [el.id],
+            });
+        }
+        for (const tool of el.flowElements) {
+            if (tool.incoming.length > 0) {
+                findings.push({
+                    id: "agentic/tool-not-root",
+                    category: "agentic",
+                    severity: "error",
+                    message: `"${tool.name ?? tool.id}" inside AI Agent "${el.name ?? el.id}" has an incoming sequence flow — the connector only discovers tools with no incoming flow.`,
+                    suggestion: "Remove the incoming sequence flow; tools must be root nodes.",
+                    processId,
+                    elementIds: [tool.id],
+                });
+            }
+            if (!tool.documentation?.trim()) {
+                findings.push({
+                    id: "agentic/tool-no-description",
+                    category: "agentic",
+                    severity: "warning",
+                    message: `Tool "${tool.name ?? tool.id}" has no documentation — the LLM sees no description for this tool.`,
+                    suggestion: "Set <bpmn:documentation> describing what this tool does.",
+                    processId,
+                    elementIds: [tool.id],
+                });
+            }
+            const toolIo = readZeebeIoMapping(tool.extensionElements);
+            for (const input of toolIo?.inputs ?? []) {
+                for (const match of input.source.matchAll(FROM_AI_CALL)) {
+                    const firstArg = match[1]?.trim();
+                    if (firstArg && !firstArg.startsWith("toolCall.")) {
+                        findings.push({
+                            id: "agentic/fromai-bad-ref",
+                            category: "agentic",
+                            severity: "error",
+                            message: `fromAi() on "${tool.name ?? tool.id}" input "${input.target}" references "${firstArg}", not a toolCall.* field.`,
+                            suggestion: 'fromAi()\'s first argument must reference "toolCall.<param>".',
+                            processId,
+                            elementIds: [tool.id],
+                        });
+                    }
+                }
+            }
+        }
+    }
+    return findings;
+}
+//# sourceMappingURL=agentic.js.map

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

@@ -0,0 +1,16 @@
+import type { BpmnProcess } from "../bpmn-model.js";
+import type { OptimizationFinding } from "./types.js";
+/**
+ * Given a bundled connector template id and the set of value keys bound on
+ * the element (io-mapping targets, task-header keys, zeebe:property names),
+ * returns the required keys that are missing. Inject `applyConnectorTemplate`-
+ * backed logic from `@bpmnkit/connectors` here; core stays dependency-free.
+ */
+export type ConnectorRequirementsResolver = (templateId: string, boundKeys: string[]) => string[];
+/**
+ * Zeebe/Reebe deploy-parity checks — mirrors what Camunda 8 rejects at
+ * deployment time (`apps/reebe/crates/reebe-bpmn/src/validator.rs`), so a
+ * process that passes this profile deploys without a validation error.
+ */
+export declare function analyzeDeploy(p: BpmnProcess, resolveConnectorRequirements?: ConnectorRequirementsResolver): OptimizationFinding[];
+//# sourceMappingURL=deploy.d.ts.map

package/dist/bpmn/optimize/deploy.js

@@ -0,0 +1,143 @@
+import { readZeebeIoMapping, readZeebeTaskHeaders, readZeebeTaskType } from "./utils.js";
+function findExt(el, name) {
+    return el.extensionElements.find((e) => e.name === name);
+}
+/**
+ * Zeebe/Reebe deploy-parity checks — mirrors what Camunda 8 rejects at
+ * deployment time (`apps/reebe/crates/reebe-bpmn/src/validator.rs`), so a
+ * process that passes this profile deploys without a validation error.
+ */
+export function analyzeDeploy(p, resolveConnectorRequirements) {
+    const findings = [];
+    const processId = p.id;
+    if (p.isExecutable !== true) {
+        findings.push({
+            id: "deploy/process-not-executable",
+            category: "deploy",
+            severity: "error",
+            message: `Process "${processId}" is not marked executable.`,
+            suggestion: 'Set isExecutable="true" — Camunda 8 refuses to deploy a non-executable process.',
+            processId,
+            elementIds: [],
+        });
+    }
+    for (const el of p.flowElements) {
+        if (el.type === "serviceTask" || el.type === "sendTask") {
+            const type = readZeebeTaskType(el.extensionElements);
+            if (!type) {
+                findings.push({
+                    id: "deploy/service-task-no-type",
+                    category: "deploy",
+                    severity: "error",
+                    message: `"${el.name ?? el.id}" (${el.type}) has no zeebe:taskDefinition type.`,
+                    suggestion: "Set a job type — Camunda 8 refuses to deploy a task with no task definition.",
+                    processId,
+                    elementIds: [el.id],
+                });
+            }
+        }
+        if (el.type === "businessRuleTask") {
+            const hasType = readZeebeTaskType(el.extensionElements) !== null;
+            const hasDecision = findExt(el, "zeebe:calledDecision") !== undefined;
+            if (!hasType && !hasDecision) {
+                findings.push({
+                    id: "deploy/service-task-no-type",
+                    category: "deploy",
+                    severity: "error",
+                    message: `"${el.name ?? el.id}" (businessRuleTask) has neither a zeebe:taskDefinition type nor a zeebe:calledDecision.`,
+                    suggestion: "Set a decisionId or a job type.",
+                    processId,
+                    elementIds: [el.id],
+                });
+            }
+        }
+        if (el.type === "callActivity") {
+            const called = findExt(el, "zeebe:calledElement");
+            if (!called?.attributes.processId) {
+                findings.push({
+                    id: "deploy/call-activity-no-process",
+                    category: "deploy",
+                    severity: "error",
+                    message: `Call activity "${el.name ?? el.id}" has no zeebe:calledElement processId.`,
+                    suggestion: "Set the process id to call.",
+                    processId,
+                    elementIds: [el.id],
+                });
+            }
+        }
+        if (el.type === "startEvent") {
+            const messageDef = el.eventDefinitions.find((d) => d.type === "message");
+            if (messageDef && !messageDef.messageRef) {
+                findings.push({
+                    id: "deploy/message-start-no-name",
+                    category: "deploy",
+                    severity: "error",
+                    message: `Message start event "${el.name ?? el.id}" has no message name.`,
+                    suggestion: "Set a message name — Camunda 8 refuses to deploy an unnamed message reference.",
+                    processId,
+                    elementIds: [el.id],
+                });
+            }
+        }
+        if (el.type === "intermediateCatchEvent" ||
+            el.type === "boundaryEvent" ||
+            el.type === "receiveTask") {
+            const messageDef = el.type === "receiveTask"
+                ? undefined
+                : el.eventDefinitions.find((d) => d.type === "message");
+            const isMessageCatch = el.type === "receiveTask" ? el.messageRef !== undefined : messageDef !== undefined;
+            if (isMessageCatch) {
+                const subscription = findExt(el, "zeebe:subscription");
+                if (!subscription?.attributes.correlationKey) {
+                    findings.push({
+                        id: "deploy/message-catch-no-correlation",
+                        category: "deploy",
+                        severity: "error",
+                        message: `Message catch "${el.name ?? el.id}" (${el.type}) has no zeebe:subscription correlationKey.`,
+                        suggestion: "Set a correlation key — required for every message catch in Camunda 8.",
+                        processId,
+                        elementIds: [el.id],
+                    });
+                }
+            }
+        }
+        if (resolveConnectorRequirements) {
+            const templateId = el.unknownAttributes["zeebe:modelerTemplate"];
+            if (templateId) {
+                const boundKeys = new Set();
+                const io = readZeebeIoMapping(el.extensionElements);
+                if (io) {
+                    for (const i of io.inputs)
+                        boundKeys.add(i.target);
+                    for (const o of io.outputs)
+                        boundKeys.add(o.target);
+                }
+                const headers = readZeebeTaskHeaders(el.extensionElements);
+                if (headers)
+                    for (const h of headers.headers)
+                        boundKeys.add(h.key);
+                const propsExt = findExt(el, "zeebe:properties");
+                if (propsExt) {
+                    for (const child of propsExt.children ?? []) {
+                        if (child.attributes.name)
+                            boundKeys.add(child.attributes.name);
+                    }
+                }
+                const missing = resolveConnectorRequirements(templateId, [...boundKeys]);
+                for (const key of missing) {
+                    findings.push({
+                        id: "connector/missing-required",
+                        category: "connector",
+                        severity: "error",
+                        message: `"${el.name ?? el.id}" is missing required connector value "${key}" for template "${templateId}".`,
+                        suggestion: `Set a value for "${key}".`,
+                        processId,
+                        elementIds: [el.id],
+                    });
+                }
+            }
+        }
+    }
+    return findings;
+}
+//# sourceMappingURL=deploy.js.map

package/dist/bpmn/optimize/feel-syntax.d.ts

@@ -0,0 +1,12 @@
+import type { BpmnProcess } from "../bpmn-model.js";
+import type { OptimizationFinding } from "./types.js";
+/**
+ * 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 declare function analyzeFeelSyntax(p: BpmnProcess): OptimizationFinding[];
+//# sourceMappingURL=feel-syntax.d.ts.map