@bpmnkit/camunda-docspack 0.0.0

package/.llms/chunks/components.modeler.bpmn.bpmn-primer.modeling-bpmn-diagrams-sequence-flow-controlling-the-flow-of-execution.md

@@ -0,0 +1,20 @@
+# BPMN primer — Modeling BPMN diagrams — Sequence flow: Controlling the flow of execution
+
+A core concept of BPMN is a **sequence flow** that defines the order in which steps in the process happen. In BPMN's visual representation, a sequence flow is an arrow connecting two elements. The direction of the arrow indicates their order of execution.
+
+![sequence flow](./assets/sequenceflow.png)
+
+You can think of process execution as tokens running through the process model. When a process is started, a token is created at the beginning of the model and advances with every completed step. When the token reaches the end of the process, it is consumed and the process instance ends. Zeebe's task is to drive the token and to make sure the job workers are invoked whenever necessary.
+
+<center>
+<ReactPlayer
+playing
+loop
+playsInline
+height="200px"
+src="/videos/sequenceflow.mp4"
+/>
+</center>
+
+---
+Source: https://docs.camunda.io/docs/next/components/modeler/bpmn/bpmn-primer

package/.llms/chunks/components.modeler.bpmn.bpmn-primer.modeling-bpmn-diagrams-subprocesses-grouping-elements.md

@@ -0,0 +1,13 @@
+# BPMN primer — Modeling BPMN diagrams — Subprocesses: Grouping elements
+
+[**Subprocesses**](https://docs.camunda.io/docs/next/components/modeler/bpmn/subprocesses) are element containers that allow defining common functionality. For example, you can attach an event to a subprocess's border.
+
+When the event is triggered, the subprocess is interrupted, regardless which of its elements is currently active.
+
+Refer to the [subprocesses](https://docs.camunda.io/docs/next/components/modeler/bpmn/subprocesses) section on which types of subprocesses are currently supported and how to use them.
+
+**Note**
+Swim lanes (pools and lanes) are only available at the top-level process or collaboration level. They cannot be added inside a subprocess. This is a constraint of the BPMN 2.0 specification.
+
+---
+Source: https://docs.camunda.io/docs/next/components/modeler/bpmn/bpmn-primer

package/.llms/chunks/components.modeler.bpmn.bpmn-primer.modeling-bpmn-diagrams-tasks-units-of-work.md

@@ -0,0 +1,20 @@
+# BPMN primer — Modeling BPMN diagrams — Tasks: Units of work
+
+The basic elements of BPMN processes are tasks; these are atomic units of work composed to create a meaningful result. Whenever a token reaches a task, the token stops and Zeebe creates a job and notifies a registered worker to perform work. When that handler signals completion, the token continues on the outgoing sequence flow.
+
+<center>
+<ReactPlayer
+playing
+loop
+playsInline
+height="300px"
+src="/videos/tasks.mp4"
+/>
+</center>
+
+Choosing the granularity of a task is up to the person modeling the process. For example, the activity of processing an order can be modeled as a single _Process Order_ task, or as three individual tasks _Collect Money_, _Fetch Items_, _Ship Parcel_. If you use Zeebe to orchestrate microservices, one task can represent one microservice invocation.
+
+Refer to the [tasks](https://docs.camunda.io/docs/next/components/modeler/bpmn/tasks) section on which types of tasks are currently supported and how to use them.
+
+---
+Source: https://docs.camunda.io/docs/next/components/modeler/bpmn/bpmn-primer

package/.llms/chunks/components.modeler.bpmn.bpmn-primer.modeling-bpmn-diagrams.md

@@ -0,0 +1,12 @@
+# BPMN primer — Modeling BPMN diagrams
+
+The best tool for modeling BPMN diagrams for Zeebe is [Modeler](https://docs.camunda.io/docs/next/components/modeler/about-modeler). Learn more by [modeling your first diagram](https://docs.camunda.io/docs/next/components/hub/workspace/modeler/modeling/model-your-first-diagram).
+
+- [Download page](https://camunda.com/download/modeler/)
+- [Source code repository](https://github.com/camunda/camunda-modeler)
+
+
+## BPMN elements
+
+---
+Source: https://docs.camunda.io/docs/next/components/modeler/bpmn/bpmn-primer

package/.llms/chunks/components.modeler.bpmn.bpmn.bpmn-2.0-properties-for-execution.md

@@ -0,0 +1,8 @@
+# BPMN in Modeler — BPMN 2.0 properties for execution
+
+![Save BPMN Diagram](./assets/quickstart-3.png)
+
+In the properties panel on the right side, view and edit attributes that apply to the selected element.
+
+---
+Source: https://docs.camunda.io/docs/next/components/modeler/bpmn/bpmn

package/.llms/chunks/components.modeler.bpmn.bpmn.md

@@ -0,0 +1,11 @@
+# BPMN in Modeler
+
+Let's start modeling by creating a BPMN diagram.
+
+**Business Process Model and Notation (BPMN)** was developed as a graphical notation to represent complex processes. It is maintained by the non-profit [The Object Management Group (OMG)](https://www.omg.org/spec/BPMN/) and employed by numerous organizations globally. The visual nature of BPMN enables greater collaboration between different teams, particularly within Modeler.
+
+**Note**
+BPMN diagrams must be created for the process engine they intend to be deployed on. You cannot run a BPMN diagram modeled for Camunda 7 in Camunda 8, or vice versa, at this time.
+
+---
+Source: https://docs.camunda.io/docs/next/components/modeler/bpmn/bpmn

package/.llms/chunks/components.modeler.bpmn.bpmn.start-modeling.md

@@ -0,0 +1,22 @@
+# BPMN in Modeler — Start modeling
+
+![Start Modeling](./assets/quickstart-2.png)
+
+Web and Desktop Modeler both offer a similar core BPMN 2.0 Modeling experience:
+
+- Add BPMN elements from the palette on the left side of the page by dragging and dropping them onto the diagram canvas.
+- Change the type of element in place by clicking on an element to reveal the context menu. Then, select the **Change element** menu icon to change the type of element to a [service task](https://docs.camunda.io/docs/next/components/modeler/bpmn/service-tasks/service-tasks) or [user task](https://docs.camunda.io/docs/next/components/modeler/bpmn/user-tasks/user-tasks), for example.
+
+
+## Creating BPMN elements
+
+Using BPMN in Modeler, you can create more BPMN 2.0 elements like task types and event definitions.
+
+For example, [service tasks](https://docs.camunda.io/docs/next/components/modeler/bpmn/service-tasks/service-tasks) within Camunda 8 require you to set a task type and implement [job workers](https://docs.camunda.io/docs/next/components/concepts/job-workers) to perform a particular task in a process.
+
+Review [the BPMN 2.0 coverage documentation](https://docs.camunda.io/docs/next/components/modeler/bpmn/bpmn-coverage) for a complete list of BPMN elements supported by our modeling tools.
+
+Additionally, visit [creating readable process models](https://docs.camunda.io/docs/next/components/best-practices/modeling/creating-readable-process-models) for general guidelines on modeling with BPMN.
+
+---
+Source: https://docs.camunda.io/docs/next/components/modeler/bpmn/bpmn

package/.llms/chunks/components.modeler.bpmn.business-rule-tasks.business-rule-tasks.additional-resources.md

@@ -0,0 +1,71 @@
+# Business rule tasks — Additional resources
+
+### XML representation
+
+A business rule task with a called decision that does not specify the binding type (`latest` is used implicitly):
+
+```xml
+<bpmn:businessRuleTask id="determine-box-size" name="Determine shipping box size">
+  <bpmn:extensionElements>
+    <zeebe:calledDecision decisionId="shipping_box_size" resultVariable="boxSize" />
+  </bpmn:extensionElements>
+</bpmn:businessRuleTask>
+```
+
+A business rule task with a called decision that uses the `deployment` binding type:
+
+```xml
+<bpmn:businessRuleTask id="determine-box-size" name="Determine shipping box size">
+  <bpmn:extensionElements>
+    <zeebe:calledDecision decisionId="shipping_box_size" bindingType="deployment"
+                          resultVariable="boxSize" />
+  </bpmn:extensionElements>
+</bpmn:businessRuleTask>
+```
+
+A business rule task with a called decision that uses the `versionTag` binding type with a static version tag:
+
+```xml
+<bpmn:businessRuleTask id="determine-box-size" name="Determine shipping box size">
+  <bpmn:extensionElements>
+    <zeebe:calledDecision decisionId="shipping_box_size"
+                          bindingType="versionTag" versionTag="v1.0"
+                          resultVariable="boxSize" />
+  </bpmn:extensionElements>
+</bpmn:businessRuleTask>
+```
+
+A business rule task with a called decision that uses the `versionTag` binding type with expressions for both `decisionId` and `versionTag`:
+
+```xml
+<bpmn:businessRuleTask id="determine-box-size" name="Determine shipping box size">
+  <bpmn:extensionElements>
+    <zeebe:calledDecision decisionId="= \"shipping_box_size_\" + countryCode"
+                          bindingType="versionTag" versionTag="= decisionVersion"
+                          resultVariable="boxSize" />
+  </bpmn:extensionElements>
+</bpmn:businessRuleTask>
+```
+
+A business rule task with a job worker implementation and a custom header:
+
+```xml
+<bpmn:businessRuleTask id="calculate-risk" name="Calculate risk">
+  <bpmn:extensionElements>
+    <zeebe:taskDefinition type="calculate_risk" />
+    <zeebe:taskHeaders>
+      <zeebe:header key="decisionRef" value="risk" />
+    </zeebe:taskHeaders>
+    <zeebe:jobPriorityDefinition priority="90" />
+  </bpmn:extensionElements>
+</bpmn:businessRuleTask>
+```
+
+### References
+
+- [DMN decision](https://docs.camunda.io/docs/next/components/modeler/dmn/dmn)
+- [Job handling](https://docs.camunda.io/docs/next/components/concepts/job-workers)
+- [Variable mappings](https://docs.camunda.io/docs/next/components/concepts/variables#inputoutput-variable-mappings)
+
+---
+Source: https://docs.camunda.io/docs/next/components/modeler/bpmn/business-rule-tasks/business-rule-tasks

package/.llms/chunks/components.modeler.bpmn.business-rule-tasks.business-rule-tasks.defining-a-called-decision-defining-a-task.md

@@ -0,0 +1,32 @@
+# Business rule tasks — Defining a called decision {#defining-a-task}
+
+A called decision links the business rule task to a DMN decision, either to
+a [decision table](https://docs.camunda.io/docs/next/components/modeler/dmn/decision-table) or to
+a [decision literal expression](https://docs.camunda.io/docs/next/components/modeler/dmn/decision-literal-expression)
+. It can be defined using the
+`zeebe:calledDecision` extension element.
+
+A business rule task must define the [DMN decision id](https://docs.camunda.io/docs/next/components/modeler/dmn/decision-table#decision-id) of the
+called decision as `decisionId`. Usually, the `decisionId` is defined as a [static value](https://docs.camunda.io/docs/next/components/concepts/expressions#expressions-vs-static-values) (for example, `shipping_box_size`), but
+it can also be defined as an [expression](https://docs.camunda.io/docs/next/components/concepts/expressions) (
+for example, `= "shipping_box_size_" + countryCode`). The expression is evaluated on activating the business rule task (or when
+an incident at the business rule task is resolved) after input mappings have been applied. The expression must result in
+a `string`.
+
+The `bindingType` attribute determines which version of the called decision is evaluated:
+
+- `latest`: The latest deployed version at the moment the business rule task is activated.
+- `deployment`: The version that was deployed together with the currently running version of the process.
+- `versionTag`: The latest deployed version that is annotated with the version tag specified in the `versionTag` attribute. Usually, the `versionTag` is defined as a [static value](https://docs.camunda.io/docs/next/components/concepts/expressions#expressions-vs-static-values) (for example, `v1.0`), but it can also be defined as an [expression](https://docs.camunda.io/docs/next/components/concepts/expressions) (for example, `= "v" + version`). The expression is evaluated on activating the business rule task or when an incident at the business rule task is resolved, after input mappings have been applied. The expression must result in a `string`.
+
+To learn more about choosing binding types, see [choosing the resource binding type](https://docs.camunda.io/docs/next/components/best-practices/modeling/choosing-the-resource-binding-type).
+
+**Note**
+If the `bindingType` attribute is not specified, `latest` is used as the default.
+
+A business rule task must define the process variable name of the decision result as
+`resultVariable`. The result of the decision is stored in this variable. The `resultVariable`
+is defined as a static value.
+
+---
+Source: https://docs.camunda.io/docs/next/components/modeler/bpmn/business-rule-tasks/business-rule-tasks

package/.llms/chunks/components.modeler.bpmn.business-rule-tasks.business-rule-tasks.job-worker-implementation.md

@@ -0,0 +1,32 @@
+# Business rule tasks — Job worker implementation
+
+A business rule task does not have to evaluate a decision modeled with DMN. Instead, you can also
+use [job workers](https://docs.camunda.io/docs/next/components/concepts/job-workers) to implement your business rule task.
+
+A job worker implementation can be defined using the `zeebe:taskDefinition` extension element.
+
+Business rule tasks with a job worker implementation behave exactly like [service tasks](https://docs.camunda.io/docs/next/components/modeler/bpmn/service-tasks/service-tasks). The differences between these task
+types are the visual representation (i.e. the task marker) and the semantics for the model.
+
+When a process instance enters a business rule task with alternative task implementation, it creates
+a corresponding job and waits for its completion. A job worker should request jobs of this job type
+and process them. When the job is completed, the process instance continues.
+
+A business rule task must define a [job type](https://docs.camunda.io/docs/next/components/modeler/bpmn/service-tasks/service-tasks#task-definition) the same way as a service task does. This is used as reference to specify which job workers request the respective business rule task job. For example, `order-items`. Note that `type` can be specified as any static value (`myType`) or as a FEEL [expression](https://docs.camunda.io/docs/next/components/concepts/expressions) prefixed by `=` that evaluates to any FEEL string; for example, `= "order-" + priorityGroup`.
+
+Use [task headers](https://docs.camunda.io/docs/next/components/modeler/bpmn/service-tasks/service-tasks#task-headers) to pass static parameters to the job
+worker (for example, the key of the decision to evaluate).
+
+Define [variable mappings](https://docs.camunda.io/docs/next/components/concepts/variables#inputoutput-variable-mappings)
+the [same way as a service task does](https://docs.camunda.io/docs/next/components/modeler/bpmn/service-tasks/service-tasks#variable-mappings)
+to transform the variables passed to the job worker, or to customize how the variables of the job merge.
+
+### Job priority
+
+This task type supports `zeebe:jobPriorityDefinition` when implemented as a job worker.
+
+You can define job priority on the process as a default and override it on this task.
+For priority behavior and limitations, see [Job prioritization](https://docs.camunda.io/docs/next/components/concepts/job-workers#job-prioritization).
+
+---
+Source: https://docs.camunda.io/docs/next/components/modeler/bpmn/business-rule-tasks/business-rule-tasks

package/.llms/chunks/components.modeler.bpmn.business-rule-tasks.business-rule-tasks.md

@@ -0,0 +1,29 @@
+# Business rule tasks
+
+A business rule task is used to model the evaluation of a business rule.
+
+A business rule task is used to model the evaluation of a business rule. For example, a decision
+modeled in [Decision Model and Notation](https://www.omg.org/dmn/) (DMN).
+
+![task](assets/business-rule-task.png)
+
+**Info**
+Camunda 8 supports alternative task implementations for the business rule task. If you want
+to use your own implementation for a business rule task, refer to the [job worker
+implementation](#job-worker-implementation) section below. The sections before this job worker implementation apply to the DMN
+decision implementation only.
+
+**Info**
+If you only want to evaluate a DMN decision, you can use the
+[`EvaluateDecision`](https://docs.camunda.io/docs/next/apis-tools/zeebe-api/gateway-service#evaluatedecision-rpc) API.
+
+When the process instance arrives at a business rule task, a decision is evaluated using the
+internal DMN decision engine. Once the decision is made, the process instance continues.
+
+If the decision evaluation is unsuccessful, an [incident](https://docs.camunda.io/docs/next/components/concepts/incidents) is
+raised at the business rule task. When the incident is resolved, the decision is evaluated again.
+
+Used as a tool inside an [ad-hoc sub-process](https://docs.camunda.io/docs/next/components/modeler/bpmn/ad-hoc-subprocesses/ad-hoc-subprocesses), a business rule task lets an [AI agent](https://docs.camunda.io/docs/next/reference/glossary#ai-agent) delegate part of its decision to a governed DMN decision instead of LLM reasoning, keeping that step deterministic. See [AI agent tool definitions](https://docs.camunda.io/docs/next/components/connectors/out-of-the-box-connectors/agentic-ai-aiagent-tool-definitions) for how tools are declared.
+
+---
+Source: https://docs.camunda.io/docs/next/components/modeler/bpmn/business-rule-tasks/business-rule-tasks

package/.llms/chunks/components.modeler.bpmn.business-rule-tasks.business-rule-tasks.variable-mappings.md

@@ -0,0 +1,20 @@
+# Business rule tasks — Variable mappings
+
+By default, the variable defined by `resultVariable` is merged into the process instance. This
+behavior can be customized by defining an output mapping at the business rule task.
+
+All variables in scope of the business rule task are available to the decision engine when the
+decision is evaluated. Input mappings can be used to transform the variables into a format accepted
+by the decision.
+
+**Info**
+Input mappings are applied on activating the business rule task (or when an incident at the business
+rule task is resolved), before the decision evaluation. When an incident is resolved at the business
+rule task, the input mappings are applied again before evaluating the decision. This can affect
+the result of the decision.
+
+For more information about this topic, visit the documentation about [input/output variable
+mappings](https://docs.camunda.io/docs/next/components/concepts/variables#inputoutput-variable-mappings).
+
+---
+Source: https://docs.camunda.io/docs/next/components/modeler/bpmn/business-rule-tasks/business-rule-tasks

package/.llms/chunks/components.modeler.bpmn.call-activities.call-activities.additional-resources.md

@@ -0,0 +1,56 @@
+# Call activities — Additional resources
+
+### XML representation
+
+A call activity with static process id, propagation of all child variables turned on, and no explicit binding type (`latest` is used implicitly):
+
+```xml
+<bpmn:callActivity id="Call_Activity" name="Call Process A">
+  <bpmn:extensionElements>
+    <zeebe:calledElement processId="child-process-a" propagateAllChildVariables="true" />
+  </bpmn:extensionElements>
+</bpmn:callActivity>
+```
+
+A call activity with the `deployment` binding type:
+
+```xml
+<bpmn:callActivity id="Call_Activity" name="Call Process A">
+  <bpmn:extensionElements>
+    <zeebe:calledElement processId="child-process-a" bindingType="deployment" />
+  </bpmn:extensionElements>
+</bpmn:callActivity>
+```
+
+A call activity with the `versionTag` binding type:
+
+```xml
+<bpmn:callActivity id="Call_Activity" name="Call Process A">
+  <bpmn:extensionElements>
+    <zeebe:calledElement processId="child-process-a"
+                         bindingType="versionTag" versionTag="v1.0" />
+  </bpmn:extensionElements>
+</bpmn:callActivity>
+```
+
+A call activity with copying of all variables to the child process turned off:
+
+```xml
+<bpmn:callActivity id="Call_Activity" name="Call Process A">
+    <bpmn:extensionElements>
+        <zeebe:calledElement processId="child-process-id" propagateAllParentVariables="false" />
+        <zeebe:ioMapping>
+            <zeebe:input source="=variableValue" target="variableName" />
+        </zeebe:ioMapping>
+    </bpmn:extensionElements>
+</bpmn:callActivity>
+```
+
+### References
+
+- [Expressions](https://docs.camunda.io/docs/next/components/concepts/expressions)
+- [Variable scopes](https://docs.camunda.io/docs/next/components/concepts/variables#variable-scopes)
+- [Variable mappings](https://docs.camunda.io/docs/next/components/concepts/variables#inputoutput-variable-mappings)
+
+---
+Source: https://docs.camunda.io/docs/next/components/modeler/bpmn/call-activities/call-activities

package/.llms/chunks/components.modeler.bpmn.call-activities.call-activities.boundary-events.md

@@ -0,0 +1,29 @@
+# Call activities — Boundary events
+
+![call-activity-boundary-event](assets/call-activities-boundary-events.png)
+
+Interrupting and non-interrupting boundary events can be attached to a call activity.
+
+When an interrupting boundary event is triggered, the call activity and the created process instance are terminated. The variables of the created process instance are not propagated to the call activity.
+
+When a non-interrupting boundary event is triggered, the created process instance is not affected. The activities at the outgoing path have no access to the variables of the created process instance since they are bound to the other process instance.
+
+
+## Variable mappings
+
+Input mappings can be used to create new local variables in the scope of the call activity. These variables are also copied to the created process instance.
+
+If the attribute `propagateAllChildVariables` is set (default: `true`), all variables of the created process instance are propagated to the call activity. This behavior can be customized by defining output mappings at the call activity. The output mappings are applied on completing the call activity and only those variables that are defined in the output mappings are propagated.
+
+If you set `propagateAllChildVariables` to `false` and define no output mappings, the variables of the created process instance are discarded when the call activity completes. To return only selected variables to the caller, keep `propagateAllChildVariables` enabled and define output mappings.
+
+It's recommended to define output mappings if the call activity is in a parallel flow (e.g. when it is marked as [parallel multi-instance](https://docs.camunda.io/docs/next/components/modeler/bpmn/multi-instance/multi-instance#variable-mappings)). Otherwise, variables can be accidentally overridden when they are changed in the parallel flow. Disable `propagateAllChildVariables` only if the caller does not need the child process variables at all.
+
+By default, all variables of the call activity scope are copied to the created process instance. This can be limited to copying only the local variables of the call activity, by setting the attribute `propagateAllParentVariables` to `false`.
+
+By disabling this attribute, variables existing at higher scopes are no longer copied. If the attribute `propagateAllParentVariables` is set (default: `true`), all variables are propagated to the child process instance.
+
+For how a call activity compares to other elements, see [variable propagation by BPMN element](https://docs.camunda.io/docs/next/components/concepts/variables#variable-propagation-by-bpmn-element).
+
+---
+Source: https://docs.camunda.io/docs/next/components/modeler/bpmn/call-activities/call-activities

package/.llms/chunks/components.modeler.bpmn.call-activities.call-activities.business-id-propagation.md

@@ -0,0 +1,53 @@
+# Call activities — Business ID propagation
+
+When a parent process instance has a business ID, child instances created by call activities inherit it by default. Starting in 8.10, you can configure each call activity to override this behavior.
+
+### Default behavior
+
+If no `businessId` configuration is set on the call activity, the child instance inherits the parent's business ID automatically. This is the 8.9 default. Existing models are unaffected.
+
+### Override with a literal value or FEEL expression
+
+To set a different business ID on the child instance, configure the `businessId` attribute on the `zeebe:calledElement` extension element. The value is resolved once at child creation and is then immutable.
+
+```xml
+<bpmn:callActivity id="Call_Activity" name="Call Process A">
+  <bpmn:extensionElements>
+    <zeebe:calledElement processId="child-process"
+                         businessId="= camunda.processInstance.businessId" />
+  </bpmn:extensionElements>
+</bpmn:callActivity>
+```
+
+You can use the FEEL expression context variable `camunda.processInstance.businessId` to reference the parent instance's business ID in the expression.
+
+| Configuration                           | Effect                                                                                             |
+| :-------------------------------------- | :------------------------------------------------------------------------------------------------- |
+| Attribute absent                        | Child inherits the parent's business ID (default).                                                 |
+| Literal string                          | Child is created with that exact string as its business ID.                                        |
+| FEEL expression (prefixed with `=`)     | Child gets the evaluated result. Access the parent's ID with `camunda.processInstance.businessId`. |
+| Empty string `""` or expression `=null` | Child starts with no business ID. No incident is raised.                                           |
+
+### Validation and error handling
+
+Business ID values go through two validation stages:
+
+**Danger: Deploy-time rejection**
+The process cannot be deployed if:
+
+- The `businessId` attribute contains an invalid FEEL expression syntax.
+- A static literal value exceeds 256 characters.
+
+If the value is empty or intentionally `null` at runtime (for example, `=null` or a FEEL expression that cleanly evaluates to `null`), the child starts with no business ID and no incident is raised.
+
+**Warning: Runtime incident (resolvable)**
+An incident is raised on the call activity if the FEEL expression:
+
+- Evaluates to `null` due to evaluation warnings — for example, a missing variable caused the null rather than an intentional `=null`.
+- Evaluates to a string exceeding 256 characters.
+- Evaluates to a non-string, non-null type (number, boolean, or list).
+
+To resolve the incident: correct the variables or expression, then retry activation. The child instance is created with the corrected business ID.
+
+---
+Source: https://docs.camunda.io/docs/next/components/modeler/bpmn/call-activities/call-activities

package/.llms/chunks/components.modeler.bpmn.call-activities.call-activities.defining-the-called-process.md

@@ -0,0 +1,19 @@
+# Call activities — Defining the called process
+
+A call activity must define the BPMN process ID of the called process as `processId`.
+
+Usually, the `processId` is defined as a [static value](https://docs.camunda.io/docs/next/components/concepts/expressions#expressions-vs-static-values) (e.g. `shipping-process`), but it can also be defined as [expression](https://docs.camunda.io/docs/next/components/concepts/expressions) (e.g. `= "shipping-" + tenantId`). The expression is evaluated on activating the call activity and must result in a `string`.
+
+The `bindingType` attribute determines which version of the called process is instantiated:
+
+- `latest`: The latest deployed version at the moment the call activity is activated.
+- `deployment`: The version that was deployed together with the currently running version of the calling process.
+- `versionTag`: The latest deployed version that is annotated with the version tag specified in the `versionTag` attribute.
+
+To learn more about choosing binding types, see [choosing the resource binding type](https://docs.camunda.io/docs/next/components/best-practices/modeling/choosing-the-resource-binding-type).
+
+**Note**
+If the `bindingType` attribute is not specified, `latest` is used as the default.
+
+---
+Source: https://docs.camunda.io/docs/next/components/modeler/bpmn/call-activities/call-activities

package/.llms/chunks/components.modeler.bpmn.call-activities.call-activities.md

@@ -0,0 +1,14 @@
+# Call activities
+
+A call activity (or reusable subprocess) allows you to call and invoke another process as part of this process.
+
+A call activity (or reusable subprocess) allows you to call and invoke another process as part of this process. It's similar to an [embedded subprocess](https://docs.camunda.io/docs/next/components/modeler/bpmn/embedded-subprocesses/embedded-subprocesses), but the process is externalized (i.e. stored as separated BPMN) and can be invoked by different processes.
+
+![call-activity](assets/call-activities-example.png)
+
+When a call activity is entered, a new process instance of the referenced process is created. The new process instance is activated at the **none start event**. The process can have start events of other types, but they are ignored.
+
+When the created process instance is completed, the call activity is left and the outgoing sequence flow is taken.
+
+---
+Source: https://docs.camunda.io/docs/next/components/modeler/bpmn/call-activities/call-activities

package/.llms/chunks/components.modeler.bpmn.compensation-events.compensation-events.compensating-embedded-subprocesses.md

@@ -0,0 +1,20 @@
+# Compensation events — Compensating embedded subprocesses
+
+If a process instance enters a compensation throw event and there are
+completed [embedded subprocesses](https://docs.camunda.io/docs/next/components/modeler/bpmn/embedded-subprocesses/embedded-subprocesses) in the
+same scope, it invokes the compensation handlers within these subprocesses and nested subprocesses. The compensation
+handlers are not invoked if the subprocess is active or terminated.
+
+![Process with embedded subprocesses](assets/compensation-embedded-subprocess.png)
+
+If the compensation throw event is inside an embedded subprocess, the process instance invokes only the compensation
+handlers within the subprocess. It doesn't invoke any compensation handler outside the subprocess.
+
+**Info**
+
+Compensation handlers of child processes are not invoked. The triggering of the compensation stops at the call activity.
+To revert the effects of a child process, attach a compensation boundary event on the call activity. Read more about
+this in [call activities as compensation handlers](https://docs.camunda.io/docs/next/components/modeler/bpmn/compensation-handler/compensation-handler#call-activity-as-compensation-handler).
+
+---
+Source: https://docs.camunda.io/docs/next/components/modeler/bpmn/compensation-events/compensation-events

package/.llms/chunks/components.modeler.bpmn.compensation-events.compensation-events.compensating-multi-instance-activities.md

@@ -0,0 +1,17 @@
+# Compensation events — Compensating multi-instance activities
+
+The compensation handler of a multi-instance activity is invoked only once, rather than for each item in the input
+collection. The compensation handler is responsible for reverting the effects of all instances of the multi-instance
+activity.
+
+![Process with multi instance activity](assets/compensation-multi-instance-activity.png)
+
+To revert the effects of each instance separately, the compensation handler could be marked as multi-instance as well.
+Read more about this in [multi-instance activities as compensation handlers](https://docs.camunda.io/docs/next/components/modeler/bpmn/compensation-handler/compensation-handler#multi-instance-activity-as-compensation-handler).
+
+**Note**
+The process instance invokes the compensation handler only if all instances of the multi-instance activity are
+completed.
+
+---
+Source: https://docs.camunda.io/docs/next/components/modeler/bpmn/compensation-events/compensation-events

package/.llms/chunks/components.modeler.bpmn.compensation-events.compensation-events.md

@@ -0,0 +1,23 @@
+# Compensation events
+
+Compensation events are used to undo tasks that have already been executed.
+
+Compensation events assist with undoing steps that were already successfully completed in the case that their results
+are no longer desired and need to be reversed.
+
+To revert the effects of an activity, a compensation boundary event is attached to the activity. This activity is called
+**compensation activity**. The compensation boundary event is associated with
+the [compensation handler](https://docs.camunda.io/docs/next/components/modeler/bpmn/compensation-handler/compensation-handler), an activity with a compensation marker that
+is in charge of reverting the effects of the compensation activity.
+
+![Process with compensation throw event](assets/compensation-throw-event.png)
+
+The example above shows the execution of compensation events:
+
+1. After the service task `A` is completed, the process reaches the compensation intermediate throw event.
+2. This invokes the compensation handler `Undo A` associated with the compensation boundary event.
+3. Once the compensation handler `Undo A` is completed, the process completes the compensation intermediate throw event
+   and takes the outgoing sequence flow.
+
+---
+Source: https://docs.camunda.io/docs/next/components/modeler/bpmn/compensation-events/compensation-events

package/.llms/chunks/components.modeler.bpmn.compensation-events.compensation-events.triggering-compensation-for-a-specific-activity.md

@@ -0,0 +1,14 @@
+# Compensation events — Triggering compensation for a specific activity
+
+By default, a compensation throw event invokes all compensation handlers in its scope. However, it is also possible to
+trigger the compensation for a specific activity. This can be used to enforce that compensation handlers are invoked
+synchronously in a given order.
+
+![Trigger compensation for a give activity](assets/compensation-activity-ref.png)
+
+On a compensation intermediate throw or end event, it is possible to specify the activity to compensate by using the
+property `activityRef`. The referenced activity must have a compensation boundary event and must be in the same scope of
+the compensation throw event.
+
+---
+Source: https://docs.camunda.io/docs/next/components/modeler/bpmn/compensation-events/compensation-events

package/.llms/chunks/components.modeler.bpmn.compensation-events.compensation-events.triggering-compensation-from-an-event-subprocess.md

@@ -0,0 +1,28 @@
+# Compensation events — Triggering compensation from an event subprocess
+
+An interrupting or non-interrupting event subprocess can contain compensation intermediate throw events or a
+compensation end event. These compensation events can specify an activity or broadcast the compensation within the outer
+scope of the event subprocess.
+
+![Trigger compensation from an event subprocess](assets/compensation-event-subprocess.png)
+
+A common pattern is to use this in combination with an error event subprocess to revert the effects of compensation
+activities if a failure occurs that can't be recovered from.
+
+
+## Additional resources
+
+### XML representation
+
+An intermediate compensation throw event with a referenced activity:
+
+```xml
+<intermediateThrowEvent id="CompensationThrowEvent">
+    <incoming>Flow_0b2blc2</incoming>
+    <outgoing>Flow_1goayj7</outgoing>
+    <compensateEventDefinition id="CompensateEventDefinition_1afu1vn" activityRef="Task_A" />
+</intermediateThrowEvent>
+```
+
+---
+Source: https://docs.camunda.io/docs/next/components/modeler/bpmn/compensation-events/compensation-events

package/.llms/chunks/components.modeler.bpmn.compensation-events.compensation-events.triggering-compensation.md

@@ -0,0 +1,14 @@
+# Compensation events — Triggering compensation
+
+When a process instance enters a compensation intermediate throw or end event, it triggers the compensation within its
+scope and invokes all compensation handlers of completed activities. The compensation handlers of active or terminated
+activities are not invoked. The compensation throw event remains active until all invoked compensation handlers are
+completed.
+
+**Note**
+The process instance invokes all compensation handlers at once without any specific order. If the order is
+important, the compensation can be triggered for a specific activity. Read more about this
+case in [triggering compensation for an activity](#triggering-compensation-for-a-specific-activity).
+
+---
+Source: https://docs.camunda.io/docs/next/components/modeler/bpmn/compensation-events/compensation-events