@bpmnkit/core 0.1.1 → 0.1.2

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

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/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/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

@@ -11,8 +11,10 @@ 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, 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";
@@ -33,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";
@@ -45,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

@@ -7,6 +7,7 @@ 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";
@@ -23,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