diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 2ccdf87f..26471959 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -53,16 +53,16 @@ them on a private corpus without copying it into the repository, are described i
   | `domain/commands/` | the commands a caller can ask for (`EditCommand`: `AddElement`, `PlaceShapes`, ...), the ops JSON of `apply` and its aliases |
   | `domain/diagram/` | the drawing (BPMN DI): `di/` reads and writes planes, frames, groups and the checkpoint every engine shares, `layout/` holds the engines (`clean/` redraws with `FullLayout`, `incremental/` keeps a hand-made drawing), `DrawnDiagram` is the drawing the diagram commands change, `commands/` holds one handler per diagram command (`ShapePlacement`, `ShapeAlignment`, `SpaceInsertion`, ...) and `DiagramCommands`, which dispatches them; `BatchDrawing` is all a batch does to the drawing |
   | `domain/editing/` | what changes the model, one folder per concern: `elements/` (add, remove, retype, move, order, placement, artifacts, pools, lanes), `connections/` (connect, associations, sequence flows, bridges, flow ids, split), `properties/` (set, value coercion, the set keys, nested slots, vendor elements, decision links), `events/` (triggers, event definitions, root elements, the event-gateway rule), `extensions/` (ext), `ids/` (id renames); a command is a class created with the `EditSession` (`new ElementCreation(edit).add(op)`, `new Connections(edit).connect(op)`, ...) |
-  | `domain/validation/` | structural validation (`StructuralValidator`, `FlowOrder`), the validator hook, the `FindingBaseline` a write compares with and the `FindingMatcher` that tells the same finding before and after an edit; `profiles/` holds the engine rules that load on demand |
+  | `domain/validation/` | structural validation (`StructuralValidator`, `FlowOrder`), the validator hook, the `FindingBaseline` a write compares with and the `FindingMatcher` that tells the same finding before and after an edit; `PlatformCheck` adds the Camunda 7 / 8 findings of the injected `EngineLint` |
   | `domain/views/` | the read views (`show`, `find`, `--around`, `--context`) and `DrawableDoc`, a document ready to draw (one without a diagram laid out in memory) |
   | `domain/batch/` | one batch of commands on a document in memory: `EditBatch` (guard, commands, validation, layout, kept text, result), `ModelCommands` hands each model command to its domain service and `BatchDrawing` (`domain/diagram/`) lays the drawing out between them; the top of the domain, nothing imports it back |
   | `application/port/in/` | one contract per use case, the way in: an interface with its `Command` and `Result` (`EditDocumentUseCase`, `RelayoutDiagramUseCase`, `ValidateDocumentUseCase`, `ShowModelUseCase`, ...), also for a pure query that needs no outbound port |
-  | `application/port/out/` | what the application needs from outside, named after what it does: `DocumentPort` (load a document, resolve where a result goes, save it), `LoadProjectSettingsPort` (the `.bpmnlintrc`), `RenderDiagramPort` (a plane as SVG), `WriteImagePort` |
+  | `application/port/out/` | what the application needs from outside, named after what it does: `DocumentPort` (load a document, resolve where a result goes, save it), `LoadProjectSettingsPort` (the `.bpmnlintrc`), `RenderDiagramPort` (a plane as SVG), `EngineLintPort` (the Camunda 7 / 8 rules), `WriteImagePort` |
   | `application/service/` | one service per use case that implements its contract (`EditDocumentService implements EditDocumentUseCase`): load, let the domain work, save, all through the outbound ports; a query asks the domain and returns its answer |
   | `adapters/in/cli/` | the driving adapter: the `Cli` (commander, streams, exit codes, errors) and one class per command; it knows the use cases only by their contracts and reaches the domain only through them; from the domain it takes the command vocabulary to check its flags (errors, op rules, flag values) |
   | `adapters/in/report/` | what a use case's result looks like to the one who asked: text and JSON reports (`MutationText`, `MutationReportBuilder`, `ValidationText`, ...), the views as text, and the reference the guide and `bpmn kinds` print; the CLI prints them and `index.ts` / `api.ts` return them |
-  | `adapters/out/bpmnlint/` | the injected bpmnlint as a validator of the domain, browser-safe: `BpmnlintConfigResolution` (the effective `.bpmnlintrc`), `BpmnlintValidator`, `IdConventionsReader` (the id conventions of `element-id-naming`) |
-  | `adapters/out/files/` | the driven adapters on disk, Node only: `FileDocumentStore`, `BpmnlintProjectSettings` (loads the `.bpmnlintrc` and its plugins for `adapters/out/bpmnlint/`), `FileImageWriter` (PNG via resvg) |
+  | `adapters/out/bpmnlint/` | the injected bpmnlint as a validator of the domain, browser-safe: `BpmnlintConfigResolution` (the effective `.bpmnlintrc`), `BpmnlintValidator`, `IdConventionsReader` (the id conventions of `element-id-naming`); `BpmnlintEngineLint`, the Camunda 7 / 8 rules (the `EngineLintPort`), which loads `engine/` on demand: camunda-compat's rules (`compatRules`) and bpmn-cli's own rules (seventy for Camunda 7, fifty for Camunda 8: `engine/rules/c7|c8/`, one rule per file and one check per rule, next to the `support/` helpers of that engine, the shared helpers in `engine/rules/support/`, the rule bases both engines share in `engine/rules/`; a rule is named after what must hold, the id `<engine>-<subject>-<requirement>` and the class `<Engine><Subject><Requirement>Rule` in a file of its name (`c7-message-needs-name`, `C7MessageNeedsNameRule.ts`), the requirement `needs-<part>` for what must be there, `no-<part>` for what must not, or `known`, `valid`, `unique`, `allowed`, `supported`, `placement`, `resolves` for a value, a name or a place the engine accepts; it declares one `code` and `impact` in `defineRule`, several rules may share a code; an abstract base without `defineRule` (`C7ExecutableRule`, `C8FeelRule`, ...) holds what two or more rules check alike; the rules on what a typed parse drops read the file as written through `WrittenModel`, written on `EngineRule` of `@miragon/bpmnlint-plugin-rules/engine` and run in one walk with its `lint`), mapped to `W_C7_*` / `W_C8_*` by the engine run in `engine/run/` (`EngineRun`, `EngineFindings`, `EngineCodes`, `EngineHint`; `CompatVerdicts` holds where bpmn-cli reads camunda-compat differently); `engine/` gets the core from `engine-kit.ts` (a rule chunk must not import the entry) |
+  | `adapters/out/files/` | the driven adapters on disk, Node only: `FileDocumentStore`, `BpmnlintProjectSettings` (loads the `.bpmnlintrc` and its plugins for `adapters/out/bpmnlint/`), `FileImageWriter` (PNG) |
   | `adapters/out/document/` | `DocumentStore`, what the file store and the in-memory store share behind the `DocumentPort`: a source parsed into a `Doc`, the lossless check, the target of a write and whether to write; browser-safe |
   | `adapters/out/render/` | the SVG renderer behind the `RenderDiagramPort`, browser-safe: `SvgRenderer` (the port), `DocRenderer` (one plane, start to end), `crop/` (which part of the plane), `paint/` (the shapes, connections and labels as SVG), `compose/` (frame, scale, badges, tiles) |
   | `adapters/out/memory/` | the driven adapters of the in-memory API: `NoDocumentFiles`, `NoProjectSettings` |
@@ -119,9 +119,10 @@ them on a private corpus without copying it into the repository, are described i
 
 `bpmn-moddle` (the semantic model; `moddle` for its types), `@resvg/resvg-wasm` (the PNG rasteriser of
 `bpmn render`), `commander` (the CLI only), and `bpmnlint` (pinned to `11.15.0`) with
-`@miragon/bpmnlint-plugin-rules` (pinned to `0.12.1`: bpmnlint's rules, camunda-compat and
-Miragon's rules behind one resolver), loaded only when a `.bpmnlintrc` applies (see
-[bpmnlint](docs/bpmnlint.md)). Both are pinned exactly: they decide which findings an agent sees,
+`@miragon/bpmnlint-plugin-rules` (bpmnlint's rules, camunda-compat and Miragon's rules behind one
+resolver). They run when a `.bpmnlintrc` applies (see [bpmnlint](docs/bpmnlint.md)), and the plugin's
+`./camunda-7` and `./camunda-8` entries are the Camunda 7 / 8 rules of every check, loaded on demand
+(see [Camunda 7 and Camunda 8](docs/camunda.md#where-the-checks-come-from)). Both are pinned exactly: they decide which findings an agent sees,
 the tests pin those findings, and bpmn-cli uses bpmnlint's `Linter` beyond its documented API.
 
 `camunda-bpmn-moddle` (pinned to `8.0.1`) is a development dependency: its Camunda 7 descriptor
diff --git a/docs/bpmnlint.md b/docs/bpmnlint.md
index 3034bf89..fe213c37 100644
--- a/docs/bpmnlint.md
+++ b/docs/bpmnlint.md
@@ -52,6 +52,11 @@ and `@miragon/rules` come with bpmn-cli and need no install.
 Keep the `moddleExtensions` entry. Without it camunda-compat sees no `camunda:` or `zeebe:`
 properties and reports them missing, as bpmnlint does in CI.
 
+bpmn-cli runs camunda-compat and the Miragon engine layer for every Camunda 7 / 8 file anyway, as
+its `W_C7_*` / `W_C8_*` findings ([Camunda 7 and Camunda 8](camunda.md#where-the-checks-come-from)).
+Extend them in the `.bpmnlintrc` when CI runs `npx bpmnlint` too: the same findings are then listed
+twice, once under their code and once under the rule name.
+
 ::: warning Untrusted repositories
 A `.bpmnlintrc` can name plugins of the repository, and `bpmn validate` then runs their code, as
 `npx bpmnlint` would. In a repository you do not trust, pass `--no-lint-config`. See
diff --git a/docs/camunda.md b/docs/camunda.md
index 48513f03..821859af 100644
--- a/docs/camunda.md
+++ b/docs/camunda.md
@@ -130,16 +130,151 @@ with the fix:
 $ bpmn set invoice.bpmn flow_amountOver1000ToApproveInvoice 'condition=${amount > 1000}'
 ...
 $ bpmn validate invoice.bpmn --strict
-W_C8_DEPLOY_EXPRESSION flow_amountOver1000ToApproveInvoice: The condition "${amount > 1000}" of sequence flow flow_amountOver1000ToApproveInvoice is no FEEL expression; Camunda 8 needs one starting with = and refuses the file  (`bpmn set <file> flow_amountOver1000ToApproveInvoice 'condition== amount > 1000'` (check the FEEL syntax: and / or, = for equality).)
+W_C8_DEPLOY_EXPRESSION flow_amountOver1000ToApproveInvoice: The condition "${amount > 1000}" of sequence flow flow_amountOver1000ToApproveInvoice is no FEEL expression; Camunda 8 needs one starting with = and refuses the file  (`bpmn set <file> flow_amountOver1000ToApproveInvoice condition==<expression>`.)
 platform: c8 (modeler:executionPlatform "Camunda Cloud") - 1 refused at deploy, 0 runtime, 0 practice finding(s)
 layout: ok
 valid, 1 warning(s)
 ```
 
+## Where the checks come from
+
+The `W_C7_*` / `W_C8_*` findings come from bpmnlint rules, loaded the first time a file of that
+engine is checked and run in one walk of the file by the engine entry point of
+`@miragon/bpmnlint-plugin-rules` (`lint`):
+
+- camunda-compat's rules for the file's `modeler:executionPlatformVersion` (`compatRules` of the
+  plugin's `camunda-7` / `camunda-8` entry; the latest without one; `--json` platform names the
+  version);
+- bpmn-cli's own rules for what camunda-compat leaves out, seventy for Camunda 7 and fifty for
+  Camunda 8 in `src/adapters/out/bpmnlint/engine/rules/c7|c8/`, written on the plugin's
+  `EngineRule` (`bpmn-cli/<rule>`). Each rule checks one thing, is named after what must hold
+  (`c7-message-needs-name`, `c8-error-code-unique`) and declares the code and severity of its
+  findings; several rules may share a code (the tables below list them by code). It gives its hint
+  with the finding;
+- among them the rules on content the engine's parser drops or rewrites, which read the file as
+  written: `c7-bpmn-attribute-known`, `c7-camunda-boolean-valid`, `c7-io-parameter-in-input-output`,
+  `c7-camunda-element-known` and `c8-bpmn-attribute-known`, the four `c8-publish-message-*` rules,
+  `c8-zeebe-element-placement`, `c8-zeebe-element-known`.
+
+bpmn-cli maps each camunda-compat rule to its code. The hint of a camunda-compat finding is built
+from where it points; its message is camunda-compat's. A rule's severity says what the finding
+means: `error` is deploy, `warn` runtime, `info` practice.
+
+Where camunda-compat reads a file differently than Camunda 8.9 (engine-checked), bpmn-cli drops its
+finding and follows the engine: white space only is a value for a job type, a message, signal,
+process or decision name, a result variable, a listener type, an error or escalation code and a link
+name; timer values are read as Camunda 8 parses them (`bpmn-cli/c8-timer-value-valid`); a
+`zeebe:jobPriorityDefinition` deploys on 8.9; a condition on a flow out of a gateway is the
+structural `W_CONDITION_IGNORED`; of two none start events or two link catch events with one name,
+the second is reported; an element with a doubled extension element reports the doubling only.
+
+Where camunda-compat is stricter than Camunda 8.9, bpmn-cli follows camunda-compat:
+
+- a flow without a condition next to conditional ones out of an exclusive or inclusive gateway
+  without a default is refused at deploy (`W_C8_EXCLUSIVE_GATEWAY`, reported on the flow), as is a
+  condition on a flow from an element that is no gateway (`W_C8_CONDITION_IGNORED`);
+- an error or escalation that a catch event references needs its code (`W_C8_DEPLOY_ERROR`,
+  `W_C8_DEPLOY_ESCALATION`);
+- execution listeners `beforeAll` and `cancel` are accepted from 8.10 on;
+- an intermediate catch or boundary event without an event definition is an unsupported element
+  (`W_C8_DEPLOY_UNSUPPORTED`);
+- a target an event-based gateway may not lead to is reported on the target, not the gateway
+  (`W_C8_DEPLOY_EVENT_GATEWAY`).
+
+bpmn-cli switches camunda-compat's `user-task-definition` off (a user task runs without a form),
+reports `zeebe-user-task` as practice and checks FEEL with its own rules
+(`bpmn-cli/c8-feel-expression-valid` and the `bpmn-cli/c8-*-needs-feel` rules, camunda-compat's
+`feel` is off).
+
+<details>
+<summary>Camunda 7: code and rules</summary>
+
+| code | rules |
+| --- | --- |
+| `W_C7_BAD_VALUE` | `bpmn-cli/c7-binding-known`, `bpmn-cli/c7-user-task-priority-valid`, `bpmn-cli/c7-variable-events-known`, `bpmn-cli/c7-camunda-boolean-valid` |
+| `W_C7_DANGLING_REF` | `bpmn-cli/c7-camunda-reference-resolves` |
+| `W_C7_DEPLOY_AD_HOC_SUBPROCESS` | `bpmn-cli/c7-ad-hoc-sub-process-no-flows`, `bpmn-cli/c7-ad-hoc-sub-process-no-multi-instance` |
+| `W_C7_DEPLOY_BAD_VALUE` | `bpmn-cli/c7-job-priority-valid`, `bpmn-cli/c7-decision-result-mapper-known` |
+| `W_C7_DEPLOY_BINDING_VERSION` | `bpmn-cli/c7-binding-needs-version` |
+| `W_C7_DEPLOY_CALLED_ELEMENT` | `bpmn-cli/c7-call-activity-one-called-element` |
+| `W_C7_DEPLOY_COMPLEX_GATEWAY` | `bpmn-cli/c7-complex-gateway-no-flows` |
+| `W_C7_DEPLOY_ERROR` | `bpmn-cli/c7-error-end-event-needs-error`, `bpmn-cli/c7-error-needs-code` |
+| `W_C7_DEPLOY_ESCALATION` | `bpmn-cli/c7-escalation-throw-needs-escalation`, `bpmn-cli/c7-escalation-needs-code`, `bpmn-cli/c7-escalation-boundary-host-allowed` |
+| `W_C7_DEPLOY_EVENT_DEFINITION` | `bpmn-cli/c7-timer-needs-one-time-value`, `bpmn-cli/c7-compensation-names-own-activity`, `bpmn-cli/c7-conditional-event-needs-condition` |
+| `W_C7_DEPLOY_EVENT_GATEWAY` | `bpmn-cli/c7-event-gateway-target-allowed`, `bpmn-cli/c7-event-gateway-branches-unique` |
+| `W_C7_DEPLOY_EXCLUSIVE_GATEWAY` | `bpmn-cli/c7-exclusive-gateway-needs-outgoing`, `bpmn-cli/c7-exclusive-gateway-default-no-condition`, `bpmn-cli/c7-exclusive-gateway-needs-conditions` |
+| `W_C7_DEPLOY_EXTENSION` | `bpmn-cli/c7-call-mapping-needs-source-and-target`, `bpmn-cli/c7-connector-needs-id`, `bpmn-cli/c7-io-parameter-needs-name`, `bpmn-cli/c7-form-field-needs-id-and-type`, `bpmn-cli/c7-field-needs-one-value` |
+| `W_C7_DEPLOY_EXTERNAL_TOPIC` | `bpmn-cli/c7-external-task-needs-topic` |
+| `W_C7_DEPLOY_FORM` | `bpmn-cli/c7-form-ref-no-form-key`, `bpmn-cli/c7-form-ref-needs-binding` |
+| `W_C7_DEPLOY_HISTORY_TTL` | `camunda-compat/history-time-to-live`, `bpmn-cli/c7-history-time-to-live-valid` |
+| `W_C7_DEPLOY_IMPLEMENTATION` | `bpmn-cli/c7-task-type-supported`, `bpmn-cli/c7-shell-task-needs-command`, `bpmn-cli/c7-shell-field-values-fixed`, `bpmn-cli/c7-task-needs-implementation` |
+| `W_C7_DEPLOY_INPUT_OUTPUT` | `bpmn-cli/c7-io-mapping-host-allowed`, `bpmn-cli/c7-output-mapping-host-allowed` |
+| `W_C7_DEPLOY_LINK` | `bpmn-cli/c7-link-catch-name-unique`, `bpmn-cli/c7-link-throw-needs-catch`, `bpmn-cli/c7-link-event-needs-name` |
+| `W_C7_DEPLOY_LISTENER` | `bpmn-cli/c7-listener-needs-implementation`, `bpmn-cli/c7-listener-event-known`, `bpmn-cli/c7-listener-script-needs-format`, `bpmn-cli/c7-timeout-listener-needs-timer-and-id` |
+| `W_C7_DEPLOY_MESSAGE` | `bpmn-cli/c7-message-subscription-unique`, `bpmn-cli/c7-message-event-needs-message`, `bpmn-cli/c7-message-needs-name` |
+| `W_C7_DEPLOY_MULTI_INSTANCE` | `bpmn-cli/c7-multi-instance-needs-cardinality-or-collection`, `bpmn-cli/c7-element-variable-needs-collection` |
+| `W_C7_DEPLOY_RESULT_VARIABLE` | `bpmn-cli/c7-result-variable-needs-expression` |
+| `W_C7_DEPLOY_SCHEMA` | `bpmn-cli/c7-bpmn-attribute-known` |
+| `W_C7_DEPLOY_SCRIPT` | `bpmn-cli/c7-script-task-needs-script` |
+| `W_C7_DEPLOY_SIGNAL` | `bpmn-cli/c7-signal-name-unique`, `bpmn-cli/c7-signal-subscription-unique`, `bpmn-cli/c7-signal-event-needs-signal`, `bpmn-cli/c7-signal-needs-name` |
+| `W_C7_DEPLOY_START_EVENT` | `bpmn-cli/c7-scope-needs-start-event`, `bpmn-cli/c7-start-event-unique` |
+| `W_C7_EXCLUSIVE_GATEWAY_DEFAULT` | `bpmn-cli/c7-exclusive-gateway-needs-default` |
+| `W_C7_FOREIGN_CONTENT` | `bpmn-cli/c7-no-zeebe-content` |
+| `W_C7_MESSAGE_NO_IMPLEMENTATION` | `bpmn-cli/c7-message-throw-needs-implementation` |
+| `W_C7_MISPLACED_ATTRIBUTE` | `bpmn-cli/c7-camunda-attribute-placement` |
+| `W_C7_MISPLACED_EXTENSION` | `bpmn-cli/c7-camunda-extension-placement`, `bpmn-cli/c7-io-parameter-in-input-output` |
+| `W_C7_TRANSACTION_NO_START` | `bpmn-cli/c7-transaction-needs-start-event` |
+| `W_C7_UNKNOWN_ATTRIBUTE` | `bpmn-cli/c7-camunda-attribute-known` |
+| `W_C7_UNKNOWN_ELEMENT` | `bpmn-cli/c7-camunda-element-known` |
+
+</details>
+
+<details>
+<summary>Camunda 8: code and rules</summary>
+
+| code | rules |
+| --- | --- |
+| `W_C8_BAD_VALUE` | `bpmn-cli/c8-job-retries-valid`, `bpmn-cli/c8-task-header-needs-key-and-value` |
+| `W_C8_CONDITION_IGNORED` | `camunda-compat/sequence-flow-condition` |
+| `W_C8_DEPLOY_AD_HOC_SUBPROCESS` | `camunda-compat/ad-hoc-sub-process`, `bpmn-cli/c8-ad-hoc-sub-process-no-start-or-end-event` |
+| `W_C8_DEPLOY_CALLED_ELEMENT` | `camunda-compat/called-element`, `camunda-compat/no-business-id`, `camunda-compat/no-propagate-all-parent-variables` |
+| `W_C8_DEPLOY_DUPLICATE_EXTENSION` | `bpmn-cli/c8-extension-element-unique` |
+| `W_C8_DEPLOY_ERROR` | `camunda-compat/error-reference`, `bpmn-cli/c8-error-catch-needs-static-code`, `bpmn-cli/c8-error-event-interrupting`, `bpmn-cli/c8-error-code-unique` |
+| `W_C8_DEPLOY_ESCALATION` | `camunda-compat/escalation-boundary-event-attached-to-ref`, `camunda-compat/escalation-reference` |
+| `W_C8_DEPLOY_EVENT_DEFINITION` | `camunda-compat/wait-for-completion`, `bpmn-cli/c8-event-sub-process-start-needs-trigger`, `bpmn-cli/c8-compensation-names-own-activity`, `bpmn-cli/c8-compensation-boundary-needs-association`, `bpmn-cli/c8-compensation-boundary-no-outgoing-flow`, `bpmn-cli/c8-conditional-event-needs-condition` |
+| `W_C8_DEPLOY_EVENT_GATEWAY` | `camunda-compat/event-based-gateway-target`, `bpmn-cli/c8-event-gateway-needs-two-branches`, `bpmn-cli/c8-event-gateway-target-allowed` |
+| `W_C8_DEPLOY_EXECUTABLE` | `camunda-compat/executable-process` |
+| `W_C8_DEPLOY_EXPRESSION` | `camunda-compat/feel`, `camunda-compat/feel-compatibility`, `camunda-compat/no-expression`, `bpmn-cli/c8-condition-needs-feel`, `bpmn-cli/c8-multi-instance-needs-feel`, `bpmn-cli/c8-script-needs-feel`, `bpmn-cli/c8-correlation-key-needs-feel`, `bpmn-cli/c8-feel-expression-valid` |
+| `W_C8_DEPLOY_EXTENSION` | `camunda-compat/agent-fromai-contract`, `camunda-compat/agent-tool-documentation`, `camunda-compat/agent-tool-output-key`, `camunda-compat/connector-properties`, `camunda-compat/duplicate-task-headers`, `camunda-compat/io-mapping`, `camunda-compat/no-binding-type`, `camunda-compat/no-job-priority-definition`, `camunda-compat/no-version-tag`, `camunda-compat/no-zeebe-properties`, `camunda-compat/secrets`, `camunda-compat/start-event-form`, `camunda-compat/start-event-form-embedded`, `camunda-compat/unresolvable-secret-reference`, `camunda-compat/variable-name`, `camunda-compat/version-tag`, `bpmn-cli/c8-linked-resource-needs-type`, `bpmn-cli/c8-binding-type-known`, `bpmn-cli/c8-version-tag-binding-needs-tag`, `bpmn-cli/c8-conditional-filter-events-known` |
+| `W_C8_DEPLOY_IMPLEMENTATION` | `camunda-compat/implementation`, `bpmn-cli/c8-thrown-message-needs-name`, `bpmn-cli/c8-publish-message-no-task-definition` |
+| `W_C8_DEPLOY_LINK` | `camunda-compat/link-event`, `bpmn-cli/c8-link-event-needs-name`, `bpmn-cli/c8-link-throw-needs-catch` |
+| `W_C8_DEPLOY_LISTENER` | `camunda-compat/before-all-execution-listener`, `camunda-compat/cancel-execution-listener`, `camunda-compat/duplicate-execution-listener-headers`, `camunda-compat/duplicate-execution-listeners`, `camunda-compat/execution-listener`, `camunda-compat/no-before-all-execution-listener`, `camunda-compat/no-cancel-execution-listener`, `camunda-compat/no-execution-listener-headers`, `camunda-compat/no-execution-listeners`, `camunda-compat/no-task-listeners`, `camunda-compat/task-listener`, `bpmn-cli/c8-sequence-flow-no-execution-listeners`, `bpmn-cli/c8-execution-listener-event-type-valid`, `bpmn-cli/c8-task-listeners-need-camunda-user-task`, `bpmn-cli/c8-task-listener-event-type-valid` |
+| `W_C8_DEPLOY_MESSAGE` | `camunda-compat/message-reference`, `camunda-compat/subscription`, `bpmn-cli/c8-message-start-needs-static-name`, `bpmn-cli/c8-message-subscription-unique`, `bpmn-cli/c8-publish-message-needs-message`, `bpmn-cli/c8-publish-message-needs-correlation-key` |
+| `W_C8_DEPLOY_MULTI_INSTANCE` | `camunda-compat/loop-characteristics` |
+| `W_C8_DEPLOY_SCHEMA` | `bpmn-cli/c8-bpmn-attribute-known` |
+| `W_C8_DEPLOY_SIGNAL` | `camunda-compat/signal-reference`, `bpmn-cli/c8-signal-start-needs-static-name`, `bpmn-cli/c8-signal-subscription-unique` |
+| `W_C8_DEPLOY_START_EVENT` | `bpmnlint/start-event-required`, `camunda-compat/no-multiple-none-start-events`, `bpmn-cli/c8-embedded-start-event-no-trigger`, `bpmn-cli/c8-sub-process-start-event-unique` |
+| `W_C8_DEPLOY_TIMER` | `camunda-compat/timer`, `bpmn-cli/c8-timer-value-valid` |
+| `W_C8_DEPLOY_UNSUPPORTED` | `camunda-compat/collapsed-subprocess`, `camunda-compat/element-type`, `camunda-compat/inclusive-gateway`, `camunda-compat/no-interrupting-event-subprocess`, `camunda-compat/no-loop`, `camunda-compat/no-signal-event-sub-process` |
+| `W_C8_DEPLOY_USER_TASK` | `camunda-compat/no-candidate-users`, `camunda-compat/no-priority-definition`, `camunda-compat/no-task-schedule`, `camunda-compat/no-zeebe-user-task`, `camunda-compat/priority-definition`, `camunda-compat/task-schedule`, `camunda-compat/user-task-definition`, `camunda-compat/user-task-form` |
+| `W_C8_EXCLUSIVE_GATEWAY` | `camunda-compat/sequence-flow-condition` |
+| `W_C8_EXPRESSION` | `bpmn-cli/c8-multi-instance-completion-needs-feel` |
+| `W_C8_FOREIGN_CONTENT` | `bpmn-cli/c8-no-camunda-7-content` |
+| `W_C8_JOB_WORKER_USER_TASK` | `camunda-compat/zeebe-user-task` |
+| `W_C8_MISPLACED_ATTRIBUTE` | `bpmn-cli/c8-zeebe-attribute-placement` |
+| `W_C8_MISPLACED_EXTENSION` | `bpmn-cli/c8-zeebe-extension-placement`, `bpmn-cli/c8-input-mapping-placement`, `bpmn-cli/c8-zeebe-element-placement` |
+| `W_C8_STANDARD_LOOP` | `camunda-compat/loop-characteristics` |
+| `W_C8_UNKNOWN_ATTRIBUTE` | `bpmn-cli/c8-zeebe-attribute-known` |
+| `W_C8_UNKNOWN_ELEMENT` | `bpmn-cli/c8-zeebe-element-known` |
+| `W_C8_UNSUPPORTED_IMPLEMENTATION` | `bpmn-cli/c8-publish-message-unsupported` |
+
+</details>
+
 ## bpmnlint and camunda-compat
 
-camunda-compat comes with bpmn-cli and runs from the project's `.bpmnlintrc`. Its findings overlap
-with the `W_C7_*` / `W_C8_*` rules; both are listed. Setup: [bpmnlint](bpmnlint.md).
+A project's `.bpmnlintrc` runs on top, as an advisory validator ([bpmnlint](bpmnlint.md)). When it
+extends camunda-compat or the Miragon engine layers too, their findings are listed twice: once
+under their bpmn-cli code, once under the rule name of the `.bpmnlintrc`.
 
 ## Next steps
 
diff --git a/docs/library.md b/docs/library.md
index cc860df4..6ecd3886 100644
--- a/docs/library.md
+++ b/docs/library.md
@@ -120,14 +120,14 @@ validator like the CLI ([bpmnlint](bpmnlint.md)). Plugins the project installed
 
 A host that keeps a parsed model between calls uses the pipeline on a `Doc`:
 `Doc.fromXml(xml)`, then `mutateDoc(doc, ops, opts)`, `layoutDoc`, `checkDoc`. They never write.
-Every other part (views, metrics, the diagram commands, the platform profile) is exported too:
+Every other part (views, metrics, the diagram commands, the platform detection) is exported too:
 `runOps(doc, commands)` runs commands on a `Doc`, `parseOps(json)` reads the ops JSON into
 `EditCommand`s.
 
-::: warning Load the profile rules before runProfile
-`runProfile` and `validateDoc(doc, { platform })` are synchronous: call `await loadProfiles()`
-once before them, otherwise they throw `E_PROFILE_NOT_LOADED` on a Camunda 7 / 8 document.
-`mutateDoc`, `checkDoc` and the in-memory API load the rules themselves.
+::: tip The Camunda 7 / 8 rules run in the async calls
+`validateDoc(doc)` is the structural validation and lint alone. The engine rules (`W_C7_*` /
+`W_C8_*`) are bpmnlint rules that load on demand; `checkDoc`, `mutateDoc` and the in-memory API run
+them.
 :::
 
 ### bpmnlint as a validator
@@ -191,17 +191,24 @@ await applyToXml(xml, ops, {
 
 ## Browser bundles
 
-The core runs in a browser; CI fails on anything Node-only. The Camunda 7 and 8 rules are
-chunks of their own, fetched the first time a document of that platform is validated
-(`loadProfile('c7')` prefetches). PNG rendering and bpmnlint live in `@miragon/bpmn-cli/node`
-only.
+The core runs in a browser; CI fails on anything Node-only. The Camunda 7 and 8 rules (bpmnlint,
+camunda-compat and the Miragon engine layer) are chunks of their own, fetched the first time a
+document of that platform is validated. PNG rendering and the project's `.bpmnlintrc` live in
+`@miragon/bpmn-cli/node` only.
 
 | bundle (minified / gzip) | size |
 | --- | ---: |
-| everything `@miragon/bpmn-cli` exports | 1103.3 / 346.7 KB |
-| `applyToXml` only | 799.8 / 250.3 KB |
-| Camunda 7 rules, on demand | 64.4 / 18.8 KB |
-| Camunda 8 rules, on demand | 88.3 / 25.2 KB |
+| everything `@miragon/bpmn-cli` exports | 1067.9 / 335.7 KB |
+| `applyToXml` only | 775.7 / 242.4 KB |
+| Camunda 7 rules, on demand | 118.7 / 34.3 KB |
+| Camunda 8 rules, on demand | 365.3 / 101.8 KB |
+| engine run (bpmnlint and the mapping to `W_C7_*` / `W_C8_*`), on demand | 26.9 / 10.0 KB |
+
+::: warning No Camunda 7 / 8 call at the top level of the entry module
+The rule chunks share packages with the core (min-dash), which a bundler puts into the entry chunk:
+a rule chunk then imports the entry chunk. An entry module that awaits a Camunda 7 / 8 call at its
+top level waits for itself. Make the first call from a function the entry module calls.
+:::
 
 `node tools/iso/check.mjs --table` prints the current sizes.
 
diff --git a/docs/testing.md b/docs/testing.md
index ebf1a0e1..3303619b 100644
--- a/docs/testing.md
+++ b/docs/testing.md
@@ -380,14 +380,16 @@ npx vitest run test/e2e/isomorphic.test.ts
   not compile. It prints the minified and gzipped sizes, split like a host's
   bundler would split them: the initial chunks of the whole entry and of an
   `applyToXml`-only entry, and the chunks loaded on demand (the Camunda 7
-  rules, the Camunda 8 rules with the FEEL, timer and schema-text checks).
-  It fails when a rule module
-  (`dist/platform/profiles/`: the profiles, their base, utils and checks) is in the initial chunks of
-  either entry, naming it; when a rule module imports a module the entry
+  and the Camunda 8 entry of `@miragon/bpmnlint-plugin-rules`, and bpmn-cli's
+  engine run in `src/adapters/out/bpmnlint/engine/run/` with bpmnlint's linter).
+  It fails when a rule module is in the initial chunks of
+  either entry, naming it; when a module of the engine run imports a module the entry
   loads, naming both (Rollup / Vite would put that module into the host's
   entry chunk and make the rule chunk import the entry chunk back: a host
   whose entry module awaits a Camunda 7 / 8 call at top level would hang;
-  the rules get the core helpers from `src/domain/validation/profiles/rule-kit.ts`); and
+  the engine run gets the core helpers from `src/adapters/out/bpmnlint/engine-kit.ts`;
+  the plugin's packages share min-dash with the core, so a host must not await
+  such a call at top level, [library.md](library.md#browser-bundles)); and
   when a size is over its budget in
   `tools/iso/budget.json` (KB = 1024 bytes; set to the measured size plus
   about 2 %: raise one only in the change that needs it, with the reason in
@@ -401,29 +403,28 @@ npx vitest run test/e2e/isomorphic.test.ts
   `process` read, and runs the bundle in a `vm` context without any Node
   global: `applyToXml` (also with host validators, and a no-op that must
   come back `unchanged`), `layoutXml` (both engines), `newXml`,
-  `validateXml` with the Camunda 7 and the Camunda 8 profile and with host
+  `validateXml` with the Camunda 7 and the Camunda 8 rules and with host
   validators, `showXml`, `findXml` and `metricsXml` must give there exactly what they
   give in Node, and `renderSvg` the same SVG. It also checks that the inlined
   Camunda 7 descriptor (`src/domain/document/vendor/camunda-descriptor.ts`) equals the
   installed `camunda-bpmn-moddle`; regenerate it with
   `node tools/gen-camunda-descriptor.mjs`.
 - The same file bundles `src/index.ts` as an ESM split bundle (what Vite or
-  esbuild make of the `import()` in `src/domain/validation/profiles/PlatformProfiles.ts`), writes a
+  esbuild make of the `import()` in `src/adapters/out/bpmnlint/BpmnlintEngineLint.ts`), writes a
   fresh copy per case, loads it with Node's own loader and records which
   chunk is evaluated: a plain model (also with a host validator, whose error, pre-existing
   error and covered lint warning come out like Node's) and
   `platform: 'none'` load no profile chunk, a Camunda 7 file only the Camunda 7 rules, a
   Camunda 8 file only the Camunda 8 rules; a batch that turns a plain file
   into a Camunda 7 / 8 file loads them after the ops and reports the added
-  findings of 0.4.0; `runProfile` without loaded rules throws
-  `E_PROFILE_NOT_LOADED`; a missing chunk rejects with `E_PROFILE_LOAD`
+  findings; `validateDoc` loads no rule chunk; a missing chunk rejects with `E_PROFILE_LOAD`
   (its hint says a browser may keep the failed fetch until the page
   reloads) and a later call imports it again, which in Node loads it. It
   also checks that the bundle's entry chunk is the requested one and that
   the rule modules (and so their chunks) import nothing the entry loads.
-- Test files that call `runProfile` or `validateDoc(doc, { platform })`
-  directly load the rules first (`await loadProfiles()` at the top); the
-  pipeline tests do not, so they run the on-demand path.
+- Tests that need the engine findings of a document on their own use
+  `runProfile` of `test/helpers/engine.ts`; the pipeline tests run the
+  on-demand path.
 - `test/e2e/api.test.ts` checks that the in-memory API gives what the CLI writes
   and prints for the same input.
 
@@ -638,32 +639,23 @@ flow between two lanes).
 
 ## Engine checks (Camunda 7)
 
-The Camunda 7 profile of `bpmn validate` (`src/domain/validation/profiles/C7Profile.ts`) states for
-every rule what the engines do. `test/domain/validation/c7-profile.test.ts` holds one synthetic
-model per rule (82 models) with the expected codes and the engine verdict;
-by default it checks only the profile. To re-check the verdicts against live
-engines (REST, no authentication), list their REST roots:
+The Camunda 7 rules of `bpmn validate` are bpmnlint rules: camunda-compat's `history-time-to-live`
+and the `c7-*` rules of `@miragon/bpmnlint-plugin-rules`, whose specs hold one model per rule with
+the engines' verdict ([Camunda 7 and Camunda 8](camunda.md#where-the-checks-come-from)). bpmn-cli
+tests what it adds: the code and the hint of each finding (`src/adapters/out/bpmnlint/engine/`),
+and the checks it makes itself. `test/adapters/out/bpmnlint/engine-codes.test.ts` fails when a rule
+of a camunda-compat version or of the Miragon engine layer has no code.
+`test/e2e/camunda7-rules.test.ts` holds synthetic models with the engines' verdict (events with
+several event definitions, attributes BPMN does not define) and runs their hints through the CLI. To
+re-check the verdicts against live engines (REST, no authentication), list their REST roots:
 
 ```
-BPMN_C7_ENGINES=http://localhost:8080/engine-rest[,http://host:port/engine-rest ...] npx vitest run test/domain/validation/c7-profile.test.ts
+BPMN_C7_ENGINES=http://localhost:8080/engine-rest[,http://host:port/engine-rest ...] npx vitest run test/e2e/camunda7-rules.test.ts
 ```
 
-Each model is deployed to every listed engine, the test asserts the engine's
-verdict and that a deploy-severity finding (`W_C7_DEPLOY_*`) is reported
-exactly for the refused ones, and every deployment is deleted again. The
-verdicts were identical on Camunda 7.24.0, CIB seven 2.2.0 and Operaton 2.1.5
-(341 tests with three engines). The follow-up rounds add their own models with
-engine verdicts the same way: `test/domain/validation/c7-profile-rules.test.ts` (deploy
-rules the engines disagreed with or the profile missed; `operaton` marks a
-verdict only Operaton gives, the engine is told apart by
-`/telemetry/data`), `test/e2e/camunda7-rules.test.ts` (events with
-several event definitions, attributes BPMN does not define) and
-`test/domain/validation/c7-schema-rules.test.ts` (schema rules on every event definition,
-start events of transactions / empty sub-processes / ad-hoc sub-processes;
-`run` also starts the process and checks that it fails or runs, and the
-second-start hint is followed and run). Run all four with the same
-`BPMN_C7_ENGINES`; `--no-file-parallelism` keeps two files from deploying
-one message name at the same time.
+Each model is deployed to every listed engine, the test asserts the engine's verdict and that a
+deploy-severity finding (`W_C7_DEPLOY_*`) is reported exactly for the refused ones, and every
+deployment is deleted again.
 
 The other C7 regression tests (`test/domain/editing/c7-semantic.test.ts`,
 `test/domain/editing/c7-ext-structure.test.ts`, `test/e2e/camunda7.test.ts`,
@@ -677,27 +669,18 @@ element by element.
 
 ## Engine checks (Camunda 8)
 
-The Camunda 8 profile (`src/domain/validation/profiles/C8Profile.ts`) states for every rule what
-Camunda 8.9 does; placement and known names come from the Zeebe descriptor
+The Camunda 8 rules are camunda-compat's config for the file's version and the `c8-*` rules of
+`@miragon/bpmnlint-plugin-rules` (the FEEL check with its 762 engine verdicts lives there). bpmn-cli
+makes the checks a typed parse cannot see itself: unknown zeebe elements, unprefixed attributes
+and `zeebe:publishMessage`; placement and known names come from the Zeebe descriptor
 (`src/domain/document/vendor/ZeebeDescriptor.ts`, the inlined `zeebe-bpmn-moddle`; regenerate with
-`node tools/gen-camunda-descriptor.mjs`, `test/e2e/isomorphic.test.ts` fails
-while it is stale). `test/domain/validation/c8-profile.test.ts` holds one synthetic model per
-rule (151 models) with the expected codes and Camunda 8's verdict, the timer
-and FEEL value checks with the values they were checked on, and the
-`validate` output; `test/domain/editing/c8-ops.test.ts` covers `set` / `ext` / `retype` /
-`show` in Camunda 8 files and runs the profile's hints through the real CLI
-until a refused model has no deploy finding left; `test/domain/validation/c8-feel-and-deploy.test.ts`
-checks the FEEL syntax check against `test/fixtures/c8/feel-verdicts.json`
-(762 synthetic expressions with the verdict of Camunda 8.9.22, one per line:
-add a new expression with the verdict you got from the engine) and the
-schema-text, white-space, `refAs` and subscription rules;
-`test/domain/validation/c8-values.test.ts` holds the timer range, cron field and
-xsd:boolean models (27, with the verdict) and the duplicate id. By default they
-check the CLI only. To re-check against a live Camunda 8 (REST v2, no
-authentication), name its v2 root:
+`node tools/gen-camunda-descriptor.mjs`, `test/e2e/isomorphic.test.ts` fails while it is stale).
+`test/domain/editing/c8-ops.test.ts` covers `set` / `ext` / `retype` / `show` in Camunda 8 files and
+runs the hints through the real CLI until a refused model has no deploy finding left. To re-check
+against a live Camunda 8 (REST v2, no authentication), name its v2 root:
 
 ```
-BPMN_C8_ENGINE=http://localhost:8088/v2 npx vitest run test/domain/validation/c8-profile.test.ts test/domain/editing/c8-ops.test.ts test/domain/validation/c8-feel-and-deploy.test.ts test/domain/validation/c8-values.test.ts
+BPMN_C8_ENGINE=http://localhost:8088/v2 npx vitest run test/domain/editing/c8-ops.test.ts
 ```
 
 Each model is deployed (`POST /v2/deployments`), the test asserts that the
diff --git a/package-lock.json b/package-lock.json
index 9837b946..69542f1e 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -9,10 +9,12 @@
       "version": "0.8.0",
       "license": "MIT",
       "dependencies": {
-        "@miragon/bpmnlint-plugin-rules": "0.19.0",
+        "@miragon/bpmnlint-plugin-rules": "file:miragon-bpmnlint-plugin-rules-0.19.0.tgz",
         "@resvg/resvg-wasm": "2.6.2",
         "bpmn-moddle": "^10.2.0",
         "bpmnlint": "11.15.0",
+        "bpmnlint-plugin-camunda-compat": "2.61.1",
+        "bpmnlint-utils": "1.1.1",
         "commander": "^15.0.0",
         "moddle": "^8.2.1"
       },
@@ -792,8 +794,8 @@
     },
     "node_modules/@miragon/bpmnlint-plugin-rules": {
       "version": "0.19.0",
-      "resolved": "https://registry.npmjs.org/@miragon/bpmnlint-plugin-rules/-/bpmnlint-plugin-rules-0.19.0.tgz",
-      "integrity": "sha512-jjCIu2qL3gDfg82HzVKZEoCfKZVWwaLNHyRP5JVwD6nq5VgHG0ZOcXFwD6ROoueRqjn3NI2nbTViK4mv7PLZeQ==",
+      "resolved": "file:miragon-bpmnlint-plugin-rules-0.19.0.tgz",
+      "integrity": "sha512-+GDa7Au3fjmfSdmooMMKBdxXeNmhbjBL7Jckt8JkNmjtWdaXLVVDoKUTphXeqJoSBLMa/5mnDOQXxZ5AlsbNxw==",
       "license": "MIT",
       "workspaces": [
         "docs"
diff --git a/package.json b/package.json
index 6e3c3f19..19c8cf60 100644
--- a/package.json
+++ b/package.json
@@ -67,10 +67,12 @@
     "architecture": "depcruise src --config .dependency-cruiser.cjs"
   },
   "dependencies": {
-    "@miragon/bpmnlint-plugin-rules": "0.19.0",
+    "@miragon/bpmnlint-plugin-rules": "file:miragon-bpmnlint-plugin-rules-0.19.0.tgz",
     "@resvg/resvg-wasm": "2.6.2",
     "bpmn-moddle": "^10.2.0",
     "bpmnlint": "11.15.0",
+    "bpmnlint-plugin-camunda-compat": "2.61.1",
+    "bpmnlint-utils": "1.1.1",
     "commander": "^15.0.0",
     "moddle": "^8.2.1"
   },
diff --git a/src/adapters/in/report/command-report.ts b/src/adapters/in/report/command-report.ts
index a18efd83..a97fafc7 100644
--- a/src/adapters/in/report/command-report.ts
+++ b/src/adapters/in/report/command-report.ts
@@ -7,7 +7,7 @@ import type { DiagramCommandResult } from '../../../domain/diagram/commands/Diag
 import type { Finding } from '../../../domain/document/Finding.js';
 import type { CheckResult } from '../../../application/port/in/ValidateDocumentUseCase.js';
 import type { LayoutStatus } from '../../../domain/diagram/types.js';
-import type { PlatformSummary } from '../../../domain/validation/profiles/PlatformProfiles.js';
+import type { PlatformSummary } from '../../../domain/validation/PlatformCheck.js';
 import type { Change } from '../../../domain/document/ChangeSet.js';
 import type { ValidationResult } from '../../../domain/validation/StructuralValidator.js';
 import type { ValidatorReport } from '../../../domain/validation/validators.js';
diff --git a/src/adapters/in/report/guide.ts b/src/adapters/in/report/guide.ts
index 39c35c66..d63cb54c 100644
--- a/src/adapters/in/report/guide.ts
+++ b/src/adapters/in/report/guide.ts
@@ -27,8 +27,7 @@ const USAGE_AND_IO_ERRORS: ErrorDoc[] = [
   { code: 'E_FILE_EXISTS', meaning: '`bpmn new` refuses to overwrite an existing file.', fix: 'Choose another name, or pass --force to overwrite.' },
   { code: 'E_INVALID_XML', meaning: 'The --xml snippet of `ext add` could not be parsed.', fix: 'Pass one well-formed element with declared prefixes, e.g. --xml \'<zeebe:taskDefinition type="x"/>\', or use <prefix:type> attr=value instead.' },
   { code: 'E_RENDER', meaning: '`bpmn render` (renderPng) could not rasterise the image: the PNG rasteriser (@resvg/resvg-wasm) failed to load or failed on this drawing (exit 4; never a process abort); or nothing on the plane can be drawn because every shape and connection has broken coordinates (not a number, beyond ±1,000,000 px, a negative size).', fix: 'Write the SVG instead (`--format svg`), or render a smaller part; report the file if it keeps failing. Broken coordinates: `bpmn layout <file>` draws the model again.' },
-  { code: 'E_PROFILE_LOAD', meaning: 'Library use (exit 4): the Camunda 7 or Camunda 8 profile rules, which load on demand (a chunk of their own in a browser bundle), could not be loaded; the call rejected before a result existed and nothing was written. `details.platform` names the platform.', fix: 'Check that the chunk is served next to the entry chunk (base URL, network, content security policy). The library does not cache the failure: a later call imports the chunk again, which loads it in Node; a browser may keep the failed module fetch until the page reloads (Chrome does), so reload the page there after fixing the cause. Prefetch with `loadProfile(platform)` when a file is opened to find out early.' },
-  { code: 'E_PROFILE_NOT_LOADED', meaning: 'Library use (exit 1): `runProfile` or `validateDoc(doc, { platform })` ran on a Camunda 7 / 8 document whose profile rules are not loaded yet (they load on demand; the async API, `applyToXml`, `validateXml`, `mutateDoc`, `checkDoc`, loads them itself). `details.platform` names the platform.', fix: '`await loadProfile(platform)` (or `await loadProfiles()` for both) once before the synchronous calls.' },
+  { code: 'E_PROFILE_LOAD', meaning: 'Library use (exit 4): the Camunda 7 or Camunda 8 engine rules (bpmnlint with camunda-compat and the Miragon engine layer), which load on demand (a chunk of their own in a browser bundle), could not be loaded; the call rejected before a result existed and nothing was written. `details.platform` names the platform.', fix: 'Check that the chunk is served next to the entry chunk (base URL, network, content security policy). The library does not cache the failure: a later call imports the chunk again, which loads it in Node; a browser may keep the failed module fetch until the page reloads (Chrome does), so reload the page there after fixing the cause.' },
 ];
 
 /** Codes of ids and their lookup. */
@@ -159,7 +158,7 @@ const LINT_FINDINGS: ErrorDoc[] = [
 const VENDOR_CONTENT_ERRORS: ErrorDoc[] = [
   { code: 'E_WRONG_HOST', meaning: '`set`: a known camunda attribute was given to an element that does not carry it: the Camunda descriptor places it on a nested element (the event definition, the multi-instance loop or the condition expression), it is a process attribute given to a participant, or a `<slot>.<attr>` the nested element cannot carry (loop.camunda:collection on a standard loop). Camunda 8: a zeebe attribute of an extension element (zeebe:assignee), or a zeebe:subscription / zeebe:correlationKey for an element that waits for no message (with a message, both go to that message\'s zeebe:subscription, with a note).', fix: 'Use the prefixed key from the hint, e.g. `bpmn set <file> <id> definition.camunda:errorCodeVariable=code`, `bpmn set <file> <id> \'loop.camunda:collection=${items}\'`, `bpmn set <file> <flowId> condition.camunda:resource=<uri>`; set the trigger it needs first (trigger=error ...), loop=parallel for multi-instance attributes, or set it on the process id.' },
   { code: 'E_NO_NESTED_ELEMENT', meaning: '`set`: a definition. or condition. key names a nested element that does not exist (an event without trigger has no event definition; a flow or conditional event without condition has no condition expression), or a `definition[<n>]` / `definition[<trigger>]` selector matches no event definition.', fix: 'Give the event a trigger in the same command (`bpmn set <file> <id> trigger=<t> definition.<key>=<value>`) or set condition=<expr> / when=<expr> first; a script resource condition is created directly with `condition.camunda:resource=<uri> language=<lang>`. (loop. never needs this: a parallel multi-instance loop is created.)' },
-  { code: 'E_AMBIGUOUS_NESTED', meaning: '`set` / `ext` with `definition.` on an event that has several event definitions: it does not say which one. The message lists them as definition[<n>] = <type> <id>.', fix: 'Name one by position (0-based) or by trigger: `bpmn set <file> <id> \'definition[1].<key>=<value>\'` or `\'definition[timer].<key>=<value>\'` (quote the brackets in a shell; `ext` takes the same prefix), or keep a single definition: `bpmn set <file> <id> trigger=<t>` (the engines act on one only, see W_C7_MULTIPLE_EVENT_DEFINITIONS).' },
+  { code: 'E_AMBIGUOUS_NESTED', meaning: '`set` / `ext` with `definition.` on an event that has several event definitions: it does not say which one. The message lists them as definition[<n>] = <type> <id>.', fix: 'Name one by position (0-based) or by trigger: `bpmn set <file> <id> \'definition[1].<key>=<value>\'` or `\'definition[timer].<key>=<value>\'` (quote the brackets in a shell; `ext` takes the same prefix), or keep a single definition: `bpmn set <file> <id> trigger=<t>` (the engines act on one only).' },
   { code: 'E_DUPLICATE_EXTENSION', meaning: '`ext add` would create a second single-instance vendor element (camunda:inputOutput, formData, connector, failedJobRetryTimeCycle, properties; nested: connector/connectorId, formField/validation, ...; zeebe:ioMapping, taskDefinition, ...) and merging is ambiguous: an attribute or value conflicts, or the element already holds several. Camunda 7 engines refuse duplicates (ENGINE-01009).', fix: 'Pass --replace to replace it as a whole, or remove the old one first (`bpmn ext remove <file> <id> <selector>`, see `bpmn ext list <file> <id>`).' },
   { code: 'E_AMBIGUOUS_EXTENSION', meaning: 'An `ext add` path step matches several vendor elements, or an `ext remove` predicate matches items in several places.', fix: 'Name one with [attr=value] or [index] in the path, e.g. \'camunda:formField[id=amount]/camunda:validation\'; the error lists the candidate paths.' },
   { code: 'E_AMBIGUOUS_BRANCH', meaning: '`remove --with-branch` on a node that several paths reach (2+ incoming flows): its downstream is not the branch of one path.', fix: 'Remove the branch from a node only one path reaches (the first node after the split), or remove the node alone (`--bridge-all` reconnects the paths to its successor).' },
@@ -170,9 +169,10 @@ const VENDOR_CONTENT_ERRORS: ErrorDoc[] = [
   { code: 'W_PROPERTY_INAPPLICABLE', meaning: '`retype`: camunda attributes or extension elements of the element are not allowed on the new kind by the Camunda descriptor (camunda:assignee on a serviceTask, camunda:topic on a userTask, camunda:taskListener outside a userTask). They are kept (nothing was dropped) but have no effect.', fix: 'Remove them with the commands in the hint (`bpmn set <file> <id> camunda:assignee=`, `bpmn ext remove <file> <id> camunda:taskListener`), set what the new kind needs, or retype back.' },
 ];
 
-/** Platform profile findings, from validate and the ones a mutation introduces. */
+/** Camunda 7 / 8 findings, from validate and the ones a mutation introduces. */
 const PLATFORM_PROFILE_FINDINGS: ErrorDoc[] = [
-  { code: 'W_C7_*', meaning: 'A finding of the Camunda 7 profile, which runs in Camunda 7 files (detected from modeler:executionPlatform or the camunda namespace; CIB seven and Operaton included; `validate --platform c7|c8|none|auto`). A file that uses Operaton\'s own namespace (operaton:*) is read the way Operaton reads it: operaton:* first, camunda:* as the fallback (Camunda 7 and CIB seven ignore operaton:*); `--json` platform says `"operaton": true` and the detail line says so. Every finding has a severity (JSON field `severity`): deploy = the engines (Camunda 7.24, CIB seven 2.2, Operaton 2.1) refuse the file (codes W_C7_DEPLOY_*); runtime = it deploys but the setting is ignored or fails when it runs; practice = it works, the engine logs a warning. Only executable processes are checked, without the content of ad-hoc sub-processes (the engines skip both); the schema rules cover the whole file (W_C7_DEPLOY_SCHEMA, and the event definitions of W_C7_DEPLOY_EVENT_DEFINITION / W_C7_DEPLOY_LINK). A mutation reports only the findings it introduced.', fix: 'Fix every W_C7_DEPLOY_* finding before deploying; the hint of each finding names the exact `bpmn set` / `bpmn ext` / `bpmn add|remove|move` command. `bpmn validate <file>` lists all of them.' },
+  { code: 'W_C7_*', meaning: 'A finding of the Camunda 7 rules (camunda-compat for the file\'s modeler:executionPlatformVersion, else the latest, and the c7-* rules of @miragon/bpmnlint-plugin-rules, mapped to these codes), which run in Camunda 7 files (detected from modeler:executionPlatform or the camunda namespace; CIB seven and Operaton included; `validate --platform c7|c8|none|auto`). A file that uses Operaton\'s own namespace (operaton:*) is read the way Operaton reads it: operaton:* first, camunda:* as the fallback (Camunda 7 and CIB seven ignore operaton:*); `--json` platform says `"operaton": true` and the detail line says so. Every finding has a severity (JSON field `severity`): deploy = the engines (Camunda 7.24, CIB seven 2.2, Operaton 2.1) refuse the file (codes W_C7_DEPLOY_*); runtime = it deploys but the setting is ignored or fails when it runs; practice = it works, the engine logs a warning. Only executable processes are checked, without the content of ad-hoc sub-processes (the engines skip both); the schema rules cover the whole file (W_C7_DEPLOY_SCHEMA, and the event definitions of W_C7_DEPLOY_EVENT_DEFINITION / W_C7_DEPLOY_LINK). A mutation reports only the findings it introduced.', fix: 'Fix every W_C7_DEPLOY_* finding before deploying; the hint of each finding names the exact `bpmn set` / `bpmn ext` / `bpmn add|remove|move` command. `bpmn validate <file>` lists all of them.' },
+  { code: 'W_C7_ENGINE_RULE', meaning: 'A finding of a Camunda 7 engine rule bpmn-cli has no code for yet (a rule a newer camunda-compat adds); the message names what the engine refuses or ignores.', fix: 'Fix what the message names; report the rule so it gets its own code.' },
   { code: 'W_C7_DEPLOY_HISTORY_TTL', meaning: 'An executable process has no camunda:historyTimeToLive, or a value that is not a number of days or P<n>D; Camunda 7.20+, CIB seven and Operaton refuse to deploy it (ENGINE-12018).', fix: '`bpmn set <file> <processId> camunda:historyTimeToLive=180` (`bpmn new <file> --target camunda7` writes 180).' },
   { code: 'W_C7_DEPLOY_IMPLEMENTATION', meaning: 'A service, send or business rule task (or a message throw / end event definition) has no implementation (class, delegateExpression, expression, type=external or shell, connector; decisionRef for business rule tasks), camunda:type is neither external nor shell ("mail" included: the standard distributions cannot load it), or a shell task has no camunda:field command, an expression field, or wait / redirectError / cleanEnv other than true / false; the engines refuse the file.', fix: '`bpmn set <file> <id> camunda:type=external camunda:topic=<topic>` (or camunda:delegateExpression=${...}; `definition.camunda:...` for message events); a shell task: `bpmn ext add <file> <id> camunda:field name=command stringValue=<command>`.' },
   { code: 'W_C7_DEPLOY_EXTERNAL_TOPIC', meaning: 'camunda:type=external without camunda:topic; the engines refuse the file.', fix: '`bpmn set <file> <id> camunda:topic=<topic>`.' },
@@ -182,7 +182,6 @@ const PLATFORM_PROFILE_FINDINGS: ErrorDoc[] = [
   { code: 'W_C7_DEPLOY_FORM', meaning: 'camunda:formRef without a formRefBinding of deployment / latest / version, or formKey and formRef together; the engines refuse the file.', fix: '`bpmn set <file> <id> camunda:formRefBinding=latest` or `bpmn set <file> <id> camunda:formKey=`.' },
   { code: 'W_C7_DEPLOY_BAD_VALUE', meaning: 'A value the engines refuse at deploy: mapDecisionResult not singleEntry / singleResult / collectEntries / resultList; jobPriority or (process / external) taskPriority not an integer or expression.', fix: '`bpmn set <file> <id> camunda:mapDecisionResult=singleEntry` or `bpmn set <file> <id> camunda:jobPriority=50`.' },
   { code: 'W_C7_DEPLOY_MULTI_INSTANCE', meaning: 'A multi-instance activity has neither loop cardinality nor camunda:collection (also when the collection sits on the activity instead of the loop), an empty cardinality, or an elementVariable without collection; the engines refuse the file.', fix: '`bpmn set <file> <id> \'loop.camunda:collection=${items}\' loop.camunda:elementVariable=item` (or cardinality=3).' },
-  { code: 'W_C7_DEPLOY_DUPLICATE_EXTENSION', meaning: 'A second camunda:inputOutput / connector / connectorId / formData / failedJobRetryTimeCycle where the engine reads it; the engines refuse the file (ENGINE-01009).', fix: 'Merge them into one: `bpmn ext list <file> <id> --json`, then `bpmn ext add <file> <id> camunda:<type> --replace --xml \'...\'`.' },
   { code: 'W_C7_DEPLOY_INPUT_OUTPUT', meaning: 'camunda:inputOutput on a start or boundary event, a gateway or an event sub-process, or output parameters on an end event or a multi-instance activity; the engines refuse the file.', fix: '`bpmn ext remove <file> <id> camunda:inputOutput` (move the mapping to the next activity).' },
   { code: 'W_C7_DEPLOY_LISTENER', meaning: 'An execution or task listener without implementation (class / expression / delegateExpression / script) or event, with an event the engine does not know, a script without scriptFormat, or a timeout task listener without timer or without id; the engines refuse the file.', fix: 'Rebuild just that listener (the hint has both commands; --replace would remove its siblings): `bpmn ext remove <file> <id> \'camunda:executionListener[event=finish]\'`, then e.g. `bpmn ext add <file> <id> camunda:executionListener event=start delegateExpression=${...}`.' },
   { code: 'W_C7_DEPLOY_EXTENSION', meaning: 'Invalid content of camunda extension elements: camunda:in/out without source and target (and without variables / businessKey), a parameter without name, a form field without id or with a type other than string / long / boolean / date / enum, a connector without connectorId, a camunda:field without a value (or with stringValue and camunda:string together) where the engines read fields (class / delegateExpression tasks, message throws and listeners, shell tasks); the engines refuse the file.', fix: '`bpmn ext list <file> <id> --json`, then re-add the item complete (`bpmn ext add <file> <id> camunda:field name=a stringValue=b`: keyed items replace the old one); a repeatable item without key is removed by its selector and added again (the hint has both commands).' },
@@ -191,30 +190,26 @@ const PLATFORM_PROFILE_FINDINGS: ErrorDoc[] = [
   { code: 'W_C7_DEPLOY_SIGNAL', meaning: 'A signal event without signalRef or with a nameless signal, two root signals with one name, or two subscriptions to one signal name in one engine scope (two signal start events, two boundary events of one host, an event sub-process start and a boundary event on its sub-process); the engines refuse the file.', fix: '`bpmn set <file> <id> signal=<SignalName>`, or rename the signal.' },
   { code: 'W_C7_DEPLOY_ERROR', meaning: 'An error end event without errorRef, or whose bpmn:Error has no errorCode; the engines refuse the file.', fix: '`bpmn set <file> <id> error=<ErrorName> errorCode=<CODE>`.' },
   { code: 'W_C7_DEPLOY_ESCALATION', meaning: 'An escalation throw / end event without escalationRef or escalationCode, or an escalation boundary event on something other than a sub-process, call activity or user task; the engines refuse the file.', fix: '`bpmn set <file> <id> escalationCode=<CODE>`, or move / remove the boundary event.' },
-  { code: 'W_C7_DEPLOY_EVENT_DEFINITION', meaning: 'A timer without date, cycle or duration, or a compensation activityRef outside the throw event\'s (sub-)process (an event sub-process may name activities of its parent scope); or, by the BPMN schema, a conditional event definition without a condition element (an empty one or a camunda:resource script deploys: W_C7_EMPTY_CONDITION / fine) or a timer definition with more than one of timeDate, timeCycle and timeDuration. The engines refuse the file. The schema rules hold for every event definition in the file: also for one the engines ignore next to another (W_C7_MULTIPLE_EVENT_DEFINITIONS) and in non-executable processes.', fix: '`bpmn set <file> <id> timer=PT1H`, `bpmn set <file> <id> \'when=${...}\'`, or `bpmn set <file> <id> definition.activityRef=<activityId>` (the hint lists the candidates); a definition the engines ignore is dropped with `bpmn set <file> <id> trigger=<acting trigger>`.' },
+  { code: 'W_C7_DEPLOY_EVENT_DEFINITION', meaning: 'A timer without date, cycle or duration, or a compensation activityRef outside the throw event\'s (sub-)process (an event sub-process may name activities of its parent scope); or, by the BPMN schema, a conditional event definition without a condition element (an empty one or a camunda:resource script deploys) or a timer definition with more than one of timeDate, timeCycle and timeDuration. The engines refuse the file. The schema rules hold for every event definition in the file: also for one the engines ignore next to another and in non-executable processes.', fix: '`bpmn set <file> <id> timer=PT1H`, `bpmn set <file> <id> \'when=${...}\'`, or `bpmn set <file> <id> definition.activityRef=<activityId>` (the hint lists the candidates); a definition the engines ignore is dropped with `bpmn set <file> <id> trigger=<acting trigger>`.' },
   { code: 'W_C7_DEPLOY_START_EVENT', meaning: 'A process or embedded sub-process without a start event, also an empty one ("must define a startEvent element"; a transaction without one deploys: W_C7_TRANSACTION_NO_START), a second none or timer start event in a process (message / signal / conditional start events may be added), or a second start event of any kind in a sub-process (event sub-processes and transactions included); the engines refuse the file. Replaces W_NO_START / W_EMPTY_SUBPROCESS for the same (sub-)process.', fix: 'A second start event: remove it when the first one already reaches where it leads (`bpmn remove <file> <extraStartId>`, its flows go with it), else start its branch from the first one (`bpmn set <file> <flowId> source=<startId>`, then remove it) or give a process start another trigger (`bpmn set <file> <id> trigger=message message=<Name>`); the hint names the flows and never moves one into a node the first start already reaches. A missing start: `bpmn add <file> startEvent "<Name>" --before <firstNodeId>` (`--in <id>` when empty).' },
   { code: 'W_C7_DEPLOY_COMPLEX_GATEWAY', meaning: 'A complex gateway with a sequence flow into or out of it: the engines do not run complex gateways and refuse the file ("Invalid destination / source of sequence flow"). One that nothing connects deploys.', fix: '`bpmn retype <file> <id> inclusiveGateway` (or `exclusiveGateway` for one path).' },
   { code: 'W_C7_DEPLOY_AD_HOC_SUBPROCESS', meaning: 'An ad-hoc sub-process with a sequence flow into or out of it, or a boundary event on it: the engines do not run ad-hoc sub-processes and refuse the file ("Invalid destination / source of sequence flow", "Invalid reference in boundary event"); one with a multi-instance loop is refused by Camunda 7 and CIB seven too (Operaton deploys a valid loop; the loop rules of W_C7_DEPLOY_MULTI_INSTANCE hold on all three). One that nothing connects deploys and is skipped with its content, so the profile does not check that content.', fix: '`bpmn retype <file> <id> subProcess`, then give its content a start event and flows (`bpmn add <file> startEvent "<Name>" --in <id>`, `bpmn connect <file> <fromId> <toId>`); or drop the loop: `bpmn set <file> <id> loop=none`.' },
   { code: 'W_C7_DEPLOY_LINK', meaning: 'A link event definition without a name (BPMN schema: every one in the file, also one the engines ignore next to another and in non-executable processes), two link catch events with one name in a process (sub-processes included), or a link throw event reached by a flow with no catch event of its name in its own (sub-)process; the engines refuse the file.', fix: '`bpmn set <file> <eventId> link=<Name>`, or add the catching side: `bpmn add <file> intermediateCatchEvent:link "<Name>" --in <scopeId> --link <Name>`.' },
   { code: 'W_C7_DEPLOY_SCHEMA', meaning: 'An attribute without namespace prefix that the BPMN schema does not define (calledDecision="..." on a businessRuleTask, assignee="..." on a userTask), anywhere in the file: non-executable processes, the diagram and bpmn:definitions included. The engines validate the file against the schema and refuse it.', fix: 'Remove it: `bpmn set <file> <id> <attr>=` (on an event definition, loop or condition: `definition.<attr>=` / `loop.<attr>=` / `condition.<attr>=`); a vendor attribute needs its prefix: `bpmn set <file> <id> assignee= camunda:assignee=<value>`. A business rule task\'s calledDecision (bpmn-cli\'s decision link for a model without an engine) is converted: `bpmn set <file> <id> calledDecision=<decision>` writes camunda:decisionRef and removes it.' },
-  { code: 'W_C7_DEPLOY_BOUNDARY_HOST', meaning: 'A boundary event is attached to a compensation handler (isForCompensation=true); the engines refuse the file. `validate` and writes report it as the structural error E_INVALID_HOST instead (the profile alone, `runProfile`, reports this code).', fix: '`bpmn remove <file> <id>` or `bpmn move <file> <id> --on <activityId>`.' },
   { code: 'W_C7_DEPLOY_SCRIPT', meaning: 'A script task has neither a script nor camunda:resource; the engines refuse the file.', fix: '`bpmn set <file> <id> scriptFormat=groovy \'script=...\'` (or camunda:resource=deployment://<file>).' },
   { code: 'W_C7_DEPLOY_EXCLUSIVE_GATEWAY', meaning: 'An exclusive gateway without outgoing flow, a single outgoing flow with a condition, a default flow with a condition, or flows without condition next to a default (or more than one without condition); the engines refuse the file.', fix: '`bpmn set <file> <flowId> \'condition=${...}\'` or `bpmn set <file> <flowId> default=true`.' },
-  { code: 'W_C7_DEPLOY_DEFINITIONS_EXTENSION', meaning: 'bpmn:extensionElements directly under bpmn:definitions (the BPMN schema does not allow them there); the engines refuse the file.', fix: '`bpmn ext remove <file> <definitionsId> <type>`, then `bpmn ext add <file> <processId> ...`.' },
   { code: 'W_C7_UNKNOWN_ATTRIBUTE', meaning: 'A camunda attribute (on a BPMN element or inside camunda content) the Camunda descriptor does not know, e.g. a typo; the engines ignore it. The message suggests the closest known name.', fix: 'Replace it: `bpmn set <file> <id> camunda:asignee= camunda:assignee=<value>`.' },
   { code: 'W_C7_MISPLACED_ATTRIBUTE', meaning: 'A camunda attribute on an element type that does not read it (camunda:assignee on a serviceTask, camunda:collection on the activity, errorCodeVariable on the event instead of its definition), or on the side of an event definition the engines do not read it on: type / topic / class / delegateExpression / expression / resultVariable / taskPriority on a message catch event, camunda:async on a signal catch event, errorCodeVariable / errorMessageVariable on an error end event, escalationCodeVariable on an escalation throw; it has no effect.', fix: 'Move it with the definition. / loop. / condition. keys of set (the hint has the command), or remove it: `bpmn set <file> <id> camunda:<attr>=` (`definition.camunda:<attr>=`).' },
   { code: 'W_C7_UNKNOWN_ELEMENT', meaning: 'A camunda extension element type the Camunda descriptor does not know (camunda:inputOutputt, camunda:values); the engines ignore it.', fix: '`bpmn ext remove <file> <id> <index>` and add the right type.' },
   { code: 'W_C7_MISPLACED_EXTENSION', meaning: 'A camunda extension element on a host that does not read it (taskListener, camunda:in or formData on a serviceTask; inputOutput on the process or a flow; camunda:field / connector on a message catch event definition, camunda:in on a signal catch), a child type loose in extensionElements, or a child in the wrong container; the engines ignore it.', fix: '`bpmn ext remove <file> <id> <selector>` (the hint has it), then add it where it belongs with `bpmn ext add <file> <hostId> <type> ...` (child types go into their container automatically).' },
   { code: 'W_C7_FOREIGN_CONTENT', meaning: 'zeebe:* attributes or extension elements in a Camunda 7 file; Camunda 7 ignores them.', fix: '`bpmn set <file> <id> zeebe:<attr>=` or `bpmn ext remove <file> <id> zeebe:<type>`, and use the camunda equivalent.' },
-  { code: 'W_C7_BAD_VALUE', meaning: 'A value the engines accept but misread: a boolean other than exactly true / false (asyncBefore=yes stays off), an unknown calledElement / case / decisionRef binding, variableEvents other than create / update / delete, an empty topic or calledElement, a non-numeric user task priority.', fix: '`bpmn set <file> <id> camunda:<attr>=<valid value>` (the hint names it).' },
+  { code: 'W_C7_BAD_VALUE', meaning: 'A value the engines accept but misread: a boolean other than exactly true / false (asyncBefore=yes stays off), an unknown calledElement / case / decisionRef binding, variableEvents other than create / update / delete, a non-numeric user task priority.', fix: '`bpmn set <file> <id> camunda:<attr>=<valid value>` (the hint names it).' },
   { code: 'W_C7_MESSAGE_NO_IMPLEMENTATION', meaning: 'A message throw or end event without implementation: it sends nothing and behaves like a none event at run time.', fix: '`bpmn set <file> <id> definition.camunda:type=external definition.camunda:topic=<topic>` (or definition.camunda:delegateExpression=${...}).' },
   { code: 'W_C7_TRANSACTION_NO_START', meaning: '(runtime) A transaction without a start event (also an empty one): unlike an embedded sub-process it deploys, but every instance that reaches it fails ("No initial activity found for subprocess"). Replaces W_NO_START / W_EMPTY_SUBPROCESS for the same transaction.', fix: '`bpmn add <file> startEvent "<Name>" --before <firstNodeId>` (`--in <id>` when empty), or `bpmn remove <file> <id>`.' },
-  { code: 'W_C7_EMPTY_CONDITION', meaning: '(runtime) A condition with no expression and no camunda:resource, on a conditional event or on a sequence flow the engines evaluate (not a default flow, not out of a parallel or event-based gateway). It deploys, but every evaluation fails ("condition expression returns non-Boolean" / "condition script returns null").', fix: '`bpmn set <file> <flowId> \'condition=${...}\'` (or `condition=` to drop it); a conditional event: `bpmn set <file> <id> \'when=${...}\'` or `bpmn set <file> <id> condition.camunda:resource=deployment://<script> condition.language=groovy`.' },
-  { code: 'W_C7_MULTIPLE_EVENT_DEFINITIONS', meaning: '(runtime) An event with several event definitions (BPMN "multiple"): the engines act on one and do not even parse the others. Engine-checked order: intermediate catch timer > signal > message > link > conditional; process start timer > message > signal > conditional; event sub-process start message > signal > timer > conditional; boundary timer > signal > message > conditional; intermediate throw signal > message; end message > signal. The other W_C7_DEPLOY_* rules look at the acting definition only, like the engines, except the schema rules (a conditional definition without condition element, a link definition without name, a timer definition with two time elements): the engines validate the file against the BPMN schema before they pick a definition, so these refuse the file on an ignored definition too.', fix: 'Keep one: `bpmn set <file> <id> trigger=<t>` (keeps that definition, drops the others), and model every other trigger as its own event (behind an event-based gateway, or another boundary / start event). One definition is edited with `bpmn set <file> <id> \'definition[<n>].<key>=<value>\'`.' },
   { code: 'W_C7_DANGLING_REF', meaning: 'An id reference inside camunda content (camunda:errorEventDefinition errorRef) points to no element of the right type; the mapping is ignored at run time.', fix: 'Rebuild just that mapping (the hint has both commands; --replace would remove the other mappings): `bpmn ext remove <file> <id> \'camunda:errorEventDefinition[id=<mappingId>]\'`, then `bpmn ext add <file> <id> camunda:errorEventDefinition id=<mappingId> errorRef=<ErrorId> expression=${...}`.' },
   { code: 'W_C7_EXCLUSIVE_GATEWAY_DEFAULT', meaning: '(practice) An exclusive gateway has exactly one flow without condition and no default; the engine takes it as the default and logs a warning.', fix: '`bpmn set <file> <flowId> default=true`.' },
-  { code: 'W_C7_DUPLICATE_EXTENSION', meaning: '(practice) A second camunda:failedJobRetryTimeCycle on an element that is not asynchronous yet; the engines refuse the file once it is.', fix: 'Keep one: `bpmn ext add <file> <id> camunda:failedJobRetryTimeCycle --replace --body R3/PT5M`.' },
-  { code: 'W_C8_*', meaning: 'A finding of the Camunda 8 profile, which runs in Camunda 8 files (modeler:executionPlatform "Camunda Cloud" or the zeebe namespace; `validate --platform c8` forces it). Every rule was checked against Camunda 8.9 (deploy and, for the runtime rules, running the process). Every finding has a severity (JSON field `severity`): deploy = Camunda 8 refuses the file (codes W_C8_DEPLOY_*); runtime = it deploys but the setting is ignored or fails when the process runs; practice = it works, but differently than intended. Executable processes are checked (Camunda 8 skips the others but refuses a file without any), the content of ad-hoc sub-processes included; the schema rules cover the whole file. Placement and known names come from the zeebe-bpmn-moddle descriptor. FEEL is parsed (the grammar Camunda 8.9 accepts; the JUEL habits &&, ||, ==, !, ${...}, single quotes are named). Timer values are checked for their form and range (a date that does not exist, 25:00, a cron field out of range), xsd:boolean attributes for true / false / 1 / 0. A mutation reports only the findings it introduced.', fix: 'Fix every W_C8_DEPLOY_* finding before deploying; the hint of each finding names the exact `bpmn ext` / `bpmn set` / `bpmn add|remove|retype` command. `bpmn validate <file>` lists all of them.' },
+  { code: 'W_C8_*', meaning: 'A finding of the Camunda 8 rules (camunda-compat for the file\'s modeler:executionPlatformVersion, else the latest, and the c8-* rules of @miragon/bpmnlint-plugin-rules, mapped to these codes), which run in Camunda 8 files (modeler:executionPlatform "Camunda Cloud" or the zeebe namespace; `validate --platform c8` forces it). Where camunda-compat is stricter than Camunda 8.9 (a gateway flow without condition, an error code on a caught error), it decides. Every finding has a severity (JSON field `severity`): deploy = Camunda 8 refuses the file (codes W_C8_DEPLOY_*); runtime = it deploys but the setting is ignored or fails when the process runs; practice = it works, but differently than intended. Executable processes are checked (Camunda 8 skips the others but refuses a file without any), the content of ad-hoc sub-processes included. Placement and known names come from the zeebe-bpmn-moddle descriptor. FEEL is parsed (the grammar Camunda 8.9 accepts; the JUEL habits &&, ||, ==, !, ${...}, single quotes are named). Timer values are checked for their form and range (a date that does not exist, 25:00, a cron field out of range). A mutation reports only the findings it introduced.', fix: 'Fix every W_C8_DEPLOY_* finding before deploying; the hint of each finding names the exact `bpmn ext` / `bpmn set` / `bpmn add|remove|retype` command. `bpmn validate <file>` lists all of them.' },
+  { code: 'W_C8_ENGINE_RULE', meaning: 'A finding of a Camunda 8 engine rule bpmn-cli has no code for yet (a rule a newer camunda-compat adds); the message names what the engine refuses or ignores.', fix: 'Fix what the message names; report the rule so it gets its own code.' },
   { code: 'W_C8_DEPLOY_EXECUTABLE', meaning: 'The file has processes, but none is executable; Camunda 8 refuses it ("Must contain at least one executable process").', fix: '`bpmn set <file> <processId> isExecutable=true`.' },
   { code: 'W_C8_DEPLOY_IMPLEMENTATION', meaning: 'A service, send, script or business rule task, or a message throw / end event, has no implementation: Camunda 8 needs a zeebe:taskDefinition (the job type a worker subscribes to); a script task may have a zeebe:script (FEEL expression + resultVariable), a business rule task a zeebe:calledDecision (decisionId + resultVariable) instead, not both. Also: a job without type, a zeebe:script without expression or resultVariable, a zeebe:calledDecision without decisionId or resultVariable, a thrown message without name. Camunda 8 refuses the file.', fix: '`bpmn ext add <file> <id> zeebe:taskDefinition type=<jobType>` (retries=3 optional); `bpmn ext add <file> <id> zeebe:script expression==<FEEL> resultVariable=<variable>`; `bpmn set <file> <id> calledDecision=<decisionId>` plus `bpmn ext add <file> <id> zeebe:calledDecision resultVariable=<variable>`.' },
   { code: 'W_C8_DEPLOY_CALLED_ELEMENT', meaning: 'A call activity without zeebe:calledElement (the BPMN calledElement attribute is not read by Camunda 8), or one without processId; Camunda 8 refuses the file.', fix: '`bpmn ext add <file> <id> zeebe:calledElement processId=<processId> propagateAllChildVariables=false`.' },
@@ -227,16 +222,15 @@ const PLATFORM_PROFILE_FINDINGS: ErrorDoc[] = [
   { code: 'W_C8_DEPLOY_ERROR', meaning: 'An error end / throw event without error or whose bpmn:Error has no errorCode, a catching error event with an error code that is an expression, two error catch events with one code (or two without code, catch-alls) in one scope, or a non-interrupting error event; Camunda 8 refuses the file.', fix: '`bpmn set <file> <id> error=<ErrorName> errorCode=<CODE>` (or another code / remove one of the catch events; `nonInterrupting=false`).' },
   { code: 'W_C8_DEPLOY_ESCALATION', meaning: 'An escalation throw / end event without escalation or escalationCode, or an escalation boundary event on something else than a sub-process or call activity; Camunda 8 refuses the file.', fix: '`bpmn set <file> <id> escalation=<Name> escalationCode=<CODE>`, or move / remove the boundary event.' },
   { code: 'W_C8_DEPLOY_TIMER', meaning: 'A timer without date, cycle or duration; a static value Camunda 8 cannot parse (an ISO 8601 duration PT1H / P2D; a date-time with offset or Z, 2030-12-31T10:00:00Z; a repeating interval R/PT1H, R5/<start>/<duration> or a 6-field cron expression / @daily) or one out of range (a date that does not exist, 2030-02-30, 25:00, an offset over 18 hours; a cron field out of range, hour 25, month 13, a step of 0, a reversed range, ? outside the day fields); a cycle on an intermediate timer catch event; an interrupting timer boundary event or event sub-process start with a cycle. Camunda 8 refuses the file.', fix: '`bpmn set <file> <id> timer=PT1H` (R/... is a cycle, an ISO date-time a date); `bpmn set <file> <id> nonInterrupting=true` for a repeating boundary timer.' },
-  { code: 'W_C8_DEPLOY_EVENT_DEFINITION', meaning: 'An intermediate catch or boundary event without event definition, an event with several, a definition its position does not support (a non-none start in an embedded sub-process is W_C8_DEPLOY_START_EVENT; a none or compensation start in an event sub-process), a conditional, compensation or link catch event definition without id (Camunda 8.9 fails with an internal error), a compensation activityRef outside the throw event\'s scope, a compensation boundary event without association to a handler or with an outgoing flow, or (BPMN schema, every definition in the file) a conditional definition without condition. Camunda 8 refuses the file.', fix: 'The hint names it: `bpmn set <file> <id> trigger=<trigger>`, `bpmn set <file> <id> definition.id=<Id>`, `bpmn set <file> <id> definition.activityRef=<activityId>`, `bpmn connect <file> <boundaryId> <handlerId>`.' },
-  { code: 'W_C8_DEPLOY_EVENT_GATEWAY', meaning: 'An event-based gateway with fewer than two outgoing flows (Camunda 8 counts the <bpmn:outgoing> entries the file lists), or a branch that is not a message, timer, signal or conditional intermediate catch event (receive tasks included); Camunda 8 refuses the file.', fix: '`bpmn add <file> intermediateCatchEvent:timer "<Timeout>" --after <gatewayId> --timer PT1H`; a receive task: `bpmn retype <file> <id> intermediateCatchEvent:message --message <Name>`.' },
+  { code: 'W_C8_DEPLOY_EVENT_DEFINITION', meaning: 'An intermediate catch or boundary event without event definition, a definition its position does not support (a non-none start in an embedded sub-process is W_C8_DEPLOY_START_EVENT; a none or compensation start in an event sub-process), a compensation activityRef outside the throw event\'s scope, a compensation boundary event without association to a handler or with an outgoing flow, or (BPMN schema, every definition in the file) a conditional definition without condition. Camunda 8 refuses the file.', fix: 'The hint names it: `bpmn set <file> <id> trigger=<trigger>`, `bpmn set <file> <id> definition.activityRef=<activityId>`, `bpmn connect <file> <boundaryId> <handlerId>`.' },
+  { code: 'W_C8_DEPLOY_EVENT_GATEWAY', meaning: 'An event-based gateway with fewer than two outgoing flows, or a branch that is not a message, timer, signal or conditional intermediate catch event (receive tasks included); Camunda 8 refuses the file.', fix: '`bpmn add <file> intermediateCatchEvent:timer "<Timeout>" --after <gatewayId> --timer PT1H`; a receive task: `bpmn retype <file> <id> intermediateCatchEvent:message --message <Name>`.' },
   { code: 'W_C8_DEPLOY_START_EVENT', meaning: 'A process without start event or with two none start events, an embedded sub-process without exactly one start event or with a start event that has a trigger, an event sub-process without exactly one start event; Camunda 8 refuses the file. Replaces W_NO_START / W_EMPTY_SUBPROCESS for the same (sub-)process.', fix: '`bpmn add <file> startEvent "<Name>" --before <firstNodeId>` (`--in <id>` when empty); a second none start: `bpmn remove <file> <id>` or `bpmn set <file> <id> trigger=message message=<Name>`.' },
   { code: 'W_C8_DEPLOY_AD_HOC_SUBPROCESS', meaning: 'An ad-hoc sub-process that contains a start or end event, or no activity; Camunda 8 refuses the file. (Its content is checked like any other: Camunda 8 runs ad-hoc sub-processes.)', fix: '`bpmn remove <file> <eventId>`; `bpmn add <file> serviceTask "<Name>" --in <id>`.' },
   { code: 'W_C8_DEPLOY_LINK', meaning: 'A link throw event without a catch event of its name in its own (sub-)process, two link catch events with one name in a process (sub-processes included), or (every definition in the file) a link definition without name (the BPMN schema) or with an empty one; Camunda 8 refuses the file.', fix: '`bpmn add <file> intermediateCatchEvent:link "<Name>" --in <scopeId> --link <Name>`, or `bpmn set <file> <id> link=<Name>`.' },
   { code: 'W_C8_DEPLOY_USER_TASK', meaning: 'A zeebe:formDefinition that is not exactly one of formId / externalReference (Camunda user task: an embedded formKey is not read) or of formId / formKey (job worker user task), a static priority that is not a number from 0 to 100, a static due or follow-up date that is no ISO 8601 date-time with offset; Camunda 8 refuses the file.', fix: '`bpmn ext add <file> <id> zeebe:formDefinition formId=<formId> --replace` (or externalReference=<url>); `bpmn ext add <file> <id> zeebe:priorityDefinition priority=50 --replace`.' },
   { code: 'W_C8_DEPLOY_LISTENER', meaning: 'An execution or task listener without type (the job type of its worker) or event type, an unknown event type (execution: start / end; task: creating / assigning / updating / completing / canceling, the older create / assignment / update / complete / cancel too), a start listener on a start or boundary event, an end listener on a gateway, execution listeners on a sequence flow, or task listeners on a job worker user task; Camunda 8 refuses the file.', fix: 'Rebuild just that listener (the hint has both commands): `bpmn ext remove <file> <id> \'zeebe:executionListeners/zeebe:executionListener[0]\'`, then `bpmn ext add <file> <id> zeebe:executionListeners/zeebe:executionListener eventType=end type=<jobType>`.' },
   { code: 'W_C8_DEPLOY_UNSUPPORTED', meaning: 'A transaction, a cancel event or a complex gateway: Camunda 8 does not support them and refuses the file.', fix: '`bpmn retype <file> <id> subProcess` (a transaction); `bpmn set <file> <id> trigger=error` (a cancel boundary event); `bpmn retype <file> <id> inclusiveGateway` or `exclusiveGateway` (a complex gateway).' },
-  { code: 'W_C8_DEPLOY_BOUNDARY_HOST', meaning: 'A boundary event is attached to a compensation handler (isForCompensation=true); Camunda 8 refuses the file. `validate` and writes report it as the structural error E_INVALID_HOST instead (the profile alone, `runProfile`, reports this code).', fix: '`bpmn remove <file> <id>` or `bpmn move <file> <id> --on <activityId>`.' },
-  { code: 'W_C8_DEPLOY_SCHEMA', meaning: 'Camunda 8 validates the file against the BPMN schema and refuses it: an attribute without namespace prefix that the schema does not define (calledDecision="..." on a businessRuleTask), bpmn:extensionElements on bpmn:definitions, an id that is no XML NCName (a:b, 1abc; one bpmn-moddle cannot read at all is an import warning too), an IDREF that names no id of the file (a lane\'s flowNodeRef, default, dataObjectRef, ...), child elements in an order the schema does not allow (extensionElements after incoming, documentation after extensionElements, a laneSet after the flow elements, a message after the diagram), or an xsd:boolean attribute of another value than true / false / 1 / 0 (cancelActivity="maybe", isExpanded="TRUE"; bpmn-moddle reads it as false). The model shows none of the last three; the rule reads the file\'s text.', fix: 'Remove the attribute: `bpmn set <file> <id> <attr>=` (a business rule task\'s calledDecision is converted: `bpmn set <file> <id> calledDecision=<decision>` writes zeebe:calledDecision); rename the id: `bpmn set <file> <id> id=<NewId>`; the reference, the order and a boolean: fix them in the XML (Camunda Modeler and `bpmn` write the schema\'s order for the elements they create or change).' },
+  { code: 'W_C8_DEPLOY_SCHEMA', meaning: 'Camunda 8 validates the file against the BPMN schema and refuses it: an attribute without namespace prefix that the schema does not define (calledDecision="..." on a businessRuleTask).', fix: 'Remove the attribute: `bpmn set <file> <id> <attr>=` (a business rule task\'s calledDecision is converted: `bpmn set <file> <id> calledDecision=<decision>` writes zeebe:calledDecision).' },
   { code: 'W_C8_FOREIGN_CONTENT', meaning: 'camunda:* / operaton:* attributes or extension elements (Camunda 7 content) in a Camunda 8 file; Camunda 8 ignores them (engine-checked: camunda:assignee does not assign a Camunda user task).', fix: 'Remove it (`bpmn set <file> <id> camunda:<attr>=` / `bpmn ext remove <file> <id> <index>`) and use the zeebe element the hint names (zeebe:assignmentDefinition, zeebe:taskDefinition, zeebe:ioMapping, ...).' },
   { code: 'W_C8_UNKNOWN_ELEMENT', meaning: 'A zeebe extension element the Zeebe descriptor does not know (a typo); Camunda 8 ignores it. The message suggests the closest known type.', fix: '`bpmn ext remove <file> <id> <index>` and add the right type.' },
   { code: 'W_C8_UNKNOWN_ATTRIBUTE', meaning: 'An attribute a zeebe element does not have (zeebe:taskDefinition typo="..."), or a zeebe:* attribute on a BPMN element the descriptor does not know (most zeebe settings are extension elements); Camunda 8 ignores it.', fix: 'Rebuild the element without it (the hint has the command), or `bpmn set <file> <id> zeebe:<attr>=`.' },
diff --git a/src/adapters/out/bpmnlint/BpmnlintEngineLint.ts b/src/adapters/out/bpmnlint/BpmnlintEngineLint.ts
new file mode 100644
index 00000000..bb7c1bd6
--- /dev/null
+++ b/src/adapters/out/bpmnlint/BpmnlintEngineLint.ts
@@ -0,0 +1,55 @@
+import type { Doc } from '../../../domain/document/Doc.js';
+import type { ProfileFinding } from '../../../domain/document/Finding.js';
+import { ioError } from '../../../domain/document/utils/errors.js';
+import { firstLine } from '../../../domain/document/utils/text.js';
+import type { EnginePlatformInfo } from '../../../domain/validation/EngineLint.js';
+import type { EngineLintPort } from '../../../application/port/out/EngineLintPort.js';
+import { ENGINE_KIT } from './engine-kit.js';
+import type { EngineRun } from './engine/run/EngineRun.js';
+
+type Engine = EnginePlatformInfo['platform'];
+
+const ENGINE_NAMES: Record<Engine, string> = { c7: 'Camunda 7', c8: 'Camunda 8' };
+
+/**
+ * The engine's rules, bpmnlint's linter and the engine run: a chunk of their own
+ * per engine in a browser bundle, loaded the first time a document of that engine is checked.
+ */
+const LOADERS: Record<Engine, () => Promise<EngineRun>> = {
+  c7: async () => {
+    const [{ Camunda7Rules }, { EngineRun }] = await Promise.all([import('./engine/rules/c7/Camunda7Rules.js'), import('./engine/run/EngineRun.js')]);
+    return new EngineRun(ENGINE_KIT, 'c7', Camunda7Rules.entry(ENGINE_KIT));
+  },
+  c8: async () => {
+    const [{ Camunda8Rules }, { EngineRun }] = await Promise.all([import('./engine/rules/c8/Camunda8Rules.js'), import('./engine/run/EngineRun.js')]);
+    return new EngineRun(ENGINE_KIT, 'c8', Camunda8Rules.entry(ENGINE_KIT));
+  },
+};
+
+/**
+ * The Camunda 7 / 8 rules as bpmnlint runs them: camunda-compat (through @miragon/bpmnlint-plugin-rules)
+ * and bpmn-cli's own rules for what it leaves out, mapped to bpmn-cli's W_C7_* / W_C8_* findings. Each engine
+ * loads on first use; a failed load is forgotten, so a later call imports the chunk again (a
+ * browser may keep the failed fetch until the page reloads).
+ */
+export class BpmnlintEngineLint implements EngineLintPort {
+  private readonly loading: Partial<Record<Engine, Promise<EngineRun>>> = {};
+
+  async findings(doc: Doc, info: EnginePlatformInfo): Promise<ProfileFinding[]> {
+    return (await this.load(info.platform)).findings(doc, info);
+  }
+
+  private load(engine: Engine): Promise<EngineRun> {
+    const loaded = this.loading[engine];
+    if (loaded) return loaded;
+    const load = LOADERS[engine]().catch((err: unknown) => {
+      delete this.loading[engine];
+      throw ioError('E_PROFILE_LOAD', `The ${ENGINE_NAMES[engine]} engine rules could not be loaded: ${firstLine(err)}`, {
+        platform: engine,
+        hint: 'They are a chunk of their own in a browser bundle: check that it is served next to the entry chunk (base URL, network, content security policy); nothing was written. A later call imports the chunk again (in Node that loads it), but a browser may keep the failed fetch until the page reloads (Chrome does): reload the page there.',
+      });
+    });
+    this.loading[engine] = load;
+    return load;
+  }
+}
diff --git a/src/adapters/out/bpmnlint/bpmnlint-contract.ts b/src/adapters/out/bpmnlint/bpmnlint-contract.ts
index ca5cd8a9..0f19d0f2 100644
--- a/src/adapters/out/bpmnlint/bpmnlint-contract.ts
+++ b/src/adapters/out/bpmnlint/bpmnlint-contract.ts
@@ -20,6 +20,11 @@ export interface BpmnlintReport {
   category: string;
 }
 
+/** An engine rule's report: camunda-compat's `path` and `data.type` say where and what. */
+export interface BpmnlintEngineReport extends BpmnlintReport {
+  data?: { type?: string; [key: string]: unknown };
+}
+
 export interface BpmnlintRule {
   check?: unknown;
   meta?: unknown;
diff --git a/src/adapters/out/bpmnlint/engine-kit.ts b/src/adapters/out/bpmnlint/engine-kit.ts
new file mode 100644
index 00000000..9f00114e
--- /dev/null
+++ b/src/adapters/out/bpmnlint/engine-kit.ts
@@ -0,0 +1,35 @@
+import { BpmnModdle } from 'bpmn-moddle';
+import { kindLabel } from '../../../domain/document/Kinds.js';
+import { makeFinding } from '../../../domain/document/utils/finding.js';
+import { levenshtein } from '../../../domain/document/utils/fuzzy.js';
+import { is, isDiElement, list, peek, walk } from '../../../domain/document/utils/moddle.js';
+import { C7_URIS, CAMUNDA, CAMUNDA_URI, OPERATON_URI } from '../../../domain/document/vendor/CamundaDescriptor.js';
+import { DocumentNamespaces } from '../../../domain/document/vendor/DocumentNamespaces.js';
+import { ZEEBE } from '../../../domain/document/vendor/ZeebeDescriptor.js';
+import { DecisionLinkReader } from '../../../domain/editing/properties/DecisionLinkReader.js';
+
+/**
+ * The core helpers the lazily loaded engine run gets handed instead of importing them: a module
+ * shared by the core and a rule chunk lands in the host's entry chunk, and the rule chunk would
+ * import the entry chunk back (a host that awaits a call at top level would wait for itself).
+ */
+export const ENGINE_KIT = {
+  BpmnModdle,
+  kindLabel,
+  makeFinding,
+  levenshtein,
+  is,
+  isDiElement,
+  list,
+  peek,
+  walk,
+  C7_URIS,
+  CAMUNDA,
+  CAMUNDA_URI,
+  OPERATON_URI,
+  DocumentNamespaces,
+  ZEEBE,
+  DecisionLinkReader,
+};
+
+export type EngineKit = typeof ENGINE_KIT;
diff --git a/src/adapters/out/bpmnlint/engine/rules/CamundaRule.ts b/src/adapters/out/bpmnlint/engine/rules/CamundaRule.ts
new file mode 100644
index 00000000..cee06454
--- /dev/null
+++ b/src/adapters/out/bpmnlint/engine/rules/CamundaRule.ts
@@ -0,0 +1,70 @@
+import { defineRule as declareRule, EngineRule, type DeclaredRuleFactory, type Engine, type ModdleElement, type Reporter, type ReportPath } from '@miragon/bpmnlint-plugin-rules/engine';
+import { reportErrors } from 'bpmnlint-plugin-camunda-compat/rules/utils/reporter.js';
+import type { VendorHost } from './support/VendorHost.js';
+
+export type { ModdleElement, ReportPath } from '@miragon/bpmnlint-plugin-rules/engine';
+export { ERROR_TYPES } from 'bpmnlint-plugin-camunda-compat/rules/utils/error-types.js';
+
+/** What the engine does with a file the rule reports: refuses it, fails or ignores a setting when it runs, or runs it other than a reader expects. */
+export type Impact = 'deploy' | 'runtime' | 'practice';
+
+/** The bpmn-cli code a rule reports and its impact. */
+export interface RuleCode {
+  code: string;
+  impact: Impact;
+}
+
+/** A bpmn-cli engine rule: the plugin's rule factory with the code and impact of its findings. */
+export type CamundaRuleFactory = DeclaredRuleFactory & RuleCode;
+
+/** The plugin's `defineRule` of an engine-specific rule for the engine its name starts with, with the code and impact from which bpmn-cli takes the finding's code, its severity and the rule's category. */
+export function defineRule<const Name extends `${Engine}-${string}`>({ ruleName, code, impact }: { ruleName: Name } & RuleCode, RuleClass: new (config?: object) => EngineRule): CamundaRuleFactory {
+  return Object.assign(declareRule({ ruleName, kind: 'engine-specific', targetEngine: ruleName.slice(0, 2) as Engine }, RuleClass), { code, impact });
+}
+
+/** What a report says besides its message: camunda-compat's `path` and `data.type`, the fix, the element holding the property (the reported one unless given) and the elements it names. */
+export interface ReportData {
+  path: ReportPath | null;
+  type: string;
+  hint?: string;
+  node?: ModdleElement;
+  [detail: string]: unknown;
+}
+
+/**
+ * The base of every bpmn-cli engine rule. A rule implements `visit(node)`, which the plugin's
+ * single walk calls for each element (return false to skip its children), and reports through
+ * `report(at, message, data)`.
+ * Every report has camunda-compat's shape (`path`, `data.type`), so `run/` maps own and compat
+ * findings alike; bpmn-cli takes its code and severity from what the rule declares in `defineRule`.
+ */
+export abstract class CamundaRule extends EngineRule {
+  private reporter!: Reporter;
+
+  protected checkElement(node: ModdleElement, reporter: Reporter): boolean | void {
+    this.reporter = reporter;
+    return this.visit(node);
+  }
+
+  protected abstract visit(node: ModdleElement): boolean | void;
+
+  protected report(at: ModdleElement, message: string, { path, ...data }: ReportData): void {
+    const node = data.node ?? at;
+    reportErrors(at, this.reporter, { message, path, data: { ...data, node, parentNode: node === at ? null : at } });
+  }
+
+  /** A finding on the element a finding about `host` lands on. */
+  protected reportOn(host: VendorHost, message: string, data: ReportData): void {
+    this.report(host.target, message, data);
+  }
+}
+
+/** A rule that checks the diagrams targeting Camunda 7. */
+export abstract class C7Rule extends CamundaRule {
+  protected readonly engine: Engine = 'c7';
+}
+
+/** A rule that checks the diagrams targeting Camunda 8. */
+export abstract class C8Rule extends CamundaRule {
+  protected readonly engine: Engine = 'c8';
+}
diff --git a/src/adapters/out/bpmnlint/engine/rules/RuleEntries.ts b/src/adapters/out/bpmnlint/engine/rules/RuleEntries.ts
new file mode 100644
index 00000000..0c9728f6
--- /dev/null
+++ b/src/adapters/out/bpmnlint/engine/rules/RuleEntries.ts
@@ -0,0 +1,28 @@
+import type { RuleEntry } from '@miragon/bpmnlint-plugin-rules/engine';
+import type { EngineKit } from '../../engine-kit.js';
+import type { EngineEntry } from '../run/EngineRun.js';
+import type { CamundaRuleFactory, Impact } from './CamundaRule.js';
+import { RuleKit } from './RuleKit.js';
+
+const CATEGORY_OF_IMPACT: Record<Impact, RuleEntry['category']> = { deploy: 'error', runtime: 'warn', practice: 'info' };
+
+/** What the plugin exports for an engine: camunda-compat's rules for an engine version, and the moddle extension they read. */
+interface EnginePlugin {
+  moddleExtensions: Record<string, unknown>;
+  compatRules(version: string | undefined): RuleEntry[];
+}
+
+/** bpmn-cli's rules ready to run, as `bpmn-cli/<rule>`: the category of their impact, told the `<major>.<minor>` engine version. */
+export class RuleEntries {
+  /** camunda-compat's rules for an engine version with bpmn-cli's `rules` and the `writtenFileRules` after them, and the moddle extension they read. */
+  static entry(kit: EngineKit, rules: readonly CamundaRuleFactory[], writtenFileRules: readonly CamundaRuleFactory[], { moddleExtensions, compatRules }: EnginePlugin, afterParse?: EngineEntry['afterParse']): EngineEntry {
+    RuleKit.use(kit);
+    const own = [...rules, ...writtenFileRules];
+    return { moddleExtensions, codes: Object.fromEntries(own.map((rule) => [`bpmn-cli/${rule.ruleName}`, [rule.code, rule.impact]])), rules: (version) => [...compatRules(version), ...RuleEntries.of(own, version)], writtenFileRules: new Set(writtenFileRules.map((rule) => `bpmn-cli/${rule.ruleName}`)), afterParse };
+  }
+
+  private static of(rules: readonly CamundaRuleFactory[], version: string | undefined): RuleEntry[] {
+    const minor = version && /^\s*(\d+\.\d+)/.exec(version)?.[1];
+    return rules.map((rule) => ({ name: `bpmn-cli/${rule.ruleName}`, category: CATEGORY_OF_IMPACT[rule.impact], rule: rule(minor ? { version: minor } : undefined) }));
+  }
+}
diff --git a/src/adapters/out/bpmnlint/engine/rules/RuleKit.ts b/src/adapters/out/bpmnlint/engine/rules/RuleKit.ts
new file mode 100644
index 00000000..9753426c
--- /dev/null
+++ b/src/adapters/out/bpmnlint/engine/rules/RuleKit.ts
@@ -0,0 +1,10 @@
+import type { EngineKit } from '../../engine-kit.js';
+
+/** What the rules use of bpmn-cli's core (element kinds, the camunda and zeebe descriptors, the edit distance), handed over by the engine run before they lint. */
+export class RuleKit {
+  static kit: EngineKit;
+
+  static use(kit: EngineKit): void {
+    RuleKit.kit = kit;
+  }
+}
diff --git a/src/adapters/out/bpmnlint/engine/rules/UnknownVendorElementsRule.ts b/src/adapters/out/bpmnlint/engine/rules/UnknownVendorElementsRule.ts
new file mode 100644
index 00000000..2d361f73
--- /dev/null
+++ b/src/adapters/out/bpmnlint/engine/rules/UnknownVendorElementsRule.ts
@@ -0,0 +1,76 @@
+import type { EngineKit } from '../../engine-kit.js';
+import { ERROR_TYPES, type ModdleElement } from './CamundaRule.js';
+import { DidYouMean } from './support/DidYouMean.js';
+import { VendorElementsRule } from './VendorElementsRule.js';
+
+type VendorType = NonNullable<ReturnType<EngineKit['ZEEBE']['type']> | ReturnType<EngineKit['CAMUNDA']['type']>>;
+type CamundaType = NonNullable<ReturnType<EngineKit['CAMUNDA']['type']>>;
+
+const ENGINE_NAME = { c7: 'the engines', c8: 'Camunda 8' };
+
+/**
+ * Extension elements of the engine's own namespace that its descriptor does not know, directly in
+ * the extension elements or inside a known one, for either engine (`C7CamundaElementKnownRule`,
+ * `C8ZeebeElementKnownRule`).
+ * The engine ignores them silently. The rule reports on the typed twin of the element that holds
+ * them, with the known name a typo most likely meant; the content of a misplaced known element is
+ * left to the placement rules.
+ *
+ * @example a misspelled extension element
+ * <bpmn:serviceTask id="Charge">
+ *   <bpmn:extensionElements><zeebe:taskDefinitions type="charge" /></bpmn:extensionElements>  <!-- zeebe:taskDefinition -->
+ * </bpmn:serviceTask>
+ */
+export abstract class UnknownVendorElementsRule extends VendorElementsRule {
+  protected checkValue(host: ModdleElement, value: ModdleElement, index: number): void {
+    const local = this.localName(value.$type);
+    const known = this.vendor.type(local);
+    if (known) {
+      if (!this.isMisplaced(host, local)) {
+        this.checkChildren(host, value, known, `${this.prefix}:${local}`);
+      }
+      return;
+    }
+    const guess = DidYouMean.of(local, this.vendor.typeNames().map((name) => this.localName(name)));
+    this.reportUnknown(host, `ext:${local}`, `${this.where(host)} has the unknown extension element ${this.prefix}:${local}${guess ? ` (did you mean ${this.prefix}:${guess}?)` : ''}; ${ENGINE_NAME[this.engine]} ignores it`, this.removeHint(host, index, guess));
+  }
+
+  private checkChildren(host: ModdleElement, parent: ModdleElement, parentType: VendorType, path: string): void {
+    for (const child of parent.$children ?? []) {
+      if (!this.isOwnGeneric(child)) continue;
+      const local = this.localName(child.$type);
+      if (this.isTextChild(parentType, local)) continue;
+      const known = this.vendor.type(local);
+      if (known) {
+        this.checkChildren(host, child, known, `${path} > ${this.prefix}:${local}`);
+        continue;
+      }
+      this.reportUnknown(host, `ext:${path}/${local}`, `${this.where(host)} contains the unknown element ${this.prefix}:${local}${path ? ` (in ${path})` : ''}; ${ENGINE_NAME[this.engine]} ignores it`, this.rebuildHint(host, path.split(' > ')[0]!));
+    }
+  }
+
+  /** Children a camunda type takes as plain text (connectorId, expression, string). */
+  private isTextChild(parentType: VendorType, local: string): boolean {
+    return this.engine === 'c7' && (parentType as CamundaType).properties.some((property) => property.name === local && !property.isAttr && !property.isBody && !property.type.includes(':'));
+  }
+
+  private removeHint(host: ModdleElement, index: number, guess: string | undefined): string {
+    const { id, slot } = this.address(host);
+    if (!id) return 'Fix it in the XML.';
+    return `Remove it (\`bpmn ext remove <file> ${id} ${slot}${index}\`)${guess ? ` and add the right one: \`bpmn ext add <file> ${id} ${slot}${this.prefix}:${guess} ...\`` : ''}.`;
+  }
+
+  private rebuildHint(host: ModdleElement, type: string): string {
+    const { id, slot } = this.address(host);
+    if (!id) return 'Fix it in the XML.';
+    return `See it with \`bpmn ext list <file> ${id} --json\`, then rebuild it: \`bpmn ext add <file> ${id} ${slot}${type} --replace --xml '<${type} ...>...</${type}>'\`.`;
+  }
+
+  private reportUnknown(host: ModdleElement, subject: string, message: string, hint: string): void {
+    let reported: ModdleElement | undefined = this.address(host).id === host.id ? host : host.$parent;
+    while (reported && !reported.id) {
+      reported = reported.$parent;
+    }
+    this.report((reported && this.model.typed(reported)) ?? this.node, message, { path: null, type: ERROR_TYPES.EXTENSION_ELEMENT_NOT_ALLOWED, writtenAt: this.model.position(host), subject, hint });
+  }
+}
diff --git a/src/adapters/out/bpmnlint/engine/rules/UnprefixedAttributesRule.ts b/src/adapters/out/bpmnlint/engine/rules/UnprefixedAttributesRule.ts
new file mode 100644
index 00000000..c9ab17f8
--- /dev/null
+++ b/src/adapters/out/bpmnlint/engine/rules/UnprefixedAttributesRule.ts
@@ -0,0 +1,80 @@
+import { CamundaRule, ERROR_TYPES, type ModdleElement } from './CamundaRule.js';
+import { RuleKit } from './RuleKit.js';
+import { ElementKinds } from './support/ElementKinds.js';
+import { SetCommand } from './support/SetCommand.js';
+import { Shell } from './support/Shell.js';
+import { WrittenModel } from './support/WrittenModel.js';
+
+/**
+ * Attributes without a namespace prefix that the BPMN schema does not define, for either engine
+ * (`C7BpmnAttributeKnownRule`, `C8BpmnAttributeKnownRule`).
+ * Both engines validate the file against the schema and refuse it. The typed parse turns some of
+ * them into the vendor attribute of that name, so the rule reads each element as the file writes
+ * it (`WrittenModel`) and reports on its typed twin. The hint suggests the prefixed vendor
+ * attribute where one fits, converts bpmn-cli's own unprefixed decision link, and else says how
+ * to remove it.
+ *
+ * @example an unprefixed assignee
+ * <bpmn:userTask id="Review" assignee="anna" />  <!-- camunda:assignee -->
+ */
+export abstract class UnprefixedAttributesRule extends CamundaRule {
+  private model!: WrittenModel;
+
+  protected visit(node: ModdleElement): void {
+    const model = WrittenModel.of(node);
+    const el = model?.written(node);
+    const keys = Object.keys(el?.$attrs ?? {}).filter((key) => !key.includes(':') && key !== 'xmlns');
+    if (!model || !keys.length) return;
+    this.model = model;
+    const { kit } = RuleKit;
+    const parent = el.$parent;
+    const slot = parent?.id ? SetCommand.slotIn(parent, el) : '';
+    let owner = slot ? parent : el;
+    while (owner && !owner.id) {
+      owner = owner.$parent;
+    }
+    const id: string | undefined = owner?.id;
+    const di = kit.isDiElement(el) || (!!owner && kit.isDiElement(owner));
+    for (const key of keys) {
+      this.checkAttribute(el, owner, id, di ? undefined : slot || (el === owner ? '' : undefined), di, key);
+    }
+  }
+
+  private get prefix(): string {
+    return this.engine === 'c8' ? 'zeebe' : (this.model.file.namespaces.prefixOf(RuleKit.kit.CAMUNDA.uri) ?? 'camunda');
+  }
+
+  private checkAttribute(el: ModdleElement, owner: ModdleElement | undefined, id: string | undefined, slot: string | undefined, di: boolean, key: string): void {
+    const own = el === owner;
+    const vendor = this.engine === 'c7' ? RuleKit.kit.CAMUNDA.attr(key) : undefined;
+    const fits = !!vendor && own && !!id && vendor.owners.some((ownerType) => RuleKit.kit.is(el, ownerType));
+    const where = own ? ElementKinds.describe(el) : `${el.$type}${id ? ` in ${id}` : ''}`;
+    const remove = id && slot !== undefined ? `\`bpmn set <file> ${id} ${Shell.quote(`${slot}${key}=`)}\`` : undefined;
+    const engines = this.engine === 'c8' ? 'Camunda 8 validates the file against the schema and refuses it' : 'the engines validate the file against the schema and refuse it';
+    const message = `${where} has the attribute ${key}, which the BPMN schema does not define${fits ? ` (did you mean ${this.prefix}:${key}?)` : ''}; ${engines}`;
+    const reported = this.model.typed(owner ?? this.model.file.definitions);
+    this.report(reported, message, { path: null, type: ERROR_TYPES.PROPERTY_NOT_ALLOWED, writtenAt: this.model.position(el), subject: `schema:${key}`, hint: this.hint(el, id, key, fits, remove, di) });
+  }
+
+  private hint(el: ModdleElement, id: string | undefined, key: string, fits: boolean, remove: string | undefined, di: boolean): string {
+    const link = id && RuleKit.kit.is(el, 'bpmn:BusinessRuleTask') && (key === 'calledDecision' || key === 'calledElement') && !this.implemented(el) ? this.model.file.decisionLinks.linkOf(el) : undefined;
+    if (link) {
+      const command = `\`bpmn set <file> ${id} ${Shell.quote(`calledDecision=${link.value}`)}\``;
+      return this.engine === 'c7' ? `Write the decision link in the engines' spelling: ${command} (${this.prefix}:decisionRef; the unprefixed ${key} is removed).` : `Write the decision link the Camunda 8 way: ${command} (${this.prefix}:calledDecision; the unprefixed ${key} is removed; give it a resultVariable).`;
+    }
+    if (fits) {
+      return `Use the vendor attribute instead: \`bpmn set <file> ${id} ${Shell.quote(`${key}=`)} ${Shell.quote(`${this.prefix}:${key}=${String(el.$attrs[key] ?? '')}`)}\`.`;
+    }
+    const prefixed = this.engine === 'c8' ? 'vendor attributes need their namespace prefix; Camunda 8 settings are mostly zeebe: extension elements' : `vendor attributes need their namespace prefix, e.g. ${this.prefix}:<name>`;
+    if (remove) return `Remove it: ${remove} (${prefixed}).`;
+    if (di) {
+      return this.engine === 'c8' ? `Remove ${key}="..." from the XML of ${id ?? 'the diagram element'}, or redraw the diagram: \`bpmn layout <file>\` (the hand-made layout is lost).` : `Remove ${key}="..." from the XML of ${id ?? 'the diagram element'}, or redraw the diagram, which writes new diagram elements: \`bpmn layout <file>\` (the hand-made layout is lost).`;
+    }
+    return this.engine === 'c8' ? `Remove ${key}="..." from the XML${id ? ` of ${id}` : ''}.` : `Remove ${key}="..." from the XML${id ? ` of ${id}` : ''} (${prefixed}).`;
+  }
+
+  /** Another implementation stays, so the unprefixed attribute is no decision link. */
+  private implemented(el: ModdleElement): boolean {
+    return Object.keys(el.$attrs ?? {}).some((name) => /^[\w.-]+:(class|delegateExpression|expression|type)$/.test(name) && RuleKit.kit.CAMUNDA.reads(this.model.file.namespaces.uriOfName(name)));
+  }
+}
diff --git a/src/adapters/out/bpmnlint/engine/rules/VendorElementsRule.ts b/src/adapters/out/bpmnlint/engine/rules/VendorElementsRule.ts
new file mode 100644
index 00000000..be13efbd
--- /dev/null
+++ b/src/adapters/out/bpmnlint/engine/rules/VendorElementsRule.ts
@@ -0,0 +1,85 @@
+import { is } from 'bpmnlint-utils';
+import type { EngineKit } from '../../engine-kit.js';
+import { CamundaRule, type ModdleElement } from './CamundaRule.js';
+import { RuleKit } from './RuleKit.js';
+import { ElementKinds } from './support/ElementKinds.js';
+import { EngineScope } from './support/EngineScope.js';
+import { SetCommand } from './support/SetCommand.js';
+import { WrittenModel } from './support/WrittenModel.js';
+
+/**
+ * The extension elements of the engine's own namespace in an executable process, as the file
+ * writes them, for the rules on what the typed parse drops of them (`UnknownVendorElementsRule`,
+ * `C7IoParameterInInputOutputRule`, `C8ZeebeElementPlacementRule`).
+ * The typed parse drops an unknown or misplaced vendor element with a warning that names neither
+ * the element nor where it sat, so the rules read the extension elements of each element as the
+ * file writes them (`WrittenModel`) and report on the typed twin.
+ *
+ * @example a zeebe element outside its container
+ * <bpmn:serviceTask id="Charge">
+ *   <bpmn:extensionElements><zeebe:input source="=a" target="b" /></bpmn:extensionElements>  <!-- inside zeebe:ioMapping -->
+ * </bpmn:serviceTask>
+ */
+export abstract class VendorElementsRule extends CamundaRule {
+  protected model!: WrittenModel;
+  protected node!: ModdleElement;
+
+  protected visit(node: ModdleElement): boolean | void {
+    if (is(node, 'bpmn:Definitions')) return;
+    if (!EngineScope.inExecutableProcess(node)) return false;
+    const model = WrittenModel.of(node);
+    const host = model?.written(node);
+    if (!host) return;
+    this.model = model!;
+    this.node = node;
+    (host.extensionElements?.values ?? []).forEach((value: ModdleElement, index: number) => {
+      if (this.isOwnGeneric(value)) this.checkValue(host, value, index);
+    });
+  }
+
+  /** An extension element of the engine's namespace that the typed parse dropped, at `index` of the extension elements of `host`. */
+  protected abstract checkValue(host: ModdleElement, value: ModdleElement, index: number): void;
+
+  protected get vendor(): EngineKit['ZEEBE'] | EngineKit['CAMUNDA'] {
+    return this.engine === 'c8' ? RuleKit.kit.ZEEBE : RuleKit.kit.CAMUNDA;
+  }
+
+  protected get prefix(): string {
+    return this.model.file.namespaces.prefixOf(this.vendor.uri) ?? this.vendor.prefix;
+  }
+
+  protected isOwnGeneric(el: ModdleElement): boolean {
+    return !!el?.$descriptor?.isGeneric && this.vendor.reads(this.model.file.namespaces.uriOfElement(el));
+  }
+
+  /**
+   * A known element the typed parse drops where it sits: a camunda parameter outside
+   * camunda:inputOutput, a zeebe element that belongs inside a container (a loose zeebe:input), or
+   * zeebe:publishMessage where Camunda 8 does not read it (on an end event instead of its message
+   * event definition).
+   */
+  protected isMisplaced(host: ModdleElement, local: string): boolean {
+    if (this.engine === 'c7') {
+      return local === 'inputParameter' || local === 'outputParameter';
+    }
+    const { ZEEBE } = RuleKit.kit;
+    return ZEEBE.nestedOnly(local) || (!this.node.$model.getTypeDescriptor(ZEEBE.type(local)!.type) && ZEEBE.allowedOn(local, host) === false);
+  }
+
+  protected localName(type: string): string {
+    return type.slice(type.indexOf(':') + 1);
+  }
+
+  /**
+   * How `bpmn` addresses the extension elements of `host`: an event definition or a loop through
+   * its flow node and slot (`W definition.`, `SP loop.`), any other element by its id.
+   */
+  protected address(host: ModdleElement): { id: string | undefined; slot: string } {
+    return SetCommand.at(host) ?? { id: undefined, slot: '' };
+  }
+
+  /** `timerEventDefinition Def_T`, or `the timerEventDefinition of intermediateCatchEvent:timer W` */
+  protected where(host: ModdleElement): string {
+    return ElementKinds.describe(host, host.$parent);
+  }
+}
diff --git a/src/adapters/out/bpmnlint/engine/rules/c7/C7AdHocSubProcessNoFlowsRule.ts b/src/adapters/out/bpmnlint/engine/rules/c7/C7AdHocSubProcessNoFlowsRule.ts
new file mode 100644
index 00000000..2f240733
--- /dev/null
+++ b/src/adapters/out/bpmnlint/engine/rules/c7/C7AdHocSubProcessNoFlowsRule.ts
@@ -0,0 +1,31 @@
+import { is } from 'bpmnlint-utils';
+import { defineRule, ERROR_TYPES, type ModdleElement } from '../CamundaRule.js';
+import { C7ExecutableRule } from './C7ExecutableRule.js';
+import { C7AdHocSubProcess } from './support/C7AdHocSubProcess.js';
+
+/**
+ * An ad-hoc sub-process with sequence flows or boundary events.
+ * The engines do not run ad-hoc sub-processes: Camunda 7 refuses the file once one is connected.
+ *
+ * @example a connected ad-hoc sub-process
+ * <bpmn:adHocSubProcess id="Research" />
+ * <bpmn:sequenceFlow sourceRef="Research" targetRef="Report" />
+ */
+class C7AdHocSubProcessNoFlowsRule extends C7ExecutableRule {
+  protected checkNode(node: ModdleElement): void {
+    if (!is(node, 'bpmn:AdHocSubProcess')) return;
+    const subProcess = new C7AdHocSubProcess(node);
+    if (!subProcess.isConnected) return;
+    const { flows, incoming, boundaryEvents } = subProcess;
+    const parts = [this.listed('sequence flow', flows), this.listed('boundary event', boundaryEvents)].filter(Boolean);
+    const refusal = flows.length ? `invalid ${incoming.length ? 'destination' : 'source'} '${node.id}' of sequence flow ${flows[0].id}` : 'invalid reference in boundary event';
+    this.report(node, `Ad-hoc sub-process ${node.id} is connected (${parts.join(' and ')}); the engines do not run ad-hoc sub-processes and refuse the file (${refusal})`, { path: null, type: ERROR_TYPES.ELEMENT_TYPE_NOT_ALLOWED, flows, boundaryEvents, hint: `${subProcess.retypeHint}.` });
+  }
+
+  /** `sequence flows F1, F2`, or '' for none. */
+  private listed(kind: string, elements: ModdleElement[]): string {
+    return elements.length ? `${kind}${elements.length > 1 ? 's' : ''} ${elements.map((element) => element.id).join(', ')}` : '';
+  }
+}
+
+export default defineRule({ ruleName: 'c7-ad-hoc-sub-process-no-flows', code: 'W_C7_DEPLOY_AD_HOC_SUBPROCESS', impact: 'deploy' }, C7AdHocSubProcessNoFlowsRule);
diff --git a/src/adapters/out/bpmnlint/engine/rules/c7/C7AdHocSubProcessNoMultiInstanceRule.ts b/src/adapters/out/bpmnlint/engine/rules/c7/C7AdHocSubProcessNoMultiInstanceRule.ts
new file mode 100644
index 00000000..99f0a37e
--- /dev/null
+++ b/src/adapters/out/bpmnlint/engine/rules/c7/C7AdHocSubProcessNoMultiInstanceRule.ts
@@ -0,0 +1,28 @@
+import { is } from 'bpmnlint-utils';
+import { defineRule, ERROR_TYPES, type ModdleElement } from '../CamundaRule.js';
+import { C7ExecutableRule } from './C7ExecutableRule.js';
+import { C7AdHocSubProcess } from './support/C7AdHocSubProcess.js';
+import { C7Diagram } from './support/C7Diagram.js';
+
+/**
+ * An ad-hoc sub-process with a multi-instance loop, that nothing connects.
+ * The engines do not run ad-hoc sub-processes: Camunda 7 and CIB seven refuse the file (Operaton
+ * deploys one with a valid loop). A connected one is the flows rule's.
+ *
+ * @example an ad-hoc sub-process with a loop
+ * <bpmn:adHocSubProcess id="Research">
+ *   <bpmn:multiInstanceLoopCharacteristics />  <!-- ENGINE-01009 -->
+ * </bpmn:adHocSubProcess>
+ */
+class C7AdHocSubProcessNoMultiInstanceRule extends C7ExecutableRule {
+  protected checkNode(node: ModdleElement): void {
+    if (!is(node, 'bpmn:AdHocSubProcess') || !node.loopCharacteristics || !is(node.loopCharacteristics, 'bpmn:MultiInstanceLoopCharacteristics') || C7Diagram.of(node).operaton) {
+      return;
+    }
+    const subProcess = new C7AdHocSubProcess(node);
+    if (subProcess.isConnected) return;
+    this.report(node, `Ad-hoc sub-process ${node.id} has a multi-instance loop; the engines do not run ad-hoc sub-processes, and Camunda 7 and CIB seven refuse the file (ENGINE-01009, "activity" is null)`, { path: ['loopCharacteristics'], type: ERROR_TYPES.PROPERTY_NOT_ALLOWED, property: 'loopCharacteristics', hint: `${subProcess.retypeHint}, or drop the loop: \`bpmn set <file> ${node.id} loop=none\`.` });
+  }
+}
+
+export default defineRule({ ruleName: 'c7-ad-hoc-sub-process-no-multi-instance', code: 'W_C7_DEPLOY_AD_HOC_SUBPROCESS', impact: 'deploy' }, C7AdHocSubProcessNoMultiInstanceRule);
diff --git a/src/adapters/out/bpmnlint/engine/rules/c7/C7BindingKnownRule.ts b/src/adapters/out/bpmnlint/engine/rules/c7/C7BindingKnownRule.ts
new file mode 100644
index 00000000..1eb07720
--- /dev/null
+++ b/src/adapters/out/bpmnlint/engine/rules/c7/C7BindingKnownRule.ts
@@ -0,0 +1,28 @@
+import { defineRule, ERROR_TYPES, type ModdleElement } from '../CamundaRule.js';
+import { ElementKinds } from '../support/ElementKinds.js';
+import { SetCommand } from '../support/SetCommand.js';
+import { C7ExecutableRule } from './C7ExecutableRule.js';
+import { C7Bindings } from './support/C7Bindings.js';
+import { C7Diagram } from './support/C7Diagram.js';
+import { CamundaAttributes } from './support/CamundaAttributes.js';
+
+/**
+ * A called element, case or decision binding the engines do not know: one of a call activity or of
+ * a business rule task with a decision that is not latest, deployment, version or versionTag.
+ * Camunda 7 deploys the file but cannot resolve the reference as intended.
+ *
+ * @example an unknown binding
+ * <bpmn:callActivity id="Ship" calledElement="shipping" camunda:calledElementBinding="newest" />  <!-- latest -->
+ */
+class C7BindingKnownRule extends C7ExecutableRule {
+  protected checkNode(node: ModdleElement): void {
+    const attributes = new CamundaAttributes(node);
+    const bindings = new C7Bindings(attributes);
+    const prefix = C7Diagram.of(node).prefix;
+    for (const { binding, allowed } of bindings.of(node).filter((candidate) => bindings.problemOf(candidate) === 'value')) {
+      this.report(node, `${prefix}:${binding}="${attributes.defined(binding)}" on ${ElementKinds.describe(node)} is not one of ${allowed.join(', ')}; the engines accept the file but cannot resolve the reference as intended`, { path: [binding], type: ERROR_TYPES.PROPERTY_VALUE_NOT_ALLOWED, property: binding, hint: `${new SetCommand(node.id).of(`${prefix}:${binding}=latest`)}.` });
+    }
+  }
+}
+
+export default defineRule({ ruleName: 'c7-binding-known', code: 'W_C7_BAD_VALUE', impact: 'runtime' }, C7BindingKnownRule);
diff --git a/src/adapters/out/bpmnlint/engine/rules/c7/C7BindingNeedsVersionRule.ts b/src/adapters/out/bpmnlint/engine/rules/c7/C7BindingNeedsVersionRule.ts
new file mode 100644
index 00000000..fc7901c6
--- /dev/null
+++ b/src/adapters/out/bpmnlint/engine/rules/c7/C7BindingNeedsVersionRule.ts
@@ -0,0 +1,41 @@
+import { defineRule, ERROR_TYPES, type ModdleElement } from '../CamundaRule.js';
+import { ElementKinds } from '../support/ElementKinds.js';
+import { C7ExecutableRule } from './C7ExecutableRule.js';
+import { C7Bindings } from './support/C7Bindings.js';
+import { C7Diagram } from './support/C7Diagram.js';
+import { CamundaAttributes } from './support/CamundaAttributes.js';
+
+/**
+ * A binding of version or versionTag without the version or version tag it binds to: of a call
+ * activity, a business rule task with a decision, or a form reference.
+ * Camunda 7 refuses to deploy the file.
+ *
+ * @example a version binding without version
+ * <bpmn:callActivity id="Ship" calledElement="shipping" camunda:calledElementBinding="version" />  <!-- camunda:calledElementVersion -->
+ */
+class C7BindingNeedsVersionRule extends C7ExecutableRule {
+  protected checkNode(node: ModdleElement): void {
+    const attributes = new CamundaAttributes(node);
+    const bindings = new C7Bindings(attributes);
+    const prefix = C7Diagram.of(node).prefix;
+    for (const binding of bindings.of(node)) {
+      const problem = bindings.problemOf(binding);
+      if (problem === 'version') {
+        this.reportBindingVersion(node, binding.binding, 'version', binding.version, '<n>', prefix);
+      }
+      if (problem === 'versionTag') {
+        this.reportBindingVersion(node, binding.binding, 'versionTag', binding.versionTag!, '<tag>', prefix);
+      }
+    }
+    if (C7Bindings.hasFormRef(node, attributes) && attributes.defined('formRefBinding') === 'version' && attributes.defined('formRefVersion') === undefined) {
+      this.reportBindingVersion(node, 'formRefBinding', 'version', 'formRefVersion', '<n>', prefix);
+    }
+  }
+
+  private reportBindingVersion(node: ModdleElement, binding: string, value: string, missing: string, placeholder: string, prefix: string): void {
+    const latest = `${prefix}:${binding}=latest`;
+    this.report(node, `${ElementKinds.describe(node)} has ${prefix}:${binding}="${value}" but no ${prefix}:${missing}; the engines refuse the file`, { path: [missing], type: ERROR_TYPES.PROPERTY_DEPENDENT_REQUIRED, property: binding, dependentRequiredProperty: missing, hint: `\`bpmn set <file> ${node.id} ${prefix}:${missing}=${placeholder}\` (or ${binding === 'formRefBinding' ? latest : `\`${latest}\``}).` });
+  }
+}
+
+export default defineRule({ ruleName: 'c7-binding-needs-version', code: 'W_C7_DEPLOY_BINDING_VERSION', impact: 'deploy' }, C7BindingNeedsVersionRule);
diff --git a/src/adapters/out/bpmnlint/engine/rules/c7/C7BpmnAttributeKnownRule.ts b/src/adapters/out/bpmnlint/engine/rules/c7/C7BpmnAttributeKnownRule.ts
new file mode 100644
index 00000000..d3cc0304
--- /dev/null
+++ b/src/adapters/out/bpmnlint/engine/rules/c7/C7BpmnAttributeKnownRule.ts
@@ -0,0 +1,19 @@
+import type { Engine } from '@miragon/bpmnlint-plugin-rules/engine';
+import { defineRule } from '../CamundaRule.js';
+import { UnprefixedAttributesRule } from '../UnprefixedAttributesRule.js';
+
+/**
+ * Attributes without a namespace prefix that the BPMN schema does not define.
+ * Camunda 7 validates the file against the schema and refuses it (cvc-complex-type.3.2.2). The
+ * typed parse reads some of them as the camunda attribute of that name (`assignee` on a user task as
+ * `camunda:assignee`), so the rule reads the attributes as the file writes them.
+ * Any element of the file is checked, the diagram's included.
+ *
+ * @example a user task with an unprefixed assignee
+ * <bpmn:userTask id="Review" assignee="demo" />  <!-- camunda:assignee -->
+ */
+class C7BpmnAttributeKnownRule extends UnprefixedAttributesRule {
+  protected readonly engine: Engine = 'c7';
+}
+
+export default defineRule({ ruleName: 'c7-bpmn-attribute-known', code: 'W_C7_DEPLOY_SCHEMA', impact: 'deploy' }, C7BpmnAttributeKnownRule);
diff --git a/src/adapters/out/bpmnlint/engine/rules/c7/C7CallActivityOneCalledElementRule.ts b/src/adapters/out/bpmnlint/engine/rules/c7/C7CallActivityOneCalledElementRule.ts
new file mode 100644
index 00000000..efc12e98
--- /dev/null
+++ b/src/adapters/out/bpmnlint/engine/rules/c7/C7CallActivityOneCalledElementRule.ts
@@ -0,0 +1,28 @@
+import { is } from 'bpmnlint-utils';
+import { defineRule, ERROR_TYPES, type ModdleElement } from '../CamundaRule.js';
+import { C7ExecutableRule } from './C7ExecutableRule.js';
+import { C7Diagram } from './support/C7Diagram.js';
+import { CamundaAttributes } from './support/CamundaAttributes.js';
+
+/**
+ * A call activity with neither calledElement nor camunda:caseRef, or with both.
+ * Camunda 7 calls exactly one process or case and refuses to deploy the file.
+ *
+ * @example a call activity that calls nothing
+ * <bpmn:callActivity id="Ship" />  <!-- calledElement="shipping" -->
+ */
+class C7CallActivityOneCalledElementRule extends C7ExecutableRule {
+  protected checkNode(node: ModdleElement): void {
+    if (!is(node, 'bpmn:CallActivity')) return;
+    const prefix = C7Diagram.of(node).prefix;
+    const caseRef = new CamundaAttributes(node).defined('caseRef');
+    const calledElement: string | undefined = node.get('calledElement');
+    if (calledElement === undefined && caseRef === undefined) {
+      this.report(node, `Call activity ${node.id} has no calledElement (nor ${prefix}:caseRef); the engines refuse the file`, { path: ['calledElement'], type: ERROR_TYPES.PROPERTY_REQUIRED, requiredProperty: 'calledElement', hint: `\`bpmn set <file> ${node.id} calledElement=<processId>\`.` });
+    } else if (calledElement !== undefined && caseRef !== undefined) {
+      this.report(node, `Call activity ${node.id} has both calledElement and ${prefix}:caseRef; the engines refuse the file`, { path: ['caseRef'], type: ERROR_TYPES.PROPERTY_NOT_ALLOWED, property: 'caseRef', hint: `Keep one: \`bpmn set <file> ${node.id} ${prefix}:caseRef=\`.` });
+    }
+  }
+}
+
+export default defineRule({ ruleName: 'c7-call-activity-one-called-element', code: 'W_C7_DEPLOY_CALLED_ELEMENT', impact: 'deploy' }, C7CallActivityOneCalledElementRule);
diff --git a/src/adapters/out/bpmnlint/engine/rules/c7/C7CallMappingNeedsSourceAndTargetRule.ts b/src/adapters/out/bpmnlint/engine/rules/c7/C7CallMappingNeedsSourceAndTargetRule.ts
new file mode 100644
index 00000000..675372e7
--- /dev/null
+++ b/src/adapters/out/bpmnlint/engine/rules/c7/C7CallMappingNeedsSourceAndTargetRule.ts
@@ -0,0 +1,36 @@
+import { defineRule, ERROR_TYPES } from '../CamundaRule.js';
+import { C7ExtensionContentRule } from './C7ExtensionContentRule.js';
+import type { C7Host, HostExtension } from './support/C7Host.js';
+
+/**
+ * A camunda:in or camunda:out without source (or sourceExpression) or without target, and without
+ * variables="all" (or a businessKey of camunda:in).
+ * Camunda 7 refuses to deploy the file.
+ *
+ * @example a call activity mapping without target
+ * <camunda:in source="orderId" />  <!-- target="orderId" -->
+ */
+class C7CallMappingNeedsSourceAndTargetRule extends C7ExtensionContentRule {
+  protected checkHost(host: C7Host, read: HostExtension[]): void {
+    for (const extension of read) {
+      if (extension.local === 'in' || extension.local === 'out') {
+        this.checkBinding(host, extension);
+      }
+    }
+  }
+
+  private checkBinding(host: C7Host, extension: HostExtension): void {
+    const { value, index, local } = extension;
+    if (value.get('variables') !== undefined || (local === 'in' && value.get('businessKey') !== undefined)) {
+      return;
+    }
+    const hasSource = value.get('source') !== undefined || value.get('sourceExpression') !== undefined;
+    const hasTarget = value.get('target') !== undefined;
+    if (hasSource && hasTarget) return;
+    const missing = [!hasSource ? 'source or sourceExpression' : '', !hasTarget ? 'target' : ''].filter(Boolean).join(' and ');
+    const fix = { ...(hasSource ? {} : { source: '<var>' }), ...(hasTarget ? {} : { target: '<var>' }) };
+    this.reportOn(host, `${host.typeName(local)} of ${host.describe()} has no ${missing} (and no variables="all"${local === 'in' ? ' / businessKey' : ''}); the engines refuse the file`, { path: hasSource ? host.extensionPath(index, 'target') : host.extensionPath(index), type: ERROR_TYPES.PROPERTY_REQUIRED, node: value, requiredProperty: hasSource ? 'target' : ['source', 'sourceExpression', ...(hasTarget ? [] : ['target'])], hint: `${host.rebuild(extension, fix).replace(/\.$/, '')} (or with variables=all instead of source and target).` });
+  }
+}
+
+export default defineRule({ ruleName: 'c7-call-mapping-needs-source-and-target', code: 'W_C7_DEPLOY_EXTENSION', impact: 'deploy' }, C7CallMappingNeedsSourceAndTargetRule);
diff --git a/src/adapters/out/bpmnlint/engine/rules/c7/C7CamundaAttributeKnownRule.ts b/src/adapters/out/bpmnlint/engine/rules/c7/C7CamundaAttributeKnownRule.ts
new file mode 100644
index 00000000..f5325bf2
--- /dev/null
+++ b/src/adapters/out/bpmnlint/engine/rules/c7/C7CamundaAttributeKnownRule.ts
@@ -0,0 +1,65 @@
+import { defineRule, ERROR_TYPES, type ModdleElement, type ReportData } from '../CamundaRule.js';
+import { RuleKit } from '../RuleKit.js';
+import { CAMUNDA_URI } from '../support/DiagramNamespaces.js';
+import { DidYouMean } from '../support/DidYouMean.js';
+import { ElementKinds } from '../support/ElementKinds.js';
+import { Shell } from '../support/Shell.js';
+import { C7VendorContentRule } from './C7VendorContentRule.js';
+import { CamundaPlacement } from './support/CamundaPlacement.js';
+import type { C7Host } from './support/C7Host.js';
+
+/** Attributes the engines read that the descriptor knows as child elements only. */
+const EXTRA_ATTRIBUTES: Record<string, string[]> = { 'camunda:Field': ['expression'] };
+
+/**
+ * A camunda attribute that does not exist, on a BPMN element or inside a camunda extension element
+ * the engines read, with the one it most likely means.
+ * Camunda 7 deploys the file and ignores it.
+ *
+ * @example a typo in an attribute name
+ * <bpmn:userTask id="Review" camunda:asignee="demo" />  <!-- nobody gets assigned -->
+ */
+class C7CamundaAttributeKnownRule extends C7VendorContentRule {
+  private readonly camunda = RuleKit.kit.CAMUNDA;
+
+  protected checkHost(host: C7Host): void {
+    this.checkUnknownAttributes(host);
+    if (host.isDefinitions()) return;
+    for (const extension of new CamundaPlacement(host).readExtensions()) {
+      for (const { element, where, path, key } of host.treeAttributes(extension)) {
+        if (!key.includes(':')) {
+          this.reportUnknownAttribute(host, where, key, { property: key, path: [...path, key], node: element, hint: host.rebuild(extension) }, DidYouMean.suggestion(key, this.attributeNamesOf(element)));
+        }
+      }
+    }
+  }
+
+  /** A camunda attribute the descriptor does not know: rename it to the one it most likely means, else remove it. */
+  private checkUnknownAttributes(host: C7Host): void {
+    for (const { key, local, uri } of host.foreignAttributes()) {
+      if (uri !== CAMUNDA_URI || this.camunda.attr(local)) continue;
+      const prefix = key.slice(0, key.indexOf(':'));
+      const names = this.camunda.attrs().map(({ name }) => name.slice(name.indexOf(':') + 1));
+      const applicable = names.filter((name) => this.camunda.attr(name)!.owners.some((owner) => host.node.$instanceOf(owner)));
+      const guess = DidYouMean.of(local, names, applicable);
+      const fits = guess !== undefined && applicable.includes(guess);
+      const unset = host.address && `bpmn set <file> ${host.address.id} ${Shell.quote(`${host.address.slot}${key}=`)}`;
+      const rename = fits ? ` ${Shell.quote(`${host.address?.slot}${prefix}:${guess}=${String(host.node.$attrs[key] ?? '')}`)}` : '';
+      const hint = unset ? `${rename ? 'Rename' : 'Remove'} it: \`${unset}${rename}\`.` : 'Remove it: edit the XML.';
+      this.reportUnknownAttribute(host, host.describe(), key, { property: `camunda:${local}`, path: host.path(`camunda:${local}`), hint }, guess ? ` (did you mean ${prefix}:${guess}?${fits ? '' : ` It applies to ${ElementKinds.list(this.camunda.attr(guess)?.owners ?? [], 4)} only.`})` : '');
+    }
+  }
+
+  /** The attributes of a camunda element: its descriptor's, and the ones the engines read that it knows as child elements only. */
+  private attributeNamesOf(element: ModdleElement): string[] {
+    const names: string[] = (element.$descriptor?.properties ?? []).filter((property: { isAttr?: boolean; isReference?: boolean; isMany?: boolean }) => property.isAttr || (property.isReference && !property.isMany)).map((property: { name: string; ns?: { localName?: string } }) => property.ns?.localName ?? property.name);
+    return [...new Set([...names, ...(EXTRA_ATTRIBUTES[element.$type] ?? [])])];
+  }
+
+  /** `name` on `where`, which the descriptor does not know; `suggestion` names the one it most likely means. */
+  private reportUnknownAttribute(host: C7Host, where: string, name: string, data: Pick<ReportData, 'path'> & Record<string, unknown>, suggestion: string): void {
+    this.reportContent(host, `${where} has the unknown attribute ${name}${suggestion}; the engines ignore it`, { type: ERROR_TYPES.PROPERTY_NOT_ALLOWED, ...data });
+  }
+}
+
+export default defineRule({ ruleName: 'c7-camunda-attribute-known', code: 'W_C7_UNKNOWN_ATTRIBUTE', impact: 'runtime' }, C7CamundaAttributeKnownRule);
diff --git a/src/adapters/out/bpmnlint/engine/rules/c7/C7CamundaAttributePlacementRule.ts b/src/adapters/out/bpmnlint/engine/rules/c7/C7CamundaAttributePlacementRule.ts
new file mode 100644
index 00000000..e4e22ac4
--- /dev/null
+++ b/src/adapters/out/bpmnlint/engine/rules/c7/C7CamundaAttributePlacementRule.ts
@@ -0,0 +1,59 @@
+import { is } from 'bpmnlint-utils';
+import { defineRule, ERROR_TYPES, type ModdleElement } from '../CamundaRule.js';
+import { RuleKit } from '../RuleKit.js';
+import { CAMUNDA_URI } from '../support/DiagramNamespaces.js';
+import { ElementKinds } from '../support/ElementKinds.js';
+import { Shell } from '../support/Shell.js';
+import { C7VendorContentRule } from './C7VendorContentRule.js';
+import { CamundaPlacement } from './support/CamundaPlacement.js';
+import type { C7Host } from './support/C7Host.js';
+
+/**
+ * A camunda attribute on an element type it does not apply to, or on the side of an event that
+ * ignores it, with where it belongs on the element instead.
+ * Camunda 7 deploys the file and ignores it.
+ *
+ * @example a multi-instance attribute on the activity
+ * <bpmn:userTask id="Review" camunda:collection="${reviewers}" />  <!-- on the multi-instance loop -->
+ */
+class C7CamundaAttributePlacementRule extends C7VendorContentRule {
+  protected checkHost(host: C7Host): void {
+    const remove = (key: string, withoutAddress: string) => (host.unset(key) ? `Remove it: ${host.unset(key)}.` : withoutAddress);
+    const report = (key: string, local: string, readOn: string, hint: string) => this.reportContent(host, `${key} on ${host.describe()} has no effect: the engines read it on ${readOn} only`, { type: ERROR_TYPES.PROPERTY_NOT_ALLOWED, property: `camunda:${local}`, path: host.path(`camunda:${local}`), hint });
+    for (const { key, local, uri } of host.foreignAttributes()) {
+      const owners = uri === CAMUNDA_URI ? RuleKit.kit.CAMUNDA.attr(local)?.owners : undefined;
+      if (owners && !owners.some((owner) => host.node.$instanceOf(owner))) {
+        report(key, local, ElementKinds.list(owners, 4), this.moveHint(host, key, `${local}=${String(host.node.$attrs[key] ?? '')}`, owners) ?? remove(key, 'Remove it from the XML.'));
+      }
+    }
+    const placement = new CamundaPlacement(host);
+    for (const local of CamundaPlacement.sideAttributes()) {
+      const side = placement.wrongSide(local, 'attributes');
+      const property = host.node.$descriptor?.propertiesByName?.[`camunda:${local}`];
+      if (side && property && Object.prototype.hasOwnProperty.call(host.node, property.name)) {
+        report(host.typeName(local), local, side, remove(host.typeName(local), 'Remove it: edit the XML.'));
+      }
+    }
+  }
+
+  /** Where the attribute belongs on the element itself: the event definition of an event, the multi-instance loop of an activity, the condition of a flow; undefined when it belongs nowhere on it. `assignment` is `<local>=<value>`. */
+  private moveHint(host: C7Host, key: string, assignment: string, owners: string[]): string | undefined {
+    const { node, address } = host;
+    if (!address || address.slot !== '') return undefined;
+    const move = (slot: string) => `\`bpmn set <file> ${address.id} ${Shell.quote(`${key}=`)} ${Shell.quote(`${slot}${host.prefix}:${assignment}`)}\``;
+    const definitions: ModdleElement[] = node.eventDefinitions ?? [];
+    const fit = definitions.findIndex((definition) => owners.some((owner) => is(definition, owner)));
+    if (is(node, 'bpmn:Event') && fit !== -1) {
+      return `It belongs on the event definition: ${move(definitions.length > 1 ? `definition[${fit}].` : 'definition.')}.`;
+    }
+    if (is(node, 'bpmn:Activity') && owners.includes('bpmn:MultiInstanceLoopCharacteristics')) {
+      return `It belongs on the multi-instance loop: ${move('loop.')}${node.loopCharacteristics && is(node.loopCharacteristics, 'bpmn:MultiInstanceLoopCharacteristics') ? '' : ' (creates a parallel multi-instance loop)'}.`;
+    }
+    if (is(node, 'bpmn:SequenceFlow') && owners.includes('bpmn:FormalExpression') && node.conditionExpression) {
+      return `It belongs on the condition: ${move('condition.')}.`;
+    }
+    return undefined;
+  }
+}
+
+export default defineRule({ ruleName: 'c7-camunda-attribute-placement', code: 'W_C7_MISPLACED_ATTRIBUTE', impact: 'runtime' }, C7CamundaAttributePlacementRule);
diff --git a/src/adapters/out/bpmnlint/engine/rules/c7/C7CamundaBooleanValidRule.ts b/src/adapters/out/bpmnlint/engine/rules/c7/C7CamundaBooleanValidRule.ts
new file mode 100644
index 00000000..b608d64e
--- /dev/null
+++ b/src/adapters/out/bpmnlint/engine/rules/c7/C7CamundaBooleanValidRule.ts
@@ -0,0 +1,71 @@
+import { C7Rule, defineRule, ERROR_TYPES, type ModdleElement } from '../CamundaRule.js';
+import { RuleKit } from '../RuleKit.js';
+import { ElementKinds } from '../support/ElementKinds.js';
+import { SetCommand } from '../support/SetCommand.js';
+import { WrittenModel } from '../support/WrittenModel.js';
+
+/**
+ * camunda booleans other than the exact `true` / `false`.
+ * The engines read only `true`, so `yes` or `TRUE` leave a setting off. The typed parse turns such
+ * a value into `false`, so the rule reads the values as the file writes them: the attributes of BPMN
+ * elements and of camunda extension elements.
+ *
+ * @example a task that is not asynchronous
+ * <bpmn:serviceTask id="Charge" camunda:asyncBefore="yes" />  <!-- read as false -->
+ */
+class C7CamundaBooleanValidRule extends C7Rule {
+  private model!: WrittenModel;
+
+  protected visit(node: ModdleElement): void {
+    const model = WrittenModel.of(node);
+    const el = model?.written(node);
+    if (!el) return;
+    this.model = model!;
+    this.checkAttributes(el);
+    for (const value of el.extensionElements?.values ?? []) {
+      this.checkVendorElement(el, value, '');
+    }
+  }
+
+  private checkAttributes(el: ModdleElement): void {
+    const { kit } = RuleKit;
+    for (const [key, raw] of Object.entries(el.$attrs ?? {})) {
+      if (!kit.CAMUNDA.reads(this.model.file.namespaces.uriOfName(key))) continue;
+      const def = kit.CAMUNDA.attr(key.slice(key.indexOf(':') + 1));
+      if (def?.type !== 'Boolean' || !def.owners.some((ownerType) => kit.is(el, ownerType))) {
+        continue;
+      }
+      const value = String(raw ?? '');
+      if (value === 'true' || value === 'false') continue;
+      const address = SetCommand.at(el);
+      this.reportValue(el, address, `${key}="${value}" on ${ElementKinds.describe(el)} is not true or false; the engines read only the exact value true (yes, TRUE or True leave it off)`, `attr:${key}`, address ? `\`bpmn set <file> ${address.id} ${address.slot}${key}=true\` (or =false).` : 'Use true or false in the XML.');
+    }
+  }
+
+  private checkVendorElement(host: ModdleElement, vendorElement: ModdleElement, path: string): void {
+    if (!RuleKit.kit.CAMUNDA.reads(this.model.file.namespaces.uriOfElement(vendorElement))) {
+      return;
+    }
+    const local = vendorElement.$type.slice(vendorElement.$type.indexOf(':') + 1);
+    const vendorType = RuleKit.kit.CAMUNDA.type(local);
+    if (!vendorType) return;
+    for (const property of vendorType.properties) {
+      if (property.type !== 'Boolean' || !property.isAttr) continue;
+      const raw = vendorElement[property.name];
+      if (raw === undefined || raw === true || raw === false || raw === 'true' || raw === 'false') {
+        continue;
+      }
+      const address = SetCommand.at(host);
+      this.reportValue(host, address, `${property.name}="${String(raw)}" on ${vendorElement.$type}${path ? ` (in ${path})` : ''} of ${ElementKinds.describe(host)} is not true or false; the engines read only the exact value true`, `ext:${path}/${local}@${property.name}`, address ? `See it with \`bpmn ext list <file> ${address.id} --json\`, then rebuild it with \`bpmn ext add <file> ${address.id} ... --replace\` and ${property.name}=true (or false).` : 'Use true or false in the XML.');
+    }
+    for (const child of vendorElement.$children ?? []) {
+      this.checkVendorElement(host, child, path ? `${path} > ${vendorElement.$type}` : vendorElement.$type);
+    }
+  }
+
+  private reportValue(el: ModdleElement, address: SetCommand | undefined, message: string, subject: string, hint: string): void {
+    this.report(this.model.typed(address?.slot ? el.$parent : el), message, { path: null, type: ERROR_TYPES.PROPERTY_VALUE_NOT_ALLOWED, writtenAt: this.model.position(el), subject, hint });
+  }
+}
+
+export default defineRule({ ruleName: 'c7-camunda-boolean-valid', code: 'W_C7_BAD_VALUE', impact: 'runtime' }, C7CamundaBooleanValidRule);
diff --git a/src/adapters/out/bpmnlint/engine/rules/c7/C7CamundaElementKnownRule.ts b/src/adapters/out/bpmnlint/engine/rules/c7/C7CamundaElementKnownRule.ts
new file mode 100644
index 00000000..07739848
--- /dev/null
+++ b/src/adapters/out/bpmnlint/engine/rules/c7/C7CamundaElementKnownRule.ts
@@ -0,0 +1,20 @@
+import type { Engine } from '@miragon/bpmnlint-plugin-rules/engine';
+import { defineRule } from '../CamundaRule.js';
+import { UnknownVendorElementsRule } from '../UnknownVendorElementsRule.js';
+
+/**
+ * camunda extension elements of an executable process that the camunda descriptor does not know,
+ * directly in the extension elements or inside a known one.
+ * The engines ignore them. The typed parse drops them with an import warning that names neither the
+ * element nor where it sat, so the rule reads the extension elements as the file writes them.
+ *
+ * @example a misspelled extension element
+ * <bpmn:serviceTask id="Charge">
+ *   <bpmn:extensionElements><camunda:inputOutputs /></bpmn:extensionElements>  <!-- camunda:inputOutput -->
+ * </bpmn:serviceTask>
+ */
+class C7CamundaElementKnownRule extends UnknownVendorElementsRule {
+  protected readonly engine: Engine = 'c7';
+}
+
+export default defineRule({ ruleName: 'c7-camunda-element-known', code: 'W_C7_UNKNOWN_ELEMENT', impact: 'runtime' }, C7CamundaElementKnownRule);
diff --git a/src/adapters/out/bpmnlint/engine/rules/c7/C7CamundaExtensionPlacementRule.ts b/src/adapters/out/bpmnlint/engine/rules/c7/C7CamundaExtensionPlacementRule.ts
new file mode 100644
index 00000000..780abaf3
--- /dev/null
+++ b/src/adapters/out/bpmnlint/engine/rules/c7/C7CamundaExtensionPlacementRule.ts
@@ -0,0 +1,50 @@
+import { defineRule, ERROR_TYPES } from '../CamundaRule.js';
+import { ElementKinds } from '../support/ElementKinds.js';
+import { C7VendorContentRule } from './C7VendorContentRule.js';
+import { C7Host, type HostExtension } from './support/C7Host.js';
+import { CamundaPlacement, type Misplacement } from './support/CamundaPlacement.js';
+
+/**
+ * A camunda extension element on an element type that ignores it, on the side of an event that
+ * ignores it, or loose instead of inside its container.
+ * Camunda 7 deploys the file and ignores it.
+ *
+ * @example a task listener on a service task
+ * <bpmn:serviceTask id="Charge">
+ *   <bpmn:extensionElements><camunda:taskListener event="create" class="org.acme.Audit" /></bpmn:extensionElements>  <!-- user tasks only -->
+ * </bpmn:serviceTask>
+ */
+class C7CamundaExtensionPlacementRule extends C7VendorContentRule {
+  protected checkHost(host: C7Host): void {
+    if (host.isDefinitions()) return;
+    const placement = new CamundaPlacement(host);
+    for (const extension of host.camundaExtensions()) {
+      const misplacement = placement.misplacementOf(extension);
+      if (!misplacement) continue;
+      const type = host.typeName(extension.local);
+      const message = misplacement.kind === 'loose' ? `${type} sits directly in the extension elements of ${host.describe()}, but belongs inside ${misplacement.containers}; the engines ignore it` : `${type} on ${host.describe()} has no effect: the engines read it on ${misplacement.readOn} only`;
+      this.reportContent(host, message, { type: ERROR_TYPES.EXTENSION_ELEMENT_NOT_ALLOWED, extensionElement: extension.value, path: host.extensionPath(extension.index), node: extension.value, hint: this.misplacedHint(host, extension, misplacement) });
+    }
+  }
+
+  /** Remove it; a loose element is added again into its container, one the flow node reads is moved there. */
+  private misplacedHint(host: C7Host, extension: HostExtension, { kind }: Misplacement): string {
+    const address = host.address;
+    if (kind === 'side') {
+      return host.address ? `Remove it: ${host.address.extRemove(host.selector(extension))}.` : 'Remove it from the XML.';
+    }
+    if (!address) {
+      return kind === 'loose' ? 'Fix it in the XML.' : 'Remove it from the XML.';
+    }
+    const type = host.typeName(extension.local);
+    const again = C7Host.extAddArguments(extension.value, type);
+    if (kind === 'loose') {
+      return `Remove it (${address.extRemove(extension.index)}) and add it again, \`bpmn ext add\` files it into its container: ${address.extAdd(again ?? `${type} --xml '...'`)}.`;
+    }
+    const owner = host.owner;
+    const moves = owner?.id && again && CamundaPlacement.isReadOn(extension.local, owner) && !new C7Host(owner).camundaExtensions(extension.local).length;
+    return `Remove it: ${address.extRemove(extension.index)}${moves ? `, then add it to ${ElementKinds.describe(owner)}, where the engines read it: \`bpmn ext add <file> ${owner.id} ${again}\`` : ''}.`;
+  }
+}
+
+export default defineRule({ ruleName: 'c7-camunda-extension-placement', code: 'W_C7_MISPLACED_EXTENSION', impact: 'runtime' }, C7CamundaExtensionPlacementRule);
diff --git a/src/adapters/out/bpmnlint/engine/rules/c7/C7CamundaReferenceResolvesRule.ts b/src/adapters/out/bpmnlint/engine/rules/c7/C7CamundaReferenceResolvesRule.ts
new file mode 100644
index 00000000..ccfe6b53
--- /dev/null
+++ b/src/adapters/out/bpmnlint/engine/rules/c7/C7CamundaReferenceResolvesRule.ts
@@ -0,0 +1,43 @@
+import { is } from 'bpmnlint-utils';
+import { defineRule, ERROR_TYPES, type ModdleElement } from '../CamundaRule.js';
+import { DiagramNamespaces } from '../support/DiagramNamespaces.js';
+import { ElementKinds } from '../support/ElementKinds.js';
+import { C7VendorContentRule } from './C7VendorContentRule.js';
+import { C7Diagram } from './support/C7Diagram.js';
+import type { C7Host, HostExtension } from './support/C7Host.js';
+
+/**
+ * An id reference of a camunda extension element (the errorRef of camunda:errorEventDefinition)
+ * that names no element of the type it needs.
+ * Camunda 7 deploys the file and ignores the mapping when it runs.
+ *
+ * @example an error mapping to an error that does not exist
+ * <camunda:errorEventDefinition errorRef="Error_Gone" expression="${failed}" />
+ */
+class C7CamundaReferenceResolvesRule extends C7VendorContentRule {
+  protected checkHost(host: C7Host): void {
+    if (host.isDefinitions()) return;
+    for (const extension of host.camundaExtensions()) {
+      this.checkReferences(host, extension);
+    }
+  }
+
+  private checkReferences(host: C7Host, extension: HostExtension): void {
+    const element = extension.value;
+    for (const property of element.$descriptor?.properties ?? []) {
+      if (!property.isReference || !property.isAttr || property.isMany) continue;
+      const name: string = property.ns?.localName ?? property.name;
+      const referenced = element.get(property.name);
+      const unresolved = C7Diagram.unresolved(element).get(name);
+      if (referenced ? referenced.$instanceOf(property.type) : unresolved === undefined) {
+        continue;
+      }
+      const id = referenced ? referenced.id : unresolved;
+      const typeName = property.type.replace(/^bpmn:/, '');
+      const candidates = (DiagramNamespaces.definitionsOf(host.node)?.rootElements ?? []).filter((root: ModdleElement) => is(root, property.type)).map((root: ModdleElement) => root.id ?? '').slice(0, 5);
+      this.reportContent(host, `${host.typeName(extension.local)} of ${host.describe()} references ${name}="${id}", which is not a ${property.type} in the file; the engines ignore the mapping when it runs`, { path: host.extensionPath(extension.index, name), type: ERROR_TYPES.PROPERTY_VALUE_NOT_ALLOWED, node: element, property: name, hint: `Point it at an existing one${candidates.length ? ` (${candidates.join(', ')})` : ''}. ${host.rebuild(extension, { [name]: `<${ElementKinds.xmlName(typeName)}Id>` })}` });
+    }
+  }
+}
+
+export default defineRule({ ruleName: 'c7-camunda-reference-resolves', code: 'W_C7_DANGLING_REF', impact: 'runtime' }, C7CamundaReferenceResolvesRule);
diff --git a/src/adapters/out/bpmnlint/engine/rules/c7/C7CompensationNamesOwnActivityRule.ts b/src/adapters/out/bpmnlint/engine/rules/c7/C7CompensationNamesOwnActivityRule.ts
new file mode 100644
index 00000000..aa9e3e70
--- /dev/null
+++ b/src/adapters/out/bpmnlint/engine/rules/c7/C7CompensationNamesOwnActivityRule.ts
@@ -0,0 +1,49 @@
+import { is, isAny } from 'bpmnlint-utils';
+import { C7Rule, defineRule, ERROR_TYPES, type ModdleElement } from '../CamundaRule.js';
+import { ElementKinds } from '../support/ElementKinds.js';
+import { EngineScope } from '../support/EngineScope.js';
+import { SetCommand } from '../support/SetCommand.js';
+import { Shell } from '../support/Shell.js';
+import { C7EventDefinitions } from './support/C7EventDefinitions.js';
+
+/**
+ * A compensation throw or end event whose activityRef names an activity outside its own
+ * (sub-)process, for an event sub-process outside it and its parent scope, or no flow node at all.
+ * Camunda 7 compensates only activities of the throw event's own scope and refuses to deploy the
+ * file.
+ *
+ * @example a compensation of an activity in another sub-process
+ * <bpmn:endEvent id="Undo">
+ *   <bpmn:compensateEventDefinition activityRef="Book" />  <!-- Book sits in another sub-process -->
+ * </bpmn:endEvent>
+ */
+class C7CompensationNamesOwnActivityRule extends C7Rule {
+  protected visit(node: ModdleElement): void {
+    if (!isAny(node, ['bpmn:IntermediateThrowEvent', 'bpmn:EndEvent']) || !EngineScope.C7.contains(node)) {
+      return;
+    }
+    const definitions = new C7EventDefinitions(node);
+    for (const definition of definitions.actedOn()) {
+      if (is(definition, 'bpmn:CompensateEventDefinition')) {
+        this.checkCompensation(node, definition, definitions);
+      }
+    }
+  }
+
+  private checkCompensation(event: ModdleElement, definition: ModdleElement, definitions: C7EventDefinitions): void {
+    const activity = definition.activityRef;
+    const scope = EngineScope.scopeOf(event);
+    if (!activity || !scope) return;
+    const allowed = EngineScope.isEventSubProcess(scope) ? [scope, EngineScope.scopeOf(scope)] : [scope];
+    const isFlowNode = is(activity, 'bpmn:FlowNode');
+    if (isFlowNode && allowed.includes(EngineScope.scopeOf(activity))) return;
+    const scopeId = scope.id ?? '<scopeId>';
+    const named = isFlowNode ? `${ElementKinds.describe(activity)}, which is not in ${scopeId}` : `${activity.id}, which is not a flow node`;
+    const key = `${SetCommand.forDefinition(event, definitions.all().indexOf(definition)).slot}activityRef`;
+    const candidates = (scope.flowElements ?? []).filter((element: ModdleElement) => is(element, 'bpmn:Activity') && !EngineScope.isEventSubProcess(element) && element.id).map((element: ModdleElement) => element.id).slice(0, 5);
+    const listed = candidates.length ? ` (in ${scopeId}: ${candidates.join(', ')})` : '';
+    this.report(event, `Compensation event ${event.id} names activityRef ${named}; the engines compensate only activities of the throw event's own (sub-)process and refuse the file`, { path: definitions.pathTo(definition, 'activityRef'), type: ERROR_TYPES.PROPERTY_VALUE_NOT_ALLOWED, node: definition, property: 'activityRef', activityRef: activity, hint: `\`bpmn set <file> ${event.id} ${Shell.quote(`${key}=<activityId>`)}\`${listed}, or compensate the whole scope: \`bpmn set <file> ${event.id} ${Shell.quote(`${key}=`)}\`.` });
+  }
+}
+
+export default defineRule({ ruleName: 'c7-compensation-names-own-activity', code: 'W_C7_DEPLOY_EVENT_DEFINITION', impact: 'deploy' }, C7CompensationNamesOwnActivityRule);
diff --git a/src/adapters/out/bpmnlint/engine/rules/c7/C7ComplexGatewayNoFlowsRule.ts b/src/adapters/out/bpmnlint/engine/rules/c7/C7ComplexGatewayNoFlowsRule.ts
new file mode 100644
index 00000000..73f301f4
--- /dev/null
+++ b/src/adapters/out/bpmnlint/engine/rules/c7/C7ComplexGatewayNoFlowsRule.ts
@@ -0,0 +1,26 @@
+import { is } from 'bpmnlint-utils';
+import { defineRule, ERROR_TYPES, type ModdleElement } from '../CamundaRule.js';
+import { C7ExecutableRule } from './C7ExecutableRule.js';
+import { C7FlowGraph } from './support/C7FlowGraph.js';
+
+/**
+ * A complex gateway a sequence flow connects.
+ * The engines do not run complex gateways: Camunda 7 refuses the file; one nothing connects deploys.
+ *
+ * @example a connected complex gateway
+ * <bpmn:complexGateway id="Join" />
+ * <bpmn:sequenceFlow sourceRef="Join" targetRef="Ship" />
+ */
+class C7ComplexGatewayNoFlowsRule extends C7ExecutableRule {
+  protected checkNode(node: ModdleElement): void {
+    if (!is(node, 'bpmn:ComplexGateway')) return;
+    const graph = C7FlowGraph.forElement(node);
+    const incoming = graph.incoming(node);
+    const flows = [...incoming, ...graph.outgoing(node)];
+    if (flows.length) {
+      this.report(node, `Complex gateway ${node.id} is connected; the engines do not run complex gateways and refuse the file (invalid ${incoming.length ? 'destination' : 'source'} '${node.id}' of sequence flow ${flows[0].id})`, { path: null, type: ERROR_TYPES.ELEMENT_TYPE_NOT_ALLOWED, flows, hint: `\`bpmn retype <file> ${node.id} inclusiveGateway\` (or exclusiveGateway: one path).` });
+    }
+  }
+}
+
+export default defineRule({ ruleName: 'c7-complex-gateway-no-flows', code: 'W_C7_DEPLOY_COMPLEX_GATEWAY', impact: 'deploy' }, C7ComplexGatewayNoFlowsRule);
diff --git a/src/adapters/out/bpmnlint/engine/rules/c7/C7ConditionalEventNeedsConditionRule.ts b/src/adapters/out/bpmnlint/engine/rules/c7/C7ConditionalEventNeedsConditionRule.ts
new file mode 100644
index 00000000..8aee3bad
--- /dev/null
+++ b/src/adapters/out/bpmnlint/engine/rules/c7/C7ConditionalEventNeedsConditionRule.ts
@@ -0,0 +1,22 @@
+import { is } from 'bpmnlint-utils';
+import { defineRule, ERROR_TYPES, type ModdleElement } from '../CamundaRule.js';
+import { Shell } from '../support/Shell.js';
+import { C7EventDefinitionSchemaRule } from './C7EventDefinitionSchemaRule.js';
+
+/**
+ * A conditional event definition without condition element, also one the engines ignore.
+ * The BPMN schema requires the condition: Camunda 7 refuses to deploy the file.
+ *
+ * @example a conditional event without condition
+ * <bpmn:intermediateCatchEvent id="Ready"><bpmn:conditionalEventDefinition /></bpmn:intermediateCatchEvent>
+ */
+class C7ConditionalEventNeedsConditionRule extends C7EventDefinitionSchemaRule {
+  protected checkDefinition(definition: ModdleElement): void {
+    if (!is(definition, 'bpmn:ConditionalEventDefinition') || definition.condition) {
+      return;
+    }
+    this.reportSchema(definition, `${this.subjectName(definition, 'Conditional event')} has no condition element, which the BPMN schema requires; the engines refuse the file`, { path: this.subjectPath(definition, 'condition'), type: ERROR_TYPES.PROPERTY_REQUIRED, requiredProperty: 'condition', hint: this.subjectHint(definition, Shell.quote('when=${expression}')) });
+  }
+}
+
+export default defineRule({ ruleName: 'c7-conditional-event-needs-condition', code: 'W_C7_DEPLOY_EVENT_DEFINITION', impact: 'deploy' }, C7ConditionalEventNeedsConditionRule);
diff --git a/src/adapters/out/bpmnlint/engine/rules/c7/C7ConnectorNeedsIdRule.ts b/src/adapters/out/bpmnlint/engine/rules/c7/C7ConnectorNeedsIdRule.ts
new file mode 100644
index 00000000..4ebd9fed
--- /dev/null
+++ b/src/adapters/out/bpmnlint/engine/rules/c7/C7ConnectorNeedsIdRule.ts
@@ -0,0 +1,23 @@
+import { defineRule, ERROR_TYPES } from '../CamundaRule.js';
+import { C7ExtensionContentRule } from './C7ExtensionContentRule.js';
+import type { C7Host, HostExtension } from './support/C7Host.js';
+
+/**
+ * A camunda:connector without camunda:connectorId.
+ * Camunda 7 refuses to deploy the file.
+ *
+ * @example a connector without id
+ * <camunda:connector />  <!-- <camunda:connectorId>http-connector</camunda:connectorId> -->
+ */
+class C7ConnectorNeedsIdRule extends C7ExtensionContentRule {
+  protected checkHost(host: C7Host, read: HostExtension[]): void {
+    for (const extension of read) {
+      const { value, index, local } = extension;
+      if (local === 'connector' && value.get('connectorId') === undefined) {
+        this.reportOn(host, `${host.typeName('connector')} of ${host.describe()} has no ${host.typeName('connectorId')}; the engines refuse the file`, { path: host.extensionPath(index, 'connectorId'), type: ERROR_TYPES.PROPERTY_REQUIRED, node: value, requiredProperty: 'connectorId', hint: host.rebuild(extension) });
+      }
+    }
+  }
+}
+
+export default defineRule({ ruleName: 'c7-connector-needs-id', code: 'W_C7_DEPLOY_EXTENSION', impact: 'deploy' }, C7ConnectorNeedsIdRule);
diff --git a/src/adapters/out/bpmnlint/engine/rules/c7/C7DecisionResultMapperKnownRule.ts b/src/adapters/out/bpmnlint/engine/rules/c7/C7DecisionResultMapperKnownRule.ts
new file mode 100644
index 00000000..6b830b6b
--- /dev/null
+++ b/src/adapters/out/bpmnlint/engine/rules/c7/C7DecisionResultMapperKnownRule.ts
@@ -0,0 +1,29 @@
+import { is } from 'bpmnlint-utils';
+import { defineRule, ERROR_TYPES, type ModdleElement } from '../CamundaRule.js';
+import { ElementKinds } from '../support/ElementKinds.js';
+import { SetCommand } from '../support/SetCommand.js';
+import { C7ExecutableRule } from './C7ExecutableRule.js';
+import { C7Diagram } from './support/C7Diagram.js';
+import { CamundaAttributes } from './support/CamundaAttributes.js';
+
+const DECISION_MAPPERS = ['singleEntry', 'singleResult', 'collectEntries', 'resultList'];
+
+/**
+ * A camunda:mapDecisionResult of a business rule task with a decision that is not singleEntry,
+ * singleResult, collectEntries or resultList.
+ * Camunda 7 refuses to deploy the file.
+ *
+ * @example an unknown result mapper
+ * <bpmn:businessRuleTask id="Rate" camunda:decisionRef="rating" camunda:mapDecisionResult="first" />  <!-- singleEntry -->
+ */
+class C7DecisionResultMapperKnownRule extends C7ExecutableRule {
+  protected checkNode(node: ModdleElement): void {
+    const attributes = new CamundaAttributes(node);
+    const mapper = is(node, 'bpmn:BusinessRuleTask') && attributes.defined('decisionRef') !== undefined ? attributes.defined('mapDecisionResult') : undefined;
+    if (mapper === undefined || DECISION_MAPPERS.includes(mapper)) return;
+    const prefix = C7Diagram.of(node).prefix;
+    this.report(node, `${prefix}:mapDecisionResult="${mapper}" on ${ElementKinds.describe(node)} is not one of ${DECISION_MAPPERS.join(', ')}; the engines refuse the file`, { path: ['mapDecisionResult'], type: ERROR_TYPES.PROPERTY_VALUE_NOT_ALLOWED, property: 'mapDecisionResult', hint: `${new SetCommand(node.id).of(`${prefix}:mapDecisionResult=singleEntry`)} (or another of the four).` });
+  }
+}
+
+export default defineRule({ ruleName: 'c7-decision-result-mapper-known', code: 'W_C7_DEPLOY_BAD_VALUE', impact: 'deploy' }, C7DecisionResultMapperKnownRule);
diff --git a/src/adapters/out/bpmnlint/engine/rules/c7/C7ElementVariableNeedsCollectionRule.ts b/src/adapters/out/bpmnlint/engine/rules/c7/C7ElementVariableNeedsCollectionRule.ts
new file mode 100644
index 00000000..e47b4014
--- /dev/null
+++ b/src/adapters/out/bpmnlint/engine/rules/c7/C7ElementVariableNeedsCollectionRule.ts
@@ -0,0 +1,29 @@
+import { defineRule, ERROR_TYPES, type ModdleElement } from '../CamundaRule.js';
+import { ElementKinds } from '../support/ElementKinds.js';
+import { Shell } from '../support/Shell.js';
+import { C7ExecutableRule } from './C7ExecutableRule.js';
+import { C7Diagram } from './support/C7Diagram.js';
+import { C7MultiInstanceLoop } from './support/C7MultiInstanceLoop.js';
+
+/**
+ * A camunda:elementVariable of a multi-instance loop with a cardinality but no collection; a loop
+ * with neither is the cardinality-or-collection rule's.
+ * Camunda 7 refuses to deploy the file.
+ *
+ * @example an element variable without collection
+ * <bpmn:multiInstanceLoopCharacteristics camunda:elementVariable="reviewer">
+ *   <bpmn:loopCardinality>3</bpmn:loopCardinality>  <!-- camunda:collection="${reviewers}" -->
+ * </bpmn:multiInstanceLoopCharacteristics>
+ */
+class C7ElementVariableNeedsCollectionRule extends C7ExecutableRule {
+  protected checkNode(node: ModdleElement): void {
+    const multiInstance = C7MultiInstanceLoop.of(node);
+    if (!multiInstance?.cardinality || multiInstance.hasCollection || multiInstance.attributes.defined('elementVariable') === undefined) {
+      return;
+    }
+    const prefix = C7Diagram.of(node).prefix;
+    this.report(node, `Multi-instance ${ElementKinds.describe(node)} has ${prefix}:elementVariable but no ${prefix}:collection; the engines refuse the file`, { path: ['loopCharacteristics', 'collection'], type: ERROR_TYPES.PROPERTY_DEPENDENT_REQUIRED, node: multiInstance.loop, property: 'elementVariable', dependentRequiredProperty: 'collection', hint: `\`bpmn set <file> ${node.id} ${Shell.quote(`loop.${prefix}:collection=\${items}`)}\` (or remove it: \`bpmn set <file> ${node.id} loop.${prefix}:elementVariable=\`).` });
+  }
+}
+
+export default defineRule({ ruleName: 'c7-element-variable-needs-collection', code: 'W_C7_DEPLOY_MULTI_INSTANCE', impact: 'deploy' }, C7ElementVariableNeedsCollectionRule);
diff --git a/src/adapters/out/bpmnlint/engine/rules/c7/C7ErrorEndEventNeedsErrorRule.ts b/src/adapters/out/bpmnlint/engine/rules/c7/C7ErrorEndEventNeedsErrorRule.ts
new file mode 100644
index 00000000..dcd89ee9
--- /dev/null
+++ b/src/adapters/out/bpmnlint/engine/rules/c7/C7ErrorEndEventNeedsErrorRule.ts
@@ -0,0 +1,24 @@
+import { defineRule } from '../CamundaRule.js';
+import { C7EventReferenceRule, type EventReference } from './C7EventReferenceRule.js';
+
+/**
+ * An error end event without error.
+ * Camunda 7 refuses to deploy the file.
+ *
+ * @example an error end event that names no error
+ * <bpmn:endEvent id="Failed">
+ *   <bpmn:errorEventDefinition />  <!-- no errorRef -->
+ * </bpmn:endEvent>
+ */
+class C7ErrorEndEventNeedsErrorRule extends C7EventReferenceRule {
+  protected readonly kind = 'Error';
+  protected readonly events = ['bpmn:EndEvent'];
+
+  protected checkReference(reference: EventReference): void {
+    if (!reference.referenced) {
+      this.reportMissing(reference, 'throws no error (no errorRef)', 'error=<ErrorName> errorCode=<CODE>');
+    }
+  }
+}
+
+export default defineRule({ ruleName: 'c7-error-end-event-needs-error', code: 'W_C7_DEPLOY_ERROR', impact: 'deploy' }, C7ErrorEndEventNeedsErrorRule);
diff --git a/src/adapters/out/bpmnlint/engine/rules/c7/C7ErrorNeedsCodeRule.ts b/src/adapters/out/bpmnlint/engine/rules/c7/C7ErrorNeedsCodeRule.ts
new file mode 100644
index 00000000..5a08bdbd
--- /dev/null
+++ b/src/adapters/out/bpmnlint/engine/rules/c7/C7ErrorNeedsCodeRule.ts
@@ -0,0 +1,20 @@
+import { defineRule } from '../CamundaRule.js';
+import { C7EventReferenceRule, type EventReference } from './C7EventReferenceRule.js';
+
+/**
+ * An error without error code that an error end event throws.
+ * Camunda 7 refuses to deploy the file.
+ *
+ * @example a thrown error without code
+ * <bpmn:error id="Rejected" name="Rejected" />  <!-- errorCode="REJECTED" -->
+ */
+class C7ErrorNeedsCodeRule extends C7EventReferenceRule {
+  protected readonly kind = 'Error';
+  protected readonly events = ['bpmn:EndEvent'];
+
+  protected checkReference(reference: EventReference): void {
+    this.reportUncoded(reference);
+  }
+}
+
+export default defineRule({ ruleName: 'c7-error-needs-code', code: 'W_C7_DEPLOY_ERROR', impact: 'deploy' }, C7ErrorNeedsCodeRule);
diff --git a/src/adapters/out/bpmnlint/engine/rules/c7/C7EscalationBoundaryHostAllowedRule.ts b/src/adapters/out/bpmnlint/engine/rules/c7/C7EscalationBoundaryHostAllowedRule.ts
new file mode 100644
index 00000000..c797a190
--- /dev/null
+++ b/src/adapters/out/bpmnlint/engine/rules/c7/C7EscalationBoundaryHostAllowedRule.ts
@@ -0,0 +1,27 @@
+import { is, isAny } from 'bpmnlint-utils';
+import { C7Rule, defineRule, ERROR_TYPES, type ModdleElement } from '../CamundaRule.js';
+import { ElementKinds } from '../support/ElementKinds.js';
+import { EngineScope } from '../support/EngineScope.js';
+import { C7EventDefinitions } from './support/C7EventDefinitions.js';
+
+const ESCALATION_HOSTS = ['bpmn:SubProcess', 'bpmn:CallActivity', 'bpmn:UserTask'];
+
+/**
+ * An escalation boundary event attached to anything but a sub-process, call activity or user task.
+ * Camunda 7 refuses to deploy the file.
+ *
+ * @example an escalation boundary event on a service task
+ * <bpmn:boundaryEvent id="Late" attachedToRef="Charge"><bpmn:escalationEventDefinition /></bpmn:boundaryEvent>
+ */
+class C7EscalationBoundaryHostAllowedRule extends C7Rule {
+  protected visit(node: ModdleElement): void {
+    if (!is(node, 'bpmn:BoundaryEvent') || !EngineScope.C7.contains(node) || !new C7EventDefinitions(node).ofType('bpmn:EscalationEventDefinition')) {
+      return;
+    }
+    const host = node.attachedToRef;
+    if (!host || isAny(host, ESCALATION_HOSTS)) return;
+    this.report(node, `Escalation boundary event ${node.id} is attached to ${ElementKinds.describe(host)}; the engines allow it only on sub-processes, call activities and user tasks and refuse the file`, { path: ['attachedToRef'], type: ERROR_TYPES.ATTACHED_TO_REF_ELEMENT_TYPE_NOT_ALLOWED, attachedToRef: host, hint: `Attach it elsewhere (\`bpmn move <file> ${node.id} --on <subProcessId>\`) or remove it: \`bpmn remove <file> ${node.id}\`.` });
+  }
+}
+
+export default defineRule({ ruleName: 'c7-escalation-boundary-host-allowed', code: 'W_C7_DEPLOY_ESCALATION', impact: 'deploy' }, C7EscalationBoundaryHostAllowedRule);
diff --git a/src/adapters/out/bpmnlint/engine/rules/c7/C7EscalationNeedsCodeRule.ts b/src/adapters/out/bpmnlint/engine/rules/c7/C7EscalationNeedsCodeRule.ts
new file mode 100644
index 00000000..f7d64de9
--- /dev/null
+++ b/src/adapters/out/bpmnlint/engine/rules/c7/C7EscalationNeedsCodeRule.ts
@@ -0,0 +1,20 @@
+import { defineRule } from '../CamundaRule.js';
+import { C7EventReferenceRule, type EventReference } from './C7EventReferenceRule.js';
+
+/**
+ * An escalation without escalation code that an escalation intermediate throw or end event throws.
+ * Camunda 7 refuses to deploy the file.
+ *
+ * @example a thrown escalation without code
+ * <bpmn:escalation id="Late" name="Late" />  <!-- escalationCode="LATE" -->
+ */
+class C7EscalationNeedsCodeRule extends C7EventReferenceRule {
+  protected readonly kind = 'Escalation';
+  protected readonly events = ['bpmn:IntermediateThrowEvent', 'bpmn:EndEvent'];
+
+  protected checkReference(reference: EventReference): void {
+    this.reportUncoded(reference);
+  }
+}
+
+export default defineRule({ ruleName: 'c7-escalation-needs-code', code: 'W_C7_DEPLOY_ESCALATION', impact: 'deploy' }, C7EscalationNeedsCodeRule);
diff --git a/src/adapters/out/bpmnlint/engine/rules/c7/C7EscalationThrowNeedsEscalationRule.ts b/src/adapters/out/bpmnlint/engine/rules/c7/C7EscalationThrowNeedsEscalationRule.ts
new file mode 100644
index 00000000..f27bf1dc
--- /dev/null
+++ b/src/adapters/out/bpmnlint/engine/rules/c7/C7EscalationThrowNeedsEscalationRule.ts
@@ -0,0 +1,22 @@
+import { defineRule } from '../CamundaRule.js';
+import { C7EventReferenceRule, type EventReference } from './C7EventReferenceRule.js';
+
+/**
+ * An escalation intermediate throw or end event without escalation.
+ * Camunda 7 refuses to deploy the file.
+ *
+ * @example an escalation end event that names no escalation
+ * <bpmn:endEvent id="Escalated"><bpmn:escalationEventDefinition /></bpmn:endEvent>  <!-- escalationRef -->
+ */
+class C7EscalationThrowNeedsEscalationRule extends C7EventReferenceRule {
+  protected readonly kind = 'Escalation';
+  protected readonly events = ['bpmn:IntermediateThrowEvent', 'bpmn:EndEvent'];
+
+  protected checkReference(reference: EventReference): void {
+    if (!reference.referenced) {
+      this.reportMissing(reference, 'throws no escalation (no escalationRef)', 'escalation=<Name> escalationCode=<CODE>');
+    }
+  }
+}
+
+export default defineRule({ ruleName: 'c7-escalation-throw-needs-escalation', code: 'W_C7_DEPLOY_ESCALATION', impact: 'deploy' }, C7EscalationThrowNeedsEscalationRule);
diff --git a/src/adapters/out/bpmnlint/engine/rules/c7/C7EventDefinitionSchemaRule.ts b/src/adapters/out/bpmnlint/engine/rules/c7/C7EventDefinitionSchemaRule.ts
new file mode 100644
index 00000000..95200fb6
--- /dev/null
+++ b/src/adapters/out/bpmnlint/engine/rules/c7/C7EventDefinitionSchemaRule.ts
@@ -0,0 +1,70 @@
+import { is } from 'bpmnlint-utils';
+import { C7Rule, type ModdleElement } from '../CamundaRule.js';
+import { ElementKinds } from '../support/ElementKinds.js';
+import { C7EventDefinitions } from './support/C7EventDefinitions.js';
+
+/**
+ * The base of the Camunda 7 rules on what the BPMN schema requires of an event definition: a rule
+ * implements `checkDefinition(definition)` for each event definition of the file, also of one the
+ * engines ignore or do not run, and `checkEvent(event)` for what it checks of the event first.
+ * Camunda 7 validates the file against the schema before it deploys it. A report about a
+ * definition goes on the event that holds it, with the fix for that event.
+ *
+ * @example a conditional event without condition
+ * <bpmn:intermediateCatchEvent id="Ready"><bpmn:conditionalEventDefinition /></bpmn:intermediateCatchEvent>
+ */
+export abstract class C7EventDefinitionSchemaRule extends C7Rule {
+  protected visit(node: ModdleElement): void {
+    if (is(node, 'bpmn:Event')) {
+      this.checkEvent(node);
+      for (const definition of new C7EventDefinitions(node).all()) {
+        this.checkDefinition(definition);
+      }
+    } else if (is(node, 'bpmn:EventDefinition') && !(node.$parent && is(node.$parent, 'bpmn:Event'))) {
+      this.checkDefinition(node);
+    }
+  }
+
+  protected checkEvent(_event: ModdleElement): void {}
+
+  protected abstract checkDefinition(definition: ModdleElement): void;
+
+  protected reportSchema(definition: ModdleElement, message: string, data: { path: (string | number)[]; type: string; hint: string; [detail: string]: unknown }): void {
+    this.report(this.eventOf(definition) ?? definition, message, { ...data, node: definition });
+  }
+
+  /** `Conditional event X`, among several definitions `The conditional definition of <event>`, without an event the definition itself. */
+  protected subjectName(definition: ModdleElement, single: string): string {
+    const event = this.eventOf(definition);
+    if (!event) {
+      return `${definition.$type}${definition.id ? ` ${definition.id}` : ''}`;
+    }
+    return new C7EventDefinitions(event).all().length > 1 ? `The ${ElementKinds.trigger(definition)} definition of ${ElementKinds.describe(event)}` : `${single} ${event.id}`;
+  }
+
+  protected subjectPath(definition: ModdleElement, ...rest: string[]): (string | number)[] {
+    const event = this.eventOf(definition);
+    return event ? new C7EventDefinitions(event).pathTo(definition, ...rest) : rest;
+  }
+
+  /** The fix `bpmn set <file> <event> <command>` (with `keeps` in brackets), or among several definitions how to drop this one when the engines act on another one. */
+  protected subjectHint(definition: ModdleElement, command: string, keeps = ''): string {
+    const event = this.eventOf(definition);
+    if (!event) return 'Fix it in the XML.';
+    const definitions = new C7EventDefinitions(event);
+    if (definitions.all().length < 2) {
+      return `\`bpmn set <file> ${event.id} ${command}\`${keeps ? ` (${keeps})` : ''}.`;
+    }
+    const only = `\`bpmn set <file> ${event.id} ${command}\` (keeps only the ${ElementKinds.trigger(definition)} definition)`;
+    const acting = definitions.acting();
+    if (!acting || acting === definition) return `${only}.`;
+    const trigger = ElementKinds.trigger(acting);
+    return `The engines act on the ${trigger} definition and ignore this one, but they validate it too: drop it with \`bpmn set <file> ${event.id} trigger=${trigger}\` (keeps only the ${trigger}), or ${only}.`;
+  }
+
+  /** The event with an id that holds `definition`: a report about the definition goes on it. */
+  private eventOf(definition: ModdleElement): ModdleElement | undefined {
+    const parent = definition.$parent;
+    return parent && is(parent, 'bpmn:Event') && parent.id ? parent : undefined;
+  }
+}
diff --git a/src/adapters/out/bpmnlint/engine/rules/c7/C7EventGatewayBranchesUniqueRule.ts b/src/adapters/out/bpmnlint/engine/rules/c7/C7EventGatewayBranchesUniqueRule.ts
new file mode 100644
index 00000000..9b6b6d26
--- /dev/null
+++ b/src/adapters/out/bpmnlint/engine/rules/c7/C7EventGatewayBranchesUniqueRule.ts
@@ -0,0 +1,36 @@
+import { is } from 'bpmnlint-utils';
+import { defineRule, ERROR_TYPES, type ModdleElement } from '../CamundaRule.js';
+import { ElementKinds } from '../support/ElementKinds.js';
+import { FirstOfKey } from '../support/FirstOfKey.js';
+import { C7ExecutableRule } from './C7ExecutableRule.js';
+import { C7EventGateway } from './support/C7EventGateway.js';
+
+const REFERENCE_BY_TRIGGER: Record<string, string> = { message: 'messageRef', signal: 'signalRef' };
+
+/**
+ * Two branches of an event-based gateway that wait for one message or signal name.
+ * Camunda 7 refuses to deploy the file. A branch the engines refuse as a target is the target
+ * rule's; the finding is on the later branch, no property of the gateway: the path is null.
+ *
+ * @example two branches waiting for the same message
+ * <bpmn:intermediateCatchEvent id="Paid"><bpmn:messageEventDefinition messageRef="Payment" /></bpmn:intermediateCatchEvent>
+ * <bpmn:intermediateCatchEvent id="PaidLate"><bpmn:messageEventDefinition messageRef="Payment" /></bpmn:intermediateCatchEvent>
+ */
+class C7EventGatewayBranchesUniqueRule extends C7ExecutableRule {
+  protected checkNode(node: ModdleElement): void {
+    if (!is(node, 'bpmn:EventBasedGateway')) return;
+    const firsts = new FirstOfKey<ModdleElement>();
+    for (const { target, definitions } of C7EventGateway.branches(node)) {
+      if (!definitions || !C7EventGateway.waits(definitions)) continue;
+      const trigger = ElementKinds.trigger(definitions[0]);
+      const referenceProperty = REFERENCE_BY_TRIGGER[trigger];
+      const name = referenceProperty ? definitions[0].get(referenceProperty)?.name : undefined;
+      const first = referenceProperty && name ? firsts.repeats(`${trigger}\u0000${name}`, target) : undefined;
+      if (first) {
+        this.report(node, `Branches ${first.id} and ${target.id} of event-based gateway ${node.id} wait for the same ${trigger} "${name}"; the engines refuse the file`, { path: null, type: ERROR_TYPES.ELEMENT_PROPERTY_VALUE_DUPLICATED, first, node: target, duplicatedProperty: referenceProperty, duplicatedPropertyValue: name, hint: `\`bpmn set <file> ${target.id} ${trigger}=<OtherName>\`, or remove one branch.` });
+      }
+    }
+  }
+}
+
+export default defineRule({ ruleName: 'c7-event-gateway-branches-unique', code: 'W_C7_DEPLOY_EVENT_GATEWAY', impact: 'deploy' }, C7EventGatewayBranchesUniqueRule);
diff --git a/src/adapters/out/bpmnlint/engine/rules/c7/C7EventGatewayTargetAllowedRule.ts b/src/adapters/out/bpmnlint/engine/rules/c7/C7EventGatewayTargetAllowedRule.ts
new file mode 100644
index 00000000..779fdef5
--- /dev/null
+++ b/src/adapters/out/bpmnlint/engine/rules/c7/C7EventGatewayTargetAllowedRule.ts
@@ -0,0 +1,31 @@
+import { is } from 'bpmnlint-utils';
+import { defineRule, ERROR_TYPES, type ModdleElement } from '../CamundaRule.js';
+import { ElementKinds } from '../support/ElementKinds.js';
+import { C7ExecutableRule } from './C7ExecutableRule.js';
+import { C7EventGateway } from './support/C7EventGateway.js';
+
+/**
+ * A branch of an event-based gateway that leads to anything but a message, timer, signal or
+ * conditional intermediate catch event.
+ * Camunda 7 refuses to deploy the file. The finding is on the branch, no property of the gateway:
+ * the path is null.
+ *
+ * @example a task right after an event-based gateway
+ * <bpmn:eventBasedGateway id="Wait" />
+ * <bpmn:sequenceFlow sourceRef="Wait" targetRef="Ship" />  <!-- a catch event first -->
+ */
+class C7EventGatewayTargetAllowedRule extends C7ExecutableRule {
+  protected checkNode(node: ModdleElement): void {
+    if (!is(node, 'bpmn:EventBasedGateway')) return;
+    for (const { flow, target, definitions } of C7EventGateway.branches(node)) {
+      const leadsTo = `Event-based gateway ${node.id} leads to ${ElementKinds.describe(target)}`;
+      if (!definitions) {
+        this.report(node, `${leadsTo}; the engines accept only intermediate catch events (message, timer, signal, conditional) there and refuse the file`, { path: null, type: ERROR_TYPES.EVENT_BASED_GATEWAY_TARGET_NOT_ALLOWED, node: target, sequenceFlow: flow, hint: `Put a catch event in front of it: \`bpmn add <file> intermediateCatchEvent:message "<Name>" --flow ${flow.id} --message <MessageName>\` (or :timer --timer PT1H).` });
+      } else if (!C7EventGateway.waits(definitions)) {
+        this.report(node, `${leadsTo}; after an event-based gateway the engines accept only message, timer, signal and conditional catch events and refuse the file`, { path: null, type: ERROR_TYPES.EVENT_BASED_GATEWAY_TARGET_NOT_ALLOWED, node: target, sequenceFlow: flow, hint: `\`bpmn set <file> ${target.id} trigger=message message=<MessageName>\` (or trigger=timer timer=PT1H).` });
+      }
+    }
+  }
+}
+
+export default defineRule({ ruleName: 'c7-event-gateway-target-allowed', code: 'W_C7_DEPLOY_EVENT_GATEWAY', impact: 'deploy' }, C7EventGatewayTargetAllowedRule);
diff --git a/src/adapters/out/bpmnlint/engine/rules/c7/C7EventReferenceRule.ts b/src/adapters/out/bpmnlint/engine/rules/c7/C7EventReferenceRule.ts
new file mode 100644
index 00000000..e2e0fbca
--- /dev/null
+++ b/src/adapters/out/bpmnlint/engine/rules/c7/C7EventReferenceRule.ts
@@ -0,0 +1,64 @@
+import { is, isAny } from 'bpmnlint-utils';
+import { C7Rule, ERROR_TYPES, type ModdleElement } from '../CamundaRule.js';
+import { ElementKinds } from '../support/ElementKinds.js';
+import { EngineScope } from '../support/EngineScope.js';
+import { C7EventDefinitions } from './support/C7EventDefinitions.js';
+
+/** A definition of the kind a reference rule checks, on an event the engines run: where its reference sits and what it references. */
+export interface EventReference {
+  event: ModdleElement;
+  definition: ModdleElement;
+  /** `messageRef`, `signalRef`, `errorRef` or `escalationRef` */
+  property: string;
+  path: (string | number)[];
+  referenced: ModdleElement | undefined;
+}
+
+/**
+ * The base of the Camunda 7 rules on what a message, signal, error or escalation event references:
+ * a rule names the `kind` and the `events` it applies to and implements `checkReference(reference)`
+ * for each definition of that kind the engines act on.
+ * Camunda 7 resolves the reference when it deploys the file and refuses it when the reference or
+ * what the engine reads of it is missing.
+ *
+ * @example an error end event that names no error
+ * <bpmn:endEvent id="Failed">
+ *   <bpmn:errorEventDefinition />  <!-- no errorRef -->
+ * </bpmn:endEvent>
+ */
+export abstract class C7EventReferenceRule extends C7Rule {
+  protected abstract readonly kind: 'Message' | 'Signal' | 'Error' | 'Escalation';
+  protected abstract readonly events: string[];
+
+  protected visit(node: ModdleElement): void {
+    if (!is(node, 'bpmn:Event') || !EngineScope.C7.contains(node) || !isAny(node, this.events)) {
+      return;
+    }
+    const definitions = new C7EventDefinitions(node);
+    const property = `${this.kind.toLowerCase()}Ref`;
+    for (const definition of definitions.actedOn()) {
+      if (is(definition, `bpmn:${this.kind}EventDefinition`)) {
+        this.checkReference({ event: node, definition, property, path: definitions.pathTo(definition, property), referenced: definition.get(property) });
+      }
+    }
+  }
+
+  protected abstract checkReference(reference: EventReference): void;
+
+  /** The event names nothing: `missing` says what, `set` how to set it. */
+  protected reportMissing({ event, definition, property, path }: EventReference, missing: string, set: string, after = ''): void {
+    this.report(event, `${ElementKinds.describe(event)} ${missing}; the engines refuse the file`, { path, type: ERROR_TYPES.PROPERTY_REQUIRED, node: definition, requiredProperty: property, hint: `\`bpmn set <file> ${event.id} ${set}\`${after}.` });
+  }
+
+  /** What `owner` references has no name. */
+  protected reportUnnamed(owner: ModdleElement, referenced: ModdleElement, subject: string, path: (string | number)[]): void {
+    this.report(owner, `${subject} has no name; the engines refuse the file`, { path: [...path, 'name'], type: ERROR_TYPES.PROPERTY_REQUIRED, node: referenced, requiredProperty: 'name', hint: `\`bpmn set <file> ${referenced.id} name=<${referenced.$type.slice('bpmn:'.length)}Name>\`.` });
+  }
+
+  /** The error or escalation thrown has no code. */
+  protected reportUncoded({ event, path, referenced }: EventReference): void {
+    const code = `${this.kind.toLowerCase()}Code`;
+    if (!referenced || String(referenced.get(code) ?? '').trim()) return;
+    this.report(event, `${this.kind} ${referenced.id} thrown by ${ElementKinds.describe(event)} has no ${code}; the engines refuse the file`, { path: [...path, code], type: ERROR_TYPES.PROPERTY_REQUIRED, node: referenced, requiredProperty: code, hint: `\`bpmn set <file> ${event.id} ${code}=<CODE>\`.` });
+  }
+}
diff --git a/src/adapters/out/bpmnlint/engine/rules/c7/C7ExclusiveGatewayDefaultNoConditionRule.ts b/src/adapters/out/bpmnlint/engine/rules/c7/C7ExclusiveGatewayDefaultNoConditionRule.ts
new file mode 100644
index 00000000..897e297a
--- /dev/null
+++ b/src/adapters/out/bpmnlint/engine/rules/c7/C7ExclusiveGatewayDefaultNoConditionRule.ts
@@ -0,0 +1,36 @@
+import { is } from 'bpmnlint-utils';
+import { defineRule, ERROR_TYPES, type ModdleElement } from '../CamundaRule.js';
+import { C7ExecutableRule } from './C7ExecutableRule.js';
+import { C7ExclusiveGateway } from './support/C7ExclusiveGateway.js';
+
+/**
+ * A condition on the default flow of an exclusive gateway, or on its only outgoing flow.
+ * Camunda 7 refuses to deploy the file. The condition of the flow goes: the path is null, as the
+ * flow is no property of the gateway.
+ *
+ * @example a default flow with a condition
+ * <bpmn:exclusiveGateway id="Approved" default="Ship" />
+ * <bpmn:sequenceFlow id="Ship" sourceRef="Approved" targetRef="Send">
+ *   <bpmn:conditionExpression>${approved}</bpmn:conditionExpression>  <!-- the default takes none -->
+ * </bpmn:sequenceFlow>
+ */
+class C7ExclusiveGatewayDefaultNoConditionRule extends C7ExecutableRule {
+  protected checkNode(node: ModdleElement): void {
+    if (!is(node, 'bpmn:ExclusiveGateway')) return;
+    const { outgoing, defaultFlow } = new C7ExclusiveGateway(node);
+    if (outgoing.length === 1) {
+      const [flow] = outgoing;
+      if (flow.conditionExpression) {
+        this.reportCondition(node, flow, flow === defaultFlow ? `Default flow ${flow.id} of exclusive gateway ${node.id} has a condition; the engines refuse the file` : `Exclusive gateway ${node.id} has a single outgoing flow ${flow.id} with a condition; the engines refuse the file`);
+      }
+    } else if (defaultFlow?.conditionExpression && outgoing.includes(defaultFlow)) {
+      this.reportCondition(node, defaultFlow, `Default flow ${defaultFlow.id} of exclusive gateway ${node.id} has a condition; the engines refuse the file`);
+    }
+  }
+
+  private reportCondition(node: ModdleElement, flow: ModdleElement, message: string): void {
+    this.report(node, message, { path: null, type: ERROR_TYPES.PROPERTY_NOT_ALLOWED, node: flow, property: 'conditionExpression', hint: `\`bpmn set <file> ${flow.id} condition=\`.` });
+  }
+}
+
+export default defineRule({ ruleName: 'c7-exclusive-gateway-default-no-condition', code: 'W_C7_DEPLOY_EXCLUSIVE_GATEWAY', impact: 'deploy' }, C7ExclusiveGatewayDefaultNoConditionRule);
diff --git a/src/adapters/out/bpmnlint/engine/rules/c7/C7ExclusiveGatewayNeedsConditionsRule.ts b/src/adapters/out/bpmnlint/engine/rules/c7/C7ExclusiveGatewayNeedsConditionsRule.ts
new file mode 100644
index 00000000..d6fa93a3
--- /dev/null
+++ b/src/adapters/out/bpmnlint/engine/rules/c7/C7ExclusiveGatewayNeedsConditionsRule.ts
@@ -0,0 +1,32 @@
+import { is } from 'bpmnlint-utils';
+import { defineRule, ERROR_TYPES, type ModdleElement } from '../CamundaRule.js';
+import { Shell } from '../support/Shell.js';
+import { C7ExecutableRule } from './C7ExecutableRule.js';
+import { C7ExclusiveGateway } from './support/C7ExclusiveGateway.js';
+
+/**
+ * Outgoing flows of an exclusive gateway without condition next to a default flow, or several of
+ * them and no default flow.
+ * Camunda 7 refuses to deploy the file. The finding is on each such flow, no property of the
+ * gateway: the path is null.
+ *
+ * @example two outgoing flows, neither with a condition nor marked as default
+ * <bpmn:exclusiveGateway id="Approved" />
+ * <bpmn:sequenceFlow sourceRef="Approved" targetRef="Ship" />    <!-- no condition -->
+ * <bpmn:sequenceFlow sourceRef="Approved" targetRef="Reject" />  <!-- no condition -->
+ */
+class C7ExclusiveGatewayNeedsConditionsRule extends C7ExecutableRule {
+  protected checkNode(node: ModdleElement): void {
+    if (!is(node, 'bpmn:ExclusiveGateway')) return;
+    const gateway = new C7ExclusiveGateway(node);
+    const { outgoing, defaultFlow } = gateway;
+    const unconditioned = gateway.unconditioned();
+    if (outgoing.length < 2 || (!defaultFlow && unconditioned.length < 2)) return;
+    for (const flow of unconditioned) {
+      const asDefault = defaultFlow ? '' : ` or make one of them the default: \`bpmn set <file> ${flow.id} default=true\``;
+      this.report(node, `Flow ${flow.id} of exclusive gateway ${node.id} has no condition and is not the default flow${defaultFlow ? '' : ` (${unconditioned.length} such flows)`}; the engines refuse the file`, { path: null, type: ERROR_TYPES.PROPERTY_REQUIRED, node: flow, requiredProperty: 'conditionExpression', hint: `\`bpmn set <file> ${flow.id} ${Shell.quote('condition=${...}')}\`${asDefault}.` });
+    }
+  }
+}
+
+export default defineRule({ ruleName: 'c7-exclusive-gateway-needs-conditions', code: 'W_C7_DEPLOY_EXCLUSIVE_GATEWAY', impact: 'deploy' }, C7ExclusiveGatewayNeedsConditionsRule);
diff --git a/src/adapters/out/bpmnlint/engine/rules/c7/C7ExclusiveGatewayNeedsDefaultRule.ts b/src/adapters/out/bpmnlint/engine/rules/c7/C7ExclusiveGatewayNeedsDefaultRule.ts
new file mode 100644
index 00000000..ac389577
--- /dev/null
+++ b/src/adapters/out/bpmnlint/engine/rules/c7/C7ExclusiveGatewayNeedsDefaultRule.ts
@@ -0,0 +1,29 @@
+import { is } from 'bpmnlint-utils';
+import { defineRule, ERROR_TYPES, type ModdleElement } from '../CamundaRule.js';
+import { C7ExecutableRule } from './C7ExecutableRule.js';
+import { C7ExclusiveGateway } from './support/C7ExclusiveGateway.js';
+
+/**
+ * Exactly one outgoing flow of an exclusive gateway without condition, and no default flow.
+ * Camunda 7 takes that flow as the default and logs a warning, so the model reads otherwise than
+ * the engine runs it.
+ *
+ * @example a flow the engines take as the default
+ * <bpmn:exclusiveGateway id="Approved" />
+ * <bpmn:sequenceFlow sourceRef="Approved" targetRef="Ship"><bpmn:conditionExpression>${approved}</bpmn:conditionExpression></bpmn:sequenceFlow>
+ * <bpmn:sequenceFlow id="Other" sourceRef="Approved" targetRef="Reject" />  <!-- default="Other" -->
+ */
+class C7ExclusiveGatewayNeedsDefaultRule extends C7ExecutableRule {
+  protected checkNode(node: ModdleElement): void {
+    if (!is(node, 'bpmn:ExclusiveGateway')) return;
+    const gateway = new C7ExclusiveGateway(node);
+    const unconditioned = gateway.unconditioned();
+    if (gateway.outgoing.length < 2 || gateway.defaultFlow || unconditioned.length !== 1) {
+      return;
+    }
+    const [flow] = unconditioned;
+    this.report(node, `Flow ${flow.id} of exclusive gateway ${node.id} has no condition and is not the default flow; the engines take it as the default and log a warning`, { path: ['default'], type: ERROR_TYPES.PROPERTY_REQUIRED, requiredProperty: 'default', sequenceFlow: flow, hint: `\`bpmn set <file> ${flow.id} default=true\`.` });
+  }
+}
+
+export default defineRule({ ruleName: 'c7-exclusive-gateway-needs-default', code: 'W_C7_EXCLUSIVE_GATEWAY_DEFAULT', impact: 'practice' }, C7ExclusiveGatewayNeedsDefaultRule);
diff --git a/src/adapters/out/bpmnlint/engine/rules/c7/C7ExclusiveGatewayNeedsOutgoingRule.ts b/src/adapters/out/bpmnlint/engine/rules/c7/C7ExclusiveGatewayNeedsOutgoingRule.ts
new file mode 100644
index 00000000..3b9f08b1
--- /dev/null
+++ b/src/adapters/out/bpmnlint/engine/rules/c7/C7ExclusiveGatewayNeedsOutgoingRule.ts
@@ -0,0 +1,22 @@
+import { is } from 'bpmnlint-utils';
+import { defineRule, ERROR_TYPES, type ModdleElement } from '../CamundaRule.js';
+import { C7ExecutableRule } from './C7ExecutableRule.js';
+import { C7FlowGraph } from './support/C7FlowGraph.js';
+
+/**
+ * An exclusive gateway without outgoing flow.
+ * Camunda 7 refuses to deploy the file.
+ *
+ * @example a gateway that leads nowhere
+ * <bpmn:exclusiveGateway id="Approved" />  <!-- no sequenceFlow with sourceRef="Approved" -->
+ */
+class C7ExclusiveGatewayNeedsOutgoingRule extends C7ExecutableRule {
+  protected checkNode(node: ModdleElement): void {
+    if (!is(node, 'bpmn:ExclusiveGateway') || C7FlowGraph.forElement(node).outgoing(node).length) {
+      return;
+    }
+    this.report(node, `Exclusive gateway ${node.id} has no outgoing flow; the engines refuse the file`, { path: ['outgoing'], type: ERROR_TYPES.PROPERTY_REQUIRED, requiredProperty: 'outgoing', hint: `Continue it: \`bpmn add <file> <kind> "<Name>" --after ${node.id}\`.` });
+  }
+}
+
+export default defineRule({ ruleName: 'c7-exclusive-gateway-needs-outgoing', code: 'W_C7_DEPLOY_EXCLUSIVE_GATEWAY', impact: 'deploy' }, C7ExclusiveGatewayNeedsOutgoingRule);
diff --git a/src/adapters/out/bpmnlint/engine/rules/c7/C7ExecutableRule.ts b/src/adapters/out/bpmnlint/engine/rules/c7/C7ExecutableRule.ts
new file mode 100644
index 00000000..05a3a286
--- /dev/null
+++ b/src/adapters/out/bpmnlint/engine/rules/c7/C7ExecutableRule.ts
@@ -0,0 +1,21 @@
+import { is } from 'bpmnlint-utils';
+import { C7Rule, type ModdleElement } from '../CamundaRule.js';
+
+/**
+ * The base of the Camunda 7 rules on what the engines run: a rule implements `check(node)` for each
+ * element of an executable process, the content of an ad-hoc sub-process left out.
+ * The engines deploy no process that is not executable, and run no ad-hoc sub-process, so neither
+ * holds anything they could refuse.
+ *
+ * @example a process the rules skip
+ * <bpmn:process id="Sketch" isExecutable="false" />
+ */
+export abstract class C7ExecutableRule extends C7Rule {
+  protected visit(node: ModdleElement): boolean {
+    if (is(node, 'bpmn:Process') && node.isExecutable !== true) return false;
+    this.checkNode(node);
+    return !is(node, 'bpmn:AdHocSubProcess');
+  }
+
+  protected abstract checkNode(node: ModdleElement): void;
+}
diff --git a/src/adapters/out/bpmnlint/engine/rules/c7/C7ExtensionContentRule.ts b/src/adapters/out/bpmnlint/engine/rules/c7/C7ExtensionContentRule.ts
new file mode 100644
index 00000000..100cb8c3
--- /dev/null
+++ b/src/adapters/out/bpmnlint/engine/rules/c7/C7ExtensionContentRule.ts
@@ -0,0 +1,25 @@
+import { C7Rule, type ModdleElement } from '../CamundaRule.js';
+import { EngineScope } from '../support/EngineScope.js';
+import { C7Host, type HostExtension } from './support/C7Host.js';
+import { CamundaPlacement } from './support/CamundaPlacement.js';
+
+/**
+ * The base of the Camunda 7 rules on the content of camunda extension elements (listeners,
+ * input/output mappings, fields, forms, connectors): a rule implements `checkHost(host, read)` for
+ * each element of an executable process, with the extension elements the engines read there.
+ * Camunda 7 parses that content when it deploys the file and refuses it where a required part is
+ * missing, a value unknown or the placement forbidden.
+ *
+ * @example a listener that runs nothing
+ * <camunda:executionListener event="start" />  <!-- no class, expression or script -->
+ */
+export abstract class C7ExtensionContentRule extends C7Rule {
+  protected visit(node: ModdleElement): boolean | void {
+    if (!C7Host.visits(node)) return false;
+    if (!EngineScope.inExecutableProcess(node)) return;
+    const host = new C7Host(node);
+    this.checkHost(host, new CamundaPlacement(host).readExtensions());
+  }
+
+  protected abstract checkHost(host: C7Host, read: HostExtension[]): void;
+}
diff --git a/src/adapters/out/bpmnlint/engine/rules/c7/C7ExternalTaskNeedsTopicRule.ts b/src/adapters/out/bpmnlint/engine/rules/c7/C7ExternalTaskNeedsTopicRule.ts
new file mode 100644
index 00000000..4bb94bc6
--- /dev/null
+++ b/src/adapters/out/bpmnlint/engine/rules/c7/C7ExternalTaskNeedsTopicRule.ts
@@ -0,0 +1,20 @@
+import { defineRule, ERROR_TYPES, type ModdleElement } from '../CamundaRule.js';
+import { C7ImplementationHostRule } from './C7ImplementationHostRule.js';
+import type { ImplementationHost } from './support/ImplementationHost.js';
+
+/**
+ * An external task, or a message throw event implemented as one, without camunda:topic.
+ * Camunda 7 refuses to deploy the file.
+ *
+ * @example an external task without topic
+ * <bpmn:serviceTask id="Charge" camunda:type="external" />  <!-- camunda:topic="charge" -->
+ */
+class C7ExternalTaskNeedsTopicRule extends C7ImplementationHostRule {
+  protected checkHost(node: ModdleElement, host: ImplementationHost): void {
+    if (!host.isExternal || host.attributes.defined('topic') !== undefined) return;
+    const { prefix, command, label } = host;
+    this.report(node, `${label} is an external task without ${prefix}:topic; the engines refuse the file`, { path: host.pathTo('topic'), type: ERROR_TYPES.PROPERTY_REQUIRED, node: host.element, requiredProperty: 'topic', hint: `${command.of(`${prefix}:topic=<topic>`)}.` });
+  }
+}
+
+export default defineRule({ ruleName: 'c7-external-task-needs-topic', code: 'W_C7_DEPLOY_EXTERNAL_TOPIC', impact: 'deploy' }, C7ExternalTaskNeedsTopicRule);
diff --git a/src/adapters/out/bpmnlint/engine/rules/c7/C7FieldNeedsOneValueRule.ts b/src/adapters/out/bpmnlint/engine/rules/c7/C7FieldNeedsOneValueRule.ts
new file mode 100644
index 00000000..df822beb
--- /dev/null
+++ b/src/adapters/out/bpmnlint/engine/rules/c7/C7FieldNeedsOneValueRule.ts
@@ -0,0 +1,102 @@
+import { is, isAny } from 'bpmnlint-utils';
+import { defineRule, ERROR_TYPES, type ModdleElement, type ReportPath } from '../CamundaRule.js';
+import { ElementKinds } from '../support/ElementKinds.js';
+import { Shell } from '../support/Shell.js';
+import { Values } from '../support/Values.js';
+import { C7ExtensionContentRule } from './C7ExtensionContentRule.js';
+import { C7EventDefinitions } from './support/C7EventDefinitions.js';
+import type { C7Host, HostExtension } from './support/C7Host.js';
+
+const SERVICE_LIKE = ['bpmn:ServiceTask', 'bpmn:SendTask', 'bpmn:BusinessRuleTask'];
+
+/** Where camunda:field elements sit: how messages name their holder, their path, and the `ext add` type argument that replaces one of them by name. */
+interface FieldsAt {
+  label: string;
+  path: ReportPath;
+  /** `X camunda:field`, `T 'camunda:taskListener[event=create]/camunda:field'`; undefined without an address */
+  fieldOf: string | undefined;
+  /** whether `path` leads to the list of fields (each one at its index) or to the field itself */
+  indexed?: boolean;
+}
+
+/**
+ * A camunda:field the engines read without value, or with both the attribute stringValue and a
+ * camunda:string element: a field of a listener, or of a task or message throw event
+ * implementation, that a class or a delegate expression reads.
+ * Camunda 7 refuses to deploy the file.
+ *
+ * @example a field without value
+ * <camunda:executionListener class="org.acme.Audit" event="start">
+ *   <camunda:field name="level" />  <!-- stringValue="info" -->
+ * </camunda:executionListener>
+ */
+class C7FieldNeedsOneValueRule extends C7ExtensionContentRule {
+  protected checkHost(host: C7Host, read: HostExtension[]): void {
+    for (const extension of read) {
+      this.checkListenerFields(host, extension);
+    }
+    const { node, owner } = host;
+    if (SERVICE_LIKE.some((type) => is(node, type))) {
+      this.checkImplementationFields(host, host.describe());
+    }
+    if (is(node, 'bpmn:MessageEventDefinition') && owner && isAny(owner, ['bpmn:IntermediateThrowEvent', 'bpmn:EndEvent']) && new C7EventDefinitions(owner).actedOn().includes(node)) {
+      this.checkImplementationFields(host, ElementKinds.describe(owner));
+    }
+  }
+
+  private checkListenerFields(host: C7Host, extension: HostExtension): void {
+    const { value, index, local } = extension;
+    if ((local !== 'executionListener' && local !== 'taskListener') || !this.readsFields(value)) {
+      return;
+    }
+    const event: string | undefined = value.get('event');
+    const fieldOf = host.address ? `${host.address.id} ${Shell.quote(`${host.address.slot}${host.selector(extension)}/${host.typeName('field')}`)}` : undefined;
+    this.checkFields(host, value.get('fields'), { label: `${host.typeName(local)}${event ? ` (event ${event})` : ''} of ${host.describe()}`, path: host.extensionPath(index, 'fields'), fieldOf });
+  }
+
+  /** The camunda:field elements of a task or a message throw event definition, where its implementation reads them. */
+  private checkImplementationFields(host: C7Host, label: string): void {
+    const type: string | undefined = host.node.get('camunda:type');
+    const shell = type?.toLowerCase() === 'shell';
+    if (type !== undefined ? !shell : !this.readsFields(host.node, 'camunda:')) {
+      return;
+    }
+    const fieldOf = host.address ? `${host.address.id} ${Shell.quote(`${host.address.slot}${host.typeName('field')}`)}` : undefined;
+    for (const { value, index } of host.camundaExtensions('field')) {
+      this.checkFields(host, [value], { label, path: host.extensionPath(index), fieldOf, indexed: false });
+    }
+  }
+
+  /** Whether the engines parse the fields of an implementation: a class, or a delegate expression without an expression. */
+  private readsFields(el: ModdleElement, prefix = ''): boolean {
+    return Values.nonEmpty(el.get(`${prefix}class`)) || (el.get(`${prefix}expression`) === undefined && Values.nonEmpty(el.get(`${prefix}delegateExpression`)));
+  }
+
+  private checkFields(host: C7Host, fields: ModdleElement[] | undefined, { label, path, fieldOf, indexed = true }: FieldsAt): void {
+    (fields ?? []).forEach((field, index) => {
+      const problem = this.fieldProblem(field);
+      if (!problem) return;
+      const name: string | undefined = field.get('name');
+      const fieldPath = indexed ? [...path, index] : path;
+      const hint = fieldOf && name !== undefined ? `Give it one: \`bpmn ext add <file> ${fieldOf} name=${Shell.quote(name)} stringValue=<value>\` (replaces the field of that name; or ${Shell.quote('expression=${...}')}).` : 'Give it a stringValue or an expression in the XML.';
+      const kind = problem === 'no value' ? { path: fieldPath, type: ERROR_TYPES.PROPERTY_REQUIRED, requiredProperty: ['stringValue', 'expression', 'string'] } : { path: [...fieldPath, 'string'], type: ERROR_TYPES.PROPERTY_NOT_ALLOWED, property: 'string' };
+      this.reportOn(host, `${host.typeName('field')}${name !== undefined ? ` "${name}"` : ''} of ${label} has ${problem}; the engines refuse the file (a field needs stringValue, expression, a ${host.typeName('string')} or a ${host.typeName('expression')})`, { node: field, hint, ...kind });
+    });
+  }
+
+  /**
+   * What keeps the engines from reading a field's value: none at all, or the stringValue attribute
+   * next to a camunda:string element. An element without text counts as a value; an empty
+   * expression does too, as the moddle cannot tell its attribute from its element.
+   */
+  private fieldProblem(field: ModdleElement): string | undefined {
+    const stringValue: string | undefined = field.get('stringValue');
+    const stringElement: string | undefined = field.get('string');
+    if (stringValue !== undefined && stringElement !== undefined) {
+      return 'both the attribute stringValue and a camunda:string element';
+    }
+    return stringElement !== undefined || (stringValue !== undefined && stringValue.length > 0) || field.get('expression') !== undefined ? undefined : 'no value';
+  }
+}
+
+export default defineRule({ ruleName: 'c7-field-needs-one-value', code: 'W_C7_DEPLOY_EXTENSION', impact: 'deploy' }, C7FieldNeedsOneValueRule);
diff --git a/src/adapters/out/bpmnlint/engine/rules/c7/C7FormFieldNeedsIdAndTypeRule.ts b/src/adapters/out/bpmnlint/engine/rules/c7/C7FormFieldNeedsIdAndTypeRule.ts
new file mode 100644
index 00000000..105c8250
--- /dev/null
+++ b/src/adapters/out/bpmnlint/engine/rules/c7/C7FormFieldNeedsIdAndTypeRule.ts
@@ -0,0 +1,43 @@
+import { defineRule, ERROR_TYPES, type ModdleElement } from '../CamundaRule.js';
+import { Values } from '../support/Values.js';
+import { C7ExtensionContentRule } from './C7ExtensionContentRule.js';
+import type { C7Host, HostExtension } from './support/C7Host.js';
+
+/** The form field types every engine knows (more only through a custom form type plugin). */
+const FORM_TYPES = ['string', 'long', 'boolean', 'date', 'enum'];
+
+/**
+ * A form field of camunda:formData without id, without type, or with a type that is none of the
+ * built-in form types string, long, boolean, date and enum.
+ * Camunda 7 refuses to deploy the file, unless a plugin registers the type as a custom form type.
+ *
+ * @example a form field without type
+ * <camunda:formData><camunda:formField id="amount" /></camunda:formData>  <!-- type="long" -->
+ */
+class C7FormFieldNeedsIdAndTypeRule extends C7ExtensionContentRule {
+  protected checkHost(host: C7Host, read: HostExtension[]): void {
+    for (const extension of read) {
+      if (extension.local === 'formData') this.checkFormFields(host, extension);
+    }
+  }
+
+  private checkFormFields(host: C7Host, extension: HostExtension): void {
+    const rebuild = host.rebuild(extension);
+    (extension.value.get('fields') ?? []).forEach((field: ModdleElement, fieldIndex: number) => {
+      const id: string | undefined = field.get('id');
+      const type: string | undefined = field.get('type');
+      const label = `Form field ${id ?? fieldIndex + 1} of ${host.describe()}`;
+      const path = host.extensionPath(extension.index, 'fields', fieldIndex);
+      if (!Values.nonEmpty(id)) {
+        this.reportOn(host, `${label} has no id; the engines refuse the file`, { path: [...path, 'id'], type: ERROR_TYPES.PROPERTY_REQUIRED, node: field, requiredProperty: 'id', hint: rebuild });
+      }
+      if (type === undefined) {
+        this.reportOn(host, `${label} has no type; the engines refuse the file`, { path: [...path, 'type'], type: ERROR_TYPES.PROPERTY_REQUIRED, node: field, requiredProperty: 'type', hint: `Use one of ${FORM_TYPES.join(', ')}. ${rebuild}` });
+      } else if (!FORM_TYPES.includes(type)) {
+        this.reportOn(host, `${label} has type "${type}", which is not one of the built-in form types ${FORM_TYPES.join(', ')}; the engines refuse the file (unless a plugin registers it as a custom form type)`, { path: [...path, 'type'], type: ERROR_TYPES.PROPERTY_VALUE_NOT_ALLOWED, node: field, property: 'type', hint: rebuild });
+      }
+    });
+  }
+}
+
+export default defineRule({ ruleName: 'c7-form-field-needs-id-and-type', code: 'W_C7_DEPLOY_EXTENSION', impact: 'deploy' }, C7FormFieldNeedsIdAndTypeRule);
diff --git a/src/adapters/out/bpmnlint/engine/rules/c7/C7FormRefNeedsBindingRule.ts b/src/adapters/out/bpmnlint/engine/rules/c7/C7FormRefNeedsBindingRule.ts
new file mode 100644
index 00000000..1faae8df
--- /dev/null
+++ b/src/adapters/out/bpmnlint/engine/rules/c7/C7FormRefNeedsBindingRule.ts
@@ -0,0 +1,32 @@
+import { defineRule, ERROR_TYPES, type ModdleElement } from '../CamundaRule.js';
+import { ElementKinds } from '../support/ElementKinds.js';
+import { C7ExecutableRule } from './C7ExecutableRule.js';
+import { C7Bindings } from './support/C7Bindings.js';
+import { C7Diagram } from './support/C7Diagram.js';
+import { CamundaAttributes } from './support/CamundaAttributes.js';
+
+const FORM_BINDINGS = ['deployment', 'latest', 'version'];
+
+/**
+ * A camunda:formRef of a user task or start event without a camunda:formRefBinding of deployment,
+ * latest or version.
+ * Camunda 7 refuses to deploy the file.
+ *
+ * @example a form reference without binding
+ * <bpmn:userTask id="Review" camunda:formRef="review" />  <!-- camunda:formRefBinding="latest" -->
+ */
+class C7FormRefNeedsBindingRule extends C7ExecutableRule {
+  protected checkNode(node: ModdleElement): void {
+    const attributes = new CamundaAttributes(node);
+    const binding = attributes.defined('formRefBinding');
+    if (!C7Bindings.hasFormRef(node, attributes) || (binding !== undefined && FORM_BINDINGS.includes(binding))) {
+      return;
+    }
+    const prefix = C7Diagram.of(node).prefix;
+    const found = binding === undefined ? `no ${prefix}:formRefBinding` : `${prefix}:formRefBinding="${binding}"`;
+    const problem = binding === undefined ? { type: ERROR_TYPES.PROPERTY_REQUIRED, requiredProperty: 'formRefBinding' } : { type: ERROR_TYPES.PROPERTY_VALUE_NOT_ALLOWED, property: 'formRefBinding' };
+    this.report(node, `${ElementKinds.describe(node)} has ${prefix}:formRef but ${found} (one of ${FORM_BINDINGS.join(', ')} is required); the engines refuse the file`, { path: ['formRefBinding'], ...problem, hint: `\`bpmn set <file> ${node.id} ${prefix}:formRefBinding=latest\`.` });
+  }
+}
+
+export default defineRule({ ruleName: 'c7-form-ref-needs-binding', code: 'W_C7_DEPLOY_FORM', impact: 'deploy' }, C7FormRefNeedsBindingRule);
diff --git a/src/adapters/out/bpmnlint/engine/rules/c7/C7FormRefNoFormKeyRule.ts b/src/adapters/out/bpmnlint/engine/rules/c7/C7FormRefNoFormKeyRule.ts
new file mode 100644
index 00000000..1b0101a3
--- /dev/null
+++ b/src/adapters/out/bpmnlint/engine/rules/c7/C7FormRefNoFormKeyRule.ts
@@ -0,0 +1,26 @@
+import { defineRule, ERROR_TYPES, type ModdleElement } from '../CamundaRule.js';
+import { ElementKinds } from '../support/ElementKinds.js';
+import { C7ExecutableRule } from './C7ExecutableRule.js';
+import { C7Bindings } from './support/C7Bindings.js';
+import { C7Diagram } from './support/C7Diagram.js';
+import { CamundaAttributes } from './support/CamundaAttributes.js';
+
+/**
+ * A camunda:formRef next to a camunda:formKey on a user task or start event.
+ * Camunda 7 takes one form and refuses to deploy the file.
+ *
+ * @example two forms on one task
+ * <bpmn:userTask id="Review" camunda:formKey="review.html" camunda:formRef="review" camunda:formRefBinding="latest" />
+ */
+class C7FormRefNoFormKeyRule extends C7ExecutableRule {
+  protected checkNode(node: ModdleElement): void {
+    const attributes = new CamundaAttributes(node);
+    if (!C7Bindings.hasFormRef(node, attributes) || attributes.defined('formKey') === undefined) {
+      return;
+    }
+    const prefix = C7Diagram.of(node).prefix;
+    this.report(node, `${ElementKinds.describe(node)} has both ${prefix}:formKey and ${prefix}:formRef; the engines refuse the file`, { path: ['formKey'], type: ERROR_TYPES.PROPERTY_NOT_ALLOWED, property: 'formKey', hint: `Keep one: \`bpmn set <file> ${node.id} ${prefix}:formKey=\` (or ${prefix}:formRef=).` });
+  }
+}
+
+export default defineRule({ ruleName: 'c7-form-ref-no-form-key', code: 'W_C7_DEPLOY_FORM', impact: 'deploy' }, C7FormRefNoFormKeyRule);
diff --git a/src/adapters/out/bpmnlint/engine/rules/c7/C7HistoryTimeToLiveValidRule.ts b/src/adapters/out/bpmnlint/engine/rules/c7/C7HistoryTimeToLiveValidRule.ts
new file mode 100644
index 00000000..28ed0103
--- /dev/null
+++ b/src/adapters/out/bpmnlint/engine/rules/c7/C7HistoryTimeToLiveValidRule.ts
@@ -0,0 +1,30 @@
+import { is } from 'bpmnlint-utils';
+import { defineRule, ERROR_TYPES, type ModdleElement } from '../CamundaRule.js';
+import { Values } from '../support/Values.js';
+import { C7ExecutableRule } from './C7ExecutableRule.js';
+import { C7Diagram } from './support/C7Diagram.js';
+import { CamundaAttributes } from './support/CamundaAttributes.js';
+
+const MAX_DAYS = 2147483647;
+
+/**
+ * A camunda:historyTimeToLive of a process that is no number of days or P<n>D.
+ * Camunda 7 refuses to deploy the file.
+ *
+ * @example a history time to live in words
+ * <bpmn:process id="Order" isExecutable="true" camunda:historyTimeToLive="6 months">  <!-- days: 180 -->
+ */
+class C7HistoryTimeToLiveValidRule extends C7ExecutableRule {
+  protected checkNode(node: ModdleElement): void {
+    if (!is(node, 'bpmn:Process')) return;
+    const timeToLive = new CamundaAttributes(node).defined('historyTimeToLive');
+    const days = Values.nonEmpty(timeToLive) ? (/^\+?(\d+)$/.exec(timeToLive) ?? /^P(\d+)D$/.exec(timeToLive)) : undefined;
+    if (!Values.nonEmpty(timeToLive) || (days && Number(days[1]) <= MAX_DAYS)) {
+      return;
+    }
+    const prefix = C7Diagram.of(node).prefix;
+    this.report(node, `${prefix}:historyTimeToLive="${timeToLive}" of process ${node.id} is not a number of days (or P<n>D); the engines refuse it`, { path: ['historyTimeToLive'], type: ERROR_TYPES.PROPERTY_VALUE_NOT_ALLOWED, property: 'historyTimeToLive', hint: `\`bpmn set <file> ${node.id} ${prefix}:historyTimeToLive=180\` (days, like Camunda Modeler; P180D works too).` });
+  }
+}
+
+export default defineRule({ ruleName: 'c7-history-time-to-live-valid', code: 'W_C7_DEPLOY_HISTORY_TTL', impact: 'deploy' }, C7HistoryTimeToLiveValidRule);
diff --git a/src/adapters/out/bpmnlint/engine/rules/c7/C7ImplementationHostRule.ts b/src/adapters/out/bpmnlint/engine/rules/c7/C7ImplementationHostRule.ts
new file mode 100644
index 00000000..d7e4a4b9
--- /dev/null
+++ b/src/adapters/out/bpmnlint/engine/rules/c7/C7ImplementationHostRule.ts
@@ -0,0 +1,23 @@
+import type { ModdleElement } from '../CamundaRule.js';
+import { C7ExecutableRule } from './C7ExecutableRule.js';
+import { ImplementationHost } from './support/ImplementationHost.js';
+
+/**
+ * The base of the Camunda 7 rules on how a task or a message throw event is implemented: a rule
+ * implements `checkHost(node, host)` for each implementation host of the element, one with a
+ * camunda:type the engines do not support left out.
+ * The engines refuse an unsupported type before they read the rest of the implementation, so
+ * that one finding says what to fix.
+ *
+ * @example a service task the implementation rules read
+ * <bpmn:serviceTask id="Charge" camunda:type="external" camunda:topic="charge" />
+ */
+export abstract class C7ImplementationHostRule extends C7ExecutableRule {
+  protected checkNode(node: ModdleElement): void {
+    for (const host of ImplementationHost.forElement(node)) {
+      if (!host.hasUnsupportedType) this.checkHost(node, host);
+    }
+  }
+
+  protected abstract checkHost(node: ModdleElement, host: ImplementationHost): void;
+}
diff --git a/src/adapters/out/bpmnlint/engine/rules/c7/C7IoMappingHostAllowedRule.ts b/src/adapters/out/bpmnlint/engine/rules/c7/C7IoMappingHostAllowedRule.ts
new file mode 100644
index 00000000..f53eee68
--- /dev/null
+++ b/src/adapters/out/bpmnlint/engine/rules/c7/C7IoMappingHostAllowedRule.ts
@@ -0,0 +1,25 @@
+import { is } from 'bpmnlint-utils';
+import { defineRule, ERROR_TYPES } from '../CamundaRule.js';
+import { C7ExtensionContentRule } from './C7ExtensionContentRule.js';
+import type { C7Host } from './support/C7Host.js';
+
+/**
+ * camunda:inputOutput on a start or boundary event, a gateway or an event sub-process.
+ * Camunda 7 does not support input/output mappings there and refuses to deploy the file.
+ *
+ * @example mappings on a start event
+ * <bpmn:startEvent id="Received">
+ *   <bpmn:extensionElements><camunda:inputOutput /></bpmn:extensionElements>
+ * </bpmn:startEvent>
+ */
+class C7IoMappingHostAllowedRule extends C7ExtensionContentRule {
+  protected checkHost(host: C7Host): void {
+    const [first] = host.camundaExtensions('inputOutput');
+    const unsupported = host.unsupportedMappingHost();
+    if (!is(host.node, 'bpmn:FlowNode') || !first || !unsupported) return;
+    const mapping = host.typeName('inputOutput');
+    this.reportOn(host, `${mapping} on ${host.describe()}: the engines do not support input/output mappings on ${unsupported} and refuse the file`, { path: host.extensionPath(first.index), type: ERROR_TYPES.EXTENSION_ELEMENT_NOT_ALLOWED, node: first.value, extensionElement: first.value, hint: `Move the mappings to the next activity and remove them here: \`bpmn ext remove <file> ${host.node.id} ${mapping}\`.` });
+  }
+}
+
+export default defineRule({ ruleName: 'c7-io-mapping-host-allowed', code: 'W_C7_DEPLOY_INPUT_OUTPUT', impact: 'deploy' }, C7IoMappingHostAllowedRule);
diff --git a/src/adapters/out/bpmnlint/engine/rules/c7/C7IoParameterInInputOutputRule.ts b/src/adapters/out/bpmnlint/engine/rules/c7/C7IoParameterInInputOutputRule.ts
new file mode 100644
index 00000000..ccd5db44
--- /dev/null
+++ b/src/adapters/out/bpmnlint/engine/rules/c7/C7IoParameterInInputOutputRule.ts
@@ -0,0 +1,32 @@
+import { defineRule, ERROR_TYPES, type ModdleElement } from '../CamundaRule.js';
+import type { Engine } from '@miragon/bpmnlint-plugin-rules/engine';
+import { VendorElementsRule } from '../VendorElementsRule.js';
+
+/**
+ * A camunda:inputParameter or outputParameter directly in the extension elements, outside the
+ * camunda:inputOutput it belongs in.
+ * The engines ignore it. The typed parse drops it with an import warning that names neither the
+ * element nor where it sat, so the rule reads the extension elements as the file writes them.
+ *
+ * @example a loose input parameter
+ * <bpmn:serviceTask id="Charge">
+ *   <bpmn:extensionElements><camunda:inputParameter name="amount">10</camunda:inputParameter></bpmn:extensionElements>  <!-- inside camunda:inputOutput -->
+ * </bpmn:serviceTask>
+ */
+class C7IoParameterInInputOutputRule extends VendorElementsRule {
+  protected readonly engine: Engine = 'c7';
+
+  protected checkValue(host: ModdleElement, parameter: ModdleElement, index: number): void {
+    const local = this.localName(parameter.$type);
+    if (!this.vendor.type(local) || !this.isMisplaced(host, local)) return;
+    const { id, slot } = this.address(host);
+    const name: string | undefined = parameter.name ?? parameter.$attrs?.name;
+    const body: string | undefined = parameter.$body;
+    const add = id ? `: \`bpmn ext add <file> ${id} ${slot}camunda:${local}${name ? ` name=${name}` : ''}${body ? ` --body ${body}` : ''}\`` : '';
+    const remove = id ? `\`bpmn ext remove <file> ${id} ${slot}${index}\`` : 'remove it from the XML';
+    const reported = slot ? this.model.typed(host.$parent) : this.node;
+    this.report(reported, `${this.prefix}:${local} sits directly in the extension elements of ${this.where(host)}, but belongs inside ${this.prefix}:inputOutput; the engines ignore it`, { path: null, type: ERROR_TYPES.CHILD_ELEMENT_TYPE_NOT_ALLOWED, writtenAt: this.model.position(host), subject: `ext:${local}`, hint: `Remove it (${remove}) and add it again, \`bpmn ext add\` files it into its container${add}.` });
+  }
+}
+
+export default defineRule({ ruleName: 'c7-io-parameter-in-input-output', code: 'W_C7_MISPLACED_EXTENSION', impact: 'runtime' }, C7IoParameterInInputOutputRule);
diff --git a/src/adapters/out/bpmnlint/engine/rules/c7/C7IoParameterNeedsNameRule.ts b/src/adapters/out/bpmnlint/engine/rules/c7/C7IoParameterNeedsNameRule.ts
new file mode 100644
index 00000000..ee5e2096
--- /dev/null
+++ b/src/adapters/out/bpmnlint/engine/rules/c7/C7IoParameterNeedsNameRule.ts
@@ -0,0 +1,36 @@
+import { defineRule, ERROR_TYPES, type ModdleElement, type ReportPath } from '../CamundaRule.js';
+import { Values } from '../support/Values.js';
+import { C7ExtensionContentRule } from './C7ExtensionContentRule.js';
+import type { C7Host, HostExtension } from './support/C7Host.js';
+
+/**
+ * An input or output parameter without name, of camunda:inputOutput or of a connector's.
+ * Camunda 7 refuses to deploy the file.
+ *
+ * @example an input parameter without name
+ * <camunda:inputOutput><camunda:inputParameter>${amount}</camunda:inputParameter></camunda:inputOutput>  <!-- name="amount" -->
+ */
+class C7IoParameterNeedsNameRule extends C7ExtensionContentRule {
+  protected checkHost(host: C7Host, read: HostExtension[]): void {
+    for (const extension of read) {
+      const { value, index, local } = extension;
+      if (local === 'inputOutput') {
+        this.checkParameters(host, value, host.extensionPath(index), host.rebuild(extension));
+      } else if (local === 'connector' && value.get('inputOutput')) {
+        this.checkParameters(host, value.get('inputOutput'), host.extensionPath(index, 'inputOutput'), host.rebuild(extension));
+      }
+    }
+  }
+
+  private checkParameters(host: C7Host, mapping: ModdleElement, path: ReportPath, rebuild: string): void {
+    for (const kind of ['inputParameter', 'outputParameter']) {
+      (mapping.get(`${kind}s`) ?? []).forEach((parameter: ModdleElement, index: number) => {
+        if (!Values.nonEmpty(parameter.get('name'))) {
+          this.reportOn(host, `${host.typeName(kind)} ${index + 1} of ${host.describe()} has no name; the engines refuse the file`, { path: [...path, `${kind}s`, index, 'name'], type: ERROR_TYPES.PROPERTY_REQUIRED, node: parameter, requiredProperty: 'name', hint: rebuild });
+        }
+      });
+    }
+  }
+}
+
+export default defineRule({ ruleName: 'c7-io-parameter-needs-name', code: 'W_C7_DEPLOY_EXTENSION', impact: 'deploy' }, C7IoParameterNeedsNameRule);
diff --git a/src/adapters/out/bpmnlint/engine/rules/c7/C7JobPriorityValidRule.ts b/src/adapters/out/bpmnlint/engine/rules/c7/C7JobPriorityValidRule.ts
new file mode 100644
index 00000000..3bf6604d
--- /dev/null
+++ b/src/adapters/out/bpmnlint/engine/rules/c7/C7JobPriorityValidRule.ts
@@ -0,0 +1,53 @@
+import { is, isAny } from 'bpmnlint-utils';
+import { defineRule, ERROR_TYPES, type ModdleElement, type ReportPath } from '../CamundaRule.js';
+import { ElementKinds } from '../support/ElementKinds.js';
+import { SetCommand } from '../support/SetCommand.js';
+import { Values } from '../support/Values.js';
+import { C7ExecutableRule } from './C7ExecutableRule.js';
+import { C7Diagram } from './support/C7Diagram.js';
+import { CamundaAttributes } from './support/CamundaAttributes.js';
+import { ImplementationHost } from './support/ImplementationHost.js';
+
+const JOB_PRIORITIZED = ['bpmn:Activity', 'bpmn:Gateway', 'bpmn:Event'];
+
+/**
+ * A camunda:jobPriority or external task camunda:taskPriority that is neither an integer nor an
+ * expression: of a process, an activity, gateway or event, a multi-instance loop, or an external
+ * task.
+ * Camunda 7 refuses to deploy the file.
+ *
+ * @example a priority in words
+ * <bpmn:serviceTask id="Charge" camunda:asyncBefore="true" camunda:jobPriority="high" />  <!-- 50 -->
+ */
+class C7JobPriorityValidRule extends C7ExecutableRule {
+  protected checkNode(node: ModdleElement): void {
+    const prefix = C7Diagram.of(node).prefix;
+    const command = new SetCommand(node.id);
+    if (is(node, 'bpmn:Process')) {
+      for (const name of ['jobPriority', 'taskPriority']) {
+        this.checkPriority(node, node, [], command, name, prefix);
+      }
+    }
+    if (isAny(node, JOB_PRIORITIZED) && !is(node, 'bpmn:AdHocSubProcess')) {
+      this.checkPriority(node, node, [], command, 'jobPriority', prefix);
+      const loop = node.get('loopCharacteristics');
+      if (loop && is(loop, 'bpmn:MultiInstanceLoopCharacteristics')) {
+        this.checkPriority(loop, node, ['loopCharacteristics'], new SetCommand(node.id, 'loop.'), 'jobPriority', prefix);
+      }
+    }
+    for (const host of ImplementationHost.forElement(node)) {
+      if (host.isExternal) {
+        this.checkPriority(host.element, node, host.path, host.command, 'taskPriority', prefix);
+      }
+    }
+  }
+
+  /** `element` carries the priority; `reported` is the element it sits on, or the element itself. */
+  private checkPriority(element: ModdleElement, reported: ModdleElement, path: ReportPath, command: SetCommand, name: string, prefix: string): void {
+    const value = new CamundaAttributes(element).defined(name);
+    if (value === undefined || Values.isPriority(value)) return;
+    this.report(reported, `${prefix}:${name}="${value}" on ${ElementKinds.describe(element, element === reported ? undefined : reported)} is not a number or expression; the engines refuse it`, { path: [...path, name], type: ERROR_TYPES.PROPERTY_VALUE_NOT_ALLOWED, node: element, property: name, hint: reported.id ? `${command.of(`${prefix}:${name}=50`)} (an integer or \${...}).` : 'Use an integer.' });
+  }
+}
+
+export default defineRule({ ruleName: 'c7-job-priority-valid', code: 'W_C7_DEPLOY_BAD_VALUE', impact: 'deploy' }, C7JobPriorityValidRule);
diff --git a/src/adapters/out/bpmnlint/engine/rules/c7/C7LinkCatchNameUniqueRule.ts b/src/adapters/out/bpmnlint/engine/rules/c7/C7LinkCatchNameUniqueRule.ts
new file mode 100644
index 00000000..20c45948
--- /dev/null
+++ b/src/adapters/out/bpmnlint/engine/rules/c7/C7LinkCatchNameUniqueRule.ts
@@ -0,0 +1,23 @@
+import { is } from 'bpmnlint-utils';
+import { C7Rule, defineRule, ERROR_TYPES, type ModdleElement } from '../CamundaRule.js';
+import { EngineScope } from '../support/EngineScope.js';
+import { C7Links } from './support/C7Links.js';
+
+/**
+ * Two link catch events with one name in a process, sub-processes included.
+ * Camunda 7 refuses to deploy the file.
+ *
+ * @example two catch events of one link
+ * <bpmn:intermediateCatchEvent id="Ship"><bpmn:linkEventDefinition name="Shipping" /></bpmn:intermediateCatchEvent>
+ * <bpmn:intermediateCatchEvent id="ShipAgain"><bpmn:linkEventDefinition name="Shipping" /></bpmn:intermediateCatchEvent>
+ */
+class C7LinkCatchNameUniqueRule extends C7Rule {
+  protected visit(node: ModdleElement): void {
+    if (!is(node, 'bpmn:Process') || !EngineScope.C7.contains(node)) return;
+    for (const { first, el, name } of C7Links.of(node).duplicateCatches()) {
+      this.report(el, `Link catch events ${first.id} and ${el.id} are both named "${name}"; the engines refuse two link catch events with one name in a process (sub-processes included)`, { path: C7Links.namePath(el), type: ERROR_TYPES.ELEMENT_PROPERTY_VALUE_DUPLICATED, duplicatedProperty: 'name', duplicatedPropertyValue: name, first, hint: `\`bpmn set <file> ${el.id} link=<OtherName>\` (and its throw events too).` });
+    }
+  }
+}
+
+export default defineRule({ ruleName: 'c7-link-catch-name-unique', code: 'W_C7_DEPLOY_LINK', impact: 'deploy' }, C7LinkCatchNameUniqueRule);
diff --git a/src/adapters/out/bpmnlint/engine/rules/c7/C7LinkEventNeedsNameRule.ts b/src/adapters/out/bpmnlint/engine/rules/c7/C7LinkEventNeedsNameRule.ts
new file mode 100644
index 00000000..59d5f199
--- /dev/null
+++ b/src/adapters/out/bpmnlint/engine/rules/c7/C7LinkEventNeedsNameRule.ts
@@ -0,0 +1,21 @@
+import { is } from 'bpmnlint-utils';
+import { defineRule, ERROR_TYPES, type ModdleElement } from '../CamundaRule.js';
+import { C7EventDefinitionSchemaRule } from './C7EventDefinitionSchemaRule.js';
+
+/**
+ * A link event definition without name, also one the engines ignore.
+ * The BPMN schema requires the name: Camunda 7 refuses to deploy the file.
+ *
+ * @example a link event without name
+ * <bpmn:intermediateThrowEvent id="GoOn"><bpmn:linkEventDefinition /></bpmn:intermediateThrowEvent>  <!-- name="Shipping" -->
+ */
+class C7LinkEventNeedsNameRule extends C7EventDefinitionSchemaRule {
+  protected checkDefinition(definition: ModdleElement): void {
+    if (!is(definition, 'bpmn:LinkEventDefinition') || (definition.name !== undefined && definition.name !== null)) {
+      return;
+    }
+    this.reportSchema(definition, `${this.subjectName(definition, 'Link event')} has no link name, which the BPMN schema requires; the engines refuse the file`, { path: this.subjectPath(definition, 'name'), type: ERROR_TYPES.PROPERTY_REQUIRED, requiredProperty: 'name', hint: this.subjectHint(definition, 'link=<Name>', 'the throw and the catch event of a pair share the name') });
+  }
+}
+
+export default defineRule({ ruleName: 'c7-link-event-needs-name', code: 'W_C7_DEPLOY_LINK', impact: 'deploy' }, C7LinkEventNeedsNameRule);
diff --git a/src/adapters/out/bpmnlint/engine/rules/c7/C7LinkThrowNeedsCatchRule.ts b/src/adapters/out/bpmnlint/engine/rules/c7/C7LinkThrowNeedsCatchRule.ts
new file mode 100644
index 00000000..8b9caf59
--- /dev/null
+++ b/src/adapters/out/bpmnlint/engine/rules/c7/C7LinkThrowNeedsCatchRule.ts
@@ -0,0 +1,41 @@
+import { is } from 'bpmnlint-utils';
+import { C7Rule, defineRule, ERROR_TYPES, type ModdleElement } from '../CamundaRule.js';
+import { EngineScope } from '../support/EngineScope.js';
+import { Shell } from '../support/Shell.js';
+import { C7Links } from './support/C7Links.js';
+
+/**
+ * A link throw event a sequence flow reaches without a link catch event of its name in its own
+ * (sub-)process.
+ * Camunda 7 resolves links within one (sub-)process and refuses to deploy the file.
+ *
+ * @example a link throw without catch
+ * <bpmn:intermediateThrowEvent id="GoShip"><bpmn:linkEventDefinition name="Shipping" /></bpmn:intermediateThrowEvent>  <!-- no catch named Shipping -->
+ */
+class C7LinkThrowNeedsCatchRule extends C7Rule {
+  protected visit(node: ModdleElement): void {
+    if (!is(node, 'bpmn:Process') || !EngineScope.C7.contains(node)) return;
+    const links = C7Links.of(node);
+    const targets = this.flowTargets(node);
+    for (const { el, name, scope } of links.unmatchedThrows()) {
+      if (!targets.has(el)) continue;
+      const elsewhere = links.catchNamed(name);
+      const scopeId = scope.id ?? '<scopeId>';
+      const missing = elsewhere ? `the catch event of that name (${elsewhere.id}) is in another scope` : 'no link catch event has that name';
+      this.report(el, `Link throw event ${el.id} jumps to "${name}", but ${missing}; the engines resolve links within one (sub-)process (${scopeId}) and refuse the file`, { path: C7Links.namePath(el), type: ERROR_TYPES.PROPERTY_VALUE_NOT_ALLOWED, property: 'name', ...(elsewhere ? { elsewhere } : {}), hint: `Add the catching side in ${scopeId}: \`bpmn add <file> intermediateCatchEvent:link "<Name>" --in ${scopeId} --link ${Shell.quote(name)}\` and continue from it, or point the throw at an existing catch: \`bpmn set <file> ${el.id} link=<Name>\`.` });
+    }
+  }
+
+  /** The flow nodes a sequence flow of the process leads to. */
+  private flowTargets(scope: ModdleElement, targets = new Set<ModdleElement>()): Set<ModdleElement> {
+    for (const element of scope.flowElements ?? []) {
+      if (is(element, 'bpmn:SequenceFlow') && element.targetRef) {
+        targets.add(element.targetRef);
+      }
+      if (element.flowElements) this.flowTargets(element, targets);
+    }
+    return targets;
+  }
+}
+
+export default defineRule({ ruleName: 'c7-link-throw-needs-catch', code: 'W_C7_DEPLOY_LINK', impact: 'deploy' }, C7LinkThrowNeedsCatchRule);
diff --git a/src/adapters/out/bpmnlint/engine/rules/c7/C7ListenerEventKnownRule.ts b/src/adapters/out/bpmnlint/engine/rules/c7/C7ListenerEventKnownRule.ts
new file mode 100644
index 00000000..6b94931e
--- /dev/null
+++ b/src/adapters/out/bpmnlint/engine/rules/c7/C7ListenerEventKnownRule.ts
@@ -0,0 +1,31 @@
+import { is } from 'bpmnlint-utils';
+import { defineRule, ERROR_TYPES } from '../CamundaRule.js';
+import { C7ListenerRule, type Listener } from './C7ListenerRule.js';
+
+const EXECUTION_EVENTS = ['start', 'end'];
+const TASK_EVENTS = ['create', 'assignment', 'complete', 'update', 'delete', 'timeout'];
+
+/**
+ * An execution or task listener without event, or with an event the engines do not know for it;
+ * the listeners of a sequence flow take none.
+ * Camunda 7 refuses to deploy the file.
+ *
+ * @example a listener on an unknown event
+ * <camunda:executionListener class="org.acme.Audit" event="begin" />  <!-- start or end -->
+ */
+class C7ListenerEventKnownRule extends C7ListenerRule {
+  protected checkListener(listener: Listener): void {
+    const { host, extension, event, label } = listener;
+    if (is(host.node, 'bpmn:SequenceFlow')) return;
+    const { local } = extension;
+    const allowed = local === 'taskListener' ? TASK_EVENTS : EXECUTION_EVENTS;
+    const rebuild = host.rebuild(extension, { event: `<${allowed.join('|')}>` });
+    if (event === undefined) {
+      this.reportListener(listener, `${label} has no event; the engines refuse the file`, ['event'], ERROR_TYPES.PROPERTY_REQUIRED, { requiredProperty: 'event', hint: `Set event to one of ${allowed.join(', ')}. ${rebuild}` });
+    } else if (!allowed.includes(event)) {
+      this.reportListener(listener, `${label}: event "${event}" is not one of ${allowed.join(', ')}; the engines refuse the file`, ['event'], ERROR_TYPES.PROPERTY_VALUE_NOT_ALLOWED, { property: 'event', hint: `${event === 'take' && local === 'executionListener' ? 'take is only read on sequence flows. ' : ''}${rebuild}` });
+    }
+  }
+}
+
+export default defineRule({ ruleName: 'c7-listener-event-known', code: 'W_C7_DEPLOY_LISTENER', impact: 'deploy' }, C7ListenerEventKnownRule);
diff --git a/src/adapters/out/bpmnlint/engine/rules/c7/C7ListenerNeedsImplementationRule.ts b/src/adapters/out/bpmnlint/engine/rules/c7/C7ListenerNeedsImplementationRule.ts
new file mode 100644
index 00000000..bf2f205d
--- /dev/null
+++ b/src/adapters/out/bpmnlint/engine/rules/c7/C7ListenerNeedsImplementationRule.ts
@@ -0,0 +1,24 @@
+import { defineRule, ERROR_TYPES } from '../CamundaRule.js';
+import { Values } from '../support/Values.js';
+import { C7ListenerRule, type Listener } from './C7ListenerRule.js';
+
+const LISTENER_IMPLEMENTATIONS = ['class', 'expression', 'delegateExpression'];
+
+/**
+ * An execution or task listener without class, expression, delegate expression or script.
+ * Camunda 7 refuses to deploy the file.
+ *
+ * @example a listener that runs nothing
+ * <camunda:executionListener event="start" />  <!-- no class, expression or script -->
+ */
+class C7ListenerNeedsImplementationRule extends C7ListenerRule {
+  protected checkListener(listener: Listener): void {
+    const { value } = listener.extension;
+    if (LISTENER_IMPLEMENTATIONS.some((name) => Values.nonEmpty(value.get(name))) || value.script !== undefined) {
+      return;
+    }
+    this.reportListener(listener, `${listener.label} has no class, expression, delegateExpression or script; the engines refuse the file`, [], ERROR_TYPES.PROPERTY_REQUIRED, { requiredProperty: [...LISTENER_IMPLEMENTATIONS, 'script'], hint: listener.host.rebuild(listener.extension, { expression: '${...}' }) });
+  }
+}
+
+export default defineRule({ ruleName: 'c7-listener-needs-implementation', code: 'W_C7_DEPLOY_LISTENER', impact: 'deploy' }, C7ListenerNeedsImplementationRule);
diff --git a/src/adapters/out/bpmnlint/engine/rules/c7/C7ListenerRule.ts b/src/adapters/out/bpmnlint/engine/rules/c7/C7ListenerRule.ts
new file mode 100644
index 00000000..ea8abfa3
--- /dev/null
+++ b/src/adapters/out/bpmnlint/engine/rules/c7/C7ListenerRule.ts
@@ -0,0 +1,38 @@
+import type { ReportPath } from '../CamundaRule.js';
+import { C7ExtensionContentRule } from './C7ExtensionContentRule.js';
+import type { C7Host, HostExtension } from './support/C7Host.js';
+
+/** A camunda:executionListener or taskListener a listener rule checks, with how its messages name it. */
+export interface Listener {
+  host: C7Host;
+  extension: HostExtension;
+  event: string | undefined;
+  /** `camunda:taskListener (event create) of userTask Review` */
+  label: string;
+}
+
+/**
+ * The base of the Camunda 7 rules on execution and task listeners: a rule implements
+ * `checkListener(listener)` for each listener the engines read, and reports on it with
+ * `reportListener`.
+ * Camunda 7 parses the listeners when it deploys the file and refuses one it cannot run.
+ *
+ * @example a listener that runs nothing
+ * <camunda:executionListener event="start" />  <!-- no class, expression or script -->
+ */
+export abstract class C7ListenerRule extends C7ExtensionContentRule {
+  protected checkHost(host: C7Host, read: HostExtension[]): void {
+    for (const extension of read) {
+      const { value, local } = extension;
+      if (local !== 'executionListener' && local !== 'taskListener') continue;
+      const event: string | undefined = value.get('event');
+      this.checkListener({ host, extension, event, label: `${host.typeName(local)}${event ? ` (event ${event})` : ''} of ${host.describe()}` });
+    }
+  }
+
+  protected abstract checkListener(listener: Listener): void;
+
+  protected reportListener({ host, extension }: Listener, message: string, steps: ReportPath, type: string, details: Record<string, unknown>): void {
+    this.reportOn(host, message, { path: host.extensionPath(extension.index, ...steps), type, node: extension.value, ...details });
+  }
+}
diff --git a/src/adapters/out/bpmnlint/engine/rules/c7/C7ListenerScriptNeedsFormatRule.ts b/src/adapters/out/bpmnlint/engine/rules/c7/C7ListenerScriptNeedsFormatRule.ts
new file mode 100644
index 00000000..75c61c8d
--- /dev/null
+++ b/src/adapters/out/bpmnlint/engine/rules/c7/C7ListenerScriptNeedsFormatRule.ts
@@ -0,0 +1,20 @@
+import { defineRule, ERROR_TYPES } from '../CamundaRule.js';
+import { Values } from '../support/Values.js';
+import { C7ListenerRule, type Listener } from './C7ListenerRule.js';
+
+/**
+ * The script of an execution or task listener without scriptFormat.
+ * Camunda 7 refuses to deploy the file.
+ *
+ * @example a listener script without format
+ * <camunda:executionListener event="start"><camunda:script>log()</camunda:script></camunda:executionListener>  <!-- scriptFormat="groovy" -->
+ */
+class C7ListenerScriptNeedsFormatRule extends C7ListenerRule {
+  protected checkListener(listener: Listener): void {
+    const { script } = listener.extension.value;
+    if (!script || Values.nonEmpty(script.get('scriptFormat'))) return;
+    this.reportListener(listener, `The script of ${listener.label} has no scriptFormat; the engines refuse the file`, ['script', 'scriptFormat'], ERROR_TYPES.PROPERTY_REQUIRED, { requiredProperty: 'scriptFormat', hint: listener.host.rebuild(listener.extension) });
+  }
+}
+
+export default defineRule({ ruleName: 'c7-listener-script-needs-format', code: 'W_C7_DEPLOY_LISTENER', impact: 'deploy' }, C7ListenerScriptNeedsFormatRule);
diff --git a/src/adapters/out/bpmnlint/engine/rules/c7/C7MessageEventNeedsMessageRule.ts b/src/adapters/out/bpmnlint/engine/rules/c7/C7MessageEventNeedsMessageRule.ts
new file mode 100644
index 00000000..285a499f
--- /dev/null
+++ b/src/adapters/out/bpmnlint/engine/rules/c7/C7MessageEventNeedsMessageRule.ts
@@ -0,0 +1,22 @@
+import { defineRule } from '../CamundaRule.js';
+import { C7EventReferenceRule, type EventReference } from './C7EventReferenceRule.js';
+
+/**
+ * A message start, intermediate catch or boundary event without message.
+ * Camunda 7 refuses to deploy the file.
+ *
+ * @example a message catch event without message
+ * <bpmn:intermediateCatchEvent id="Paid"><bpmn:messageEventDefinition /></bpmn:intermediateCatchEvent>  <!-- messageRef -->
+ */
+class C7MessageEventNeedsMessageRule extends C7EventReferenceRule {
+  protected readonly kind = 'Message';
+  protected readonly events = ['bpmn:StartEvent', 'bpmn:IntermediateCatchEvent', 'bpmn:BoundaryEvent'];
+
+  protected checkReference(reference: EventReference): void {
+    if (!reference.referenced) {
+      this.reportMissing(reference, 'has no message', 'message=<MessageName>', ' (creates the bpmn:Message)');
+    }
+  }
+}
+
+export default defineRule({ ruleName: 'c7-message-event-needs-message', code: 'W_C7_DEPLOY_MESSAGE', impact: 'deploy' }, C7MessageEventNeedsMessageRule);
diff --git a/src/adapters/out/bpmnlint/engine/rules/c7/C7MessageNeedsNameRule.ts b/src/adapters/out/bpmnlint/engine/rules/c7/C7MessageNeedsNameRule.ts
new file mode 100644
index 00000000..1f02e775
--- /dev/null
+++ b/src/adapters/out/bpmnlint/engine/rules/c7/C7MessageNeedsNameRule.ts
@@ -0,0 +1,34 @@
+import { is } from 'bpmnlint-utils';
+import { defineRule, type ModdleElement } from '../CamundaRule.js';
+import { ElementKinds } from '../support/ElementKinds.js';
+import { EngineScope } from '../support/EngineScope.js';
+import { C7EventReferenceRule, type EventReference } from './C7EventReferenceRule.js';
+
+/**
+ * A message without name that a message start, intermediate catch or boundary event, or a receive
+ * task, waits for.
+ * Camunda 7 correlates messages by name and refuses to deploy the file.
+ *
+ * @example a message without name
+ * <bpmn:message id="Payment" />  <!-- name="Payment" -->
+ * <bpmn:receiveTask id="Wait" messageRef="Payment" />
+ */
+class C7MessageNeedsNameRule extends C7EventReferenceRule {
+  protected readonly kind = 'Message';
+  protected readonly events = ['bpmn:StartEvent', 'bpmn:IntermediateCatchEvent', 'bpmn:BoundaryEvent'];
+
+  protected override visit(node: ModdleElement): void {
+    super.visit(node);
+    if (is(node, 'bpmn:ReceiveTask') && node.messageRef && !node.messageRef.name && EngineScope.C7.contains(node)) {
+      this.reportUnnamed(node, node.messageRef, `Message ${node.messageRef.id} of receive task ${node.id}`, ['messageRef']);
+    }
+  }
+
+  protected checkReference({ event, referenced, path }: EventReference): void {
+    if (referenced && !referenced.name) {
+      this.reportUnnamed(event, referenced, `Message ${referenced.id} of ${ElementKinds.describe(event)}`, path);
+    }
+  }
+}
+
+export default defineRule({ ruleName: 'c7-message-needs-name', code: 'W_C7_DEPLOY_MESSAGE', impact: 'deploy' }, C7MessageNeedsNameRule);
diff --git a/src/adapters/out/bpmnlint/engine/rules/c7/C7MessageSubscriptionUniqueRule.ts b/src/adapters/out/bpmnlint/engine/rules/c7/C7MessageSubscriptionUniqueRule.ts
new file mode 100644
index 00000000..30332dec
--- /dev/null
+++ b/src/adapters/out/bpmnlint/engine/rules/c7/C7MessageSubscriptionUniqueRule.ts
@@ -0,0 +1,16 @@
+import { defineRule } from '../CamundaRule.js';
+import { C7SubscriptionUniqueRule } from './C7SubscriptionUniqueRule.js';
+
+/**
+ * One message name twice among the events and receive tasks waiting in one engine scope.
+ * Camunda 7 refuses two message subscriptions with one name and does not deploy the file.
+ *
+ * @example two boundary events of one task waiting for the same message
+ * <bpmn:boundaryEvent attachedToRef="Pay"><bpmn:messageEventDefinition messageRef="Cancel" /></bpmn:boundaryEvent>
+ * <bpmn:boundaryEvent attachedToRef="Pay"><bpmn:messageEventDefinition messageRef="Cancel" /></bpmn:boundaryEvent>  <!-- same message -->
+ */
+class C7MessageSubscriptionUniqueRule extends C7SubscriptionUniqueRule {
+  protected readonly kind = 'message';
+}
+
+export default defineRule({ ruleName: 'c7-message-subscription-unique', code: 'W_C7_DEPLOY_MESSAGE', impact: 'deploy' }, C7MessageSubscriptionUniqueRule);
diff --git a/src/adapters/out/bpmnlint/engine/rules/c7/C7MessageThrowNeedsImplementationRule.ts b/src/adapters/out/bpmnlint/engine/rules/c7/C7MessageThrowNeedsImplementationRule.ts
new file mode 100644
index 00000000..2d009388
--- /dev/null
+++ b/src/adapters/out/bpmnlint/engine/rules/c7/C7MessageThrowNeedsImplementationRule.ts
@@ -0,0 +1,30 @@
+import { defineRule, ERROR_TYPES, type ModdleElement } from '../CamundaRule.js';
+import { C7ImplementationHostRule } from './C7ImplementationHostRule.js';
+import { CamundaAttributes } from './support/CamundaAttributes.js';
+import { type ImplementationHost, IMPLEMENTATIONS } from './support/ImplementationHost.js';
+
+/**
+ * A message throw or end event without implementation; one written on the event instead of its
+ * message definition is the misplaced attribute rule's.
+ * Camunda 7 deploys the file, but the event sends nothing and behaves like a none event when it
+ * runs.
+ *
+ * @example a message end event that sends nothing
+ * <bpmn:endEvent id="Notified"><bpmn:messageEventDefinition /></bpmn:endEvent>  <!-- camunda:type="external" -->
+ */
+class C7MessageThrowNeedsImplementationRule extends C7ImplementationHostRule {
+  protected checkHost(node: ModdleElement, host: ImplementationHost): void {
+    if (!host.isEvent || host.hasImplementation || this.hasMisplacedImplementation(node)) {
+      return;
+    }
+    const { prefix, command, label } = host;
+    this.report(node, `${label} has no implementation: it sends nothing and behaves like a none event at run time`, { path: host.pathTo('type'), type: ERROR_TYPES.PROPERTY_REQUIRED, node: host.element, requiredProperty: IMPLEMENTATIONS, hint: `Give it one: ${command.of(`${prefix}:type=external`, `${prefix}:topic=<topic>`)} (or ${prefix}:delegateExpression=\${...}).` });
+  }
+
+  private hasMisplacedImplementation(event: ModdleElement): boolean {
+    const attributes = new CamundaAttributes(event);
+    return [...IMPLEMENTATIONS, 'topic'].some((local) => attributes.any(local) !== undefined);
+  }
+}
+
+export default defineRule({ ruleName: 'c7-message-throw-needs-implementation', code: 'W_C7_MESSAGE_NO_IMPLEMENTATION', impact: 'runtime' }, C7MessageThrowNeedsImplementationRule);
diff --git a/src/adapters/out/bpmnlint/engine/rules/c7/C7MissingStartEventRule.ts b/src/adapters/out/bpmnlint/engine/rules/c7/C7MissingStartEventRule.ts
new file mode 100644
index 00000000..c0908fb0
--- /dev/null
+++ b/src/adapters/out/bpmnlint/engine/rules/c7/C7MissingStartEventRule.ts
@@ -0,0 +1,32 @@
+import { is, isAny } from 'bpmnlint-utils';
+import { ERROR_TYPES, type ModdleElement, type ReportData } from '../CamundaRule.js';
+import { C7ExecutableRule } from './C7ExecutableRule.js';
+
+/**
+ * The base of the rules on a process or sub-process without start event (an empty one too): a
+ * rule implements `checkScope(scope, what, data)` with what the scope lacks and the report's data.
+ * The engines need a start event to begin a scope; the kind of scope says whether they refuse the
+ * file or fail when an instance reaches it.
+ *
+ * @example a sub-process without start event
+ * <bpmn:subProcess id="Review"><bpmn:task id="Check" /></bpmn:subProcess>
+ */
+export abstract class C7MissingStartEventRule extends C7ExecutableRule {
+  protected checkNode(node: ModdleElement): void {
+    if (!isAny(node, ['bpmn:Process', 'bpmn:SubProcess']) || is(node, 'bpmn:AdHocSubProcess')) {
+      return;
+    }
+    const nodes: ModdleElement[] = (node.flowElements ?? []).filter((element: ModdleElement) => is(element, 'bpmn:FlowNode'));
+    if (nodes.some((element) => is(element, 'bpmn:StartEvent'))) return;
+    const what = nodes.length ? 'has no start event' : 'is empty, without a start event';
+    this.checkScope(node, what, { path: ['flowElements'], type: ERROR_TYPES.CHILD_ELEMENT_OF_TYPE_REQUIRED, requiredType: 'bpmn:StartEvent', hint: this.hint(node.id, nodes.length > 0, !is(node, 'bpmn:Process')) });
+  }
+
+  protected abstract checkScope(scope: ModdleElement, what: string, data: ReportData): void;
+
+  /** Add a start event before the first node (or into an empty scope); a sub-process may go instead. */
+  private hint(scopeId: string, hasNodes: boolean, removable: boolean): string {
+    const add = hasNodes ? `Add one: \`bpmn add <file> startEvent "<Name>" --before <firstNodeId>\` (or --in ${scopeId}, then connect it)` : `Add content: \`bpmn add <file> startEvent "<Name>" --in ${scopeId}\` and continue from it`;
+    return `${add}${removable ? `, or remove it: \`bpmn remove <file> ${scopeId}\`` : ''}.`;
+  }
+}
diff --git a/src/adapters/out/bpmnlint/engine/rules/c7/C7MultiInstanceNeedsCardinalityOrCollectionRule.ts b/src/adapters/out/bpmnlint/engine/rules/c7/C7MultiInstanceNeedsCardinalityOrCollectionRule.ts
new file mode 100644
index 00000000..240fd7a1
--- /dev/null
+++ b/src/adapters/out/bpmnlint/engine/rules/c7/C7MultiInstanceNeedsCardinalityOrCollectionRule.ts
@@ -0,0 +1,40 @@
+import { defineRule, ERROR_TYPES, type ModdleElement } from '../CamundaRule.js';
+import { ElementKinds } from '../support/ElementKinds.js';
+import { Shell } from '../support/Shell.js';
+import { Values } from '../support/Values.js';
+import { C7ExecutableRule } from './C7ExecutableRule.js';
+import { C7Diagram } from './support/C7Diagram.js';
+import { C7MultiInstanceLoop } from './support/C7MultiInstanceLoop.js';
+import { CamundaAttributes } from './support/CamundaAttributes.js';
+
+/**
+ * A multi-instance loop with nothing to iterate over: neither a loop cardinality nor a collection,
+ * or an empty cardinality and no collection.
+ * Camunda 7 refuses to deploy the file.
+ *
+ * @example a loop without cardinality or collection
+ * <bpmn:userTask id="Review">
+ *   <bpmn:multiInstanceLoopCharacteristics />  <!-- camunda:collection="${reviewers}" -->
+ * </bpmn:userTask>
+ */
+class C7MultiInstanceNeedsCardinalityOrCollectionRule extends C7ExecutableRule {
+  protected checkNode(node: ModdleElement): void {
+    const multiInstance = C7MultiInstanceLoop.of(node);
+    if (!multiInstance || multiInstance.hasCollection) return;
+    const { loop, cardinality } = multiInstance;
+    const prefix = C7Diagram.of(node).prefix;
+    const label = ElementKinds.describe(node);
+    const id = node.id;
+    if (!cardinality) {
+      const misplaced = new CamundaAttributes(node).any('collection');
+      const elementVariable = new CamundaAttributes(node).any('elementVariable');
+      const variable = elementVariable !== undefined ? ` ${prefix}:elementVariable= ${Shell.quote(`loop.${prefix}:elementVariable=${elementVariable}`)}` : '';
+      const hint = misplaced !== undefined ? `Move it onto the loop: \`bpmn set <file> ${id} ${prefix}:collection= ${Shell.quote(`loop.${prefix}:collection=${misplaced}`)}${variable}\`.` : `\`bpmn set <file> ${id} ${Shell.quote(`loop.${prefix}:collection=\${items}`)} loop.${prefix}:elementVariable=item\` (or \`bpmn set <file> ${id} cardinality=3\`).`;
+      this.report(node, `Multi-instance ${label} has neither a loop cardinality nor ${prefix}:collection${misplaced !== undefined ? ` (${prefix}:collection sits on the activity, not on the loop)` : ''}; the engines refuse the file`, { path: ['loopCharacteristics', 'collection'], type: ERROR_TYPES.PROPERTY_REQUIRED, node: loop, requiredProperty: ['loopCardinality', 'collection'], hint });
+    } else if (!Values.nonEmpty(cardinality.get('body'))) {
+      this.report(node, `Multi-instance ${label} has an empty loop cardinality; the engines refuse the file`, { path: ['loopCharacteristics', 'loopCardinality'], type: ERROR_TYPES.EXPRESSION_REQUIRED, node: loop, property: 'loopCardinality', hint: `\`bpmn set <file> ${id} cardinality=3\` (a number or \${...}).` });
+    }
+  }
+}
+
+export default defineRule({ ruleName: 'c7-multi-instance-needs-cardinality-or-collection', code: 'W_C7_DEPLOY_MULTI_INSTANCE', impact: 'deploy' }, C7MultiInstanceNeedsCardinalityOrCollectionRule);
diff --git a/src/adapters/out/bpmnlint/engine/rules/c7/C7NoZeebeContentRule.ts b/src/adapters/out/bpmnlint/engine/rules/c7/C7NoZeebeContentRule.ts
new file mode 100644
index 00000000..deaf81f6
--- /dev/null
+++ b/src/adapters/out/bpmnlint/engine/rules/c7/C7NoZeebeContentRule.ts
@@ -0,0 +1,45 @@
+import { defineRule, ERROR_TYPES, type ReportData } from '../CamundaRule.js';
+import { ZEEBE_URI } from '../support/DiagramNamespaces.js';
+import { C7VendorContentRule } from './C7VendorContentRule.js';
+import { CamundaPlacement } from './support/CamundaPlacement.js';
+import type { C7Host } from './support/C7Host.js';
+
+/**
+ * Camunda 8 content in a Camunda 7 model: zeebe attributes, of BPMN elements and inside the camunda
+ * extension elements the engines read, and zeebe extension elements.
+ * Camunda 7 deploys the file and ignores them.
+ *
+ * @example a Camunda 8 job type in a Camunda 7 model
+ * <bpmn:serviceTask id="Charge">
+ *   <bpmn:extensionElements><zeebe:taskDefinition type="charge" /></bpmn:extensionElements>  <!-- camunda:type="external" -->
+ * </bpmn:serviceTask>
+ */
+class C7NoZeebeContentRule extends C7VendorContentRule {
+  protected checkHost(host: C7Host): void {
+    for (const { key, local, uri } of host.foreignAttributes()) {
+      if (uri === ZEEBE_URI) {
+        this.reportForeignAttribute(host, host.describe(), key, { property: `zeebe:${local}`, path: host.path(`zeebe:${local}`), hint: `Remove it: ${host.unset(key) ?? 'edit the XML'}, and use the camunda attribute instead (\`bpmn kinds\` lists them).` });
+      }
+    }
+    if (host.isDefinitions()) return;
+    const read = new CamundaPlacement(host).readExtensions().map(({ index }) => index);
+    for (const extension of host.extensions()) {
+      const type = String(extension.value.$type);
+      if (extension.uri === ZEEBE_URI) {
+        this.reportContent(host, `${host.describe()} contains the Camunda 8 extension ${type}, which Camunda 7 ignores`, { type: ERROR_TYPES.EXTENSION_ELEMENT_NOT_ALLOWED, extensionElement: extension.value, path: host.extensionPath(extension.index), node: extension.value, hint: host.address ? `Remove it: ${host.address.extRemove(type)}.` : 'Remove it from the XML.' });
+      }
+      if (!read.includes(extension.index)) continue;
+      for (const { element, where, path, key, local, uri } of host.treeAttributes(extension)) {
+        if (uri === ZEEBE_URI) {
+          this.reportForeignAttribute(host, where, key, { property: `zeebe:${local}`, path: [...path, `zeebe:${local}`], node: element, hint: host.rebuild(extension) });
+        }
+      }
+    }
+  }
+
+  private reportForeignAttribute(host: C7Host, where: string, key: string, data: Pick<ReportData, 'path'> & Record<string, unknown>): void {
+    this.reportContent(host, `${where} carries the Camunda 8 attribute ${key}, which Camunda 7 ignores`, { type: ERROR_TYPES.PROPERTY_NOT_ALLOWED, ...data });
+  }
+}
+
+export default defineRule({ ruleName: 'c7-no-zeebe-content', code: 'W_C7_FOREIGN_CONTENT', impact: 'runtime' }, C7NoZeebeContentRule);
diff --git a/src/adapters/out/bpmnlint/engine/rules/c7/C7OutputMappingHostAllowedRule.ts b/src/adapters/out/bpmnlint/engine/rules/c7/C7OutputMappingHostAllowedRule.ts
new file mode 100644
index 00000000..e51bc860
--- /dev/null
+++ b/src/adapters/out/bpmnlint/engine/rules/c7/C7OutputMappingHostAllowedRule.ts
@@ -0,0 +1,36 @@
+import { is } from 'bpmnlint-utils';
+import { defineRule, ERROR_TYPES } from '../CamundaRule.js';
+import { C7ExtensionContentRule } from './C7ExtensionContentRule.js';
+import type { C7Host } from './support/C7Host.js';
+
+/**
+ * Output parameters of camunda:inputOutput on an end event or a multi-instance activity; mappings
+ * where the engines take none at all are the input/output host rule's.
+ * Camunda 7 refuses output mappings there and does not deploy the file.
+ *
+ * @example an output mapping on an end event
+ * <bpmn:endEvent id="Done">
+ *   <bpmn:extensionElements><camunda:inputOutput><camunda:outputParameter name="result">ok</camunda:outputParameter></camunda:inputOutput></bpmn:extensionElements>
+ * </bpmn:endEvent>
+ */
+class C7OutputMappingHostAllowedRule extends C7ExtensionContentRule {
+  protected checkHost(host: C7Host): void {
+    const node = host.node;
+    const withOutputs = host.camundaExtensions('inputOutput').find(({ value }) => (value.get('outputParameters') ?? []).length);
+    if (!is(node, 'bpmn:FlowNode') || !withOutputs || host.unsupportedMappingHost()) {
+      return;
+    }
+    const mapping = host.typeName('inputOutput');
+    const parameter = host.typeName('outputParameter');
+    const dropOutputs = `Remove the output parameters: rebuild the mapping without them (\`bpmn ext list <file> ${node.id} --json\`, then \`bpmn ext add <file> ${node.id} ${mapping} --replace --xml '...'\`).`;
+    const loop = node.loopCharacteristics;
+    const report = (message: string, hint: string) => this.reportOn(host, message, { hint, path: host.extensionPath(withOutputs.index, 'outputParameters'), type: ERROR_TYPES.PROPERTY_NOT_ALLOWED, node: withOutputs.value, property: 'outputParameters' });
+    if (is(node, 'bpmn:EndEvent')) {
+      report(`${parameter} on end event ${node.id}: the engines refuse output mappings on end events`, dropOutputs);
+    } else if (loop && is(loop, 'bpmn:MultiInstanceLoopCharacteristics')) {
+      report(`${parameter} on multi-instance ${host.describe()}: the engines refuse output mappings on multi-instance activities`, `${dropOutputs} Collect results in an activity inside the loop instead.`);
+    }
+  }
+}
+
+export default defineRule({ ruleName: 'c7-output-mapping-host-allowed', code: 'W_C7_DEPLOY_INPUT_OUTPUT', impact: 'deploy' }, C7OutputMappingHostAllowedRule);
diff --git a/src/adapters/out/bpmnlint/engine/rules/c7/C7ResultVariableNeedsExpressionRule.ts b/src/adapters/out/bpmnlint/engine/rules/c7/C7ResultVariableNeedsExpressionRule.ts
new file mode 100644
index 00000000..11d04b04
--- /dev/null
+++ b/src/adapters/out/bpmnlint/engine/rules/c7/C7ResultVariableNeedsExpressionRule.ts
@@ -0,0 +1,25 @@
+import { defineRule, ERROR_TYPES, type ModdleElement } from '../CamundaRule.js';
+import { Values } from '../support/Values.js';
+import { C7ImplementationHostRule } from './C7ImplementationHostRule.js';
+import type { ImplementationHost } from './support/ImplementationHost.js';
+
+/**
+ * A camunda:resultVariable next to a camunda:class or delegateExpression.
+ * Camunda 7 supports a result variable only with camunda:expression and refuses to deploy the
+ * file.
+ *
+ * @example a delegate with a result variable
+ * <bpmn:serviceTask id="Charge" camunda:class="org.acme.Charge" camunda:resultVariable="receipt" />
+ */
+class C7ResultVariableNeedsExpressionRule extends C7ImplementationHostRule {
+  protected checkHost(node: ModdleElement, host: ImplementationHost): void {
+    const delegate = ['class', 'delegateExpression'].find((local) => Values.nonEmpty(host.attributes.defined(local)));
+    if (!delegate || host.attributes.defined('resultVariable') === undefined) {
+      return;
+    }
+    const { prefix, command, label } = host;
+    this.report(node, `${label} combines ${prefix}:resultVariable with ${prefix}:${delegate}; the engines support a result variable only with ${prefix}:expression and refuse the file`, { path: host.pathTo('resultVariable'), type: ERROR_TYPES.PROPERTY_NOT_ALLOWED, node: host.element, property: 'resultVariable', hint: `Remove it: ${command.of(`${prefix}:resultVariable=`)} (or switch to ${prefix}:expression=\${...}).` });
+  }
+}
+
+export default defineRule({ ruleName: 'c7-result-variable-needs-expression', code: 'W_C7_DEPLOY_RESULT_VARIABLE', impact: 'deploy' }, C7ResultVariableNeedsExpressionRule);
diff --git a/src/adapters/out/bpmnlint/engine/rules/c7/C7ScopeNeedsStartEventRule.ts b/src/adapters/out/bpmnlint/engine/rules/c7/C7ScopeNeedsStartEventRule.ts
new file mode 100644
index 00000000..d0477e24
--- /dev/null
+++ b/src/adapters/out/bpmnlint/engine/rules/c7/C7ScopeNeedsStartEventRule.ts
@@ -0,0 +1,24 @@
+import { is } from 'bpmnlint-utils';
+import { defineRule, type ModdleElement, type ReportData } from '../CamundaRule.js';
+import { EngineScope } from '../support/EngineScope.js';
+import { C7MissingStartEventRule } from './C7MissingStartEventRule.js';
+
+/**
+ * A process or sub-process without start event, an empty one too; an event sub-process without one
+ * is left to other rules, a transaction to the transaction rule.
+ * Camunda 7 refuses to deploy the file (`process must define a startEvent element`).
+ *
+ * @example a process without start event
+ * <bpmn:process id="Order" isExecutable="true"><bpmn:task id="Check" /></bpmn:process>
+ */
+class C7ScopeNeedsStartEventRule extends C7MissingStartEventRule {
+  protected checkScope(scope: ModdleElement, what: string, data: ReportData): void {
+    if (is(scope, 'bpmn:Transaction') || EngineScope.isEventSubProcess(scope)) {
+      return;
+    }
+    const isProcess = is(scope, 'bpmn:Process');
+    this.report(scope, `${isProcess ? 'Process' : 'Sub-process'} ${scope.id} ${what}; the engines refuse the file (${isProcess ? 'process' : 'subProcess'} must define a startEvent element)`, data);
+  }
+}
+
+export default defineRule({ ruleName: 'c7-scope-needs-start-event', code: 'W_C7_DEPLOY_START_EVENT', impact: 'deploy' }, C7ScopeNeedsStartEventRule);
diff --git a/src/adapters/out/bpmnlint/engine/rules/c7/C7ScriptTaskNeedsScriptRule.ts b/src/adapters/out/bpmnlint/engine/rules/c7/C7ScriptTaskNeedsScriptRule.ts
new file mode 100644
index 00000000..77d35b80
--- /dev/null
+++ b/src/adapters/out/bpmnlint/engine/rules/c7/C7ScriptTaskNeedsScriptRule.ts
@@ -0,0 +1,25 @@
+import { is } from 'bpmnlint-utils';
+import { defineRule, ERROR_TYPES, type ModdleElement } from '../CamundaRule.js';
+import { Values } from '../support/Values.js';
+import { C7ExecutableRule } from './C7ExecutableRule.js';
+import { C7Diagram } from './support/C7Diagram.js';
+import { CamundaAttributes } from './support/CamundaAttributes.js';
+
+/**
+ * A script task with neither script nor camunda:resource.
+ * Camunda 7 refuses to deploy the file.
+ *
+ * @example a script task without script
+ * <bpmn:scriptTask id="Compute" scriptFormat="groovy" />  <!-- <bpmn:script> or camunda:resource -->
+ */
+class C7ScriptTaskNeedsScriptRule extends C7ExecutableRule {
+  protected checkNode(node: ModdleElement): void {
+    if (!is(node, 'bpmn:ScriptTask') || Values.nonEmpty(node.get('script')) || new CamundaAttributes(node).defined('resource') !== undefined) {
+      return;
+    }
+    const prefix = C7Diagram.of(node).prefix;
+    this.report(node, `Script task ${node.id} has neither a script nor ${prefix}:resource; the engines refuse the file`, { path: ['script'], type: ERROR_TYPES.PROPERTY_REQUIRED, requiredProperty: ['script', 'resource'], hint: `\`bpmn set <file> ${node.id} scriptFormat=groovy script=...\` (or ${prefix}:resource=deployment://<file>).` });
+  }
+}
+
+export default defineRule({ ruleName: 'c7-script-task-needs-script', code: 'W_C7_DEPLOY_SCRIPT', impact: 'deploy' }, C7ScriptTaskNeedsScriptRule);
diff --git a/src/adapters/out/bpmnlint/engine/rules/c7/C7ShellFieldValuesFixedRule.ts b/src/adapters/out/bpmnlint/engine/rules/c7/C7ShellFieldValuesFixedRule.ts
new file mode 100644
index 00000000..92174fa6
--- /dev/null
+++ b/src/adapters/out/bpmnlint/engine/rules/c7/C7ShellFieldValuesFixedRule.ts
@@ -0,0 +1,40 @@
+import { defineRule, ERROR_TYPES, type ModdleElement } from '../CamundaRule.js';
+import { Shell } from '../support/Shell.js';
+import { C7ImplementationHostRule } from './C7ImplementationHostRule.js';
+import type { ImplementationHost } from './support/ImplementationHost.js';
+
+const SHELL_FLAGS = ['wait', 'redirectError', 'cleanEnv'];
+
+/**
+ * A camunda:field of a shell task given as expression, or a flag (wait, redirectError, cleanEnv)
+ * other than true or false.
+ * The shell task takes fixed values only: Camunda 7 refuses to deploy the file. A field with no
+ * value, or with both a string attribute and element, is the field rule's.
+ *
+ * @example a shell flag that is no boolean
+ * <bpmn:serviceTask id="Backup" camunda:type="shell">
+ *   <bpmn:extensionElements><camunda:field name="wait" stringValue="yes" /></bpmn:extensionElements>  <!-- true or false -->
+ * </bpmn:serviceTask>
+ */
+class C7ShellFieldValuesFixedRule extends C7ImplementationHostRule {
+  protected checkHost(node: ModdleElement, host: ImplementationHost): void {
+    if (!host.isShell) return;
+    for (const { field, index } of host.fields()) {
+      const name = field.get('name') ?? '';
+      const fieldPath = host.pathTo('extensionElements', 'values', index);
+      const stringValue: string | undefined = field.get('stringValue');
+      const string: string | undefined = field.get('string');
+      if (stringValue !== undefined && string !== undefined) continue;
+      const fixed = string ?? (stringValue ? stringValue : undefined);
+      const property = string !== undefined ? 'string' : 'stringValue';
+      if (fixed !== undefined && SHELL_FLAGS.includes(name) && !['true', 'false'].includes(fixed.toLowerCase())) {
+        this.report(node, `${host.prefix}:field "${name}" of shell task ${host.label} is "${fixed}", not true or false; the engines refuse the file`, { path: [...fieldPath, property], type: ERROR_TYPES.PROPERTY_VALUE_NOT_ALLOWED, node: field, property, hint: host.fieldHint(`name=${name} stringValue=true`, 'Use true or false.', ' (or false).') });
+      }
+      if (fixed === undefined && field.get('expression') !== undefined) {
+        this.report(node, `${host.prefix}:field "${name}" of shell task ${host.label} is an expression; the shell task takes fixed values only and the engines refuse the file`, { path: [...fieldPath, 'expression'], type: ERROR_TYPES.PROPERTY_NOT_ALLOWED, node: field, property: 'expression', hint: host.fieldHint(`name=${Shell.quote(name)} stringValue=<value>`, 'Use a stringValue.') });
+      }
+    }
+  }
+}
+
+export default defineRule({ ruleName: 'c7-shell-field-values-fixed', code: 'W_C7_DEPLOY_IMPLEMENTATION', impact: 'deploy' }, C7ShellFieldValuesFixedRule);
diff --git a/src/adapters/out/bpmnlint/engine/rules/c7/C7ShellTaskNeedsCommandRule.ts b/src/adapters/out/bpmnlint/engine/rules/c7/C7ShellTaskNeedsCommandRule.ts
new file mode 100644
index 00000000..ca76f4be
--- /dev/null
+++ b/src/adapters/out/bpmnlint/engine/rules/c7/C7ShellTaskNeedsCommandRule.ts
@@ -0,0 +1,21 @@
+import { defineRule, ERROR_TYPES, type ModdleElement } from '../CamundaRule.js';
+import { C7ImplementationHostRule } from './C7ImplementationHostRule.js';
+import type { ImplementationHost } from './support/ImplementationHost.js';
+
+/**
+ * A shell task without a camunda:field named command.
+ * Camunda 7 refuses to deploy the file.
+ *
+ * @example a shell task that runs nothing
+ * <bpmn:serviceTask id="Backup" camunda:type="shell" />  <!-- camunda:field name="command" -->
+ */
+class C7ShellTaskNeedsCommandRule extends C7ImplementationHostRule {
+  protected checkHost(node: ModdleElement, host: ImplementationHost): void {
+    if (!host.isShell || host.fields().some(({ field }) => field.get('name') === 'command')) {
+      return;
+    }
+    this.report(node, `${host.label} is a shell task without a ${host.prefix}:field named command; the engines refuse the file`, { path: host.pathTo('extensionElements'), type: ERROR_TYPES.EXTENSION_ELEMENT_REQUIRED, node: host.element, requiredExtensionElement: 'camunda:Field', hint: host.fieldHint('name=command stringValue=<command>', 'Add a command field in the XML.') });
+  }
+}
+
+export default defineRule({ ruleName: 'c7-shell-task-needs-command', code: 'W_C7_DEPLOY_IMPLEMENTATION', impact: 'deploy' }, C7ShellTaskNeedsCommandRule);
diff --git a/src/adapters/out/bpmnlint/engine/rules/c7/C7SignalEventNeedsSignalRule.ts b/src/adapters/out/bpmnlint/engine/rules/c7/C7SignalEventNeedsSignalRule.ts
new file mode 100644
index 00000000..d28ef1d4
--- /dev/null
+++ b/src/adapters/out/bpmnlint/engine/rules/c7/C7SignalEventNeedsSignalRule.ts
@@ -0,0 +1,22 @@
+import { defineRule } from '../CamundaRule.js';
+import { C7EventReferenceRule, type EventReference } from './C7EventReferenceRule.js';
+
+/**
+ * A signal event without signal.
+ * Camunda 7 refuses to deploy the file.
+ *
+ * @example a signal event without signal
+ * <bpmn:intermediateThrowEvent id="Alarm"><bpmn:signalEventDefinition /></bpmn:intermediateThrowEvent>  <!-- signalRef -->
+ */
+class C7SignalEventNeedsSignalRule extends C7EventReferenceRule {
+  protected readonly kind = 'Signal';
+  protected readonly events = ['bpmn:Event'];
+
+  protected checkReference(reference: EventReference): void {
+    if (!reference.referenced) {
+      this.reportMissing(reference, 'has no signal', 'signal=<SignalName>');
+    }
+  }
+}
+
+export default defineRule({ ruleName: 'c7-signal-event-needs-signal', code: 'W_C7_DEPLOY_SIGNAL', impact: 'deploy' }, C7SignalEventNeedsSignalRule);
diff --git a/src/adapters/out/bpmnlint/engine/rules/c7/C7SignalNameUniqueRule.ts b/src/adapters/out/bpmnlint/engine/rules/c7/C7SignalNameUniqueRule.ts
new file mode 100644
index 00000000..dbfdca40
--- /dev/null
+++ b/src/adapters/out/bpmnlint/engine/rules/c7/C7SignalNameUniqueRule.ts
@@ -0,0 +1,30 @@
+import { is } from 'bpmnlint-utils';
+import { C7Rule, defineRule, ERROR_TYPES, type ModdleElement } from '../CamundaRule.js';
+import { FirstOfKey } from '../support/FirstOfKey.js';
+
+/**
+ * Two signals of the file with one name, even of an unused signal, once a process is executable.
+ * Camunda 7 refuses duplicate signal names and does not deploy the file.
+ *
+ * @example two signals with one name
+ * <bpmn:signal id="Fire" name="Alarm" />
+ * <bpmn:signal id="Smoke" name="Alarm" />
+ */
+class C7SignalNameUniqueRule extends C7Rule {
+  protected visit(node: ModdleElement): void {
+    if (!is(node, 'bpmn:Definitions')) return;
+    const roots: ModdleElement[] = node.rootElements ?? [];
+    if (!roots.some((root) => is(root, 'bpmn:Process') && root.isExecutable === true)) {
+      return;
+    }
+    const firsts = new FirstOfKey<ModdleElement>();
+    for (const signal of roots.filter((root) => is(root, 'bpmn:Signal') && root.name)) {
+      const first = firsts.repeats(signal.name, signal);
+      if (first) {
+        this.report(signal, `Signals ${first.id} and ${signal.id} are both named "${signal.name}"; the engines refuse duplicate signal names`, { path: ['name'], type: ERROR_TYPES.ELEMENT_PROPERTY_VALUE_DUPLICATED, duplicatedProperty: 'name', duplicatedPropertyValue: signal.name, first, hint: `\`bpmn set <file> ${signal.id} name=<OtherName>\` (or point its events at ${first.id} and remove it).` });
+      }
+    }
+  }
+}
+
+export default defineRule({ ruleName: 'c7-signal-name-unique', code: 'W_C7_DEPLOY_SIGNAL', impact: 'deploy' }, C7SignalNameUniqueRule);
diff --git a/src/adapters/out/bpmnlint/engine/rules/c7/C7SignalNeedsNameRule.ts b/src/adapters/out/bpmnlint/engine/rules/c7/C7SignalNeedsNameRule.ts
new file mode 100644
index 00000000..bed1d1ff
--- /dev/null
+++ b/src/adapters/out/bpmnlint/engine/rules/c7/C7SignalNeedsNameRule.ts
@@ -0,0 +1,23 @@
+import { defineRule } from '../CamundaRule.js';
+import { ElementKinds } from '../support/ElementKinds.js';
+import { C7EventReferenceRule, type EventReference } from './C7EventReferenceRule.js';
+
+/**
+ * A signal without name that a signal event references.
+ * Camunda 7 broadcasts signals by name and refuses to deploy the file.
+ *
+ * @example a signal without name
+ * <bpmn:signal id="Alarm" />  <!-- name="Alarm" -->
+ */
+class C7SignalNeedsNameRule extends C7EventReferenceRule {
+  protected readonly kind = 'Signal';
+  protected readonly events = ['bpmn:Event'];
+
+  protected checkReference({ event, referenced, path }: EventReference): void {
+    if (referenced && !referenced.name) {
+      this.reportUnnamed(event, referenced, `Signal ${referenced.id} of ${ElementKinds.describe(event)}`, path);
+    }
+  }
+}
+
+export default defineRule({ ruleName: 'c7-signal-needs-name', code: 'W_C7_DEPLOY_SIGNAL', impact: 'deploy' }, C7SignalNeedsNameRule);
diff --git a/src/adapters/out/bpmnlint/engine/rules/c7/C7SignalSubscriptionUniqueRule.ts b/src/adapters/out/bpmnlint/engine/rules/c7/C7SignalSubscriptionUniqueRule.ts
new file mode 100644
index 00000000..d9ec6984
--- /dev/null
+++ b/src/adapters/out/bpmnlint/engine/rules/c7/C7SignalSubscriptionUniqueRule.ts
@@ -0,0 +1,16 @@
+import { defineRule } from '../CamundaRule.js';
+import { C7SubscriptionUniqueRule } from './C7SubscriptionUniqueRule.js';
+
+/**
+ * One signal name twice among the events waiting in one engine scope.
+ * Camunda 7 refuses two signal subscriptions with one name and does not deploy the file.
+ *
+ * @example two process start events waiting for the same signal
+ * <bpmn:startEvent id="Alarm"><bpmn:signalEventDefinition signalRef="Fire" /></bpmn:startEvent>
+ * <bpmn:startEvent id="AlarmAgain"><bpmn:signalEventDefinition signalRef="Fire" /></bpmn:startEvent>  <!-- same signal -->
+ */
+class C7SignalSubscriptionUniqueRule extends C7SubscriptionUniqueRule {
+  protected readonly kind = 'signal';
+}
+
+export default defineRule({ ruleName: 'c7-signal-subscription-unique', code: 'W_C7_DEPLOY_SIGNAL', impact: 'deploy' }, C7SignalSubscriptionUniqueRule);
diff --git a/src/adapters/out/bpmnlint/engine/rules/c7/C7StartEventUniqueRule.ts b/src/adapters/out/bpmnlint/engine/rules/c7/C7StartEventUniqueRule.ts
new file mode 100644
index 00000000..1e24c053
--- /dev/null
+++ b/src/adapters/out/bpmnlint/engine/rules/c7/C7StartEventUniqueRule.ts
@@ -0,0 +1,33 @@
+import { is, isAny } from 'bpmnlint-utils';
+import { defineRule, ERROR_TYPES, type ModdleElement } from '../CamundaRule.js';
+import { EngineScope } from '../support/EngineScope.js';
+import { C7ExecutableRule } from './C7ExecutableRule.js';
+import { C7EventDefinitions } from './support/C7EventDefinitions.js';
+import { C7ExtraStartHint } from './support/C7ExtraStartHint.js';
+
+/**
+ * A second none or timer start event of a process, or a second start event of a sub-process.
+ * Camunda 7 allows only one and refuses to deploy the file.
+ *
+ * @example two none start events of a process
+ * <bpmn:startEvent id="Received" />
+ * <bpmn:startEvent id="Entered" />  <!-- a message start event may stay -->
+ */
+class C7StartEventUniqueRule extends C7ExecutableRule {
+  protected checkNode(scope: ModdleElement): void {
+    if (!isAny(scope, ['bpmn:Process', 'bpmn:SubProcess']) || is(scope, 'bpmn:AdHocSubProcess')) {
+      return;
+    }
+    const starts: ModdleElement[] = (scope.flowElements ?? []).filter((element: ModdleElement) => is(element, 'bpmn:FlowNode') && is(element, 'bpmn:StartEvent'));
+    const isProcess = is(scope, 'bpmn:Process');
+    const limited = isProcess ? starts.filter((start) => new C7EventDefinitions(start).actedOn().every((definition) => is(definition, 'bpmn:TimerEventDefinition'))) : starts;
+    const [first, ...rest] = limited;
+    const kind = is(scope, 'bpmn:Transaction') ? 'Transaction' : 'Sub-process';
+    for (const extra of rest) {
+      const message = isProcess ? `Start event ${extra.id} is a second none or timer start event of process ${scope.id} (with ${first.id}); the engines allow only one and refuse the file` : `${EngineScope.isEventSubProcess(scope) ? 'Event sub-process' : kind} ${scope.id} has ${limited.length} start events (${limited.map((start) => start.id).join(', ')}); the engines allow only one in a sub-process and refuse the file`;
+      this.report(extra, message, { path: null, type: ERROR_TYPES.ELEMENT_MULTIPLE_NOT_ALLOWED, first, hint: new C7ExtraStartHint(scope, first, extra).text() });
+    }
+  }
+}
+
+export default defineRule({ ruleName: 'c7-start-event-unique', code: 'W_C7_DEPLOY_START_EVENT', impact: 'deploy' }, C7StartEventUniqueRule);
diff --git a/src/adapters/out/bpmnlint/engine/rules/c7/C7SubscriptionUniqueRule.ts b/src/adapters/out/bpmnlint/engine/rules/c7/C7SubscriptionUniqueRule.ts
new file mode 100644
index 00000000..4d1d8984
--- /dev/null
+++ b/src/adapters/out/bpmnlint/engine/rules/c7/C7SubscriptionUniqueRule.ts
@@ -0,0 +1,62 @@
+import { is } from 'bpmnlint-utils';
+import { C7Rule, ERROR_TYPES, type ModdleElement } from '../CamundaRule.js';
+import { ElementKinds } from '../support/ElementKinds.js';
+import { EngineScope } from '../support/EngineScope.js';
+import { FirstOfKey } from '../support/FirstOfKey.js';
+import { C7EventDefinitions } from './support/C7EventDefinitions.js';
+
+/**
+ * The base of the Camunda 7 rules on message and signal subscriptions with one name in one engine
+ * scope: a rule names the `kind`. The scopes are the start events of a process; the event
+ * sub-process starts of a scope with the boundary events on it; the boundary events of one
+ * activity with its own receive-task message (multi-instance: separate scopes).
+ * Camunda 7 refuses to deploy a file with two subscriptions of one name in a scope.
+ *
+ * @example two boundary events of one task waiting for the same message
+ * <bpmn:boundaryEvent attachedToRef="Pay"><bpmn:messageEventDefinition messageRef="Cancel" /></bpmn:boundaryEvent>
+ * <bpmn:boundaryEvent attachedToRef="Pay"><bpmn:messageEventDefinition messageRef="Cancel" /></bpmn:boundaryEvent>  <!-- same message -->
+ */
+export abstract class C7SubscriptionUniqueRule extends C7Rule {
+  protected abstract readonly kind: 'message' | 'signal';
+
+  protected visit(node: ModdleElement): void {
+    if (is(node, 'bpmn:Process') && EngineScope.C7.contains(node)) {
+      this.checkSubscriptions(node);
+    }
+  }
+
+  private checkSubscriptions(scope: ModdleElement, firsts = new FirstOfKey<ModdleElement>()): void {
+    const { kind } = this;
+    for (const node of scope.flowElements ?? []) {
+      if (kind === 'message' && is(node, 'bpmn:ReceiveTask')) {
+        this.checkSubscription(firsts, node, `scope:${node.id}`, node.messageRef?.name, ['messageRef']);
+      }
+      const subscriptionScope = this.subscriptionScope(node);
+      const definitions = new C7EventDefinitions(node);
+      const definition = subscriptionScope ? definitions.ofType(`bpmn:${kind.charAt(0).toUpperCase()}${kind.slice(1)}EventDefinition`) : undefined;
+      if (definition) {
+        this.checkSubscription(firsts, node, subscriptionScope!, definition.get(`${kind}Ref`)?.name, definitions.pathTo(definition, `${kind}Ref`));
+      }
+      if (is(node, 'bpmn:SubProcess') && !is(node, 'bpmn:AdHocSubProcess')) {
+        this.checkSubscriptions(node, firsts);
+      }
+    }
+  }
+
+  private checkSubscription(firsts: FirstOfKey<ModdleElement>, el: ModdleElement, scope: string, name: string | undefined, path: (string | number)[]): void {
+    const { kind } = this;
+    const first = name ? firsts.repeats(`${scope}\u0000${name}`, el) : undefined;
+    if (!first) return;
+    this.report(el, `${ElementKinds.describe(el)} waits for ${kind} "${name}" like ${first.id} in the same scope; the engines refuse two ${kind} subscriptions with one name`, { path, type: ERROR_TYPES.ELEMENT_PROPERTY_VALUE_DUPLICATED, duplicatedProperty: 'name', duplicatedPropertyValue: name, first, hint: `Use another ${kind}: \`bpmn set <file> ${el.id} ${kind}=<OtherName>\`.` });
+  }
+
+  private subscriptionScope(node: ModdleElement): string | undefined {
+    if (is(node, 'bpmn:StartEvent')) {
+      if (is(node.$parent, 'bpmn:Process')) return `start:${node.$parent.id}`;
+      return EngineScope.isEventSubProcess(node.$parent) ? `scope:${EngineScope.scopeOf(node.$parent)?.id}` : undefined;
+    }
+    if (!is(node, 'bpmn:BoundaryEvent') || !node.attachedToRef) return undefined;
+    const loop = node.attachedToRef.loopCharacteristics;
+    return `${loop && is(loop, 'bpmn:MultiInstanceLoopCharacteristics') ? 'body' : 'scope'}:${node.attachedToRef.id}`;
+  }
+}
diff --git a/src/adapters/out/bpmnlint/engine/rules/c7/C7TaskNeedsImplementationRule.ts b/src/adapters/out/bpmnlint/engine/rules/c7/C7TaskNeedsImplementationRule.ts
new file mode 100644
index 00000000..c6449d43
--- /dev/null
+++ b/src/adapters/out/bpmnlint/engine/rules/c7/C7TaskNeedsImplementationRule.ts
@@ -0,0 +1,23 @@
+import { defineRule, ERROR_TYPES, type ModdleElement } from '../CamundaRule.js';
+import { C7ImplementationHostRule } from './C7ImplementationHostRule.js';
+import { type ImplementationHost, IMPLEMENTATIONS } from './support/ImplementationHost.js';
+
+/**
+ * A service, send or business rule task without class, expression, delegate expression, external
+ * type, decision or connector.
+ * Camunda 7 refuses to deploy the file.
+ *
+ * @example a service task without implementation
+ * <bpmn:serviceTask id="Charge" />  <!-- no camunda:class, expression or type -->
+ */
+class C7TaskNeedsImplementationRule extends C7ImplementationHostRule {
+  protected checkHost(node: ModdleElement, host: ImplementationHost): void {
+    if (host.hasImplementation || host.isEvent) return;
+    const { prefix, command, label } = host;
+    const decision = host.readsDecisionRef ? `, ${prefix}:decisionRef=<decisionId>` : '';
+    const hint = host.attributes.defined('topic') !== undefined ? `It has a ${prefix}:topic but no ${prefix}:type: ${command.of(`${prefix}:type=external`)}.` : `Give it one: ${command.of(`${prefix}:type=external`, `${prefix}:topic=<topic>`)} (or ${prefix}:delegateExpression=\${...}, ${prefix}:class=..., ${prefix}:expression=\${...}${decision}).`;
+    this.report(node, `${label} has no implementation (${prefix}:class, delegateExpression, expression, type=external${host.readsDecisionRef ? ', decisionRef' : ''} or a connector); the engines refuse the file`, { path: host.pathTo('type'), type: ERROR_TYPES.PROPERTY_REQUIRED, node: host.element, requiredProperty: host.readsDecisionRef ? [...IMPLEMENTATIONS, 'decisionRef'] : IMPLEMENTATIONS, hint });
+  }
+}
+
+export default defineRule({ ruleName: 'c7-task-needs-implementation', code: 'W_C7_DEPLOY_IMPLEMENTATION', impact: 'deploy' }, C7TaskNeedsImplementationRule);
diff --git a/src/adapters/out/bpmnlint/engine/rules/c7/C7TaskTypeSupportedRule.ts b/src/adapters/out/bpmnlint/engine/rules/c7/C7TaskTypeSupportedRule.ts
new file mode 100644
index 00000000..0d9b4a10
--- /dev/null
+++ b/src/adapters/out/bpmnlint/engine/rules/c7/C7TaskTypeSupportedRule.ts
@@ -0,0 +1,24 @@
+import { defineRule, ERROR_TYPES, type ModdleElement } from '../CamundaRule.js';
+import { C7ExecutableRule } from './C7ExecutableRule.js';
+import { ImplementationHost } from './support/ImplementationHost.js';
+
+/**
+ * A camunda:type on a task or a message throw event other than external or shell.
+ * Camunda 7 refuses to deploy the file; the standard engine distributions cannot load the mail
+ * task either.
+ *
+ * @example a mail task
+ * <bpmn:sendTask id="Notify" camunda:type="mail" />  <!-- camunda:type="external" -->
+ */
+class C7TaskTypeSupportedRule extends C7ExecutableRule {
+  protected checkNode(node: ModdleElement): void {
+    for (const host of ImplementationHost.forElement(node)) {
+      if (!host.hasUnsupportedType) continue;
+      const { prefix, command, label } = host;
+      const mail = host.type!.toLowerCase() === 'mail' ? ' (the standard engine distributions cannot load the mail task)' : '';
+      this.report(node, `${prefix}:type="${host.type}" on ${label} is not supported (only "external" and "shell")${mail}; the engines refuse the file`, { path: host.pathTo('type'), type: ERROR_TYPES.PROPERTY_VALUE_NOT_ALLOWED, node: host.element, property: 'type', hint: `Use an external task: ${command.of(`${prefix}:type=external`, `${prefix}:topic=<topic>`)}, or remove it: ${command.of(`${prefix}:type=`)}.` });
+    }
+  }
+}
+
+export default defineRule({ ruleName: 'c7-task-type-supported', code: 'W_C7_DEPLOY_IMPLEMENTATION', impact: 'deploy' }, C7TaskTypeSupportedRule);
diff --git a/src/adapters/out/bpmnlint/engine/rules/c7/C7TimeoutListenerNeedsTimerAndIdRule.ts b/src/adapters/out/bpmnlint/engine/rules/c7/C7TimeoutListenerNeedsTimerAndIdRule.ts
new file mode 100644
index 00000000..84874ee8
--- /dev/null
+++ b/src/adapters/out/bpmnlint/engine/rules/c7/C7TimeoutListenerNeedsTimerAndIdRule.ts
@@ -0,0 +1,26 @@
+import { is } from 'bpmnlint-utils';
+import { defineRule, ERROR_TYPES, type ModdleElement } from '../CamundaRule.js';
+import { C7ListenerRule, type Listener } from './C7ListenerRule.js';
+
+/**
+ * A timeout task listener without bpmn:timerEventDefinition or without id.
+ * Camunda 7 needs both to schedule the timeout and refuses to deploy the file.
+ *
+ * @example a timeout listener without timer
+ * <camunda:taskListener id="Remind" class="org.acme.Remind" event="timeout" />  <!-- <bpmn:timerEventDefinition> -->
+ */
+class C7TimeoutListenerNeedsTimerAndIdRule extends C7ListenerRule {
+  protected checkListener(listener: Listener): void {
+    const { host, extension, event, label } = listener;
+    if (extension.local !== 'taskListener' || event !== 'timeout') return;
+    const { value } = extension;
+    if (!(value.get('eventDefinitions') ?? []).some((definition: ModdleElement) => is(definition, 'bpmn:TimerEventDefinition'))) {
+      this.reportListener(listener, `${label} has no bpmn:timerEventDefinition; the engines refuse the file`, ['eventDefinitions'], ERROR_TYPES.CHILD_ELEMENT_OF_TYPE_REQUIRED, { requiredType: 'bpmn:TimerEventDefinition', hint: host.rebuild(extension) });
+    }
+    if (value.get('id') === undefined) {
+      this.reportListener(listener, `${label} has no id, which the engines require on timeout task listeners; they refuse the file`, ['id'], ERROR_TYPES.PROPERTY_REQUIRED, { requiredProperty: 'id', hint: host.rebuild(extension, { id: '<listenerId>' }) });
+    }
+  }
+}
+
+export default defineRule({ ruleName: 'c7-timeout-listener-needs-timer-and-id', code: 'W_C7_DEPLOY_LISTENER', impact: 'deploy' }, C7TimeoutListenerNeedsTimerAndIdRule);
diff --git a/src/adapters/out/bpmnlint/engine/rules/c7/C7TimerNeedsOneTimeValueRule.ts b/src/adapters/out/bpmnlint/engine/rules/c7/C7TimerNeedsOneTimeValueRule.ts
new file mode 100644
index 00000000..6ce41cdd
--- /dev/null
+++ b/src/adapters/out/bpmnlint/engine/rules/c7/C7TimerNeedsOneTimeValueRule.ts
@@ -0,0 +1,38 @@
+import { is } from 'bpmnlint-utils';
+import { defineRule, ERROR_TYPES, type ModdleElement } from '../CamundaRule.js';
+import { ElementKinds } from '../support/ElementKinds.js';
+import { EngineScope } from '../support/EngineScope.js';
+import { C7EventDefinitionSchemaRule } from './C7EventDefinitionSchemaRule.js';
+import { C7EventDefinitions } from './support/C7EventDefinitions.js';
+
+const TIMER_ELEMENTS = ['timeDate', 'timeCycle', 'timeDuration'];
+
+/**
+ * A timer without date, duration or cycle that the engines run, or a timer with more than one of
+ * them, also one the engines ignore.
+ * Camunda 7 refuses to deploy the file; the BPMN schema allows only one of the three.
+ *
+ * @example a timer without value
+ * <bpmn:intermediateCatchEvent id="Wait"><bpmn:timerEventDefinition /></bpmn:intermediateCatchEvent>  <!-- timeDuration PT1H -->
+ */
+class C7TimerNeedsOneTimeValueRule extends C7EventDefinitionSchemaRule {
+  protected override checkEvent(event: ModdleElement): void {
+    if (!EngineScope.C7.contains(event)) return;
+    const definitions = new C7EventDefinitions(event);
+    for (const definition of definitions.actedOn()) {
+      if (is(definition, 'bpmn:TimerEventDefinition') && !TIMER_ELEMENTS.some((timeElement) => definition[timeElement])) {
+        this.report(event, `Timer of ${ElementKinds.describe(event)} has no date, cycle or duration; the engines refuse the file`, { path: definitions.pathTo(definition), type: ERROR_TYPES.PROPERTY_REQUIRED, node: definition, requiredProperty: TIMER_ELEMENTS, hint: `\`bpmn set <file> ${event.id} timer=PT1H\` (or R/PT1H, or a date).` });
+      }
+    }
+  }
+
+  protected checkDefinition(definition: ModdleElement): void {
+    const timeElements = TIMER_ELEMENTS.filter((timeElement) => definition[timeElement]);
+    if (!is(definition, 'bpmn:TimerEventDefinition') || timeElements.length < 2) {
+      return;
+    }
+    this.reportSchema(definition, `${this.subjectName(definition, 'Timer event')} has ${timeElements.join(' and ')}; the BPMN schema allows only one of timeDate, timeCycle and timeDuration, and the engines refuse the file`, { path: this.subjectPath(definition), type: ERROR_TYPES.ELEMENT_MULTIPLE_NOT_ALLOWED, hint: this.subjectHint(definition, 'timer=<value>', 'R/PT1H is a cycle, PT1H a duration, else a date; the other elements go') });
+  }
+}
+
+export default defineRule({ ruleName: 'c7-timer-needs-one-time-value', code: 'W_C7_DEPLOY_EVENT_DEFINITION', impact: 'deploy' }, C7TimerNeedsOneTimeValueRule);
diff --git a/src/adapters/out/bpmnlint/engine/rules/c7/C7TransactionNeedsStartEventRule.ts b/src/adapters/out/bpmnlint/engine/rules/c7/C7TransactionNeedsStartEventRule.ts
new file mode 100644
index 00000000..4ec244a5
--- /dev/null
+++ b/src/adapters/out/bpmnlint/engine/rules/c7/C7TransactionNeedsStartEventRule.ts
@@ -0,0 +1,19 @@
+import { is } from 'bpmnlint-utils';
+import { defineRule, type ModdleElement, type ReportData } from '../CamundaRule.js';
+import { C7MissingStartEventRule } from './C7MissingStartEventRule.js';
+
+/**
+ * A transaction without start event, an empty one too.
+ * Camunda 7 deploys the file, but every instance that reaches the transaction fails.
+ *
+ * @example a transaction without start event
+ * <bpmn:transaction id="Booking"><bpmn:task id="Reserve" /></bpmn:transaction>
+ */
+class C7TransactionNeedsStartEventRule extends C7MissingStartEventRule {
+  protected checkScope(scope: ModdleElement, what: string, data: ReportData): void {
+    if (!is(scope, 'bpmn:Transaction')) return;
+    this.report(scope, `Transaction ${scope.id} ${what}: it deploys, but every instance that reaches it fails ("No initial activity found for subprocess ${scope.id}")`, data);
+  }
+}
+
+export default defineRule({ ruleName: 'c7-transaction-needs-start-event', code: 'W_C7_TRANSACTION_NO_START', impact: 'runtime' }, C7TransactionNeedsStartEventRule);
diff --git a/src/adapters/out/bpmnlint/engine/rules/c7/C7UserTaskPriorityValidRule.ts b/src/adapters/out/bpmnlint/engine/rules/c7/C7UserTaskPriorityValidRule.ts
new file mode 100644
index 00000000..f44ae6a7
--- /dev/null
+++ b/src/adapters/out/bpmnlint/engine/rules/c7/C7UserTaskPriorityValidRule.ts
@@ -0,0 +1,26 @@
+import { is } from 'bpmnlint-utils';
+import { defineRule, ERROR_TYPES, type ModdleElement } from '../CamundaRule.js';
+import { ElementKinds } from '../support/ElementKinds.js';
+import { SetCommand } from '../support/SetCommand.js';
+import { Values } from '../support/Values.js';
+import { C7ExecutableRule } from './C7ExecutableRule.js';
+import { C7Diagram } from './support/C7Diagram.js';
+import { CamundaAttributes } from './support/CamundaAttributes.js';
+
+/**
+ * A camunda:priority of a user task that is neither a number nor an expression.
+ * Camunda 7 deploys the file, but creating the task fails when the process reaches it.
+ *
+ * @example a task priority in words
+ * <bpmn:userTask id="Review" camunda:priority="urgent" />  <!-- 50 -->
+ */
+class C7UserTaskPriorityValidRule extends C7ExecutableRule {
+  protected checkNode(node: ModdleElement): void {
+    const priority = is(node, 'bpmn:UserTask') ? new CamundaAttributes(node).defined('priority') : undefined;
+    if (priority === undefined || Values.isPriority(priority)) return;
+    const prefix = C7Diagram.of(node).prefix;
+    this.report(node, `${prefix}:priority="${priority}" on ${ElementKinds.describe(node)} is not a number or expression; creating the task fails`, { path: ['priority'], type: ERROR_TYPES.PROPERTY_VALUE_NOT_ALLOWED, property: 'priority', hint: `${new SetCommand(node.id).of(`${prefix}:priority=50`)}.` });
+  }
+}
+
+export default defineRule({ ruleName: 'c7-user-task-priority-valid', code: 'W_C7_BAD_VALUE', impact: 'runtime' }, C7UserTaskPriorityValidRule);
diff --git a/src/adapters/out/bpmnlint/engine/rules/c7/C7VariableEventsKnownRule.ts b/src/adapters/out/bpmnlint/engine/rules/c7/C7VariableEventsKnownRule.ts
new file mode 100644
index 00000000..a88187aa
--- /dev/null
+++ b/src/adapters/out/bpmnlint/engine/rules/c7/C7VariableEventsKnownRule.ts
@@ -0,0 +1,34 @@
+import { is } from 'bpmnlint-utils';
+import { defineRule, ERROR_TYPES, type ModdleElement } from '../CamundaRule.js';
+import { ElementKinds } from '../support/ElementKinds.js';
+import { SetCommand } from '../support/SetCommand.js';
+import { C7ExecutableRule } from './C7ExecutableRule.js';
+import { C7Diagram } from './support/C7Diagram.js';
+import { C7EventDefinitions } from './support/C7EventDefinitions.js';
+import { CamundaAttributes } from './support/CamundaAttributes.js';
+
+const VARIABLE_EVENTS = ['create', 'update', 'delete'];
+
+/**
+ * camunda:variableEvents of a conditional event that list an event other than create, update and
+ * delete.
+ * Camunda 7 deploys the file, but only create, update and delete trigger the condition.
+ *
+ * @example an unknown variable event
+ * <bpmn:conditionalEventDefinition camunda:variableEvents="change" />  <!-- update -->
+ */
+class C7VariableEventsKnownRule extends C7ExecutableRule {
+  protected checkNode(node: ModdleElement): void {
+    if (!is(node, 'bpmn:Event')) return;
+    const prefix = C7Diagram.of(node).prefix;
+    for (const { definition, index } of new C7EventDefinitions(node).indexedOfType('bpmn:ConditionalEventDefinition')) {
+      const events = new CamundaAttributes(definition).defined('variableEvents');
+      const unknown = (events ?? '').split(',').map((eventName) => eventName.trim()).filter((eventName) => eventName && !VARIABLE_EVENTS.includes(eventName));
+      if (unknown.length) {
+        this.report(node, `${prefix}:variableEvents="${events}" of ${ElementKinds.describe(node)} lists ${unknown.join(', ')}; only ${VARIABLE_EVENTS.join(', ')} trigger the condition`, { path: ['eventDefinitions', index, 'variableEvents'], type: ERROR_TYPES.PROPERTY_VALUE_NOT_ALLOWED, node: definition, property: 'variableEvents', hint: `${SetCommand.forDefinition(node, index).of(`${prefix}:variableEvents=create, update`)}.` });
+      }
+    }
+  }
+}
+
+export default defineRule({ ruleName: 'c7-variable-events-known', code: 'W_C7_BAD_VALUE', impact: 'runtime' }, C7VariableEventsKnownRule);
diff --git a/src/adapters/out/bpmnlint/engine/rules/c7/C7VendorContentRule.ts b/src/adapters/out/bpmnlint/engine/rules/c7/C7VendorContentRule.ts
new file mode 100644
index 00000000..664a880a
--- /dev/null
+++ b/src/adapters/out/bpmnlint/engine/rules/c7/C7VendorContentRule.ts
@@ -0,0 +1,25 @@
+import { C7Rule, type ModdleElement, type ReportData } from '../CamundaRule.js';
+import type { VendorHost } from '../support/VendorHost.js';
+import { C7Host } from './support/C7Host.js';
+
+/**
+ * The base of the Camunda 7 rules on vendor content the engines do not read: a rule implements
+ * `checkHost(host)` for each BPMN element the engines look at, and reports with `reportContent`.
+ * Camunda 7 deploys the file and silently ignores such a setting, so the process runs without the
+ * behaviour the model seems to configure.
+ *
+ * @example a typo in an attribute name
+ * <bpmn:userTask id="Review" camunda:asignee="demo" />  <!-- nobody gets assigned -->
+ */
+export abstract class C7VendorContentRule extends C7Rule {
+  protected visit(node: ModdleElement): boolean | void {
+    if (!C7Host.visits(node)) return false;
+    this.checkHost(new C7Host(node));
+  }
+
+  protected abstract checkHost(host: C7Host): void;
+
+  protected reportContent(host: VendorHost, message: string, { path, ...data }: ReportData): void {
+    this.report(host.target, message, { node: host.node, path, ...data });
+  }
+}
diff --git a/src/adapters/out/bpmnlint/engine/rules/c7/Camunda7Rules.ts b/src/adapters/out/bpmnlint/engine/rules/c7/Camunda7Rules.ts
new file mode 100644
index 00000000..f15cde92
--- /dev/null
+++ b/src/adapters/out/bpmnlint/engine/rules/c7/Camunda7Rules.ts
@@ -0,0 +1,158 @@
+import { compatRules, moddleExtensions } from '@miragon/bpmnlint-plugin-rules/camunda-7';
+import type { EngineKit } from '../../../engine-kit.js';
+import type { EngineEntry } from '../../run/EngineRun.js';
+import { RuleEntries } from '../RuleEntries.js';
+import { C7Diagram } from './support/C7Diagram.js';
+import c7EventGatewayTargetAllowed from './C7EventGatewayTargetAllowedRule.js';
+import c7EventGatewayBranchesUnique from './C7EventGatewayBranchesUniqueRule.js';
+import c7ExclusiveGatewayNeedsOutgoing from './C7ExclusiveGatewayNeedsOutgoingRule.js';
+import c7ExclusiveGatewayDefaultNoCondition from './C7ExclusiveGatewayDefaultNoConditionRule.js';
+import c7ExclusiveGatewayNeedsDefault from './C7ExclusiveGatewayNeedsDefaultRule.js';
+import c7ExclusiveGatewayNeedsConditions from './C7ExclusiveGatewayNeedsConditionsRule.js';
+import c7ComplexGatewayNoFlows from './C7ComplexGatewayNoFlowsRule.js';
+import c7AdHocSubProcessNoFlows from './C7AdHocSubProcessNoFlowsRule.js';
+import c7AdHocSubProcessNoMultiInstance from './C7AdHocSubProcessNoMultiInstanceRule.js';
+import c7ScopeNeedsStartEvent from './C7ScopeNeedsStartEventRule.js';
+import c7TransactionNeedsStartEvent from './C7TransactionNeedsStartEventRule.js';
+import c7StartEventUnique from './C7StartEventUniqueRule.js';
+import c7TaskTypeSupported from './C7TaskTypeSupportedRule.js';
+import c7ShellTaskNeedsCommand from './C7ShellTaskNeedsCommandRule.js';
+import c7ShellFieldValuesFixed from './C7ShellFieldValuesFixedRule.js';
+import c7TaskNeedsImplementation from './C7TaskNeedsImplementationRule.js';
+import c7MessageThrowNeedsImplementation from './C7MessageThrowNeedsImplementationRule.js';
+import c7ExternalTaskNeedsTopic from './C7ExternalTaskNeedsTopicRule.js';
+import c7ResultVariableNeedsExpression from './C7ResultVariableNeedsExpressionRule.js';
+import c7ScriptTaskNeedsScript from './C7ScriptTaskNeedsScriptRule.js';
+import c7HistoryTimeToLiveValid from './C7HistoryTimeToLiveValidRule.js';
+import c7JobPriorityValid from './C7JobPriorityValidRule.js';
+import c7DecisionResultMapperKnown from './C7DecisionResultMapperKnownRule.js';
+import c7BindingKnown from './C7BindingKnownRule.js';
+import c7UserTaskPriorityValid from './C7UserTaskPriorityValidRule.js';
+import c7VariableEventsKnown from './C7VariableEventsKnownRule.js';
+import c7BindingNeedsVersion from './C7BindingNeedsVersionRule.js';
+import c7CallActivityOneCalledElement from './C7CallActivityOneCalledElementRule.js';
+import c7FormRefNoFormKey from './C7FormRefNoFormKeyRule.js';
+import c7FormRefNeedsBinding from './C7FormRefNeedsBindingRule.js';
+import c7MultiInstanceNeedsCardinalityOrCollection from './C7MultiInstanceNeedsCardinalityOrCollectionRule.js';
+import c7ElementVariableNeedsCollection from './C7ElementVariableNeedsCollectionRule.js';
+import c7SignalNameUnique from './C7SignalNameUniqueRule.js';
+import c7MessageSubscriptionUnique from './C7MessageSubscriptionUniqueRule.js';
+import c7SignalSubscriptionUnique from './C7SignalSubscriptionUniqueRule.js';
+import c7LinkCatchNameUnique from './C7LinkCatchNameUniqueRule.js';
+import c7LinkThrowNeedsCatch from './C7LinkThrowNeedsCatchRule.js';
+import c7TimerNeedsOneTimeValue from './C7TimerNeedsOneTimeValueRule.js';
+import c7CompensationNamesOwnActivity from './C7CompensationNamesOwnActivityRule.js';
+import c7ConditionalEventNeedsCondition from './C7ConditionalEventNeedsConditionRule.js';
+import c7LinkEventNeedsName from './C7LinkEventNeedsNameRule.js';
+import c7MessageEventNeedsMessage from './C7MessageEventNeedsMessageRule.js';
+import c7MessageNeedsName from './C7MessageNeedsNameRule.js';
+import c7SignalEventNeedsSignal from './C7SignalEventNeedsSignalRule.js';
+import c7SignalNeedsName from './C7SignalNeedsNameRule.js';
+import c7ErrorEndEventNeedsError from './C7ErrorEndEventNeedsErrorRule.js';
+import c7ErrorNeedsCode from './C7ErrorNeedsCodeRule.js';
+import c7EscalationThrowNeedsEscalation from './C7EscalationThrowNeedsEscalationRule.js';
+import c7EscalationNeedsCode from './C7EscalationNeedsCodeRule.js';
+import c7EscalationBoundaryHostAllowed from './C7EscalationBoundaryHostAllowedRule.js';
+import c7CallMappingNeedsSourceAndTarget from './C7CallMappingNeedsSourceAndTargetRule.js';
+import c7ConnectorNeedsId from './C7ConnectorNeedsIdRule.js';
+import c7IoParameterNeedsName from './C7IoParameterNeedsNameRule.js';
+import c7FormFieldNeedsIdAndType from './C7FormFieldNeedsIdAndTypeRule.js';
+import c7FieldNeedsOneValue from './C7FieldNeedsOneValueRule.js';
+import c7ListenerNeedsImplementation from './C7ListenerNeedsImplementationRule.js';
+import c7ListenerEventKnown from './C7ListenerEventKnownRule.js';
+import c7ListenerScriptNeedsFormat from './C7ListenerScriptNeedsFormatRule.js';
+import c7TimeoutListenerNeedsTimerAndId from './C7TimeoutListenerNeedsTimerAndIdRule.js';
+import c7IoMappingHostAllowed from './C7IoMappingHostAllowedRule.js';
+import c7OutputMappingHostAllowed from './C7OutputMappingHostAllowedRule.js';
+import c7NoZeebeContent from './C7NoZeebeContentRule.js';
+import c7CamundaAttributeKnown from './C7CamundaAttributeKnownRule.js';
+import c7CamundaAttributePlacement from './C7CamundaAttributePlacementRule.js';
+import c7CamundaExtensionPlacement from './C7CamundaExtensionPlacementRule.js';
+import c7CamundaReferenceResolves from './C7CamundaReferenceResolvesRule.js';
+import c7BpmnAttributeKnown from './C7BpmnAttributeKnownRule.js';
+import c7CamundaBooleanValid from './C7CamundaBooleanValidRule.js';
+import c7IoParameterInInputOutput from './C7IoParameterInInputOutputRule.js';
+import c7CamundaElementKnown from './C7CamundaElementKnownRule.js';
+
+/** bpmn-cli's Camunda 7 rules: the checks camunda-compat's `camunda-platform-7-*` configs leave out, in the order their findings of one element are listed. */
+export class Camunda7Rules {
+  static readonly RULES = [
+    c7EventGatewayTargetAllowed,
+    c7EventGatewayBranchesUnique,
+    c7ExclusiveGatewayNeedsOutgoing,
+    c7ExclusiveGatewayDefaultNoCondition,
+    c7ExclusiveGatewayNeedsDefault,
+    c7ExclusiveGatewayNeedsConditions,
+    c7ComplexGatewayNoFlows,
+    c7AdHocSubProcessNoFlows,
+    c7AdHocSubProcessNoMultiInstance,
+    c7ScopeNeedsStartEvent,
+    c7TransactionNeedsStartEvent,
+    c7StartEventUnique,
+    c7TaskTypeSupported,
+    c7ShellTaskNeedsCommand,
+    c7ShellFieldValuesFixed,
+    c7TaskNeedsImplementation,
+    c7MessageThrowNeedsImplementation,
+    c7ExternalTaskNeedsTopic,
+    c7ResultVariableNeedsExpression,
+    c7ScriptTaskNeedsScript,
+    c7HistoryTimeToLiveValid,
+    c7JobPriorityValid,
+    c7DecisionResultMapperKnown,
+    c7BindingKnown,
+    c7UserTaskPriorityValid,
+    c7VariableEventsKnown,
+    c7BindingNeedsVersion,
+    c7CallActivityOneCalledElement,
+    c7FormRefNoFormKey,
+    c7FormRefNeedsBinding,
+    c7MultiInstanceNeedsCardinalityOrCollection,
+    c7ElementVariableNeedsCollection,
+    c7SignalNameUnique,
+    c7MessageSubscriptionUnique,
+    c7SignalSubscriptionUnique,
+    c7LinkCatchNameUnique,
+    c7LinkThrowNeedsCatch,
+    c7TimerNeedsOneTimeValue,
+    c7CompensationNamesOwnActivity,
+    c7ConditionalEventNeedsCondition,
+    c7LinkEventNeedsName,
+    c7MessageEventNeedsMessage,
+    c7MessageNeedsName,
+    c7SignalEventNeedsSignal,
+    c7SignalNeedsName,
+    c7ErrorEndEventNeedsError,
+    c7ErrorNeedsCode,
+    c7EscalationThrowNeedsEscalation,
+    c7EscalationNeedsCode,
+    c7EscalationBoundaryHostAllowed,
+    c7CallMappingNeedsSourceAndTarget,
+    c7ConnectorNeedsId,
+    c7IoParameterNeedsName,
+    c7FormFieldNeedsIdAndType,
+    c7FieldNeedsOneValue,
+    c7ListenerNeedsImplementation,
+    c7ListenerEventKnown,
+    c7ListenerScriptNeedsFormat,
+    c7TimeoutListenerNeedsTimerAndId,
+    c7IoMappingHostAllowed,
+    c7OutputMappingHostAllowed,
+    c7NoZeebeContent,
+    c7CamundaAttributeKnown,
+    c7CamundaAttributePlacement,
+    c7CamundaExtensionPlacement,
+    c7CamundaReferenceResolves,
+  ];
+  static readonly WRITTEN_FILE_RULES = [
+    c7BpmnAttributeKnown,
+    c7CamundaBooleanValid,
+    c7IoParameterInInputOutput,
+    c7CamundaElementKnown,
+  ];
+
+  /** camunda-compat's rules for an engine version with these, as `bpmn-cli/<rule>`, and the moddle extension they read. */
+  static entry(kit: EngineKit): EngineEntry {
+    return RuleEntries.entry(kit, Camunda7Rules.RULES, Camunda7Rules.WRITTEN_FILE_RULES, { compatRules, moddleExtensions }, (definitions, warnings, vendor) => C7Diagram.record(definitions, vendor, warnings));
+  }
+}
diff --git a/src/adapters/out/bpmnlint/engine/rules/c7/support/C7AdHocSubProcess.ts b/src/adapters/out/bpmnlint/engine/rules/c7/support/C7AdHocSubProcess.ts
new file mode 100644
index 00000000..41001cc1
--- /dev/null
+++ b/src/adapters/out/bpmnlint/engine/rules/c7/support/C7AdHocSubProcess.ts
@@ -0,0 +1,25 @@
+import type { ModdleElement } from '@miragon/bpmnlint-plugin-rules/engine';
+import { C7FlowGraph } from './C7FlowGraph.js';
+
+/** What connects an ad-hoc sub-process, which the engines do not run, and how to make it one they run. */
+export class C7AdHocSubProcess {
+  readonly incoming: ModdleElement[];
+  readonly flows: ModdleElement[];
+  readonly boundaryEvents: ModdleElement[];
+
+  constructor(readonly node: ModdleElement) {
+    const graph = C7FlowGraph.forElement(node);
+    this.incoming = graph.incoming(node);
+    this.flows = [...this.incoming, ...graph.outgoing(node)];
+    this.boundaryEvents = graph.boundaryEvents(node);
+  }
+
+  get isConnected(): boolean {
+    return this.flows.length > 0 || this.boundaryEvents.length > 0;
+  }
+
+  get retypeHint(): string {
+    const { id } = this.node;
+    return `Make it an embedded sub-process: \`bpmn retype <file> ${id} subProcess\`, then give its content a start event and flows (\`bpmn add <file> startEvent "<Name>" --in ${id}\`, \`bpmn connect <file> <fromId> <toId>\`)`;
+  }
+}
diff --git a/src/adapters/out/bpmnlint/engine/rules/c7/support/C7Bindings.ts b/src/adapters/out/bpmnlint/engine/rules/c7/support/C7Bindings.ts
new file mode 100644
index 00000000..7020b545
--- /dev/null
+++ b/src/adapters/out/bpmnlint/engine/rules/c7/support/C7Bindings.ts
@@ -0,0 +1,44 @@
+import { is, isAny } from 'bpmnlint-utils';
+import type { ModdleElement } from '@miragon/bpmnlint-plugin-rules/engine';
+import { CamundaAttributes } from './CamundaAttributes.js';
+
+const BINDINGS = ['latest', 'deployment', 'version', 'versionTag'];
+
+/** A `camunda:*Binding` that picks the version of the process, case or decision called, with the attributes a binding of `version` or `versionTag` needs. */
+export interface Binding {
+  binding: string;
+  version: string;
+  versionTag?: string;
+  allowed: string[];
+}
+
+/** The bindings of an element the engines read, and the form reference of a user task or start event. */
+export class C7Bindings {
+  constructor(private readonly attributes: CamundaAttributes) {}
+
+  /** Of a call activity, or of a business rule task with a decision. */
+  of(node: ModdleElement): Binding[] {
+    if (is(node, 'bpmn:CallActivity')) {
+      return [{ binding: 'calledElementBinding', version: 'calledElementVersion', versionTag: 'calledElementVersionTag', allowed: BINDINGS }, { binding: 'caseBinding', version: 'caseVersion', allowed: ['latest', 'deployment', 'version'] }];
+    }
+    return is(node, 'bpmn:BusinessRuleTask') && this.attributes.defined('decisionRef') !== undefined ? [{ binding: 'decisionRefBinding', version: 'decisionRefVersion', versionTag: 'decisionRefVersionTag', allowed: BINDINGS }] : [];
+  }
+
+  /** What is wrong with a binding: a version it needs is missing, or the value is unknown. */
+  problemOf({ binding, version, versionTag, allowed }: Binding): 'version' | 'versionTag' | 'value' | undefined {
+    const value = this.attributes.defined(binding);
+    if (value === undefined) return undefined;
+    if (value === 'version' && this.attributes.any(version) === undefined) {
+      return 'version';
+    }
+    if (value === 'versionTag' && versionTag && this.attributes.any(versionTag) === undefined) {
+      return 'versionTag';
+    }
+    return allowed.includes(value) ? undefined : 'value';
+  }
+
+  /** A `camunda:formRef` of a user task or start event. */
+  static hasFormRef(node: ModdleElement, attributes: CamundaAttributes): boolean {
+    return isAny(node, ['bpmn:UserTask', 'bpmn:StartEvent']) && attributes.defined('formRef') !== undefined;
+  }
+}
diff --git a/src/adapters/out/bpmnlint/engine/rules/c7/support/C7Diagram.ts b/src/adapters/out/bpmnlint/engine/rules/c7/support/C7Diagram.ts
new file mode 100644
index 00000000..8375db8e
--- /dev/null
+++ b/src/adapters/out/bpmnlint/engine/rules/c7/support/C7Diagram.ts
@@ -0,0 +1,59 @@
+import type { ModdleElement } from '@miragon/bpmnlint-plugin-rules/engine';
+import { CAMUNDA_URI, DiagramNamespaces } from '../../support/DiagramNamespaces.js';
+
+const OPERATON = 'operaton';
+
+/** What the engine run knows of a file that its parse for the rules no longer shows. */
+export interface C7DiagramFacts {
+  /** the file uses Operaton's namespace, which the run reads as the camunda one */
+  operaton: boolean;
+  /** the prefix the file writes camunda content with (`camunda`, `operaton`, ...) */
+  prefix: string;
+}
+
+/** An import warning of the typed parse (`unresolved reference <Error_Gone>`). */
+interface ImportWarning {
+  message?: string;
+  element?: unknown;
+  property?: string;
+  value?: unknown;
+}
+
+/**
+ * The Camunda 7 vendor of a diagram, the prefix its messages and hints write, and the id references
+ * the typed parse dropped (it only warns, so a rule reads the id the file wrote from here). The
+ * engine run records them before it lints; without that record (a rule spec), vendor and prefix
+ * are read from the namespaces: an `operaton` prefix bound to the camunda URI is Operaton's.
+ */
+export class C7Diagram {
+  private static readonly recorded = new WeakMap<object, C7DiagramFacts>();
+  private static readonly unresolvedByElement = new WeakMap<object, Map<string, string>>();
+
+  static record(definitions: ModdleElement, facts: C7DiagramFacts, warnings: readonly ImportWarning[]): void {
+    C7Diagram.recorded.set(definitions, facts);
+    for (const { message, element, property, value } of warnings) {
+      if (!message?.startsWith('unresolved reference') || !element || typeof element !== 'object' || !property) {
+        continue;
+      }
+      const references = C7Diagram.unresolvedByElement.get(element) ?? new Map<string, string>();
+      references.set(property.slice(property.indexOf(':') + 1), String(value));
+      C7Diagram.unresolvedByElement.set(element, references);
+    }
+  }
+
+  static of(node: ModdleElement): C7DiagramFacts {
+    const definitions = DiagramNamespaces.definitionsOf(node);
+    return (definitions && C7Diagram.recorded.get(definitions)) ?? C7Diagram.declared(definitions);
+  }
+
+  /** The references of `element` the parse dropped, by name (`errorRef`), with the id the file wrote. */
+  static unresolved(element: ModdleElement): ReadonlyMap<string, string> {
+    return C7Diagram.unresolvedByElement.get(element) ?? new Map();
+  }
+
+  private static declared(definitions: ModdleElement | undefined): C7DiagramFacts {
+    const prefixes = Object.entries(definitions?.$attrs ?? {}).filter(([name, uri]) => name.startsWith('xmlns:') && uri === CAMUNDA_URI).map(([name]) => name.slice('xmlns:'.length));
+    const operaton = prefixes.includes(OPERATON);
+    return { operaton, prefix: operaton ? OPERATON : (prefixes[0] ?? 'camunda') };
+  }
+}
diff --git a/src/adapters/out/bpmnlint/engine/rules/c7/support/C7EventDefinitions.ts b/src/adapters/out/bpmnlint/engine/rules/c7/support/C7EventDefinitions.ts
new file mode 100644
index 00000000..94dc3a5c
--- /dev/null
+++ b/src/adapters/out/bpmnlint/engine/rules/c7/support/C7EventDefinitions.ts
@@ -0,0 +1,66 @@
+import { is } from 'bpmnlint-utils';
+
+import type { ModdleElement } from '@miragon/bpmnlint-plugin-rules/engine';
+import { EngineScope } from '../../support/EngineScope.js';
+
+/** The order in which the engines pick the definition they act on, per event type (engine-checked, each pair in both XML orders). */
+const ACTING_ORDERS: Array<[type: string, order: string[]]> = [
+  ['bpmn:IntermediateCatchEvent', ['Timer', 'Signal', 'Message', 'Link', 'Conditional']],
+  ['bpmn:BoundaryEvent', ['Timer', 'Signal', 'Message', 'Conditional']],
+  ['bpmn:IntermediateThrowEvent', ['Signal', 'Message']],
+  ['bpmn:EndEvent', ['Message', 'Signal']],
+];
+
+/**
+ * The event definitions of one event as the Camunda 7 engines read them. Of several definitions
+ * they act on one, the first kind present in the order of the event type, and do not even parse
+ * the others. Where the order is not known, every definition counts as acted on.
+ */
+export class C7EventDefinitions {
+  constructor(private readonly event: ModdleElement) {}
+
+  all(): ModdleElement[] {
+    return this.event.eventDefinitions ?? [];
+  }
+
+  /** The definition the engines act on when the event has several, else `undefined`. */
+  acting(): ModdleElement | undefined {
+    const definitions = this.all();
+    const order = definitions.length > 1 ? this.actingOrder() : undefined;
+    if (!order) return undefined;
+    const ranks = definitions.map((definition) => order.findIndex((kind) => is(definition, `bpmn:${kind}EventDefinition`)));
+    return ranks.includes(-1) ? undefined : definitions[ranks.indexOf(Math.min(...ranks))];
+  }
+
+  /** The definitions the engines read: the acting one of several, else all. */
+  actedOn(): ModdleElement[] {
+    const acting = this.acting();
+    return acting ? [acting] : this.all();
+  }
+
+  /** The first acted-on definition of `type`. */
+  ofType(type: string): ModdleElement | undefined {
+    return this.actedOn().find((definition) => is(definition, type));
+  }
+
+  /** The acted-on definitions of `type` (`bpmn:MessageEventDefinition`) with their indexes. */
+  indexedOfType(type: string): Array<{ definition: ModdleElement; index: number }> {
+    return this.actedOn().filter((definition) => is(definition, type)).map((definition) => ({ definition, index: this.all().indexOf(definition) }));
+  }
+
+  /** The report path from the event to `definition`, followed by `rest`. */
+  pathTo(definition: ModdleElement, ...rest: string[]): (string | number)[] {
+    return ['eventDefinitions', this.all().indexOf(definition), ...rest];
+  }
+
+  private actingOrder(): string[] | undefined {
+    const event = this.event;
+    if (is(event, 'bpmn:StartEvent') && EngineScope.isEventSubProcess(event.$parent)) {
+      return ['Message', 'Signal', 'Timer', 'Conditional'];
+    }
+    if (is(event, 'bpmn:StartEvent') && is(event.$parent, 'bpmn:Process')) {
+      return ['Timer', 'Message', 'Signal', 'Conditional'];
+    }
+    return ACTING_ORDERS.find(([type]) => is(event, type))?.[1];
+  }
+}
diff --git a/src/adapters/out/bpmnlint/engine/rules/c7/support/C7EventGateway.ts b/src/adapters/out/bpmnlint/engine/rules/c7/support/C7EventGateway.ts
new file mode 100644
index 00000000..d2d4fd10
--- /dev/null
+++ b/src/adapters/out/bpmnlint/engine/rules/c7/support/C7EventGateway.ts
@@ -0,0 +1,26 @@
+import { is } from 'bpmnlint-utils';
+import type { ModdleElement } from '@miragon/bpmnlint-plugin-rules/engine';
+import { ElementKinds } from '../../support/ElementKinds.js';
+import { C7EventDefinitions } from './C7EventDefinitions.js';
+import { C7FlowGraph } from './C7FlowGraph.js';
+
+const WAITING_TRIGGERS = ['message', 'timer', 'signal', 'conditional'];
+
+/** A branch of an event-based gateway: its flow, the target, and the definitions the engines act on when the target is an intermediate catch event. */
+interface Branch {
+  flow: ModdleElement;
+  target: ModdleElement;
+  definitions: ModdleElement[] | undefined;
+}
+
+/** The branches of an event-based gateway as the engines read them. */
+export class C7EventGateway {
+  static branches(gateway: ModdleElement): Branch[] {
+    return C7FlowGraph.forElement(gateway).outgoing(gateway).filter((flow) => flow.targetRef).map((flow) => ({ flow, target: flow.targetRef, definitions: is(flow.targetRef, 'bpmn:IntermediateCatchEvent') ? new C7EventDefinitions(flow.targetRef).actedOn() : undefined }));
+  }
+
+  /** Whether a catch event with these definitions waits for one message, timer, signal or condition. */
+  static waits(definitions: ModdleElement[]): boolean {
+    return definitions.length === 1 && WAITING_TRIGGERS.includes(ElementKinds.trigger(definitions[0]));
+  }
+}
diff --git a/src/adapters/out/bpmnlint/engine/rules/c7/support/C7ExclusiveGateway.ts b/src/adapters/out/bpmnlint/engine/rules/c7/support/C7ExclusiveGateway.ts
new file mode 100644
index 00000000..c8726e0d
--- /dev/null
+++ b/src/adapters/out/bpmnlint/engine/rules/c7/support/C7ExclusiveGateway.ts
@@ -0,0 +1,18 @@
+import type { ModdleElement } from '@miragon/bpmnlint-plugin-rules/engine';
+import { C7FlowGraph } from './C7FlowGraph.js';
+
+/** The outgoing flows of an exclusive gateway as the engines read them: the default flow and the flows without condition besides it. */
+export class C7ExclusiveGateway {
+  readonly outgoing: ModdleElement[];
+  readonly defaultFlow: ModdleElement | undefined;
+
+  constructor(readonly node: ModdleElement) {
+    this.outgoing = C7FlowGraph.forElement(node).outgoing(node);
+    this.defaultFlow = node.default;
+  }
+
+  /** The flows that are neither the default flow nor have a condition. */
+  unconditioned(): ModdleElement[] {
+    return this.outgoing.filter((flow) => flow !== this.defaultFlow && !flow.conditionExpression);
+  }
+}
diff --git a/src/adapters/out/bpmnlint/engine/rules/c7/support/C7ExtraStartHint.ts b/src/adapters/out/bpmnlint/engine/rules/c7/support/C7ExtraStartHint.ts
new file mode 100644
index 00000000..4b44b277
--- /dev/null
+++ b/src/adapters/out/bpmnlint/engine/rules/c7/support/C7ExtraStartHint.ts
@@ -0,0 +1,112 @@
+import { is } from 'bpmnlint-utils';
+
+import type { ModdleElement } from '@miragon/bpmnlint-plugin-rules/engine';
+import { ElementKinds } from '../../support/ElementKinds.js';
+import { EngineScope } from '../../support/EngineScope.js';
+import { Shell } from '../../support/Shell.js';
+import { C7EventDefinitions } from './C7EventDefinitions.js';
+import { C7FlowGraph } from './C7FlowGraph.js';
+
+/** The `bpmn add eventSubProcess` option that carries a trigger's reference. */
+const TRIGGER_OPTIONS: Record<string, string> = { message: 'messageRef', signal: 'signalRef', error: 'errorRef', escalation: 'escalationRef' };
+
+/**
+ * Builds the fix advice for a second start event Camunda 7 refuses: remove it, move its branch to
+ * the first start event, or keep it with another trigger.
+ * The advice depends on what each start event reaches, as removing it can leave its branch
+ * unstarted and moving the branch can run a node twice.
+ */
+export class C7ExtraStartHint {
+  private readonly graph: C7FlowGraph;
+
+  constructor(private readonly scope: ModdleElement, private readonly first: ModdleElement, private readonly extra: ModdleElement) {
+    this.graph = C7FlowGraph.forElement(scope);
+  }
+
+  text(): string {
+    const parts = [this.removal()];
+    if (is(this.scope, 'bpmn:Process')) {
+      parts.push(`give it another trigger, which keeps it as a second way into the process: \`bpmn set <file> ${this.extra.id} trigger=message message=<Name>\``);
+    }
+    const again = EngineScope.isEventSubProcess(this.scope) ? this.ownEventSubProcess() : '';
+    return `${parts.join(', or ')}${again ? `; ${again}` : ''}.`;
+  }
+
+  private removal(): string {
+    const { id: extraId } = this.extra;
+    const { id: firstId } = this.first;
+    const reached = this.reachableFrom(this.first);
+    const flows = this.graph.outgoing(this.extra);
+    const own = flows.filter((flow) => flow.targetRef && flow.targetRef !== this.first && !reached.has(flow.targetRef));
+    const into = flows.filter((flow) => !own.includes(flow));
+    const remove = `\`bpmn remove <file> ${extraId}\``;
+    const goes = `go${into.length === 1 ? 'es' : ''}`;
+    if (!own.length) {
+      return `Remove it: ${remove}${into.length ? ` (${firstId} already leads to ${this.targets(into)}; ${this.ids(into)} ${goes} with it)` : ''}`;
+    }
+    const meet = this.meetingNodes(own, reached);
+    if (meet.length) {
+      return `Remove it: ${remove} (${this.targets(own)} is then no longer started; starting it from ${firstId} instead would run ${meet.slice(0, 3).join(', ') + (meet.length > 3 ? ', ...' : '')}, which ${firstId} reaches too, once per branch)`;
+    }
+    const moves = own.map((flow) => `\`bpmn set <file> ${flow.id} source=${firstId}\``).join(', ');
+    const notes = [this.graph.outgoing(this.first).length ? `${firstId} then starts both branches in parallel` : '', into.length ? `${this.ids(into)} into ${this.targets(into)}, which ${firstId} already reaches, ${goes} with ${extraId}` : ''].filter(Boolean);
+    return `Start its branch from ${firstId}: ${moves}, then ${remove}${notes.length ? ` (${notes.join('; ')})` : ''}`;
+  }
+
+  /** The nodes (no end events) a branch of its own runs into that `first` reaches as well. */
+  private meetingNodes(own: ModdleElement[], reached: Set<ModdleElement>): string[] {
+    const meet = new Set<string>();
+    for (const flow of own) {
+      for (const node of this.reachableFrom(flow.targetRef)) {
+        if (reached.has(node) && !is(node, 'bpmn:EndEvent') && node.id) {
+          meet.add(node.id);
+        }
+      }
+    }
+    return [...meet];
+  }
+
+  /** The flow nodes reachable from `from` (without `from`, unless a loop leads back to it). */
+  private reachableFrom(from: ModdleElement): Set<ModdleElement> {
+    const seen = new Set<ModdleElement>();
+    const queue = [from];
+    while (queue.length) {
+      for (const { targetRef: target } of this.graph.outgoing(queue.shift())) {
+        if (target && !seen.has(target)) {
+          seen.add(target);
+          queue.push(target);
+        }
+      }
+    }
+    return seen;
+  }
+
+  /** `then keep its <trigger> trigger in an event sub-process of its own: ...` */
+  private ownEventSubProcess(): string {
+    const definitions = new C7EventDefinitions(this.extra);
+    const definition = definitions.acting() ?? definitions.all()[0];
+    if (!definition) return '';
+    const trigger = ElementKinds.trigger(definition);
+    const options = [this.triggerOption(trigger, definition), this.extra.isInterrupting === false ? '--non-interrupting' : ''].filter(Boolean).join(' ');
+    const parentId = EngineScope.scopeOf(this.scope)?.id ?? '<parentId>';
+    return `then keep its ${trigger} trigger in an event sub-process of its own: \`bpmn add <file> eventSubProcess:${trigger} "<Name>" --in ${parentId}${options ? ` ${options}` : ''}\``;
+  }
+
+  private triggerOption(trigger: string, definition: ModdleElement): string {
+    const reference = TRIGGER_OPTIONS[trigger];
+    if (reference) {
+      const name = definition.get(reference)?.name;
+      return `--${trigger} ${Shell.quote(typeof name === 'string' && name.trim() ? name : '<Name>')}`;
+    }
+    if (trigger === 'timer') return '--timer <value>';
+    return trigger === 'conditional' ? `--when ${Shell.quote('${expression}')}` : '';
+  }
+
+  private ids(flows: ModdleElement[]): string {
+    return flows.map((flow) => flow.id).join(', ');
+  }
+
+  private targets(flows: ModdleElement[]): string {
+    return [...new Set(flows.map((flow) => flow.targetRef?.id).filter((id): id is string => !!id))].join(', ');
+  }
+}
diff --git a/src/adapters/out/bpmnlint/engine/rules/c7/support/C7FlowGraph.ts b/src/adapters/out/bpmnlint/engine/rules/c7/support/C7FlowGraph.ts
new file mode 100644
index 00000000..5da6ce45
--- /dev/null
+++ b/src/adapters/out/bpmnlint/engine/rules/c7/support/C7FlowGraph.ts
@@ -0,0 +1,69 @@
+import { is } from 'bpmnlint-utils';
+
+import type { ModdleElement } from '@miragon/bpmnlint-plugin-rules/engine';
+import { DiagramNamespaces } from '../../support/DiagramNamespaces.js';
+
+/**
+ * The sequence flows and boundary events of a diagram by the node they connect to, read from
+ * `sourceRef`, `targetRef` and `attachedToRef`: the `incoming` / `outgoing` mirror lists are
+ * optional in a file and a typed parse does not fill them in. Built once per diagram.
+ */
+export class C7FlowGraph {
+  private static readonly byDefinitions = new WeakMap<object, C7FlowGraph>();
+
+  private readonly incomingByNode = new Map<ModdleElement, ModdleElement[]>();
+  private readonly outgoingByNode = new Map<ModdleElement, ModdleElement[]>();
+  private readonly boundaryEventsByHost = new Map<ModdleElement, ModdleElement[]>();
+
+  private constructor(definitions: ModdleElement) {
+    for (const root of definitions?.rootElements ?? []) {
+      this.index(root);
+    }
+  }
+
+  /** The graph of the diagram `node` belongs to. */
+  static forElement(node: ModdleElement): C7FlowGraph {
+    const definitions = DiagramNamespaces.definitionsOf(node);
+    const key = definitions ?? C7FlowGraph;
+    let graph = C7FlowGraph.byDefinitions.get(key);
+    if (!graph) {
+      graph = new C7FlowGraph(definitions);
+      C7FlowGraph.byDefinitions.set(key, graph);
+    }
+    return graph;
+  }
+
+  incoming(node: ModdleElement): ModdleElement[] {
+    return this.incomingByNode.get(node) ?? [];
+  }
+
+  outgoing(node: ModdleElement): ModdleElement[] {
+    return this.outgoingByNode.get(node) ?? [];
+  }
+
+  boundaryEvents(host: ModdleElement): ModdleElement[] {
+    return this.boundaryEventsByHost.get(host) ?? [];
+  }
+
+  private index(container: ModdleElement): void {
+    for (const element of container.flowElements ?? []) {
+      if (is(element, 'bpmn:SequenceFlow')) {
+        this.add(this.outgoingByNode, element.sourceRef, element);
+        this.add(this.incomingByNode, element.targetRef, element);
+      } else if (is(element, 'bpmn:BoundaryEvent')) {
+        this.add(this.boundaryEventsByHost, element.attachedToRef, element);
+      }
+      this.index(element);
+    }
+  }
+
+  private add(byNode: Map<ModdleElement, ModdleElement[]>, node: ModdleElement, element: ModdleElement): void {
+    if (!node) return;
+    const elements = byNode.get(node);
+    if (elements) {
+      elements.push(element);
+    } else {
+      byNode.set(node, [element]);
+    }
+  }
+}
diff --git a/src/adapters/out/bpmnlint/engine/rules/c7/support/C7Host.ts b/src/adapters/out/bpmnlint/engine/rules/c7/support/C7Host.ts
new file mode 100644
index 00000000..10daa204
--- /dev/null
+++ b/src/adapters/out/bpmnlint/engine/rules/c7/support/C7Host.ts
@@ -0,0 +1,167 @@
+import { is } from 'bpmnlint-utils';
+
+import type { ModdleElement } from '@miragon/bpmnlint-plugin-rules/engine';
+import { CAMUNDA_URI, DiagramNamespaces } from '../../support/DiagramNamespaces.js';
+import { ElementKinds } from '../../support/ElementKinds.js';
+import { Shell } from '../../support/Shell.js';
+import { EngineScope } from '../../support/EngineScope.js';
+import { type ForeignAttribute, type TreeElement, VendorHost } from '../../support/VendorHost.js';
+import { C7Diagram } from './C7Diagram.js';
+
+/** The camunda types the engines read as one element, which `bpmn ext add --replace` rebuilds as a whole. */
+const SINGLE_TYPES = ['inputOutput', 'formData', 'connector', 'failedJobRetryTimeCycle', 'properties'];
+/** Attributes that pick one item of a repeatable type, in the order a selector prefers them. */
+const SELECTOR_KEYS = ['id', 'name', 'event', 'target', 'source', 'errorRef'];
+
+/** One entry of a host's extension elements: a typed camunda element, or a generic one of another namespace. */
+export interface HostExtension {
+  value: ModdleElement;
+  index: number;
+  /** `inputOutput`, `taskListener`, `taskDefinition` */
+  local: string;
+  uri: string | undefined;
+  isCamunda: boolean;
+}
+
+/**
+ * A BPMN element as the Camunda 7 checks of camunda content see it: whether they look at it at
+ * all, its camunda content, and the `bpmn` commands of the hints that rebuild or remove its
+ * extension elements and unset its attributes, through the slot of the flow node.
+ */
+export class C7Host extends VendorHost {
+  /** The prefix the file writes camunda content with. */
+  readonly prefix: string;
+
+  constructor(node: ModdleElement) {
+    super(node);
+    this.prefix = C7Diagram.of(node).prefix;
+  }
+
+  /**
+   * Whether the checks look at `node`: BPMN elements outside vendor content and DI, except a
+   * non-executable process and an ad-hoc sub-process of an executable one, with everything inside
+   * them (the engines skip them).
+   */
+  static visits(node: ModdleElement): boolean {
+    if (!String(node.$type).startsWith('bpmn:') || is(node, 'bpmn:ExtensionElements')) {
+      return false;
+    }
+    if (is(node, 'bpmn:Process')) return node.isExecutable === true;
+    return !(is(node, 'bpmn:AdHocSubProcess') && EngineScope.inExecutableProcess(node));
+  }
+
+  isDefinitions(): boolean {
+    return is(this.node, 'bpmn:Definitions');
+  }
+
+  /** `a startEvent`, `a boundaryEvent:timer`, `an event sub-process`: where the engines take no input/output mappings; undefined where they take them. */
+  unsupportedMappingHost(): string | undefined {
+    const { node } = this;
+    if (is(node, 'bpmn:SubProcess') && node.triggeredByEvent === true) {
+      return 'an event sub-process';
+    }
+    return is(node, 'bpmn:StartEvent') || is(node, 'bpmn:BoundaryEvent') || is(node, 'bpmn:Gateway') ? `a ${ElementKinds.of(node)}` : undefined;
+  }
+
+  extensions(): HostExtension[] {
+    const namespaces = DiagramNamespaces.forElement(this.node);
+    return (this.node.extensionElements?.values ?? []).map((value: ModdleElement, index: number) => {
+      const type = String(value.$type);
+      const isCamunda = !value.$descriptor?.isGeneric && type.startsWith('camunda:');
+      return { value, index, local: ElementKinds.xmlName(type.slice(type.indexOf(':') + 1)), uri: isCamunda ? CAMUNDA_URI : namespaces.uriOf(type), isCamunda };
+    });
+  }
+
+  camundaExtensions(local?: string): HostExtension[] {
+    return this.extensions().filter((extension) => extension.isCamunda && (local === undefined || extension.local === local));
+  }
+
+  /** The prefixed attributes the moddle left on the camunda elements of `extension`, depth first, each with its element. */
+  treeAttributes(extension: HostExtension): Array<TreeElement & ForeignAttribute> {
+    return this.tree(extension.value, this.prefix, this.extensionPath(extension.index)).flatMap((treeElement) => VendorHost.foreignAttributesOf(treeElement.element).map((attribute) => ({ ...treeElement, ...attribute })));
+  }
+
+  /** `camunda:inputOutput`, with the file's prefix. */
+  typeName(local: string): string {
+    return `${this.prefix}:${local}`;
+  }
+
+  /** `` `bpmn set <file> X camunda:asignee=` `` for the attribute `key` as the file spells it; undefined without an address. */
+  unset(key: string): string | undefined {
+    return this.address?.unset(key);
+  }
+
+  /**
+   * How to rebuild one top-level extension element. A single-instance type is replaced as a whole
+   * (`--replace`); a repeatable one is removed by its own selector and added again, as `--replace`
+   * would remove its siblings. `fix` puts placeholders in for attributes.
+   */
+  rebuild(extension: HostExtension, fix: Record<string, string> = {}): string {
+    if (!this.address) return 'Fix it in the XML.';
+    const type = this.typeName(extension.local);
+    if (SINGLE_TYPES.includes(extension.local)) {
+      return this.address.rebuild(type, type);
+    }
+    const flat = C7Host.extAddArguments(extension.value, type, fix);
+    const again = flat ? this.address.extAdd(flat) : `${this.address.extAdd(`${type} --xml '<${type} ...>...</${type}>'`)} (\`bpmn ext list <file> ${this.address.id} --json\` shows it)`;
+    return `Replace just this one (--replace would remove every ${type}): ${this.address.extRemove(this.selector(extension))}, then ${again}.`;
+  }
+
+  /** `ext remove` selector of a top-level extension element: a unique attribute, else its index among its type. */
+  selector(extension: HostExtension): string {
+    const type = this.typeName(extension.local);
+    const siblings = this.extensions().filter((sibling) => sibling.value.$type === extension.value.$type).map((sibling) => sibling.value);
+    for (const key of SELECTOR_KEYS) {
+      const value = C7Host.attributeValue(extension.value, key);
+      if (value !== undefined && value !== '' && siblings.filter((sibling) => C7Host.attributeValue(sibling, key) === value).length === 1) {
+        return `${type}[${key}=${/^[\w.:-]+$/.test(value) ? value : `"${value.replace(/"/g, '\\"')}"`}]`;
+      }
+    }
+    return `${type}[${Math.max(0, siblings.indexOf(extension.value))}]`;
+  }
+
+  /** `bpmn ext add` arguments that re-create a flat camunda element (attributes and body), or undefined when it has child elements; `fix` replaces attribute values (placeholders). */
+  static extAddArguments(element: ModdleElement, type: string, fix: Record<string, string> = {}): string | undefined {
+    const entries = C7Host.attributesOf(element);
+    if (!entries) return undefined;
+    for (const key of Object.keys(fix)) {
+      if (!entries.some(([existing]) => existing === key)) {
+        entries.push([key, fix[key] ?? '']);
+      }
+    }
+    const bodyProperty = (element.$descriptor?.properties ?? []).find((property: { isBody?: boolean }) => property.isBody);
+    const body = bodyProperty ? element[bodyProperty.name] : undefined;
+    return [type, ...entries.map(([key, value]) => Shell.quote(`${key}=${fix[key] ?? value}`)), ...(body !== undefined ? ['--body', Shell.quote(String(body))] : [])].join(' ');
+  }
+
+  /** The attributes of a typed camunda element in file order, an unresolved reference where the descriptor puts it; undefined with child elements. */
+  private static attributesOf(element: ModdleElement): Array<[string, string]> | undefined {
+    const properties: Array<{ name: string; isAttr?: boolean; isBody?: boolean }> = element.$descriptor?.properties ?? [];
+    const entries: Array<[string, string]> = [];
+    for (const key of Object.keys(element)) {
+      const property = properties.find((candidate) => candidate.name === key);
+      const value = element[key];
+      if (key.startsWith('$') || property?.isBody || (Array.isArray(value) && value.length === 0)) {
+        continue;
+      }
+      if (property && !property.isAttr) return undefined;
+      entries.push([key, value && typeof value === 'object' ? String(value.id) : String(value)]);
+    }
+    const rank = (name: string) => properties.findIndex((property) => property.name === name);
+    for (const [name, id] of C7Diagram.unresolved(element)) {
+      const before = entries.findIndex(([key]) => rank(key) > rank(name));
+      entries.splice(before === -1 ? entries.length : before, 0, [name, id]);
+    }
+    for (const [key, value] of Object.entries(element.$attrs ?? {})) {
+      if (!key.startsWith('xmlns')) entries.push([key, String(value)]);
+    }
+    return entries;
+  }
+
+  /** An attribute as the file writes it: a typed property (a reference as the id it names, also one the parse could not resolve), else one the moddle left in `$attrs`. */
+  private static attributeValue(element: ModdleElement, name: string): string | undefined {
+    const value = Object.prototype.hasOwnProperty.call(element, name) ? element[name] : (element.$attrs?.[name] ?? C7Diagram.unresolved(element).get(name));
+    if (value === undefined || value === null) return undefined;
+    return typeof value === 'object' ? value.id : String(value);
+  }
+}
diff --git a/src/adapters/out/bpmnlint/engine/rules/c7/support/C7Links.ts b/src/adapters/out/bpmnlint/engine/rules/c7/support/C7Links.ts
new file mode 100644
index 00000000..efae8b12
--- /dev/null
+++ b/src/adapters/out/bpmnlint/engine/rules/c7/support/C7Links.ts
@@ -0,0 +1,16 @@
+import type { ModdleElement } from '@miragon/bpmnlint-plugin-rules/engine';
+import { EngineScope } from '../../support/EngineScope.js';
+import { LinkEvents } from '../../support/LinkEvents.js';
+import { C7EventDefinitions } from './C7EventDefinitions.js';
+
+/** The link events of a process the engines run, by the name of the link definition they act on. */
+export class C7Links {
+  static of(process: ModdleElement): LinkEvents {
+    return new LinkEvents(process, (node) => (EngineScope.C7.contains(node) ? (new C7EventDefinitions(node).ofType('bpmn:LinkEventDefinition')?.name ?? undefined) : undefined));
+  }
+
+  static namePath(event: ModdleElement): (string | number)[] {
+    const definitions = new C7EventDefinitions(event);
+    return definitions.pathTo(definitions.ofType('bpmn:LinkEventDefinition'), 'name');
+  }
+}
diff --git a/src/adapters/out/bpmnlint/engine/rules/c7/support/C7MultiInstanceLoop.ts b/src/adapters/out/bpmnlint/engine/rules/c7/support/C7MultiInstanceLoop.ts
new file mode 100644
index 00000000..fe3bb788
--- /dev/null
+++ b/src/adapters/out/bpmnlint/engine/rules/c7/support/C7MultiInstanceLoop.ts
@@ -0,0 +1,27 @@
+import { is } from 'bpmnlint-utils';
+import type { ModdleElement } from '@miragon/bpmnlint-plugin-rules/engine';
+import { C7Diagram } from './C7Diagram.js';
+import { CamundaAttributes } from './CamundaAttributes.js';
+
+/** The multi-instance loop of an activity and what it iterates over. */
+export class C7MultiInstanceLoop {
+  readonly attributes: CamundaAttributes;
+
+  private constructor(readonly loop: ModdleElement) {
+    this.attributes = new CamundaAttributes(loop);
+  }
+
+  static of(activity: ModdleElement): C7MultiInstanceLoop | undefined {
+    const loop = is(activity, 'bpmn:Activity') ? activity.get('loopCharacteristics') : undefined;
+    return loop && is(loop, 'bpmn:MultiInstanceLoopCharacteristics') ? new C7MultiInstanceLoop(loop) : undefined;
+  }
+
+  get cardinality(): ModdleElement | undefined {
+    return this.loop.get('loopCardinality');
+  }
+
+  /** A camunda:collection, or a `loopDataInputRef`, which the engines read as a variable name, also one that is no id of the file. */
+  get hasCollection(): boolean {
+    return this.attributes.defined('collection') !== undefined || !!this.loop.get('loopDataInputRef') || C7Diagram.unresolved(this.loop).has('loopDataInputRef');
+  }
+}
diff --git a/src/adapters/out/bpmnlint/engine/rules/c7/support/CamundaAttributes.ts b/src/adapters/out/bpmnlint/engine/rules/c7/support/CamundaAttributes.ts
new file mode 100644
index 00000000..50defff5
--- /dev/null
+++ b/src/adapters/out/bpmnlint/engine/rules/c7/support/CamundaAttributes.ts
@@ -0,0 +1,21 @@
+import type { ModdleElement } from '@miragon/bpmnlint-plugin-rules/engine';
+import { CAMUNDA_URI, DiagramNamespaces } from '../../support/DiagramNamespaces.js';
+
+/** Reads the `camunda:*` attributes of an element, whatever prefix the file spells. */
+export class CamundaAttributes {
+  constructor(private readonly node: ModdleElement) {}
+
+  /** The value of `camunda:<local>` where the element's type defines it, else undefined. */
+  defined(local: string): string | undefined {
+    return this.node?.$descriptor?.propertiesByName?.[`camunda:${local}`] ? this.node.get(`camunda:${local}`) : undefined;
+  }
+
+  /** The value of `camunda:<local>`, also where the element's type does not define it. */
+  any(local: string): string | undefined {
+    const defined = this.defined(local);
+    if (defined !== undefined) return defined;
+    const namespaces = DiagramNamespaces.forElement(this.node);
+    const key = Object.keys(this.node?.$attrs ?? {}).find((name) => name.slice(name.indexOf(':') + 1) === local && namespaces.uriOf(name) === CAMUNDA_URI);
+    return key === undefined ? undefined : String(this.node.$attrs[key]);
+  }
+}
diff --git a/src/adapters/out/bpmnlint/engine/rules/c7/support/CamundaPlacement.ts b/src/adapters/out/bpmnlint/engine/rules/c7/support/CamundaPlacement.ts
new file mode 100644
index 00000000..05f6da2b
--- /dev/null
+++ b/src/adapters/out/bpmnlint/engine/rules/c7/support/CamundaPlacement.ts
@@ -0,0 +1,77 @@
+import { is } from 'bpmnlint-utils';
+
+import type { ModdleElement } from '@miragon/bpmnlint-plugin-rules/engine';
+import { ElementKinds } from '../../support/ElementKinds.js';
+import { RuleKit } from '../../RuleKit.js';
+import type { C7Host, HostExtension } from './C7Host.js';
+
+/** Hosts the descriptor misses but the engines read. */
+const EXTRA_HOSTS: Record<string, string[]> = {
+  potentialStarter: ['bpmn:Process'],
+  errorEventDefinition: ['bpmn:ServiceTask', 'bpmn:SendTask', 'bpmn:BusinessRuleTask', 'bpmn:MessageEventDefinition', 'bpmn:IntermediateThrowEvent', 'bpmn:EndEvent'],
+};
+
+/**
+ * Content of an event definition the engines read on one side only (the descriptor allows it on
+ * both): delegate settings on message throw events, async and camunda:in on signal throw events,
+ * the code variables on error and escalation catch events.
+ */
+const SIDE_RULES: Array<{ definition: string; side: 'throw' | 'catch'; attributes: string[]; extensions: string[]; where: string }> = [
+  { definition: 'bpmn:MessageEventDefinition', side: 'throw', attributes: ['class', 'delegateExpression', 'expression', 'resultVariable', 'type', 'topic', 'taskPriority'], extensions: ['field', 'connector'], where: 'message throw and end events' },
+  { definition: 'bpmn:SignalEventDefinition', side: 'throw', attributes: ['async'], extensions: ['in'], where: 'signal throw and end events' },
+  { definition: 'bpmn:ErrorEventDefinition', side: 'catch', attributes: ['errorCodeVariable', 'errorMessageVariable'], extensions: [], where: 'error boundary and error start events' },
+  { definition: 'bpmn:EscalationEventDefinition', side: 'catch', attributes: ['escalationCodeVariable'], extensions: [], where: 'escalation boundary and escalation start events' },
+];
+
+/** Why the engines ignore an extension element: the side of the event or the host (read on `readOn` only), or loose instead of in its `containers`. */
+export type Misplacement = { kind: 'side' | 'host'; readOn: string } | { kind: 'loose'; containers: string };
+
+/** Whether the Camunda 7 engines read camunda content where a host carries it. */
+export class CamundaPlacement {
+  constructor(private readonly host: C7Host) {}
+
+  /** The hosts the engines read the extension element `local` on, the descriptor's and the extra ones. */
+  static hostsOf(local: string): string[] {
+    return [...RuleKit.kit.CAMUNDA.allowedParents(local), ...(EXTRA_HOSTS[local] ?? [])];
+  }
+
+  /** Whether the engines read the extension element `local` directly in the extension elements of `host`. */
+  static isReadOn(local: string, host: ModdleElement): boolean {
+    return CamundaPlacement.hostsOf(local).some((allowed) => allowed === '*' || (allowed.startsWith('bpmn:') && host.$instanceOf(allowed)));
+  }
+
+  /** The camunda attributes the descriptor allows on the host's event definition but the engines read on the other side only. */
+  static sideAttributes(): string[] {
+    return SIDE_RULES.flatMap((rule) => rule.attributes);
+  }
+
+  /** Where the engines read the attribute or extension element `local` instead, when the host is an event definition on the side of its event that ignores it; undefined otherwise. */
+  wrongSide(local: string, kind: 'attributes' | 'extensions'): string | undefined {
+    const { node, owner } = this.host;
+    if (!owner || !(owner.eventDefinitions ?? []).includes(node)) return undefined;
+    const side = is(owner, 'bpmn:CatchEvent') ? 'catch' : 'throw';
+    const rule = SIDE_RULES.find((sideRule) => is(node, sideRule.definition) && sideRule[kind].includes(local));
+    return rule && rule.side !== side ? rule.where : undefined;
+  }
+
+  /**
+   * Why and how the engines ignore the camunda extension element where it sits: on the side of an
+   * event that ignores it, loose instead of inside its container, or on a host that does not read
+   * it; undefined when they read it.
+   */
+  misplacementOf({ local }: HostExtension): Misplacement | undefined {
+    const side = this.wrongSide(local, 'extensions');
+    if (side) return { kind: 'side', readOn: side };
+    if (CamundaPlacement.isReadOn(local, this.host.node)) return undefined;
+    const containers = RuleKit.kit.CAMUNDA.allowedParents(local).length === 0 ? RuleKit.kit.CAMUNDA.containersOf(local) : [];
+    if (containers.length) {
+      return { kind: 'loose', containers: containers.map((container) => container.replace(/^camunda:/, `${this.host.prefix}:`)).join(' / ') };
+    }
+    return { kind: 'host', readOn: ElementKinds.list(CamundaPlacement.hostsOf(local), 4) };
+  }
+
+  /** The camunda extension elements the engines read where they sit. */
+  readExtensions(): HostExtension[] {
+    return this.host.camundaExtensions().filter((extension) => !this.misplacementOf(extension));
+  }
+}
diff --git a/src/adapters/out/bpmnlint/engine/rules/c7/support/ImplementationHost.ts b/src/adapters/out/bpmnlint/engine/rules/c7/support/ImplementationHost.ts
new file mode 100644
index 00000000..72e19fb0
--- /dev/null
+++ b/src/adapters/out/bpmnlint/engine/rules/c7/support/ImplementationHost.ts
@@ -0,0 +1,105 @@
+import { is, isAny } from 'bpmnlint-utils';
+
+import type { ModdleElement, ReportPath } from '@miragon/bpmnlint-plugin-rules/engine';
+import { ElementKinds } from '../../support/ElementKinds.js';
+import { SetCommand } from '../../support/SetCommand.js';
+import { Values } from '../../support/Values.js';
+import { C7Diagram } from './C7Diagram.js';
+import { C7EventDefinitions } from './C7EventDefinitions.js';
+import { CamundaAttributes } from './CamundaAttributes.js';
+
+const SERVICE_LIKE = ['bpmn:ServiceTask', 'bpmn:SendTask', 'bpmn:BusinessRuleTask'];
+const THROW_EVENTS = ['bpmn:IntermediateThrowEvent', 'bpmn:EndEvent'];
+/** The attributes that implement a host. */
+export const IMPLEMENTATIONS = ['class', 'delegateExpression', 'expression', 'type'];
+
+/**
+ * Where Camunda 7 reads how work is implemented: a service, send or business rule task, or the
+ * message definition of a message throw or end event. Reports go on the task or the event; `path`
+ * leads from there to the host.
+ */
+export class ImplementationHost {
+  readonly attributes: CamundaAttributes;
+  /** The prefix the file writes camunda content with (`operaton` in an Operaton file). */
+  readonly prefix: string;
+  /** `bpmn set` on the host: the task, or the message definition through its event. */
+  readonly command: SetCommand;
+
+  private constructor(
+    /** The task, or the event of a message definition. */
+    readonly reported: ModdleElement,
+    /** The task, or the message definition. */
+    readonly element: ModdleElement,
+    readonly path: ReportPath,
+  ) {
+    this.attributes = new CamundaAttributes(element);
+    this.prefix = C7Diagram.of(reported).prefix;
+    this.command = typeof path[1] === 'number' ? SetCommand.forDefinition(reported, path[1]) : new SetCommand(reported.id);
+  }
+
+  /** The implementation hosts of `node`: none, the task itself, or its read message definitions. */
+  static forElement(node: ModdleElement): ImplementationHost[] {
+    if (isAny(node, SERVICE_LIKE)) return [new ImplementationHost(node, node, [])];
+    if (!isAny(node, THROW_EVENTS)) return [];
+    return new C7EventDefinitions(node).indexedOfType('bpmn:MessageEventDefinition').map(({ definition, index }) => new ImplementationHost(node, definition, ['eventDefinitions', index]));
+  }
+
+  /** `serviceTask X`, or `endEvent X` for a message definition. */
+  get label(): string {
+    return ElementKinds.describe(this.reported);
+  }
+
+  get isEvent(): boolean {
+    return this.reported !== this.element;
+  }
+
+  get readsDecisionRef(): boolean {
+    return is(this.element, 'bpmn:BusinessRuleTask');
+  }
+
+  get type(): string | undefined {
+    return this.attributes.defined('type');
+  }
+
+  get isExternal(): boolean {
+    return this.type?.toLowerCase() === 'external';
+  }
+
+  get isShell(): boolean {
+    return this.type?.toLowerCase() === 'shell';
+  }
+
+  /** A camunda:type other than external or shell, which the engines refuse before they look at anything else of the host. */
+  get hasUnsupportedType(): boolean {
+    return this.type !== undefined && !this.isExternal && !this.isShell;
+  }
+
+  /** Whether the engines find an implementation: a delegate, an external or shell task, a connector or a decision. */
+  get hasImplementation(): boolean {
+    return ['class', 'delegateExpression', 'expression'].some((local) => Values.nonEmpty(this.attributes.defined(local))) || this.isExternal || this.isShell || this.hasConnector() || (this.readsDecisionRef && this.attributes.defined('decisionRef') !== undefined);
+  }
+
+  /** The path from the reported element to `property` of the host. */
+  pathTo(...property: ReportPath): ReportPath {
+    return [...this.path, ...property];
+  }
+
+  /** `bpmn ext add` of a camunda:field, which replaces the field of that name; `otherwise` without an id to address. */
+  fieldHint(args: string, otherwise: string, after = '.'): string {
+    const target = this.command.extTarget(`${this.prefix}:field`);
+    return target ? `\`bpmn ext add <file> ${target} ${args}\`${after}` : otherwise;
+  }
+
+  /** The `camunda:Field` extension elements of the host, with their index in `values`. */
+  fields(): Array<{ field: ModdleElement; index: number }> {
+    return this.extensionValues(this.element).map((field, index) => ({ field, index })).filter(({ field }) => is(field, 'camunda:Field'));
+  }
+
+  private hasConnector(): boolean {
+    return (this.isEvent ? [this.element, this.reported] : [this.element]).some((host) => this.extensionValues(host).some((value) => is(value, 'camunda:Connector')));
+  }
+
+  private extensionValues(host: ModdleElement): ModdleElement[] {
+    return host.get('extensionElements')?.get('values') ?? [];
+  }
+}
diff --git a/src/adapters/out/bpmnlint/engine/rules/c8/C8AdHocSubProcessNoStartOrEndEventRule.ts b/src/adapters/out/bpmnlint/engine/rules/c8/C8AdHocSubProcessNoStartOrEndEventRule.ts
new file mode 100644
index 00000000..511137d3
--- /dev/null
+++ b/src/adapters/out/bpmnlint/engine/rules/c8/C8AdHocSubProcessNoStartOrEndEventRule.ts
@@ -0,0 +1,29 @@
+import { is, isAny } from 'bpmnlint-utils';
+import { C8Rule, defineRule, ERROR_TYPES, type ModdleElement } from '../CamundaRule.js';
+import { EngineScope } from '../support/EngineScope.js';
+
+/**
+ * A start or end event in an ad-hoc sub-process.
+ * Camunda 8 activates the content of an ad-hoc sub-process without flow from a start event to an
+ * end event and refuses the file. The report goes on the sub-process, with the path to the event
+ * to remove.
+ *
+ * @example an ad-hoc sub-process with a start event
+ * <bpmn:adHocSubProcess id="Research">
+ *   <bpmn:startEvent id="Begin" />  <!-- not allowed here -->
+ * </bpmn:adHocSubProcess>
+ */
+class C8AdHocSubProcessNoStartOrEndEventRule extends C8Rule {
+  protected visit(subProcess: ModdleElement): void {
+    if (!is(subProcess, 'bpmn:AdHocSubProcess') || !EngineScope.C8.contains(subProcess)) {
+      return;
+    }
+    (subProcess.get('flowElements') as ModdleElement[]).forEach((child, index) => {
+      if (isAny(child, ['bpmn:StartEvent', 'bpmn:EndEvent'])) {
+        this.report(subProcess, `Ad-hoc sub-process ${subProcess.id} contains the ${is(child, 'bpmn:StartEvent') ? 'start' : 'end'} event ${child.id}; Camunda 8 refuses start and end events in ad-hoc sub-processes`, { path: ['flowElements', index], type: ERROR_TYPES.ELEMENT_TYPE_NOT_ALLOWED, node: child, hint: `\`bpmn remove <file> ${child.id}\`.` });
+      }
+    });
+  }
+}
+
+export default defineRule({ ruleName: 'c8-ad-hoc-sub-process-no-start-or-end-event', code: 'W_C8_DEPLOY_AD_HOC_SUBPROCESS', impact: 'deploy' }, C8AdHocSubProcessNoStartOrEndEventRule);
diff --git a/src/adapters/out/bpmnlint/engine/rules/c8/C8BindingRule.ts b/src/adapters/out/bpmnlint/engine/rules/c8/C8BindingRule.ts
new file mode 100644
index 00000000..3c7b31c8
--- /dev/null
+++ b/src/adapters/out/bpmnlint/engine/rules/c8/C8BindingRule.ts
@@ -0,0 +1,60 @@
+import { is } from 'bpmnlint-utils';
+import type { ModdleElement, ReportPath } from '../CamundaRule.js';
+import { C8HostRule } from './C8HostRule.js';
+import type { C8Host, ZeebeValue } from './support/C8Host.js';
+
+/** The binding types Camunda 8 accepts. */
+export const BINDING_TYPES = ['deployment', 'latest', 'versionTag'];
+/** The extension element camunda-compat's `version-tag` checks on each host: the first of its type. */
+const VERSION_TAG_CHECKED_BY_COMPAT: Record<string, string> = { 'zeebe:calledDecision': 'bpmn:BusinessRuleTask', 'zeebe:calledElement': 'bpmn:CallActivity', 'zeebe:formDefinition': 'bpmn:UserTask' };
+
+/** An element with a binding: a called decision, element or form, or one linked resource. */
+export interface BindingSite {
+  element: ModdleElement;
+  subject: string;
+  path: (property: string) => ReportPath;
+  hint: (fix: Record<string, string>) => string;
+  /** whether camunda-compat reports its empty version tag already */
+  checkedByCompat: boolean;
+  /** whether it is a linked resource */
+  linked: boolean;
+}
+
+/**
+ * The bindings of the zeebe elements an element reads, for the rules on them
+ * (`C8LinkedResourceNeedsTypeRule`, `C8BindingTypeKnownRule`, `C8VersionTagBindingNeedsTagRule`):
+ * zeebe:calledDecision, zeebe:calledElement, zeebe:formDefinition and each resource of
+ * zeebe:linkedResources.
+ * Camunda 8 resolves the resource by its binding at deploy and refuses the file when it cannot.
+ *
+ * @example a versionTag binding without version tag
+ * <zeebe:calledElement processId="Billing" bindingType="versionTag" />  <!-- versionTag="v2" -->
+ */
+export abstract class C8BindingRule extends C8HostRule {
+  protected checkHost(host: C8Host): void {
+    for (const zeebeValue of host.zeebeValues().filter(({ placement }) => placement === 'read')) {
+      const { value, index, type } = zeebeValue;
+      if (type.name in VERSION_TAG_CHECKED_BY_COMPAT) {
+        this.checkBinding(host, { element: value, subject: `${host.spell(type.name)} of ${host.describe()}`, path: (property) => host.extensionPath(index, property), hint: (fix) => host.hint()?.replace(value, fix) ?? 'Fix it in the XML.', checkedByCompat: this.isCheckedByCompat(host, value, type.name), linked: false });
+      } else if (type.name === 'zeebe:linkedResources') {
+        this.checkLinkedResources(host, zeebeValue);
+      }
+    }
+  }
+
+  private checkLinkedResources(host: C8Host, { value, index }: ZeebeValue): void {
+    const rebuild = this.rebuildHint(host, value);
+    (value.values ?? []).forEach((resource: ModdleElement, resourceIndex: number) => {
+      const subject = `Linked resource ${resource.linkName ?? resourceIndex + 1} of ${host.describe()}`;
+      this.checkBinding(host, { element: resource, subject, path: (property) => host.extensionPath(index, 'values', resourceIndex, property), hint: () => rebuild, checkedByCompat: false, linked: true });
+    });
+  }
+
+  protected abstract checkBinding(host: C8Host, site: BindingSite): void;
+
+  /** camunda-compat reports an empty version tag of the first such element on its host. */
+  private isCheckedByCompat(host: C8Host, value: ModdleElement, name: string): boolean {
+    const versionTag: string | undefined = value.versionTag;
+    return host.zeebeValues().find((zeebeValue) => zeebeValue.type.name === name)?.value === value && is(host.node, VERSION_TAG_CHECKED_BY_COMPAT[name] ?? '') && (versionTag === undefined || versionTag === '');
+  }
+}
diff --git a/src/adapters/out/bpmnlint/engine/rules/c8/C8BindingTypeKnownRule.ts b/src/adapters/out/bpmnlint/engine/rules/c8/C8BindingTypeKnownRule.ts
new file mode 100644
index 00000000..7411227a
--- /dev/null
+++ b/src/adapters/out/bpmnlint/engine/rules/c8/C8BindingTypeKnownRule.ts
@@ -0,0 +1,21 @@
+import { defineRule, ERROR_TYPES } from '../CamundaRule.js';
+import { BINDING_TYPES, type BindingSite, C8BindingRule } from './C8BindingRule.js';
+import type { C8Host } from './support/C8Host.js';
+
+/**
+ * A binding type other than deployment, latest or versionTag, of a called decision, element or
+ * form, or of a linked resource.
+ * Camunda 8 cannot resolve the resource and refuses the file.
+ *
+ * @example an unknown binding type
+ * <zeebe:calledElement processId="Billing" bindingType="newest" />  <!-- latest -->
+ */
+class C8BindingTypeKnownRule extends C8BindingRule {
+  protected checkBinding(host: C8Host, { element, subject, path, hint }: BindingSite): void {
+    const bindingType: string | undefined = element.bindingType;
+    if (bindingType === undefined || BINDING_TYPES.includes(bindingType)) return;
+    this.reportOn(host, `${subject} has bindingType="${bindingType}"; Camunda 8 accepts ${BINDING_TYPES.join(', ')} only and refuses the file`, { path: path('bindingType'), type: ERROR_TYPES.PROPERTY_VALUE_NOT_ALLOWED, node: element, property: 'bindingType', hint: hint({ bindingType: 'latest' }) });
+  }
+}
+
+export default defineRule({ ruleName: 'c8-binding-type-known', code: 'W_C8_DEPLOY_EXTENSION', impact: 'deploy' }, C8BindingTypeKnownRule);
diff --git a/src/adapters/out/bpmnlint/engine/rules/c8/C8BpmnAttributeKnownRule.ts b/src/adapters/out/bpmnlint/engine/rules/c8/C8BpmnAttributeKnownRule.ts
new file mode 100644
index 00000000..104be84e
--- /dev/null
+++ b/src/adapters/out/bpmnlint/engine/rules/c8/C8BpmnAttributeKnownRule.ts
@@ -0,0 +1,19 @@
+import type { Engine } from '@miragon/bpmnlint-plugin-rules/engine';
+import { defineRule } from '../CamundaRule.js';
+import { UnprefixedAttributesRule } from '../UnprefixedAttributesRule.js';
+
+/**
+ * Attributes without a namespace prefix that the BPMN schema does not define.
+ * Camunda 8 validates the file against the schema and refuses it. The typed parse reads some of
+ * them as the zeebe attribute of that name, so the rule reads the attributes as the file writes
+ * them.
+ * Any element of the file is checked, the diagram's included.
+ *
+ * @example a service task with an unprefixed retries
+ * <bpmn:serviceTask id="Charge" retries="3" />  <!-- zeebe:taskDefinition retries -->
+ */
+class C8BpmnAttributeKnownRule extends UnprefixedAttributesRule {
+  protected readonly engine: Engine = 'c8';
+}
+
+export default defineRule({ ruleName: 'c8-bpmn-attribute-known', code: 'W_C8_DEPLOY_SCHEMA', impact: 'deploy' }, C8BpmnAttributeKnownRule);
diff --git a/src/adapters/out/bpmnlint/engine/rules/c8/C8CompensationBoundaryNeedsAssociationRule.ts b/src/adapters/out/bpmnlint/engine/rules/c8/C8CompensationBoundaryNeedsAssociationRule.ts
new file mode 100644
index 00000000..4287434a
--- /dev/null
+++ b/src/adapters/out/bpmnlint/engine/rules/c8/C8CompensationBoundaryNeedsAssociationRule.ts
@@ -0,0 +1,20 @@
+import { defineRule, ERROR_TYPES, type ModdleElement } from '../CamundaRule.js';
+import { C8CompensationBoundaryRule } from './C8CompensationBoundaryRule.js';
+
+/**
+ * A compensation boundary event without an association to its compensation handler.
+ * Camunda 8 has no handler to call and refuses the file.
+ *
+ * @example a compensation boundary event without handler
+ * <bpmn:boundaryEvent id="UndoCharge" attachedToRef="Charge">
+ *   <bpmn:compensateEventDefinition />  <!-- no bpmn:association to a handler -->
+ * </bpmn:boundaryEvent>
+ */
+class C8CompensationBoundaryNeedsAssociationRule extends C8CompensationBoundaryRule {
+  protected checkBoundary(event: ModdleElement, associated: boolean): void {
+    if (associated) return;
+    this.report(event, `Compensation boundary event ${event.id} has no association to a compensation handler; Camunda 8 refuses the file`, { path: null, type: ERROR_TYPES.CHILD_ELEMENT_OF_TYPE_REQUIRED, requiredType: 'bpmn:Association', hint: `Connect it to its handler (an activity with isForCompensation=true): \`bpmn connect <file> ${event.id} <handlerId>\`.` });
+  }
+}
+
+export default defineRule({ ruleName: 'c8-compensation-boundary-needs-association', code: 'W_C8_DEPLOY_EVENT_DEFINITION', impact: 'deploy' }, C8CompensationBoundaryNeedsAssociationRule);
diff --git a/src/adapters/out/bpmnlint/engine/rules/c8/C8CompensationBoundaryNoOutgoingFlowRule.ts b/src/adapters/out/bpmnlint/engine/rules/c8/C8CompensationBoundaryNoOutgoingFlowRule.ts
new file mode 100644
index 00000000..aaeae081
--- /dev/null
+++ b/src/adapters/out/bpmnlint/engine/rules/c8/C8CompensationBoundaryNoOutgoingFlowRule.ts
@@ -0,0 +1,24 @@
+import { defineRule, ERROR_TYPES, type ModdleElement } from '../CamundaRule.js';
+import { C8CompensationBoundaryRule } from './C8CompensationBoundaryRule.js';
+import { FlowIndex } from './support/FlowIndex.js';
+
+/**
+ * A compensation boundary event, associated to its handler, with an outgoing sequence flow.
+ * Camunda 8 reaches the handler through the association only and refuses the file. One without
+ * association is the association rule's.
+ *
+ * @example a compensation boundary event that continues with a flow
+ * <bpmn:boundaryEvent id="UndoCharge" attachedToRef="Charge"><bpmn:compensateEventDefinition /></bpmn:boundaryEvent>
+ * <bpmn:sequenceFlow sourceRef="UndoCharge" targetRef="Refund" />  <!-- use the association -->
+ */
+class C8CompensationBoundaryNoOutgoingFlowRule extends C8CompensationBoundaryRule {
+  private readonly flows = new FlowIndex();
+
+  protected checkBoundary(event: ModdleElement, associated: boolean): void {
+    const [outgoing] = associated ? this.flows.outgoing(event) : [];
+    if (!outgoing) return;
+    this.report(event, `Compensation boundary event ${event.id} has an outgoing sequence flow; Camunda 8 refuses the file`, { path: ['outgoing'], type: ERROR_TYPES.PROPERTY_NOT_ALLOWED, property: 'outgoing', hint: `Remove the flow (\`bpmn remove <file> ${outgoing.id} --no-bridge\`) and connect the handler instead: \`bpmn connect <file> ${event.id} <handlerId>\`.` });
+  }
+}
+
+export default defineRule({ ruleName: 'c8-compensation-boundary-no-outgoing-flow', code: 'W_C8_DEPLOY_EVENT_DEFINITION', impact: 'deploy' }, C8CompensationBoundaryNoOutgoingFlowRule);
diff --git a/src/adapters/out/bpmnlint/engine/rules/c8/C8CompensationBoundaryRule.ts b/src/adapters/out/bpmnlint/engine/rules/c8/C8CompensationBoundaryRule.ts
new file mode 100644
index 00000000..5bc5c8c9
--- /dev/null
+++ b/src/adapters/out/bpmnlint/engine/rules/c8/C8CompensationBoundaryRule.ts
@@ -0,0 +1,27 @@
+import { is } from 'bpmnlint-utils';
+import { C8Rule, type ModdleElement } from '../CamundaRule.js';
+import { EngineScope } from '../support/EngineScope.js';
+import { C8EventDefinitions } from './support/C8EventDefinitions.js';
+
+/**
+ * The compensation boundary events Camunda 8 runs, with whether an association connects them to
+ * their handler, for the rules on how they reach it (`C8CompensationBoundaryNeedsAssociationRule`,
+ * `C8CompensationBoundaryNoOutgoingFlowRule`).
+ * Camunda 8 calls the handler through the association and refuses a boundary event without one or
+ * with a sequence flow.
+ *
+ * @example a compensation boundary event with its handler
+ * <bpmn:boundaryEvent id="UndoCharge" attachedToRef="Charge"><bpmn:compensateEventDefinition /></bpmn:boundaryEvent>
+ * <bpmn:association sourceRef="UndoCharge" targetRef="Refund" />
+ */
+export abstract class C8CompensationBoundaryRule extends C8Rule {
+  protected visit(event: ModdleElement): void {
+    if (!is(event, 'bpmn:BoundaryEvent') || !EngineScope.C8.contains(event)) return;
+    const definition = C8EventDefinitions.definitionOf(event);
+    if (!definition || !is(definition, 'bpmn:CompensateEventDefinition')) return;
+    const associated = (EngineScope.scopeOf(event)?.get('artifacts') ?? []).some((artifact: ModdleElement) => is(artifact, 'bpmn:Association') && artifact.get('sourceRef') === event);
+    this.checkBoundary(event, associated);
+  }
+
+  protected abstract checkBoundary(event: ModdleElement, associated: boolean): void;
+}
diff --git a/src/adapters/out/bpmnlint/engine/rules/c8/C8CompensationNamesOwnActivityRule.ts b/src/adapters/out/bpmnlint/engine/rules/c8/C8CompensationNamesOwnActivityRule.ts
new file mode 100644
index 00000000..57a8094e
--- /dev/null
+++ b/src/adapters/out/bpmnlint/engine/rules/c8/C8CompensationNamesOwnActivityRule.ts
@@ -0,0 +1,27 @@
+import { is } from 'bpmnlint-utils';
+import { C8Rule, defineRule, ERROR_TYPES, type ModdleElement } from '../CamundaRule.js';
+import { EngineScope } from '../support/EngineScope.js';
+import { C8EventDefinitions } from './support/C8EventDefinitions.js';
+
+/**
+ * A compensation throw event whose activityRef names an activity outside its own scope.
+ * Camunda 8 compensates only activities of the throw event's scope and refuses the file.
+ *
+ * @example a compensation throw naming an activity of another sub-process
+ * <bpmn:intermediateThrowEvent id="Undo">
+ *   <bpmn:compensateEventDefinition activityRef="ChargeInSub" />  <!-- not in Undo's scope -->
+ * </bpmn:intermediateThrowEvent>
+ */
+class C8CompensationNamesOwnActivityRule extends C8Rule {
+  protected visit(event: ModdleElement): void {
+    if (!is(event, 'bpmn:ThrowEvent') || !EngineScope.C8.contains(event)) return;
+    const definition = C8EventDefinitions.definitionOf(event);
+    if (!definition || !is(definition, 'bpmn:CompensateEventDefinition')) return;
+    const activity = definition.get('activityRef');
+    const scope = EngineScope.scopeOf(event);
+    if (!activity || EngineScope.scopeOf(activity) === scope) return;
+    this.report(event, `Compensation event ${event.id} names ${activity.id}, which is not in its own scope ${scope?.id}; Camunda 8 refuses the file`, { path: ['eventDefinitions', 0, 'activityRef'], type: ERROR_TYPES.PROPERTY_VALUE_NOT_ALLOWED, node: definition, property: 'activityRef', activityRef: activity, hint: `\`bpmn set <file> ${event.id} definition.activityRef=<activityId>\` (an activity of ${scope?.id}), or \`definition.activityRef=\` to compensate the whole scope.` });
+  }
+}
+
+export default defineRule({ ruleName: 'c8-compensation-names-own-activity', code: 'W_C8_DEPLOY_EVENT_DEFINITION', impact: 'deploy' }, C8CompensationNamesOwnActivityRule);
diff --git a/src/adapters/out/bpmnlint/engine/rules/c8/C8ConditionNeedsFeelRule.ts b/src/adapters/out/bpmnlint/engine/rules/c8/C8ConditionNeedsFeelRule.ts
new file mode 100644
index 00000000..893013f0
--- /dev/null
+++ b/src/adapters/out/bpmnlint/engine/rules/c8/C8ConditionNeedsFeelRule.ts
@@ -0,0 +1,22 @@
+import { defineRule, ERROR_TYPES, type ModdleElement } from '../CamundaRule.js';
+import { Values } from '../support/Values.js';
+import { C8FeelRule } from './C8FeelRule.js';
+
+/**
+ * A sequence flow condition, an ad-hoc completion condition or the condition of a conditional
+ * event that is no FEEL expression (a static or Camunda 7 JUEL value).
+ * Camunda 8 evaluates conditions as FEEL and refuses the file.
+ *
+ * @example a Camunda 7 (JUEL) condition
+ * <bpmn:conditionExpression>${amount > 1000}</bpmn:conditionExpression>  <!-- FEEL: =amount > 1000 -->
+ */
+class C8ConditionNeedsFeelRule extends C8FeelRule {
+  protected visit(node: ModdleElement): void {
+    const condition = this.runs(node) ? this.conditionOf(node) : undefined;
+    if (!condition || Values.isFeel(condition.body)) return;
+    const { site, what, label, body, notFeelHint } = condition;
+    this.reportAt(site, `The ${what} "${body.trim()}" of ${label} is no FEEL expression; Camunda 8 needs one starting with = and refuses the file`, ERROR_TYPES.EXPRESSION_REQUIRED, notFeelHint);
+  }
+}
+
+export default defineRule({ ruleName: 'c8-condition-needs-feel', code: 'W_C8_DEPLOY_EXPRESSION', impact: 'deploy' }, C8ConditionNeedsFeelRule);
diff --git a/src/adapters/out/bpmnlint/engine/rules/c8/C8ConditionalEventNeedsConditionRule.ts b/src/adapters/out/bpmnlint/engine/rules/c8/C8ConditionalEventNeedsConditionRule.ts
new file mode 100644
index 00000000..82459975
--- /dev/null
+++ b/src/adapters/out/bpmnlint/engine/rules/c8/C8ConditionalEventNeedsConditionRule.ts
@@ -0,0 +1,25 @@
+import { is } from 'bpmnlint-utils';
+import { C8Rule, defineRule, ERROR_TYPES, type ModdleElement } from '../CamundaRule.js';
+import { ElementKinds } from '../support/ElementKinds.js';
+import { C8EventDefinitions } from './support/C8EventDefinitions.js';
+
+/**
+ * A conditional event definition without condition element, anywhere in the file.
+ * The BPMN schema requires one, and Camunda 8 refuses the file.
+ *
+ * @example a conditional start event without condition
+ * <bpmn:startEvent id="LowStock">
+ *   <bpmn:conditionalEventDefinition />  <!-- no bpmn:condition -->
+ * </bpmn:startEvent>
+ */
+class C8ConditionalEventNeedsConditionRule extends C8Rule {
+  protected visit(definition: ModdleElement): void {
+    if (!is(definition, 'bpmn:ConditionalEventDefinition') || definition.get('condition')) {
+      return;
+    }
+    const { owner, path } = C8EventDefinitions.definitionOwner(definition);
+    this.report(owner, `The conditional event definition of ${owner === definition ? definition.$type : ElementKinds.describe(owner)} has no condition element, which the BPMN schema requires; Camunda 8 refuses the file`, { path: [...path, 'condition'], type: ERROR_TYPES.PROPERTY_REQUIRED, node: definition, requiredProperty: 'condition', hint: owner.id ? `\`bpmn set <file> ${owner.id} 'when== <expression>'\`.` : 'Fix it in the XML.' });
+  }
+}
+
+export default defineRule({ ruleName: 'c8-conditional-event-needs-condition', code: 'W_C8_DEPLOY_EVENT_DEFINITION', impact: 'deploy' }, C8ConditionalEventNeedsConditionRule);
diff --git a/src/adapters/out/bpmnlint/engine/rules/c8/C8ConditionalFilterEventsKnownRule.ts b/src/adapters/out/bpmnlint/engine/rules/c8/C8ConditionalFilterEventsKnownRule.ts
new file mode 100644
index 00000000..81a87516
--- /dev/null
+++ b/src/adapters/out/bpmnlint/engine/rules/c8/C8ConditionalFilterEventsKnownRule.ts
@@ -0,0 +1,24 @@
+import { defineRule, ERROR_TYPES } from '../CamundaRule.js';
+import { C8HostRule } from './C8HostRule.js';
+import type { C8Host } from './support/C8Host.js';
+
+/**
+ * Variable events of a zeebe:conditionalFilter other than create and update.
+ * Camunda 8 triggers a condition on create and update only and refuses the file.
+ *
+ * @example a Camunda 7 variable event
+ * <zeebe:conditionalFilter variableEvents="create, delete" />  <!-- create, update -->
+ */
+class C8ConditionalFilterEventsKnownRule extends C8HostRule {
+  protected checkHost(host: C8Host): void {
+    for (const { value, index, type, placement } of host.zeebeValues()) {
+      if (placement !== 'read' || type.name !== 'zeebe:conditionalFilter') continue;
+      const unknown = (value.variableEvents as string | undefined)?.split(',').map((eventName) => eventName.trim()).filter((eventName) => eventName && eventName !== 'create' && eventName !== 'update') ?? [];
+      if (unknown.length) {
+        this.reportOn(host, `${host.spell('zeebe:conditionalFilter')} of ${host.describe()} lists the variable events ${unknown.join(', ')}; Camunda 8 knows create and update only and refuses the file`, { path: host.extensionPath(index, 'variableEvents'), type: ERROR_TYPES.PROPERTY_VALUE_NOT_ALLOWED, node: value, property: 'variableEvents', hint: `${this.rebuildHint(host, value)} (variableEvents=create,update)` });
+      }
+    }
+  }
+}
+
+export default defineRule({ ruleName: 'c8-conditional-filter-events-known', code: 'W_C8_DEPLOY_EXTENSION', impact: 'deploy' }, C8ConditionalFilterEventsKnownRule);
diff --git a/src/adapters/out/bpmnlint/engine/rules/c8/C8CorrelationKeyNeedsFeelRule.ts b/src/adapters/out/bpmnlint/engine/rules/c8/C8CorrelationKeyNeedsFeelRule.ts
new file mode 100644
index 00000000..2d5e33a2
--- /dev/null
+++ b/src/adapters/out/bpmnlint/engine/rules/c8/C8CorrelationKeyNeedsFeelRule.ts
@@ -0,0 +1,50 @@
+import { is } from 'bpmnlint-utils';
+import { defineRule, ERROR_TYPES, type ModdleElement } from '../CamundaRule.js';
+import { ModdlePath } from '../support/ModdlePath.js';
+import { Values } from '../support/Values.js';
+import { C8FeelRule } from './C8FeelRule.js';
+import { C8EventDefinitions } from './support/C8EventDefinitions.js';
+import { C8Host } from './support/C8Host.js';
+import { ZeebeHint } from './support/ZeebeHint.js';
+
+/**
+ * The correlation key of a message a receive task or catch event waits for that is a static value
+ * (a process start event correlates no key).
+ * Camunda 8 evaluates the key as a FEEL expression when the instance subscribes and refuses the
+ * file.
+ *
+ * @example a static correlation key
+ * <bpmn:message id="Paid" name="Paid">
+ *   <bpmn:extensionElements><zeebe:subscription correlationKey="orderId" /></bpmn:extensionElements>  <!-- =orderId -->
+ * </bpmn:message>
+ */
+class C8CorrelationKeyNeedsFeelRule extends C8FeelRule {
+  protected visit(el: ModdleElement): void {
+    if (this.runs(el) && (is(el, 'bpmn:ReceiveTask') || this.catchesMessage(el))) {
+      this.checkCorrelationKey(el);
+    }
+  }
+
+  private catchesMessage(el: ModdleElement): boolean {
+    const definition = is(el, 'bpmn:Event') ? C8EventDefinitions.definitionOf(el) : undefined;
+    return !!definition && is(definition, 'bpmn:MessageEventDefinition') && is(el, 'bpmn:CatchEvent');
+  }
+
+  private checkCorrelationKey(el: ModdleElement): void {
+    const holder = C8EventDefinitions.messageHolderOf(el);
+    const message = holder?.messageRef;
+    if (!message || !Values.hasName(message) || (is(el, 'bpmn:StartEvent') && is(el.$parent, 'bpmn:Process'))) {
+      return;
+    }
+    const subscriptions = C8Host.valuesOf(message, 'zeebe:Subscription');
+    const [subscription] = subscriptions;
+    const key = subscription?.correlationKey;
+    if (subscriptions.length !== 1 || !Values.nonEmpty(key) || Values.isFeel(key)) {
+      return;
+    }
+    const site = { owner: el, holder: subscription, property: 'correlationKey', path: [...ModdlePath.between(el, holder), 'messageRef', ...ModdlePath.between(message, subscription), 'correlationKey'], related: message };
+    this.reportAt(site, `The correlationKey "${key}" of message ${message.id} is a static value; Camunda 8 needs a FEEL expression (=${key.trim()}) and refuses the file`, ERROR_TYPES.EXPRESSION_REQUIRED, ZeebeHint.fix(message, subscription, { correlationKey: `=${key.trim()}` }));
+  }
+}
+
+export default defineRule({ ruleName: 'c8-correlation-key-needs-feel', code: 'W_C8_DEPLOY_EXPRESSION', impact: 'deploy' }, C8CorrelationKeyNeedsFeelRule);
diff --git a/src/adapters/out/bpmnlint/engine/rules/c8/C8EmbeddedStartEventNoTriggerRule.ts b/src/adapters/out/bpmnlint/engine/rules/c8/C8EmbeddedStartEventNoTriggerRule.ts
new file mode 100644
index 00000000..c9511c86
--- /dev/null
+++ b/src/adapters/out/bpmnlint/engine/rules/c8/C8EmbeddedStartEventNoTriggerRule.ts
@@ -0,0 +1,31 @@
+import { is } from 'bpmnlint-utils';
+import { C8Rule, defineRule, ERROR_TYPES, type ModdleElement } from '../CamundaRule.js';
+import { ElementKinds } from '../support/ElementKinds.js';
+import { EngineScope } from '../support/EngineScope.js';
+import { C8EventDefinitions } from './support/C8EventDefinitions.js';
+
+/**
+ * A start event with a trigger in an embedded sub-process.
+ * Camunda 8 enters an embedded sub-process through a none start event only and refuses the file;
+ * triggered starts belong in an event sub-process.
+ *
+ * @example a message start event in an embedded sub-process
+ * <bpmn:subProcess id="Review">
+ *   <bpmn:startEvent id="Begin"><bpmn:messageEventDefinition messageRef="Go" /></bpmn:startEvent>  <!-- none start -->
+ * </bpmn:subProcess>
+ */
+class C8EmbeddedStartEventNoTriggerRule extends C8Rule {
+  protected visit(start: ModdleElement): void {
+    if (!EngineScope.C8.contains(start) || !C8EventDefinitions.isEmbeddedSubProcessStart(start)) {
+      return;
+    }
+    const definitions = start.get('eventDefinitions');
+    const [definition] = definitions;
+    if (definitions.length !== 1 || is(definition, 'bpmn:CancelEventDefinition')) {
+      return;
+    }
+    this.report(start, `Start event ${start.id} of sub-process ${start.$parent.id} has a ${ElementKinds.trigger(definition)} trigger; Camunda 8 allows only a none start event in an embedded sub-process and refuses the file`, { path: ['eventDefinitions', 0], type: ERROR_TYPES.ELEMENT_TYPE_NOT_ALLOWED, eventDefinition: definition, hint: `\`bpmn set <file> ${start.id} trigger=none\` (an event sub-process takes triggered starts: \`bpmn add <file> eventSubProcess:${ElementKinds.trigger(definition)} ... --in ${start.$parent.id}\`).` });
+  }
+}
+
+export default defineRule({ ruleName: 'c8-embedded-start-event-no-trigger', code: 'W_C8_DEPLOY_START_EVENT', impact: 'deploy' }, C8EmbeddedStartEventNoTriggerRule);
diff --git a/src/adapters/out/bpmnlint/engine/rules/c8/C8ErrorCatchNeedsStaticCodeRule.ts b/src/adapters/out/bpmnlint/engine/rules/c8/C8ErrorCatchNeedsStaticCodeRule.ts
new file mode 100644
index 00000000..ae6269cf
--- /dev/null
+++ b/src/adapters/out/bpmnlint/engine/rules/c8/C8ErrorCatchNeedsStaticCodeRule.ts
@@ -0,0 +1,26 @@
+import { is } from 'bpmnlint-utils';
+import { C8Rule, defineRule, ERROR_TYPES, type ModdleElement } from '../CamundaRule.js';
+import { ElementKinds } from '../support/ElementKinds.js';
+import { EngineScope } from '../support/EngineScope.js';
+import { Values } from '../support/Values.js';
+import { C8EventDefinitions } from './support/C8EventDefinitions.js';
+
+/**
+ * An error catch event whose error code is a FEEL expression.
+ * Camunda 8 matches a thrown error against static codes on catching events and refuses the file.
+ *
+ * @example an error boundary event with a FEEL code
+ * <bpmn:error id="Declined" errorCode="=code" />  <!-- a static code -->
+ */
+class C8ErrorCatchNeedsStaticCodeRule extends C8Rule {
+  protected visit(event: ModdleElement): void {
+    if (!EngineScope.C8.contains(event) || !is(event, 'bpmn:CatchEvent')) return;
+    const definition = C8EventDefinitions.definitionOfType(event, 'bpmn:ErrorEventDefinition');
+    const error = definition?.get('errorRef');
+    const code = error?.get('errorCode');
+    if (!definition || !Values.isFeel(code)) return;
+    this.report(event, `${ElementKinds.describe(event)} catches the error code "${code}", an expression; Camunda 8 needs a static code on catching error events and refuses the file`, { path: ['eventDefinitions', 0, 'errorRef', 'errorCode'], type: ERROR_TYPES.EXPRESSION_NOT_ALLOWED, node: error, property: 'errorCode', hint: `\`bpmn set <file> ${event.id} errorCode=<CODE>\` (or no code: it catches every error).` });
+  }
+}
+
+export default defineRule({ ruleName: 'c8-error-catch-needs-static-code', code: 'W_C8_DEPLOY_ERROR', impact: 'deploy' }, C8ErrorCatchNeedsStaticCodeRule);
diff --git a/src/adapters/out/bpmnlint/engine/rules/c8/C8ErrorCodeUniqueRule.ts b/src/adapters/out/bpmnlint/engine/rules/c8/C8ErrorCodeUniqueRule.ts
new file mode 100644
index 00000000..3ae0b458
--- /dev/null
+++ b/src/adapters/out/bpmnlint/engine/rules/c8/C8ErrorCodeUniqueRule.ts
@@ -0,0 +1,41 @@
+import { defineRule, type ModdleElement } from '../CamundaRule.js';
+import { ElementKinds } from '../support/ElementKinds.js';
+import { Values } from '../support/Values.js';
+import { C8EventDefinitions } from './support/C8EventDefinitions.js';
+import type { C8SubscriptionGroups } from './support/C8SubscriptionGroups.js';
+import { C8SubscriptionUniqueRule } from './C8SubscriptionUniqueRule.js';
+
+/**
+ * One error code twice, or two catch-alls without code, among the boundary events of an activity
+ * or the event sub-process starts of a scope.
+ * Camunda 8 cannot tell which of them catches an error and refuses the file.
+ *
+ * @example two boundary events of one task catching the same code
+ * <bpmn:boundaryEvent attachedToRef="Pay"><bpmn:errorEventDefinition errorRef="Declined" /></bpmn:boundaryEvent>
+ * <bpmn:boundaryEvent attachedToRef="Pay"><bpmn:errorEventDefinition errorRef="Declined" /></bpmn:boundaryEvent>  <!-- same code -->
+ */
+class C8ErrorCodeUniqueRule extends C8SubscriptionUniqueRule {
+  protected checkScope(groups: C8SubscriptionGroups, scope: ModdleElement): void {
+    for (const { activity, boundaries } of groups.boundaryGroups) {
+      this.reportErrorCodes(boundaries, `the boundary events of ${activity.id}`);
+    }
+    this.reportErrorCodes(groups.eventSubProcessStarts, `the event sub-processes of ${scope.id}`);
+  }
+
+  /** One error code twice; no code (`''`) catches every error. */
+  private reportErrorCodes(events: ModdleElement[], where: string): void {
+    const keyOf = (el: ModdleElement) => {
+      const definition = C8EventDefinitions.onlyDefinition(el, 'bpmn:ErrorEventDefinition');
+      const code = definition?.get('errorRef')?.get('errorCode');
+      if (!definition) return undefined;
+      return Values.nonEmpty(code) ? code : '';
+    };
+    for (const duplicate of this.duplicates(events, keyOf)) {
+      const { first, el, key } = duplicate;
+      const message = key ? `${ElementKinds.describe(el)} catches the error code "${key}" like ${ElementKinds.describe(first)} (${where}); Camunda 8 refuses one code twice in a scope` : `${ElementKinds.describe(el)} and ${ElementKinds.describe(first)} both catch every error (no error code) (${where}); Camunda 8 allows one catch-all per scope`;
+      this.reportDuplicate(duplicate, message, ['eventDefinitions', 0, 'errorRef'], 'errorCode', `Catch another error: \`bpmn set <file> ${el.id} error=<OtherError> errorCode=<OTHER_CODE>\` (the events share no bpmn:Error then), or remove one of them.`);
+    }
+  }
+}
+
+export default defineRule({ ruleName: 'c8-error-code-unique', code: 'W_C8_DEPLOY_ERROR', impact: 'deploy' }, C8ErrorCodeUniqueRule);
diff --git a/src/adapters/out/bpmnlint/engine/rules/c8/C8ErrorEventInterruptingRule.ts b/src/adapters/out/bpmnlint/engine/rules/c8/C8ErrorEventInterruptingRule.ts
new file mode 100644
index 00000000..9480d683
--- /dev/null
+++ b/src/adapters/out/bpmnlint/engine/rules/c8/C8ErrorEventInterruptingRule.ts
@@ -0,0 +1,29 @@
+import { is } from 'bpmnlint-utils';
+import { C8Rule, defineRule, ERROR_TYPES, type ModdleElement } from '../CamundaRule.js';
+import { ElementKinds } from '../support/ElementKinds.js';
+import { EngineScope } from '../support/EngineScope.js';
+import { C8EventDefinitions } from './support/C8EventDefinitions.js';
+
+/**
+ * A non-interrupting error boundary event or error start event of an event sub-process.
+ * Error events always interrupt in Camunda 8, which refuses the file.
+ *
+ * @example a non-interrupting error boundary event
+ * <bpmn:boundaryEvent id="Failed" attachedToRef="Pay" cancelActivity="false">
+ *   <bpmn:errorEventDefinition errorRef="Declined" />
+ * </bpmn:boundaryEvent>
+ */
+class C8ErrorEventInterruptingRule extends C8Rule {
+  protected visit(event: ModdleElement): void {
+    if (!EngineScope.C8.contains(event) || !is(event, 'bpmn:CatchEvent') || is(event, 'bpmn:IntermediateCatchEvent')) {
+      return;
+    }
+    const interrupting = is(event, 'bpmn:BoundaryEvent') ? 'cancelActivity' : 'isInterrupting';
+    if (!C8EventDefinitions.definitionOfType(event, 'bpmn:ErrorEventDefinition') || event.get(interrupting) !== false) {
+      return;
+    }
+    this.report(event, `${ElementKinds.describe(event)} is a non-interrupting error event; Camunda 8 refuses it (error events always interrupt)`, { path: [interrupting], type: ERROR_TYPES.PROPERTY_VALUE_NOT_ALLOWED, property: interrupting, hint: `\`bpmn set <file> ${event.id} nonInterrupting=false\`.` });
+  }
+}
+
+export default defineRule({ ruleName: 'c8-error-event-interrupting', code: 'W_C8_DEPLOY_ERROR', impact: 'deploy' }, C8ErrorEventInterruptingRule);
diff --git a/src/adapters/out/bpmnlint/engine/rules/c8/C8EventGatewayNeedsTwoBranchesRule.ts b/src/adapters/out/bpmnlint/engine/rules/c8/C8EventGatewayNeedsTwoBranchesRule.ts
new file mode 100644
index 00000000..a20f02f4
--- /dev/null
+++ b/src/adapters/out/bpmnlint/engine/rules/c8/C8EventGatewayNeedsTwoBranchesRule.ts
@@ -0,0 +1,27 @@
+import { is } from 'bpmnlint-utils';
+import { C8Rule, defineRule, ERROR_TYPES, type ModdleElement } from '../CamundaRule.js';
+import { EngineScope } from '../support/EngineScope.js';
+import { FlowIndex } from './support/FlowIndex.js';
+
+/**
+ * An event-based gateway with fewer than two outgoing flows.
+ * Camunda 8 needs at least two events to wait for and refuses the file.
+ *
+ * @example an event-based gateway with one branch
+ * <bpmn:eventBasedGateway id="Wait" />
+ * <bpmn:sequenceFlow sourceRef="Wait" targetRef="PaymentReceived" />  <!-- the only branch -->
+ */
+class C8EventGatewayNeedsTwoBranchesRule extends C8Rule {
+  private readonly flows = new FlowIndex();
+
+  protected visit(gateway: ModdleElement): void {
+    if (!is(gateway, 'bpmn:EventBasedGateway') || !EngineScope.C8.contains(gateway)) {
+      return;
+    }
+    const flows = this.flows.outgoing(gateway);
+    if (flows.length >= 2) return;
+    this.report(gateway, `Event-based gateway ${gateway.id} has ${flows.length} outgoing flow${flows.length === 1 ? '' : 's'}; Camunda 8 needs at least two and refuses the file`, { path: ['outgoing'], type: ERROR_TYPES.PROPERTY_REQUIRED, requiredProperty: 'outgoing', hint: `Add a branch: \`bpmn add <file> intermediateCatchEvent:timer "<Timeout>" --after ${gateway.id} --timer PT1H\`.` });
+  }
+}
+
+export default defineRule({ ruleName: 'c8-event-gateway-needs-two-branches', code: 'W_C8_DEPLOY_EVENT_GATEWAY', impact: 'deploy' }, C8EventGatewayNeedsTwoBranchesRule);
diff --git a/src/adapters/out/bpmnlint/engine/rules/c8/C8EventGatewayTargetAllowedRule.ts b/src/adapters/out/bpmnlint/engine/rules/c8/C8EventGatewayTargetAllowedRule.ts
new file mode 100644
index 00000000..512749e6
--- /dev/null
+++ b/src/adapters/out/bpmnlint/engine/rules/c8/C8EventGatewayTargetAllowedRule.ts
@@ -0,0 +1,37 @@
+import { is } from 'bpmnlint-utils';
+import { C8Rule, defineRule, ERROR_TYPES, type ModdleElement } from '../CamundaRule.js';
+import { ElementKinds } from '../support/ElementKinds.js';
+import { EngineScope } from '../support/EngineScope.js';
+import { C8EventDefinitions } from './support/C8EventDefinitions.js';
+import { FlowIndex } from './support/FlowIndex.js';
+
+const GATEWAY_TRIGGERS = ['bpmn:MessageEventDefinition', 'bpmn:TimerEventDefinition', 'bpmn:SignalEventDefinition', 'bpmn:ConditionalEventDefinition'];
+
+/**
+ * A branch of an event-based gateway that leads to anything but a message, timer, signal or
+ * conditional intermediate catch event (a receive task is camunda-compat's
+ * `event-based-gateway-target`).
+ * Camunda 8 waits only for such events after the gateway and refuses the file.
+ *
+ * @example an event-based gateway that leads to a task
+ * <bpmn:eventBasedGateway id="Wait" />
+ * <bpmn:sequenceFlow sourceRef="Wait" targetRef="Ship" />  <!-- Ship is a service task -->
+ */
+class C8EventGatewayTargetAllowedRule extends C8Rule {
+  private readonly flows = new FlowIndex();
+
+  protected visit(gateway: ModdleElement): void {
+    if (!is(gateway, 'bpmn:EventBasedGateway') || !EngineScope.C8.contains(gateway)) {
+      return;
+    }
+    for (const flow of this.flows.outgoing(gateway)) {
+      const target = flow.get('targetRef');
+      if (!target || is(target, 'bpmn:ReceiveTask') || (is(target, 'bpmn:IntermediateCatchEvent') && GATEWAY_TRIGGERS.some((type) => C8EventDefinitions.onlyDefinition(target, type)))) {
+        continue;
+      }
+      this.report(gateway, `Event-based gateway ${gateway.id} leads to ${ElementKinds.describe(target)}; Camunda 8 allows only message, timer, signal and conditional intermediate catch events after it and refuses the file`, { path: null, type: ERROR_TYPES.EVENT_BASED_GATEWAY_TARGET_NOT_ALLOWED, target, flow, hint: `Put a catch event in between: \`bpmn add <file> intermediateCatchEvent:message "<Name>" --flow ${flow.id} --message <MessageName>\` (or retype ${target.id}).` });
+    }
+  }
+}
+
+export default defineRule({ ruleName: 'c8-event-gateway-target-allowed', code: 'W_C8_DEPLOY_EVENT_GATEWAY', impact: 'deploy' }, C8EventGatewayTargetAllowedRule);
diff --git a/src/adapters/out/bpmnlint/engine/rules/c8/C8EventSubProcessStartNeedsTriggerRule.ts b/src/adapters/out/bpmnlint/engine/rules/c8/C8EventSubProcessStartNeedsTriggerRule.ts
new file mode 100644
index 00000000..f3ef8cbb
--- /dev/null
+++ b/src/adapters/out/bpmnlint/engine/rules/c8/C8EventSubProcessStartNeedsTriggerRule.ts
@@ -0,0 +1,25 @@
+import { is } from 'bpmnlint-utils';
+import { C8Rule, defineRule, ERROR_TYPES, type ModdleElement } from '../CamundaRule.js';
+import { EngineScope } from '../support/EngineScope.js';
+
+/**
+ * A start event of an event sub-process without a trigger.
+ * Camunda 8 needs a message, timer, error, signal, escalation or conditional start there and
+ * refuses the file.
+ *
+ * @example an event sub-process with a none start event
+ * <bpmn:subProcess id="OnCancel" triggeredByEvent="true">
+ *   <bpmn:startEvent id="Cancelled" />  <!-- no event definition -->
+ * </bpmn:subProcess>
+ */
+class C8EventSubProcessStartNeedsTriggerRule extends C8Rule {
+  protected visit(event: ModdleElement): void {
+    if (!is(event, 'bpmn:StartEvent') || !EngineScope.C8.contains(event)) return;
+    if ((event.get('eventDefinitions') ?? []).length || !EngineScope.isEventSubProcess(event.$parent)) {
+      return;
+    }
+    this.report(event, `Start event ${event.id} of event sub-process ${event.$parent.id} has no trigger; Camunda 8 needs a message, timer, error, signal, escalation or conditional start there and refuses the file`, { path: ['eventDefinitions'], type: ERROR_TYPES.PROPERTY_REQUIRED, requiredProperty: 'eventDefinitions', hint: `\`bpmn set <file> ${event.id} trigger=message message=<MessageName>\` (or timer, error, signal, escalation, conditional).` });
+  }
+}
+
+export default defineRule({ ruleName: 'c8-event-sub-process-start-needs-trigger', code: 'W_C8_DEPLOY_EVENT_DEFINITION', impact: 'deploy' }, C8EventSubProcessStartNeedsTriggerRule);
diff --git a/src/adapters/out/bpmnlint/engine/rules/c8/C8ExecutionListenerEventTypeValidRule.ts b/src/adapters/out/bpmnlint/engine/rules/c8/C8ExecutionListenerEventTypeValidRule.ts
new file mode 100644
index 00000000..30ddbfd3
--- /dev/null
+++ b/src/adapters/out/bpmnlint/engine/rules/c8/C8ExecutionListenerEventTypeValidRule.ts
@@ -0,0 +1,41 @@
+import { is } from 'bpmnlint-utils';
+import { defineRule, type ModdleElement } from '../CamundaRule.js';
+import { C8ListenerEventTypeRule } from './C8ListenerEventTypeRule.js';
+import type { C8Host } from './support/C8Host.js';
+
+/**
+ * An execution listener without event type, with one Camunda 8 does not know (beforeAll and cancel
+ * from 8.10 on), a start listener on a start or boundary event, or an end listener on a gateway.
+ * Camunda 8 refuses the file.
+ *
+ * @example a start listener on a start event
+ * <bpmn:startEvent id="Received">
+ *   <bpmn:extensionElements><zeebe:executionListeners><zeebe:executionListener eventType="start" type="audit" /></zeebe:executionListeners></bpmn:extensionElements>  <!-- end -->
+ * </bpmn:startEvent>
+ */
+class C8ExecutionListenerEventTypeValidRule extends C8ListenerEventTypeRule {
+  protected readonly list = 'zeebe:executionListeners';
+
+  protected checkListeners(host: C8Host, value: ModdleElement, index: number): void {
+    const allowedEvents = this.runsAtLeast(host.node, '8.10') ? ['start', 'end', 'beforeAll', 'cancel'] : ['start', 'end'];
+    (value.listeners ?? []).forEach((listener: ModdleElement, listenerIndex: number) => {
+      const eventType: string | undefined = listener.eventType;
+      const label = `Execution listener ${listenerIndex + 1}${eventType?.trim() ? ` (${eventType})` : ''} of ${host.describe()}`;
+      const rebuild = (lead: string, eventTypeFix: string) => this.rebuildListenerHint(host, 'executionListener', listenerIndex, lead, `eventType=${eventTypeFix} type=${listener.type ?? '<jobType>'}`);
+      const unsupported = (where: string, lead: string, fix: string) => this.reportEventType(host, listener, index, listenerIndex, `${label}: Camunda 8 does not support ${eventType} listeners on ${where} and refuses the file`, rebuild(lead, fix));
+      if (!eventType?.trim()) {
+        this.reportEventType(host, listener, index, listenerIndex, `${label} has no eventType; Camunda 8 refuses the file`, rebuild('Rebuild it', '<start|end>'), true);
+      } else if (!allowedEvents.includes(eventType)) {
+        this.reportEventType(host, listener, index, listenerIndex, `${label}: eventType "${eventType}" is not ${allowedEvents.length === 2 ? 'start or end' : `one of ${allowedEvents.join(', ')}`}; Camunda 8 refuses the file`, rebuild('Rebuild it', '<start|end>'));
+      } else if (eventType === 'start' && is(host.node, 'bpmn:StartEvent')) {
+        unsupported('start events', 'Make it an end listener or remove it', 'end');
+      } else if (eventType === 'start' && is(host.node, 'bpmn:BoundaryEvent')) {
+        unsupported('boundary events', 'Make it an end listener or remove it', 'end');
+      } else if (eventType === 'end' && is(host.node, 'bpmn:Gateway')) {
+        unsupported('gateways', 'Make it a start listener or remove it', 'start');
+      }
+    });
+  }
+}
+
+export default defineRule({ ruleName: 'c8-execution-listener-event-type-valid', code: 'W_C8_DEPLOY_LISTENER', impact: 'deploy' }, C8ExecutionListenerEventTypeValidRule);
diff --git a/src/adapters/out/bpmnlint/engine/rules/c8/C8ExtensionElementUniqueRule.ts b/src/adapters/out/bpmnlint/engine/rules/c8/C8ExtensionElementUniqueRule.ts
new file mode 100644
index 00000000..b8951c1b
--- /dev/null
+++ b/src/adapters/out/bpmnlint/engine/rules/c8/C8ExtensionElementUniqueRule.ts
@@ -0,0 +1,33 @@
+import { defineRule, ERROR_TYPES } from '../CamundaRule.js';
+import { RuleKit } from '../RuleKit.js';
+import { C8HostRule } from './C8HostRule.js';
+import type { C8Host, ZeebeValue } from './support/C8Host.js';
+
+/**
+ * Two or more of a zeebe extension element Camunda 8 reads once per element, reported on the
+ * second.
+ * Camunda 8 reads one and refuses the file.
+ *
+ * @example two task definitions
+ * <zeebe:taskDefinition type="charge" />
+ * <zeebe:taskDefinition type="refund" />  <!-- one too many -->
+ */
+class C8ExtensionElementUniqueRule extends C8HostRule {
+  protected checkHost(host: C8Host): void {
+    const byName = new Map<string, ZeebeValue[]>();
+    for (const value of host.zeebeValues()) {
+      if (value.placement === 'read' && RuleKit.kit.ZEEBE.isSingle(value.type.name)) {
+        byName.set(value.type.name, [...(byName.get(value.type.name) ?? []), value]);
+      }
+    }
+    const hint = host.hint();
+    for (const [name, values] of byName) {
+      const [, second] = values;
+      if (second) {
+        this.reportOn(host, `${host.describe()} has ${values.length} ${host.spell(name)} elements; Camunda 8 reads one and refuses the file`, { path: host.extensionPath(second.index), type: ERROR_TYPES.ELEMENT_MULTIPLE_NOT_ALLOWED, node: host.node, extensionElement: second.value, hint: hint ? `Merge them into one: ${hint.rebuild(hint.nameOf(second.value)).replace(/^See it/, 'see them')}` : 'Merge them into one: fix it in the XML.' });
+      }
+    }
+  }
+}
+
+export default defineRule({ ruleName: 'c8-extension-element-unique', code: 'W_C8_DEPLOY_DUPLICATE_EXTENSION', impact: 'deploy' }, C8ExtensionElementUniqueRule);
diff --git a/src/adapters/out/bpmnlint/engine/rules/c8/C8FeelExpressionValidRule.ts b/src/adapters/out/bpmnlint/engine/rules/c8/C8FeelExpressionValidRule.ts
new file mode 100644
index 00000000..132f9c13
--- /dev/null
+++ b/src/adapters/out/bpmnlint/engine/rules/c8/C8FeelExpressionValidRule.ts
@@ -0,0 +1,150 @@
+import { is } from 'bpmnlint-utils';
+import { defineRule, ERROR_TYPES, type ModdleElement } from '../CamundaRule.js';
+import { ElementKinds } from '../support/ElementKinds.js';
+import { ModdlePath } from '../support/ModdlePath.js';
+import { Shell } from '../support/Shell.js';
+import { Values } from '../support/Values.js';
+import { C8FeelRule, type FeelCondition, type ValueSite } from './C8FeelRule.js';
+import { C8EventDefinitions } from './support/C8EventDefinitions.js';
+import { C8Host } from './support/C8Host.js';
+import { FeelExpression } from './support/feel/FeelExpression.js';
+import { ZeebeHint } from './support/ZeebeHint.js';
+
+const FEEL_ATTRIBUTES: Record<string, string[]> = {
+  'zeebe:TaskDefinition': ['type', 'retries'],
+  'zeebe:LoopCharacteristics': ['inputCollection', 'outputElement'],
+  'zeebe:CalledElement': ['processId'],
+  'zeebe:CalledDecision': ['decisionId'],
+  'zeebe:Script': ['expression'],
+  'zeebe:Subscription': ['correlationKey'],
+  'zeebe:AssignmentDefinition': ['assignee', 'candidateGroups', 'candidateUsers'],
+  'zeebe:TaskSchedule': ['dueDate', 'followUpDate'],
+  'zeebe:PriorityDefinition': ['priority'],
+  'zeebe:AdHoc': ['activeElementsCollection', 'outputElement'],
+};
+const TIMER_KINDS = ['timeDate', 'timeDuration', 'timeCycle'];
+
+/**
+ * A value starting with = that is no valid FEEL: in a zeebe extension element, a condition, a
+ * multi-instance completion condition, a timer, or the name of a message or signal the process
+ * uses.
+ * Camunda 8 parses every FEEL expression at deploy and refuses the file.
+ *
+ * @example a FEEL condition with Camunda 7 operators
+ * <bpmn:conditionExpression>=amount &gt; 1000 &amp;&amp; approved</bpmn:conditionExpression>  <!-- FEEL: and -->
+ */
+class C8FeelExpressionValidRule extends C8FeelRule {
+  protected visit(node: ModdleElement): void {
+    if (is(node, 'bpmn:Definitions')) return this.checkMessageAndSignalNames(node);
+    if (String(node.$type).startsWith('zeebe:')) return this.checkExtension(node);
+    if (!this.runs(node)) return;
+    const condition = is(node, 'bpmn:Event') ? undefined : this.conditionOf(node);
+    if (condition) this.checkCondition(condition);
+    if (is(node, 'bpmn:Activity')) this.checkCompletionCondition(node);
+    if (is(node, 'bpmn:Event')) this.checkEvent(node);
+  }
+
+  private checkExtension(node: ModdleElement): void {
+    const host = C8Host.readHostOf(node);
+    if (!host) return;
+    this.checkFeelAttributes(node, FEEL_ATTRIBUTES[node.$type] ?? [], host, '');
+    if (is(node, 'zeebe:IoMapping')) {
+      for (const mapping of [...(node.inputParameters ?? []), ...(node.outputParameters ?? [])]) {
+        this.checkFeelAttributes(mapping, ['source'], host, ' (in zeebe:ioMapping)');
+      }
+    }
+  }
+
+  private checkFeelAttributes(element: ModdleElement, attributes: string[], host: ModdleElement, container: string): void {
+    const owner = ModdlePath.ownerOf(host);
+    const where = `${ZeebeHint.typeName(element)}${container} of ${host.id ? ElementKinds.describe(host) : ElementKinds.describe(host, owner)}`;
+    for (const attribute of attributes) {
+      this.checkSyntax(`${attribute} of ${where}`, element[attribute], this.siteOf(owner, element, attribute), this.extensionHint(element, attribute, host, container !== ''));
+    }
+  }
+
+  /** A mapping is added again for its target, an element inside another is rebuilt with its container, a flat one is replaced. */
+  private extensionHint(element: ModdleElement, attribute: string, host: ModdleElement, nested: boolean): string {
+    const hint = ZeebeHint.of(host);
+    if ((is(element, 'zeebe:Input') || is(element, 'zeebe:Output')) && element.target) {
+      const args = `${ZeebeHint.typeName(element)} ${Shell.quote(`${attribute}==${FeelExpression.fromJuel(String(element[attribute] ?? '').trim().slice(1)).trim()}`)} target=${Shell.quote(element.target)}`;
+      return `${hint ? hint.extAdd(args) : 'edit the XML'} (replaces the mapping of that target; check the FEEL syntax).`;
+    }
+    if (nested) {
+      return hint ? hint.rebuild(ZeebeHint.typeName(element.$parent)) : 'Fix it in the XML.';
+    }
+    return ZeebeHint.fix(host, element, { [attribute]: '=<FEEL expression>' });
+  }
+
+  private checkCondition({ site, what, label, body, invalidHint }: FeelCondition): void {
+    if (Values.isFeel(body)) {
+      this.checkSyntax(`The ${what} of ${label}`, body, site, invalidHint);
+    }
+  }
+
+  private checkCompletionCondition(activity: ModdleElement): void {
+    const loop = activity.loopCharacteristics;
+    if (!loop || !is(loop, 'bpmn:MultiInstanceLoopCharacteristics') || !loop.completionCondition) {
+      return;
+    }
+    const body: string = loop.completionCondition.body ?? '';
+    this.checkSyntax(`The completion condition of multi-instance ${ElementKinds.describe(activity)}`, body, { owner: activity, holder: loop, property: 'completionCondition', path: ['loopCharacteristics', 'completionCondition'] }, `\`bpmn set <file> ${activity.id} ${Shell.quote(`completion==${FeelExpression.fromJuel(body.trim().slice(1))}`)}\` (check the FEEL syntax).`);
+  }
+
+  private checkEvent(event: ModdleElement): void {
+    const definition = C8EventDefinitions.definitionOf(event);
+    if (definition && is(definition, 'bpmn:TimerEventDefinition')) {
+      this.checkTimer(event, definition);
+    }
+    const condition = this.conditionOf(event);
+    if (condition) this.checkCondition(condition);
+  }
+
+  private checkTimer(event: ModdleElement, definition: ModdleElement): void {
+    const kinds = TIMER_KINDS.filter((kind) => definition[kind]);
+    const [kind] = kinds;
+    if (kinds.length !== 1 || !kind || (kind === 'timeCycle' && is(event, 'bpmn:IntermediateCatchEvent'))) {
+      return;
+    }
+    this.checkSyntax(`The ${kind} of ${ElementKinds.describe(event)}`, definition[kind].body, this.siteOf(event, definition, kind), `\`bpmn set <file> ${event.id} ${Shell.quote('timer==<FEEL expression>')}\` (check the FEEL syntax).`);
+  }
+
+  private checkMessageAndSignalNames(definitions: ModdleElement): void {
+    for (const used of this.usedMessagesAndSignals(definitions)) {
+      const kind = is(used, 'bpmn:Signal') ? 'signal' : 'message';
+      if (used.id && Values.hasName(used)) {
+        this.checkSyntax(`The name of ${kind} ${used.id}`, used.name, { owner: used, holder: used, property: 'name', path: ['name'] }, `\`bpmn set <file> ${used.id} ${Shell.quote('name==<FEEL expression>')}\` (check the FEEL syntax), or a static name.`);
+      }
+    }
+  }
+
+  private usedMessagesAndSignals(definitions: ModdleElement): Set<ModdleElement> {
+    const used = new Set<ModdleElement>();
+    const pending: ModdleElement[] = (definitions.rootElements ?? []).filter((root: ModdleElement) => is(root, 'bpmn:Process'));
+    while (pending.length) {
+      for (const element of pending.pop().flowElements ?? []) {
+        if (element.flowElements) pending.push(element);
+        if (!is(element, 'bpmn:FlowNode')) continue;
+        const message = C8EventDefinitions.messageOf(element);
+        if (message) used.add(message);
+        for (const definition of element.eventDefinitions ?? []) {
+          if (is(definition, 'bpmn:SignalEventDefinition') && definition.signalRef) {
+            used.add(definition.signalRef);
+          }
+        }
+      }
+    }
+    return used;
+  }
+
+  private checkSyntax(what: string, value: unknown, site: ValueSite, hint: string): void {
+    if (!Values.isFeel(value)) return;
+    const expression = String(value).trim();
+    const problem = new FeelExpression(expression.slice(1)).problem();
+    if (problem) {
+      this.reportAt(site, `${what} "${expression}" is no valid FEEL: ${problem}; Camunda 8 parses it at deploy and refuses the file`, ERROR_TYPES.FEEL_EXPRESSION_INVALID, hint);
+    }
+  }
+}
+
+export default defineRule({ ruleName: 'c8-feel-expression-valid', code: 'W_C8_DEPLOY_EXPRESSION', impact: 'deploy' }, C8FeelExpressionValidRule);
diff --git a/src/adapters/out/bpmnlint/engine/rules/c8/C8FeelRule.ts b/src/adapters/out/bpmnlint/engine/rules/c8/C8FeelRule.ts
new file mode 100644
index 00000000..edf67596
--- /dev/null
+++ b/src/adapters/out/bpmnlint/engine/rules/c8/C8FeelRule.ts
@@ -0,0 +1,85 @@
+import { is } from 'bpmnlint-utils';
+import { C8Rule, type ModdleElement, type ReportPath } from '../CamundaRule.js';
+import { EngineScope } from '../support/EngineScope.js';
+import { ModdlePath } from '../support/ModdlePath.js';
+import { Shell } from '../support/Shell.js';
+import { Values } from '../support/Values.js';
+import { C8EventDefinitions } from './support/C8EventDefinitions.js';
+import { FeelExpression } from './support/feel/FeelExpression.js';
+
+/**
+ * Where a value sits: the element reported on, the element holding the property, and the path;
+ * `related` is another element the finding names (the message of a correlation key).
+ */
+export interface ValueSite {
+  owner: ModdleElement;
+  holder: ModdleElement;
+  property: string;
+  path: ReportPath;
+  related?: ModdleElement;
+}
+
+/** A condition Camunda 8 evaluates as FEEL, with the fixes for an invalid and for a static one. */
+export interface FeelCondition {
+  site: ValueSite;
+  what: string;
+  label: string;
+  body: string;
+  invalidHint: string;
+  notFeelHint: string;
+}
+
+/**
+ * The values Camunda 8 parses as FEEL, for the rules on them (`C8FeelExpressionValidRule`,
+ * `C8ConditionNeedsFeelRule`, `C8MultiInstanceNeedsFeelRule`, `C8ScriptNeedsFeelRule`,
+ * `C8CorrelationKeyNeedsFeelRule`): where a value sits, the conditions of an element and how a
+ * finding on a value is reported.
+ * Camunda 8 parses them at deploy and refuses the file.
+ *
+ * @example a Camunda 7 (JUEL) condition
+ * <bpmn:conditionExpression>${amount > 1000}</bpmn:conditionExpression>  <!-- FEEL: =amount > 1000 -->
+ */
+export abstract class C8FeelRule extends C8Rule {
+  /** An element Camunda 8 runs whose values it parses: a transaction is no Camunda 8 element. */
+  protected runs(node: ModdleElement): boolean {
+    return EngineScope.C8.runs(node) && !is(node, 'bpmn:Transaction');
+  }
+
+  /** The condition of a sequence flow, the completion condition of an ad-hoc sub-process, the condition of a conditional event. */
+  protected conditionOf(node: ModdleElement): FeelCondition | undefined {
+    if (is(node, 'bpmn:SequenceFlow') || is(node, 'bpmn:AdHocSubProcess')) {
+      return this.flowConditionOf(node);
+    }
+    const definition = is(node, 'bpmn:Event') ? C8EventDefinitions.definitionOf(node) : undefined;
+    const condition = definition && is(definition, 'bpmn:ConditionalEventDefinition') ? definition.condition : undefined;
+    if (!condition) return undefined;
+    const body: string = condition.body ?? '';
+    const fix = (expression: string) => `\`bpmn set <file> ${node.id} ${Shell.quote(`when==${FeelExpression.fromJuel(expression)}`)}\` (check the FEEL syntax).`;
+    return { site: this.siteOf(node, definition, 'condition'), what: 'condition', label: `conditional event ${node.id}`, body, invalidHint: fix(body.trim().slice(1)), notFeelHint: fix(body) };
+  }
+
+  private flowConditionOf(node: ModdleElement): FeelCondition | undefined {
+    const flow = is(node, 'bpmn:SequenceFlow');
+    const condition = flow ? node.conditionExpression : node.completionCondition;
+    if (!condition) return undefined;
+    const property = flow ? 'conditionExpression' : 'completionCondition';
+    const body: string = condition.body ?? '';
+    const id = node.id;
+    const site = { owner: node, holder: node, property, path: [property] };
+    if (flow) {
+      const invalidHint = `\`bpmn set <file> ${id} ${Shell.quote(`condition==${FeelExpression.fromJuel(body.trim().slice(1))}`)}\` (check the FEEL syntax: and / or, = for equality, not(...)).`;
+      const notFeelHint = body.trim() ? `\`bpmn set <file> ${id} ${Shell.quote(`condition==${FeelExpression.fromJuel(body)}`)}\` (check the FEEL syntax: and / or, = for equality).` : `Give it one (\`bpmn set <file> ${id} ${Shell.quote('condition== <expression>')}\`) or remove it (\`bpmn set <file> ${id} condition=\`).`;
+      return { site, what: 'condition', label: `sequence flow ${id}`, body, invalidHint, notFeelHint };
+    }
+    const fix = `\`bpmn set <file> ${id} ${Shell.quote(`completion==${FeelExpression.fromJuel(Values.isFeel(body) ? body.trim().slice(1) : body)}`)}\` (check the FEEL syntax)`;
+    return { site, what: 'completion condition', label: `ad-hoc sub-process ${id}`, body, invalidHint: `${fix}.`, notFeelHint: `${fix}, or remove it: \`bpmn set <file> ${id} completion=\`.` };
+  }
+
+  protected siteOf(owner: ModdleElement, holder: ModdleElement, property: string): ValueSite {
+    return { owner, holder, property, path: [...ModdlePath.between(owner, holder), property] };
+  }
+
+  protected reportAt({ owner, holder, property, path, related }: ValueSite, message: string, type: string, hint: string): void {
+    this.report(owner, message, { path, type, node: holder, property, ...(related ? { related } : {}), hint });
+  }
+}
diff --git a/src/adapters/out/bpmnlint/engine/rules/c8/C8HostRule.ts b/src/adapters/out/bpmnlint/engine/rules/c8/C8HostRule.ts
new file mode 100644
index 00000000..1ce12100
--- /dev/null
+++ b/src/adapters/out/bpmnlint/engine/rules/c8/C8HostRule.ts
@@ -0,0 +1,33 @@
+import { C8Rule, type ModdleElement, type ReportData } from '../CamundaRule.js';
+import { C8Host } from './support/C8Host.js';
+
+/**
+ * The elements whose zeebe content Camunda 8 reads (`C8Host`), for the rules on that content: its
+ * extension elements, listeners, bindings and attributes. A finding goes on the element it lands
+ * on (an event definition's on its event).
+ * Camunda 8 refuses or ignores content it cannot read where it sits.
+ *
+ * @example task listeners on a job worker user task
+ * <bpmn:userTask id="Review">
+ *   <bpmn:extensionElements><zeebe:taskListeners>...</zeebe:taskListeners></bpmn:extensionElements>  <!-- no zeebe:userTask -->
+ * </bpmn:userTask>
+ */
+export abstract class C8HostRule extends C8Rule {
+  protected visit(node: ModdleElement): void {
+    const host = C8Host.of(node);
+    if (host) this.checkHost(host);
+  }
+
+  protected abstract checkHost(host: C8Host): void;
+
+  /** A finding about content of `host`, which names `host.node` unless it names a part of it. */
+  protected reportContent(host: C8Host, message: string, { path, ...data }: ReportData): void {
+    this.report(host.target, message, { node: host.node, path, ...data });
+  }
+
+  /** How to rebuild a zeebe element with child elements (`zeebe:linkedResources`). */
+  protected rebuildHint(host: C8Host, element: ModdleElement): string {
+    const hint = host.hint();
+    return hint ? hint.rebuild(hint.nameOf(element)) : 'Fix it in the XML.';
+  }
+}
diff --git a/src/adapters/out/bpmnlint/engine/rules/c8/C8InputMappingPlacementRule.ts b/src/adapters/out/bpmnlint/engine/rules/c8/C8InputMappingPlacementRule.ts
new file mode 100644
index 00000000..7c8fe42e
--- /dev/null
+++ b/src/adapters/out/bpmnlint/engine/rules/c8/C8InputMappingPlacementRule.ts
@@ -0,0 +1,40 @@
+import { is } from 'bpmnlint-utils';
+import { defineRule, ERROR_TYPES, type ModdleElement } from '../CamundaRule.js';
+import { C8HostRule } from './C8HostRule.js';
+import type { C8Host } from './support/C8Host.js';
+
+/** Where Camunda 8 ignores input mappings: on events of a type, some only without an event definition. */
+const INPUTS_IGNORED: Array<[type: string, noneOnly: boolean, where: string]> = [
+  ['bpmn:StartEvent', false, 'start events'],
+  ['bpmn:BoundaryEvent', false, 'boundary events'],
+  ['bpmn:IntermediateThrowEvent', true, 'none intermediate throw events'],
+  ['bpmn:EndEvent', true, 'none end events'],
+];
+
+/**
+ * An input mapping on a start, boundary, none intermediate throw or none end event, where only
+ * output mappings work.
+ * Camunda 8 deploys the file and silently ignores the mapping.
+ *
+ * @example an input mapping on a start event
+ * <bpmn:startEvent id="Received">
+ *   <bpmn:extensionElements><zeebe:ioMapping><zeebe:input source="=1" target="count" /></zeebe:ioMapping></bpmn:extensionElements>  <!-- an output mapping -->
+ * </bpmn:startEvent>
+ */
+class C8InputMappingPlacementRule extends C8HostRule {
+  protected checkHost(host: C8Host): void {
+    const node = host.node;
+    const noDefinitions = !(node.eventDefinitions ?? []).length;
+    const ignoredOn = INPUTS_IGNORED.find(([type, noneOnly]) => is(node, type) && (!noneOnly || noDefinitions))?.[2];
+    if (!ignoredOn) return;
+    const hint = host.hint();
+    for (const { value, index, type } of host.zeebeValues()) {
+      if (type.name !== 'zeebe:ioMapping') continue;
+      (value.inputParameters ?? []).forEach((input: ModdleElement, inputIndex: number) => {
+        this.reportContent(host, `The input mapping ${input.target ? `to ${input.target} ` : ''}on ${host.describe()} has no effect: Camunda 8 ignores input mappings on ${ignoredOn} (output mappings work there)`, { path: host.extensionPath(index, 'inputParameters', inputIndex), type: ERROR_TYPES.EXTENSION_ELEMENT_NOT_ALLOWED, node: value, extensionElement: input, hint: hint ? `Remove it: ${hint.extRemove(`${hint.name('input')}[target=${input.target ?? ''}]`)} (set the variable in an activity before it, or as an output mapping of the element before).` : 'Remove it from the XML.' });
+      });
+    }
+  }
+}
+
+export default defineRule({ ruleName: 'c8-input-mapping-placement', code: 'W_C8_MISPLACED_EXTENSION', impact: 'runtime' }, C8InputMappingPlacementRule);
diff --git a/src/adapters/out/bpmnlint/engine/rules/c8/C8JobRetriesValidRule.ts b/src/adapters/out/bpmnlint/engine/rules/c8/C8JobRetriesValidRule.ts
new file mode 100644
index 00000000..183bc0e8
--- /dev/null
+++ b/src/adapters/out/bpmnlint/engine/rules/c8/C8JobRetriesValidRule.ts
@@ -0,0 +1,36 @@
+import { is, isAny } from 'bpmnlint-utils';
+import { C8Rule, defineRule, ERROR_TYPES, type ModdleElement } from '../CamundaRule.js';
+import { ElementKinds } from '../support/ElementKinds.js';
+import { EngineScope } from '../support/EngineScope.js';
+import { ModdlePath } from '../support/ModdlePath.js';
+import { Values } from '../support/Values.js';
+import { C8EventDefinitions } from './support/C8EventDefinitions.js';
+import { C8Host } from './support/C8Host.js';
+import { ZeebeHint } from './support/ZeebeHint.js';
+
+const JOB_TASKS = ['bpmn:ServiceTask', 'bpmn:SendTask', 'bpmn:ScriptTask', 'bpmn:BusinessRuleTask'];
+
+/**
+ * Job retries of a zeebe:taskDefinition that are neither a number nor a FEEL expression.
+ * Camunda 8 deploys the file, but every instance gets an incident when it reaches the element.
+ *
+ * @example retries that are no number
+ * <zeebe:taskDefinition type="charge" retries="three" />  <!-- incident on every instance -->
+ */
+class C8JobRetriesValidRule extends C8Rule {
+  protected visit(node: ModdleElement): void {
+    if (!this.isJobHost(node) || !EngineScope.C8.runs(node)) return;
+    const [taskDefinition] = C8Host.valuesOf(node, 'zeebe:TaskDefinition');
+    const retries = taskDefinition?.retries;
+    if (retries === undefined || Values.isFeel(retries) || /^\s*-?\d+\s*$/.test(retries)) {
+      return;
+    }
+    this.report(node, `The ${ZeebeHint.prefixOf(node)}:taskDefinition of ${ElementKinds.describe(node)} has retries="${retries}", which is no number; it deploys, but every instance gets an incident when it reaches ${node.id}`, { path: [...ModdlePath.between(node, taskDefinition), 'retries'], type: ERROR_TYPES.PROPERTY_VALUE_NOT_ALLOWED, node: taskDefinition, property: 'retries', hint: ZeebeHint.of(node)?.replace(taskDefinition, { retries: '3' }) ?? 'edit the XML.' });
+  }
+
+  private isJobHost(node: ModdleElement): boolean {
+    return isAny(node, JOB_TASKS) || (is(node, 'bpmn:ThrowEvent') && !!C8EventDefinitions.definitionOfType(node, 'bpmn:MessageEventDefinition'));
+  }
+}
+
+export default defineRule({ ruleName: 'c8-job-retries-valid', code: 'W_C8_BAD_VALUE', impact: 'runtime' }, C8JobRetriesValidRule);
diff --git a/src/adapters/out/bpmnlint/engine/rules/c8/C8LinkEventNeedsNameRule.ts b/src/adapters/out/bpmnlint/engine/rules/c8/C8LinkEventNeedsNameRule.ts
new file mode 100644
index 00000000..feca3001
--- /dev/null
+++ b/src/adapters/out/bpmnlint/engine/rules/c8/C8LinkEventNeedsNameRule.ts
@@ -0,0 +1,31 @@
+import { is, isAny } from 'bpmnlint-utils';
+import { C8Rule, defineRule, ERROR_TYPES, type ModdleElement } from '../CamundaRule.js';
+import { ElementKinds } from '../support/ElementKinds.js';
+import { EngineScope } from '../support/EngineScope.js';
+import { C8EventDefinitions } from './support/C8EventDefinitions.js';
+
+/**
+ * A link event definition without name or with an empty one, anywhere in the file.
+ * The BPMN schema requires a name, and Camunda 8 refuses an empty one. camunda-compat checks the
+ * first definition of an intermediate event in an executable process; this rule checks the others.
+ *
+ * @example a link catch event without name
+ * <bpmn:intermediateCatchEvent id="Resume">
+ *   <bpmn:linkEventDefinition />  <!-- no name -->
+ * </bpmn:intermediateCatchEvent>
+ */
+class C8LinkEventNeedsNameRule extends C8Rule {
+  protected visit(definition: ModdleElement): void {
+    if (!is(definition, 'bpmn:LinkEventDefinition')) return;
+    const name = definition.get('name');
+    const event = definition.$parent;
+    const checkedByCompat = isAny(event, ['bpmn:IntermediateCatchEvent', 'bpmn:IntermediateThrowEvent']) && event.get('eventDefinitions')[0] === definition && EngineScope.inExecutableProcess(event);
+    if ((name !== undefined && name !== null && name !== '') || checkedByCompat) {
+      return;
+    }
+    const { owner, path } = C8EventDefinitions.definitionOwner(definition);
+    this.report(owner, `The link event definition of ${owner === definition ? definition.$type : ElementKinds.describe(owner)} has ${name === '' ? 'an empty name' : 'no name, which the BPMN schema requires'}; Camunda 8 refuses the file`, { path: [...path, 'name'], type: ERROR_TYPES.PROPERTY_REQUIRED, node: definition, requiredProperty: 'name', hint: owner.id ? `\`bpmn set <file> ${owner.id} link=<Name>\` (the throw and the catch event of a pair share the name).` : 'Fix it in the XML.' });
+  }
+}
+
+export default defineRule({ ruleName: 'c8-link-event-needs-name', code: 'W_C8_DEPLOY_LINK', impact: 'deploy' }, C8LinkEventNeedsNameRule);
diff --git a/src/adapters/out/bpmnlint/engine/rules/c8/C8LinkThrowNeedsCatchRule.ts b/src/adapters/out/bpmnlint/engine/rules/c8/C8LinkThrowNeedsCatchRule.ts
new file mode 100644
index 00000000..7842662f
--- /dev/null
+++ b/src/adapters/out/bpmnlint/engine/rules/c8/C8LinkThrowNeedsCatchRule.ts
@@ -0,0 +1,27 @@
+import { is } from 'bpmnlint-utils';
+import { C8Rule, defineRule, ERROR_TYPES, type ModdleElement } from '../CamundaRule.js';
+import { EngineScope } from '../support/EngineScope.js';
+import { LinkEvents } from '../support/LinkEvents.js';
+import { Shell } from '../support/Shell.js';
+import { C8EventDefinitions } from './support/C8EventDefinitions.js';
+
+/**
+ * A link throw event without a link catch event of its name in its scope.
+ * Camunda 8 resolves a link within its (sub-)process and refuses the file.
+ *
+ * @example a link throw without its catch
+ * <bpmn:intermediateThrowEvent id="GoOn">
+ *   <bpmn:linkEventDefinition name="Resume" />  <!-- no catch event named Resume -->
+ * </bpmn:intermediateThrowEvent>
+ */
+class C8LinkThrowNeedsCatchRule extends C8Rule {
+  protected visit(process: ModdleElement): void {
+    if (!is(process, 'bpmn:Process') || !EngineScope.C8.contains(process)) return;
+    const links = new LinkEvents(process, (node) => C8EventDefinitions.onlyDefinition(node, 'bpmn:LinkEventDefinition')?.get('name'));
+    for (const { el, name, scope } of links.unmatchedThrows()) {
+      this.report(el, `Link throw event ${el.id} goes to "${name}", but ${scope.id} has no link catch event of that name; Camunda 8 refuses the file`, { path: ['eventDefinitions', 0, 'name'], type: ERROR_TYPES.PROPERTY_VALUE_NOT_ALLOWED, node: el.get('eventDefinitions')[0], property: 'name', hint: `\`bpmn add <file> intermediateCatchEvent:link "<Name>" --in ${scope.id} --link ${Shell.quote(name)}\`, then continue from it (or rename the link: \`bpmn set <file> ${el.id} link=<Name>\`).` });
+    }
+  }
+}
+
+export default defineRule({ ruleName: 'c8-link-throw-needs-catch', code: 'W_C8_DEPLOY_LINK', impact: 'deploy' }, C8LinkThrowNeedsCatchRule);
diff --git a/src/adapters/out/bpmnlint/engine/rules/c8/C8LinkedResourceNeedsTypeRule.ts b/src/adapters/out/bpmnlint/engine/rules/c8/C8LinkedResourceNeedsTypeRule.ts
new file mode 100644
index 00000000..9eb1bb34
--- /dev/null
+++ b/src/adapters/out/bpmnlint/engine/rules/c8/C8LinkedResourceNeedsTypeRule.ts
@@ -0,0 +1,21 @@
+import { defineRule, ERROR_TYPES } from '../CamundaRule.js';
+import { type BindingSite, C8BindingRule } from './C8BindingRule.js';
+import type { C8Host } from './support/C8Host.js';
+
+/**
+ * A linked resource without resource type.
+ * Camunda 8 cannot tell what the resource is and refuses the file.
+ *
+ * @example a linked resource without type
+ * <zeebe:linkedResources><zeebe:linkedResource linkName="tools" resourceId="toolbox" /></zeebe:linkedResources>  <!-- resourceType="RPA" -->
+ */
+class C8LinkedResourceNeedsTypeRule extends C8BindingRule {
+  protected checkBinding(host: C8Host, { element, subject, path, hint, linked }: BindingSite): void {
+    if (!linked || (element.resourceType !== undefined && element.resourceType !== '')) {
+      return;
+    }
+    this.reportOn(host, `${subject} has no resourceType; Camunda 8 refuses the file`, { path: path('resourceType'), type: ERROR_TYPES.PROPERTY_REQUIRED, node: element, requiredProperty: 'resourceType', hint: hint({}) });
+  }
+}
+
+export default defineRule({ ruleName: 'c8-linked-resource-needs-type', code: 'W_C8_DEPLOY_EXTENSION', impact: 'deploy' }, C8LinkedResourceNeedsTypeRule);
diff --git a/src/adapters/out/bpmnlint/engine/rules/c8/C8ListenerEventTypeRule.ts b/src/adapters/out/bpmnlint/engine/rules/c8/C8ListenerEventTypeRule.ts
new file mode 100644
index 00000000..5e9a66bd
--- /dev/null
+++ b/src/adapters/out/bpmnlint/engine/rules/c8/C8ListenerEventTypeRule.ts
@@ -0,0 +1,40 @@
+import { ERROR_TYPES, type ModdleElement } from '../CamundaRule.js';
+import { C8HostRule } from './C8HostRule.js';
+import type { C8Host } from './support/C8Host.js';
+
+/**
+ * The listeners of one zeebe listener list an element reads, for the rules on their event type
+ * (`C8ExecutionListenerEventTypeValidRule`, `C8TaskListenerEventTypeValidRule`): a finding is
+ * reported on the event type, and its fix rebuilds the listener in its list.
+ * Camunda 8 refuses a listener without event type or with one it does not run there.
+ *
+ * @example an execution listener without event type
+ * <zeebe:executionListeners><zeebe:executionListener type="audit" /></zeebe:executionListeners>  <!-- eventType="start" -->
+ */
+export abstract class C8ListenerEventTypeRule extends C8HostRule {
+  /** The zeebe list this rule checks (`zeebe:executionListeners`). */
+  protected abstract readonly list: string;
+
+  protected checkHost(host: C8Host): void {
+    for (const { value, index, type, placement } of host.zeebeValues()) {
+      if (placement === 'read' && type.name === this.list) {
+        this.checkListeners(host, value, index);
+      }
+    }
+  }
+
+  protected abstract checkListeners(host: C8Host, value: ModdleElement, index: number): void;
+
+  protected reportEventType(host: C8Host, listener: ModdleElement, index: number, listenerIndex: number, message: string, hint: string, missing = false): void {
+    const path = host.extensionPath(index, 'listeners', listenerIndex, 'eventType');
+    this.reportOn(host, message, missing ? { path, type: ERROR_TYPES.PROPERTY_REQUIRED, node: listener, requiredProperty: 'eventType', hint } : { path, type: ERROR_TYPES.PROPERTY_VALUE_NOT_ALLOWED, node: listener, property: 'eventType', hint });
+  }
+
+  /** `<lead>: <remove the listener>, then <add it again with fix>`: the listener is rebuilt in its list (`zeebe:taskListeners/zeebe:taskListener[0]`). */
+  protected rebuildListenerHint(host: C8Host, listenerLocal: 'executionListener' | 'taskListener', listenerIndex: number, lead: string, fix: string): string {
+    const hint = host.hint();
+    if (!hint) return `${lead}: remove it from the XML, then edit the XML.`;
+    const listener = `${hint.name(`${listenerLocal}s`)}/${hint.name(listenerLocal)}`;
+    return `${lead}: ${hint.extRemove(`${listener}[${listenerIndex}]`)}, then ${hint.extAdd(`${listener} ${fix}`)}.`;
+  }
+}
diff --git a/src/adapters/out/bpmnlint/engine/rules/c8/C8MessageStartNeedsStaticNameRule.ts b/src/adapters/out/bpmnlint/engine/rules/c8/C8MessageStartNeedsStaticNameRule.ts
new file mode 100644
index 00000000..814610c6
--- /dev/null
+++ b/src/adapters/out/bpmnlint/engine/rules/c8/C8MessageStartNeedsStaticNameRule.ts
@@ -0,0 +1,22 @@
+import { is } from 'bpmnlint-utils';
+import { defineRule, type ModdleElement } from '../CamundaRule.js';
+import { C8StartNameRule } from './C8StartNameRule.js';
+
+/**
+ * A process start event whose message name is a FEEL expression.
+ * Camunda 8 subscribes to a process start message at deploy, before any variable exists, and
+ * refuses the file.
+ *
+ * @example a message start event with a FEEL name
+ * <bpmn:message id="Order" name="=orderMessage" />  <!-- a static name -->
+ */
+class C8MessageStartNeedsStaticNameRule extends C8StartNameRule {
+  protected readonly trigger = 'message';
+  protected readonly starts = 'process start events';
+
+  protected applies(start: ModdleElement): boolean {
+    return is(start.$parent, 'bpmn:Process');
+  }
+}
+
+export default defineRule({ ruleName: 'c8-message-start-needs-static-name', code: 'W_C8_DEPLOY_MESSAGE', impact: 'deploy' }, C8MessageStartNeedsStaticNameRule);
diff --git a/src/adapters/out/bpmnlint/engine/rules/c8/C8MessageSubscriptionUniqueRule.ts b/src/adapters/out/bpmnlint/engine/rules/c8/C8MessageSubscriptionUniqueRule.ts
new file mode 100644
index 00000000..eb02a339
--- /dev/null
+++ b/src/adapters/out/bpmnlint/engine/rules/c8/C8MessageSubscriptionUniqueRule.ts
@@ -0,0 +1,30 @@
+import { is } from 'bpmnlint-utils';
+import { defineRule, type ModdleElement } from '../CamundaRule.js';
+import type { C8SubscriptionGroups } from './support/C8SubscriptionGroups.js';
+import { C8SubscriptionUniqueRule } from './C8SubscriptionUniqueRule.js';
+
+/**
+ * One static message name twice among the boundary events and receive task of an activity, the
+ * branches of an event-based gateway, the event sub-process starts of a scope or the process start
+ * events.
+ * Camunda 8 cannot tell which of them a message is for and refuses the file.
+ *
+ * @example two boundary events of one task waiting for the same message
+ * <bpmn:boundaryEvent attachedToRef="Pay"><bpmn:messageEventDefinition messageRef="Cancel" /></bpmn:boundaryEvent>
+ * <bpmn:boundaryEvent attachedToRef="Pay"><bpmn:messageEventDefinition messageRef="Cancel" /></bpmn:boundaryEvent>  <!-- same message -->
+ */
+class C8MessageSubscriptionUniqueRule extends C8SubscriptionUniqueRule {
+  protected checkScope(groups: C8SubscriptionGroups, scope: ModdleElement): void {
+    const note = ' (and a zeebe:subscription on it)';
+    for (const { activity, boundaries } of groups.boundaryGroups) {
+      this.reportNamed('message', is(activity, 'bpmn:ReceiveTask') ? [activity, ...boundaries] : boundaries, `on ${activity.id}`, note);
+    }
+    for (const { gateway, targets } of groups.gatewayTargets) {
+      this.reportNamed('message', targets, `after event-based gateway ${gateway.id}`, note);
+    }
+    this.reportNamed('message', groups.eventSubProcessStarts, `in the event sub-processes of ${scope.id}`, note);
+    this.reportNamed('message', groups.processStarts, `in process ${scope.id}`, note);
+  }
+}
+
+export default defineRule({ ruleName: 'c8-message-subscription-unique', code: 'W_C8_DEPLOY_MESSAGE', impact: 'deploy' }, C8MessageSubscriptionUniqueRule);
diff --git a/src/adapters/out/bpmnlint/engine/rules/c8/C8MultiInstanceCompletionNeedsFeelRule.ts b/src/adapters/out/bpmnlint/engine/rules/c8/C8MultiInstanceCompletionNeedsFeelRule.ts
new file mode 100644
index 00000000..e869c706
--- /dev/null
+++ b/src/adapters/out/bpmnlint/engine/rules/c8/C8MultiInstanceCompletionNeedsFeelRule.ts
@@ -0,0 +1,30 @@
+import { is } from 'bpmnlint-utils';
+import { C8Rule, defineRule, ERROR_TYPES, type ModdleElement } from '../CamundaRule.js';
+import { ElementKinds } from '../support/ElementKinds.js';
+import { EngineScope } from '../support/EngineScope.js';
+import { Shell } from '../support/Shell.js';
+import { Values } from '../support/Values.js';
+import { FeelExpression } from './support/feel/FeelExpression.js';
+
+/**
+ * A multi-instance completion condition that is no FEEL expression.
+ * Camunda 8 deploys it, then reads the condition as a string and raises an incident on every
+ * completed instance (expected a boolean, got a string).
+ *
+ * @example a Camunda 7 (JUEL) completion condition
+ * <bpmn:multiInstanceLoopCharacteristics>
+ *   <bpmn:completionCondition>${nrOfCompletedInstances == 2}</bpmn:completionCondition>  <!-- =nrOfCompletedInstances = 2 -->
+ * </bpmn:multiInstanceLoopCharacteristics>
+ */
+class C8MultiInstanceCompletionNeedsFeelRule extends C8Rule {
+  protected visit(node: ModdleElement): void {
+    const loop = is(node, 'bpmn:Activity') && !is(node, 'bpmn:Transaction') ? node.loopCharacteristics : undefined;
+    const condition = loop && is(loop, 'bpmn:MultiInstanceLoopCharacteristics') ? loop.completionCondition : undefined;
+    if (!condition || Values.isFeel(condition.body) || !EngineScope.C8.runs(node)) {
+      return;
+    }
+    this.report(node, `The completion condition "${condition.body ?? ''}" of multi-instance ${ElementKinds.describe(node)} is no FEEL expression (=...); it deploys, but every completed instance gets an incident (expected a boolean, got a string)`, { path: ['loopCharacteristics', 'completionCondition'], type: ERROR_TYPES.EXPRESSION_REQUIRED, node: loop, property: 'completionCondition', hint: `\`bpmn set <file> ${node.id} ${Shell.quote(`completion==${FeelExpression.fromJuel(condition.body ?? '')}`)}\` (check the FEEL syntax).` });
+  }
+}
+
+export default defineRule({ ruleName: 'c8-multi-instance-completion-needs-feel', code: 'W_C8_EXPRESSION', impact: 'runtime' }, C8MultiInstanceCompletionNeedsFeelRule);
diff --git a/src/adapters/out/bpmnlint/engine/rules/c8/C8MultiInstanceNeedsFeelRule.ts b/src/adapters/out/bpmnlint/engine/rules/c8/C8MultiInstanceNeedsFeelRule.ts
new file mode 100644
index 00000000..5f32ef8a
--- /dev/null
+++ b/src/adapters/out/bpmnlint/engine/rules/c8/C8MultiInstanceNeedsFeelRule.ts
@@ -0,0 +1,39 @@
+import { is } from 'bpmnlint-utils';
+import { defineRule, ERROR_TYPES, type ModdleElement } from '../CamundaRule.js';
+import { ElementKinds } from '../support/ElementKinds.js';
+import { Values } from '../support/Values.js';
+import { C8FeelRule } from './C8FeelRule.js';
+import { C8Host } from './support/C8Host.js';
+import { ZeebeHint } from './support/ZeebeHint.js';
+
+/**
+ * A multi-instance input collection, or an output element next to an output collection, that is a
+ * static value.
+ * Camunda 8 reads both as FEEL expressions and refuses the file.
+ *
+ * @example a static input collection
+ * <bpmn:multiInstanceLoopCharacteristics>
+ *   <bpmn:extensionElements><zeebe:loopCharacteristics inputCollection="items" /></bpmn:extensionElements>  <!-- =items -->
+ * </bpmn:multiInstanceLoopCharacteristics>
+ */
+class C8MultiInstanceNeedsFeelRule extends C8FeelRule {
+  protected visit(activity: ModdleElement): void {
+    if (!this.runs(activity) || !is(activity, 'bpmn:Activity')) return;
+    const loop = activity.loopCharacteristics;
+    if (!loop || !is(loop, 'bpmn:MultiInstanceLoopCharacteristics')) return;
+    const [zeebeLoop] = C8Host.valuesOf(loop, 'zeebe:LoopCharacteristics');
+    if (zeebeLoop && Values.nonEmpty(zeebeLoop.inputCollection) && !Values.isFeel(zeebeLoop.inputCollection)) {
+      this.reportStatic(activity, zeebeLoop, 'inputCollection');
+    }
+    if (zeebeLoop && zeebeLoop.outputCollection !== undefined && zeebeLoop.outputElement !== undefined && !Values.isFeel(zeebeLoop.outputElement)) {
+      this.reportStatic(activity, zeebeLoop, 'outputElement');
+    }
+  }
+
+  private reportStatic(activity: ModdleElement, zeebeLoop: ModdleElement, property: string): void {
+    const value: string = zeebeLoop[property];
+    this.reportAt(this.siteOf(activity, zeebeLoop, property), `${property}="${value}" of multi-instance ${ElementKinds.describe(activity)} is a static value; Camunda 8 needs a FEEL expression (=${value.trim()}) and refuses the file`, ERROR_TYPES.EXPRESSION_REQUIRED, ZeebeHint.fix(activity.loopCharacteristics, zeebeLoop, { [property]: `=${value.trim()}` }));
+  }
+}
+
+export default defineRule({ ruleName: 'c8-multi-instance-needs-feel', code: 'W_C8_DEPLOY_EXPRESSION', impact: 'deploy' }, C8MultiInstanceNeedsFeelRule);
diff --git a/src/adapters/out/bpmnlint/engine/rules/c8/C8NoCamunda7ContentRule.ts b/src/adapters/out/bpmnlint/engine/rules/c8/C8NoCamunda7ContentRule.ts
new file mode 100644
index 00000000..352eda40
--- /dev/null
+++ b/src/adapters/out/bpmnlint/engine/rules/c8/C8NoCamunda7ContentRule.ts
@@ -0,0 +1,59 @@
+import { defineRule, ERROR_TYPES } from '../CamundaRule.js';
+import { C7_URIS, DiagramNamespaces } from '../support/DiagramNamespaces.js';
+import { C8HostRule } from './C8HostRule.js';
+import type { C8Host } from './support/C8Host.js';
+import type { ZeebeHint } from './support/ZeebeHint.js';
+
+/** The zeebe content Camunda 8 reads in place of a Camunda 7 attribute or element, as `bpmn ext add` takes it. */
+const CAMUNDA_8_EQUIVALENT: Record<string, string> = {
+  assignee: 'assignmentDefinition assignee=<assignee>',
+  candidateGroups: 'assignmentDefinition candidateGroups=<groups>',
+  candidateUsers: 'assignmentDefinition candidateUsers=<users>',
+  dueDate: 'taskSchedule dueDate=<date>',
+  followUpDate: 'taskSchedule followUpDate=<date>',
+  priority: 'priorityDefinition priority=<0..100>',
+  formKey: 'formDefinition formId=<formId>',
+  topic: 'taskDefinition type=<jobType>',
+  type: 'taskDefinition type=<jobType>',
+  class: 'taskDefinition type=<jobType>',
+  delegateExpression: 'taskDefinition type=<jobType>',
+  expression: 'taskDefinition type=<jobType>',
+  decisionRef: 'calledDecision decisionId=<decisionId> resultVariable=<variable>',
+  inputOutput: 'input source==<expression> target=<variable>',
+  versionTag: 'versionTag value=<tag>',
+};
+
+/**
+ * Camunda 7 content in a Camunda 8 model: camunda and operaton attributes and extension elements.
+ * Camunda 8 deploys the file and silently ignores them, so the process runs without the behaviour
+ * the model seems to configure.
+ *
+ * @example a Camunda 7 assignee in a Camunda 8 model
+ * <bpmn:userTask id="Review" camunda:assignee="demo" />  <!-- Camunda 8 reads zeebe:assignmentDefinition -->
+ */
+class C8NoCamunda7ContentRule extends C8HostRule {
+  protected checkHost(host: C8Host): void {
+    const hint = host.hint();
+    for (const { key, uri } of host.foreignAttributes()) {
+      if (C7_URIS.includes(uri ?? '')) {
+        this.reportContent(host, `${host.describe()} carries the Camunda 7 attribute ${key}, which Camunda 8 ignores`, { type: ERROR_TYPES.PROPERTY_NOT_ALLOWED, property: key, path: host.path(key), hint: this.removeHint(hint, key, hint ? hint.unset(key) : 'edit the XML') });
+      }
+    }
+    const namespaces = DiagramNamespaces.forElement(host.node);
+    host.extensionValues().forEach((value, index) => {
+      const type = String(value.$type ?? '');
+      if (value.$descriptor?.isGeneric && C7_URIS.includes(namespaces.uriOf(type) ?? '')) {
+        this.reportContent(host, `${host.describe()} contains the Camunda 7 extension ${type}, which Camunda 8 ignores`, { type: ERROR_TYPES.EXTENSION_ELEMENT_NOT_ALLOWED, extensionElement: value, path: host.extensionPath(index), hint: this.removeHint(hint, type, hint ? hint.extRemove(index) : 'remove it from the XML') });
+      }
+    });
+  }
+
+  /** `Remove it: <remove>`, and the zeebe content Camunda 8 reads instead, if there is one. */
+  private removeHint(hint: ZeebeHint | undefined, name: string, remove: string): string {
+    const equivalent = CAMUNDA_8_EQUIVALENT[name.slice(name.indexOf(':') + 1)];
+    if (!equivalent) return `Remove it: ${remove}.`;
+    return `Remove it: ${remove}; Camunda 8 reads ${hint ? hint.extAdd(hint.name(equivalent)) : 'edit the XML'}.`;
+  }
+}
+
+export default defineRule({ ruleName: 'c8-no-camunda-7-content', code: 'W_C8_FOREIGN_CONTENT', impact: 'runtime' }, C8NoCamunda7ContentRule);
diff --git a/src/adapters/out/bpmnlint/engine/rules/c8/C8PublishMessageNeedsCorrelationKeyRule.ts b/src/adapters/out/bpmnlint/engine/rules/c8/C8PublishMessageNeedsCorrelationKeyRule.ts
new file mode 100644
index 00000000..93194635
--- /dev/null
+++ b/src/adapters/out/bpmnlint/engine/rules/c8/C8PublishMessageNeedsCorrelationKeyRule.ts
@@ -0,0 +1,24 @@
+import { defineRule, ERROR_TYPES } from '../CamundaRule.js';
+import { C8PublishMessageRule, type Publish } from './C8PublishMessageRule.js';
+
+/**
+ * A zeebe:publishMessage without correlationKey (one next to a zeebe:taskDefinition is the
+ * implementation rule's).
+ * Camunda 8 cannot tell which instance the message is for and refuses the file.
+ *
+ * @example a published message without correlation key
+ * <bpmn:sendTask id="Notify" messageRef="Message_Order">
+ *   <bpmn:extensionElements><zeebe:publishMessage /></bpmn:extensionElements>  <!-- correlationKey="=orderId" -->
+ * </bpmn:sendTask>
+ */
+class C8PublishMessageNeedsCorrelationKeyRule extends C8PublishMessageRule {
+  protected checkPublish({ node, publish, id, writtenAt, label, name, slot, withTaskDefinition }: Publish): void {
+    const correlationKey: string | undefined = publish.correlationKey;
+    if (withTaskDefinition || (correlationKey !== undefined && correlationKey !== '')) {
+      return;
+    }
+    this.report(node, `The ${name} of ${label} has no correlationKey; Camunda 8 refuses the file`, { path: null, type: ERROR_TYPES.PROPERTY_REQUIRED, writtenAt, subject: 'publish:correlationKey', hint: `\`bpmn ext add <file> ${id} ${slot}${name} correlationKey==<expression>\`.` });
+  }
+}
+
+export default defineRule({ ruleName: 'c8-publish-message-needs-correlation-key', code: 'W_C8_DEPLOY_MESSAGE', impact: 'deploy' }, C8PublishMessageNeedsCorrelationKeyRule);
diff --git a/src/adapters/out/bpmnlint/engine/rules/c8/C8PublishMessageNeedsMessageRule.ts b/src/adapters/out/bpmnlint/engine/rules/c8/C8PublishMessageNeedsMessageRule.ts
new file mode 100644
index 00000000..658df3a4
--- /dev/null
+++ b/src/adapters/out/bpmnlint/engine/rules/c8/C8PublishMessageNeedsMessageRule.ts
@@ -0,0 +1,21 @@
+import { defineRule, ERROR_TYPES } from '../CamundaRule.js';
+import { C8PublishMessageRule, type Publish } from './C8PublishMessageRule.js';
+
+/**
+ * A zeebe:publishMessage whose send task or message definition references no message (one next to
+ * a zeebe:taskDefinition is the implementation rule's).
+ * Camunda 8 has no message to publish and refuses the file.
+ *
+ * @example a send task that publishes no message
+ * <bpmn:sendTask id="Notify">  <!-- no messageRef -->
+ *   <bpmn:extensionElements><zeebe:publishMessage correlationKey="=orderId" /></bpmn:extensionElements>
+ * </bpmn:sendTask>
+ */
+class C8PublishMessageNeedsMessageRule extends C8PublishMessageRule {
+  protected checkPublish({ node, host, id, writtenAt, label, withTaskDefinition }: Publish): void {
+    if (withTaskDefinition || host.messageRef) return;
+    this.report(node, `${label} publishes no message (no message reference); Camunda 8 refuses the file`, { path: null, type: ERROR_TYPES.PROPERTY_REQUIRED, writtenAt, subject: 'publish:messageRef', hint: `\`bpmn set <file> ${id} message=<MessageName>\`.` });
+  }
+}
+
+export default defineRule({ ruleName: 'c8-publish-message-needs-message', code: 'W_C8_DEPLOY_MESSAGE', impact: 'deploy' }, C8PublishMessageNeedsMessageRule);
diff --git a/src/adapters/out/bpmnlint/engine/rules/c8/C8PublishMessageNoTaskDefinitionRule.ts b/src/adapters/out/bpmnlint/engine/rules/c8/C8PublishMessageNoTaskDefinitionRule.ts
new file mode 100644
index 00000000..d6eb61ab
--- /dev/null
+++ b/src/adapters/out/bpmnlint/engine/rules/c8/C8PublishMessageNoTaskDefinitionRule.ts
@@ -0,0 +1,21 @@
+import { defineRule, ERROR_TYPES } from '../CamundaRule.js';
+import { C8PublishMessageRule, type Publish } from './C8PublishMessageRule.js';
+
+/**
+ * A zeebe:publishMessage next to a zeebe:taskDefinition.
+ * Camunda 8 needs exactly one implementation of a send task or message throw event and refuses
+ * the file.
+ *
+ * @example a send task with a job worker and a published message
+ * <bpmn:sendTask id="Notify" messageRef="Message_Order">
+ *   <bpmn:extensionElements><zeebe:taskDefinition type="notify" /><zeebe:publishMessage correlationKey="=orderId" /></bpmn:extensionElements>  <!-- keep one -->
+ * </bpmn:sendTask>
+ */
+class C8PublishMessageNoTaskDefinitionRule extends C8PublishMessageRule {
+  protected checkPublish({ node, id, writtenAt, label, name, slot, withTaskDefinition }: Publish, prefix: string): void {
+    if (!withTaskDefinition) return;
+    this.report(node, `${label} has both a ${prefix}:taskDefinition and a ${name}; Camunda 8 needs exactly one of them and refuses the file`, { path: null, type: ERROR_TYPES.EXTENSION_ELEMENT_NOT_ALLOWED, writtenAt, subject: 'impl:both', hint: `Keep one: \`bpmn ext remove <file> ${id} ${prefix}:taskDefinition\` (or \`bpmn ext remove <file> ${id} ${slot}${name}\`).` });
+  }
+}
+
+export default defineRule({ ruleName: 'c8-publish-message-no-task-definition', code: 'W_C8_DEPLOY_IMPLEMENTATION', impact: 'deploy' }, C8PublishMessageNoTaskDefinitionRule);
diff --git a/src/adapters/out/bpmnlint/engine/rules/c8/C8PublishMessageRule.ts b/src/adapters/out/bpmnlint/engine/rules/c8/C8PublishMessageRule.ts
new file mode 100644
index 00000000..552ecfae
--- /dev/null
+++ b/src/adapters/out/bpmnlint/engine/rules/c8/C8PublishMessageRule.ts
@@ -0,0 +1,70 @@
+import { is } from 'bpmnlint-utils';
+import { C8Rule, type ModdleElement } from '../CamundaRule.js';
+import { RuleKit } from '../RuleKit.js';
+import { ElementKinds } from '../support/ElementKinds.js';
+import { EngineScope } from '../support/EngineScope.js';
+import { WrittenModel } from '../support/WrittenModel.js';
+
+/** A zeebe:publishMessage as the file writes it, with what a finding about it names. */
+export interface Publish {
+  /** the typed element the finding goes on */
+  node: ModdleElement;
+  /** the send task or the message definition that holds the zeebe:publishMessage */
+  host: ModdleElement;
+  publish: ModdleElement;
+  id: string;
+  writtenAt: number;
+  label: string;
+  name: string;
+  slot: string;
+  withTaskDefinition: boolean;
+  send: boolean;
+}
+
+/**
+ * `zeebe:publishMessage` on a send task or a message throw or end event, which Camunda 8.9 checks
+ * but does not run, for the rules on it (`C8PublishMessageNoTaskDefinitionRule`,
+ * `C8PublishMessageNeedsMessageRule`, `C8PublishMessageNeedsCorrelationKeyRule`,
+ * `C8PublishMessageUnsupportedRule`).
+ * zeebe-bpmn-moddle does not define it, so the typed parse drops it and camunda-compat reports its
+ * send task as one without an implementation (the engine run drops that report): the rules read
+ * the extension elements as the file writes them.
+ *
+ * @example a send task that publishes its message
+ * <bpmn:sendTask id="Notify" messageRef="Message_Order">
+ *   <bpmn:extensionElements><zeebe:publishMessage correlationKey="=orderId" /></bpmn:extensionElements>
+ * </bpmn:sendTask>
+ */
+export abstract class C8PublishMessageRule extends C8Rule {
+  private model!: WrittenModel;
+  private prefix = 'zeebe';
+
+  protected visit(node: ModdleElement): boolean | void {
+    if (is(node, 'bpmn:Definitions')) return;
+    if (!EngineScope.inExecutableProcess(node)) return false;
+    const model = WrittenModel.of(node);
+    const el = model?.written(node);
+    if (!el) return;
+    this.model = model!;
+    this.prefix = this.model.file.namespaces.prefixOf(RuleKit.kit.ZEEBE.uri) ?? 'zeebe';
+    if (is(el, 'bpmn:SendTask')) {
+      this.checkHost(node, el, el);
+    } else if (is(el, 'bpmn:IntermediateThrowEvent') || is(el, 'bpmn:EndEvent')) {
+      const definition = (el.eventDefinitions ?? []).find((candidate: ModdleElement) => is(candidate, 'bpmn:MessageEventDefinition'));
+      if (definition) this.checkHost(node, el, definition);
+    }
+  }
+
+  private checkHost(node: ModdleElement, el: ModdleElement, host: ModdleElement): void {
+    const publish = this.zeebe(host, 'publishMessage')[0];
+    if (!publish) return;
+    const name = `${this.prefix}:publishMessage`;
+    this.checkPublish({ node, host, publish, id: el.id, writtenAt: this.model.position(el), label: ElementKinds.describe(el), name, slot: host === el ? '' : 'definition.', withTaskDefinition: this.zeebe(el, 'taskDefinition').length > 0, send: is(el, 'bpmn:SendTask') }, this.prefix);
+  }
+
+  protected abstract checkPublish(publish: Publish, prefix: string): void;
+
+  private zeebe(el: ModdleElement, local: string): ModdleElement[] {
+    return (el.extensionElements?.values ?? []).filter((value: ModdleElement) => this.model.file.namespaces.uriOfElement(value) === RuleKit.kit.ZEEBE.uri && value.$type.slice(value.$type.indexOf(':') + 1) === local);
+  }
+}
diff --git a/src/adapters/out/bpmnlint/engine/rules/c8/C8PublishMessageUnsupportedRule.ts b/src/adapters/out/bpmnlint/engine/rules/c8/C8PublishMessageUnsupportedRule.ts
new file mode 100644
index 00000000..87577fda
--- /dev/null
+++ b/src/adapters/out/bpmnlint/engine/rules/c8/C8PublishMessageUnsupportedRule.ts
@@ -0,0 +1,22 @@
+import { defineRule, ERROR_TYPES } from '../CamundaRule.js';
+import { C8PublishMessageRule, type Publish } from './C8PublishMessageRule.js';
+
+/**
+ * A zeebe:publishMessage that Camunda 8.9 deploys and does not run (one next to a
+ * zeebe:taskDefinition is the implementation rule's).
+ * A send task gets an incident, as only job worker send tasks are supported; a message throw or
+ * end event completes without sending anything.
+ *
+ * @example a send task that publishes its message
+ * <bpmn:sendTask id="Notify" messageRef="Message_Order">
+ *   <bpmn:extensionElements><zeebe:publishMessage correlationKey="=orderId" /></bpmn:extensionElements>  <!-- zeebe:taskDefinition -->
+ * </bpmn:sendTask>
+ */
+class C8PublishMessageUnsupportedRule extends C8PublishMessageRule {
+  protected checkPublish({ node, id, writtenAt, label, name, slot, withTaskDefinition, send }: Publish, prefix: string): void {
+    if (withTaskDefinition) return;
+    this.report(node, `${label} publishes its message with ${name}: Camunda 8.9 accepts the file but does not run it (${send ? 'the instance gets an incident: only job worker send tasks are supported' : 'the event completes without sending anything'})`, { path: null, type: ERROR_TYPES.EXTENSION_ELEMENT_NOT_ALLOWED, writtenAt, subject: 'publishMessage', hint: `Use a job worker: \`bpmn ext remove <file> ${id} ${slot}${name}\`, then \`bpmn ext add <file> ${id} ${prefix}:taskDefinition type=<jobType>\`.` });
+  }
+}
+
+export default defineRule({ ruleName: 'c8-publish-message-unsupported', code: 'W_C8_UNSUPPORTED_IMPLEMENTATION', impact: 'runtime' }, C8PublishMessageUnsupportedRule);
diff --git a/src/adapters/out/bpmnlint/engine/rules/c8/C8ScriptNeedsFeelRule.ts b/src/adapters/out/bpmnlint/engine/rules/c8/C8ScriptNeedsFeelRule.ts
new file mode 100644
index 00000000..689e4235
--- /dev/null
+++ b/src/adapters/out/bpmnlint/engine/rules/c8/C8ScriptNeedsFeelRule.ts
@@ -0,0 +1,30 @@
+import { is } from 'bpmnlint-utils';
+import { defineRule, ERROR_TYPES, type ModdleElement } from '../CamundaRule.js';
+import { C8FeelRule } from './C8FeelRule.js';
+import { ElementKinds } from '../support/ElementKinds.js';
+import { Values } from '../support/Values.js';
+import { C8Host } from './support/C8Host.js';
+import { ZeebeHint } from './support/ZeebeHint.js';
+
+/**
+ * The zeebe:script expression of a script task without job worker that is a static value.
+ * Camunda 8 evaluates the script as a FEEL expression and refuses the file.
+ *
+ * @example a static script expression
+ * <bpmn:scriptTask id="Total">
+ *   <bpmn:extensionElements><zeebe:script expression="a + b" resultVariable="total" /></bpmn:extensionElements>  <!-- =a + b -->
+ * </bpmn:scriptTask>
+ */
+class C8ScriptNeedsFeelRule extends C8FeelRule {
+  protected visit(task: ModdleElement): void {
+    if (!this.runs(task) || !is(task, 'bpmn:ScriptTask')) return;
+    const [script] = C8Host.valuesOf(task, 'zeebe:Script');
+    const expression = script?.expression;
+    if (!script || C8Host.valuesOf(task, 'zeebe:TaskDefinition').length || !Values.nonEmpty(expression) || Values.isFeel(expression)) {
+      return;
+    }
+    this.reportAt(this.siteOf(task, script, 'expression'), `The zeebe:script expression "${expression}" of ${ElementKinds.describe(task)} is a static value; Camunda 8 needs a FEEL expression starting with = and refuses the file`, ERROR_TYPES.EXPRESSION_REQUIRED, ZeebeHint.fix(task, script, { expression: `=${expression.trim()}` }));
+  }
+}
+
+export default defineRule({ ruleName: 'c8-script-needs-feel', code: 'W_C8_DEPLOY_EXPRESSION', impact: 'deploy' }, C8ScriptNeedsFeelRule);
diff --git a/src/adapters/out/bpmnlint/engine/rules/c8/C8SequenceFlowNoExecutionListenersRule.ts b/src/adapters/out/bpmnlint/engine/rules/c8/C8SequenceFlowNoExecutionListenersRule.ts
new file mode 100644
index 00000000..acdfcde1
--- /dev/null
+++ b/src/adapters/out/bpmnlint/engine/rules/c8/C8SequenceFlowNoExecutionListenersRule.ts
@@ -0,0 +1,26 @@
+import { defineRule, ERROR_TYPES } from '../CamundaRule.js';
+import { C8HostRule } from './C8HostRule.js';
+import type { C8Host } from './support/C8Host.js';
+
+/**
+ * Execution listeners on a sequence flow.
+ * Camunda 8 supports execution listeners on processes, activities, events and gateways only and
+ * refuses the file.
+ *
+ * @example execution listeners on a flow
+ * <bpmn:sequenceFlow id="ToShip" sourceRef="Pack" targetRef="Ship">
+ *   <bpmn:extensionElements><zeebe:executionListeners>...</zeebe:executionListeners></bpmn:extensionElements>
+ * </bpmn:sequenceFlow>
+ */
+class C8SequenceFlowNoExecutionListenersRule extends C8HostRule {
+  protected checkHost(host: C8Host): void {
+    const hint = host.hint();
+    for (const { value, index, placement } of host.zeebeValues()) {
+      if (placement === 'flowListeners') {
+        this.reportOn(host, `${host.describe()} has execution listeners; Camunda 8 supports them on processes, activities, events and gateways, not on sequence flows, and refuses the file`, { path: host.extensionPath(index), type: ERROR_TYPES.EXTENSION_ELEMENT_NOT_ALLOWED, node: host.node, extensionElement: value, hint: `Remove them (${hint ? hint.extRemove(index) : 'remove it from the XML'}) and put them on the flow's source or target.` });
+      }
+    }
+  }
+}
+
+export default defineRule({ ruleName: 'c8-sequence-flow-no-execution-listeners', code: 'W_C8_DEPLOY_LISTENER', impact: 'deploy' }, C8SequenceFlowNoExecutionListenersRule);
diff --git a/src/adapters/out/bpmnlint/engine/rules/c8/C8SignalStartNeedsStaticNameRule.ts b/src/adapters/out/bpmnlint/engine/rules/c8/C8SignalStartNeedsStaticNameRule.ts
new file mode 100644
index 00000000..ee5b9ac7
--- /dev/null
+++ b/src/adapters/out/bpmnlint/engine/rules/c8/C8SignalStartNeedsStaticNameRule.ts
@@ -0,0 +1,21 @@
+import { defineRule } from '../CamundaRule.js';
+import { C8StartNameRule } from './C8StartNameRule.js';
+
+/**
+ * A start event whose signal name is a FEEL expression.
+ * Camunda 8 subscribes to a start signal at deploy, before any variable exists, and refuses the
+ * file.
+ *
+ * @example a signal start event with a FEEL name
+ * <bpmn:signal id="Go" name="=signalName" />  <!-- a static name -->
+ */
+class C8SignalStartNeedsStaticNameRule extends C8StartNameRule {
+  protected readonly trigger = 'signal';
+  protected readonly starts = 'start events';
+
+  protected applies(): boolean {
+    return true;
+  }
+}
+
+export default defineRule({ ruleName: 'c8-signal-start-needs-static-name', code: 'W_C8_DEPLOY_SIGNAL', impact: 'deploy' }, C8SignalStartNeedsStaticNameRule);
diff --git a/src/adapters/out/bpmnlint/engine/rules/c8/C8SignalSubscriptionUniqueRule.ts b/src/adapters/out/bpmnlint/engine/rules/c8/C8SignalSubscriptionUniqueRule.ts
new file mode 100644
index 00000000..8492ca7a
--- /dev/null
+++ b/src/adapters/out/bpmnlint/engine/rules/c8/C8SignalSubscriptionUniqueRule.ts
@@ -0,0 +1,23 @@
+import { defineRule, type ModdleElement } from '../CamundaRule.js';
+import type { C8SubscriptionGroups } from './support/C8SubscriptionGroups.js';
+import { C8SubscriptionUniqueRule } from './C8SubscriptionUniqueRule.js';
+
+/**
+ * One static signal name twice among the boundary events of an activity or the process start
+ * events.
+ * Camunda 8 cannot tell which of them a signal is for and refuses the file.
+ *
+ * @example two process start events waiting for the same signal
+ * <bpmn:startEvent id="A"><bpmn:signalEventDefinition signalRef="Go" /></bpmn:startEvent>
+ * <bpmn:startEvent id="B"><bpmn:signalEventDefinition signalRef="Go" /></bpmn:startEvent>  <!-- same signal -->
+ */
+class C8SignalSubscriptionUniqueRule extends C8SubscriptionUniqueRule {
+  protected checkScope(groups: C8SubscriptionGroups, scope: ModdleElement): void {
+    for (const { activity, boundaries } of groups.boundaryGroups) {
+      this.reportNamed('signal', boundaries, `on ${activity.id}`, '');
+    }
+    this.reportNamed('signal', groups.processStarts, `in process ${scope.id}`, '');
+  }
+}
+
+export default defineRule({ ruleName: 'c8-signal-subscription-unique', code: 'W_C8_DEPLOY_SIGNAL', impact: 'deploy' }, C8SignalSubscriptionUniqueRule);
diff --git a/src/adapters/out/bpmnlint/engine/rules/c8/C8StartNameRule.ts b/src/adapters/out/bpmnlint/engine/rules/c8/C8StartNameRule.ts
new file mode 100644
index 00000000..41d812dc
--- /dev/null
+++ b/src/adapters/out/bpmnlint/engine/rules/c8/C8StartNameRule.ts
@@ -0,0 +1,36 @@
+import { is } from 'bpmnlint-utils';
+import { C8Rule, ERROR_TYPES, type ModdleElement } from '../CamundaRule.js';
+import { EngineScope } from '../support/EngineScope.js';
+import { Values } from '../support/Values.js';
+import { C8EventDefinitions } from './support/C8EventDefinitions.js';
+
+/**
+ * A start event Camunda 8 runs that waits for a message or signal whose name is a FEEL
+ * expression, for the rules of either trigger (`C8MessageStartNeedsStaticNameRule`,
+ * `C8SignalStartNeedsStaticNameRule`).
+ * Camunda 8 subscribes to such start events at deploy, before any variable exists, and refuses the
+ * file.
+ *
+ * @example a signal start event with a FEEL name
+ * <bpmn:signal id="Go" name="=signalName" />  <!-- a static name -->
+ */
+export abstract class C8StartNameRule extends C8Rule {
+  protected abstract readonly trigger: 'message' | 'signal';
+  /** Where Camunda 8 needs the static name, in the message. */
+  protected abstract readonly starts: string;
+
+  protected visit(start: ModdleElement): void {
+    if (!EngineScope.C8.contains(start) || !is(start, 'bpmn:StartEvent') || !this.applies(start)) {
+      return;
+    }
+    const trigger = this.trigger;
+    const kind = `${trigger.charAt(0).toUpperCase()}${trigger.slice(1)}`;
+    const reference = C8EventDefinitions.definitionOfType(start, `bpmn:${kind}EventDefinition`)?.get(`${trigger}Ref`);
+    const name = reference?.get('name');
+    if (Values.isFeel(name)) {
+      this.report(start, `Start event ${start.id} catches the ${trigger} "${name}", a FEEL expression; Camunda 8 needs a static ${trigger} name on ${this.starts} and refuses the file`, { path: ['eventDefinitions', 0, `${trigger}Ref`, 'name'], type: ERROR_TYPES.EXPRESSION_NOT_ALLOWED, node: reference, property: 'name', hint: `\`bpmn set <file> ${reference.id} name=<${kind}Name>\`.` });
+    }
+  }
+
+  protected abstract applies(start: ModdleElement): boolean;
+}
diff --git a/src/adapters/out/bpmnlint/engine/rules/c8/C8SubProcessStartEventUniqueRule.ts b/src/adapters/out/bpmnlint/engine/rules/c8/C8SubProcessStartEventUniqueRule.ts
new file mode 100644
index 00000000..87f260ad
--- /dev/null
+++ b/src/adapters/out/bpmnlint/engine/rules/c8/C8SubProcessStartEventUniqueRule.ts
@@ -0,0 +1,27 @@
+import { is } from 'bpmnlint-utils';
+import { C8Rule, defineRule, ERROR_TYPES, type ModdleElement } from '../CamundaRule.js';
+import { EngineScope } from '../support/EngineScope.js';
+
+/**
+ * A sub-process or event sub-process with more than one start event (one without is bpmnlint's
+ * `start-event-required`).
+ * Camunda 8 needs exactly one start event in a sub-process and refuses the file.
+ *
+ * @example a sub-process with two start events
+ * <bpmn:subProcess id="Review">
+ *   <bpmn:startEvent id="Begin" />
+ *   <bpmn:startEvent id="BeginToo" />  <!-- one too many -->
+ * </bpmn:subProcess>
+ */
+class C8SubProcessStartEventUniqueRule extends C8Rule {
+  protected visit(subProcess: ModdleElement): void {
+    if (!EngineScope.C8.contains(subProcess) || !is(subProcess, 'bpmn:SubProcess') || is(subProcess, 'bpmn:AdHocSubProcess')) {
+      return;
+    }
+    const starts = (subProcess.get('flowElements') ?? []).filter((element: ModdleElement) => is(element, 'bpmn:StartEvent'));
+    if (starts.length < 2) return;
+    this.report(subProcess, `${EngineScope.isEventSubProcess(subProcess) ? 'Event sub-process' : 'Sub-process'} ${subProcess.id} has ${starts.length} start events; Camunda 8 needs exactly one and refuses the file`, { path: ['flowElements'], type: ERROR_TYPES.ELEMENT_MULTIPLE_NOT_ALLOWED, hint: `Keep one: \`bpmn remove <file> ${starts[1].id}\`.` });
+  }
+}
+
+export default defineRule({ ruleName: 'c8-sub-process-start-event-unique', code: 'W_C8_DEPLOY_START_EVENT', impact: 'deploy' }, C8SubProcessStartEventUniqueRule);
diff --git a/src/adapters/out/bpmnlint/engine/rules/c8/C8SubscriptionUniqueRule.ts b/src/adapters/out/bpmnlint/engine/rules/c8/C8SubscriptionUniqueRule.ts
new file mode 100644
index 00000000..1b73d5a8
--- /dev/null
+++ b/src/adapters/out/bpmnlint/engine/rules/c8/C8SubscriptionUniqueRule.ts
@@ -0,0 +1,69 @@
+import { is } from 'bpmnlint-utils';
+import { C8Rule, ERROR_TYPES, type ModdleElement, type ReportPath } from '../CamundaRule.js';
+import { ElementKinds } from '../support/ElementKinds.js';
+import { EngineScope } from '../support/EngineScope.js';
+import { FirstOfKey } from '../support/FirstOfKey.js';
+import { Values } from '../support/Values.js';
+import { C8EventDefinitions } from './support/C8EventDefinitions.js';
+import { C8SubscriptionGroups } from './support/C8SubscriptionGroups.js';
+import { FlowIndex } from './support/FlowIndex.js';
+
+/** An element whose key an earlier element of its group already has. */
+export interface Duplicate {
+  first: ModdleElement;
+  el: ModdleElement;
+  key: string;
+}
+
+/**
+ * The subscription groups of each (sub-)process Camunda 8 runs, for the rules on a message name,
+ * signal name or error code twice in one group (`C8MessageSubscriptionUniqueRule`,
+ * `C8SignalSubscriptionUniqueRule`, `C8ErrorCodeUniqueRule`), reported on the second and later
+ * elements.
+ * Camunda 8 cannot tell which of the events a message, signal or error is for and refuses the
+ * file.
+ *
+ * @example two boundary events of one task waiting for the same message
+ * <bpmn:boundaryEvent attachedToRef="Pay"><bpmn:messageEventDefinition messageRef="Cancel" /></bpmn:boundaryEvent>
+ * <bpmn:boundaryEvent attachedToRef="Pay"><bpmn:messageEventDefinition messageRef="Cancel" /></bpmn:boundaryEvent>  <!-- same message -->
+ */
+export abstract class C8SubscriptionUniqueRule extends C8Rule {
+  private readonly flows = new FlowIndex();
+
+  protected visit(node: ModdleElement): void {
+    if (!EngineScope.C8.contains(node) || !(is(node, 'bpmn:Process') || is(node, 'bpmn:SubProcess'))) {
+      return;
+    }
+    this.checkScope(new C8SubscriptionGroups(node, this.flows), node);
+  }
+
+  protected abstract checkScope(groups: C8SubscriptionGroups, scope: ModdleElement): void;
+
+  /** The 2nd and later elements of `elements` whose key (`undefined`: none) an earlier one has. */
+  protected duplicates(elements: ModdleElement[], keyOf: (el: ModdleElement) => string | undefined): Duplicate[] {
+    const firsts = new FirstOfKey<ModdleElement>();
+    return elements.flatMap((el) => {
+      const key = keyOf(el);
+      const first = key === undefined ? undefined : firsts.repeats(key, el);
+      return first && key !== undefined ? [{ first, el, key }] : [];
+    });
+  }
+
+  /** One static name twice among `events`; a receive task waits for its own message. */
+  protected reportNamed(trigger: 'message' | 'signal', events: ModdleElement[], where: string, note: string): void {
+    const holderOf = (el: ModdleElement) => (trigger === 'message' && is(el, 'bpmn:ReceiveTask') ? el : C8EventDefinitions.onlyDefinition(el, `bpmn:${trigger === 'message' ? 'Message' : 'Signal'}EventDefinition`));
+    const keyOf = (el: ModdleElement) => {
+      const name = holderOf(el)?.get(`${trigger}Ref`)?.get('name');
+      return !Values.nonEmpty(name) || Values.isFeel(name) ? undefined : name;
+    };
+    for (const duplicate of this.duplicates(events, keyOf)) {
+      const { first, el, key } = duplicate;
+      const path = is(el, 'bpmn:ReceiveTask') ? ['messageRef'] : ['eventDefinitions', 0, `${trigger}Ref`];
+      this.reportDuplicate(duplicate, `${ElementKinds.describe(el)} waits for the ${trigger} "${key}" like ${ElementKinds.describe(first)} ${where}; Camunda 8 refuses one ${trigger} name twice there`, path, 'name', `Use another ${trigger}: \`bpmn set <file> ${el.id} ${trigger}=<Other${trigger.charAt(0).toUpperCase()}${trigger.slice(1)}>\`${note}.`);
+    }
+  }
+
+  protected reportDuplicate({ first, el, key }: Duplicate, message: string, path: ReportPath, property: string, hint: string): void {
+    this.report(el, message, { path, type: ERROR_TYPES.ELEMENT_PROPERTY_VALUE_DUPLICATED, duplicatedProperty: property, duplicatedPropertyValue: key, duplicateOf: first, hint });
+  }
+}
diff --git a/src/adapters/out/bpmnlint/engine/rules/c8/C8TaskHeaderNeedsKeyAndValueRule.ts b/src/adapters/out/bpmnlint/engine/rules/c8/C8TaskHeaderNeedsKeyAndValueRule.ts
new file mode 100644
index 00000000..8702f456
--- /dev/null
+++ b/src/adapters/out/bpmnlint/engine/rules/c8/C8TaskHeaderNeedsKeyAndValueRule.ts
@@ -0,0 +1,56 @@
+import { is, isAny } from 'bpmnlint-utils';
+import { C8Rule, defineRule, ERROR_TYPES, type ModdleElement } from '../CamundaRule.js';
+import { ElementKinds } from '../support/ElementKinds.js';
+import { ModdlePath } from '../support/ModdlePath.js';
+import { Shell } from '../support/Shell.js';
+import { Values } from '../support/Values.js';
+import { C8Host } from './support/C8Host.js';
+import { ZeebeHint } from './support/ZeebeHint.js';
+
+/**
+ * A task header without key or value, of an element or of its execution listeners (not on a
+ * sequence flow).
+ * Camunda 8 deploys the file and drops the header: the job does not carry it.
+ *
+ * @example a task header without value
+ * <zeebe:taskHeaders><zeebe:header key="region" /></zeebe:taskHeaders>  <!-- no value -->
+ */
+class C8TaskHeaderNeedsKeyAndValueRule extends C8Rule {
+  protected visit(host: ModdleElement): void {
+    for (const value of host.extensionElements?.values ?? []) {
+      if (isAny(value, ['zeebe:TaskHeaders', 'zeebe:ExecutionListeners']) && C8Host.readHostOf(value)) {
+        this.checkHeaderValues(value, host);
+      }
+    }
+  }
+
+  /** Task headers without key or value, of the host or of its execution listeners (not on a sequence flow). */
+  private checkHeaderValues(value: ModdleElement, host: ModdleElement): void {
+    if (is(value, 'zeebe:TaskHeaders')) {
+      this.checkHeaderValuesOf(value, host, '');
+    } else if (!is(host, 'bpmn:SequenceFlow')) {
+      (value.listeners ?? []).forEach((listener: ModdleElement, index: number) => listener.headers && this.checkHeaderValuesOf(listener.headers, host, `execution listener ${index + 1} of `));
+    }
+  }
+
+  private checkHeaderValuesOf(headers: ModdleElement, host: ModdleElement, inListener: string): void {
+    const owner = ModdlePath.ownerOf(host);
+    const where = `${inListener}${host.id ? ElementKinds.describe(host) : ElementKinds.describe(host, owner)}`;
+    const hint = host.id && !inListener ? ZeebeHint.of(host) : undefined;
+    (headers.values ?? []).forEach((header: ModdleElement, index: number) => {
+      const missing = (['key', 'value'] as const).find((property) => !Values.nonEmpty(header[property]));
+      if (missing) {
+        this.report(owner, `Task header ${header.key ? `"${header.key}"` : index + 1} of ${where} has no ${missing}; Camunda 8 drops it, the job does not carry it`, { path: [...ModdlePath.between(owner, header), missing], type: ERROR_TYPES.PROPERTY_REQUIRED, node: header, requiredProperty: missing, hint: hint ? this.headerValueHint(hint, header, index, missing) : 'Fix it in the XML.' });
+      }
+    });
+  }
+
+  /** Re-add a header without key (after removing it) or without value: `bpmn ext add` replaces the header of its key. */
+  private headerValueHint(hint: ZeebeHint, header: ModdleElement, index: number, missing: 'key' | 'value'): string {
+    const add = hint.extAdd(`${hint.name('header')} key=${header.key ?? '<key>'} value=<value>`);
+    if (missing === 'value') return `Give it a value: ${add}.`;
+    return `Remove it (\`bpmn ext remove <file> ${hint.id} ${Shell.quote(`${hint.name('taskHeaders')}/${hint.name('header')}[${index}]`)}\`) and add it with a key: ${add}.`;
+  }
+}
+
+export default defineRule({ ruleName: 'c8-task-header-needs-key-and-value', code: 'W_C8_BAD_VALUE', impact: 'runtime' }, C8TaskHeaderNeedsKeyAndValueRule);
diff --git a/src/adapters/out/bpmnlint/engine/rules/c8/C8TaskListenerEventTypeValidRule.ts b/src/adapters/out/bpmnlint/engine/rules/c8/C8TaskListenerEventTypeValidRule.ts
new file mode 100644
index 00000000..b2b56f70
--- /dev/null
+++ b/src/adapters/out/bpmnlint/engine/rules/c8/C8TaskListenerEventTypeValidRule.ts
@@ -0,0 +1,33 @@
+import { defineRule, type ModdleElement } from '../CamundaRule.js';
+import { C8ListenerEventTypeRule } from './C8ListenerEventTypeRule.js';
+import type { C8Host } from './support/C8Host.js';
+
+const TASK_LISTENER_EVENT_CHOICE = '<creating|assigning|updating|completing|canceling>';
+const TASK_LISTENER_EVENTS = ['creating', 'assigning', 'updating', 'completing', 'canceling', 'create', 'assignment', 'update', 'complete', 'cancel'];
+
+/**
+ * A task listener without event type, or with one Camunda 8 does not know.
+ * Camunda 8 runs task listeners on creating, assigning, updating, completing and canceling only
+ * and refuses the file.
+ *
+ * @example a task listener with a Camunda 7 event
+ * <zeebe:taskListeners><zeebe:taskListener eventType="timeout" type="remind" /></zeebe:taskListeners>  <!-- not a Camunda 8 event -->
+ */
+class C8TaskListenerEventTypeValidRule extends C8ListenerEventTypeRule {
+  protected readonly list = 'zeebe:taskListeners';
+
+  protected checkListeners(host: C8Host, value: ModdleElement, index: number): void {
+    (value.listeners ?? []).forEach((listener: ModdleElement, listenerIndex: number) => {
+      const eventType: string | undefined = listener.eventType;
+      const rebuild = this.rebuildListenerHint(host, 'taskListener', listenerIndex, 'Rebuild it', `eventType=${TASK_LISTENER_EVENT_CHOICE} type=${listener.type ?? '<jobType>'}`);
+      const label = `Task listener ${listenerIndex + 1}${eventType?.trim() ? ` (${eventType})` : ''} of ${host.describe()}`;
+      if (!eventType?.trim()) {
+        this.reportEventType(host, listener, index, listenerIndex, `${label} has no eventType; Camunda 8 refuses the file`, rebuild, true);
+      } else if (!TASK_LISTENER_EVENTS.includes(eventType)) {
+        this.reportEventType(host, listener, index, listenerIndex, `${label}: eventType "${eventType}" is not one of creating, assigning, updating, completing, canceling; Camunda 8 refuses the file`, rebuild);
+      }
+    });
+  }
+}
+
+export default defineRule({ ruleName: 'c8-task-listener-event-type-valid', code: 'W_C8_DEPLOY_LISTENER', impact: 'deploy' }, C8TaskListenerEventTypeValidRule);
diff --git a/src/adapters/out/bpmnlint/engine/rules/c8/C8TaskListenersNeedCamundaUserTaskRule.ts b/src/adapters/out/bpmnlint/engine/rules/c8/C8TaskListenersNeedCamundaUserTaskRule.ts
new file mode 100644
index 00000000..6fdcd0dd
--- /dev/null
+++ b/src/adapters/out/bpmnlint/engine/rules/c8/C8TaskListenersNeedCamundaUserTaskRule.ts
@@ -0,0 +1,27 @@
+import { defineRule, ERROR_TYPES } from '../CamundaRule.js';
+import { C8HostRule } from './C8HostRule.js';
+import type { C8Host } from './support/C8Host.js';
+
+/**
+ * Task listeners on a job worker user task (one without zeebe:userTask).
+ * Camunda 8 runs task listeners on Camunda user tasks only and refuses the file.
+ *
+ * @example task listeners on a job worker user task
+ * <bpmn:userTask id="Review">
+ *   <bpmn:extensionElements><zeebe:taskListeners>...</zeebe:taskListeners></bpmn:extensionElements>  <!-- no zeebe:userTask -->
+ * </bpmn:userTask>
+ */
+class C8TaskListenersNeedCamundaUserTaskRule extends C8HostRule {
+  protected checkHost(host: C8Host): void {
+    const values = host.zeebeValues();
+    const hint = host.hint();
+    for (const { type, placement } of values) {
+      if (placement !== 'read' || type.name !== 'zeebe:taskListeners' || values.some((zeebeValue) => zeebeValue.type.name === 'zeebe:userTask')) {
+        continue;
+      }
+      this.reportOn(host, `${host.describe()} has task listeners but is a job worker user task (no ${host.spell('zeebe:userTask')}); Camunda 8 allows task listeners on Camunda user tasks only and refuses the file`, { path: host.path('extensionElements'), type: ERROR_TYPES.EXTENSION_ELEMENT_REQUIRED, node: host.node, requiredExtensionElement: 'zeebe:UserTask', hint: hint ? `Make it a Camunda user task: ${hint.extAdd(hint.name('userTask'))} (or remove the listeners: \`bpmn ext remove <file> ${hint.id} ${hint.name('taskListeners')}\`).` : 'Make it a Camunda user task in the XML (or remove the listeners).' });
+    }
+  }
+}
+
+export default defineRule({ ruleName: 'c8-task-listeners-need-camunda-user-task', code: 'W_C8_DEPLOY_LISTENER', impact: 'deploy' }, C8TaskListenersNeedCamundaUserTaskRule);
diff --git a/src/adapters/out/bpmnlint/engine/rules/c8/C8ThrownMessageNeedsNameRule.ts b/src/adapters/out/bpmnlint/engine/rules/c8/C8ThrownMessageNeedsNameRule.ts
new file mode 100644
index 00000000..0aa6c5ab
--- /dev/null
+++ b/src/adapters/out/bpmnlint/engine/rules/c8/C8ThrownMessageNeedsNameRule.ts
@@ -0,0 +1,29 @@
+import { is, isAny } from 'bpmnlint-utils';
+import { C8Rule, defineRule, ERROR_TYPES, type ModdleElement } from '../CamundaRule.js';
+import { C8EventDefinitions } from './support/C8EventDefinitions.js';
+import { ElementKinds } from '../support/ElementKinds.js';
+import { EngineScope } from '../support/EngineScope.js';
+import { ModdlePath } from '../support/ModdlePath.js';
+import { Values } from '../support/Values.js';
+
+/**
+ * A send task or message throw event whose message has no name.
+ * Camunda 8 publishes a message by its name and refuses the file.
+ *
+ * @example a send task whose message has no name
+ * <bpmn:message id="Message_Order" />  <!-- no name -->
+ * <bpmn:sendTask id="Notify" messageRef="Message_Order" />
+ */
+class C8ThrownMessageNeedsNameRule extends C8Rule {
+  protected visit(node: ModdleElement): void {
+    if (!EngineScope.C8.contains(node) || !isAny(node, ['bpmn:SendTask', 'bpmn:ThrowEvent'])) {
+      return;
+    }
+    const holder = is(node, 'bpmn:SendTask') ? node : C8EventDefinitions.definitionOfType(node, 'bpmn:MessageEventDefinition');
+    const message = holder?.messageRef;
+    if (!message || Values.hasName(message)) return;
+    this.report(node, `Message ${message.id} of ${ElementKinds.describe(node)} has no name; Camunda 8 refuses the file`, { path: [...ModdlePath.between(node, holder), 'messageRef', 'name'], type: ERROR_TYPES.PROPERTY_REQUIRED, node: message, requiredProperty: 'name', hint: `\`bpmn set <file> ${message.id} name=<MessageName>\`.` });
+  }
+}
+
+export default defineRule({ ruleName: 'c8-thrown-message-needs-name', code: 'W_C8_DEPLOY_IMPLEMENTATION', impact: 'deploy' }, C8ThrownMessageNeedsNameRule);
diff --git a/src/adapters/out/bpmnlint/engine/rules/c8/C8TimerValueValidRule.ts b/src/adapters/out/bpmnlint/engine/rules/c8/C8TimerValueValidRule.ts
new file mode 100644
index 00000000..533d813f
--- /dev/null
+++ b/src/adapters/out/bpmnlint/engine/rules/c8/C8TimerValueValidRule.ts
@@ -0,0 +1,67 @@
+import { is } from 'bpmnlint-utils';
+import { C8Rule, defineRule, ERROR_TYPES, type ModdleElement } from '../CamundaRule.js';
+import { ElementKinds } from '../support/ElementKinds.js';
+import { EngineScope } from '../support/EngineScope.js';
+import { Shell } from '../support/Shell.js';
+import { TimerValue } from './support/TimerValue.js';
+
+const TIMER_KINDS = ['timeDate', 'timeCycle', 'timeDuration'] as const;
+type TimerKind = (typeof TIMER_KINDS)[number];
+const TIMER_EXAMPLE: Record<TimerKind, string> = { timeDuration: 'PT1H', timeDate: '2030-12-31T10:00:00Z', timeCycle: 'R/PT1H' };
+const TIMER_EXPECTED: Record<TimerKind, string> = {
+  timeDuration: 'an ISO 8601 duration (PT1H, P2D)',
+  timeDate: 'an ISO 8601 date-time with offset (2030-12-31T10:00:00Z, ...+01:00)',
+  timeCycle: 'a repeating interval (R/PT1H, R5/2030-01-01T08:00:00Z/P1D) or a 6-field cron expression (0 0 9 * * MON)',
+};
+const TIMER_CHECKS: Record<TimerKind, { valid: (timer: TimerValue) => boolean; range: (timer: TimerValue) => string | undefined }> = {
+  timeDuration: { valid: (timer) => timer.isDuration(), range: () => undefined },
+  timeDate: { valid: (timer) => timer.isDateTime(), range: (timer) => timer.dateTimeRangeProblem() },
+  timeCycle: { valid: (timer) => timer.isCycle(), range: (timer) => timer.cycleRangeProblem() },
+};
+
+/**
+ * A static timer value that is empty, no ISO 8601 date, duration or cycle nor a 6-field cron
+ * expression, or out of range.
+ * Camunda 8.9 parses Java's Period and Duration split at an upper-case T, date-times with offset,
+ * repeating intervals and Spring's 6-field cron, each within its range, and refuses the file
+ * otherwise. A FEEL value (=...) is left to the FEEL rules.
+ *
+ * @example a timer duration in words
+ * <bpmn:timerEventDefinition>
+ *   <bpmn:timeDuration>1 hour</bpmn:timeDuration>  <!-- ISO 8601: PT1H -->
+ * </bpmn:timerEventDefinition>
+ */
+class C8TimerValueValidRule extends C8Rule {
+  protected visit(event: ModdleElement): void {
+    if (is(event, 'bpmn:Event') && EngineScope.inExecutableProcess(event)) {
+      (event.get('eventDefinitions') as ModdleElement[]).forEach((definition, index) => this.checkTimer(event, definition, index));
+    }
+  }
+
+  private checkTimer(event: ModdleElement, definition: ModdleElement, index: number): void {
+    const kinds = is(definition, 'bpmn:TimerEventDefinition') ? TIMER_KINDS.filter((timerKind) => definition.get(timerKind)) : [];
+    const [kind] = kinds;
+    if (kinds.length !== 1 || !kind) return;
+    const value = String(definition.get(kind).get('body') ?? '').trim();
+    const problem = value.startsWith('=') ? undefined : this.timerProblem(event, kind, value);
+    if (problem) {
+      this.report(event, `The ${kind}${value === '' ? '' : ` "${value}"`} of ${ElementKinds.describe(event)} ${problem.text}; Camunda 8 refuses the file`, { path: ['eventDefinitions', index, kind], type: ERROR_TYPES.EXPRESSION_VALUE_NOT_ALLOWED, node: definition.get(kind), property: 'body', hint: problem.hint });
+    }
+  }
+
+  /** What is wrong with a static timer value, and the `bpmn set` that fixes it. */
+  private timerProblem(event: ModdleElement, kind: TimerKind, value: string): { text: string; hint: string } | undefined {
+    if (value === '') {
+      return { text: 'is empty', hint: `\`bpmn set <file> ${event.id} timer=PT1H\`.` };
+    }
+    const timer = new TimerValue(value);
+    if (TIMER_CHECKS[kind].valid(timer)) return undefined;
+    const range = TIMER_CHECKS[kind].range(timer);
+    if (range) {
+      return { text: `is no valid ${kind === 'timeDate' || !/^\S+( +\S+){5}$/.test(value) ? 'date-time' : 'cron expression'}: ${range}`, hint: `\`bpmn set <file> ${event.id} ${Shell.quote(`timer=${kind === 'timeDate' ? TIMER_EXAMPLE.timeDate : TIMER_EXAMPLE.timeCycle}`)}\` (with a value in range).` };
+    }
+    return { text: `is not ${TIMER_EXPECTED[kind]}`, hint: `\`bpmn set <file> ${event.id} ${Shell.quote(`timer=${TIMER_EXAMPLE[kind]}`)}\` (or a FEEL expression: ${Shell.quote('timer==<expression>')} with --timer-kind ${kind.replace('time', '').toLowerCase()}).` };
+  }
+}
+
+export default defineRule({ ruleName: 'c8-timer-value-valid', code: 'W_C8_DEPLOY_TIMER', impact: 'deploy' }, C8TimerValueValidRule);
diff --git a/src/adapters/out/bpmnlint/engine/rules/c8/C8VersionTagBindingNeedsTagRule.ts b/src/adapters/out/bpmnlint/engine/rules/c8/C8VersionTagBindingNeedsTagRule.ts
new file mode 100644
index 00000000..7bdfad7a
--- /dev/null
+++ b/src/adapters/out/bpmnlint/engine/rules/c8/C8VersionTagBindingNeedsTagRule.ts
@@ -0,0 +1,22 @@
+import { defineRule, ERROR_TYPES } from '../CamundaRule.js';
+import { type BindingSite, C8BindingRule } from './C8BindingRule.js';
+import type { C8Host } from './support/C8Host.js';
+
+/**
+ * A versionTag binding without version tag, of a called decision, element or form (beyond the one
+ * camunda-compat checks), or of a linked resource.
+ * Camunda 8 has no version to resolve and refuses the file.
+ *
+ * @example a versionTag binding without version tag
+ * <zeebe:calledElement processId="Billing" bindingType="versionTag" />  <!-- versionTag="v2" -->
+ */
+class C8VersionTagBindingNeedsTagRule extends C8BindingRule {
+  protected checkBinding(host: C8Host, { element, subject, path, hint, checkedByCompat }: BindingSite): void {
+    if (element.bindingType !== 'versionTag' || element.versionTag?.trim() || checkedByCompat) {
+      return;
+    }
+    this.reportOn(host, `${subject} has bindingType="versionTag" but no versionTag; Camunda 8 refuses the file`, { path: path('versionTag'), type: ERROR_TYPES.PROPERTY_REQUIRED, node: element, requiredProperty: 'versionTag', hint: hint({ versionTag: '<versionTag>' }) });
+  }
+}
+
+export default defineRule({ ruleName: 'c8-version-tag-binding-needs-tag', code: 'W_C8_DEPLOY_EXTENSION', impact: 'deploy' }, C8VersionTagBindingNeedsTagRule);
diff --git a/src/adapters/out/bpmnlint/engine/rules/c8/C8ZeebeAttributeKnownRule.ts b/src/adapters/out/bpmnlint/engine/rules/c8/C8ZeebeAttributeKnownRule.ts
new file mode 100644
index 00000000..a87ae0d6
--- /dev/null
+++ b/src/adapters/out/bpmnlint/engine/rules/c8/C8ZeebeAttributeKnownRule.ts
@@ -0,0 +1,67 @@
+import { defineRule, ERROR_TYPES, type ReportData } from '../CamundaRule.js';
+import { RuleKit } from '../RuleKit.js';
+import { DidYouMean } from '../support/DidYouMean.js';
+import { Shell } from '../support/Shell.js';
+import { C8HostRule } from './C8HostRule.js';
+import type { C8Host } from './support/C8Host.js';
+import { ZeebeHint } from './support/ZeebeHint.js';
+
+/** Zeebe elements Camunda 8 accepts but does not execute: no home for an attribute. */
+const NOT_EXECUTED = ['zeebe:publishMessage'];
+
+/**
+ * A zeebe attribute that does not exist, on a BPMN element or on a zeebe extension element (or one
+ * inside it). On a BPMN element, the hint moves it to the extension element that has it.
+ * Camunda 8 deploys the file and silently ignores the attribute.
+ *
+ * @example a zeebe attribute on the task instead of its task definition
+ * <bpmn:serviceTask id="Charge" zeebe:type="charge" />  <!-- zeebe:taskDefinition type="charge" -->
+ */
+class C8ZeebeAttributeKnownRule extends C8HostRule {
+  protected checkHost(host: C8Host): void {
+    this.checkUnknownAttributes(host);
+    this.checkUnknownTreeAttributes(host);
+  }
+
+  /** A zeebe attribute of the BPMN element the descriptor does not define, moved to the extension element that has it. */
+  private checkUnknownAttributes(host: C8Host): void {
+    const zeebe = RuleKit.kit.ZEEBE;
+    const hint = host.hint();
+    const prefix = ZeebeHint.prefixOf(host.node);
+    for (const key of host.zeebeAttributeKeys()) {
+      const local = key.slice(key.indexOf(':') + 1);
+      if (zeebe.attr(local)) continue;
+      const home = zeebe.typeNames().map((name) => zeebe.type(name)!).find((type) => !NOT_EXECUTED.includes(type.name) && zeebe.allowedOn(type.name, host.node) === true && type.attributes.some(({ name }) => name === local));
+      const homeName = home && `${prefix}:${home.name.slice('zeebe:'.length)}`;
+      const guess = home ? undefined : DidYouMean.of(local, zeebe.attrs().map(({ name }) => name.slice('zeebe:'.length)));
+      const unset = hint ? hint.unset(`${prefix}:${local}`) : 'edit the XML';
+      const move = home && hint ? hint.extAdd(`${homeName} ${Shell.quote(`${local}=${host.node.$attrs[key] ?? ''}`)}`) : 'edit the XML';
+      this.reportUnknownAttribute(host, host.describe(), `${prefix}:${local}`, { property: key, path: host.path(key), hint: home ? `Move it: ${unset}, then ${move}.` : `Remove it: ${unset}.` }, guess ? ` (did you mean ${prefix}:${guess}?)` : '', home ? ` (it reads ${local} on the ${homeName} extension element)` : ' (most zeebe settings are extension elements: `bpmn kinds`, `bpmn guide`)');
+    }
+  }
+
+  /** An attribute a zeebe extension element (or one inside it) does not have. */
+  private checkUnknownTreeAttributes(host: C8Host): void {
+    const hint = host.hint();
+    const prefix = ZeebeHint.prefixOf(host.node);
+    for (const { value, index, placement } of host.zeebeValues()) {
+      if (placement !== 'read') continue;
+      const rebuild = hint ? hint.rebuild(hint.nameOf(value)) : 'Fix it in the XML.';
+      for (const element of host.tree(value, prefix, host.extensionPath(index))) {
+        const names = RuleKit.kit.ZEEBE.type(element.element.$type)?.attributes.map(({ name }) => name);
+        for (const key of names ? Object.keys(element.element.$attrs ?? {}) : []) {
+          if (!key.includes(':') && !key.startsWith('xmlns')) {
+            this.reportUnknownAttribute(host, element.where, key, { property: key, path: [...element.path, key], node: element.element, hint: rebuild }, DidYouMean.suggestion(key, names!));
+          }
+        }
+      }
+    }
+  }
+
+  /** `name` on `where`, which the descriptor does not know; `suggestion` names the one it most likely means, `after` where Camunda 8 reads it. */
+  private reportUnknownAttribute(host: C8Host, where: string, name: string, data: Pick<ReportData, 'path'> & Record<string, unknown>, suggestion: string, after = ''): void {
+    this.reportContent(host, `${where} has the unknown attribute ${name}${suggestion}; Camunda 8 ignores it${after}`, { type: ERROR_TYPES.PROPERTY_NOT_ALLOWED, ...data });
+  }
+}
+
+export default defineRule({ ruleName: 'c8-zeebe-attribute-known', code: 'W_C8_UNKNOWN_ATTRIBUTE', impact: 'runtime' }, C8ZeebeAttributeKnownRule);
diff --git a/src/adapters/out/bpmnlint/engine/rules/c8/C8ZeebeAttributePlacementRule.ts b/src/adapters/out/bpmnlint/engine/rules/c8/C8ZeebeAttributePlacementRule.ts
new file mode 100644
index 00000000..592a71b6
--- /dev/null
+++ b/src/adapters/out/bpmnlint/engine/rules/c8/C8ZeebeAttributePlacementRule.ts
@@ -0,0 +1,29 @@
+import { defineRule, ERROR_TYPES } from '../CamundaRule.js';
+import { RuleKit } from '../RuleKit.js';
+import { ElementKinds } from '../support/ElementKinds.js';
+import { C8HostRule } from './C8HostRule.js';
+import type { C8Host } from './support/C8Host.js';
+import { ZeebeHint } from './support/ZeebeHint.js';
+
+/**
+ * A zeebe attribute on a BPMN element that does not carry it (`zeebe:modelerTemplate` on a lane).
+ * Camunda 8 deploys the file and silently ignores the attribute.
+ *
+ * @example a template reference on a lane
+ * <bpmn:lane id="Sales" zeebe:modelerTemplate="io.camunda.connectors.Slack" />  <!-- read on tasks and events -->
+ */
+class C8ZeebeAttributePlacementRule extends C8HostRule {
+  protected checkHost(host: C8Host): void {
+    const hint = host.hint();
+    const prefix = ZeebeHint.prefixOf(host.node);
+    for (const key of host.zeebeAttributeKeys()) {
+      const local = key.slice(key.indexOf(':') + 1);
+      const owners = RuleKit.kit.ZEEBE.attr(local)?.owners;
+      if (owners && !owners.some((owner) => host.node.$instanceOf(owner))) {
+        this.reportContent(host, `${prefix}:${local} on ${host.describe()} has no effect: Camunda 8 reads it on ${ElementKinds.list(owners)} only`, { type: ERROR_TYPES.PROPERTY_NOT_ALLOWED, property: key, path: host.path(key), hint: `Remove it: ${hint ? hint.unset(`${prefix}:${local}`) : 'edit the XML'}.` });
+      }
+    }
+  }
+}
+
+export default defineRule({ ruleName: 'c8-zeebe-attribute-placement', code: 'W_C8_MISPLACED_ATTRIBUTE', impact: 'runtime' }, C8ZeebeAttributePlacementRule);
diff --git a/src/adapters/out/bpmnlint/engine/rules/c8/C8ZeebeElementKnownRule.ts b/src/adapters/out/bpmnlint/engine/rules/c8/C8ZeebeElementKnownRule.ts
new file mode 100644
index 00000000..18641ec1
--- /dev/null
+++ b/src/adapters/out/bpmnlint/engine/rules/c8/C8ZeebeElementKnownRule.ts
@@ -0,0 +1,20 @@
+import type { Engine } from '@miragon/bpmnlint-plugin-rules/engine';
+import { defineRule } from '../CamundaRule.js';
+import { UnknownVendorElementsRule } from '../UnknownVendorElementsRule.js';
+
+/**
+ * zeebe extension elements of an executable process that the zeebe descriptor does not know,
+ * directly in the extension elements or inside a known one.
+ * Camunda 8 ignores them. The typed parse drops them with an import warning that names neither the
+ * element nor where it sat, so the rule reads the extension elements as the file writes them.
+ *
+ * @example a misspelled extension element
+ * <bpmn:serviceTask id="Charge">
+ *   <bpmn:extensionElements><zeebe:taskDefinitions type="charge" /></bpmn:extensionElements>  <!-- zeebe:taskDefinition -->
+ * </bpmn:serviceTask>
+ */
+class C8ZeebeElementKnownRule extends UnknownVendorElementsRule {
+  protected readonly engine: Engine = 'c8';
+}
+
+export default defineRule({ ruleName: 'c8-zeebe-element-known', code: 'W_C8_UNKNOWN_ELEMENT', impact: 'runtime' }, C8ZeebeElementKnownRule);
diff --git a/src/adapters/out/bpmnlint/engine/rules/c8/C8ZeebeElementPlacementRule.ts b/src/adapters/out/bpmnlint/engine/rules/c8/C8ZeebeElementPlacementRule.ts
new file mode 100644
index 00000000..9a1103bc
--- /dev/null
+++ b/src/adapters/out/bpmnlint/engine/rules/c8/C8ZeebeElementPlacementRule.ts
@@ -0,0 +1,43 @@
+import { defineRule, ERROR_TYPES, type ModdleElement } from '../CamundaRule.js';
+import type { Engine } from '@miragon/bpmnlint-plugin-rules/engine';
+import { RuleKit } from '../RuleKit.js';
+import { VendorElementsRule } from '../VendorElementsRule.js';
+
+/**
+ * A known zeebe extension element the typed parse drops where it sits: one that belongs inside a
+ * container (a loose zeebe:input), or zeebe:publishMessage on an element Camunda 8 does not read it
+ * on (an end event instead of its message event definition).
+ * Camunda 8 ignores it. The typed parse drops it with an import warning that names neither the
+ * element nor where it sat, so the rule reads the extension elements as the file writes them.
+ *
+ * @example a loose input mapping
+ * <bpmn:serviceTask id="Charge">
+ *   <bpmn:extensionElements><zeebe:input source="=amount" target="amount" /></bpmn:extensionElements>  <!-- inside zeebe:ioMapping -->
+ * </bpmn:serviceTask>
+ */
+class C8ZeebeElementPlacementRule extends VendorElementsRule {
+  protected readonly engine: Engine = 'c8';
+
+  protected checkValue(host: ModdleElement, value: ModdleElement, index: number): void {
+    const local = this.localName(value.$type);
+    const { ZEEBE } = RuleKit.kit;
+    const type = ZEEBE.type(local);
+    if (!type || !this.isMisplaced(host, local)) return;
+    const id: string | undefined = host.id;
+    const remove = id ? `\`bpmn ext remove <file> ${id} ${index}\`` : 'remove it from the XML';
+    const name = `${this.prefix}:${local}`;
+    if (ZEEBE.nestedOnly(local)) {
+      const container = ZEEBE.containersOf(local)[0]!;
+      const add = id ? `: \`bpmn ext add <file> ${id} ${name} ...\`` : '';
+      return this.reportMisplaced(host, local, `${name} sits directly in the extension elements of ${this.where(host)}, but belongs inside ${this.prefix}:${this.localName(container)}; Camunda 8 ignores it`, `Remove it (${remove}) and add it again, \`bpmn ext add\` files it into its container${add}.`);
+    }
+    const hosts = type.allowedIn.filter((allowed) => allowed.startsWith('bpmn:')).map((allowed) => `${allowed.charAt(5).toLowerCase()}${allowed.slice(6)}`);
+    this.reportMisplaced(host, local, `${name} on ${this.where(host)} has no effect: Camunda 8 reads it on ${hosts.length > 5 ? `${hosts.slice(0, 5).join(', ')}, ...` : hosts.join(', ')} only`, `Remove it: ${remove}.`);
+  }
+
+  private reportMisplaced(host: ModdleElement, local: string, message: string, hint: string): void {
+    this.report(this.node, message, { path: null, type: ERROR_TYPES.EXTENSION_ELEMENT_NOT_ALLOWED, writtenAt: this.model.position(host), subject: `ext:${local}`, hint });
+  }
+}
+
+export default defineRule({ ruleName: 'c8-zeebe-element-placement', code: 'W_C8_MISPLACED_EXTENSION', impact: 'runtime' }, C8ZeebeElementPlacementRule);
diff --git a/src/adapters/out/bpmnlint/engine/rules/c8/C8ZeebeExtensionPlacementRule.ts b/src/adapters/out/bpmnlint/engine/rules/c8/C8ZeebeExtensionPlacementRule.ts
new file mode 100644
index 00000000..4016935d
--- /dev/null
+++ b/src/adapters/out/bpmnlint/engine/rules/c8/C8ZeebeExtensionPlacementRule.ts
@@ -0,0 +1,32 @@
+import { defineRule, ERROR_TYPES } from '../CamundaRule.js';
+import { RuleKit } from '../RuleKit.js';
+import { ElementKinds } from '../support/ElementKinds.js';
+import { C8HostRule } from './C8HostRule.js';
+import type { C8Host } from './support/C8Host.js';
+
+/**
+ * A zeebe extension element on an element that does not read it, or directly in the extension
+ * elements instead of inside its container.
+ * Camunda 8 deploys the file and silently ignores the element.
+ *
+ * @example a task definition on a user task
+ * <bpmn:userTask id="Review">
+ *   <bpmn:extensionElements><zeebe:taskDefinition type="review" /></bpmn:extensionElements>  <!-- read on service tasks -->
+ * </bpmn:userTask>
+ */
+class C8ZeebeExtensionPlacementRule extends C8HostRule {
+  protected checkHost(host: C8Host): void {
+    const hint = host.hint();
+    for (const { value, index, type, placement } of host.zeebeValues()) {
+      const finding = { type: ERROR_TYPES.EXTENSION_ELEMENT_NOT_ALLOWED, extensionElement: value, path: host.extensionPath(index), node: host.node };
+      if (placement === 'loose') {
+        this.reportContent(host, `${host.spell(type.name)} sits directly in the extension elements of ${host.describe()}, but belongs inside ${host.spell(RuleKit.kit.ZEEBE.containersOf(type.name)[0] ?? '')}; Camunda 8 ignores it`, { ...finding, hint: hint ? `Remove it (${hint.extRemove(index)}) and add it again, \`bpmn ext add\` files it into its container: ${hint.extAdd(`${hint.nameOf(value)} ...`)}.` : 'Remove it (remove it from the XML) and add it again, `bpmn ext add` files it into its container: edit the XML.' });
+      }
+      if (placement === 'misplaced') {
+        this.reportContent(host, `${host.spell(type.name)} on ${host.describe()} has no effect: Camunda 8 reads it on ${ElementKinds.list(type.allowedIn.filter((allowed) => allowed.startsWith('bpmn:')), 5)} only`, { ...finding, hint: `Remove it: ${hint ? hint.extRemove(index) : 'remove it from the XML'}.` });
+      }
+    }
+  }
+}
+
+export default defineRule({ ruleName: 'c8-zeebe-extension-placement', code: 'W_C8_MISPLACED_EXTENSION', impact: 'runtime' }, C8ZeebeExtensionPlacementRule);
diff --git a/src/adapters/out/bpmnlint/engine/rules/c8/Camunda8Rules.ts b/src/adapters/out/bpmnlint/engine/rules/c8/Camunda8Rules.ts
new file mode 100644
index 00000000..a912a418
--- /dev/null
+++ b/src/adapters/out/bpmnlint/engine/rules/c8/Camunda8Rules.ts
@@ -0,0 +1,117 @@
+import { compatRules, moddleExtensions } from '@miragon/bpmnlint-plugin-rules/camunda-8';
+import type { EngineKit } from '../../../engine-kit.js';
+import type { EngineEntry } from '../../run/EngineRun.js';
+import { RuleEntries } from '../RuleEntries.js';
+import c8EventSubProcessStartNeedsTrigger from './C8EventSubProcessStartNeedsTriggerRule.js';
+import c8CompensationNamesOwnActivity from './C8CompensationNamesOwnActivityRule.js';
+import c8CompensationBoundaryNeedsAssociation from './C8CompensationBoundaryNeedsAssociationRule.js';
+import c8CompensationBoundaryNoOutgoingFlow from './C8CompensationBoundaryNoOutgoingFlowRule.js';
+import c8AdHocSubProcessNoStartOrEndEvent from './C8AdHocSubProcessNoStartOrEndEventRule.js';
+import c8EventGatewayNeedsTwoBranches from './C8EventGatewayNeedsTwoBranchesRule.js';
+import c8EventGatewayTargetAllowed from './C8EventGatewayTargetAllowedRule.js';
+import c8EmbeddedStartEventNoTrigger from './C8EmbeddedStartEventNoTriggerRule.js';
+import c8SubProcessStartEventUnique from './C8SubProcessStartEventUniqueRule.js';
+import c8TimerValueValid from './C8TimerValueValidRule.js';
+import c8ConditionalEventNeedsCondition from './C8ConditionalEventNeedsConditionRule.js';
+import c8LinkEventNeedsName from './C8LinkEventNeedsNameRule.js';
+import c8LinkThrowNeedsCatch from './C8LinkThrowNeedsCatchRule.js';
+import c8MessageStartNeedsStaticName from './C8MessageStartNeedsStaticNameRule.js';
+import c8MessageSubscriptionUnique from './C8MessageSubscriptionUniqueRule.js';
+import c8SignalStartNeedsStaticName from './C8SignalStartNeedsStaticNameRule.js';
+import c8SignalSubscriptionUnique from './C8SignalSubscriptionUniqueRule.js';
+import c8ErrorCatchNeedsStaticCode from './C8ErrorCatchNeedsStaticCodeRule.js';
+import c8ErrorEventInterrupting from './C8ErrorEventInterruptingRule.js';
+import c8ErrorCodeUnique from './C8ErrorCodeUniqueRule.js';
+import c8ThrownMessageNeedsName from './C8ThrownMessageNeedsNameRule.js';
+import c8ConditionNeedsFeel from './C8ConditionNeedsFeelRule.js';
+import c8MultiInstanceNeedsFeel from './C8MultiInstanceNeedsFeelRule.js';
+import c8ScriptNeedsFeel from './C8ScriptNeedsFeelRule.js';
+import c8CorrelationKeyNeedsFeel from './C8CorrelationKeyNeedsFeelRule.js';
+import c8FeelExpressionValid from './C8FeelExpressionValidRule.js';
+import c8MultiInstanceCompletionNeedsFeel from './C8MultiInstanceCompletionNeedsFeelRule.js';
+import c8JobRetriesValid from './C8JobRetriesValidRule.js';
+import c8TaskHeaderNeedsKeyAndValue from './C8TaskHeaderNeedsKeyAndValueRule.js';
+import c8SequenceFlowNoExecutionListeners from './C8SequenceFlowNoExecutionListenersRule.js';
+import c8ExecutionListenerEventTypeValid from './C8ExecutionListenerEventTypeValidRule.js';
+import c8TaskListenersNeedCamundaUserTask from './C8TaskListenersNeedCamundaUserTaskRule.js';
+import c8TaskListenerEventTypeValid from './C8TaskListenerEventTypeValidRule.js';
+import c8LinkedResourceNeedsType from './C8LinkedResourceNeedsTypeRule.js';
+import c8BindingTypeKnown from './C8BindingTypeKnownRule.js';
+import c8VersionTagBindingNeedsTag from './C8VersionTagBindingNeedsTagRule.js';
+import c8ConditionalFilterEventsKnown from './C8ConditionalFilterEventsKnownRule.js';
+import c8ExtensionElementUnique from './C8ExtensionElementUniqueRule.js';
+import c8NoCamunda7Content from './C8NoCamunda7ContentRule.js';
+import c8ZeebeAttributeKnown from './C8ZeebeAttributeKnownRule.js';
+import c8ZeebeAttributePlacement from './C8ZeebeAttributePlacementRule.js';
+import c8ZeebeExtensionPlacement from './C8ZeebeExtensionPlacementRule.js';
+import c8InputMappingPlacement from './C8InputMappingPlacementRule.js';
+import c8BpmnAttributeKnown from './C8BpmnAttributeKnownRule.js';
+import c8PublishMessageNoTaskDefinition from './C8PublishMessageNoTaskDefinitionRule.js';
+import c8PublishMessageNeedsMessage from './C8PublishMessageNeedsMessageRule.js';
+import c8PublishMessageNeedsCorrelationKey from './C8PublishMessageNeedsCorrelationKeyRule.js';
+import c8PublishMessageUnsupported from './C8PublishMessageUnsupportedRule.js';
+import c8ZeebeElementPlacement from './C8ZeebeElementPlacementRule.js';
+import c8ZeebeElementKnown from './C8ZeebeElementKnownRule.js';
+
+/** bpmn-cli's Camunda 8 rules: the checks camunda-compat's `camunda-cloud-8-*` configs leave out, in the order their findings of one element are listed. */
+export class Camunda8Rules {
+  static readonly RULES = [
+    c8EventSubProcessStartNeedsTrigger,
+    c8CompensationNamesOwnActivity,
+    c8CompensationBoundaryNeedsAssociation,
+    c8CompensationBoundaryNoOutgoingFlow,
+    c8AdHocSubProcessNoStartOrEndEvent,
+    c8EventGatewayNeedsTwoBranches,
+    c8EventGatewayTargetAllowed,
+    c8EmbeddedStartEventNoTrigger,
+    c8SubProcessStartEventUnique,
+    c8TimerValueValid,
+    c8ConditionalEventNeedsCondition,
+    c8LinkEventNeedsName,
+    c8LinkThrowNeedsCatch,
+    c8MessageStartNeedsStaticName,
+    c8MessageSubscriptionUnique,
+    c8SignalStartNeedsStaticName,
+    c8SignalSubscriptionUnique,
+    c8ErrorCatchNeedsStaticCode,
+    c8ErrorEventInterrupting,
+    c8ErrorCodeUnique,
+    c8ThrownMessageNeedsName,
+    c8ConditionNeedsFeel,
+    c8MultiInstanceNeedsFeel,
+    c8ScriptNeedsFeel,
+    c8CorrelationKeyNeedsFeel,
+    c8FeelExpressionValid,
+    c8MultiInstanceCompletionNeedsFeel,
+    c8JobRetriesValid,
+    c8TaskHeaderNeedsKeyAndValue,
+    c8SequenceFlowNoExecutionListeners,
+    c8ExecutionListenerEventTypeValid,
+    c8TaskListenersNeedCamundaUserTask,
+    c8TaskListenerEventTypeValid,
+    c8LinkedResourceNeedsType,
+    c8BindingTypeKnown,
+    c8VersionTagBindingNeedsTag,
+    c8ConditionalFilterEventsKnown,
+    c8ExtensionElementUnique,
+    c8NoCamunda7Content,
+    c8ZeebeAttributeKnown,
+    c8ZeebeAttributePlacement,
+    c8ZeebeExtensionPlacement,
+    c8InputMappingPlacement,
+  ];
+  static readonly WRITTEN_FILE_RULES = [
+    c8BpmnAttributeKnown,
+    c8PublishMessageNoTaskDefinition,
+    c8PublishMessageNeedsMessage,
+    c8PublishMessageNeedsCorrelationKey,
+    c8PublishMessageUnsupported,
+    c8ZeebeElementPlacement,
+    c8ZeebeElementKnown,
+  ];
+
+  /** camunda-compat's rules for an engine version with these, as `bpmn-cli/<rule>`, and the moddle extension they read. */
+  static entry(kit: EngineKit): EngineEntry {
+    return RuleEntries.entry(kit, Camunda8Rules.RULES, Camunda8Rules.WRITTEN_FILE_RULES, { compatRules, moddleExtensions });
+  }
+}
diff --git a/src/adapters/out/bpmnlint/engine/rules/c8/support/C8EventDefinitions.ts b/src/adapters/out/bpmnlint/engine/rules/c8/support/C8EventDefinitions.ts
new file mode 100644
index 00000000..8d60abc9
--- /dev/null
+++ b/src/adapters/out/bpmnlint/engine/rules/c8/support/C8EventDefinitions.ts
@@ -0,0 +1,86 @@
+import { is, isAny } from 'bpmnlint-utils';
+
+import type { ModdleElement, ReportPath } from '@miragon/bpmnlint-plugin-rules/engine';
+import { EngineScope } from '../../support/EngineScope.js';
+
+/** How Camunda 8 reads events: the one event definition it checks an event by, where a report on a definition goes, and the messages the executable processes use. */
+export class C8EventDefinitions {
+  private static readonly usedByDefinitions = new WeakMap<object, Set<ModdleElement>>();
+
+  /**
+   * The event definition Camunda 8 checks further: the only one of the event, unless the event has
+   * none or several, or sits where the engine refuses it outright (a cancel event, a triggered
+   * start of an embedded sub-process, a compensation start of an event sub-process).
+   */
+  static definitionOf(event: ModdleElement): ModdleElement | undefined {
+    const definitions = event.get('eventDefinitions') ?? [];
+    if (definitions.length !== 1) return undefined;
+    const [definition] = definitions;
+    const refused = is(definition, 'bpmn:CancelEventDefinition') || C8EventDefinitions.isEmbeddedSubProcessStart(event) || (is(event, 'bpmn:StartEvent') && EngineScope.isEventSubProcess(event.$parent) && is(definition, 'bpmn:CompensateEventDefinition'));
+    return refused ? undefined : definition;
+  }
+
+  /** The checked definition of `event` when it is of `type`. */
+  static definitionOfType(event: ModdleElement, type: string): ModdleElement | undefined {
+    const definition = C8EventDefinitions.definitionOf(event);
+    return definition && is(definition, type) ? definition : undefined;
+  }
+
+  /** The event's definition when it is its only one and of `type`. */
+  static onlyDefinition(event: ModdleElement, type: string): ModdleElement | undefined {
+    const definitions = event.get('eventDefinitions') ?? [];
+    return definitions.length === 1 && is(definitions[0], type) ? definitions[0] : undefined;
+  }
+
+  /** A start event of an embedded sub-process (not an event or ad-hoc sub-process, not a transaction). */
+  static isEmbeddedSubProcessStart(event: ModdleElement): boolean {
+    const parent = event.$parent;
+    return is(event, 'bpmn:StartEvent') && is(parent, 'bpmn:SubProcess') && !EngineScope.isEventSubProcess(parent) && !isAny(parent, ['bpmn:AdHocSubProcess', 'bpmn:Transaction']);
+  }
+
+  /** Where a report on an event definition goes: on its event, with the path to the definition, or on the definition itself when no event holds it (a root element). */
+  static definitionOwner(definition: ModdleElement): { owner: ModdleElement; path: ReportPath } {
+    const event = definition.$parent;
+    if (event && is(event, 'bpmn:Event')) {
+      return { owner: event, path: ['eventDefinitions', event.get('eventDefinitions').indexOf(definition)] };
+    }
+    return { owner: definition, path: [] };
+  }
+
+  /** The element that references the message: a receive or send task itself, or the first message event definition of an event. */
+  static messageHolderOf(el: ModdleElement): ModdleElement | undefined {
+    if (is(el, 'bpmn:ReceiveTask') || is(el, 'bpmn:SendTask')) return el;
+    return (el.eventDefinitions ?? []).find((definition: ModdleElement) => is(definition, 'bpmn:MessageEventDefinition'));
+  }
+
+  /** The message a task or event sends or waits for. */
+  static messageOf(el: ModdleElement): ModdleElement | undefined {
+    return C8EventDefinitions.messageHolderOf(el)?.messageRef;
+  }
+
+  /** Whether `node` is a message an event or receive task of an executable process of its diagram uses: Camunda 8 reads its zeebe content. */
+  static isUsedMessage(node: ModdleElement): boolean {
+    const definitions = node.$parent;
+    if (!is(node, 'bpmn:Message') || !definitions || !is(definitions, 'bpmn:Definitions')) {
+      return false;
+    }
+    let used = C8EventDefinitions.usedByDefinitions.get(definitions);
+    if (!used) {
+      C8EventDefinitions.usedByDefinitions.set(definitions, (used = C8EventDefinitions.usedMessages(definitions)));
+    }
+    return used.has(node);
+  }
+
+  private static usedMessages(definitions: ModdleElement): Set<ModdleElement> {
+    const used = new Set<ModdleElement>();
+    const pending: ModdleElement[] = (definitions.rootElements ?? []).filter((root: ModdleElement) => is(root, 'bpmn:Process') && root.isExecutable === true);
+    while (pending.length) {
+      for (const element of pending.pop().flowElements ?? []) {
+        const message = is(element, 'bpmn:Event') || is(element, 'bpmn:ReceiveTask') ? C8EventDefinitions.messageOf(element) : undefined;
+        if (message) used.add(message);
+        if (element.flowElements) pending.push(element);
+      }
+    }
+    return used;
+  }
+}
diff --git a/src/adapters/out/bpmnlint/engine/rules/c8/support/C8Host.ts b/src/adapters/out/bpmnlint/engine/rules/c8/support/C8Host.ts
new file mode 100644
index 00000000..cce87698
--- /dev/null
+++ b/src/adapters/out/bpmnlint/engine/rules/c8/support/C8Host.ts
@@ -0,0 +1,102 @@
+import { is } from 'bpmnlint-utils';
+
+import type { ModdleElement } from '@miragon/bpmnlint-plugin-rules/engine';
+import type { EngineKit } from '../../../../engine-kit.js';
+import { ZEEBE_URI } from '../../support/DiagramNamespaces.js';
+import { EngineScope } from '../../support/EngineScope.js';
+import { RuleKit } from '../../RuleKit.js';
+import { VendorHost } from '../../support/VendorHost.js';
+import { C8EventDefinitions } from './C8EventDefinitions.js';
+import { ZeebeHint } from './ZeebeHint.js';
+
+export type ZeebeType = NonNullable<ReturnType<EngineKit['ZEEBE']['type']>>;
+
+/**
+ * How Camunda 8 treats a zeebe extension element where it sits: `read`, `loose` (a child element
+ * outside its container), `flowListeners` (execution listeners on a sequence flow, refused) or
+ * `misplaced` (on a host that does not read it).
+ */
+type ZeebePlacement = 'read' | 'loose' | 'flowListeners' | 'misplaced';
+
+/** A typed zeebe element in the extension elements of a BPMN element. */
+export interface ZeebeValue {
+  value: ModdleElement;
+  /** Its index in `extensionElements.values`. */
+  index: number;
+  type: ZeebeType;
+  placement: ZeebePlacement;
+}
+
+/**
+ * A BPMN element whose vendor content Camunda 8 reads: an element of an executable process (not
+ * inside a transaction, which Camunda 8 refuses as a whole) or a message that process uses, with
+ * an id of its own or of an element around it to report on.
+ */
+export class C8Host extends VendorHost {
+  static of(node: ModdleElement): C8Host | undefined {
+    const type = String(node?.$type ?? '');
+    if (!type.startsWith('bpmn:') || is(node, 'bpmn:Definitions') || node.$descriptor?.isGeneric || !C8Host.readsExtensionsOf(node)) {
+      return undefined;
+    }
+    for (let ancestor = node; ancestor; ancestor = ancestor.$parent) {
+      if (is(ancestor, 'bpmn:ExtensionElements')) return undefined;
+    }
+    const host = new C8Host(node);
+    return node.id || host.owner ? host : undefined;
+  }
+
+  /** Whether Camunda 8 reads the extension elements of `host`: in the engine's scope, or a message it uses. */
+  static readsExtensionsOf(host: ModdleElement): boolean {
+    return EngineScope.C8.runs(host) || C8EventDefinitions.isUsedMessage(host);
+  }
+
+  /** The BPMN element whose extension elements hold `node` directly, when Camunda 8 reads it there: it reads the host's extensions and the type is allowed on it. */
+  static readHostOf(node: ModdleElement): ModdleElement | undefined {
+    if (!node.$parent || !is(node.$parent, 'bpmn:ExtensionElements')) {
+      return undefined;
+    }
+    const host = node.$parent.$parent;
+    const allowedIn: string[] | undefined = node.$model?.getTypeDescriptor(node.$type)?.meta?.allowedIn;
+    return host && C8Host.readsExtensionsOf(host) && (!allowedIn || allowedIn.some((type) => is(host, type))) ? host : undefined;
+  }
+
+  /** The extension elements of `host` of one type (`zeebe:TaskDefinition`), in document order. */
+  static valuesOf(host: ModdleElement, type: string): ModdleElement[] {
+    return (host?.extensionElements?.values ?? []).filter((value: ModdleElement) => value.$type === type);
+  }
+
+  /** The commands a hint gives for this element; undefined when `bpmn` cannot address it. */
+  hint(): ZeebeHint | undefined {
+    return ZeebeHint.of(this.node);
+  }
+
+  /** A zeebe name (`zeebe:taskDefinition`) with the prefix the file declares for the zeebe namespace. */
+  spell(name: string): string {
+    return name.replace(/^zeebe:/, `${ZeebeHint.prefixOf(this.node)}:`);
+  }
+
+  /** The keys of the zeebe attributes the moddle left in `$attrs`. */
+  zeebeAttributeKeys(): string[] {
+    return this.foreignAttributes().filter(({ uri }) => uri === ZEEBE_URI).map(({ key }) => key);
+  }
+
+  extensionValues(): ModdleElement[] {
+    return this.node.extensionElements?.values ?? [];
+  }
+
+  /** The typed zeebe elements in the extension elements, with how Camunda 8 treats each. */
+  zeebeValues(): ZeebeValue[] {
+    return this.extensionValues().flatMap((value, index) => {
+      const type = value.$descriptor?.isGeneric || !String(value.$type).startsWith('zeebe:') ? undefined : RuleKit.kit.ZEEBE.type(value.$type);
+      return type ? [{ value, index, type, placement: this.placementOf(type) }] : [];
+    });
+  }
+
+  private placementOf(type: ZeebeType): ZeebePlacement {
+    if (RuleKit.kit.ZEEBE.nestedOnly(type.name)) return 'loose';
+    if (type.name === 'zeebe:executionListeners' && is(this.node, 'bpmn:SequenceFlow')) {
+      return 'flowListeners';
+    }
+    return RuleKit.kit.ZEEBE.allowedOn(type.name, this.node) === false ? 'misplaced' : 'read';
+  }
+}
diff --git a/src/adapters/out/bpmnlint/engine/rules/c8/support/C8SubscriptionGroups.ts b/src/adapters/out/bpmnlint/engine/rules/c8/support/C8SubscriptionGroups.ts
new file mode 100644
index 00000000..8d632535
--- /dev/null
+++ b/src/adapters/out/bpmnlint/engine/rules/c8/support/C8SubscriptionGroups.ts
@@ -0,0 +1,32 @@
+import { is } from 'bpmnlint-utils';
+import type { ModdleElement } from '../../CamundaRule.js';
+import { EngineScope } from '../../support/EngineScope.js';
+import type { FlowIndex } from './FlowIndex.js';
+
+/**
+ * The events of one (sub-)process that Camunda 8 subscribes to together, so a message name, signal
+ * name or error code may occur only once among them: the boundary events of one activity, the
+ * targets of one event-based gateway, the start events of the scope's event sub-processes and the
+ * start events of a process (none for a sub-process).
+ */
+export class C8SubscriptionGroups {
+  readonly boundaryGroups: Array<{ activity: ModdleElement; boundaries: ModdleElement[] }>;
+  readonly gatewayTargets: Array<{ gateway: ModdleElement; targets: ModdleElement[] }>;
+  readonly eventSubProcessStarts: ModdleElement[];
+  readonly processStarts: ModdleElement[];
+
+  constructor(scope: ModdleElement, flows: FlowIndex) {
+    const nodes: ModdleElement[] = (scope.get('flowElements') ?? []).filter((element: ModdleElement) => is(element, 'bpmn:FlowNode'));
+    const boundariesByActivity = new Map<ModdleElement, ModdleElement[]>();
+    for (const node of nodes) {
+      const host = is(node, 'bpmn:BoundaryEvent') ? node.get('attachedToRef') : undefined;
+      if (host) {
+        boundariesByActivity.set(host, [...(boundariesByActivity.get(host) ?? []), node]);
+      }
+    }
+    this.boundaryGroups = nodes.filter((node) => is(node, 'bpmn:Activity') && boundariesByActivity.has(node)).map((activity) => ({ activity, boundaries: boundariesByActivity.get(activity)! }));
+    this.gatewayTargets = nodes.filter((node) => is(node, 'bpmn:EventBasedGateway')).map((gateway) => ({ gateway, targets: flows.outgoing(gateway).map((flow) => flow.get('targetRef')).filter((target) => target && is(target, 'bpmn:IntermediateCatchEvent')) }));
+    this.eventSubProcessStarts = nodes.filter((node) => EngineScope.isEventSubProcess(node)).flatMap((subProcess) => (subProcess.get('flowElements') ?? []).filter((element: ModdleElement) => is(element, 'bpmn:StartEvent')));
+    this.processStarts = is(scope, 'bpmn:Process') ? nodes.filter((node) => is(node, 'bpmn:StartEvent')) : [];
+  }
+}
diff --git a/src/adapters/out/bpmnlint/engine/rules/c8/support/FlowIndex.ts b/src/adapters/out/bpmnlint/engine/rules/c8/support/FlowIndex.ts
new file mode 100644
index 00000000..4dd129a7
--- /dev/null
+++ b/src/adapters/out/bpmnlint/engine/rules/c8/support/FlowIndex.ts
@@ -0,0 +1,32 @@
+import { is } from 'bpmnlint-utils';
+
+import type { ModdleElement } from '@miragon/bpmnlint-plugin-rules/engine';
+
+/** The sequence flows out of each flow node, indexed once per (sub-)process. */
+export class FlowIndex {
+  private readonly byContainer = new WeakMap<object, Map<ModdleElement, ModdleElement[]>>();
+
+  /** The sequence flows whose sourceRef is `node`, in document order. */
+  outgoing(node: ModdleElement): ModdleElement[] {
+    const container = node.$parent;
+    if (!container) return [];
+    let bySource = this.byContainer.get(container);
+    if (!bySource) {
+      bySource = this.index(container);
+      this.byContainer.set(container, bySource);
+    }
+    return bySource.get(node) ?? [];
+  }
+
+  private index(container: ModdleElement): Map<ModdleElement, ModdleElement[]> {
+    const bySource = new Map<ModdleElement, ModdleElement[]>();
+    for (const element of container.get?.('flowElements') ?? []) {
+      const source = is(element, 'bpmn:SequenceFlow') ? element.get('sourceRef') : undefined;
+      if (!source) continue;
+      const flows = bySource.get(source) ?? [];
+      flows.push(element);
+      bySource.set(source, flows);
+    }
+    return bySource;
+  }
+}
diff --git a/src/domain/validation/profiles/TimerValue.ts b/src/adapters/out/bpmnlint/engine/rules/c8/support/TimerValue.ts
similarity index 100%
rename from src/domain/validation/profiles/TimerValue.ts
rename to src/adapters/out/bpmnlint/engine/rules/c8/support/TimerValue.ts
diff --git a/src/adapters/out/bpmnlint/engine/rules/c8/support/ZeebeHint.ts b/src/adapters/out/bpmnlint/engine/rules/c8/support/ZeebeHint.ts
new file mode 100644
index 00000000..8c68fb9e
--- /dev/null
+++ b/src/adapters/out/bpmnlint/engine/rules/c8/support/ZeebeHint.ts
@@ -0,0 +1,78 @@
+import type { ModdleElement } from '@miragon/bpmnlint-plugin-rules/engine';
+import { DiagramNamespaces, ZEEBE_URI } from '../../support/DiagramNamespaces.js';
+import { ElementKinds } from '../../support/ElementKinds.js';
+import { SetCommand } from '../../support/SetCommand.js';
+import { Shell } from '../../support/Shell.js';
+
+/**
+ * The `bpmn` commands a Camunda 8 hint gives for one BPMN element: addressed by its id, or by the
+ * id of its flow node or flow and a slot (`definition.`, `loop.`) for a nested one, with zeebe
+ * elements spelled with the prefix the file declares.
+ */
+export class ZeebeHint extends SetCommand {
+  private constructor(address: SetCommand, private readonly prefix: string) {
+    super(address.id, address.slot);
+  }
+
+  /** The hint commands for `el`; undefined when `bpmn` cannot address it (no id, not nested). */
+  static of(el: ModdleElement): ZeebeHint | undefined {
+    const address = SetCommand.at(el);
+    return address && new ZeebeHint(address, ZeebeHint.prefixOf(el));
+  }
+
+  /** `zeebe:taskDefinition` for `taskDefinition`, in the file's spelling. */
+  name(local: string): string {
+    return `${this.prefix}:${local}`;
+  }
+
+  /** The element name of a typed zeebe element, `zeebe:taskDefinition` for `zeebe:TaskDefinition`, in the file's spelling. */
+  nameOf(element: ModdleElement): string {
+    return ZeebeHint.typeName(element).replace(/^[^:]*:/, `${this.prefix}:`);
+  }
+
+  /** `bpmn ext add --replace` that writes the zeebe element anew with `fix` laid over its attributes, those the descriptor knows and the unknown ones; the rebuild hint when it has child elements. */
+  replace(element: ModdleElement, fix: Record<string, string>): string {
+    const properties: Array<{ name: string; isAttr?: boolean }> = element.$descriptor?.properties ?? [];
+    if (properties.some(({ name, isAttr }) => !isAttr && (Array.isArray(element[name]) ? element[name].length > 0 : element[name] !== undefined && typeof element[name] === 'object'))) {
+      return this.rebuild(this.nameOf(element));
+    }
+    const attributes: Record<string, string> = {};
+    for (const { name, isAttr } of properties) {
+      if (isAttr && Object.hasOwn(element, name) && element[name] !== undefined && element[name] !== null && typeof element[name] !== 'object') {
+        attributes[name] = String(element[name]);
+      }
+    }
+    for (const [key, value] of Object.entries(element.$attrs ?? {})) {
+      if (!key.startsWith('xmlns') && value !== undefined && value !== null) {
+        attributes[key] = String(value);
+      }
+    }
+    return this.replaceWith(this.nameOf(element), attributes, fix);
+  }
+
+  /** `replace` for the attributes as the typed element holds them, the element named by its type; without an address, the XML. */
+  static fix(host: ModdleElement, element: ModdleElement, fix: Record<string, string>): string {
+    const hint = ZeebeHint.of(host);
+    const written = Object.entries(element).filter(([key]) => !key.startsWith('$'));
+    if (written.some(([, value]) => value !== null && typeof value === 'object' && (!Array.isArray(value) || value.length > 0))) {
+      return hint ? hint.rebuild(ZeebeHint.typeName(element)) : 'Fix it in the XML.';
+    }
+    const attributes = Object.fromEntries(written.filter(([, value]) => value !== undefined && value !== null && typeof value !== 'object').map(([key, value]) => [key, String(value)]));
+    return hint ? hint.replaceWith(ZeebeHint.typeName(element), attributes, fix) : 'edit the XML.';
+  }
+
+  /** `zeebe:TaskDefinition` -> `zeebe:taskDefinition`, the element name a message shows. */
+  static typeName(element: ModdleElement): string {
+    return ElementKinds.xmlName(String(element.$type));
+  }
+
+  /** The prefix the diagram of `el` declares for the zeebe namespace, `zeebe` when it declares none. */
+  static prefixOf(el: ModdleElement): string {
+    return DiagramNamespaces.forElement(el).prefixOf(ZEEBE_URI) ?? 'zeebe';
+  }
+
+  private replaceWith(name: string, attributes: Record<string, string>, fix: Record<string, string>): string {
+    const args = Object.entries({ ...attributes, ...fix }).map(([key, value]) => Shell.quote(`${key}=${value}`));
+    return `${this.extAdd([name, ...args, '--replace'].join(' '))}.`;
+  }
+}
diff --git a/src/domain/validation/profiles/FeelExpression.ts b/src/adapters/out/bpmnlint/engine/rules/c8/support/feel/FeelExpression.ts
similarity index 74%
rename from src/domain/validation/profiles/FeelExpression.ts
rename to src/adapters/out/bpmnlint/engine/rules/c8/support/feel/FeelExpression.ts
index d3f66b10..aedd3ba8 100644
--- a/src/domain/validation/profiles/FeelExpression.ts
+++ b/src/adapters/out/bpmnlint/engine/rules/c8/support/feel/FeelExpression.ts
@@ -1,9 +1,18 @@
-import { FeelError } from './FeelError.js';
-import { FeelParser } from './FeelParser.js';
+import { FeelError, FeelParser } from './FeelParser.js';
 
 export class FeelExpression {
   constructor(private readonly expression: string) {}
 
+  /**
+   * `${a && b}` -> ` a and b`: a starting point for FEEL (the hint asks to check it). Single-quoted
+   * JUEL strings become double-quoted FEEL strings.
+   */
+  static fromJuel(juel: string): string {
+    const match = /^\s*[$#]\{([\s\S]*)\}\s*$/.exec(juel);
+    const quoted = (match ? match[1]! : juel).trim().replace(/'((?:[^'\\]|\\.)*)'/g, (_match, text: string) => `"${text.replace(/"/g, '\\"')}"`);
+    return ` ${quoted.replace(/&&/g, 'and').replace(/\|\|/g, 'or').replace(/==/g, '=').replace(/!\s*\((?!=)/g, 'not(').replace(/!(?!=)\s*([\w.]+)/g, 'not($1)')}`;
+  }
+
   /** Why Camunda 8 refuses the expression at deploy: JUEL habits first, then the FEEL syntax. */
   problem(): string | undefined {
     const expression = this.expression;
diff --git a/src/domain/validation/profiles/FeelParser.ts b/src/adapters/out/bpmnlint/engine/rules/c8/support/feel/FeelParser.ts
similarity index 91%
rename from src/domain/validation/profiles/FeelParser.ts
rename to src/adapters/out/bpmnlint/engine/rules/c8/support/feel/FeelParser.ts
index 31881a80..35d8b3a6 100644
--- a/src/domain/validation/profiles/FeelParser.ts
+++ b/src/adapters/out/bpmnlint/engine/rules/c8/support/feel/FeelParser.ts
@@ -1,5 +1,3 @@
-import { FeelError } from './FeelError.js';
-
 type Kind = 'num' | 'str' | 'temporal' | 'word' | 'tick' | 'op' | 'end';
 
 interface Tok {
@@ -10,33 +8,23 @@ interface Tok {
   nl: boolean;
 }
 
+export class FeelError extends Error {
+  constructor(readonly at: number, message: string) {
+    super(message);
+  }
+}
+
 const RESERVED = new Set(['then', 'else', 'in', 'return', 'satisfies', 'function', 'and', 'or', 'true', 'false', 'null']);
 /** Other function names with spaces hold no reserved word: `foo then bar(1)` is refused. */
 const KEYWORD_CALLS = [['get', 'or', 'else']];
-const MULTI_WORD_TYPES = [
-  ['days', 'and', 'time', 'duration'],
-  ['years', 'and', 'months', 'duration'],
-  ['date', 'and', 'time'],
-];
+const MULTI_WORD_TYPES = [['days', 'and', 'time', 'duration'], ['years', 'and', 'months', 'duration'], ['date', 'and', 'time']];
 
 const NAME_START = /[\p{L}\p{Nl}\p{Sc}\p{Pc}]/u;
 const NAME_PART = /[\p{L}\p{Nl}\p{Sc}\p{Pc}\p{Nd}\p{Mn}\p{Mc}\p{Cf}\u007f-\u009f]/u;
 const SPACE = /[ \t\r\n\f\v\u2000-\u200a\u2028\u2029\u3000\ufeff]/;
 const OPERATORS = ['**', '<=', '>=', '!=', '..', '*', '/', '+', '-', '<', '>', '=', '.', ',', '(', ')', '[', ']', '{', '}', ':'];
 
-const STRAY: Record<string, string> = {
-  '&': '& (FEEL: and)',
-  '|': '| (FEEL: or)',
-  '%': '% (FEEL has no modulo operator: modulo(a, b))',
-  '^': '^ (FEEL: ** for powers)',
-  '!': '! (FEEL: not(...))',
-  "'": "' (FEEL strings use double quotes)",
-  '\\': 'a backslash outside a string',
-  ';': ';',
-  '#': '#',
-  '~': '~',
-  '\u00a0': 'a non-breaking space',
-};
+const STRAY: Record<string, string> = { '&': '& (FEEL: and)', '|': '| (FEEL: or)', '%': '% (FEEL has no modulo operator: modulo(a, b))', '^': '^ (FEEL: ** for powers)', '\\': 'a backslash outside a string', ';': ';', '#': '#', '~': '~', '\u00a0': 'a non-breaking space' };
 
 /**
  * The FEEL grammar Camunda 8.9 accepts at deploy, written down from 766 deployed expressions;
@@ -99,7 +87,7 @@ export class FeelParser {
    * Camunda's parser reads a keyword at the start of a longer word as the keyword:
    * `x andy` is `x and y`. The token is split then; either() undoes it.
    */
-  private kw(word: string, offset = 0): boolean {
+  private isKeyword(word: string, offset = 0): boolean {
     const token = this.peek(offset);
     if (token.kind !== 'word' || !token.text.startsWith(word)) return false;
     if (token.text === word) return true;
@@ -109,13 +97,22 @@ export class FeelParser {
     } catch {
       return false;
     }
-    const at = Math.min(this.pos + offset, this.tokens.length - 1);
-    this.tokens = [...this.tokens.slice(0, at), { ...token, text: word }, ...rest.map((restToken) => ({ ...restToken, pos: restToken.pos + token.pos + word.length, nl: false })), ...this.tokens.slice(at + 1)];
+    const index = Math.min(this.pos + offset, this.tokens.length - 1);
+    this.tokens = [
+      ...this.tokens.slice(0, index),
+      { ...token, text: word },
+      ...rest.map((restToken) => ({
+        ...restToken,
+        pos: restToken.pos + token.pos + word.length,
+        nl: false,
+      })),
+      ...this.tokens.slice(index + 1),
+    ];
     return true;
   }
 
   private expectKw(word: string, what: string): void {
-    if (!this.kw(word)) this.unexpected(what);
+    if (!this.isKeyword(word)) this.unexpected(what);
     this.pos++;
   }
 
@@ -167,11 +164,11 @@ export class FeelParser {
   }
 
   /** When both readings fail, the error that got further wins. */
-  private either(fn: () => void, fallback: () => void): void {
+  private either(attempt: () => void, fallback: () => void): void {
     const start = this.pos;
     const tokens = this.tokens;
     try {
-      fn();
+      attempt();
       return;
     } catch (first) {
       if (!(first instanceof FeelError)) throw first;
@@ -198,7 +195,10 @@ export class FeelParser {
         ['every', () => this.quantified()],
       ] as const) {
         if (token.text.startsWith(word)) {
-          return this.either(() => (this.kw(word), form()), () => this.disjunction());
+          return this.either(
+            () => (this.isKeyword(word), form()),
+            () => this.disjunction(),
+          );
         }
       }
     }
@@ -224,11 +224,11 @@ export class FeelParser {
   }
 
   private quantified(): void {
-    const kw = this.next().text;
+    const quantifier = this.next().text;
     do {
       this.iteration();
     } while (this.eatOp(','));
-    this.expectKw('satisfies', `${kw} ... in ... needs satisfies: ${kw} x in xs satisfies x > 1`);
+    this.expectKw('satisfies', `${quantifier} ... in ... needs satisfies: ${quantifier} x in xs satisfies x > 1`);
     this.textual();
   }
 
@@ -246,7 +246,7 @@ export class FeelParser {
 
   private disjunction(): void {
     this.conjunction();
-    while (this.kw('or')) {
+    while (this.isKeyword('or')) {
       this.next();
       this.conjunction();
     }
@@ -254,7 +254,7 @@ export class FeelParser {
 
   private conjunction(): void {
     this.comparison();
-    while (this.kw('and')) {
+    while (this.isKeyword('and')) {
       this.next();
       this.comparison();
     }
@@ -275,7 +275,7 @@ export class FeelParser {
     if (['=', '!=', '<', '<=', '>', '>='].some((operator) => this.isOp(operator))) {
       this.next();
       this.sum();
-    } else if (this.kw('between')) {
+    } else if (this.isKeyword('between')) {
       this.next();
       this.sum();
       this.expectKw('and', 'between needs and: x between 1 and 5');
@@ -283,7 +283,7 @@ export class FeelParser {
     } else if (this.isWord() && this.peek().text.startsWith('in')) {
       this.either(
         () => {
-          if (!this.kw('instance')) this.unexpected();
+          if (!this.isKeyword('instance')) this.unexpected();
           this.next();
           this.expectKw('of', 'instance of needs of: x instance of number');
           this.typeName();
@@ -599,16 +599,16 @@ export class FeelParser {
   private static tokenize(src: string): Tok[] {
     const out: Tok[] = [];
     let index = 0;
-    let nl = false;
+    let lineBreak = false;
     const push = (kind: Kind, text: string, pos: number): void => {
-      out.push({ kind, text, pos, nl });
-      nl = false;
+      out.push({ kind, text, pos, nl: lineBreak });
+      lineBreak = false;
     };
     while (index < src.length) {
       const char = src[index]!;
       if (SPACE.test(char)) {
         if (char === '\n' || char === '\r' || char === '\u2028' || char === '\u2029') {
-          nl = true;
+          lineBreak = true;
         }
         index++;
         continue;
@@ -622,7 +622,7 @@ export class FeelParser {
       if (char === '/' && src[index + 1] === '*') {
         const end = src.indexOf('*/', index + 2);
         if (end === -1) throw new FeelError(index, 'an unterminated comment');
-        if (/[\n\r]/.test(src.slice(index, end))) nl = true;
+        if (/[\n\r]/.test(src.slice(index, end))) lineBreak = true;
         index = end + 2;
         continue;
       }
@@ -680,15 +680,15 @@ export class FeelParser {
         index = nameEnd;
         continue;
       }
-      const op = OPERATORS.find((operator) => src.startsWith(operator, index));
-      if (op) {
-        push('op', op, index);
-        index += op.length;
+      const operator = OPERATORS.find((candidate) => src.startsWith(candidate, index));
+      if (operator) {
+        push('op', operator, index);
+        index += operator.length;
         continue;
       }
       throw new FeelError(index, STRAY[char] ?? `the character ${JSON.stringify(char)}`);
     }
-    out.push({ kind: 'end', text: '', pos: src.length, nl });
+    out.push({ kind: 'end', text: '', pos: src.length, nl: lineBreak });
     return out;
   }
 }
diff --git a/src/adapters/out/bpmnlint/engine/rules/support/DiagramNamespaces.ts b/src/adapters/out/bpmnlint/engine/rules/support/DiagramNamespaces.ts
new file mode 100644
index 00000000..fdb1bfb9
--- /dev/null
+++ b/src/adapters/out/bpmnlint/engine/rules/support/DiagramNamespaces.ts
@@ -0,0 +1,66 @@
+import { is } from 'bpmnlint-utils';
+
+import type { ModdleElement } from '@miragon/bpmnlint-plugin-rules/engine';
+
+export const ZEEBE_URI = 'http://camunda.org/schema/zeebe/1.0';
+export const CAMUNDA_URI = 'http://camunda.org/schema/1.0/bpmn';
+/** Camunda 7 content, in its own namespace and in Operaton's copy of it. */
+export const C7_URIS = [CAMUNDA_URI, 'http://operaton.org/schema/1.0/bpmn'];
+
+/**
+ * The prefixes a typed parse writes for the engine packages, whatever the file spells: an unknown
+ * attribute of `xmlns:z="...zeebe/1.0"` lands in `$attrs` as `zeebe:foo`.
+ */
+const PACKAGE_URIS: Record<string, string> = { zeebe: ZEEBE_URI, camunda: CAMUNDA_URI };
+
+/**
+ * The namespace prefixes a diagram declares, so a rule can tell which namespace an attribute the
+ * moddle left in `$attrs` belongs to: a typed parse keeps unknown attributes there under the
+ * prefix the file spells, which says nothing on its own.
+ */
+export class DiagramNamespaces {
+  private static readonly byDefinitions = new WeakMap<object, DiagramNamespaces>();
+
+  private readonly uriByPrefix = new Map<string, string>();
+
+  private constructor(definitions: ModdleElement) {
+    for (const [name, uri] of Object.entries(definitions?.$attrs ?? {})) {
+      if (name.startsWith('xmlns:') && typeof uri === 'string') {
+        this.uriByPrefix.set(name.slice('xmlns:'.length), uri);
+      }
+    }
+  }
+
+  /** The `bpmn:Definitions` of the diagram `node` belongs to. */
+  static definitionsOf(node: ModdleElement): ModdleElement | undefined {
+    let definitions = node;
+    while (definitions && !is(definitions, 'bpmn:Definitions')) {
+      definitions = definitions.$parent;
+    }
+    return definitions;
+  }
+
+  /** The namespaces of the diagram `node` belongs to. */
+  static forElement(node: ModdleElement): DiagramNamespaces {
+    const definitions = DiagramNamespaces.definitionsOf(node);
+    const key = definitions ?? DiagramNamespaces;
+    let namespaces = DiagramNamespaces.byDefinitions.get(key);
+    if (!namespaces) {
+      DiagramNamespaces.byDefinitions.set(key, (namespaces = new DiagramNamespaces(definitions)));
+    }
+    return namespaces;
+  }
+
+  /** The URI of a prefixed name (`zeebe:foo`), or of the prefix of a type (`zeebe:TaskDefinition`). */
+  uriOf(prefixedName: string): string | undefined {
+    const colon = prefixedName.indexOf(':');
+    if (colon === -1) return undefined;
+    const prefix = prefixedName.slice(0, colon);
+    return this.uriByPrefix.get(prefix) ?? PACKAGE_URIS[prefix];
+  }
+
+  /** The first prefix the diagram declares for `uri`. */
+  prefixOf(uri: string): string | undefined {
+    return [...this.uriByPrefix].find(([, declared]) => declared === uri)?.[0];
+  }
+}
diff --git a/src/adapters/out/bpmnlint/engine/rules/support/DidYouMean.ts b/src/adapters/out/bpmnlint/engine/rules/support/DidYouMean.ts
new file mode 100644
index 00000000..36d1edbb
--- /dev/null
+++ b/src/adapters/out/bpmnlint/engine/rules/support/DidYouMean.ts
@@ -0,0 +1,23 @@
+import { RuleKit } from '../RuleKit.js';
+
+/** The name a typo most likely meant. */
+export class DidYouMean {
+  /** The closest candidate within a small edit distance (a quarter of the name), preferring `preferred`. */
+  static of(name: string, candidates: string[], preferred: string[] = []): string | undefined {
+    const limit = Math.max(1, Math.floor(name.length / 4));
+    let best: { candidate: string; distance: number } | undefined;
+    for (const candidate of [...preferred, ...candidates]) {
+      const distance = RuleKit.kit.levenshtein(name.toLowerCase(), candidate.toLowerCase());
+      if (distance <= limit && (!best || distance < best.distance)) {
+        best = { candidate, distance };
+      }
+    }
+    return best?.candidate;
+  }
+
+  /** ` (did you mean <closest>?)`, or '' without a close candidate. */
+  static suggestion(name: string, candidates: string[]): string {
+    const guess = DidYouMean.of(name, candidates);
+    return guess ? ` (did you mean ${guess}?)` : '';
+  }
+}
diff --git a/src/adapters/out/bpmnlint/engine/rules/support/ElementKinds.ts b/src/adapters/out/bpmnlint/engine/rules/support/ElementKinds.ts
new file mode 100644
index 00000000..636e043c
--- /dev/null
+++ b/src/adapters/out/bpmnlint/engine/rules/support/ElementKinds.ts
@@ -0,0 +1,39 @@
+import type { ModdleElement } from '@miragon/bpmnlint-plugin-rules/engine';
+import { RuleKit } from '../RuleKit.js';
+
+/** How bpmn-cli names a BPMN element's kind (`endEvent:message`). */
+export class ElementKinds {
+  /** `userTask`, `endEvent:message`; `camunda:InputOutput` for a vendor element. */
+  static of(el: ModdleElement): string {
+    const type = String(el.$type ?? '');
+    const kind = type.startsWith('bpmn:') ? RuleKit.kit.kindLabel(el).replace(/^bpmn:/, '') : type.replace(/^bpmn:/, '');
+    return kind.charAt(0).toLowerCase() + kind.slice(1);
+  }
+
+  /** `userTask`, `activity, gateway, event, ...`: BPMN types as a message lists them, the first `limit` only. */
+  static list(types: string[], limit = Number.POSITIVE_INFINITY): string {
+    const names = types.map((type) => type.replace(/^bpmn:/, '')).map((local) => local.charAt(0).toLowerCase() + local.slice(1));
+    return names.length > limit ? `${names.slice(0, limit).join(', ')}, ...` : names.join(', ');
+  }
+
+  /**
+   * How an engine message names an element: `serviceTask Activity_1`, or for an element without an
+   * id `the multiInstanceLoopCharacteristics of serviceTask Activity_1`.
+   */
+  static describe(el: ModdleElement, owner?: ModdleElement): string {
+    const kind = ElementKinds.of(el);
+    if (el.id) return `${kind} ${el.id}`;
+    return owner ? `the ${kind.replace(/^[^:]*:/, '')} of ${ElementKinds.describe(owner)}` : kind;
+  }
+
+  /** A type as the XML names its element: `zeebe:TaskDefinition` -> `zeebe:taskDefinition`, `InputOutput` -> `inputOutput`. */
+  static xmlName(type: string): string {
+    const colon = type.indexOf(':');
+    return `${type.slice(0, colon + 1)}${type.charAt(colon + 1).toLowerCase()}${type.slice(colon + 2)}`;
+  }
+
+  /** How an engine message names the trigger of an event definition: `timer`, `message`, ... */
+  static trigger(definition: ModdleElement): string {
+    return ElementKinds.xmlName(String(definition.$type).replace(/^[^:]*:/, '').replace(/EventDefinition$/, ''));
+  }
+}
diff --git a/src/adapters/out/bpmnlint/engine/rules/support/EngineScope.ts b/src/adapters/out/bpmnlint/engine/rules/support/EngineScope.ts
new file mode 100644
index 00000000..bcc3b7b2
--- /dev/null
+++ b/src/adapters/out/bpmnlint/engine/rules/support/EngineScope.ts
@@ -0,0 +1,49 @@
+import { is } from 'bpmnlint-utils';
+
+import type { ModdleElement } from '@miragon/bpmnlint-plugin-rules/engine';
+
+/** Where an engine runs content: executable processes, without the content of the sub-process kind it skips (Camunda 7: an ad-hoc sub-process; Camunda 8: a transaction, refused as a whole). */
+export class EngineScope {
+  static readonly C7 = new EngineScope('bpmn:AdHocSubProcess');
+  static readonly C8 = new EngineScope('bpmn:Transaction');
+
+  private constructor(private readonly skipped: string) {}
+
+  /** Whether `node` is in (or is) an executable process and inside no skipped sub-process; the skipped one itself counts. */
+  runs(node: ModdleElement): boolean {
+    let ancestor = node;
+    while (ancestor && !is(ancestor, 'bpmn:Process')) {
+      ancestor = ancestor.$parent;
+      if (ancestor && is(ancestor, this.skipped)) return false;
+    }
+    return ancestor?.isExecutable === true;
+  }
+
+  /** Whether the engine runs `node`, a skipped sub-process not. */
+  contains(node: ModdleElement): boolean {
+    return !is(node, this.skipped) && this.runs(node);
+  }
+
+  /** Whether `node` is (in) an executable process, wherever in it: what camunda-compat checks. */
+  static inExecutableProcess(node: ModdleElement): boolean {
+    let process = node;
+    while (process && !is(process, 'bpmn:Process')) {
+      process = process.$parent;
+    }
+    return process?.isExecutable === true;
+  }
+
+  /** The process or sub-process whose flow elements hold `node`. */
+  static scopeOf(node: ModdleElement): ModdleElement | undefined {
+    for (let ancestor = node.$parent; ancestor; ancestor = ancestor.$parent) {
+      if (is(ancestor, 'bpmn:Process') || is(ancestor, 'bpmn:SubProcess')) {
+        return ancestor;
+      }
+    }
+    return undefined;
+  }
+
+  static isEventSubProcess(node: ModdleElement): boolean {
+    return !!node && is(node, 'bpmn:SubProcess') && node.triggeredByEvent === true;
+  }
+}
diff --git a/src/adapters/out/bpmnlint/engine/rules/support/FirstOfKey.ts b/src/adapters/out/bpmnlint/engine/rules/support/FirstOfKey.ts
new file mode 100644
index 00000000..7819b649
--- /dev/null
+++ b/src/adapters/out/bpmnlint/engine/rules/support/FirstOfKey.ts
@@ -0,0 +1,11 @@
+/** The first item of each key, in the order the items come: a later item with the key repeats it. */
+export class FirstOfKey<T> {
+  private readonly firsts = new Map<string, T>();
+
+  /** The first item of `key` when `item` repeats it, else undefined, and `item` is the first. */
+  repeats(key: string, item: T): T | undefined {
+    const first = this.firsts.get(key);
+    if (first === undefined) this.firsts.set(key, item);
+    return first;
+  }
+}
diff --git a/src/adapters/out/bpmnlint/engine/rules/support/LinkEvents.ts b/src/adapters/out/bpmnlint/engine/rules/support/LinkEvents.ts
new file mode 100644
index 00000000..54e3dcfd
--- /dev/null
+++ b/src/adapters/out/bpmnlint/engine/rules/support/LinkEvents.ts
@@ -0,0 +1,66 @@
+import { is } from 'bpmnlint-utils';
+
+import type { ModdleElement } from '@miragon/bpmnlint-plugin-rules/engine';
+
+/** A link throw event and the (sub-)process it throws in. */
+export interface LinkThrow {
+  el: ModdleElement;
+  name: string;
+  scope: ModdleElement;
+}
+
+/** A link catch event whose name an earlier catch event of the process already has. */
+export interface DuplicateLinkCatch {
+  first: ModdleElement;
+  el: ModdleElement;
+  name: string;
+}
+
+/**
+ * The link events of a process, as both engines resolve them: a throw jumps to the catch of its
+ * name in its own (sub-)process, and catch names are unique in the process.
+ */
+export class LinkEvents {
+  private readonly firstCatch = new Map<string, ModdleElement>();
+  private readonly caughtIn = new Map<ModdleElement, Set<string>>();
+  private readonly throws: LinkThrow[] = [];
+  private readonly duplicates: DuplicateLinkCatch[] = [];
+
+  /** `linkName`: the link name a node throws or catches, `undefined` for any other node. */
+  constructor(process: ModdleElement, linkName: (node: ModdleElement) => string | undefined) {
+    this.collect(process, linkName);
+  }
+
+  /** The second and later catch events of a name, in document order. */
+  duplicateCatches(): DuplicateLinkCatch[] {
+    return this.duplicates;
+  }
+
+  /** The throw events whose (sub-)process has no catch event of their name. */
+  unmatchedThrows(): LinkThrow[] {
+    return this.throws.filter((linkThrow) => !this.caughtIn.get(linkThrow.scope)?.has(linkThrow.name));
+  }
+
+  /** The first catch event of a name, wherever it is in the process. */
+  catchNamed(name: string): ModdleElement | undefined {
+    return this.firstCatch.get(name);
+  }
+
+  private collect(scope: ModdleElement, linkName: (node: ModdleElement) => string | undefined): void {
+    for (const node of scope.flowElements ?? []) {
+      const name = linkName(node);
+      if (name !== undefined && is(node, 'bpmn:IntermediateCatchEvent')) {
+        const first = this.firstCatch.get(name);
+        if (first) {
+          this.duplicates.push({ first, el: node, name });
+        } else {
+          this.firstCatch.set(name, node);
+        }
+        this.caughtIn.set(scope, new Set([...(this.caughtIn.get(scope) ?? []), name]));
+      } else if (name !== undefined && is(node, 'bpmn:IntermediateThrowEvent')) {
+        this.throws.push({ el: node, name, scope });
+      }
+      if (node.flowElements) this.collect(node, linkName);
+    }
+  }
+}
diff --git a/src/adapters/out/bpmnlint/engine/rules/support/ModdlePath.ts b/src/adapters/out/bpmnlint/engine/rules/support/ModdlePath.ts
new file mode 100644
index 00000000..4eb13fbc
--- /dev/null
+++ b/src/adapters/out/bpmnlint/engine/rules/support/ModdlePath.ts
@@ -0,0 +1,46 @@
+import { is } from 'bpmnlint-utils';
+
+import type { ModdleElement, ReportPath } from '@miragon/bpmnlint-plugin-rules/engine';
+import { SetCommand } from './SetCommand.js';
+
+/** Where a finding on a nested element goes: the element it is reported on, and the property path from there, as camunda-compat spells it. */
+export class ModdlePath {
+  /** The flow node or flow of an event definition, loop or condition, else the nearest element with an id (`node` itself when it has one). */
+  static ownerOf(node: ModdleElement): ModdleElement | undefined {
+    const parent = node.$parent;
+    if (parent?.id && SetCommand.slotIn(parent, node)) return parent;
+    let owner = node;
+    while (owner && !owner.id) {
+      owner = owner.$parent;
+    }
+    return owner;
+  }
+
+  /** The nearest element with an id from `start` up, below `bpmn:Definitions`. */
+  static nearestWithId(start: ModdleElement | undefined): ModdleElement | undefined {
+    for (let current = start; current && !is(current, 'bpmn:Definitions'); current = current.$parent) {
+      if (current.id) return current;
+    }
+    return undefined;
+  }
+
+  /** The property steps from `ancestor` down to `descendant`: `['loopCharacteristics', 'extensionElements', 'values', 0]`. */
+  static between(ancestor: ModdleElement, descendant: ModdleElement): ReportPath {
+    const steps: ReportPath = [];
+    for (let child = descendant; child && child !== ancestor && child.$parent; child = child.$parent) {
+      steps.unshift(...ModdlePath.stepInto(child.$parent, child));
+    }
+    return steps;
+  }
+
+  private static stepInto(parent: ModdleElement, child: ModdleElement): ReportPath {
+    for (const property of parent.$descriptor?.properties ?? []) {
+      const value = parent.get(property.name);
+      if (value === child) return [property.ns?.localName ?? property.name];
+      if (Array.isArray(value) && value.includes(child)) {
+        return [property.ns?.localName ?? property.name, value.indexOf(child)];
+      }
+    }
+    return [];
+  }
+}
diff --git a/src/adapters/out/bpmnlint/engine/rules/support/SetCommand.ts b/src/adapters/out/bpmnlint/engine/rules/support/SetCommand.ts
new file mode 100644
index 00000000..699b555a
--- /dev/null
+++ b/src/adapters/out/bpmnlint/engine/rules/support/SetCommand.ts
@@ -0,0 +1,69 @@
+import type { ModdleElement } from '@miragon/bpmnlint-plugin-rules/engine';
+import { Shell } from './Shell.js';
+
+/** The slot `bpmn set` gives a part of a flow node or flow. */
+const SLOTS: Array<[property: string, slot: string]> = [['eventDefinitions', 'definition'], ['loopCharacteristics', 'loop'], ['conditionExpression', 'condition']];
+
+/**
+ * How `bpmn set` and `bpmn ext` address an element: its id, or the id of the flow node or flow of
+ * a nested element with its slot (`definition.`, `definition[1].`, `loop.`, `condition.`). Without
+ * an id to address, the fix goes into the XML.
+ */
+export class SetCommand {
+  constructor(readonly id: string | undefined, readonly slot = '') {}
+
+  /** The address of `el`: through the slot of its flow node or flow, else its own id; undefined without either. */
+  static at(el: ModdleElement): SetCommand | undefined {
+    const parent = el.$parent;
+    const slot = parent?.id ? SetCommand.slotIn(parent, el) : '';
+    if (slot) return new SetCommand(parent.id, slot);
+    return el.id ? new SetCommand(el.id) : undefined;
+  }
+
+  /** The slot of `el` in `parent` when it is an event definition, loop or condition of it, else ''. */
+  static slotIn(parent: ModdleElement, el: ModdleElement): string {
+    for (const [property, slot] of SLOTS) {
+      const value = parent[property];
+      if (value === el) return `${slot}.`;
+      if (Array.isArray(value) && value.includes(el)) {
+        return value.length > 1 ? `${slot}[${value.indexOf(el)}].` : `${slot}.`;
+      }
+    }
+    return '';
+  }
+
+  /** On the event definition at `index` of `event`: `definition.`, or of several `definition[1].`. */
+  static forDefinition(event: ModdleElement, index: number): SetCommand {
+    return new SetCommand(event.id, event.get('eventDefinitions').length > 1 ? `definition[${index}].` : 'definition.');
+  }
+
+  /** `` `bpmn set <file> X 'definition.camunda:type=external'` ``, or `edit the XML`. */
+  of(...assignments: string[]): string {
+    return this.id ? `\`bpmn set <file> ${this.id} ${assignments.map((assignment) => Shell.quote(`${this.slot}${assignment}`)).join(' ')}\`` : 'edit the XML';
+  }
+
+  /** `` `bpmn set <file> X camunda:asignee=` ``, which removes the attribute `key` as the file spells it. */
+  unset(key: string): string {
+    return `\`bpmn set <file> ${this.id} ${Shell.quote(`${this.slot}${key}=`)}\``;
+  }
+
+  /** `` `bpmn ext add <file> X 'definition.camunda:field' name=a` ``: the first of `args` through the slot. */
+  extAdd(args: string): string {
+    return `\`bpmn ext add <file> ${this.id} ${Shell.slotted(this.slot, args)}\``;
+  }
+
+  /** `` `bpmn ext remove <file> X 'definition.camunda:field[name=a]'` `` */
+  extRemove(selector: string | number): string {
+    return `\`bpmn ext remove <file> ${this.id} ${Shell.quote(`${this.slot}${selector}`)}\``;
+  }
+
+  /** How to rebuild an extension element `name` with child elements: list it, then add it again from its XML, `<open>` its start tag. */
+  rebuild(name: string, open = `${name} ...`): string {
+    return `See it with \`bpmn ext list <file> ${this.id} --json\`, then rebuild it: \`bpmn ext add <file> ${this.id} ${Shell.quote(`${this.slot}${name}`)} --replace --xml '<${open}>...</${name}>'\`.`;
+  }
+
+  /** The `bpmn ext add` arguments that address `type` through the slot (`X 'definition.camunda:field'`). */
+  extTarget(type: string): string | undefined {
+    return this.id ? `${this.id} ${Shell.quote(`${this.slot}${type}`)}` : undefined;
+  }
+}
diff --git a/src/adapters/out/bpmnlint/engine/rules/support/Shell.ts b/src/adapters/out/bpmnlint/engine/rules/support/Shell.ts
new file mode 100644
index 00000000..bca1c3d1
--- /dev/null
+++ b/src/adapters/out/bpmnlint/engine/rules/support/Shell.ts
@@ -0,0 +1,13 @@
+/** How a hint writes a `bpmn` command line. */
+export class Shell {
+  /** Quotes a shell argument when the shell would interpret it (a `<placeholder>` stays as it is). */
+  static quote(argument: string): string {
+    return /^[A-Za-z0-9_.:=,/@+-]*(<[a-zA-Z]+>)?$/.test(argument) ? argument : `'${argument.replace(/'/g, `'\\''`)}'`;
+  }
+
+  /** `<slot><first argument>` shell-quoted (`'definition[1].camunda:field'`), the rest as is. */
+  static slotted(slot: string, args: string): string {
+    const space = args.indexOf(' ');
+    return space === -1 ? Shell.quote(`${slot}${args}`) : `${Shell.quote(`${slot}${args.slice(0, space)}`)}${args.slice(space)}`;
+  }
+}
diff --git a/src/adapters/out/bpmnlint/engine/rules/support/Values.ts b/src/adapters/out/bpmnlint/engine/rules/support/Values.ts
new file mode 100644
index 00000000..a96488a4
--- /dev/null
+++ b/src/adapters/out/bpmnlint/engine/rules/support/Values.ts
@@ -0,0 +1,22 @@
+/** How the engines read a value the file writes as text. */
+export class Values {
+  /** Whether `text` holds more than white space. */
+  static nonEmpty(text: unknown): text is string {
+    return typeof text === 'string' && text.trim() !== '';
+  }
+
+  /** Whether a message or signal has a name as Camunda 8 reads it: white space counts, `''` does not. */
+  static hasName(element: { name?: unknown } | undefined): boolean {
+    return typeof element?.name === 'string' && element.name !== '';
+  }
+
+  /** A FEEL expression for Camunda 8: the value starts with `=` (after white space). */
+  static isFeel(value: unknown): boolean {
+    return typeof value === 'string' && value.trim().startsWith('=');
+  }
+
+  /** Whether `value` is a plain integer or holds a JUEL expression (`${...}` or `#{...}`), as the engines read a priority. */
+  static isPriority(value: string): boolean {
+    return /^[+-]?\d+$/.test(value) || /[$#]\{/.test(value);
+  }
+}
diff --git a/src/adapters/out/bpmnlint/engine/rules/support/VendorHost.ts b/src/adapters/out/bpmnlint/engine/rules/support/VendorHost.ts
new file mode 100644
index 00000000..29008f2c
--- /dev/null
+++ b/src/adapters/out/bpmnlint/engine/rules/support/VendorHost.ts
@@ -0,0 +1,93 @@
+import type { ModdleElement, ReportPath } from '@miragon/bpmnlint-plugin-rules/engine';
+import { DiagramNamespaces } from './DiagramNamespaces.js';
+import { ElementKinds } from './ElementKinds.js';
+import { ModdlePath } from './ModdlePath.js';
+import { SetCommand } from './SetCommand.js';
+
+/** A prefixed attribute the moddle left in `$attrs`, with the namespace its prefix stands for. */
+export interface ForeignAttribute {
+  key: string;
+  local: string;
+  uri: string | undefined;
+}
+
+/** One vendor element inside an extension element (the extension element included), as messages name it. */
+export interface TreeElement {
+  element: ModdleElement;
+  /** `camunda:inputParameter (in camunda:connector > camunda:inputOutput) of serviceTask Activity_1` */
+  where: string;
+  /** The path from the host's reported element to this one. */
+  path: ReportPath;
+}
+
+/**
+ * A BPMN element as the vendor-content checks of both engines see it: the element its findings
+ * land on (an event definition, loop or condition on its flow node or flow, anything without an id
+ * on the nearest element with one), the path from there, how messages name it and how `bpmn set`
+ * and `bpmn ext` address it.
+ */
+export class VendorHost {
+  /** The nearest enclosing element with an id, below `bpmn:Definitions`. */
+  readonly owner: ModdleElement | undefined;
+  /** The element a finding about this host is reported on. */
+  readonly target: ModdleElement;
+  /** How `bpmn set` and `bpmn ext` address this host, undefined without an id to address it by. */
+  readonly address: SetCommand | undefined;
+  private readonly pathPrefix: ReportPath;
+
+  constructor(readonly node: ModdleElement) {
+    this.owner = ModdlePath.nearestWithId(node.$parent);
+    this.address = SetCommand.at(node);
+    this.target = this.address?.slot || !node.id ? (this.owner ?? node) : node;
+    this.pathPrefix = ModdlePath.between(this.target, node);
+  }
+
+  /** `serviceTask Activity_1`, `the multiInstanceLoopCharacteristics of userTask Activity_1` */
+  describe(): string {
+    return ElementKinds.describe(this.node, this.owner);
+  }
+
+  /** The path from the reported element to a property of this host. */
+  path(...steps: ReportPath): ReportPath {
+    return [...this.pathPrefix, ...steps];
+  }
+
+  /** The path from the reported element to a property of the extension element at `index`. */
+  extensionPath(index: number, ...steps: ReportPath): ReportPath {
+    return this.path('extensionElements', 'values', index, ...steps);
+  }
+
+  /** The prefixed attributes the moddle did not type, in file order. */
+  foreignAttributes(): ForeignAttribute[] {
+    return VendorHost.foreignAttributesOf(this.node).filter(({ key }) => key.includes(':'));
+  }
+
+  /** The attributes of any element the moddle did not type, with their namespace when prefixed. */
+  static foreignAttributesOf(el: ModdleElement): ForeignAttribute[] {
+    const namespaces = DiagramNamespaces.forElement(el);
+    return Object.keys(el.$attrs ?? {}).filter((key) => !key.startsWith('xmlns')).map((key) => ({ key, local: key.slice(key.indexOf(':') + 1), uri: namespaces.uriOf(key) }));
+  }
+
+  /** The typed vendor element `root` at `path` and the ones of its package inside it, depth first, named with the file's `prefix`. */
+  tree(root: ModdleElement, prefix: string, path: ReportPath): TreeElement[] {
+    const found: TreeElement[] = [];
+    this.collect(root, prefix, '', path, found);
+    return found;
+  }
+
+  private collect(element: ModdleElement, prefix: string, trail: string, path: ReportPath, found: TreeElement[]): void {
+    const type = String(element.$type);
+    const local = type.slice(type.indexOf(':') + 1);
+    const name = `${prefix}:${ElementKinds.xmlName(local)}`;
+    found.push({ element, where: `${name}${trail ? ` (in ${trail})` : ''} of ${this.describe()}`, path });
+    for (const property of element.$descriptor?.properties ?? []) {
+      if (property.isAttr || property.isReference || !String(property.type).startsWith(type.slice(0, type.indexOf(':') + 1))) {
+        continue;
+      }
+      const propertyName = property.ns?.localName ?? property.name;
+      const value = element.get(property.name);
+      const children: ModdleElement[] = (Array.isArray(value) ? value : [value]).filter(Boolean);
+      children.forEach((child, index) => this.collect(child, prefix, trail ? `${trail} > ${name}` : name, Array.isArray(value) ? [...path, propertyName, index] : [...path, propertyName], found));
+    }
+  }
+}
diff --git a/src/adapters/out/bpmnlint/engine/rules/support/WrittenModel.ts b/src/adapters/out/bpmnlint/engine/rules/support/WrittenModel.ts
new file mode 100644
index 00000000..9f0c356f
--- /dev/null
+++ b/src/adapters/out/bpmnlint/engine/rules/support/WrittenModel.ts
@@ -0,0 +1,65 @@
+import { is } from 'bpmnlint-utils';
+
+import type { ModdleElement } from '@miragon/bpmnlint-plugin-rules/engine';
+import type { EngineKit } from '../../../engine-kit.js';
+import { RuleKit } from '../RuleKit.js';
+import { DiagramNamespaces } from './DiagramNamespaces.js';
+
+const BPMN_TYPE = /^(bpmn|bpmndi|dc|di):/;
+
+export interface WrittenFile {
+  definitions: ModdleElement;
+  namespaces: InstanceType<EngineKit['DocumentNamespaces']>;
+  decisionLinks: InstanceType<EngineKit['DecisionLinkReader']>;
+}
+
+export class WrittenModel {
+  private static readonly recorded = new WeakMap<object, WrittenModel>();
+
+  private readonly writtenByTyped = new WeakMap<object, ModdleElement>();
+  private readonly typedByWritten = new WeakMap<object, ModdleElement>();
+  private readonly walkOrder = new Map<ModdleElement, number>();
+
+  private constructor(typedDefinitions: ModdleElement, readonly file: WrittenFile) {
+    this.pair(typedDefinitions, file.definitions);
+    for (const el of RuleKit.kit.walk(file.definitions)) {
+      this.walkOrder.set(el, this.walkOrder.size);
+    }
+  }
+
+  static record(typedDefinitions: ModdleElement, file: WrittenFile): void {
+    WrittenModel.recorded.set(typedDefinitions, new WrittenModel(typedDefinitions, file));
+  }
+
+  static of(node: ModdleElement): WrittenModel | undefined {
+    const definitions = DiagramNamespaces.definitionsOf(node);
+    return definitions && WrittenModel.recorded.get(definitions);
+  }
+
+  written(typed: ModdleElement): ModdleElement | undefined {
+    return this.writtenByTyped.get(typed);
+  }
+
+  typed(written: ModdleElement): ModdleElement | undefined {
+    return this.typedByWritten.get(written);
+  }
+
+  position(written: ModdleElement): number {
+    return this.walkOrder.get(written) ?? -1;
+  }
+
+  private pair(typed: ModdleElement, written: ModdleElement): void {
+    this.writtenByTyped.set(typed, written);
+    this.typedByWritten.set(written, typed);
+    if (is(typed, 'bpmn:ExtensionElements')) return;
+    for (const { name, isAttr, isReference } of typed.$descriptor.properties) {
+      if (isAttr || isReference) continue;
+      const writtenValues = [written[name]].flat();
+      [typed[name]].flat().forEach((value, index) => {
+        if (BPMN_TYPE.test(value?.$type) && writtenValues[index]?.$type === value.$type) {
+          this.pair(value, writtenValues[index]);
+        }
+      });
+    }
+  }
+}
diff --git a/src/adapters/out/bpmnlint/engine/run/CompatVerdicts.ts b/src/adapters/out/bpmnlint/engine/run/CompatVerdicts.ts
new file mode 100644
index 00000000..9cfebfd2
--- /dev/null
+++ b/src/adapters/out/bpmnlint/engine/run/CompatVerdicts.ts
@@ -0,0 +1,152 @@
+import type { Doc } from '../../../../../domain/document/Doc.js';
+import type { EnginePlatformInfo } from '../../../../../domain/validation/EngineLint.js';
+import type { RuleEntry } from '@miragon/bpmnlint-plugin-rules/engine';
+import type { BpmnlintEngineReport } from '../../bpmnlint-contract.js';
+import type { EngineKit } from '../../engine-kit.js';
+
+type Engine = EnginePlatformInfo['platform'];
+
+/**
+ * Where bpmn-cli reads camunda-compat's severity differently: a user task needs no form to run,
+ * and a job worker user task works (the engines' layers would say runtime for both); Camunda 7.20+
+ * refuses a process without a history time to live unless the engine sets a default.
+ * c8-feel-expression-valid checks FEEL with the grammar Camunda 8 accepts, names and values without = too.
+ */
+const SEVERITY_OVERRIDES: Record<Engine, Record<string, RuleEntry['category'] | 'off'>> = {
+  c7: { 'camunda-compat/history-time-to-live': 'error' },
+  c8: {
+    'camunda-compat/feel': 'off',
+    'camunda-compat/user-task-definition': 'off',
+    'camunda-compat/zeebe-user-task': 'info',
+  },
+};
+
+/** Rules of camunda-compat's configs that do not skip the processes the engine does not run. */
+const EXECUTABLE_ONLY = ['bpmnlint/start-event-required', 'camunda-compat/history-time-to-live'];
+/** It reports a send task with a zeebe:publishMessage as one without an implementation. */
+const COMPAT_IMPLEMENTATION = 'camunda-compat/implementation';
+const PUBLISH_MESSAGE = ['c8-publish-message-no-task-definition', 'c8-publish-message-unsupported'].map((rule) => `bpmn-cli/${rule}`);
+
+/**
+ * camunda-compat's rules that report a property of white space only as missing, where Camunda 8.9
+ * deploys it (engine-checked): a job type, message, signal, process, decision or listener name, a
+ * result variable, an error or escalation code thrown, a link name.
+ */
+const BLANK_PASSES = ['implementation', 'message-reference', 'signal-reference', 'called-element', 'execution-listener', 'error-reference', 'escalation-reference', 'link-event', 'variable-name'].map((rule) => `camunda-compat/${rule}`);
+const COMPAT_TIMER = 'camunda-compat/timer';
+const FLOW_CONDITION = 'camunda-compat/sequence-flow-condition';
+/** camunda-compat says from 8.10 on; Camunda 8.9 deploys it (engine-checked). */
+const JOB_PRIORITY = { rule: 'camunda-compat/no-job-priority-definition', since: [8, 9] };
+const OWN_DUPLICATES = 'bpmn-cli/c8-extension-element-unique';
+/** Reported on every element of a group; the engine refuses the second and later ones. */
+const REPEATS = new Set(['camunda.elementMultipleNotAllowed', 'camunda.elementPropertyValueDuplicated']);
+
+type Results = Record<string, BpmnlintEngineReport[]>;
+
+interface Node {
+  id?: string;
+  $parent?: Node;
+  $instanceOf?: (type: string) => boolean;
+  sourceRef?: Node;
+}
+
+/** Where camunda-compat's verdict is not the engine's: its rules at bpmn-cli's severity, its reports dropped. */
+export class CompatVerdicts {
+  constructor(
+    private readonly kit: EngineKit,
+    private readonly engine: Engine,
+    private readonly doc: Doc,
+    private readonly elementsById: Readonly<Record<string, unknown>>,
+    private readonly version: string | undefined,
+  ) {}
+
+  /** The rules at bpmn-cli's category where it reads camunda-compat's differently, without the ones it turns off. */
+  rules(entries: RuleEntry[]): RuleEntry[] {
+    const overrides = SEVERITY_OVERRIDES[this.engine];
+    return entries.flatMap((entry) => {
+      const category = overrides[entry.name];
+      if (!category) return [entry];
+      return category === 'off' ? [] : [{ ...entry, category }];
+    });
+  }
+
+  apply(results: Results): void {
+    this.withoutNonExecutableProcesses(results);
+    if (this.engine !== 'c8') return;
+    const published = new Set(PUBLISH_MESSAGE.flatMap((rule) => results[rule] ?? []).map((report) => report.id));
+    const implementations = results[COMPAT_IMPLEMENTATION];
+    if (implementations) {
+      results[COMPAT_IMPLEMENTATION] = implementations.filter((report) => !report.id || !published.has(report.id));
+    }
+    const duplicated = new Set(results[OWN_DUPLICATES]?.map((report) => report.id));
+    for (const [rule, reports] of Object.entries(results)) {
+      if (!rule.startsWith('camunda-compat/')) continue;
+      results[rule] = this.withoutFirstOfRepeats(reports.filter((report) => !this.dropped(rule, report, duplicated)));
+    }
+  }
+
+  /** The engines check executable processes only: a missing start event or history time to live elsewhere is no finding. */
+  private withoutNonExecutableProcesses(results: Results): void {
+    for (const rule of EXECUTABLE_ONLY) {
+      const reports = results[rule];
+      if (!reports) continue;
+      results[rule] = reports.filter((report) => {
+        let el = report.id ? this.doc.get(report.id) : undefined;
+        while (el && !this.kit.is(el, 'bpmn:Process')) {
+          el = el.$parent as typeof el;
+        }
+        return !el || this.kit.peek<boolean>(el, 'isExecutable') === true;
+      });
+    }
+  }
+
+  private dropped(rule: string, report: BpmnlintEngineReport, duplicated: ReadonlySet<string | undefined>): boolean {
+    const type = report.data?.type;
+    if (duplicated.has(report.id) || duplicated.has((report.data?.node as Node | undefined)?.id)) {
+      return true;
+    }
+    if (BLANK_PASSES.includes(rule) && this.isBlank(report)) return true;
+    if (rule === COMPAT_TIMER && type === 'camunda.expressionValueNotAllowed') {
+      return true;
+    }
+    if (rule === FLOW_CONDITION && type === 'camunda.propertyNotAllowed') {
+      return this.leavesGateway(report);
+    }
+    return rule === JOB_PRIORITY.rule && this.runsAtLeast(JOB_PRIORITY.since);
+  }
+
+  /** The first element of a group is the one the engine keeps: only the others are reported. */
+  private withoutFirstOfRepeats(reports: BpmnlintEngineReport[]): BpmnlintEngineReport[] {
+    const seen = new Set<string>();
+    return reports.filter((report) => {
+      if (!REPEATS.has(report.data?.type ?? '')) return true;
+      const node = report.id ? (this.elementsById[report.id] as Node | undefined) : undefined;
+      const group = `${report.data?.type}|${node?.$parent?.id ?? ''}|${String(report.data?.duplicatedPropertyValue ?? '')}`;
+      if (seen.has(group)) return true;
+      seen.add(group);
+      return false;
+    });
+  }
+
+  /** A condition on a flow out of a gateway is the structural W_CONDITION_IGNORED's. */
+  private leavesGateway(report: BpmnlintEngineReport): boolean {
+    const flow = report.id ? (this.elementsById[report.id] as Node | undefined) : undefined;
+    return flow?.sourceRef?.$instanceOf?.('bpmn:Gateway') === true;
+  }
+
+  private runsAtLeast([major, minor]: number[]): boolean {
+    const [fileMajor, fileMinor] = (this.version ?? '').split('.').map(Number);
+    if (fileMajor === undefined || Number.isNaN(fileMajor) || fileMinor === undefined || Number.isNaN(fileMinor)) {
+      return true;
+    }
+    return fileMajor !== major ? fileMajor > major! : fileMinor >= minor!;
+  }
+
+  private isBlank(report: BpmnlintEngineReport): boolean {
+    let value: unknown = report.id ? this.elementsById[report.id] : undefined;
+    for (const step of report.path ?? []) {
+      value = (value as Record<string | number, unknown> | undefined)?.[step];
+    }
+    return typeof value === 'string' && value !== '' && value.trim() === '';
+  }
+}
diff --git a/src/adapters/out/bpmnlint/engine/run/EngineCodes.ts b/src/adapters/out/bpmnlint/engine/run/EngineCodes.ts
new file mode 100644
index 00000000..ccd37349
--- /dev/null
+++ b/src/adapters/out/bpmnlint/engine/run/EngineCodes.ts
@@ -0,0 +1,56 @@
+import type { BpmnlintEngineReport } from '../../bpmnlint-contract.js';
+
+/**
+ * The bpmn-cli code of every camunda-compat rule, the agent-facing W_C7_* / W_C8_* codes, with the
+ * rules that report it as bpmnlint names them (`camunda-compat/` left out, `bpmnlint/<rule>`), or
+ * `<rule>#<data.type>` for the findings of one kind of a rule that splits by kind. bpmn-cli's own
+ * rules declare theirs; the rules bpmn-cli turns off have none.
+ */
+export class EngineCodes {
+  static readonly TABLE: Readonly<Record<'c7' | 'c8', Readonly<Record<string, readonly string[]>>>> = {
+    c7: { 'W_C7_DEPLOY_HISTORY_TTL': ['history-time-to-live'] },
+    c8: {
+      'W_C8_CONDITION_IGNORED': ['sequence-flow-condition#camunda.propertyNotAllowed'],
+      'W_C8_DEPLOY_AD_HOC_SUBPROCESS': ['ad-hoc-sub-process'],
+      'W_C8_DEPLOY_CALLED_ELEMENT': ['called-element', 'no-business-id', 'no-propagate-all-parent-variables'],
+      'W_C8_DEPLOY_ERROR': ['error-reference'],
+      'W_C8_DEPLOY_ESCALATION': ['escalation-boundary-event-attached-to-ref', 'escalation-reference'],
+      'W_C8_DEPLOY_EVENT_DEFINITION': ['wait-for-completion'],
+      'W_C8_DEPLOY_EVENT_GATEWAY': ['event-based-gateway-target'],
+      'W_C8_DEPLOY_EXECUTABLE': ['executable-process'],
+      'W_C8_DEPLOY_EXPRESSION': ['feel-compatibility', 'no-expression'],
+      'W_C8_DEPLOY_EXTENSION': ['agent-fromai-contract', 'agent-tool-documentation', 'agent-tool-output-key', 'connector-properties', 'duplicate-task-headers', 'io-mapping', 'no-binding-type', 'no-job-priority-definition', 'no-version-tag', 'no-zeebe-properties', 'secrets', 'start-event-form', 'start-event-form-embedded', 'unresolvable-secret-reference', 'variable-name', 'version-tag'],
+      'W_C8_DEPLOY_IMPLEMENTATION': ['implementation'],
+      'W_C8_DEPLOY_LINK': ['link-event'],
+      'W_C8_DEPLOY_LISTENER': ['before-all-execution-listener', 'cancel-execution-listener', 'duplicate-execution-listener-headers', 'duplicate-execution-listeners', 'execution-listener', 'no-before-all-execution-listener', 'no-cancel-execution-listener', 'no-execution-listener-headers', 'no-execution-listeners', 'no-task-listeners', 'task-listener'],
+      'W_C8_DEPLOY_MESSAGE': ['message-reference', 'subscription'],
+      'W_C8_DEPLOY_MULTI_INSTANCE': ['loop-characteristics'],
+      'W_C8_DEPLOY_SIGNAL': ['signal-reference'],
+      'W_C8_DEPLOY_START_EVENT': ['bpmnlint/start-event-required', 'no-multiple-none-start-events'],
+      'W_C8_DEPLOY_TIMER': ['timer'],
+      'W_C8_DEPLOY_UNSUPPORTED': ['collapsed-subprocess', 'element-type', 'inclusive-gateway', 'no-interrupting-event-subprocess', 'no-loop', 'no-signal-event-sub-process'],
+      'W_C8_DEPLOY_USER_TASK': ['no-candidate-users', 'no-priority-definition', 'no-task-schedule', 'no-zeebe-user-task', 'priority-definition', 'task-schedule', 'user-task-form'],
+      'W_C8_EXCLUSIVE_GATEWAY': ['sequence-flow-condition'],
+      'W_C8_JOB_WORKER_USER_TASK': ['zeebe-user-task'],
+      'W_C8_STANDARD_LOOP': ['loop-characteristics#camunda.propertyTypeNotAllowed'],
+    },
+  };
+
+  /** What a rule reports that bpmn-cli has no code for yet (a rule a newer camunda-compat adds). */
+  static readonly UNMAPPED: Readonly<Record<'c7' | 'c8', string>> = { c7: 'W_C7_ENGINE_RULE', c8: 'W_C8_ENGINE_RULE' };
+
+  /** Codes camunda-compat reports as refused at deploy that Camunda 8.9 deploys (engine-checked): the flow out of an exclusive or inclusive gateway is never taken, a standard loop runs once. */
+  static readonly RUNTIME: readonly string[] = ['W_C8_EXCLUSIVE_GATEWAY', 'W_C8_STANDARD_LOOP'];
+
+  private static readonly BY_RULE = { c7: EngineCodes.byRule('c7'), c8: EngineCodes.byRule('c8') };
+
+  static codeOf(platform: 'c7' | 'c8', rule: string, report: BpmnlintEngineReport): string {
+    const name = rule.replace(/^camunda-compat\//, '');
+    const codes = EngineCodes.BY_RULE[platform];
+    return codes.get(`${name}#${report.data?.type}`) ?? codes.get(name) ?? EngineCodes.UNMAPPED[platform];
+  }
+
+  private static byRule(platform: 'c7' | 'c8'): Map<string, string> {
+    return new Map(Object.entries(EngineCodes.TABLE[platform]).flatMap(([code, rules]) => rules.map((rule) => [rule, code] as const)));
+  }
+}
diff --git a/src/adapters/out/bpmnlint/engine/run/EngineFindings.ts b/src/adapters/out/bpmnlint/engine/run/EngineFindings.ts
new file mode 100644
index 00000000..b182c5ac
--- /dev/null
+++ b/src/adapters/out/bpmnlint/engine/run/EngineFindings.ts
@@ -0,0 +1,148 @@
+import type { ProfileFinding, Severity } from '../../../../../domain/document/Finding.js';
+
+import type { BpmnlintEngineReport } from '../../bpmnlint-contract.js';
+import { EngineCodes } from './EngineCodes.js';
+import { EngineHint } from './EngineHint.js';
+import { ElementKinds } from '../rules/support/ElementKinds.js';
+import type { EngineKit } from '../../engine-kit.js';
+import type { EngineEntry } from './EngineRun.js';
+
+/** The engine layers set what a finding means by its bpmnlint category. */
+const SEVERITY_OF_CATEGORY: Record<string, Severity> = { error: 'deploy', warn: 'runtime', info: 'practice' };
+
+const OWN_RULES = 'bpmn-cli/';
+
+interface ModdleNode {
+  $type?: string;
+  id?: string;
+  $instanceOf?: unknown;
+  $parent?: ModdleNode;
+  $descriptor?: { propertiesByName?: Record<string, { ns?: { prefix?: string } }> };
+  extensionElements?: { values?: ModdleNode[] };
+}
+
+/**
+ * The engine rules' bpmnlint reports as bpmn-cli findings: an own rule's code and severity from its
+ * declaration, camunda-compat's code from its rule and severity from the category, the hint from `path` and `data.type`, and the subject (what a mutation tells
+ * apart on one element) from the path, an extension element as `ext:<local>` and a vendor
+ * attribute as `attr:<local>`, as the operation warnings name what they cover.
+ */
+export class EngineFindings {
+  private readonly hint: EngineHint;
+
+  /** `spelling`: the attribute as the file writes it (`operaton:assignee` for the parse's `camunda:assignee`). */
+  constructor(
+    private readonly kit: EngineKit,
+    private readonly platform: 'c7' | 'c8',
+    private readonly elementsById: Readonly<Record<string, unknown>>,
+    private readonly entry: Pick<EngineEntry, 'codes' | 'writtenFileRules'>,
+    private readonly spelling: (id: string, key: string) => string,
+    private readonly zeebePrefix: string,
+  ) {
+    this.hint = new EngineHint(elementsById);
+  }
+
+  /**
+   * One finding per subject of an element: where an own rule and camunda-compat both report it
+   * (a misplaced zeebe:taskDefinition), the own rule's says what bpmn-cli's code says; where two
+   * camunda-compat rules report it with one code (io-mapping and variable-name), the first says it.
+   * The findings of the rules on the file as written follow, and tell no subject apart.
+   */
+  of(results: Record<string, BpmnlintEngineReport[]>): ProfileFinding[] {
+    const out: ProfileFinding[] = [];
+    const written: ProfileFinding[] = [];
+    const ownSubjects = new Set<string>();
+    const compat: Array<{ finding: ProfileFinding; identity: string }> = [];
+    for (const [rule, reports] of Object.entries(results)) {
+      for (const report of this.entry.writtenFileRules.has(rule) ? EngineFindings.inWrittenOrder(reports) : reports) {
+        const [code, severity] = this.entry.codes[rule] ?? this.compatCodeOf(rule, report);
+        const related = this.relatedIds(report);
+        const subject = this.subjectOf(report);
+        const finding = this.kit.makeFinding(severity, code, String(report.message), report.id ?? undefined, { hint: this.spelledHint(this.hint.of(report, rule), rule), subject, ...(related.length ? { related } : {}) });
+        const identity = `${report.id ?? ''}|${subject}`;
+        if (this.entry.writtenFileRules.has(rule)) {
+          written.push(finding);
+        } else if (rule.startsWith(OWN_RULES)) {
+          if (subject) ownSubjects.add(identity);
+          out.push(finding);
+        } else {
+          compat.push({ finding, identity });
+        }
+      }
+    }
+    const reported = new Set<string>();
+    const firstOfSubject = ({ finding, identity }: { finding: ProfileFinding; identity: string }): boolean => {
+      if (!finding.subject) return true;
+      const key = `${identity}|${finding.code}`;
+      if (ownSubjects.has(identity) || reported.has(key)) return false;
+      reported.add(key);
+      return true;
+    };
+    return [...out, ...compat.filter(firstOfSubject).map(({ finding }) => finding), ...written];
+  }
+
+  private static inWrittenOrder(reports: BpmnlintEngineReport[]): BpmnlintEngineReport[] {
+    return [...reports].sort((left, right) => Number(left.data?.writtenAt) - Number(right.data?.writtenAt));
+  }
+
+  private compatCodeOf(rule: string, report: BpmnlintEngineReport): readonly [string, Severity] {
+    const code = EngineCodes.codeOf(this.platform, rule, report);
+    return [code, EngineCodes.RUNTIME.includes(code) ? 'runtime' : (SEVERITY_OF_CATEGORY[report.category] ?? 'runtime')];
+  }
+
+  private subjectOf(report: BpmnlintEngineReport): string {
+    if (typeof report.data?.subject === 'string') return report.data.subject;
+    const path = report.path ?? [];
+    const at = path.indexOf('extensionElements');
+    const host = report.id ? (this.elementsById[report.id] as ModdleNode | undefined) : undefined;
+    if (at === 0 && path[1] === 'values' && typeof path[2] === 'number') {
+      const type = host?.extensionElements?.values?.[path[2]]?.$type;
+      const local = type?.slice(type.indexOf(':') + 1);
+      if (local) {
+        return [`ext:${ElementKinds.xmlName(local)}`, ...path.slice(3)].join('.');
+      }
+    }
+    if (path.length === 1 && typeof path[0] === 'string') {
+      return `attr:${report.id ? this.spelling(report.id, this.attributeKey(host, path[0])) : this.attributeKey(host, path[0])}`;
+    }
+    return path.join('.');
+  }
+
+  /** A vendor attribute as the operation warnings name it, with its prefix (`camunda:class`). */
+  private attributeKey(host: ModdleNode | undefined, name: string): string {
+    if (name.includes(':')) return name;
+    const prefix = host?.$descriptor?.propertiesByName?.[name]?.ns?.prefix;
+    return prefix && prefix !== 'bpmn' ? `${prefix}:${name}` : name;
+  }
+
+  /** An event definition or loop of the reported element is part of it, not another element; a flow node in it is one. */
+  private isInside(node: ModdleNode, id: string | undefined): boolean {
+    for (let parent = node.$parent; parent; parent = parent.$parent) {
+      if (parent.id === id) return true;
+    }
+    return false;
+  }
+
+  /** A camunda-compat hint names zeebe content as the file spells it; an own rule's hint does already. */
+  private spelledHint(hint: string, rule: string): string {
+    return this.zeebePrefix === 'zeebe' || rule.startsWith(OWN_RULES) ? hint : hint.replace(/\bzeebe:/g, `${this.zeebePrefix}:`);
+  }
+
+  private isFlowElement(node: ModdleNode): boolean {
+    return (node.$instanceOf as ((type: string) => boolean) | undefined)?.('bpmn:FlowElement') === true;
+  }
+
+  /** The other elements a report names in its data (a referenced host, a gateway's flow, a duplicate). */
+  private relatedIds(report: BpmnlintEngineReport): string[] {
+    const ids = new Set<string>();
+    for (const value of Object.values(report.data ?? {})) {
+      for (const item of Array.isArray(value) ? value : [value]) {
+        const id = item && typeof item === 'object' && typeof (item as ModdleNode).$instanceOf === 'function' ? (item as ModdleNode).id : undefined;
+        if (id && id !== report.id && !(this.isInside(item as ModdleNode, report.id) && !this.isFlowElement(item as ModdleNode))) {
+          ids.add(id);
+        }
+      }
+    }
+    return [...ids];
+  }
+}
diff --git a/src/adapters/out/bpmnlint/engine/run/EngineHint.ts b/src/adapters/out/bpmnlint/engine/run/EngineHint.ts
new file mode 100644
index 00000000..56cce3dc
--- /dev/null
+++ b/src/adapters/out/bpmnlint/engine/run/EngineHint.ts
@@ -0,0 +1,363 @@
+import type { BpmnlintEngineReport } from '../../bpmnlint-contract.js';
+import { ElementKinds } from '../rules/support/ElementKinds.js';
+import { Shell } from '../rules/support/Shell.js';
+
+/** camunda-compat's error types (`data.type`), the ones a hint tells apart. */
+const SET = new Set(['camunda.propertyRequired', 'camunda.propertyValueRequired', 'camunda.propertyDependentRequired', 'camunda.propertyValueNotAllowed', 'camunda.propertyTypeNotAllowed', 'camunda.expressionRequired', 'camunda.expressionValueNotAllowed', 'camunda.expressionNotAllowed', 'camunda.feelExpressionInvalid', 'camunda.feelExpressionUnsupportedFunction', 'camunda.propertyValueDuplicated', 'camunda.elementPropertyValueDuplicated', 'camunda.propertiesValuesDuplicated']);
+const UNSET = new Set(['camunda.propertyNotAllowed', 'camunda.propertyDeprecated']);
+const FEEL = new Set(['camunda.expressionRequired', 'camunda.feelExpressionInvalid', 'camunda.expressionValueNotAllowed']);
+const EXT_ADD = new Set(['camunda.extensionElementRequired', 'camunda.childElementOfTypeRequired']);
+const EXT_REMOVE = new Set(['camunda.extensionElementNotAllowed', 'camunda.elementMultipleNotAllowed', 'camunda.childElementTypeNotAllowed']);
+const REMOVE = new Set(['camunda.elementTypeNotAllowed', 'camunda.attachedToRefElementTypeNotAllowed', 'camunda.loopNotAllowed', 'camunda.elementCollapsedNotAllowed', 'camunda.eventBasedGatewayTargetNotAllowed']);
+
+/** How `bpmn set` addresses an element nested in a flow node or flow. */
+const SLOTS: Record<string, string> = { eventDefinitions: 'definition', loopCharacteristics: 'loop', conditionExpression: 'condition' };
+
+/** What an alternative extension element does, for a hint that offers it next to a job. */
+const ALTERNATIVES: Record<string, string> = { 'zeebe:script': 'a FEEL script', 'zeebe:calledDecision': 'call a DMN decision' };
+
+/** The attributes an extension element needs to deploy, as `bpmn ext add` takes them. */
+const REQUIRED_ATTRIBUTES: Record<string, string> = {
+  'zeebe:taskDefinition': 'type=<jobType>',
+  'zeebe:calledElement': 'processId=<processId>',
+  'zeebe:calledDecision': 'decisionId=<decisionId> resultVariable=<variable>',
+  'zeebe:subscription': 'correlationKey==<expression>',
+  'zeebe:loopCharacteristics': 'inputCollection==<items> inputElement=<item>',
+  'zeebe:script': 'expression==<expression> resultVariable=<variable>',
+  'zeebe:formDefinition': 'formId=<formId>',
+};
+
+/**
+ * The `bpmn set` key that writes a property of a nested element, with its placeholder: the
+ * timer, message or condition of an event, the condition of a flow.
+ */
+const SET_ALIASES: Record<string, string> = {
+  'definition.timeDate': 'timer=<date>',
+  'definition.timeCycle': 'timer=<cycle>',
+  'definition.timeDuration': 'timer=PT1H',
+  'definition.messageRef': 'message=<MessageName>',
+  'definition.signalRef': 'signal=<SignalName>',
+  'definition.errorRef': 'error=<ErrorName> errorCode=<CODE>',
+  'definition.escalationRef': 'escalation=<Name> escalationCode=<CODE>',
+  'definition.condition': 'when=<expression>',
+  'definition.name': 'link=<Name>',
+  messageRef: 'message=<MessageName>',
+  conditionExpression: 'condition=<expression>',
+  completionCondition: 'completion=<expression>',
+};
+
+/** The placeholder a hint writes for a property, in the vocabulary of bpmn-cli's hints. */
+const PLACEHOLDERS: Record<string, string> = {
+  resultVariable: '<variable>',
+  expression: '=<expression>',
+  type: '<jobType>',
+  target: '<variable>',
+  source: '=<expression>',
+  processId: '<processId>',
+  decisionId: '<decisionId>',
+  formId: '<formId>',
+  versionTag: '<versionTag>',
+  inputElement: '<item>',
+  outputElement: '=<expression>',
+  inputCollection: '=<items>',
+  outputCollection: '<variable>',
+  correlationKey: '=<expression>',
+  errorCode: '<CODE>',
+  escalationCode: '<CODE>',
+  messageName: '<MessageName>',
+};
+
+/** The kind `bpmn retype` makes of an element type the engine does not support. */
+const REPLACEMENTS: Record<string, string> = {
+  'bpmn:Transaction': '`bpmn retype <file> {id} subProcess` (an embedded sub-process).',
+  'bpmn:ComplexGateway': '`bpmn retype <file> {id} inclusiveGateway` (or exclusiveGateway: one path).',
+};
+
+interface ModdleNode {
+  $type?: string;
+  id?: string;
+  $descriptor?: { properties?: Array<{ name: string; isAttr?: boolean; ns?: { prefix?: string } }>; propertiesByName?: Record<string, { ns?: { prefix?: string }; isReference?: boolean }> };
+  [property: string]: unknown;
+}
+
+/** Where a path leads: the element `bpmn` addresses, the slot of the nested element, the rest. */
+interface Address {
+  target: string;
+  slot: string;
+  node: ModdleNode;
+  rest: Array<string | number>;
+}
+
+/**
+ * The `bpmn` command that fixes an engine finding, derived from where the report points (`path`)
+ * and what kind of problem it is (`data.type`, camunda-compat's error types): one rule for all
+ * engine rules instead of a hint per rule. Without a command that fits, it says what to look at.
+ */
+export class EngineHint {
+  constructor(private readonly elementsById: Readonly<Record<string, unknown>>) {}
+
+  of(report: BpmnlintEngineReport, rule: string): string {
+    const id = report.id;
+    const type = report.data?.type;
+    const host = id ? (this.elementsById[id] as ModdleNode | undefined) : undefined;
+    const own = report.data?.hint;
+    if (typeof own === 'string') return own;
+    const special = id && host ? this.compatHint(rule, report, host) : undefined;
+    if (special) return special;
+    if (!id || !host || !type) return this.fallback(id);
+    const path = report.path ?? [];
+    const requiredType = report.data?.requiredType;
+    if (type === 'camunda.childElementOfTypeRequired' && typeof requiredType === 'string' && requiredType.startsWith('bpmn:')) {
+      return this.addChild(id, host, requiredType);
+    }
+    if (!path.length && EXT_REMOVE.has(type)) {
+      return `Remove it (\`bpmn remove <file> ${id}\`), or give it another trigger (\`bpmn set <file> ${id} trigger=<trigger>\`).`;
+    }
+    const address = this.address(host, path);
+    if (!address) return this.fallback(id);
+    const ext = this.extensionStep(address);
+    if (EXT_ADD.has(type)) return this.extAdd(address, ext, report);
+    const child = ext && !EXT_REMOVE.has(type) && !UNSET.has(type) ? this.childRebuild(address, ext.element) : undefined;
+    if (child) return child;
+    if (ext) {
+      return EXT_REMOVE.has(type) || UNSET.has(type) ? `Remove it: \`bpmn ext remove <file> ${address.target} ${Shell.quote(`${address.slot}${ext.index}`)}\` (\`bpmn ext list <file> ${address.target}\` shows the extension elements).` : this.extRebuild(address.target, address.slot, ext.element, ext.property, FEEL.has(type));
+    }
+    if (REMOVE.has(type)) {
+      return `Remove it (\`bpmn remove <file> ${id}\`), or change it to a kind the engine supports (\`bpmn retype <file> ${id} <kind>\`, \`bpmn kinds\` lists them).`;
+    }
+    const key = this.attributeKey(address, report);
+    if (!key) return this.fallback(id);
+    const alias = SET_ALIASES[key.replace(/^definition\[\d+\]\./, 'definition.')];
+    if (alias && !UNSET.has(type)) {
+      return `\`bpmn set <file> ${address.target} ${alias.split(' ').map((pair) => Shell.quote(FEEL.has(type) ? pair.replace(/=<expression>$/, '==<expression>') : pair)).join(' ')}\`.`;
+    }
+    if (UNSET.has(type)) {
+      return `Remove it: \`bpmn set <file> ${address.target} ${Shell.quote(`${key}=`)}\`.`;
+    }
+    const suggested = report.data?.suggestedValue ?? report.data?.requiredValue;
+    if (SET.has(type)) {
+      return `\`bpmn set <file> ${address.target} ${Shell.quote(`${key}=${typeof suggested === 'string' || typeof suggested === 'boolean' ? String(suggested) : FEEL.has(type) ? '=<expression>' : this.placeholder(key, address.node)}`)}\`.`;
+    }
+    return this.fallback(id);
+  }
+
+  /**
+   * The hints for camunda-compat reports where the one derived from `path` and `data.type` would be
+   * vague or wrong: a missing start event, a timer cycle where the engine refuses one, an element the
+   * engine does not support, a duplicated header, a standard loop.
+   */
+  private compatHint(rule: string, report: BpmnlintEngineReport, host: ModdleNode): string | undefined {
+    const id = String(host.id);
+    const type = report.data?.type;
+    const path = report.path ?? [];
+    if (rule === 'bpmnlint/start-event-required') {
+      return host.$type === 'bpmn:Process' ? `\`bpmn add <file> startEvent "<Name>" --before <firstNodeId>\` (or --in ${id}).` : `\`bpmn add <file> startEvent "<Name>" --in ${id}\`, then connect it to the first node.`;
+    }
+    if (rule === 'camunda-compat/history-time-to-live') {
+      return `\`bpmn set <file> ${id} camunda:historyTimeToLive=180\` (days, like Camunda Modeler; P180D works too).`;
+    }
+    if (type === 'camunda.propertyNotAllowed' && path[path.length - 1] === 'timeCycle') {
+      return this.timerCycle(id, host);
+    }
+    if (type === 'camunda.elementTypeNotAllowed') {
+      return this.unsupported(id, host, report);
+    }
+    if (type === 'camunda.attachedToRefElementTypeNotAllowed') {
+      return `Attach it elsewhere (\`bpmn move <file> ${id} --on <subProcessId>\`) or remove it: \`bpmn remove <file> ${id}\`.`;
+    }
+    if (type === 'camunda.propertyTypeNotAllowed' && path[0] === 'loopCharacteristics') {
+      return `Remove it (\`bpmn set <file> ${id} loop=none\`) and model the loop with a gateway, or make it a multi-instance: \`bpmn set <file> ${id} loop=sequential\`, then \`bpmn ext add <file> ${id} loop.zeebe:loopCharacteristics inputCollection==<items> inputElement=<item>\`.`;
+    }
+    if (type === 'camunda.elementMultipleNotAllowed' && !path.length) {
+      return `Remove ${id} (\`bpmn remove <file> ${id}\`) or give it a trigger: \`bpmn set <file> ${id} trigger=message message=<MessageName>\`.`;
+    }
+    if (type === 'camunda.propertyValueDuplicated') {
+      return this.duplicatedChild(id, report);
+    }
+    if (type === 'camunda.extensionElementRequired') {
+      return this.unprefixedDecision(id, host, report);
+    }
+    return undefined;
+  }
+
+  /** A business rule task that names its decision without the zeebe prefix: `bpmn set` writes the zeebe:calledDecision. */
+  private unprefixedDecision(id: string, host: ModdleNode, report: BpmnlintEngineReport): string | undefined {
+    const required = report.data?.requiredExtensionElement;
+    const decision = (host.$attrs as Record<string, unknown> | undefined)?.['calledDecision'];
+    if (!Array.isArray(required) || !required.includes('zeebe:CalledDecision') || typeof decision !== 'string') {
+      return undefined;
+    }
+    return `Give it its decision: \`bpmn set <file> ${id} calledDecision=${decision}\`.`;
+  }
+
+  /** A catch event takes a duration or a date; an interrupting boundary or event sub-process start no cycle. */
+  private timerCycle(id: string, host: ModdleNode): string {
+    if (host.$type === 'bpmn:IntermediateCatchEvent') {
+      return `\`bpmn set <file> ${id} timer=PT1H\` (a duration, or a date-time).`;
+    }
+    return `Make it non-interrupting (\`bpmn set <file> ${id} nonInterrupting=true\`) or use a duration (\`bpmn set <file> ${id} timer=PT1H\`).`;
+  }
+
+  private unsupported(id: string, host: ModdleNode, report: BpmnlintEngineReport): string | undefined {
+    if (report.data?.eventDefinition === 'bpmn:CancelEventDefinition' || (report.data?.eventDefinition as ModdleNode | undefined)?.$type === 'bpmn:CancelEventDefinition') {
+      return `\`bpmn set <file> ${id} trigger=none\`.`;
+    }
+    return REPLACEMENTS[String(host.$type)]?.replace('{id}', id);
+  }
+
+  /** Two children of one container with the same key: the second goes. */
+  private duplicatedChild(id: string, report: BpmnlintEngineReport): string | undefined {
+    const container = report.data?.node as ModdleNode | undefined;
+    const second = (report.data?.properties as ModdleNode[] | undefined)?.[1];
+    const values = container?.values as ModdleNode[] | undefined;
+    const index = second && values ? values.indexOf(second) : -1;
+    if (!container?.$type || !second?.$type || index < 0) return undefined;
+    return `Keep one: \`bpmn ext remove <file> ${id} '${ElementKinds.xmlName(container.$type)}/${ElementKinds.xmlName(second.$type)}[${index}]'\`.`;
+  }
+
+  /**
+   * Follows the path from the reported element: into a nested element of a flow node (a slot of
+   * `bpmn set`) or a referenced root element (a message, an error), which `bpmn` then addresses.
+   */
+  private address(host: ModdleNode, path: ReadonlyArray<string | number>): Address | undefined {
+    let node = host;
+    let target = String(host.id);
+    let slot = '';
+    let index = 0;
+    while (index < path.length) {
+      const step = path[index]!;
+      if (typeof step === 'number' || step === 'extensionElements') break;
+      const value = node[step];
+      const isLast = index === path.length - 1;
+      if (isLast && !SLOTS[step]) break;
+      const property = node.$descriptor?.propertiesByName?.[step];
+      if (property?.isReference && value && typeof value === 'object' && (value as ModdleNode).id) {
+        node = value as ModdleNode;
+        target = String(node.id);
+        slot = '';
+        index++;
+        continue;
+      }
+      if (!SLOTS[step] || node !== host) break;
+      const many = Array.isArray(value) && value.length > 1;
+      const position = typeof path[index + 1] === 'number' ? (path[index + 1] as number) : 0;
+      const nested = Array.isArray(value) ? value[position] : value;
+      if (!nested || typeof nested !== 'object') break;
+      slot = `${SLOTS[step]}${many ? `[${position}]` : ''}.`;
+      node = nested as ModdleNode;
+      index += typeof path[index + 1] === 'number' ? 2 : 1;
+    }
+    return { target, slot, node, rest: path.slice(index) };
+  }
+
+  /**
+   * The `bpmn set` key of the attribute the rest of the path names (`camunda:topic`,
+   * `definition.name`); a path that ends at a nested element names the property it lacks in `data`.
+   */
+  private attributeKey(address: Address, report: BpmnlintEngineReport): string | undefined {
+    const required = report.data?.requiredProperty;
+    if (!address.rest.length && !required && address.slot === 'condition.') {
+      return 'conditionExpression';
+    }
+    const [step, ...more] = address.rest.length ? address.rest : [Array.isArray(required) ? required[required.length - 1] : required];
+    if (typeof step !== 'string' || more.some((part) => typeof part === 'string')) {
+      return undefined;
+    }
+    const prefix = address.node.$descriptor?.propertiesByName?.[step]?.ns?.prefix;
+    const name = step.includes(':') || !prefix || prefix === 'bpmn' ? step : `${prefix}:${step}`;
+    return `${address.slot}${name}`;
+  }
+
+  private extensionStep(address: Address): { index: number; element: ModdleNode; property?: string } | undefined {
+    const [first, values, index, property] = address.rest;
+    if (first !== 'extensionElements' || values !== 'values' || typeof index !== 'number') {
+      return undefined;
+    }
+    const element = ((address.node.extensionElements as ModdleNode | undefined)?.values as ModdleNode[] | undefined)?.[index];
+    if (!element) return undefined;
+    return { index, element, ...(typeof property === 'string' ? { property } : {}) };
+  }
+
+  private extAdd(address: Address, ext: { element: ModdleNode } | undefined, report: BpmnlintEngineReport): string {
+    if (ext) {
+      return this.extRebuild(address.target, address.slot, ext.element, undefined, false);
+    }
+    const required = report.data?.requiredExtensionElement ?? report.data?.requiredChildElement;
+    const named = (Array.isArray(required) ? required : [required ?? '<type>']).map((type) => ElementKinds.xmlName(String(type)));
+    const types = named.includes('zeebe:taskDefinition') ? ['zeebe:taskDefinition', ...named.filter((type) => type !== 'zeebe:taskDefinition')] : named;
+    const present = types.filter((type) => this.extensionTypes(address.node).includes(type));
+    if (present.length > 1) {
+      return `Keep one: ${present.map((type, index) => `${index ? '(or ' : ''}\`bpmn ext remove <file> ${address.target} ${type}\`${index ? ')' : ''}`).join(' ')}.`;
+    }
+    const owner = report.data?.node as ModdleNode | undefined;
+    const target = owner?.id && owner.$type === 'bpmn:Message' ? owner.id : address.target;
+    const slot = target === address.target ? address.slot : '';
+    const [first, ...others] = types;
+    const command = (type: string): string => {
+      const attributes = REQUIRED_ATTRIBUTES[type];
+      return `\`bpmn ext add <file> ${target} ${Shell.quote(`${slot}${type}`)}${attributes ? ` ${attributes}` : ''}\``;
+    };
+    const lead = first === 'zeebe:taskDefinition' ? 'Give it a job type: ' : '';
+    const alternatives = others.map((type) => ` (or ${ALTERNATIVES[type] ?? 'one'}: ${command(type)})`).join('');
+    const kinds = REQUIRED_ATTRIBUTES[first!] ? '' : ' (`bpmn kinds` lists the extension elements and their attributes)';
+    return `${lead}${command(first!)}${alternatives}${kinds}.`;
+  }
+
+  /**
+   * `bpmn ext add --replace` that writes the extension element anew with all its attributes and
+   * the one to fix; an element with child elements is rebuilt from its XML.
+   */
+  private extRebuild(target: string, slot: string, element: ModdleNode, property: string | undefined, feel: boolean): string {
+    const type = ElementKinds.xmlName(String(element.$type));
+    const attributes = (element.$descriptor?.properties ?? []).filter((candidate) => candidate.isAttr && candidate.name !== property && Object.hasOwn(element, candidate.name) && element[candidate.name] !== undefined && typeof element[candidate.name] !== 'object').map((candidate) => Shell.quote(`${candidate.name}=${String(element[candidate.name])}`));
+    const required = REQUIRED_ATTRIBUTES[type]?.split(' ').filter((pair) => !attributes.some((attribute) => attribute.startsWith(`${pair.split('=')[0]}=`))) ?? [];
+    const fixed = property ? [Shell.quote(`${property}=${feel ? '=<expression>' : (PLACEHOLDERS[property] ?? `<${property}>`)}`)] : required;
+    const hasChildren = (element.$descriptor?.properties ?? []).some((candidate) => !candidate.isAttr && element[candidate.name] !== undefined && typeof element[candidate.name] === 'object');
+    if (hasChildren) {
+      return `See it with \`bpmn ext list <file> ${target} --json\`, then rebuild it: \`bpmn ext add <file> ${target} ${Shell.quote(`${slot}${type}`)} --replace --xml '<${type} ...>...</${type}>'\`.`;
+    }
+    return `\`bpmn ext add <file> ${target} ${[Shell.quote(`${slot}${type}`), ...attributes, ...fixed, '--replace'].join(' ')}\`.`;
+  }
+
+  /**
+   * A child of a container extension (a listener, an input or output mapping) that lacks or has a
+   * wrong attribute: it is removed and added again, its siblings stay.
+   */
+  private childRebuild(address: Address, container: ModdleNode): string | undefined {
+    const [, , , list, position, property] = address.rest;
+    if (typeof list !== 'string' || typeof position !== 'number' || typeof property !== 'string') {
+      return undefined;
+    }
+    const element = (container[list] as ModdleNode[] | undefined)?.[position];
+    if (!element?.$type) return undefined;
+    const containerName = ElementKinds.xmlName(String(container.$type));
+    const childName = ElementKinds.xmlName(String(element.$type));
+    const added = containerName === 'zeebe:ioMapping' ? childName : `${containerName}/${childName}`;
+    const attributes = (element.$descriptor?.properties ?? []).filter((candidate) => candidate.isAttr && candidate.name !== property && typeof element[candidate.name] === 'string' && element[candidate.name] !== '').map((candidate) => Shell.quote(`${candidate.name}=${String(element[candidate.name])}`));
+    const fixed = Shell.quote(`${property}=${PLACEHOLDERS[property] ?? `<${property}>`}`);
+    return `Rebuild it: \`bpmn ext remove <file> ${address.target} ${Shell.quote(`${containerName}/${childName}[${position}]`)}\`, then \`bpmn ext add <file> ${address.target} ${[Shell.quote(`${address.slot}${added}`), ...attributes, fixed].join(' ')}\`.`;
+  }
+
+  /** `bpmn add` of a BPMN element a process or sub-process lacks (a start event). */
+  private addChild(id: string, host: ModdleNode, requiredType: string): string {
+    const kind = requiredType === 'bpmn:Activity' ? 'serviceTask' : `${requiredType.charAt(5).toLowerCase()}${requiredType.slice(6)}`;
+    return host.$type === 'bpmn:Process' ? `\`bpmn add <file> ${kind} "<Name>" --before <firstNodeId>\`.` : `\`bpmn add <file> ${kind} "<Name>" --in ${id}\`.`;
+  }
+
+  private extensionTypes(node: ModdleNode): string[] {
+    return (((node.extensionElements as ModdleNode | undefined)?.values as ModdleNode[] | undefined) ?? []).map((value) => ElementKinds.xmlName(String(value.$type)));
+  }
+
+  /** `<topic>` for `camunda:topic`, `<variable>` for `camunda:resultVariable`. */
+  private placeholder(key: string, node?: ModdleNode): string {
+    const name = key.slice(Math.max(key.lastIndexOf(':'), key.lastIndexOf('.')) + 1);
+    if (name === 'name' && (node?.$type === 'bpmn:Message' || node?.$type === 'bpmn:Signal')) {
+      return `<${node.$type.slice(5)}Name>`;
+    }
+    return PLACEHOLDERS[name] ?? `<${name}>`;
+  }
+
+  private fallback(id: string | undefined): string {
+    return id ? `Fix what the message names on ${id}: \`bpmn show <file> ${id}\` shows the element.` : 'Fix what the message names in the XML.';
+  }
+}
diff --git a/src/adapters/out/bpmnlint/engine/run/EngineRun.ts b/src/adapters/out/bpmnlint/engine/run/EngineRun.ts
new file mode 100644
index 00000000..586cdf23
--- /dev/null
+++ b/src/adapters/out/bpmnlint/engine/run/EngineRun.ts
@@ -0,0 +1,120 @@
+import type { BpmnModdle, ImportWarning } from 'bpmn-moddle';
+import type { Doc } from '../../../../../domain/document/Doc.js';
+import type { DocumentNamespaces } from '../../../../../domain/document/vendor/DocumentNamespaces.js';
+import type { ProfileFinding } from '../../../../../domain/document/Finding.js';
+import type { EnginePlatformInfo } from '../../../../../domain/validation/EngineLint.js';
+import { lint as lintRules, type RuleEntry } from '@miragon/bpmnlint-plugin-rules/engine';
+import type { BpmnlintEngineReport } from '../../bpmnlint-contract.js';
+import type { EngineKit } from '../../engine-kit.js';
+import type { Impact } from '../rules/CamundaRule.js';
+import { WrittenModel } from '../rules/support/WrittenModel.js';
+import { CompatVerdicts } from './CompatVerdicts.js';
+import { EngineFindings } from './EngineFindings.js';
+
+type Engine = EnginePlatformInfo['platform'];
+
+/** One engine's rules for an engine version and the moddle extension they read, as `rules/c7` and `rules/c8` build them. */
+export interface EngineEntry {
+  moddleExtensions: Record<string, unknown>;
+  /** The code and impact of each of bpmn-cli's rules, by `bpmn-cli/<rule>`. */
+  codes: Readonly<Record<string, readonly [code: string, impact: Impact]>>;
+  rules(version: string | undefined): RuleEntry[];
+  writtenFileRules: ReadonlySet<string>;
+  /** What the rules need of the file that the parse for them no longer shows. */
+  afterParse?(definitions: unknown, warnings: readonly ImportWarning[], vendor: { operaton: boolean; prefix: string }): void;
+}
+
+const ENGINE_NAMES: Record<Engine, string> = { c7: 'Camunda 7', c8: 'Camunda 8' };
+const EXECUTION_PLATFORMS: Record<Engine, string> = { c7: 'Camunda Platform', c8: 'Camunda Cloud' };
+
+/**
+ * One engine's rules on a document, loaded on demand: camunda-compat's config for the file's
+ * engine version and bpmn-cli's own rules, on the document parsed again
+ * with the engine's moddle extension. What that parse drops or rewrites (unknown vendor elements,
+ * unprefixed attributes, booleans, publishMessage) the rules read in the file as written.
+ */
+export class EngineRun {
+  private readonly moddle: BpmnModdle;
+
+  constructor(
+    private readonly kit: EngineKit,
+    private readonly engine: Engine,
+    private readonly entry: EngineEntry,
+  ) {
+    this.moddle = new kit.BpmnModdle(entry.moddleExtensions);
+  }
+
+  async findings(doc: Doc, info: EnginePlatformInfo): Promise<ProfileFinding[]> {
+    const ns = new this.kit.DocumentNamespaces(doc);
+    const { rootElement, elementsById, warnings } = await this.moddle.fromXML(this.lintedXml(await doc.toXml(), info, ns));
+    this.entry.afterParse?.(rootElement, warnings, this.vendor(ns, info));
+    WrittenModel.record(rootElement, { definitions: doc.definitions, namespaces: ns, decisionLinks: new this.kit.DecisionLinkReader(doc) });
+    (rootElement as unknown as { $attrs: Record<string, unknown> }).$attrs['modeler:executionPlatform'] = EXECUTION_PLATFORMS[this.engine];
+    const verdicts = new CompatVerdicts(this.kit, this.engine, doc, elementsById, info.version);
+    const results = lintRules(rootElement, verdicts.rules(this.entry.rules(info.version))) as Record<string, BpmnlintEngineReport[]>;
+    const failures = this.failuresOf(results);
+    verdicts.apply(results);
+    const lint = new EngineFindings(this.kit, this.engine, elementsById, this.entry, (id, key) => this.spelling(doc, ns, id, key), ns.prefixOf(this.kit.ZEEBE.uri) ?? 'zeebe').of(results);
+    const failed = [...failures].map(([rule, message]) => this.kit.makeFinding('practice', 'W_LINT_FAILED', `The ${ENGINE_NAMES[this.engine]} rule ${rule} failed: ${message}; its findings are left out`, undefined, { subject: `failed:${rule}`, hint: 'Report the file and the rule: it is a bug of the rule, not of the model.' }));
+    return this.inDocumentOrder(doc, [...lint, ...failed]);
+  }
+
+  /** Operaton reads its own namespace like the camunda one: the rules read the camunda properties. */
+  private lintedXml(xml: string, info: EnginePlatformInfo, ns: DocumentNamespaces): string {
+    if (!info.operaton) return xml;
+    const camundaPrefix = ns.prefixOf(this.kit.CAMUNDA_URI);
+    const shadowed = camundaPrefix ? this.withoutCamundaElements(xml, camundaPrefix) : xml;
+    return shadowed.replaceAll(`"${this.kit.OPERATON_URI}"`, `"${this.kit.CAMUNDA_URI}"`);
+  }
+
+  /**
+   * Operaton reads its own namespace: the rules read it as camunda's. In a file that declares both,
+   * the camunda extension elements go out of their sight (else one of each reads as doubled), while
+   * camunda attributes stay, which Operaton reads when the operaton one is missing.
+   */
+  private withoutCamundaElements(xml: string, prefix: string): string {
+    const shadow = `${prefix}-read-after-operaton`;
+    return xml.replace(new RegExp(`<(/?)${prefix}:`, 'g'), `<$1${shadow}:`).replace(/<([\w-]+:)?definitions\b/, (start) => `${start} xmlns:${shadow}="${this.kit.CAMUNDA_URI}#read-after-operaton"`);
+  }
+
+  /** The Camunda 7 vendor and the prefix of the content the rules read. */
+  private vendor(ns: DocumentNamespaces, info: EnginePlatformInfo): { operaton: boolean; prefix: string } {
+    const uri = info.operaton ? this.kit.OPERATON_URI : this.kit.CAMUNDA_URI;
+    return { operaton: !!info.operaton, prefix: ns.prefixOf(uri) ?? 'camunda' };
+  }
+
+  /** The file's spelling of a vendor attribute the typed parse names with its package prefix. */
+  private spelling(doc: Doc, ns: DocumentNamespaces, id: string, key: string): string {
+    const local = key.slice(key.indexOf(':') + 1);
+    const written = Object.keys(doc.get(id)?.$attrs ?? {}).find((name) => {
+      const uri = ns.uriOfName(name);
+      return name.slice(name.indexOf(':') + 1) === local && uri !== undefined && this.kit.C7_URIS.has(uri);
+    });
+    return written ?? key;
+  }
+
+  /** Grouped by element in the order of the file, as `bpmn validate` lists the other findings. */
+  private inDocumentOrder(doc: Doc, findings: ProfileFinding[]): ProfileFinding[] {
+    const position = new Map<string, number>();
+    for (const el of this.kit.walk(doc.definitions)) {
+      const id = (el as { id?: unknown }).id;
+      if (typeof id === 'string' && !position.has(id)) {
+        position.set(id, position.size);
+      }
+    }
+    const at = (finding: ProfileFinding): number => (finding.element !== undefined ? (position.get(finding.element) ?? -1) : -1);
+    return findings.map((finding, index) => ({ finding, index })).sort((left, right) => at(left.finding) - at(right.finding) || left.index - right.index).map(({ finding }) => finding);
+  }
+
+  /** A rule that threw reports one rule-error and no findings: it is named in a finding of its own. */
+  private failuresOf(results: Record<string, BpmnlintEngineReport[]>): Map<string, string> {
+    const failures = new Map<string, string>();
+    for (const [rule, reports] of Object.entries(results)) {
+      const failure = reports.find((report) => report.category === 'rule-error');
+      if (!failure) continue;
+      failures.set(rule, String(failure.message ?? '').split('\n')[0] ?? '');
+      delete results[rule];
+    }
+    return failures;
+  }
+}
diff --git a/src/api.ts b/src/api.ts
index f318df2e..562389c2 100644
--- a/src/api.ts
+++ b/src/api.ts
@@ -22,6 +22,7 @@ import { NoProjectSettings } from './adapters/out/memory/NoProjectSettings.js';
 import { NoDocumentFiles } from './adapters/out/memory/NoDocumentFiles.js';
 import { RelayoutDiagramService } from './application/service/RelayoutDiagramService.js';
 import { ValidateDocumentService } from './application/service/ValidateDocumentService.js';
+import { BpmnlintEngineLint } from './adapters/out/bpmnlint/BpmnlintEngineLint.js';
 import type { PlatformChoice } from './domain/document/vendor/PlatformDetection.js';
 import { type MutationReport, type ValidationReport } from './adapters/in/report/command-report.js';
 import type { Validator } from './domain/validation/validators.js';
@@ -41,6 +42,7 @@ import { ShownText } from './adapters/in/report/ShownText.js';
 
 /** The in-memory API runs the use cases without files and without a project around the document. */
 const NO_PROJECT = new NoProjectSettings();
+const ENGINE = new BpmnlintEngineLint();
 const NO_FILES = new NoDocumentFiles();
 const READ_DOCUMENT = new ReadDocumentService(NO_FILES);
 
@@ -99,12 +101,12 @@ function parseXml(xml: string, file?: string): Promise<Doc> {
 export async function applyToXml(xml: string, ops: unknown, opts: EditOptions = {}): Promise<EditResult> {
   const list = readOps(ops);
   const doc = await loadXml(xml, opts);
-  return toEditResult(xml, await new EditDocumentService(NO_PROJECT, NO_FILES).edit({ ...opts, source: { doc }, commands: list, dryRun: true }));
+  return toEditResult(xml, await new EditDocumentService(NO_PROJECT, NO_FILES, ENGINE).edit({ ...opts, source: { doc }, commands: list, dryRun: true }));
 }
 
 /** `bpmn new`: a laid-out document with one empty process. */
 export async function newXml(opts: NewDocOptions & EditOptions = {}): Promise<EditResult> {
-  return toEditResult(undefined, await new CreateDocumentService(NO_PROJECT, NO_FILES).create({ ...opts, dryRun: true }));
+  return toEditResult(undefined, await new CreateDocumentService(NO_PROJECT, NO_FILES, ENGINE).create({ ...opts, dryRun: true }));
 }
 
 export interface LayoutXmlOptions extends Omit<EditOptions, 'layout'> {
@@ -118,7 +120,7 @@ export interface LayoutXmlOptions extends Omit<EditOptions, 'layout'> {
 export async function layoutXml(xml: string, opts: LayoutXmlOptions = {}): Promise<EditResult> {
   RelayoutDiagramService.assertOptions(opts);
   const doc = await loadXml(xml, opts);
-  return toEditResult(xml, await new RelayoutDiagramService(NO_PROJECT, NO_FILES).relayout({ ...opts, source: { doc }, dryRun: true }));
+  return toEditResult(xml, await new RelayoutDiagramService(NO_PROJECT, NO_FILES, ENGINE).relayout({ ...opts, source: { doc }, dryRun: true }));
 }
 
 export interface ValidateXmlOptions {
@@ -131,7 +133,7 @@ export interface ValidateXmlOptions {
 
 /** `bpmn validate --json`: structure, lint, platform profile, validators and a layout dry run. */
 export async function validateXml(xml: string, opts: ValidateXmlOptions = {}): Promise<ValidationReport> {
-  return new ValidationReportBuilder(await new ValidateDocumentService(NO_PROJECT, NO_FILES).validate({ ...opts, source: { doc: await parseXml(xml, opts.file) } })).report();
+  return new ValidationReportBuilder(await new ValidateDocumentService(NO_PROJECT, NO_FILES, ENGINE).validate({ ...opts, source: { doc: await parseXml(xml, opts.file) } })).report();
 }
 
 /** The text of a view as `bpmn show` prints it, without the final newline. */
@@ -179,20 +181,20 @@ export async function extensionsXml(xml: string, id: string): Promise<ExtensionI
 
 /** Sets or, without an argument, clears the process-wide sink of layout diagnostics. */
 export function setLayoutDebug(sink?: DebugSink): void {
-  new RelayoutDiagramService(NO_PROJECT, NO_FILES).setDebugSink(sink !== undefined ? { sink } : {});
+  new RelayoutDiagramService(NO_PROJECT, NO_FILES, ENGINE).setDebugSink(sink !== undefined ? { sink } : {});
 }
 
 /** Applies ops to an in-memory document in one batch. */
 export function mutateDoc(doc: Doc, ops: EditCommand[], opts: MutationOptions = {}): Promise<MutationResult> {
-  return new EditDocumentService(NO_PROJECT, NO_FILES).edit({ ...opts, source: { doc }, commands: ops, dryRun: true });
+  return new EditDocumentService(NO_PROJECT, NO_FILES, ENGINE).edit({ ...opts, source: { doc }, commands: ops, dryRun: true });
 }
 
 /** `bpmn layout` on an in-memory document. */
 export function layoutDoc(doc: Doc, opts: LayoutDocOptions = {}): Promise<MutationResult> {
-  return new RelayoutDiagramService(NO_PROJECT, NO_FILES).relayout({ ...opts, source: { doc }, dryRun: true });
+  return new RelayoutDiagramService(NO_PROJECT, NO_FILES, ENGINE).relayout({ ...opts, source: { doc }, dryRun: true });
 }
 
 /** What `bpmn validate` finds in a document. */
 export function checkDoc(doc: Doc, opts: CheckOptions = {}): Promise<CheckResult> {
-  return new ValidateDocumentService(NO_PROJECT, NO_FILES).validate({ ...opts, source: { doc } });
+  return new ValidateDocumentService(NO_PROJECT, NO_FILES, ENGINE).validate({ ...opts, source: { doc } });
 }
diff --git a/src/application/port/in/ValidateDocumentUseCase.ts b/src/application/port/in/ValidateDocumentUseCase.ts
index e32c314d..2e5fdb27 100644
--- a/src/application/port/in/ValidateDocumentUseCase.ts
+++ b/src/application/port/in/ValidateDocumentUseCase.ts
@@ -1,7 +1,6 @@
 import type { Doc } from '../../../domain/document/Doc.js';
-import type { Platform, PlatformChoice, PlatformInfo } from '../../../domain/document/vendor/PlatformDetection.js';
-import type { ValidateOptions, ValidationResult } from '../../../domain/validation/StructuralValidator.js';
-import type { ProfileReport } from '../../../domain/validation/profiles/PlatformProfiles.js';
+import type { PlatformInfo } from '../../../domain/document/vendor/PlatformDetection.js';
+import type { ValidationResult } from '../../../domain/validation/StructuralValidator.js';
 import type { FileBpmnlintOptions } from '../out/LoadProjectSettingsPort.js';
 import type { CheckOptions, CheckResult } from '../../../domain/validation/DocumentCheck.js';
 import type { DocumentSource } from './DocumentSource.js';
@@ -14,17 +13,8 @@ export interface ValidateDocumentUseCase {
 
   validate(command: ValidateDocumentUseCase.Command): Promise<ValidateDocumentUseCase.Result>;
 
-  /** Structural validation and lint of a document, with the platform profile on request. */
-  validateStructure(command: ValidateDocumentUseCase.StructureCommand): ValidationResult;
-
-  /** Loads the engine rules of a platform (cached), needed before the synchronous profile runs. */
-  loadProfile(command: ValidateDocumentUseCase.LoadProfileCommand): Promise<void>;
-
-  /** Loads the engine rules of several platforms (default: all). */
-  loadProfiles(command: ValidateDocumentUseCase.LoadProfilesCommand): Promise<void>;
-
-  /** Runs the profile of the document's platform (or `choice`); its rules must be loaded. */
-  runProfile(command: ValidateDocumentUseCase.ProfileCommand): ProfileReport;
+  /** Structural validation and lint of a document (the engine rules run in `validate`). */
+  validateStructure(command: ValidateDocumentUseCase.DocumentCommand): ValidationResult;
 
   detectPlatform(command: ValidateDocumentUseCase.DocumentCommand): PlatformInfo;
 }
@@ -44,25 +34,6 @@ export declare namespace ValidateDocumentUseCase {
     doc: Doc;
   }
 
-  /** A document and the structural validation options. */
-  interface StructureCommand extends DocumentCommand, ValidateOptions {}
-
-  /** A document whose platform profile runs. */
-  interface ProfileCommand extends DocumentCommand {
-    /** the platform to run instead of the detected one */
-    choice?: PlatformChoice;
-  }
-
-  /** The platform whose engine rules are loaded. */
-  interface LoadProfileCommand {
-    platform: Platform;
-  }
-
-  /** The platforms whose engine rules are loaded. */
-  interface LoadProfilesCommand {
-    /** default: all */
-    platforms?: readonly Exclude<Platform, 'none'>[];
-  }
 }
 
 export type { CheckOptions, CheckResult };
diff --git a/src/application/port/out/EngineLintPort.ts b/src/application/port/out/EngineLintPort.ts
new file mode 100644
index 00000000..e8264b12
--- /dev/null
+++ b/src/application/port/out/EngineLintPort.ts
@@ -0,0 +1,4 @@
+import type { EngineLint } from '../../../domain/validation/EngineLint.js';
+
+/** The Camunda 7 / 8 rules a document is checked with: what its engine refuses, ignores or fails on. */
+export type EngineLintPort = EngineLint;
diff --git a/src/application/service/CreateDocumentService.ts b/src/application/service/CreateDocumentService.ts
index aa56b6fc..06c2f012 100644
--- a/src/application/service/CreateDocumentService.ts
+++ b/src/application/service/CreateDocumentService.ts
@@ -2,6 +2,7 @@ import { Doc } from '../../domain/document/Doc.js';
 import { newProcessChange } from '../../domain/document/utils/new-process.js';
 import type { CreateDocumentUseCase } from '../port/in/CreateDocumentUseCase.js';
 import type { DocumentPort } from '../port/out/DocumentPort.js';
+import type { EngineLintPort } from '../port/out/EngineLintPort.js';
 import type { LoadProjectSettingsPort } from '../port/out/LoadProjectSettingsPort.js';
 import { EditBatch } from '../../domain/batch/EditBatch.js';
 
@@ -9,6 +10,7 @@ export class CreateDocumentService implements CreateDocumentUseCase {
   constructor(
     private readonly settings: LoadProjectSettingsPort,
     private readonly documents: DocumentPort,
+    private readonly engine: EngineLintPort,
   ) {}
 
   /** An existing file fails before the .bpmnlintrc is read. */
@@ -16,7 +18,7 @@ export class CreateDocumentService implements CreateDocumentUseCase {
     const { destination, ...opts } = command;
     if (opts.processId !== undefined) Doc.assertProcessId(opts.processId);
     const target = await this.documents.target(destination, opts);
-    const project = (await this.settings.lint(opts.file ?? target, opts)).applyTo(opts, target);
+    const project = (await this.settings.lint(opts.file ?? target, opts)).applyTo({ engine: this.engine, ...opts }, target);
     const conventions = opts.conventions ?? (await this.settings.idConventions(target, opts))?.conventions;
     const doc = Doc.create({ processName: opts.processName, processId: opts.processId, executable: opts.executable, target: opts.target, ...(conventions ? { conventions } : {}) }, destination);
     const result = await new EditBatch(doc, [], project).run(target);
diff --git a/src/application/service/EditDocumentService.ts b/src/application/service/EditDocumentService.ts
index 4e8cb4eb..599890c0 100644
--- a/src/application/service/EditDocumentService.ts
+++ b/src/application/service/EditDocumentService.ts
@@ -1,5 +1,6 @@
 import type { EditDocumentUseCase } from '../port/in/EditDocumentUseCase.js';
 import type { DocumentPort } from '../port/out/DocumentPort.js';
+import type { EngineLintPort } from '../port/out/EngineLintPort.js';
 import type { LoadProjectSettingsPort } from '../port/out/LoadProjectSettingsPort.js';
 import { EditBatch } from '../../domain/batch/EditBatch.js';
 import { TextPreservation, type PreservedText } from '../../domain/document/xml/TextPreservation.js';
@@ -8,13 +9,14 @@ export class EditDocumentService implements EditDocumentUseCase {
   constructor(
     private readonly settings: LoadProjectSettingsPort,
     private readonly documents: DocumentPort,
+    private readonly engine: EngineLintPort,
   ) {}
 
   async edit(command: EditDocumentUseCase.Command): Promise<EditDocumentUseCase.Result> {
     const { source, commands, ...opts } = command;
     const doc = await this.documents.load(source, { ...opts, lossless: true });
     const target = await this.documents.target(doc.file, opts);
-    const project = (await this.settings.lint(opts.file ?? target, opts)).applyTo(opts, target);
+    const project = (await this.settings.lint(opts.file ?? target, opts)).applyTo({ engine: this.engine, ...opts }, target);
     const result = await new EditBatch(doc, commands, project).run(target);
     await this.documents.save(result, doc, target, opts);
     return result;
diff --git a/src/application/service/RelayoutDiagramService.ts b/src/application/service/RelayoutDiagramService.ts
index 7daffe37..6430edee 100644
--- a/src/application/service/RelayoutDiagramService.ts
+++ b/src/application/service/RelayoutDiagramService.ts
@@ -8,6 +8,7 @@ import { LayoutDebug } from '../../domain/diagram/layout/LayoutDebug.js';
 import type { LayoutDocOptions, RelayoutDiagramUseCase } from '../port/in/RelayoutDiagramUseCase.js';
 import type { MutationResult } from '../../domain/batch/types.js';
 import type { DocumentPort } from '../port/out/DocumentPort.js';
+import type { EngineLintPort } from '../port/out/EngineLintPort.js';
 import type { LoadProjectSettingsPort } from '../port/out/LoadProjectSettingsPort.js';
 
 /** Ids that are no sub-process are errors, not silent no-ops. */
@@ -15,6 +16,7 @@ export class RelayoutDiagramService implements RelayoutDiagramUseCase {
   constructor(
     private readonly settings: LoadProjectSettingsPort,
     private readonly documents: DocumentPort,
+    private readonly engine: EngineLintPort,
   ) {}
 
   async relayout(command: RelayoutDiagramUseCase.Command): Promise<RelayoutDiagramUseCase.Result> {
@@ -22,7 +24,7 @@ export class RelayoutDiagramService implements RelayoutDiagramUseCase {
     RelayoutDiagramService.assertOptions(opts);
     const doc = await this.documents.load(source, { ...opts, lossless: true });
     const target = await this.documents.target(doc.file, opts);
-    const project = (await this.settings.lint(opts.file ?? target, opts)).applyTo(opts, target);
+    const project = (await this.settings.lint(opts.file ?? target, opts)).applyTo({ engine: this.engine, ...opts }, target);
     const result = project.tidy ? await this.tidy(doc, project, target) : await this.redraw(doc, project, target);
     await this.documents.save(result, doc, target, opts);
     return result;
diff --git a/src/application/service/ValidateDocumentService.ts b/src/application/service/ValidateDocumentService.ts
index 82cb4d29..d5996244 100644
--- a/src/application/service/ValidateDocumentService.ts
+++ b/src/application/service/ValidateDocumentService.ts
@@ -1,39 +1,27 @@
 import { PlatformDetection, type PlatformInfo } from '../../domain/document/vendor/PlatformDetection.js';
-import { PLATFORM_PROFILES, type ProfileReport } from '../../domain/validation/profiles/PlatformProfiles.js';
 import { StructuralValidator, type ValidationResult } from '../../domain/validation/StructuralValidator.js';
 import { DocumentCheck } from '../../domain/validation/DocumentCheck.js';
 import type { ValidateDocumentUseCase } from '../port/in/ValidateDocumentUseCase.js';
 import type { DocumentPort } from '../port/out/DocumentPort.js';
+import type { EngineLintPort } from '../port/out/EngineLintPort.js';
 import type { LoadProjectSettingsPort } from '../port/out/LoadProjectSettingsPort.js';
 
 export class ValidateDocumentService implements ValidateDocumentUseCase {
   constructor(
     private readonly settings: LoadProjectSettingsPort,
     private readonly documents: DocumentPort,
+    private readonly engine: EngineLintPort,
   ) {}
 
   async validate(command: ValidateDocumentUseCase.Command): Promise<ValidateDocumentUseCase.Result> {
     const { source, ...opts } = command;
     const doc = await this.documents.load(source);
-    const project = (await this.settings.lint(opts.file ?? doc.file, opts)).applyTo(opts, doc.file);
+    const project = (await this.settings.lint(opts.file ?? doc.file, opts)).applyTo({ engine: this.engine, ...opts }, doc.file);
     return new DocumentCheck(doc, project).run();
   }
 
-  validateStructure(command: ValidateDocumentUseCase.StructureCommand): ValidationResult {
-    const { doc, ...opts } = command;
-    return new StructuralValidator(doc).validate(opts);
-  }
-
-  loadProfile(command: ValidateDocumentUseCase.LoadProfileCommand): Promise<void> {
-    return PLATFORM_PROFILES.load(command.platform);
-  }
-
-  loadProfiles(command: ValidateDocumentUseCase.LoadProfilesCommand): Promise<void> {
-    return PLATFORM_PROFILES.loadAll(command.platforms);
-  }
-
-  runProfile(command: ValidateDocumentUseCase.ProfileCommand): ProfileReport {
-    return PLATFORM_PROFILES.run(command.doc, command.choice);
+  validateStructure(command: ValidateDocumentUseCase.DocumentCommand): ValidationResult {
+    return new StructuralValidator(command.doc).validate();
   }
 
   detectPlatform(command: ValidateDocumentUseCase.DocumentCommand): PlatformInfo {
diff --git a/src/cli.ts b/src/cli.ts
index 698c48b0..500e9873 100644
--- a/src/cli.ts
+++ b/src/cli.ts
@@ -9,6 +9,7 @@ import { EditDocumentService } from './application/service/EditDocumentService.j
 import { CreateDocumentService } from './application/service/CreateDocumentService.js';
 import { RelayoutDiagramService } from './application/service/RelayoutDiagramService.js';
 import { ValidateDocumentService } from './application/service/ValidateDocumentService.js';
+import { BpmnlintEngineLint } from './adapters/out/bpmnlint/BpmnlintEngineLint.js';
 import { ReadDocumentService } from './application/service/ReadDocumentService.js';
 import { ShowConventionsService } from './application/service/ShowConventionsService.js';
 import { RenderDiagramService } from './application/service/RenderDiagramService.js';
@@ -37,15 +38,16 @@ function exitWhenWritten(): void {
 
 const files = new FileDocumentStore();
 const project = new BpmnlintProjectSettings();
-const relayoutDiagram = new RelayoutDiagramService(project, files);
+const engine = new BpmnlintEngineLint();
+const relayoutDiagram = new RelayoutDiagramService(project, files, engine);
 if (process.env['BPMN_LAYOUT_DEBUG']) {
   relayoutDiagram.setDebugSink({ sink: (line) => process.stderr.write(`${line}\n`) });
 }
 const cli = new Cli(VERSION, {
-  editDocument: new EditDocumentService(project, files),
-  createDocument: new CreateDocumentService(project, files),
+  editDocument: new EditDocumentService(project, files, engine),
+  createDocument: new CreateDocumentService(project, files, engine),
   relayoutDiagram,
-  validateDocument: new ValidateDocumentService(project, files),
+  validateDocument: new ValidateDocumentService(project, files, engine),
   readDocument: new ReadDocumentService(files),
   showModel: new ShowModelService(),
   showConventions: new ShowConventionsService(project),
diff --git a/src/domain/batch/EditBatch.ts b/src/domain/batch/EditBatch.ts
index f050f4e6..aff1c531 100644
--- a/src/domain/batch/EditBatch.ts
+++ b/src/domain/batch/EditBatch.ts
@@ -6,7 +6,6 @@ import { reportedImportWarnings } from '../editing/utils/decision-link-warnings.
 import { ModelCommands, type BatchRun } from './ModelCommands.js';
 import { withoutProfileDuplicates } from '../validation/utils/finding-coverage.js';
 import type { EditCommand } from '../commands/types.js';
-import { PLATFORM_PROFILES } from '../validation/profiles/PlatformProfiles.js';
 import type { ValidationResult } from '../validation/StructuralValidator.js';
 import { FindingBaseline, type ValidationDelta } from '../validation/FindingBaseline.js';
 import { ModelViewBuilder } from '../views/ModelViewBuilder.js';
@@ -43,10 +42,10 @@ export class EditBatch {
    */
   async run(file = this.doc.file): Promise<MutationResult> {
     return LayoutDebug.during(this.opts.debug, async () => {
-      await this.guard();
+      this.doc.assertLossless(this.opts);
       const asRead = await this.textAsRead();
       const diagram = await BatchDrawing.capture(this.doc, this.commands, this.opts, asRead, EditBatch.removeElements);
-      const findings = await FindingBaseline.capture(this.doc, { platform: this.opts.platform, force: this.opts.force, validators: this.opts.validators, file: this.opts.file ?? this.doc.file, ops: this.commands });
+      const findings = await FindingBaseline.capture(this.doc, { platform: this.opts.platform, engine: this.opts.engine, force: this.opts.force, validators: this.opts.validators, file: this.opts.file ?? this.doc.file, ops: this.commands });
       const importWarnings = reportedImportWarnings(this.doc).map((warning) => warning.message.split('\n')[0]!);
       const { batch, last } = await this.runCommands(diagram);
       await this.validateAndDropProfileDuplicates(findings, batch);
@@ -62,12 +61,6 @@ export class EditBatch {
     new ModelCommands(doc).runBatch([{ op: 'remove', ids, ifExists: true }]);
   }
 
-  /** Loads the platform profiles, a chunk of their own in a browser bundle, before anything runs. */
-  private async guard(): Promise<void> {
-    this.doc.assertLossless(this.opts);
-    await PLATFORM_PROFILES.ensure(this.doc, this.opts.platform);
-  }
-
   private async runCommands(diagram: BatchDrawing): Promise<{ batch: BatchRun; last?: DrawingSegment }> {
     let ran: { batch: BatchRun; last?: DrawingSegment };
     try {
diff --git a/src/domain/batch/types.ts b/src/domain/batch/types.ts
index 6578dbea..6d7b4549 100644
--- a/src/domain/batch/types.ts
+++ b/src/domain/batch/types.ts
@@ -6,6 +6,7 @@ import type { PlatformChoice } from '../document/vendor/PlatformDetection.js';
 import type { ValidationResult } from '../validation/StructuralValidator.js';
 import type { ValidationDelta } from '../validation/FindingBaseline.js';
 import type { Validator } from '../validation/validators.js';
+import type { EngineLint } from '../validation/EngineLint.js';
 import type { ModelView } from '../views/model-view.js';
 
 /** How one batch runs: its layout, guards, validators and id conventions. */
@@ -15,6 +16,8 @@ export interface MutationOptions extends DrawingOptions {
   show?: boolean;
   /** platform profile whose new findings are reported: 'auto' (default), 'none' switches it off */
   platform?: PlatformChoice;
+  /** the Camunda 7 / 8 rules; without them a change reports no platform findings */
+  engine?: EngineLint;
   /** receives the layout engines' diagnostic lines during this call */
   debug?: DebugSink;
   /** run on the candidate XML; errors the change introduces block the write */
diff --git a/src/domain/document/vendor/DocumentNamespaces.ts b/src/domain/document/vendor/DocumentNamespaces.ts
index 5996db4f..9b4b5791 100644
--- a/src/domain/document/vendor/DocumentNamespaces.ts
+++ b/src/domain/document/vendor/DocumentNamespaces.ts
@@ -79,10 +79,16 @@ export class DocumentNamespaces {
 
   /** Any prefix bound to the modeler namespace counts. */
   executionPlatform(): string | undefined {
+    return this.modelerAttribute('executionPlatform');
+  }
+
+  executionPlatformVersion(): string | undefined {
+    return this.modelerAttribute('executionPlatformVersion');
+  }
+
+  private modelerAttribute(local: string): string | undefined {
     for (const [attrName, attrValue] of Object.entries(this.definitions.$attrs ?? {})) {
-      if (!attrName.endsWith(':executionPlatform') && attrName !== 'executionPlatform') {
-        continue;
-      }
+      if (!attrName.endsWith(`:${local}`) && attrName !== local) continue;
       const uri = this.uriOfName(attrName);
       if (uri && uri !== MODELER_URI) continue;
       if (typeof attrValue === 'string') return attrValue;
diff --git a/src/domain/document/vendor/PlatformDetection.ts b/src/domain/document/vendor/PlatformDetection.ts
index b4be78af..746d41a0 100644
--- a/src/domain/document/vendor/PlatformDetection.ts
+++ b/src/domain/document/vendor/PlatformDetection.ts
@@ -23,6 +23,8 @@ export interface PlatformInfo {
   detail: string;
   /** c7 only: the profile then reads operaton:* before camunda:* like Operaton does. */
   operaton?: boolean;
+  /** `modeler:executionPlatformVersion` of an engine file, e.g. `8.9.0`: the engine rules check against it */
+  version?: string;
 }
 
 const OPERATON_NOTE = 'only Operaton reads the operaton namespace, Camunda 7 and CIB seven ignore it';
@@ -51,8 +53,9 @@ export class PlatformDetection {
       info.platform === 'c7' && operaton > 0 ? { ...info, operaton: true, ...(info.source === 'namespace-use' ? {} : { detail: `${info.detail}; ${operaton} operaton attribute(s)/element(s): ${OPERATON_NOTE}` }) } : info;
     if (declared !== undefined) {
       const platform = this.fromExecutionPlatform(declared);
+      const version = ns.executionPlatformVersion();
       if (platform) {
-        return withOperaton({ platform, source: 'executionPlatform', detail: `modeler:executionPlatform "${declared}"` });
+        return withOperaton({ platform, source: 'executionPlatform', detail: `modeler:executionPlatform "${declared}"`, ...(version ? { version } : {}) });
       }
     }
     if (c7 || c8) {
@@ -78,9 +81,9 @@ export class PlatformDetection {
   /** The choice picks the profile; whether content is read as Operaton's still comes from the file. */
   resolve(choice: PlatformChoice = 'auto'): PlatformInfo {
     if (choice === 'auto') return this.info();
-    const info: PlatformInfo = { platform: choice, source: 'option', detail: '--platform option' };
-    if (choice !== 'c7') return info;
     const detected = this.info();
+    const info: PlatformInfo = { platform: choice, source: 'option', detail: '--platform option', ...(detected.platform === choice && detected.version ? { version: detected.version } : {}) };
+    if (choice !== 'c7') return info;
     return detected.operaton ? { ...info, operaton: true, detail: `--platform option; the file uses the operaton namespace: ${OPERATON_NOTE}` } : info;
   }
 
diff --git a/src/domain/editing/properties/DecisionLinkWriter.ts b/src/domain/editing/properties/DecisionLinkWriter.ts
index d2d7af1e..72bb9801 100644
--- a/src/domain/editing/properties/DecisionLinkWriter.ts
+++ b/src/domain/editing/properties/DecisionLinkWriter.ts
@@ -112,7 +112,7 @@ export class DecisionLinkWriter {
               element: shownId(el),
               hint: `Name the variable that receives the result: \`bpmn ext add <file> ${shownId(el)} ${call.$type} decisionId=${value} resultVariable=<variable> --replace\`.`,
             },
-            { covers: ['decision:resultVariable'] },
+            { covers: ['ext:calledDecision.resultVariable'] },
           ),
         );
       }
diff --git a/src/domain/validation/DocumentCheck.ts b/src/domain/validation/DocumentCheck.ts
index dcb00730..2036909d 100644
--- a/src/domain/validation/DocumentCheck.ts
+++ b/src/domain/validation/DocumentCheck.ts
@@ -6,7 +6,8 @@ import { LayoutDebug, type DebugSink } from '../diagram/layout/LayoutDebug.js';
 import { FullLayout } from '../diagram/layout/FullLayout.js';
 import { reportedImportWarnings } from '../editing/utils/decision-link-warnings.js';
 import { PlatformDetection, type PlatformChoice } from '../document/vendor/PlatformDetection.js';
-import { PLATFORM_PROFILES } from './profiles/PlatformProfiles.js';
+import type { EngineLint } from './EngineLint.js';
+import { PlatformCheck } from './PlatformCheck.js';
 import { StructuralValidator, type ValidationResult } from './StructuralValidator.js';
 import { ValidatorSet } from './ValidatorSet.js';
 import { counts, withValidatorReports } from './utils/validator-issues.js';
@@ -19,6 +20,9 @@ export interface CheckOptions {
 
   platform?: PlatformChoice;
 
+  /** the Camunda 7 / 8 rules; without it the check has no platform findings */
+  engine?: EngineLint;
+
   /** their errors fail the check, an advisory one's too */
   validators?: Validator[];
 
@@ -51,8 +55,10 @@ export class DocumentCheck {
   run(): Promise<CheckResult> {
     return LayoutDebug.during(this.opts.debug, async () => {
       const platform = this.opts.platform ?? 'auto';
-      await PLATFORM_PROFILES.ensure(this.doc, platform);
-      let validation = new StructuralValidator(this.doc).validate({ platform });
+      const structure = new StructuralValidator(this.doc);
+      const structural = structure.validate();
+      const report = await new PlatformCheck(this.opts.engine).run(this.doc, platform);
+      let validation = structure.withProfile(structural, report, report.findings);
       const structuralErrors = validation.errors.length;
       const importWarnings = reportedImportWarnings(this.doc).map((warning) => warning.message.split('\n')[0]!);
       const validators = new ValidatorSet(this.opts.validators);
diff --git a/src/domain/validation/EngineLint.ts b/src/domain/validation/EngineLint.ts
new file mode 100644
index 00000000..f8472b7d
--- /dev/null
+++ b/src/domain/validation/EngineLint.ts
@@ -0,0 +1,14 @@
+import type { Doc } from '../document/Doc.js';
+import type { ProfileFinding } from '../document/Finding.js';
+import type { PlatformInfo } from '../document/vendor/PlatformDetection.js';
+
+/** The platform a document is checked for, once it is an engine. */
+export type EnginePlatformInfo = PlatformInfo & { platform: 'c7' | 'c8' };
+
+/**
+ * What the engine refuses, ignores or fails on in a document: the Camunda 7 / 8 rules, which
+ * the host injects (bpmn-cli's own run bpmnlint with the Miragon engine layers).
+ */
+export interface EngineLint {
+  findings(doc: Doc, info: EnginePlatformInfo): Promise<ProfileFinding[]>;
+}
diff --git a/src/domain/validation/FindingBaseline.ts b/src/domain/validation/FindingBaseline.ts
index 510acda6..fe43774d 100644
--- a/src/domain/validation/FindingBaseline.ts
+++ b/src/domain/validation/FindingBaseline.ts
@@ -4,7 +4,8 @@ import { modelError } from '../document/utils/errors.js';
 import type { EditCommand } from '../commands/types.js';
 import { PlatformDetection, type PlatformChoice } from '../document/vendor/PlatformDetection.js';
 import type { ProfileFinding } from '../document/Finding.js';
-import { PLATFORM_PROFILES, type ProfileReport } from './profiles/PlatformProfiles.js';
+import type { EngineLint } from './EngineLint.js';
+import { PlatformCheck, type ProfileReport } from './PlatformCheck.js';
 import { StructuralValidator, type ValidationResult } from './StructuralValidator.js';
 import { coveredLint, lintCoveredBy, lintKey } from './utils/finding-coverage.js';
 import { counts, preexisting, validatorRefusal, withValidatorReports } from './utils/validator-issues.js';
@@ -23,6 +24,7 @@ export interface ValidationDelta {
 
 export interface BaselineOptions {
   platform?: PlatformChoice;
+  engine?: EngineLint;
   force?: boolean;
   validators?: Validator[];
   file?: string;
@@ -56,7 +58,7 @@ export class FindingBaseline {
 
   static async capture(doc: Doc, opts: BaselineOptions): Promise<FindingBaseline> {
     const { errors, warnings } = new StructuralValidator(doc).validate();
-    const profile = PLATFORM_PROFILES.run(doc, opts.platform);
+    const profile = await new PlatformCheck(opts.engine).run(doc, opts.platform);
     const index = new Map(doc.byId());
     const validators = new ValidatorSet(opts.validators);
     const context: Omit<ValidatorContext, 'doc' | 'phase'> = { ...(opts.file ? { file: opts.file } : {}), platform: validators.size ? PlatformDetection.of(doc).resolve(opts.platform ?? 'auto').platform : 'none', ops: opts.ops };
@@ -64,13 +66,12 @@ export class FindingBaseline {
     return new FindingBaseline(doc, opts, { errors, warnings }, new FindingMatcher(index, doc), new FindingMatcher(index, doc, { bySubject: true, reusedIdIsNew: true }), doc.source ? profile : { ...profile, findings: [] }, validators, context, validatorsBefore);
   }
 
-  /** The ops can change the platform (camunda: / zeebe: content), so its rules may load now. */
+  /** The ops can change the platform (camunda: / zeebe: content): it is detected again. */
   async afterCommands(): Promise<ValidationResult> {
     const validator = new StructuralValidator(this.doc);
     const raw = (this.raw = validator.validate());
     const structural = this.separatePreexisting(raw);
-    await PLATFORM_PROFILES.ensure(this.doc, this.opts.platform);
-    const after = (this.profileAfter = PLATFORM_PROFILES.run(this.doc, this.opts.platform));
+    const after = (this.profileAfter = await new PlatformCheck(this.opts.engine).run(this.doc, this.opts.platform));
     const delta = this.profileMatcher.delta(this.profileBefore.findings, after.findings);
     const validation = (this.validation = validator.withProfile(structural, after, delta.added, delta));
     if (validation.errors.length && !this.opts.force) {
diff --git a/src/domain/validation/PlatformCheck.ts b/src/domain/validation/PlatformCheck.ts
new file mode 100644
index 00000000..d9ff75cb
--- /dev/null
+++ b/src/domain/validation/PlatformCheck.ts
@@ -0,0 +1,36 @@
+import type { Doc } from '../document/Doc.js';
+import type { ProfileFinding, Severity } from '../document/Finding.js';
+import { SEVERITIES } from '../document/utils/finding.js';
+import { PlatformDetection, type PlatformChoice, type PlatformInfo } from '../document/vendor/PlatformDetection.js';
+import type { EngineLint } from './EngineLint.js';
+
+export interface ProfileReport extends PlatformInfo {
+  findings: ProfileFinding[];
+}
+
+export interface PlatformSummary extends PlatformInfo {
+  /** all findings, also the ones a mutation did not introduce */
+  counts: Record<Severity, number>;
+  added?: ProfileFinding[];
+  resolved?: ProfileFinding[];
+}
+
+/** The engine-specific findings on top of the structural validation, from the injected engine lint. */
+export class PlatformCheck {
+  constructor(private readonly engine: EngineLint | undefined) {}
+
+  /** No engine lint, or a document for no engine: the platform with no finding. */
+  async run(doc: Doc, choice: PlatformChoice = 'auto'): Promise<ProfileReport> {
+    const info = PlatformDetection.of(doc).resolve(choice);
+    if (info.platform === 'none' || !this.engine) return { ...info, findings: [] };
+    return { ...info, findings: await this.engine.findings(doc, { ...info, platform: info.platform }) };
+  }
+
+  static summarize(report: ProfileReport): PlatformSummary {
+    const counts = Object.fromEntries(SEVERITIES.map((severity) => [severity, 0])) as Record<Severity, number>;
+    for (const finding of report.findings) {
+      counts[finding.severity]++;
+    }
+    return { platform: report.platform, source: report.source, detail: report.detail, ...(report.operaton ? { operaton: true } : {}), ...(report.version ? { version: report.version } : {}), counts };
+  }
+}
diff --git a/src/domain/validation/StructuralValidator.ts b/src/domain/validation/StructuralValidator.ts
index bea0a5fb..5c07d290 100644
--- a/src/domain/validation/StructuralValidator.ts
+++ b/src/domain/validation/StructuralValidator.ts
@@ -3,9 +3,8 @@ import type { Finding } from '../document/Finding.js';
 import { isEventSubProcess, isRejectedType } from '../document/Kinds.js';
 import { completeMirrorLists } from '../document/utils/mirror.js';
 import { is, walk, type El, shownId } from '../document/utils/moddle.js';
-import type { PlatformChoice } from '../document/vendor/PlatformDetection.js';
 import type { ProfileFinding } from '../document/Finding.js';
-import { PLATFORM_PROFILES, type PlatformSummary, type ProfileReport } from './profiles/PlatformProfiles.js';
+import { PlatformCheck, type PlatformSummary, type ProfileReport } from './PlatformCheck.js';
 import type { ValidatorReport } from './validators.js';
 import { FlowOrder } from './FlowOrder.js';
 import { lintCoveredBy } from './utils/finding-coverage.js';
@@ -25,24 +24,16 @@ export interface ValidationResult {
   validators?: ValidatorReport[];
 }
 
-export interface ValidateOptions {
-  /** omitted runs no profile; a given one's rules must be loaded first (loadProfile) */
-  platform?: PlatformChoice;
-}
-
 /**
- * Structural validation (errors block writes) and lint (warnings), optionally followed by
- * the platform profile's engine-specific findings.
+ * Structural validation (errors block writes) and lint (warnings); `withProfile` adds the
+ * platform's engine-specific findings.
  */
 export class StructuralValidator {
   constructor(private readonly doc: Doc) {}
 
   /** Completes the incoming/outgoing mirror lists first: the only change it makes to the model. */
-  validate(opts: ValidateOptions = {}): ValidationResult {
-    const result = this.validateStructure();
-    if (opts.platform === undefined) return result;
-    const report = PLATFORM_PROFILES.run(this.doc, opts.platform);
-    return this.withProfile(result, report, report.findings);
+  validate(): ValidationResult {
+    return this.validateStructure();
   }
 
   /**
@@ -53,27 +44,11 @@ export class StructuralValidator {
     return completeMirrorLists(this.doc.definitions);
   }
 
-  /**
-   * A lint warning a shown platform finding repeats is dropped (it adds the engine's verdict),
-   * and so is a platform finding an E_INVALID_HOST already reports.
-   */
+  /** A lint warning a shown platform finding repeats is dropped (it adds the engine's verdict). */
   withProfile(result: ValidationResult, report: ProfileReport, shown: ProfileFinding[], delta?: { added: ProfileFinding[]; resolved: ProfileFinding[] }): ValidationResult {
-    const invalidHost = new Set(
-      [...result.errors, ...result.warnings]
-        .filter((error) => error.code === 'E_INVALID_HOST' || (error.code === 'W_PREEXISTING_ERROR' && error.message.startsWith('E_INVALID_HOST')))
-        .map((error) => error.element),
-    );
-    const repeated = (finding: ProfileFinding): boolean => (finding.code === 'W_C7_DEPLOY_BOUNDARY_HOST' || finding.code === 'W_C8_DEPLOY_BOUNDARY_HOST') && invalidHost.has(finding.element);
-    if (invalidHost.size) {
-      shown = shown.filter((finding) => !repeated(finding));
-      report = { ...report, findings: report.findings.filter((finding) => !repeated(finding)) };
-      if (delta) {
-        delta = { added: delta.added.filter((finding) => !repeated(finding)), resolved: delta.resolved };
-      }
-    }
     const covered = lintCoveredBy(shown);
     const warnings = result.warnings.filter((warning) => !covered(warning));
-    const platform: PlatformSummary = { ...PLATFORM_PROFILES.summarize(report), ...(delta ? { added: delta.added, resolved: delta.resolved } : {}) };
+    const platform: PlatformSummary = { ...PlatformCheck.summarize(report), ...(delta ? { added: delta.added, resolved: delta.resolved } : {}) };
     return { errors: result.errors, warnings: [...warnings, ...shown], platform };
   }
 
diff --git a/src/domain/validation/profiles/BpmnSchema.ts b/src/domain/validation/profiles/BpmnSchema.ts
deleted file mode 100644
index 2e5cb2da..00000000
--- a/src/domain/validation/profiles/BpmnSchema.ts
+++ /dev/null
@@ -1,112 +0,0 @@
-import type { BpmnModdle } from 'bpmn-moddle';
-
-export const BPMNDI_NS = 'http://www.omg.org/spec/BPMN/20100524/DI';
-
-/** An XSD choice, or children bpmn-moddle orders differently from the XSD: one place each. */
-const SAME_SLOT = [
-  ['timeDate', 'timeDuration', 'timeCycle'],
-  ['source', 'target'],
-  ['supportedInterfaceRef', 'ioSpecification', 'ioBinding'],
-  ['auditing', 'monitoring', 'categoryValueRef', 'dataState'],
-  ['resourceRef', 'resourceParameterBinding', 'resourceAssignmentExpression'],
-  ['dataOutputRefs', 'optionalOutputRefs', 'whileExecutingOutputRefs', 'inputSetRefs'],
-  ['participantMultiplicity', 'endPointRef', 'endPointRefs'],
-];
-
-export interface Descriptor {
-  name: string;
-  allTypes?: Array<{ name: string }>;
-  properties: Array<{ name: string; type: string; isAttr?: boolean; isBody?: boolean; isVirtual?: boolean; isReference?: boolean }>;
-}
-
-interface Registry {
-  typeMap: Record<string, unknown>;
-  getEffectiveDescriptor(name: string): Descriptor;
-}
-
-export class BpmnSchema {
-  private readonly registry: Registry;
-  private readonly bpmnTypes: string[];
-  private readonly slots = new Map<string, Map<string, number>>();
-  private readonly descriptors = new Map<string, Descriptor | undefined>();
-  private readonly booleans = new Map<string, Set<string>>();
-
-  constructor(
-    moddle: BpmnModdle,
-    private readonly bpmnNs: string,
-  ) {
-    this.registry = (moddle as unknown as { registry: Registry }).registry;
-    this.bpmnTypes = Object.keys(this.registry.typeMap).filter((typeName) => typeName.startsWith('bpmn:'));
-  }
-
-  descriptor(type: string): Descriptor | undefined {
-    if (!this.descriptors.has(type)) {
-      let descriptor: Descriptor | undefined;
-      try {
-        descriptor = this.registry.typeMap[type] ? this.registry.getEffectiveDescriptor(type) : undefined;
-      } catch {
-        descriptor = undefined;
-      }
-      this.descriptors.set(type, descriptor);
-    }
-    return this.descriptors.get(type);
-  }
-
-  isA(type: string, base: string): boolean {
-    return type === base || !!this.descriptor(type)?.allTypes?.some((ancestor) => ancestor.name === base);
-  }
-
-  /** A child's own type name, else the type of the parent's property of that name. */
-  typeOf(local: string, uri: string, parentType: string | undefined): string | undefined {
-    const prefix = uri === this.bpmnNs ? 'bpmn' : uri === BPMNDI_NS ? 'bpmndi' : undefined;
-    if (!prefix) return undefined;
-    const own = `${prefix}:${local.charAt(0).toUpperCase()}${local.slice(1)}`;
-    if (this.descriptor(own)) return own;
-    const property = parentType ? this.descriptor(parentType)?.properties.find((candidate) => candidate.name === local) : undefined;
-    return property && !property.isReference && this.descriptor(property.type) ? property.type : undefined;
-  }
-
-  booleanAttrs(type: string): Set<string> {
-    let out = this.booleans.get(type);
-    if (!out) {
-      out = new Set((this.descriptor(type)?.properties ?? []).filter((property) => property.isAttr && property.type === 'Boolean' && !property.name.includes(':')).map((property) => property.name));
-      this.booleans.set(type, out);
-    }
-    return out;
-  }
-
-  /** -1: the name fits two places and is not checked */
-  slotsOf(type: string): Map<string, number> {
-    let out = this.slots.get(type);
-    if (out) return out;
-    out = new Map();
-    const descriptor = this.descriptor(type);
-    descriptor?.properties.forEach((property, slot) => {
-      if (property.isAttr || property.isBody || property.isVirtual) return;
-      const names = new Set([property.name]);
-      if (!property.isReference && property.type.startsWith('bpmn:')) {
-        for (const bpmnType of this.bpmnTypes) {
-          if (this.isA(bpmnType, property.type)) {
-            names.add(bpmnType.charAt(5).toLowerCase() + bpmnType.slice(6));
-          }
-        }
-      }
-      if (!property.isReference && property.type.startsWith('bpmndi:')) {
-        names.add(property.type.slice('bpmndi:'.length));
-      }
-      for (const name of names) {
-        out!.set(name, out!.has(name) && out!.get(name) !== slot ? -1 : slot);
-      }
-    });
-    for (const group of SAME_SLOT) {
-      const at = group.map((name) => out!.get(name)).filter((slot): slot is number => slot !== undefined && slot >= 0);
-      if (at.length < 2) continue;
-      const first = Math.min(...at);
-      for (const name of group) {
-        if ((out.get(name) ?? -1) >= 0) out.set(name, first);
-      }
-    }
-    this.slots.set(type, out);
-    return out;
-  }
-}
diff --git a/src/domain/validation/profiles/C7Profile.ts b/src/domain/validation/profiles/C7Profile.ts
deleted file mode 100644
index 074a9ec7..00000000
--- a/src/domain/validation/profiles/C7Profile.ts
+++ /dev/null
@@ -1,94 +0,0 @@
-import type { El } from '../../document/utils/moddle.js';
-import { C7DescriptorNames } from './c7/C7DescriptorNames.js';
-import { C7EventRules } from './c7/C7EventRules.js';
-import { C7ExtensionContentRules } from './c7/C7ExtensionContentRules.js';
-import { C7ExtensionRules } from './c7/C7ExtensionRules.js';
-import { C7FlowRules } from './c7/C7FlowRules.js';
-import { C7ImplementationRules } from './c7/C7ImplementationRules.js';
-import { SERVICE_LIKE } from './c7/C7Rules.js';
-import { C7SchemaRules } from './c7/C7SchemaRules.js';
-import { EngineProfile, type ElementWalk } from './EngineProfile.js';
-import type { RuleRun } from './RuleRun.js';
-import { list, peek } from '../utils/element.js';
-
-/**
- * The Camunda 7 profile, also for CIB seven and Operaton: what the engines refuse on deploy,
- * ignore or fail on at run time (checked against 7.24, CIB seven 2.2, Operaton 2.1.5), over
- * executable processes, file-level content and the schema of the whole file.
- */
-export class C7Profile extends EngineProfile {
-  private readonly names = new C7DescriptorNames(this.kit);
-  private extensions!: C7ExtensionRules;
-  private implementation!: C7ImplementationRules;
-  private events!: C7EventRules;
-  private flows!: C7FlowRules;
-
-  /** `operaton`: read the file like Operaton does (detected from the namespace when omitted). */
-  protected override checkDocument(run: RuleRun, opts: { operaton?: boolean }): void {
-    const { doc, ns } = run;
-    const operaton = opts.operaton ?? (ns.usage().get(this.kit.OPERATON_URI) ?? 0) > 0;
-    const prefix = (operaton ? ns.prefixOf(this.kit.OPERATON_URI) : undefined) ?? ns.prefixOf(this.kit.camunda.uri) ?? ns.prefixOf(this.kit.OPERATON_URI) ?? 'camunda';
-    this.implementation = new C7ImplementationRules(run, prefix);
-    this.extensions = new C7ExtensionRules(run, prefix, this.names, new C7ExtensionContentRules(run, prefix, this.implementation));
-    this.events = new C7EventRules(run, prefix, this.implementation);
-    this.flows = new C7FlowRules(run, prefix, operaton, this.implementation);
-    const defs = doc.definitions;
-    this.extensions.checkAttributes(defs, undefined);
-    this.extensions.checkExtensions(defs, undefined, true);
-    const executable = doc.processes().filter((proc) => peek<boolean>(proc, 'isExecutable') === true);
-    for (const root of list(defs, 'rootElements')) {
-      if (this.kit.is(root, 'bpmn:Process')) {
-        if (executable.includes(root)) this.visit(root, undefined, true);
-        continue;
-      }
-      this.visit(root, undefined, false);
-    }
-    if (executable.length) this.events.checkSignalNames();
-    const schema = new C7SchemaRules(run, prefix);
-    schema.checkSchemaEventDefinitions();
-    schema.checkSchemaAttributes();
-  }
-
-  /** Checks one element; an executable ad-hoc sub-process ends the walk, as the engines skip it with its content like a non-executable process. */
-  protected override checkElement(el: El, owner: El | undefined, executable: boolean): ElementWalk {
-    const is = this.kit.is;
-    if (executable && is(el, 'bpmn:AdHocSubProcess')) {
-      this.flows.checkAdHoc(el);
-      return 'stop';
-    }
-    this.extensions.checkAttributes(el, owner);
-    this.extensions.checkExtensions(el, owner, executable);
-    this.extensions.checkVendorRefs(el, owner);
-    if (!executable) return 'descend';
-    const implementation = this.implementation;
-    if (is(el, 'bpmn:Process')) implementation.checkProcess(el);
-    if (SERVICE_LIKE.some((type) => is(el, type))) {
-      implementation.checkServiceLike(el);
-    }
-    if (is(el, 'bpmn:BusinessRuleTask')) implementation.checkBusinessRule(el);
-    if (is(el, 'bpmn:CallActivity')) implementation.checkCallActivity(el);
-    if (is(el, 'bpmn:UserTask') || is(el, 'bpmn:StartEvent')) {
-      implementation.checkForms(el);
-    }
-    if (is(el, 'bpmn:UserTask')) implementation.checkUserTaskPriority(el);
-    if (is(el, 'bpmn:Activity')) implementation.checkMultiInstance(el);
-    if (is(el, 'bpmn:Event')) this.events.checkEvent(el);
-    if (is(el, 'bpmn:EventBasedGateway')) this.flows.checkEventGateway(el);
-    if (is(el, 'bpmn:ComplexGateway')) this.flows.checkComplexGateway(el);
-    if (is(el, 'bpmn:ExclusiveGateway')) this.flows.checkExclusiveGateway(el);
-    if (is(el, 'bpmn:ScriptTask')) implementation.checkScriptTask(el);
-    if (is(el, 'bpmn:ReceiveTask')) this.events.checkReceiveTask(el);
-    if (is(el, 'bpmn:SequenceFlow')) this.flows.checkFlowCondition(el);
-    if ((is(el, 'bpmn:Activity') || is(el, 'bpmn:Gateway') || is(el, 'bpmn:Event') || is(el, 'bpmn:MultiInstanceLoopCharacteristics')) && !is(el, 'bpmn:Process')) {
-      implementation.checkPriorities(el, owner, ['jobPriority']);
-    }
-    if (is(el, 'bpmn:Process') || is(el, 'bpmn:SubProcess')) {
-      this.events.checkStartEvents(el);
-    }
-    if (is(el, 'bpmn:Process')) {
-      this.events.checkSubscriptions(el);
-      this.events.checkLinks(el);
-    }
-    return 'descend';
-  }
-}
diff --git a/src/domain/validation/profiles/C8Profile.ts b/src/domain/validation/profiles/C8Profile.ts
deleted file mode 100644
index 5d2bcee0..00000000
--- a/src/domain/validation/profiles/C8Profile.ts
+++ /dev/null
@@ -1,92 +0,0 @@
-import type { Doc } from '../../document/Doc.js';
-import type { El } from '../../document/utils/moddle.js';
-import { C8EventRules } from './c8/C8EventRules.js';
-import { C8ExtensionRules } from './c8/C8ExtensionRules.js';
-import { C8FlowRules } from './c8/C8FlowRules.js';
-import { C8SchemaRules } from './c8/C8SchemaRules.js';
-import { C8TaskRules } from './c8/C8TaskRules.js';
-import { EngineProfile, type ElementWalk } from './EngineProfile.js';
-import type { RuleRun } from './RuleRun.js';
-import { SchemaText, type SchemaTextIssue } from './SchemaText.js';
-import { peek } from '../utils/element.js';
-
-/**
- * The Camunda 8 (Zeebe) profile: what Camunda 8.9 refuses on deploy, ignores or fails on at run
- * time, and zeebe content it does not know. It covers executable processes (ad-hoc content
- * included), the root elements they use, and the schema of the whole file.
- */
-export class C8Profile extends EngineProfile {
-  private readonly textIssues = new WeakMap<object, SchemaTextIssue[]>();
-  private readonly schemaText = new SchemaText(this.kit);
-  private extensions!: C8ExtensionRules;
-  private tasks!: C8TaskRules;
-  private events!: C8EventRules;
-  private flows!: C8FlowRules;
-
-  /** Checks the document; the root elements the executable processes use are checked through their events. */
-  protected override checkDocument(run: RuleRun): void {
-    const { doc } = run;
-    const prefix = run.ns.prefixOf(this.kit.zeebe.uri) ?? 'zeebe';
-    this.extensions = new C8ExtensionRules(run, prefix);
-    this.tasks = new C8TaskRules(run, prefix);
-    this.events = new C8EventRules(run, prefix, this.tasks);
-    this.flows = new C8FlowRules(run, prefix);
-    const schema = new C8SchemaRules(run, prefix);
-    const processes = doc.processes();
-    const executable = processes.filter((proc) => peek<boolean>(proc, 'isExecutable') === true);
-    schema.checkExecutable(processes, executable);
-    for (const proc of executable) {
-      this.visit(proc, undefined, true);
-    }
-    this.extensions.checkCaughtMessages(executable);
-    schema.checkSchemaEventDefinitions();
-    this.events.checkFeelNames();
-    schema.checkSchema();
-    schema.checkIds();
-    if (doc.source) schema.checkSchemaText(this.schemaTextIssues(doc, doc.source));
-  }
-
-  /** Read once per text: the profile runs before and after an edit. */
-  private schemaTextIssues(doc: Doc, source: NonNullable<Doc['source']>): SchemaTextIssue[] {
-    let issues = this.textIssues.get(source);
-    if (!issues) {
-      issues = this.schemaText.issues(source.text, doc.moddle);
-      this.textIssues.set(source, issues);
-    }
-    return issues;
-  }
-
-  protected override checkElement(el: El, owner: El | undefined): ElementWalk {
-    const is = this.kit.is;
-    this.extensions.checkAttributes(el, owner);
-    this.extensions.checkExtensions(el, owner);
-    if (is(el, 'bpmn:Transaction')) {
-      this.flows.checkTransaction(el);
-      return 'stop';
-    }
-    if (is(el, 'bpmn:ComplexGateway')) this.flows.checkComplexGateway(el);
-    if (is(el, 'bpmn:Process') || (is(el, 'bpmn:SubProcess') && !is(el, 'bpmn:AdHocSubProcess'))) {
-      this.events.checkStartEvents(el);
-    }
-    if (is(el, 'bpmn:Process') || is(el, 'bpmn:SubProcess')) {
-      this.events.checkSubscriptionScopes(el);
-    }
-    if (is(el, 'bpmn:Process')) this.events.checkLinks(el);
-    if (is(el, 'bpmn:AdHocSubProcess')) this.flows.checkAdHoc(el);
-    if (is(el, 'bpmn:ServiceTask') || is(el, 'bpmn:SendTask') || is(el, 'bpmn:ScriptTask') || is(el, 'bpmn:BusinessRuleTask')) {
-      this.tasks.checkServiceLike(el);
-    }
-    if (is(el, 'bpmn:ReceiveTask')) this.events.checkMessageCatch(el);
-    if (is(el, 'bpmn:CallActivity')) this.tasks.checkCallActivity(el);
-    if (is(el, 'bpmn:UserTask')) this.tasks.checkUserTask(el);
-    if (is(el, 'bpmn:Activity')) this.tasks.checkMultiInstance(el);
-    if (is(el, 'bpmn:Event')) this.events.checkEvent(el);
-    if (is(el, 'bpmn:BoundaryEvent')) this.events.checkBoundaryHost(el);
-    if (is(el, 'bpmn:ExclusiveGateway') || is(el, 'bpmn:InclusiveGateway')) {
-      this.flows.checkBranchingGateway(el);
-    }
-    if (is(el, 'bpmn:EventBasedGateway')) this.flows.checkEventGateway(el);
-    if (is(el, 'bpmn:SequenceFlow')) this.flows.checkFlow(el);
-    return 'descend';
-  }
-}
diff --git a/src/domain/validation/profiles/EngineProfile.ts b/src/domain/validation/profiles/EngineProfile.ts
deleted file mode 100644
index c9f96dc2..00000000
--- a/src/domain/validation/profiles/EngineProfile.ts
+++ /dev/null
@@ -1,50 +0,0 @@
-import type { Doc } from '../../document/Doc.js';
-import type { El } from '../../document/utils/moddle.js';
-import type { ProfileFinding } from '../../document/Finding.js';
-import type { RuleKit } from './rule-kit.js';
-import { RuleRun } from './RuleRun.js';
-import { idOf, peek } from '../utils/element.js';
-
-export type ElementWalk = 'descend' | 'stop';
-
-/** An engine's validation profile: walks a document and hands its elements to its rule classes. */
-export abstract class EngineProfile {
-  constructor(protected readonly kit: RuleKit) {}
-
-  findings(doc: Doc, opts: { operaton?: boolean } = {}): ProfileFinding[] {
-    const run = new RuleRun(this.kit, doc);
-    this.checkDocument(run, opts);
-    return run.out;
-  }
-
-  protected abstract checkDocument(run: RuleRun, opts: { operaton?: boolean }): void;
-
-  protected abstract checkElement(el: El, owner: El | undefined, executable: boolean): ElementWalk;
-
-  protected visit(el: El, owner: El | undefined, executable: boolean): void {
-    if (this.checkElement(el, owner, executable) === 'stop') return;
-    const next = idOf(el) ? el : owner;
-    for (const child of this.bpmnChildren(el)) {
-      this.visit(child, next, executable);
-    }
-  }
-
-  /** BPMN containment children (no references, no DI, no vendor content). */
-  private bpmnChildren(el: El): El[] {
-    const descriptor = el.$descriptor as { isGeneric?: boolean; properties?: Array<{ name: string; isReference?: boolean }> };
-    if (descriptor.isGeneric) return [];
-    const out: El[] = [];
-    for (const property of descriptor.properties ?? []) {
-      if (property.isReference || property.name === 'extensionElements' || property.name === 'diagrams') {
-        continue;
-      }
-      const propertyValue = peek<unknown>(el, property.name);
-      for (const child of Array.isArray(propertyValue) ? propertyValue : [propertyValue]) {
-        if (child && typeof child === 'object' && typeof (child as El).$type === 'string' && '$descriptor' in (child as object) && this.kit.isBpmnElement(child as El) && !this.kit.isDiElement(child as El)) {
-          out.push(child as El);
-        }
-      }
-    }
-    return out;
-  }
-}
diff --git a/src/domain/validation/profiles/EngineRules.ts b/src/domain/validation/profiles/EngineRules.ts
deleted file mode 100644
index 4f3f544c..00000000
--- a/src/domain/validation/profiles/EngineRules.ts
+++ /dev/null
@@ -1,115 +0,0 @@
-import type { Doc } from '../../document/Doc.js';
-import type { DocumentNamespaces } from '../../document/vendor/DocumentNamespaces.js';
-import type { El } from '../../document/utils/moddle.js';
-import type { ProfileFinding, Severity } from '../../document/Finding.js';
-import type { RuleKit } from './rule-kit.js';
-import type { RuleRun } from './RuleRun.js';
-import { idOf, isGeneric, list, localName, peek } from '../utils/element.js';
-
-export interface ExtValue {
-  el: El;
-  uri: string | undefined;
-  local: string;
-  index: number;
-}
-
-export interface Address {
-  id: string;
-  prefix: string;
-}
-
-/**
- * The attributes without namespace prefix of one element, with the element that reports them
- * and the `set` address that removes them.
- */
-export interface UnprefixedAttributes {
-  el: El;
-  owner: El | undefined;
-  id: string | undefined;
-  /** on a diagram element: no `set` address */
-  di: boolean;
-  addr: Address | undefined;
-  keys: string[];
-}
-
-/** Base of the rule classes of an engine profile: the run they check and how they report. */
-export abstract class EngineRules {
-  protected readonly kit: RuleKit;
-  protected readonly doc: Doc;
-  protected readonly ns: DocumentNamespaces;
-  protected readonly outgoing: Map<El, El[]>;
-  protected readonly incoming: Map<El, El[]>;
-  private readonly out: ProfileFinding[];
-
-  /** `prefix`: the prefix of the engine's namespace in this file, for messages and hints */
-  constructor(
-    run: RuleRun,
-    protected readonly prefix: string,
-  ) {
-    this.kit = run.kit;
-    this.doc = run.doc;
-    this.ns = run.ns;
-    this.outgoing = run.outgoing;
-    this.incoming = run.incoming;
-    this.out = run.out;
-  }
-
-  /** Reports a finding; a nested element (event definition, loop, condition) is reported on its flow node / flow. */
-  protected push(severity: Severity, code: string, element: El | undefined, owner: El | undefined, subject: string, message: string, hint: string, related: string[] = []): void {
-    const addr = element ? this.addressOf(element, owner) : undefined;
-    const target = addr?.prefix ? addr.id : (idOf(element) ?? idOf(owner));
-    this.out.push(this.kit.makeFinding(severity, code, message, target, { hint, related, subject }));
-  }
-
-  /**
-   * The `set` / `ext` address of `el` through `owner` (`definition.`, `loop.`, `condition.`).
-   * One of several event definitions is `definition[n].`, as `definition.` would be ambiguous (E_AMBIGUOUS_NESTED).
-   */
-  protected addressOf(el: El, owner: El | undefined): Address | undefined {
-    const id = idOf(el);
-    const own = id ? { id, prefix: '' } : undefined;
-    const oid = idOf(owner);
-    if (!owner || el === owner || !oid) return own;
-    const defs = list(owner, 'eventDefinitions');
-    if (defs.includes(el)) {
-      return { id: oid, prefix: defs.length > 1 ? `definition[${defs.indexOf(el)}].` : 'definition.' };
-    }
-    if (peek<El>(owner, 'loopCharacteristics') === el) {
-      return { id: oid, prefix: 'loop.' };
-    }
-    if (peek<El>(owner, 'conditionExpression') === el) {
-      return { id: oid, prefix: 'condition.' };
-    }
-    return own;
-  }
-
-  /** The generic extension elements of a BPMN element, with their namespace. */
-  protected extensionValues(el: El | undefined): ExtValue[] {
-    const ext = peek<El>(el, 'extensionElements');
-    return list(ext, 'values').map((extension, index) => ({ el: extension, uri: isGeneric(extension) ? this.ns.uriOfElement(extension) : undefined, local: localName(extension.$type), index }));
-  }
-
-  /**
-   * The attributes without namespace prefix of every BPMN element (refused by the schema).
-   * A nested element is reported on and addressed through its flow node / flow; outside the
-   * diagram the hint `bpmn set <id> <key>=` removes it, through a nested key if needed.
-   */
-  protected unprefixedAttributes(): UnprefixedAttributes[] {
-    const found: UnprefixedAttributes[] = [];
-    for (const el of this.kit.walk(this.doc.definitions, { bpmnOnly: true })) {
-      const keys = Object.keys(el.$attrs ?? {}).filter((key) => !key.includes(':') && key !== 'xmlns');
-      if (!keys.length) continue;
-      const parent = el.$parent as El | undefined;
-      const nested = parent && idOf(parent) && this.addressOf(el, parent)?.prefix ? parent : undefined;
-      let owner: El | undefined = nested ?? el;
-      while (owner && !idOf(owner)) {
-        owner = owner.$parent as El | undefined;
-      }
-      const id = idOf(owner);
-      const di = this.kit.isDiElement(el) || (!!owner && this.kit.isDiElement(owner));
-      const addr = di ? undefined : el === owner ? (id ? { id, prefix: '' } : undefined) : owner ? this.addressOf(el, owner) : undefined;
-      found.push({ el, owner, id, di, addr, keys });
-    }
-    return found;
-  }
-}
diff --git a/src/domain/validation/profiles/FeelError.ts b/src/domain/validation/profiles/FeelError.ts
deleted file mode 100644
index 8965e72c..00000000
--- a/src/domain/validation/profiles/FeelError.ts
+++ /dev/null
@@ -1,8 +0,0 @@
-export class FeelError extends Error {
-  constructor(
-    readonly at: number,
-    message: string,
-  ) {
-    super(message);
-  }
-}
diff --git a/src/domain/validation/profiles/LinkEvents.ts b/src/domain/validation/profiles/LinkEvents.ts
deleted file mode 100644
index 05edc26f..00000000
--- a/src/domain/validation/profiles/LinkEvents.ts
+++ /dev/null
@@ -1,61 +0,0 @@
-import type { Doc } from '../../document/Doc.js';
-import type { El } from '../../document/utils/moddle.js';
-import type { RuleKit } from './rule-kit.js';
-
-export interface LinkThrow {
-  el: El;
-  name: string;
-  scope: El | undefined;
-}
-
-export interface DuplicateLinkCatch {
-  first: El;
-  el: El;
-  name: string;
-}
-
-/**
- * The link events among a process's flow nodes, as both engines resolve them: a throw jumps to
- * the catch of its name in its own (sub-)process, and catch names are unique in the process.
- */
-export class LinkEvents {
-  private readonly firstCatch = new Map<string, El>();
-  private readonly caughtIn = new Map<El | undefined, Set<string>>();
-  private readonly throws: LinkThrow[] = [];
-  private readonly duplicates: DuplicateLinkCatch[] = [];
-
-  /** `linkName`: the link name a node throws or catches, `undefined` for any other node. */
-  constructor(doc: Doc, kit: RuleKit, nodes: El[], linkName: (node: El) => string | undefined) {
-    for (const node of nodes) {
-      const name = linkName(node);
-      if (name === undefined) continue;
-      const scope = doc.scopeOf(node);
-      if (kit.is(node, 'bpmn:IntermediateCatchEvent')) {
-        const first = this.firstCatch.get(name);
-        if (first) {
-          this.duplicates.push({ first, el: node, name });
-        } else {
-          this.firstCatch.set(name, node);
-        }
-        this.caughtIn.set(scope, new Set([...(this.caughtIn.get(scope) ?? []), name]));
-      } else if (kit.is(node, 'bpmn:IntermediateThrowEvent')) {
-        this.throws.push({ el: node, name, scope });
-      }
-    }
-  }
-
-  /** The second and later catch events of a name, in document order. */
-  duplicateCatches(): DuplicateLinkCatch[] {
-    return this.duplicates;
-  }
-
-  /** The throw events whose (sub-)process has no catch event of their name. */
-  unmatchedThrows(): LinkThrow[] {
-    return this.throws.filter((linkThrow) => !this.caughtIn.get(linkThrow.scope)?.has(linkThrow.name));
-  }
-
-  /** The first catch event of a name, wherever it is in the process. */
-  catchNamed(name: string): El | undefined {
-    return this.firstCatch.get(name);
-  }
-}
diff --git a/src/domain/validation/profiles/PlatformProfiles.ts b/src/domain/validation/profiles/PlatformProfiles.ts
deleted file mode 100644
index e9558c84..00000000
--- a/src/domain/validation/profiles/PlatformProfiles.ts
+++ /dev/null
@@ -1,108 +0,0 @@
-import type { Doc } from '../../document/Doc.js';
-import { BpmnError } from '../../document/BpmnError.js';
-import { ioError, usageError } from '../../document/utils/errors.js';
-import { PlatformDetection, type Platform, type PlatformChoice, type PlatformInfo } from '../../document/vendor/PlatformDetection.js';
-import { SEVERITIES } from '../../document/utils/finding.js';
-import type { ProfileFinding, Severity } from '../../document/Finding.js';
-import type { EngineProfile } from './EngineProfile.js';
-import { RULE_KIT } from './rule-kit.js';
-
-export interface ProfileReport extends PlatformInfo {
-  findings: ProfileFinding[];
-}
-
-export interface PlatformSummary extends PlatformInfo {
-  /** all findings, also the ones a mutation did not introduce */
-  counts: Record<Severity, number>;
-  added?: ProfileFinding[];
-  resolved?: ProfileFinding[];
-}
-
-type EnginePlatform = Exclude<Platform, 'none'>;
-
-const ENGINE_NAMES: Record<EnginePlatform, string> = { c7: 'Camunda 7', c8: 'Camunda 8' };
-
-/** The rules get RULE_KIT instead of importing the core, so their chunk imports nothing. */
-const LOADERS: Record<EnginePlatform, () => Promise<EngineProfile>> = {
-  c7: async () => {
-    const { C7Profile } = await import('./C7Profile.js');
-    return new C7Profile(RULE_KIT);
-  },
-  c8: async () => {
-    const { C8Profile } = await import('./C8Profile.js');
-    return new C8Profile(RULE_KIT);
-  },
-};
-
-/**
- * Engine-specific checks on top of the structural validation. Each platform's rules load on
- * demand as a chunk of their own; run stays synchronous and throws E_PROFILE_NOT_LOADED until
- * they are loaded. Mutations report only the findings the change introduced (delta).
- */
-class PlatformProfiles {
-  private readonly rules: Partial<Record<EnginePlatform, EngineProfile>> = {};
-  /**
-   * A failed load is forgotten, so a later call imports the chunk again; a browser
-   * may keep the failed fetch until the page reloads, and the specifier cannot vary.
-   */
-  private readonly loading: Partial<Record<EnginePlatform, Promise<void>>> = {};
-
-  load(platform: Platform): Promise<void> {
-    if (platform === 'none') return Promise.resolve();
-    if (!this.isEnginePlatform(platform)) {
-      return Promise.reject(usageError(`Unknown platform "${String(platform)}": loadProfile takes 'c7', 'c8' or 'none'`, { hint: 'Pass the platform of a document (detectPlatform(doc).platform) or one of c7, c8.' }));
-    }
-    const loaded = this.loading[platform];
-    if (loaded) return loaded;
-    const load = LOADERS[platform]().then(
-      (rules) => {
-        this.rules[platform] = rules;
-      },
-      (err: unknown) => {
-        delete this.loading[platform];
-        throw ioError('E_PROFILE_LOAD', `The ${ENGINE_NAMES[platform]} profile rules could not be loaded: ${err instanceof Error ? err.message : String(err)}`, {
-          platform,
-          hint: 'They are a chunk of their own in a browser bundle: check that it is served next to the entry chunk (base URL, network, content security policy); nothing was written. A later call imports the chunk again (in Node that loads it), but a browser may keep the failed fetch until the page reloads (Chrome does): reload the page there.',
-        });
-      },
-    );
-    this.loading[platform] = load;
-    return load;
-  }
-
-  async loadAll(platforms: readonly EnginePlatform[] = ['c7', 'c8']): Promise<void> {
-    await Promise.all(platforms.map((platform) => this.load(platform)));
-  }
-
-  async ensure(doc: Doc, choice: PlatformChoice = 'auto'): Promise<void> {
-    if (this.rules.c7 && this.rules.c8) return;
-    await this.load(PlatformDetection.of(doc).resolve(choice).platform);
-  }
-
-  run(doc: Doc, choice: PlatformChoice = 'auto'): ProfileReport {
-    const info = PlatformDetection.of(doc).resolve(choice);
-    if (info.platform === 'none') return { ...info, findings: [] };
-    const rules = this.rules[info.platform];
-    if (!rules) {
-      throw new BpmnError('E_PROFILE_NOT_LOADED', `The ${ENGINE_NAMES[info.platform]} profile rules are not loaded (they load on demand)`, 'usage', {
-        platform: info.platform,
-        hint: `await loadProfile('${info.platform}') (or loadProfiles()) before runProfile / validateDoc(doc, { platform }); applyToXml, validateXml, mutateDoc and checkDoc load them themselves.`,
-      });
-    }
-    return { ...info, findings: rules.findings(doc, { operaton: info.operaton === true }) };
-  }
-
-  summarize(report: ProfileReport): PlatformSummary {
-    const counts = Object.fromEntries(SEVERITIES.map((severity) => [severity, 0])) as Record<Severity, number>;
-    for (const finding of report.findings) {
-      counts[finding.severity]++;
-    }
-    return { platform: report.platform, source: report.source, detail: report.detail, ...(report.operaton ? { operaton: true } : {}), counts };
-  }
-
-  private isEnginePlatform(platform: string): platform is EnginePlatform {
-    return Object.hasOwn(LOADERS, platform);
-  }
-}
-
-export const PLATFORM_PROFILES = new PlatformProfiles();
diff --git a/src/domain/validation/profiles/RuleRun.ts b/src/domain/validation/profiles/RuleRun.ts
deleted file mode 100644
index c613677d..00000000
--- a/src/domain/validation/profiles/RuleRun.ts
+++ /dev/null
@@ -1,33 +0,0 @@
-import type { Doc } from '../../document/Doc.js';
-import type { DocumentNamespaces } from '../../document/vendor/DocumentNamespaces.js';
-import type { El } from '../../document/utils/moddle.js';
-import type { ProfileFinding } from '../../document/Finding.js';
-import type { RuleKit } from './rule-kit.js';
-import { peek } from '../utils/element.js';
-
-/** One profile run over a document: what its rule classes read, and the findings they collect. */
-export class RuleRun {
-  readonly ns: DocumentNamespaces;
-  readonly out: ProfileFinding[] = [];
-  /** sequence flows by source / target, from sourceRef / targetRef (mirror lists are optional) */
-  readonly outgoing = new Map<El, El[]>();
-  readonly incoming = new Map<El, El[]>();
-
-  constructor(
-    readonly kit: RuleKit,
-    readonly doc: Doc,
-  ) {
-    this.ns = new kit.DocumentNamespaces(doc);
-    for (const flow of kit.walk(doc.definitions, { bpmnOnly: true })) {
-      if (!kit.is(flow, 'bpmn:SequenceFlow')) continue;
-      const source = peek<El>(flow, 'sourceRef');
-      const target = peek<El>(flow, 'targetRef');
-      if (source) {
-        this.outgoing.set(source, [...(this.outgoing.get(source) ?? []), flow]);
-      }
-      if (target) {
-        this.incoming.set(target, [...(this.incoming.get(target) ?? []), flow]);
-      }
-    }
-  }
-}
diff --git a/src/domain/validation/profiles/SchemaText.ts b/src/domain/validation/profiles/SchemaText.ts
deleted file mode 100644
index 4b7bf290..00000000
--- a/src/domain/validation/profiles/SchemaText.ts
+++ /dev/null
@@ -1,152 +0,0 @@
-import type { BpmnModdle } from 'bpmn-moddle';
-import type { XElement } from '../../document/utils/text-reader.js';
-import { BpmnSchema, BPMNDI_NS } from './BpmnSchema.js';
-import type { RuleKit } from './rule-kit.js';
-
-const OPAQUE = new Set(['extensionElements', 'documentation']);
-
-const IDREF_ATTRS: Array<[string, string[]]> = [
-  ['bpmn:Activity', ['default']],
-  ['bpmn:ExclusiveGateway', ['default']],
-  ['bpmn:InclusiveGateway', ['default']],
-  ['bpmn:ComplexGateway', ['default']],
-  ['bpmn:DataObjectReference', ['dataObjectRef']],
-  ['bpmn:InputOutputBinding', ['inputDataRef', 'outputDataRef']],
-];
-
-const IDREF_CHILDREN: Array<[string, string[]]> = [
-  ['bpmn:Lane', ['flowNodeRef']],
-  ['bpmn:DataAssociation', ['sourceRef', 'targetRef']],
-  ['bpmn:InputSet', ['dataInputRefs', 'optionalInputRefs', 'whileExecutingInputRefs', 'outputSetRefs']],
-  ['bpmn:OutputSet', ['dataOutputRefs', 'optionalOutputRefs', 'whileExecutingOutputRefs', 'inputSetRefs']],
-];
-
-const XSD_BOOLEAN = /^[ \t\r\n]*(?:true|false|1|0)[ \t\r\n]*$/;
-
-/** XML 1.0 fifth edition: what the schema's xsd:ID allows. */
-const NCNAME_START = 'A-Z_a-z\\u00C0-\\u00D6\\u00D8-\\u00F6\\u00F8-\\u02FF\\u0370-\\u037D\\u037F-\\u1FFF\\u200C-\\u200D\\u2070-\\u218F\\u2C00-\\u2FEF\\u3001-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFFD\\u{10000}-\\u{EFFFF}';
-export const NCNAME = new RegExp(`^[${NCNAME_START}][${NCNAME_START}\\-.0-9\\u00B7\\u0300-\\u036F\\u203F-\\u2040]*$`, 'u');
-
-export interface SchemaTextIssue {
-  kind: 'order' | 'idref' | 'id' | 'boolean';
-  /** the nearest element with an id, as written */
-  owner: string | undefined;
-  element: string;
-  /** order: the child that comes too late */
-  child?: string;
-  before?: string;
-  ref?: string;
-  value?: string;
-  attribute?: boolean;
-}
-
-/**
- * BPMN schema rules the model cannot see, read from a file's text: child order, dangling
- * IDREFs, ids that are no NCName, bad xsd:booleans. bpmn-moddle hides them on import,
- * but an engine that validates against the XSD refuses them (Camunda 8.9, engine-checked).
- */
-export class SchemaText {
-  constructor(private readonly kit: RuleKit) {}
-
-  /**
-   * [] when the text cannot be read: the model is then all there is. An xsd:boolean attribute
-   * with another value is an issue, as bpmn-moddle reads it as false; on a diagram element it is
-   * the issue of its BPMN element.
-   */
-  issues(xml: string, moddle: BpmnModdle): SchemaTextIssue[] {
-    let root: XElement;
-    try {
-      root = this.kit.readXmlText(xml).root;
-    } catch (err) {
-      if (err instanceof this.kit.XmlTextError) return [];
-      throw err;
-    }
-    const schema = new BpmnSchema(moddle, this.kit.BPMN_NS);
-    const ids = new Set<string>();
-    const out: SchemaTextIssue[] = [];
-    const collect = (el: XElement, owner: string | undefined): void => {
-      let here = owner;
-      if (el.uri.startsWith('http://www.omg.org/spec/')) {
-        const id = this.attr(el, 'id');
-        if (id !== undefined) {
-          ids.add(id.trim());
-          if (!NCNAME.test(id.trim())) {
-            out.push({ kind: 'id', owner: id.trim(), element: el.local, value: id.trim() });
-          }
-          here = id.trim();
-        }
-        const type = schema.typeOf(el.local, el.uri, undefined);
-        const booleans = type ? schema.booleanAttrs(type) : undefined;
-        for (const attribute of booleans?.size ? el.attrs : []) {
-          if (!booleans!.has(attribute.name)) continue;
-          const decoded = this.kit.decodeXml(attribute.raw);
-          if (!XSD_BOOLEAN.test(decoded)) {
-            out.push({ kind: 'boolean', owner: el.uri === this.kit.BPMN_NS ? here : (this.attr(el, 'bpmnElement')?.trim() ?? owner), element: el.local, ref: attribute.name, value: decoded, attribute: true });
-          }
-        }
-      }
-      for (const child of this.kit.elementChildren(el)) {
-        collect(child, here);
-      }
-    };
-    collect(root, undefined);
-
-    const visit = (el: XElement, type: string, owner: string | undefined): void => {
-      const here = this.attr(el, 'id') ?? owner;
-      for (const [base, names] of IDREF_ATTRS) {
-        if (!schema.isA(type, base)) continue;
-        for (const attrName of names) {
-          const idref = this.attr(el, attrName)?.trim();
-          if (idref && !ids.has(idref)) {
-            out.push({ kind: 'idref', owner: here, element: el.local, ref: attrName, value: idref, attribute: true });
-          }
-        }
-      }
-      const kids = this.kit.elementChildren(el);
-      for (const [base, names] of IDREF_CHILDREN) {
-        if (!schema.isA(type, base)) continue;
-        for (const kid of kids) {
-          if (kid.uri !== this.kit.BPMN_NS || !names.includes(kid.local)) continue;
-          const idref = this.text(xml, kid);
-          if (idref && !ids.has(idref)) {
-            out.push({ kind: 'idref', owner: here, element: el.local, ref: kid.local, value: idref });
-          }
-        }
-      }
-      const slots = schema.slotsOf(type);
-      let last = -1;
-      let lastName = '';
-      for (const kid of kids) {
-        if (kid.uri !== this.kit.BPMN_NS && kid.uri !== BPMNDI_NS) continue;
-        const slot = slots.get(kid.local);
-        if (slot === undefined || slot < 0) continue;
-        if (slot < last) {
-          out.push({ kind: 'order', owner: here, element: el.local, child: kid.local, before: lastName });
-          break;
-        }
-        if (slot > last) {
-          last = slot;
-          lastName = kid.local;
-        }
-      }
-      for (const kid of kids) {
-        if (kid.uri !== this.kit.BPMN_NS || OPAQUE.has(kid.local)) continue;
-        const kidType = schema.typeOf(kid.local, kid.uri, type);
-        if (kidType) visit(kid, kidType, here);
-      }
-    };
-    if (root.uri === this.kit.BPMN_NS && root.local === 'definitions') {
-      visit(root, 'bpmn:Definitions', undefined);
-    }
-    return out;
-  }
-
-  private attr(el: XElement, name: string): string | undefined {
-    const attribute = el.attrs.find((candidate) => candidate.name === name);
-    return attribute ? this.kit.decodeXml(attribute.raw) : undefined;
-  }
-
-  private text(doc: string, el: XElement): string {
-    return this.kit.decodeXml(doc.slice(el.tagEnd, el.closeStart)).trim();
-  }
-}
diff --git a/src/domain/validation/profiles/c7/C7DescriptorNames.ts b/src/domain/validation/profiles/c7/C7DescriptorNames.ts
deleted file mode 100644
index fbe1f55b..00000000
--- a/src/domain/validation/profiles/c7/C7DescriptorNames.ts
+++ /dev/null
@@ -1,52 +0,0 @@
-import type { CamundaElementType } from '../../../document/vendor/CamundaDescriptor.js';
-import type { RuleKit } from '../rule-kit.js';
-
-/** The names the camunda descriptor defines, read once per profile and kept across runs. */
-export class C7DescriptorNames {
-  private probe: ReturnType<RuleKit['createModdle']> | undefined;
-  private readonly bpmnAttrNames = new Map<string, Set<string>>();
-  private typeNameCache: string[] | undefined;
-
-  constructor(private readonly kit: RuleKit) {}
-
-  /** Attribute names of a camunda type: its own, its camunda and its BPMN super types' (none for an unknown BPMN type). */
-  attrNames(elementType: CamundaElementType): Set<string> {
-    const names = new Set(elementType.properties.filter((property) => property.isAttr || property.isReference).map((property) => property.name));
-    for (const sup of elementType.bpmnSuperTypes) {
-      let known = this.bpmnAttrNames.get(sup);
-      if (!known) {
-        this.probe ??= this.kit.createModdle();
-        known = new Set<string>();
-        try {
-          const descriptor = this.probe.getElementDescriptor(this.probe.getType(sup)) as { properties?: Array<{ name: string; isAttr?: boolean; isReference?: boolean; isMany?: boolean }> };
-          for (const property of descriptor.properties ?? []) {
-            if (property.isAttr || (property.isReference && !property.isMany)) {
-              known.add(property.name);
-            }
-          }
-        } catch {}
-        this.bpmnAttrNames.set(sup, known);
-      }
-      for (const name of known) {
-        names.add(name);
-      }
-    }
-    return names;
-  }
-
-  /** Child elements a camunda type takes as plain text (connectorId, expression, string). */
-  textChildNames(elementType: CamundaElementType): Set<string> {
-    return new Set(elementType.properties.filter((property) => !property.isAttr && !property.isBody && !property.type.includes(':')).map((property) => property.name));
-  }
-
-  /** The top-level extension element types a did-you-mean may suggest. */
-  typeNames(): string[] {
-    if (this.typeNameCache) return this.typeNameCache;
-    const names = new Set<string>();
-    for (const typeName of ['inputOutput', 'inputParameter', 'outputParameter', 'in', 'out', 'field', 'connector', 'properties', 'property', 'formData', 'formField', 'formProperty', 'taskListener', 'executionListener', 'failedJobRetryTimeCycle', 'errorEventDefinition', 'potentialStarter', 'list', 'map', 'entry', 'value', 'script', 'validation', 'constraint']) {
-      if (this.kit.camunda.type(typeName)) names.add(typeName);
-    }
-    this.typeNameCache = [...names];
-    return this.typeNameCache;
-  }
-}
diff --git a/src/domain/validation/profiles/c7/C7EventRules.ts b/src/domain/validation/profiles/c7/C7EventRules.ts
deleted file mode 100644
index 7a29f728..00000000
--- a/src/domain/validation/profiles/c7/C7EventRules.ts
+++ /dev/null
@@ -1,417 +0,0 @@
-import type { El } from '../../../document/utils/moddle.js';
-import { LinkEvents } from '../LinkEvents.js';
-import type { RuleRun } from '../RuleRun.js';
-import { idOf, list, nameOf, peek, TIMER_ELEMENTS, triggerName } from '../../utils/element.js';
-import { sh } from '../../utils/hint.js';
-import { nonEmpty } from '../../utils/value.js';
-import type { C7ImplementationRules } from './C7ImplementationRules.js';
-import { C7Rules } from './C7Rules.js';
-
-const VARIABLE_EVENTS = ['create', 'update', 'delete'];
-
-/** Events and their triggers: event definitions, messages and signals, links, start events. */
-export class C7EventRules extends C7Rules {
-  constructor(
-    run: RuleRun,
-    prefix: string,
-    private readonly implementation: C7ImplementationRules,
-  ) {
-    super(run, prefix);
-  }
-
-  /**
-   * An event with several event definitions: the engines act on one of them and ignore the others
-   * (a message + timer catch event creates only the timer job). It deploys.
-   */
-  private checkMultipleDefinitions(el: El): void {
-    const defs = list(el, 'eventDefinitions');
-    if (defs.length < 2) return;
-    const id = idOf(el)!;
-    const kinds = defs.map(triggerName);
-    const acting = this.actingDefinition(el);
-    const what = acting
-      ? `the engines act on the ${triggerName(acting)} only and ignore the ${kinds.filter((_kind, index) => defs[index] !== acting).join(' and ')}`
-      : 'the engines act on one of them only and ignore the others';
-    const keep = acting ? triggerName(acting) : '<trigger>';
-    this.push('runtime', 'W_C7_MULTIPLE_EVENT_DEFINITIONS', el, undefined, 'definitions', `${this.describe(el, undefined)} has ${defs.length} event definitions (${kinds.join(', ')}); ${what}`, `Keep one: \`bpmn set <file> ${id} trigger=${keep}\` (keeps that definition, drops the others), and model each other trigger as its own event (behind an event-based gateway, or another boundary / start event). One definition is edited with \`bpmn set <file> ${id} 'definition[<n>].<key>=<value>'\`.`);
-  }
-
-  /** Checks an event; of several definitions only the one the engines act on is checked, as they parse only that one. */
-  checkEvent(el: El): void {
-    this.checkCompensationHost(el);
-    this.checkMultipleDefinitions(el);
-    for (const def of this.actedOn(el)) {
-      this.checkDefinition(el, def);
-    }
-  }
-
-  private checkCompensationHost(el: El): void {
-    const host = this.kit.is(el, 'bpmn:BoundaryEvent') ? peek<El>(el, 'attachedToRef') : undefined;
-    if (!host || peek<boolean>(host, 'isForCompensation') !== true) return;
-    const id = idOf(el)!;
-    this.push('deploy', 'W_C7_DEPLOY_BOUNDARY_HOST', el, undefined, 'compensationHost', `Boundary event ${id} is attached to the compensation handler ${idOf(host)}; the engines refuse boundary events on compensation handlers`, `Remove it: \`bpmn remove <file> ${id}\` (or attach it to a normal activity: \`bpmn move <file> ${id} --on <activityId>\`).`, [idOf(host)!]);
-  }
-
-  private checkDefinition(el: El, def: El): void {
-    if (this.kit.is(def, 'bpmn:MessageEventDefinition')) {
-      this.checkMessageDefinition(el, def);
-    } else if (this.kit.is(def, 'bpmn:SignalEventDefinition')) {
-      this.checkSignalDefinition(el, def);
-    } else if (this.kit.is(def, 'bpmn:ErrorEventDefinition') && this.kit.is(el, 'bpmn:EndEvent')) {
-      this.checkErrorDefinition(el, def);
-    } else if (this.kit.is(def, 'bpmn:EscalationEventDefinition')) {
-      this.checkEscalationDefinition(el, def);
-    } else if (this.kit.is(def, 'bpmn:CompensateEventDefinition') && this.isThrowing(el)) {
-      this.checkCompensationRef(el, def);
-    } else if (this.kit.is(def, 'bpmn:TimerEventDefinition')) {
-      this.checkTimerDefinition(el, def);
-    } else if (this.kit.is(def, 'bpmn:ConditionalEventDefinition')) {
-      this.checkConditionalDefinition(el, def);
-    }
-  }
-
-  private isCatching(el: El): boolean {
-    return this.kit.is(el, 'bpmn:StartEvent') || this.kit.is(el, 'bpmn:IntermediateCatchEvent') || this.kit.is(el, 'bpmn:BoundaryEvent');
-  }
-
-  private isThrowing(el: El): boolean {
-    return this.kit.is(el, 'bpmn:IntermediateThrowEvent') || this.kit.is(el, 'bpmn:EndEvent');
-  }
-
-  private checkMessageDefinition(el: El, def: El): void {
-    if (this.isThrowing(el)) {
-      this.implementation.checkImplementation(def, el, this.describe(el, undefined), { event: el });
-      return;
-    }
-    if (!this.isCatching(el)) return;
-    const id = idOf(el)!;
-    const label = this.describe(el, undefined);
-    const msg = peek<El>(def, 'messageRef');
-    if (!msg) {
-      this.push('deploy', 'W_C7_DEPLOY_MESSAGE', el, undefined, 'messageRef', `${label} has no message; the engines refuse the file`, `\`bpmn set <file> ${id} message=<MessageName>\` (creates the bpmn:Message).`);
-    } else if (!nameOf(msg)) {
-      this.push('deploy', 'W_C7_DEPLOY_MESSAGE', el, undefined, 'messageName', `Message ${idOf(msg)} of ${label} has no name; the engines refuse the file`, `\`bpmn set <file> ${idOf(msg)} name=<MessageName>\`.`, [idOf(msg)!]);
-    }
-  }
-
-  private checkSignalDefinition(el: El, def: El): void {
-    const id = idOf(el)!;
-    const label = this.describe(el, undefined);
-    const sig = peek<El>(def, 'signalRef');
-    if (!sig) {
-      this.push('deploy', 'W_C7_DEPLOY_SIGNAL', el, undefined, 'signalRef', `${label} has no signal; the engines refuse the file`, `\`bpmn set <file> ${id} signal=<SignalName>\`.`);
-    } else if (!nameOf(sig)) {
-      this.push('deploy', 'W_C7_DEPLOY_SIGNAL', el, undefined, 'signalName', `Signal ${idOf(sig)} of ${label} has no name; the engines refuse the file`, `\`bpmn set <file> ${idOf(sig)} name=<SignalName>\`.`, [idOf(sig)!]);
-    }
-  }
-
-  private checkErrorDefinition(el: El, def: El): void {
-    const id = idOf(el)!;
-    const label = this.describe(el, undefined);
-    const err = peek<El>(def, 'errorRef');
-    if (!err) {
-      this.push('deploy', 'W_C7_DEPLOY_ERROR', el, undefined, 'errorRef', `${label} throws no error (no errorRef); the engines refuse the file`, `\`bpmn set <file> ${id} error=<ErrorName> errorCode=<CODE>\`.`);
-    } else if (!nonEmpty(peek<string>(err, 'errorCode'))) {
-      this.push('deploy', 'W_C7_DEPLOY_ERROR', el, undefined, 'errorCode', `Error ${idOf(err)} thrown by ${label} has no errorCode; the engines refuse the file`, `\`bpmn set <file> ${id} errorCode=<CODE>\`.`, [idOf(err)!]);
-    }
-  }
-
-  private checkEscalationDefinition(el: El, def: El): void {
-    if (this.isThrowing(el)) {
-      this.checkThrownEscalation(el, def);
-    } else if (this.kit.is(el, 'bpmn:BoundaryEvent')) {
-      this.checkEscalationHost(el);
-    }
-  }
-
-  private checkThrownEscalation(el: El, def: El): void {
-    const id = idOf(el)!;
-    const label = this.describe(el, undefined);
-    const esc = peek<El>(def, 'escalationRef');
-    if (!esc) {
-      this.push('deploy', 'W_C7_DEPLOY_ESCALATION', el, undefined, 'escalationRef', `${label} throws no escalation (no escalationRef); the engines refuse the file`, `\`bpmn set <file> ${id} escalation=<Name> escalationCode=<CODE>\`.`);
-    } else if (!nonEmpty(peek<string>(esc, 'escalationCode'))) {
-      this.push('deploy', 'W_C7_DEPLOY_ESCALATION', el, undefined, 'escalationCode', `Escalation ${idOf(esc)} thrown by ${label} has no escalationCode; the engines refuse the file`, `\`bpmn set <file> ${id} escalationCode=<CODE>\`.`, [idOf(esc)!]);
-    }
-  }
-
-  private checkEscalationHost(el: El): void {
-    const host = peek<El>(el, 'attachedToRef');
-    if (!host || this.kit.is(host, 'bpmn:SubProcess') || this.kit.is(host, 'bpmn:CallActivity') || this.kit.is(host, 'bpmn:UserTask')) {
-      return;
-    }
-    const id = idOf(el)!;
-    this.push('deploy', 'W_C7_DEPLOY_ESCALATION', el, undefined, 'escalationHost', `Escalation boundary event ${id} is attached to ${this.describe(host, undefined)}; the engines allow it only on sub-processes, call activities and user tasks and refuse the file`, `Attach it elsewhere (\`bpmn move <file> ${id} --on <subProcessId>\`) or remove it: \`bpmn remove <file> ${id}\`.`, [idOf(host)!]);
-  }
-
-  private checkTimerDefinition(el: El, def: El): void {
-    if (TIMER_ELEMENTS.some((timerKind) => peek<El>(def, timerKind))) return;
-    this.push('deploy', 'W_C7_DEPLOY_EVENT_DEFINITION', el, undefined, 'timer', `Timer of ${this.describe(el, undefined)} has no date, cycle or duration; the engines refuse the file`, `\`bpmn set <file> ${idOf(el)} timer=PT1H\` (or R/PT1H, or a date).`);
-  }
-
-  /** Checks the condition of a conditional definition; a missing condition element is left to the schema error. */
-  private checkConditionalDefinition(el: El, def: El): void {
-    const id = idOf(el)!;
-    const cond = peek<El>(def, 'condition');
-    if (cond && this.emptyCondition(cond)) {
-      this.push('runtime', 'W_C7_EMPTY_CONDITION', el, undefined, 'emptyCondition', `Conditional event ${id} has an empty condition (no expression and no ${this.prefix}:resource): it deploys, but evaluating it fails when the process runs`, `\`bpmn set <file> ${id} ${sh('when=${expression}')}\` (or a script: \`bpmn set <file> ${id} condition.${this.prefix}:resource=deployment://<script>.groovy condition.language=groovy\`).`);
-    }
-    this.checkVariableEvents(el, def);
-  }
-
-  private checkVariableEvents(el: El, def: El): void {
-    const events = this.c7(def, 'variableEvents');
-    if (events === undefined) return;
-    const bad = events.split(',').map((eventName) => eventName.trim()).filter((eventName) => eventName && !VARIABLE_EVENTS.includes(eventName));
-    if (!bad.length) return;
-    this.push('runtime', 'W_C7_BAD_VALUE', def, el, 'attr:variableEvents', `${this.prefix}:variableEvents="${events}" of ${this.describe(el, undefined)} lists ${bad.join(', ')}; only ${VARIABLE_EVENTS.join(', ')} trigger the condition`, `\`bpmn set <file> ${idOf(el)} ${sh(`${this.addressOf(def, el)?.prefix ?? 'definition.'}${this.prefix}:variableEvents=create, update`)}\`.`);
-  }
-
-  /**
-   * The activities a compensation throw event may name: those of its own (sub-)process, for an
-   * event sub-process also those of its parent scope.
-   */
-  private checkCompensationRef(el: El, def: El): void {
-    const ref = peek<El>(def, 'activityRef');
-    if (!ref) return;
-    const scope = this.doc.scopeOf(el);
-    if (!scope) return;
-    const allowed: Array<El | undefined> = [scope];
-    if (this.kit.isEventSubProcess(scope)) allowed.push(this.doc.scopeOf(scope));
-    if (this.kit.is(ref, 'bpmn:FlowNode') && allowed.includes(this.doc.scopeOf(ref))) {
-      return;
-    }
-    const id = idOf(el)!;
-    const sid = idOf(scope) ?? '<scopeId>';
-    const candidates = this.doc
-      .flowNodes(scope)
-      .filter((node) => this.kit.is(node, 'bpmn:Activity') && !this.kit.isEventSubProcess(node))
-      .map(idOf)
-      .filter((candidateId): candidateId is string => !!candidateId)
-      .slice(0, 5);
-    const what = this.kit.is(ref, 'bpmn:FlowNode') ? `${this.describe(ref, undefined)}, which is not in ${sid}` : `${idOf(ref)}, which is not a flow node`;
-    const key = `${this.addressOf(def, el)?.prefix ?? 'definition.'}activityRef`;
-    this.push('deploy', 'W_C7_DEPLOY_EVENT_DEFINITION', el, undefined, 'activityRef', `Compensation event ${id} names activityRef ${what}; the engines compensate only activities of the throw event's own (sub-)process and refuse the file`, `\`bpmn set <file> ${id} ${sh(`${key}=<activityId>`)}\`${candidates.length ? ` (in ${sid}: ${candidates.join(', ')})` : ''}, or compensate the whole scope: \`bpmn set <file> ${id} ${sh(`${key}=`)}\`.`, idOf(ref) ? [idOf(ref)!] : []);
-  }
-
-  checkReceiveTask(el: El): void {
-    const msg = peek<El>(el, 'messageRef');
-    if (msg && !nameOf(msg)) {
-      this.push('deploy', 'W_C7_DEPLOY_MESSAGE', el, undefined, 'messageName', `Message ${idOf(msg)} of receive task ${idOf(el)} has no name; the engines refuse the file`, `\`bpmn set <file> ${idOf(msg)} name=<MessageName>\`.`, [idOf(msg)!]);
-    }
-  }
-
-  /**
-   * Every flow node of a scope and of its nested sub-processes, except the content of an ad-hoc
-   * sub-process, which the engines skip.
-   */
-  private allFlowNodes(scope: El): El[] {
-    const out: El[] = [];
-    for (const node of this.doc.flowNodes(scope)) {
-      out.push(node);
-      if (this.kit.is(node, 'bpmn:SubProcess') && !this.kit.is(node, 'bpmn:AdHocSubProcess')) {
-        out.push(...this.allFlowNodes(node));
-      }
-    }
-    return out;
-  }
-
-  /**
-   * Message and signal subscriptions that share a name in one engine scope: the start events of a
-   * process; the event sub-process starts of a scope with the boundary events on it; the boundary
-   * events of one activity with its own receive-task message (multi-instance: separate scopes).
-   */
-  checkSubscriptions(proc: El): void {
-    const groups = new Map<string, El[]>();
-    const add = (kind: 'message' | 'signal', scope: string, name: string | undefined, el: El): void => {
-      if (!name) return;
-      const key = `${kind}\u0000${scope}\u0000${name}`;
-      groups.set(key, [...(groups.get(key) ?? []), el]);
-    };
-    for (const node of this.allFlowNodes(proc)) {
-      let scope: string | undefined;
-      if (this.kit.is(node, 'bpmn:StartEvent')) {
-        const parent = this.doc.scopeOf(node);
-        if (parent && this.kit.is(parent, 'bpmn:Process')) {
-          scope = `start:${idOf(parent)}`;
-        } else if (parent && this.kit.isEventSubProcess(parent)) {
-          scope = `scope:${idOf(this.doc.scopeOf(parent))}`;
-        }
-      } else if (this.kit.is(node, 'bpmn:BoundaryEvent')) {
-        const host = peek<El>(node, 'attachedToRef');
-        if (host) {
-          scope = `${this.isMultiInstance(host) ? 'body' : 'scope'}:${idOf(host)}`;
-        }
-      } else if (this.kit.is(node, 'bpmn:ReceiveTask')) {
-        add('message', `scope:${idOf(node)}`, nameOf(peek<El>(node, 'messageRef')), node);
-      }
-      if (!scope) continue;
-      add('message', scope, nameOf(peek<El>(this.definitionOf(node, 'bpmn:MessageEventDefinition'), 'messageRef')), node);
-      add('signal', scope, nameOf(peek<El>(this.definitionOf(node, 'bpmn:SignalEventDefinition'), 'signalRef')), node);
-    }
-    for (const [key, els] of groups) {
-      if (els.length < 2) continue;
-      const [kind, , name] = key.split('\u0000') as ['message' | 'signal', string, string];
-      const [first, ...rest] = els;
-      for (const el of rest) {
-        const code = kind === 'message' ? 'W_C7_DEPLOY_MESSAGE' : 'W_C7_DEPLOY_SIGNAL';
-        this.push('deploy', code, el, undefined, kind === 'message' ? `dupMessage:${name}` : `dupSignalEvent:${name}`, `${this.describe(el, undefined)} waits for ${kind} "${name}" like ${idOf(first)} in the same scope; the engines refuse two ${kind} subscriptions with one name`, `Use another ${kind}: \`bpmn set <file> ${idOf(el)} ${kind}=<OtherName>\`.`, [idOf(first)!]);
-      }
-    }
-  }
-
-  /**
-   * Link events: catch names are unique in the whole process (sub-processes included); a throw
-   * event reached by a sequence flow needs a catch event of its name in the same (sub-)process.
-   * A definition without name is skipped: that is a schema error.
-   */
-  checkLinks(proc: El): void {
-    const links = new LinkEvents(this.doc, this.kit, this.allFlowNodes(proc), (node) => {
-      const name = peek<string>(this.definitionOf(node, 'bpmn:LinkEventDefinition'), 'name');
-      return name === null ? undefined : name;
-    });
-    for (const { first, el, name } of links.duplicateCatches()) {
-      const id = idOf(el)!;
-      this.push('deploy', 'W_C7_DEPLOY_LINK', el, undefined, `link:dup:${name}`, `Link catch events ${idOf(first)} and ${id} are both named "${name}"; the engines refuse two link catch events with one name in a process (sub-processes included)`, `\`bpmn set <file> ${id} link=<OtherName>\` (and its throw events too).`, [idOf(first)!]);
-    }
-    for (const { el, name, scope } of links.unmatchedThrows()) {
-      if (!(this.incoming.get(el) ?? []).length) continue;
-      const id = idOf(el)!;
-      const sid = idOf(scope) ?? '<scopeId>';
-      const elsewhere = links.catchNamed(name);
-      this.push('deploy', 'W_C7_DEPLOY_LINK', el, undefined, `link:target:${name}`, `Link throw event ${id} jumps to "${name}", but ${elsewhere ? `the catch event of that name (${idOf(elsewhere)}) is in another scope` : 'no link catch event has that name'}; the engines resolve links within one (sub-)process (${sid}) and refuse the file`, `Add the catching side in ${sid}: \`bpmn add <file> intermediateCatchEvent:link "<Name>" --in ${sid} --link ${sh(name)}\` and continue from it, or point the throw at an existing catch: \`bpmn set <file> ${id} link=<Name>\`.`, elsewhere ? [idOf(elsewhere)!] : []);
-    }
-  }
-
-  /** Duplicate root signal names (the engines refuse the file even when one is unused). */
-  checkSignalNames(): void {
-    const seen = new Map<string, El>();
-    for (const sig of this.doc.rootElementsOfType('bpmn:Signal')) {
-      const name = nameOf(sig);
-      if (!name) continue;
-      const first = seen.get(name);
-      if (first) {
-        this.push('deploy', 'W_C7_DEPLOY_SIGNAL', sig, undefined, `dupSignal:${name}`, `Signals ${idOf(first)} and ${idOf(sig)} are both named "${name}"; the engines refuse duplicate signal names`, `\`bpmn set <file> ${idOf(sig)} name=<OtherName>\` (or point its events at ${idOf(first)} and remove it).`, [idOf(first)!]);
-      } else {
-        seen.set(name, sig);
-      }
-    }
-  }
-
-  /**
-   * Start events of a process or sub-process: each needs one, also an empty one; a transaction
-   * without one deploys and fails when reached (an event sub-process: E_EVENT_SUBPROCESS_NO_START).
-   * A process allows one none or timer start event, a sub-process one start event at all.
-   */
-  checkStartEvents(scope: El): void {
-    const id = idOf(scope) ?? '<scopeId>';
-    const nodes = this.doc.flowNodes(scope);
-    const starts = nodes.filter((node) => this.kit.is(node, 'bpmn:StartEvent'));
-    const isProcess = this.kit.is(scope, 'bpmn:Process');
-    const transaction = this.kit.is(scope, 'bpmn:Transaction');
-    const kind = isProcess ? 'Process' : this.kit.isEventSubProcess(scope) ? 'Event sub-process' : transaction ? 'Transaction' : 'Sub-process';
-    if (!starts.length) {
-      if (this.kit.isEventSubProcess(scope)) return;
-      const what = nodes.length ? 'has no start event' : 'is empty, without a start event';
-      const add = nodes.length
-        ? `Add one: \`bpmn add <file> startEvent "<Name>" --before <firstNodeId>\` (or --in ${id}, then connect it)`
-        : `Add content: \`bpmn add <file> startEvent "<Name>" --in ${id}\` and continue from it`;
-      const hint = `${add}${isProcess ? '' : `, or remove it: \`bpmn remove <file> ${id}\``}.`;
-      if (transaction) {
-        this.push('runtime', 'W_C7_TRANSACTION_NO_START', scope, undefined, 'start:none', `${kind} ${id} ${what}: it deploys, but every instance that reaches it fails ("No initial activity found for subprocess ${id}")`, hint);
-      } else {
-        this.push('deploy', 'W_C7_DEPLOY_START_EVENT', scope, undefined, 'start:none', `${kind} ${id} ${what}; the engines refuse the file (${isProcess ? 'process' : 'subProcess'} must define a startEvent element)`, hint);
-      }
-      return;
-    }
-    const limited = isProcess ? starts.filter((start) => this.actedOn(start).every((definition) => this.kit.is(definition, 'bpmn:TimerEventDefinition'))) : starts;
-    const [first, ...rest] = limited;
-    for (const extra of rest) {
-      const sid = idOf(extra)!;
-      const message = isProcess
-        ? `Start event ${sid} is a second none or timer start event of process ${id} (with ${idOf(first)}); the engines allow only one and refuse the file`
-        : `${kind} ${id} has ${limited.length} start events (${limited.map(idOf).join(', ')}); the engines allow only one in a sub-process and refuse the file`;
-      this.push('deploy', 'W_C7_DEPLOY_START_EVENT', extra, undefined, 'start:multiple', message, this.extraStartHint(scope, first!, extra), [idOf(first)!]);
-    }
-  }
-
-  /** The flow nodes reachable from `from` (without `from`, unless a loop leads back to it). */
-  private reachableFrom(from: El): Set<El> {
-    const seen = new Set<El>();
-    const queue = [from];
-    while (queue.length) {
-      for (const flow of this.outgoing.get(queue.shift()!) ?? []) {
-        const target = peek<El>(flow, 'targetRef');
-        if (target && !seen.has(target)) {
-          seen.add(target);
-          queue.push(target);
-        }
-      }
-    }
-    return seen;
-  }
-
-  /**
-   * How to get rid of a second start event `extra` next to `first`, without running a node twice:
-   * its flows into what `first` reaches go with it, a branch of its own moves to `first` unless it
-   * runs into a node `first` reaches. A process may keep it with another trigger.
-   * The hint names the nodes (no end events) a branch of its own runs into that `first` reaches as well.
-   */
-  private extraStartHint(scope: El, first: El, extra: El): string {
-    const sid = idOf(extra)!;
-    const fid = idOf(first)!;
-    const reached = this.reachableFrom(first);
-    const flows = this.outgoing.get(extra) ?? [];
-    const own = flows.filter((flow) => {
-      const target = peek<El>(flow, 'targetRef');
-      return target && target !== first && !reached.has(target);
-    });
-    const into = flows.filter((flow) => !own.includes(flow));
-    const meet = new Set<string>();
-    for (const flow of own) {
-      const target = peek<El>(flow, 'targetRef')!;
-      for (const node of this.reachableFrom(target)) {
-        if (reached.has(node) && !this.kit.is(node, 'bpmn:EndEvent') && idOf(node)) {
-          meet.add(idOf(node)!);
-        }
-      }
-    }
-    const ids = (els: El[]): string => els.map(idOf).join(', ');
-    const targets = (els: El[]): string => [...new Set(els.map((flow) => idOf(peek<El>(flow, 'targetRef'))).filter((targetId): targetId is string => !!targetId))].join(', ');
-    const remove = `\`bpmn remove <file> ${sid}\``;
-    const parts: string[] = [];
-    if (!own.length) {
-      parts.push(`Remove it: ${remove}${into.length ? ` (${fid} already leads to ${targets(into)}; ${ids(into)} go${into.length === 1 ? 'es' : ''} with it)` : ''}`);
-    } else if (meet.size) {
-      const names = [...meet].slice(0, 3).join(', ') + (meet.size > 3 ? ', ...' : '');
-      parts.push(`Remove it: ${remove} (${targets(own)} is then no longer started; starting it from ${fid} instead would run ${names}, which ${fid} reaches too, once per branch)`);
-    } else {
-      const moves = own.map((flow) => `\`bpmn set <file> ${idOf(flow)} source=${fid}\``).join(', ');
-      const notes = [(this.outgoing.get(first) ?? []).length ? `${fid} then starts both branches in parallel` : '', into.length ? `${ids(into)} into ${targets(into)}, which ${fid} already reaches, go${into.length === 1 ? 'es' : ''} with ${sid}` : ''].filter(Boolean);
-      parts.push(`Start its branch from ${fid}: ${moves}, then ${remove}${notes.length ? ` (${notes.join('; ')})` : ''}`);
-    }
-    if (this.kit.is(scope, 'bpmn:Process')) {
-      parts.push(`give it another trigger, which keeps it as a second way into the process: \`bpmn set <file> ${sid} trigger=message message=<Name>\``);
-    }
-    const again = this.kit.isEventSubProcess(scope) ? this.ownEventSubProcess(scope, extra) : '';
-    return `${parts.join(', or ')}${again ? `; ${again}` : ''}.`;
-  }
-
-  /** `then keep its <trigger> trigger in an event sub-process of its own: ...` for `extra`. */
-  private ownEventSubProcess(scope: El, extra: El): string {
-    const def = this.actingDefinition(extra) ?? list(extra, 'eventDefinitions')[0];
-    if (!def) return '';
-    const trigger = triggerName(def);
-    const ref = (prop: string): string => sh(nameOf(peek<El>(def, prop)) ?? '<Name>');
-    const option: Record<string, string> = {
-      message: `--message ${ref('messageRef')}`,
-      signal: `--signal ${ref('signalRef')}`,
-      error: `--error ${ref('errorRef')}`,
-      escalation: `--escalation ${ref('escalationRef')}`,
-      timer: '--timer <value>',
-      conditional: `--when ${sh('${expression}')}`,
-    };
-    const opts = [option[trigger] ?? '', peek<boolean>(extra, 'isInterrupting') === false ? '--non-interrupting' : ''].filter(Boolean).join(' ');
-    return `then keep its ${trigger} trigger in an event sub-process of its own: \`bpmn add <file> eventSubProcess:${trigger} "<Name>" --in ${idOf(this.doc.scopeOf(scope)) ?? '<parentId>'}${opts ? ` ${opts}` : ''}\``;
-  }
-}
diff --git a/src/domain/validation/profiles/c7/C7ExtensionContentRules.ts b/src/domain/validation/profiles/c7/C7ExtensionContentRules.ts
deleted file mode 100644
index 4cdcade8..00000000
--- a/src/domain/validation/profiles/c7/C7ExtensionContentRules.ts
+++ /dev/null
@@ -1,156 +0,0 @@
-import type { El } from '../../../document/utils/moddle.js';
-import type { RuleRun } from '../RuleRun.js';
-import { attr, idOf, localName, peek } from '../../utils/element.js';
-import { sh } from '../../utils/hint.js';
-import { nonEmpty } from '../../utils/value.js';
-import type { C7ImplementationRules } from './C7ImplementationRules.js';
-import { C7Rules } from './C7Rules.js';
-
-const EXECUTION_EVENTS = ['start', 'end'];
-/** the form field types every engine knows (more only through a custom form type plugin) */
-const FORM_TYPES = ['string', 'long', 'boolean', 'date', 'enum'];
-const TASK_EVENTS = ['create', 'assignment', 'complete', 'update', 'delete', 'timeout'];
-
-/** Engine rules on the content of camunda extensions: listeners, mappings, connectors, forms. */
-export class C7ExtensionContentRules extends C7Rules {
-  constructor(
-    run: RuleRun,
-    prefix: string,
-    private readonly implementation: C7ImplementationRules,
-  ) {
-    super(run, prefix);
-  }
-
-  /**
-   * Engine rules on the content of one (allowed, top-level) camunda extension element.
-   * The fields of a class / delegateExpression listener are checked, as the engines parse them on deploy.
-   */
-  checkContent(host: El, owner: El | undefined, extension: El, local: string): void {
-    const where = this.describe(host, owner);
-    const rebuild = (fix: Record<string, string> = {}): string => this.extHint(host, owner, extension, local, fix);
-    if (local === 'executionListener' || local === 'taskListener') {
-      if (local === 'taskListener' && !this.kit.is(host, 'bpmn:UserTask')) return;
-      const impl = ['class', 'expression', 'delegateExpression'].some((attribute) => nonEmpty(attr(extension, attribute))) || this.children(extension, 'script').length > 0;
-      const event = attr(extension, 'event');
-      const label = `${this.prefix}:${local}${event ? ` (event ${event})` : ''} of ${where}`;
-      if (!impl) {
-        this.push('deploy', 'W_C7_DEPLOY_LISTENER', host, owner, `listener:${local}:${event}:impl`, `${label} has no class, expression, delegateExpression or script; the engines refuse the file`, rebuild({ [`expression`]: '${...}' }));
-      }
-      if (!this.kit.is(host, 'bpmn:SequenceFlow')) {
-        const allowed = local === 'taskListener' ? TASK_EVENTS : EXECUTION_EVENTS;
-        const placeholder = `<${allowed.join('|')}>`;
-        if (event === undefined) {
-          this.push('deploy', 'W_C7_DEPLOY_LISTENER', host, owner, `listener:${local}:event`, `${label} has no event; the engines refuse the file`, `Set event to one of ${allowed.join(', ')}. ${rebuild({ event: placeholder })}`);
-        } else if (!allowed.includes(event)) {
-          this.push('deploy', 'W_C7_DEPLOY_LISTENER', host, owner, `listener:${local}:${event}:event`, `${label}: event "${event}" is not one of ${allowed.join(', ')}; the engines refuse the file`, `${event === 'take' && local === 'executionListener' ? 'take is only read on sequence flows. ' : ''}${rebuild({ event: placeholder })}`);
-        }
-      }
-      for (const script of this.children(extension, 'script')) {
-        if (!nonEmpty(attr(script, 'scriptFormat'))) {
-          this.push('deploy', 'W_C7_DEPLOY_LISTENER', host, owner, `listener:${local}:${event}:script`, `The script of ${label} has no scriptFormat; the engines refuse the file`, rebuild());
-        }
-      }
-      if (local === 'taskListener' && event === 'timeout') {
-        const kids = peek<unknown[]>(extension, '$children');
-        const timer = Array.isArray(kids) && (kids as El[]).some((kid) => kid && typeof kid.$type === 'string' && /timerEventDefinition$/i.test(kid.$type));
-        if (!timer) {
-          this.push('deploy', 'W_C7_DEPLOY_LISTENER', host, owner, `listener:${local}:timeout:timer`, `${label} has no bpmn:timerEventDefinition; the engines refuse the file`, rebuild());
-        }
-        if (attr(extension, 'id') === undefined) {
-          this.push('deploy', 'W_C7_DEPLOY_LISTENER', host, owner, `listener:${local}:timeout:id`, `${label} has no id, which the engines require on timeout task listeners; they refuse the file`, rebuild({ id: '<listenerId>' }));
-        }
-      }
-      const fieldsHere = this.children(extension, 'field');
-      if (fieldsHere.length && this.implementation.fieldsRead(extension)) {
-        const addr = this.addressOf(host, owner);
-        this.implementation.checkFieldValues(host, owner, fieldsHere, label, addr ? `${addr.id} ${sh(`${addr.prefix}${this.selectorOf(host, extension)}/${this.prefix}:field`)}` : undefined);
-      }
-      return;
-    }
-    if (local === 'in' || local === 'out') {
-      if (!this.kit.is(host, 'bpmn:CallActivity') && !(local === 'in' && this.kit.is(host, 'bpmn:SignalEventDefinition'))) {
-        return;
-      }
-      if (attr(extension, 'variables') !== undefined || (local === 'in' && attr(extension, 'businessKey') !== undefined)) {
-        return;
-      }
-      const source = attr(extension, 'source') !== undefined || attr(extension, 'sourceExpression') !== undefined;
-      const target = attr(extension, 'target') !== undefined;
-      if (!source || !target) {
-        const missing = [!source ? 'source or sourceExpression' : '', !target ? 'target' : ''].filter(Boolean).join(' and ');
-        const fix: Record<string, string> = {};
-        if (!source) fix['source'] = '<var>';
-        if (!target) fix['target'] = '<var>';
-        this.push('deploy', 'W_C7_DEPLOY_EXTENSION', host, owner, `${local}:${attr(extension, 'source') ?? attr(extension, 'sourceExpression') ?? attr(extension, 'target') ?? ''}`, `${this.prefix}:${local} of ${where} has no ${missing} (and no variables="all"${local === 'in' ? ' / businessKey' : ''}); the engines refuse the file`, `${rebuild(fix).replace(/\.$/, '')} (or with variables=all instead of source and target).`);
-      }
-      return;
-    }
-    if (local === 'inputOutput') {
-      this.checkParameters(host, owner, extension, rebuild(), local);
-      return;
-    }
-    if (local === 'connector') {
-      const ids = this.children(extension).filter((child) => localName(child.$type) === 'connectorId');
-      if (!ids.length) {
-        this.push('deploy', 'W_C7_DEPLOY_EXTENSION', host, owner, 'connector:id', `${this.prefix}:connector of ${where} has no ${this.prefix}:connectorId; the engines refuse the file`, rebuild());
-      }
-      if (ids.length > 1) {
-        this.push('deploy', 'W_C7_DEPLOY_DUPLICATE_EXTENSION', host, owner, 'dup:connectorId', `${this.prefix}:connector of ${where} has ${ids.length} ${this.prefix}:connectorId elements; the engines refuse the file`, rebuild());
-      }
-      const ios = this.children(extension, 'inputOutput');
-      if (ios.length > 1) {
-        this.push('deploy', 'W_C7_DEPLOY_DUPLICATE_EXTENSION', host, owner, 'dup:connector/inputOutput', `${this.prefix}:connector of ${where} has ${ios.length} ${this.prefix}:inputOutput elements; the engines refuse the file`, rebuild());
-      }
-      for (const io of ios) {
-        this.checkParameters(host, owner, io, rebuild(), 'connector');
-      }
-      return;
-    }
-    if (local === 'formData' && (this.kit.is(host, 'bpmn:UserTask') || this.kit.is(host, 'bpmn:StartEvent'))) {
-      this.children(extension, 'formField').forEach((field, index) => {
-        const label = `Form field ${attr(field, 'id') ?? index + 1} of ${where}`;
-        if (!nonEmpty(attr(field, 'id'))) {
-          this.push('deploy', 'W_C7_DEPLOY_EXTENSION', host, owner, `formField#${index}:id`, `${label} has no id; the engines refuse the file`, rebuild());
-        }
-        const type = attr(field, 'type');
-        if (type === undefined) {
-          this.push('deploy', 'W_C7_DEPLOY_EXTENSION', host, owner, `formField#${index}:type`, `${label} has no type; the engines refuse the file`, `Use one of ${FORM_TYPES.join(', ')}. ${rebuild()}`);
-        } else if (!FORM_TYPES.includes(type)) {
-          this.push('deploy', 'W_C7_DEPLOY_EXTENSION', host, owner, `formField#${index}:type`, `${label} has type "${type}", which is not one of the built-in form types ${FORM_TYPES.join(', ')}; the engines refuse the file (unless a plugin registers it as a custom form type)`, rebuild());
-        }
-      });
-    }
-  }
-
-  private checkParameters(host: El, owner: El | undefined, io: El, rebuild: string, scope: string): void {
-    const where = this.describe(host, owner);
-    for (const kind of ['inputParameter', 'outputParameter']) {
-      this.children(io, kind).forEach((param, index) => {
-        if (!nonEmpty(attr(param, 'name'))) {
-          this.push('deploy', 'W_C7_DEPLOY_EXTENSION', host, owner, `${scope}:${kind}#${index}:name`, `${this.prefix}:${kind} ${index + 1} of ${where} has no name; the engines refuse the file`, rebuild);
-        }
-      });
-    }
-  }
-
-  /** Where the engines refuse camunda:inputOutput. */
-  checkInputOutputHost(host: El, owner: El | undefined, ios: El[]): void {
-    if (!ios.length || !this.kit.is(host, 'bpmn:FlowNode')) return;
-    const hostId = idOf(host) ?? idOf(owner);
-    const where = this.describe(host, owner);
-    const remove = hostId ? `Move the mappings to the next activity and remove them here: \`bpmn ext remove <file> ${hostId} ${this.prefix}:inputOutput\`.` : 'Remove it from the XML.';
-    if (this.kit.is(host, 'bpmn:StartEvent') || this.kit.is(host, 'bpmn:BoundaryEvent') || this.kit.is(host, 'bpmn:Gateway') || this.kit.isEventSubProcess(host)) {
-      const kind = this.kit.isEventSubProcess(host) ? 'an event sub-process' : `a ${this.describe(host, undefined).split(' ')[0]}`;
-      this.push('deploy', 'W_C7_DEPLOY_INPUT_OUTPUT', host, owner, 'io:host', `${this.prefix}:inputOutput on ${where}: the engines do not support input/output mappings on ${kind} and refuse the file`, remove);
-      return;
-    }
-    const outputs = ios.some((io) => this.children(io, 'outputParameter').length > 0);
-    if (!outputs) return;
-    const dropOutputs = hostId ? `Remove the output parameters: rebuild the mapping without them (\`bpmn ext list <file> ${hostId} --json\`, then \`bpmn ext add <file> ${hostId} ${this.prefix}:inputOutput --replace --xml '...'\`).` : 'Remove them from the XML.';
-    if (this.kit.is(host, 'bpmn:EndEvent')) {
-      this.push('deploy', 'W_C7_DEPLOY_INPUT_OUTPUT', host, owner, 'io:output', `${this.prefix}:outputParameter on end event ${hostId}: the engines refuse output mappings on end events`, dropOutputs);
-    } else if (this.isMultiInstance(host)) {
-      this.push('deploy', 'W_C7_DEPLOY_INPUT_OUTPUT', host, owner, 'io:output', `${this.prefix}:outputParameter on multi-instance ${where}: the engines refuse output mappings on multi-instance activities`, `${dropOutputs} Collect results in an activity inside the loop instead.`);
-    }
-  }
-}
diff --git a/src/domain/validation/profiles/c7/C7ExtensionRules.ts b/src/domain/validation/profiles/c7/C7ExtensionRules.ts
deleted file mode 100644
index c1279243..00000000
--- a/src/domain/validation/profiles/c7/C7ExtensionRules.ts
+++ /dev/null
@@ -1,313 +0,0 @@
-import type { El } from '../../../document/utils/moddle.js';
-import type { RuleRun } from '../RuleRun.js';
-import { attr, idOf, isGeneric, list, localName, peek } from '../../utils/element.js';
-import { didYouMean, sh, slotted } from '../../utils/hint.js';
-import { extAddArgs, kindsText } from '../../utils/c7-hint.js';
-import type { C7DescriptorNames } from './C7DescriptorNames.js';
-import type { C7ExtensionContentRules } from './C7ExtensionContentRules.js';
-import { C7Rules, SERVICE_LIKE } from './C7Rules.js';
-
-/**
- * Content of an event definition the engines read on one side only (the descriptor allows it on
- * both): delegate settings on message throw events, async and camunda:in on signal throw events,
- * the code variables on error and escalation catch events.
- */
-const SIDE_RULES: Array<{ def: string; side: 'throw' | 'catch'; attrs: string[]; ext: string[]; where: string }> = [
-  { def: 'bpmn:MessageEventDefinition', side: 'throw', attrs: ['class', 'delegateExpression', 'expression', 'resultVariable', 'type', 'topic', 'taskPriority'], ext: ['field', 'connector'], where: 'message throw and end events' },
-  { def: 'bpmn:SignalEventDefinition', side: 'throw', attrs: ['async'], ext: ['in'], where: 'signal throw and end events' },
-  { def: 'bpmn:ErrorEventDefinition', side: 'catch', attrs: ['errorCodeVariable', 'errorMessageVariable'], ext: [], where: 'error boundary and error start events' },
-  { def: 'bpmn:EscalationEventDefinition', side: 'catch', attrs: ['escalationCodeVariable'], ext: [], where: 'escalation boundary and escalation start events' },
-];
-
-/** Hosts the descriptor misses but the engines read. */
-const EXTRA_HOSTS: Record<string, string[]> = {
-  potentialStarter: ['bpmn:Process'],
-  errorEventDefinition: ['bpmn:ServiceTask', 'bpmn:SendTask', 'bpmn:BusinessRuleTask', 'bpmn:MessageEventDefinition', 'bpmn:IntermediateThrowEvent', 'bpmn:EndEvent'],
-};
-
-/** Attributes the engines read that the descriptor knows as child elements only. */
-const EXTRA_ATTRS: Record<string, string[]> = { field: ['expression'] };
-
-/**
- * Camunda attributes and extension elements against the descriptor: unknown, misplaced,
- * duplicated or Camunda 8 content, and id references inside camunda content.
- */
-export class C7ExtensionRules extends C7Rules {
-  private readonly errors: Map<string, El>;
-
-  constructor(
-    run: RuleRun,
-    prefix: string,
-    private readonly names: C7DescriptorNames,
-    private readonly content: C7ExtensionContentRules,
-  ) {
-    super(run, prefix);
-    this.errors = new Map(run.doc.rootElementsOfType('bpmn:Error').map((error) => [idOf(error) ?? '', error] as const));
-  }
-
-  private wrongSide(def: El, owner: El | undefined, local: string, kind: 'attrs' | 'ext'): string | undefined {
-    if (!owner || !list(owner, 'eventDefinitions').includes(def)) return undefined;
-    const side = this.kit.is(owner, 'bpmn:CatchEvent') ? 'catch' : this.kit.is(owner, 'bpmn:ThrowEvent') ? 'throw' : undefined;
-    if (!side) return undefined;
-    const rule = SIDE_RULES.find((sideRule) => this.kit.is(def, sideRule.def) && sideRule[kind].includes(local));
-    return rule && rule.side !== side ? rule.where : undefined;
-  }
-
-  /** camunda / zeebe attributes of a BPMN element: unknown, misplaced, foreign, bad booleans. */
-  checkAttributes(el: El, owner: El | undefined): void {
-    const addr = this.addressOf(el, owner);
-    const where = this.describe(el, owner);
-    for (const [key, raw] of Object.entries(el.$attrs ?? {})) {
-      const uri = this.ns.uriOfName(key);
-      if (!uri) continue;
-      const local = key.slice(key.indexOf(':') + 1);
-      const value = raw === undefined || raw === null ? '' : String(raw);
-      const unset = addr ? `\`bpmn set <file> ${addr.id} ${sh(`${addr.prefix}${key}=`)}\`` : 'edit the XML';
-      if (uri === this.kit.zeebe.uri) {
-        this.push('runtime', 'W_C7_FOREIGN_CONTENT', el, owner, `attr:${key}`, `${where} carries the Camunda 8 attribute ${key}, which Camunda 7 ignores`, `Remove it: ${unset}, and use the camunda attribute instead (\`bpmn kinds\` lists them).`);
-        continue;
-      }
-      if (!this.kit.camunda.reads(uri)) continue;
-      const def = this.kit.camunda.attr(local);
-      if (!def) {
-        const applicable = this.kit.camunda.attrs().filter((attribute) => attribute.owners.some((ownerType) => this.kit.is(el, ownerType))).map((attribute) => localName(attribute.name));
-        const guess = didYouMean(local, this.kit.camunda.attrs().map((attribute) => localName(attribute.name)), applicable);
-        const prefix = key.slice(0, key.indexOf(':'));
-        const fits = !!guess && applicable.includes(guess);
-        const elsewhere = guess && !fits ? ` It applies to ${kindsText(this.kit.camunda.attr(guess)!.owners)} only.` : '';
-        this.push(
-          'runtime',
-          'W_C7_UNKNOWN_ATTRIBUTE',
-          el,
-          owner,
-          `attr:${key}`,
-          `${where} has the unknown attribute ${key}${guess ? ` (did you mean ${prefix}:${guess}?${elsewhere})` : ''}; the engines ignore it`,
-          fits && addr ? `Rename it: \`bpmn set <file> ${addr.id} ${sh(`${addr.prefix}${key}=`)} ${sh(`${addr.prefix}${prefix}:${guess}=${value}`)}\`.` : `Remove it: ${unset}.`,
-        );
-        continue;
-      }
-      const owned = def.owners.some((ownerType) => this.kit.is(el, ownerType));
-      const readOn = owned ? this.wrongSide(el, owner, local, 'attrs') : kindsText(def.owners);
-      if (readOn !== undefined) {
-        this.push('runtime', 'W_C7_MISPLACED_ATTRIBUTE', el, owner, `attr:${key}`, `${key} on ${where} has no effect: the engines read it on ${readOn} only`, owned ? `Remove it: ${unset}.` : this.misplacedHint(el, owner, key, local, value, def.owners));
-        continue;
-      }
-      if (def.type === 'Boolean' && value !== 'true' && value !== 'false') {
-        this.push('runtime', 'W_C7_BAD_VALUE', el, owner, `attr:${key}`, `${key}="${value}" on ${where} is not true or false; the engines read only the exact value true (yes, TRUE or True leave it off)`, addr ? `\`bpmn set <file> ${addr.id} ${sh(`${addr.prefix}${key}=true`)}\` (or =false).` : 'Use true or false.');
-      }
-    }
-  }
-
-  private misplacedHint(el: El, owner: El | undefined, key: string, local: string, value: string, owners: string[]): string {
-    const addr = this.addressOf(el, owner);
-    const id = addr?.id;
-    const move = (prefix: string): string => `\`bpmn set <file> ${id} ${sh(`${addr!.prefix}${key}=`)} ${sh(`${prefix}${this.prefix}:${local}=${value}`)}\``;
-    if (id && addr!.prefix === '') {
-      const defs = list(el, 'eventDefinitions');
-      const fit = defs.findIndex((definition) => owners.some((ownerType) => this.kit.is(definition, ownerType)));
-      if (this.kit.is(el, 'bpmn:Event') && fit !== -1) {
-        return `It belongs on the event definition: ${move(defs.length > 1 ? `definition[${fit}].` : 'definition.')}.`;
-      }
-      if (this.kit.is(el, 'bpmn:Activity') && owners.includes('bpmn:MultiInstanceLoopCharacteristics')) {
-        const mi = this.isMultiInstance(el);
-        return `It belongs on the multi-instance loop: ${move('loop.')}${mi ? '' : ' (creates a parallel multi-instance loop)'}.`;
-      }
-      if (this.kit.is(el, 'bpmn:SequenceFlow') && owners.includes('bpmn:FormalExpression') && peek<El>(el, 'conditionExpression')) {
-        return `It belongs on the condition: ${move('condition.')}.`;
-      }
-    }
-    return id ? `Remove it: \`bpmn set <file> ${id} ${sh(`${addr!.prefix}${key}=`)}\`.` : 'Remove it from the XML.';
-  }
-
-  private allowedTop(local: string, host: El): boolean {
-    const vendorType = this.kit.camunda.type(local);
-    if (!vendorType) return true;
-    const hosts = [...vendorType.allowedIn, ...(EXTRA_HOSTS[local] ?? [])];
-    return hosts.some((allowedHost) => allowedHost === '*' || (allowedHost.startsWith('bpmn:') && this.kit.is(host, allowedHost)));
-  }
-
-  /** Attributes and children of a generic camunda element, recursively. */
-  private checkVendorElement(vendorElement: El, host: El, owner: El | undefined, topEl: El, path: string): void {
-    const local = localName(vendorElement.$type);
-    const vendorType = this.kit.camunda.type(local);
-    if (!vendorType) return;
-    const rebuild = (): string => this.extHint(host, owner, topEl, localName(topEl.$type));
-    const where = `${this.prefix}:${local}${path ? ` (in ${path})` : ''} of ${this.describe(host, owner)}`;
-    const names = this.names.attrNames(vendorType);
-    for (const extra of EXTRA_ATTRS[local] ?? []) {
-      names.add(extra);
-    }
-    for (const [key, raw] of Object.entries(vendorElement as unknown as Record<string, unknown>)) {
-      if (key.startsWith('$') || key.startsWith('xmlns')) continue;
-      if (key.includes(':')) {
-        if (this.ns.uriOfName(key) === this.kit.zeebe.uri) {
-          this.push('runtime', 'W_C7_FOREIGN_CONTENT', host, owner, `ext:${path}/${local}@${key}`, `${where} carries the Camunda 8 attribute ${key}, which Camunda 7 ignores`, rebuild());
-        }
-        continue;
-      }
-      if (!names.has(key)) {
-        const guess = didYouMean(key, [...names]);
-        this.push('runtime', 'W_C7_UNKNOWN_ATTRIBUTE', host, owner, `ext:${path}/${local}@${key}`, `${where} has the unknown attribute ${key}${guess ? ` (did you mean ${guess}?)` : ''}; the engines ignore it`, rebuild());
-        continue;
-      }
-      const prop = vendorType.properties.find((property) => property.name === key);
-      if (prop?.type === 'Boolean' && raw !== 'true' && raw !== 'false' && raw !== true && raw !== false) {
-        this.push('runtime', 'W_C7_BAD_VALUE', host, owner, `ext:${path}/${local}@${key}`, `${key}="${String(raw)}" on ${where} is not true or false; the engines read only the exact value true`, rebuild());
-      }
-    }
-    const texts = this.names.textChildNames(vendorType);
-    const kids = peek<unknown[]>(vendorElement, '$children');
-    for (const child of Array.isArray(kids) ? (kids as El[]) : []) {
-      if (!child || typeof child.$type !== 'string' || !isGeneric(child)) continue;
-      const uri = this.ns.uriOfElement(child);
-      const cl = localName(child.$type);
-      if (uri === this.kit.zeebe.uri) {
-        this.push('runtime', 'W_C7_FOREIGN_CONTENT', host, owner, `ext:${path}/${local}/${cl}`, `${where} contains the Camunda 8 element ${child.$type}, which Camunda 7 ignores`, rebuild());
-        continue;
-      }
-      if (!this.kit.camunda.reads(uri)) continue;
-      const childPath = path ? `${path} > ${this.prefix}:${local}` : `${this.prefix}:${local}`;
-      if (texts.has(cl)) continue;
-      const ct = this.kit.camunda.type(cl);
-      if (!ct) {
-        const guess = didYouMean(cl, [...texts, ...vendorType.properties.filter((property) => property.type.startsWith('camunda:')).map((property) => localName(property.type).replace(/^./, (firstLetter) => firstLetter.toLowerCase()))]);
-        this.push('runtime', 'W_C7_UNKNOWN_ELEMENT', host, owner, `ext:${childPath}/${cl}`, `${where} contains the unknown element ${this.prefix}:${cl}${guess ? ` (did you mean ${this.prefix}:${guess}?)` : ''}; the engines ignore it`, rebuild());
-        continue;
-      }
-      if (!this.kit.camunda.containersOf(cl).includes(vendorType.name)) {
-        this.push('runtime', 'W_C7_MISPLACED_EXTENSION', host, owner, `ext:${childPath}/${cl}`, `${this.prefix}:${cl} does not belong inside ${this.prefix}:${local} (${where}); the engines ignore it`, rebuild());
-        continue;
-      }
-      this.checkVendorElement(child, host, owner, topEl, childPath);
-    }
-  }
-
-  private isAsync(el: El): boolean {
-    return ['async', 'asyncBefore', 'asyncAfter'].some((asyncAttribute) => this.c7(el, asyncAttribute) === 'true');
-  }
-
-  private hasTimer(el: El): boolean {
-    return list(el, 'eventDefinitions').some((definition) => this.kit.is(definition, 'bpmn:TimerEventDefinition'));
-  }
-
-  /**
-   * Extension elements of one BPMN element: unknown or misplaced types, duplicates, foreign
-   * content, and the engine rules on their content.
-   * Types are grouped per namespace, as Operaton reads one operaton:inputOutput next to one
-   * camunda:inputOutput; when executable, duplicates of the containers the engines read with a
-   * single-element lookup are reported.
-   */
-  checkExtensions(host: El, owner: El | undefined, executable: boolean): void {
-    const values = this.extensionValues(host);
-    if (!values.length) return;
-    /**
-     * `ext` addresses a nested element's extensions through its flow node (or flow) with a key
-     * prefix, also when it has an id of its own (`ext <ownId> definition.0` fails)
-     */
-    const addr = this.addressOf(host, owner);
-    const hostId = addr?.id;
-    const slot = addr?.prefix ?? '';
-    const where = this.describe(host, owner);
-    if (this.kit.is(host, 'bpmn:Definitions')) {
-      const types = values.map((extValue) => extValue.el.$type).join(', ');
-      this.push('deploy', 'W_C7_DEPLOY_DEFINITIONS_EXTENSION', host, undefined, 'definitions', `bpmn:definitions carries bpmn:extensionElements (${types}), which the BPMN schema does not allow there; the engines refuse the file`, `Move the content to the process: \`bpmn ext remove <file> ${hostId ?? '<definitionsId>'} <type>\`, then \`bpmn ext add <file> <processId> <type> ...\`.`);
-      return;
-    }
-    const byType = new Map<string, { local: string; type: string; uri: string; els: El[] }>();
-    for (const extValue of values) {
-      if (!extValue.uri) continue;
-      if (extValue.uri === this.kit.zeebe.uri) {
-        this.push('runtime', 'W_C7_FOREIGN_CONTENT', host, owner, `ext:${extValue.el.$type}`, `${where} contains the Camunda 8 extension ${extValue.el.$type}, which Camunda 7 ignores`, hostId ? `Remove it: \`bpmn ext remove <file> ${hostId} ${slotted(slot, extValue.el.$type)}\`.` : 'Remove it from the XML.');
-        continue;
-      }
-      if (!this.kit.camunda.reads(extValue.uri)) continue;
-      const vendorType = this.kit.camunda.type(extValue.local);
-      if (!vendorType) {
-        const guess = didYouMean(extValue.local, this.names.typeNames());
-        this.push('runtime', 'W_C7_UNKNOWN_ELEMENT', host, owner, `ext:${extValue.local}`, `${where} has the unknown extension element ${this.prefix}:${extValue.local}${guess ? ` (did you mean ${this.prefix}:${guess}?)` : ''}; the engines ignore it`, hostId ? `Remove it (\`bpmn ext remove <file> ${hostId} ${slotted(slot, String(extValue.index))}\`) and add the right one with \`bpmn ext add <file> ${hostId} ${slotted(slot, `${this.prefix}:${guess ?? '<type>'}`)} ...\`.` : 'Fix it in the XML.');
-        continue;
-      }
-      const key = `${extValue.uri}\u0000${extValue.local}`;
-      const group = byType.get(key) ?? { local: extValue.local, type: extValue.el.$type, uri: extValue.uri, els: [] };
-      group.els.push(extValue.el);
-      byType.set(key, group);
-      const side = this.wrongSide(host, owner, extValue.local, 'ext');
-      if (side) {
-        this.push('runtime', 'W_C7_MISPLACED_EXTENSION', host, owner, `ext:${extValue.local}`, `${extValue.el.$type} on ${where} has no effect: the engines read it on ${side} only`, hostId ? `Remove it: \`bpmn ext remove <file> ${hostId} ${sh(`${slot}${this.selectorOf(host, extValue.el)}`)}\`.` : 'Remove it from the XML.');
-        continue;
-      }
-      if (!this.allowedTop(extValue.local, host)) {
-        const containers = vendorType.allowedIn.length ? [] : this.kit.camunda.containersOf(extValue.local);
-        const message = containers.length
-          ? `${this.prefix}:${extValue.local} sits directly in the extension elements of ${where}, but belongs inside ${containers.map((container) => container.replace(/^camunda:/, `${this.prefix}:`)).join(' / ')}; the engines ignore it`
-          : `${this.prefix}:${extValue.local} on ${where} has no effect: the engines read it on ${kindsText([...vendorType.allowedIn, ...(EXTRA_HOSTS[extValue.local] ?? [])])} only`;
-        const again = extAddArgs(extValue.el, `${this.prefix}:${extValue.local}`);
-        const hint = !hostId
-          ? 'Fix it in the XML.'
-          : containers.length
-            ? `Remove it (\`bpmn ext remove <file> ${hostId} ${slotted(slot, String(extValue.index))}\`) and add it again, \`bpmn ext add\` files it into its container: ${again ? `\`bpmn ext add <file> ${hostId} ${slotted(slot, again)}\`` : `\`bpmn ext add <file> ${hostId} ${slotted(slot, `${this.prefix}:${extValue.local}`)} --xml '...'\``}.`
-            : `Remove it: \`bpmn ext remove <file> ${hostId} ${slotted(slot, String(extValue.index))}\`${this.movable(host, owner, extValue.local, again)}.`;
-        this.push('runtime', 'W_C7_MISPLACED_EXTENSION', host, owner, `ext:${extValue.local}`, message, hint);
-        continue;
-      }
-      this.checkVendorElement(extValue.el, host, owner, extValue.el, '');
-      if (executable) {
-        this.content.checkContent(host, owner, extValue.el, extValue.local);
-      }
-    }
-    if (!executable) return;
-    for (const { local, type, uri, els } of byType.values()) {
-      if (els.length < 2) continue;
-      let read = false;
-      if (local === 'inputOutput') {
-        read = this.kit.is(host, 'bpmn:FlowNode');
-      } else if (local === 'connector') {
-        read = SERVICE_LIKE.some((serviceType) => this.kit.is(host, serviceType));
-      } else if (local === 'formData') {
-        read = this.kit.is(host, 'bpmn:UserTask') || this.kit.is(host, 'bpmn:StartEvent');
-      } else if (local === 'failedJobRetryTimeCycle') {
-        read = this.isAsync(host) || this.hasTimer(host);
-      } else {
-        continue;
-      }
-      if (!read && local !== 'failedJobRetryTimeCycle') continue;
-      const merge = hostId ? `Merge them into one: \`bpmn ext list <file> ${hostId} --json\`, then \`bpmn ext add <file> ${hostId} ${slotted(slot, type)} --replace --xml '<${type}>...</${type}>'\`.` : 'Merge them in the XML.';
-      const subject = `dup:${local}${uri === this.kit.camunda.uri ? '' : `@${uri}`}`;
-      if (read) {
-        this.push('deploy', 'W_C7_DEPLOY_DUPLICATE_EXTENSION', host, owner, subject, `${where} has ${els.length} ${type} elements; the engines refuse the file (ENGINE-01009 multiple elements with tag name ${local})`, merge);
-      } else {
-        this.push('practice', 'W_C7_DUPLICATE_EXTENSION', host, owner, subject, `${where} has ${els.length} ${type} elements; once it runs asynchronously the engines refuse the file`, merge);
-      }
-    }
-    this.content.checkInputOutputHost(host, owner, [...byType.values()].filter((group) => group.local === 'inputOutput').flatMap((group) => group.els));
-  }
-
-  /**
-   * `, then add it to <flow node>: ...` when an extension element on a nested element is read on
-   * the flow node that holds it and that node has none of its type yet; '' otherwise.
-   */
-  private movable(host: El, owner: El | undefined, local: string, again: string | undefined): string {
-    const oid = idOf(owner);
-    if (!owner || owner === host || !oid || !again || !this.allowedTop(local, owner) || this.camundaExt(owner, local).length) {
-      return '';
-    }
-    return `, then add it to ${this.describe(owner, undefined)}, where the engines read it: \`bpmn ext add <file> ${oid} ${again}\``;
-  }
-
-  /** Id references inside camunda content (camunda:errorEventDefinition errorRef -> bpmn:Error). */
-  checkVendorRefs(host: El, owner: El | undefined): void {
-    for (const extValue of this.extensionValues(host)) {
-      if (!extValue.uri || !this.kit.camunda.reads(extValue.uri)) continue;
-      for (const ref of this.kit.camunda.idReferenceAttrs()) {
-        if (localName(ref.element) !== extValue.local) continue;
-        const target = attr(extValue.el, ref.attr);
-        if (target === undefined) continue;
-        const el = this.doc.get(target);
-        if (el && this.kit.is(el, ref.target)) continue;
-        const candidates = ref.target === 'bpmn:Error' ? [...this.errors.keys()] : [];
-        const pointAt = `Point it at an existing one${candidates.length ? ` (${candidates.slice(0, 5).join(', ')})` : ''}`;
-        this.push('runtime', 'W_C7_DANGLING_REF', host, owner, `ref:${extValue.local}#${extValue.index}@${ref.attr}`, `${extValue.el.$type} of ${this.describe(host, owner)} references ${ref.attr}="${target}", which is not a ${ref.target} in the file; the engines ignore the mapping when it runs`, `${pointAt}. ${this.extHint(host, owner, extValue.el, extValue.local, { [ref.attr]: `<${localName(ref.target).replace(/^./, (firstLetter) => firstLetter.toLowerCase())}Id>` })}`);
-      }
-    }
-  }
-}
diff --git a/src/domain/validation/profiles/c7/C7FlowRules.ts b/src/domain/validation/profiles/c7/C7FlowRules.ts
deleted file mode 100644
index 35080910..00000000
--- a/src/domain/validation/profiles/c7/C7FlowRules.ts
+++ /dev/null
@@ -1,137 +0,0 @@
-import type { El } from '../../../document/utils/moddle.js';
-import type { RuleRun } from '../RuleRun.js';
-import { idOf, nameOf, peek, triggerName } from '../../utils/element.js';
-import { sh } from '../../utils/hint.js';
-import type { C7ImplementationRules } from './C7ImplementationRules.js';
-import { C7Rules } from './C7Rules.js';
-
-/** Sequence flows, gateways, and the elements the engines refuse once something connects them. */
-export class C7FlowRules extends C7Rules {
-  /** `operaton`: the file targets Operaton, which deploys a valid loop on an ad-hoc sub-process */
-  constructor(
-    run: RuleRun,
-    prefix: string,
-    private readonly operaton: boolean,
-    private readonly implementation: C7ImplementationRules,
-  ) {
-    super(run, prefix);
-  }
-
-  /**
-   * An empty condition on a sequence flow the engines evaluate (not a default flow, not out of a
-   * parallel / event-based gateway).
-   */
-  checkFlowCondition(flow: El): void {
-    const cond = peek<El>(flow, 'conditionExpression');
-    if (!cond || !this.emptyCondition(cond)) return;
-    const source = peek<El>(flow, 'sourceRef');
-    if (source && (this.kit.ignoresConditions(source) || peek<El>(source, 'default') === flow)) {
-      return;
-    }
-    const id = idOf(flow)!;
-    this.push('runtime', 'W_C7_EMPTY_CONDITION', flow, undefined, 'emptyCondition', `Sequence flow ${id} has an empty condition (no expression and no ${this.prefix}:resource): it deploys, but the engines fail when they evaluate it`, `Give it one: \`bpmn set <file> ${id} ${sh('condition=${expression}')}\`, or remove it: \`bpmn set <file> ${id} condition=\`.`);
-  }
-
-  /** Checks the targets of an event-based gateway; of several definitions the engines act on one, so a link is refused only when it wins. */
-  checkEventGateway(gw: El): void {
-    const id = idOf(gw)!;
-    const names = new Map<string, El>();
-    for (const flow of this.outgoing.get(gw) ?? []) {
-      const target = peek<El>(flow, 'targetRef');
-      if (!target) continue;
-      const tid = idOf(target)!;
-      const fid = idOf(flow)!;
-      const leadsTo = `Event-based gateway ${id} leads to ${this.describe(target, undefined)}`;
-      if (!this.kit.is(target, 'bpmn:IntermediateCatchEvent')) {
-        this.push('deploy', 'W_C7_DEPLOY_EVENT_GATEWAY', gw, undefined, `target:${tid}`, `${leadsTo}; the engines accept only intermediate catch events (message, timer, signal, conditional) there and refuse the file`, `Put a catch event in front of it: \`bpmn add <file> intermediateCatchEvent:message "<Name>" --flow ${fid} --message <MessageName>\` (or :timer --timer PT1H).`, [tid, fid]);
-        continue;
-      }
-      const defs = this.actedOn(target);
-      const trigger = defs.length === 1 ? triggerName(defs[0]!) : '';
-      const kind = this.kit.EVENT_GATEWAY_TRIGGERS.find((knownTrigger) => knownTrigger === trigger) ?? '';
-      if (!kind) {
-        this.push('deploy', 'W_C7_DEPLOY_EVENT_GATEWAY', gw, undefined, `target:${tid}`, `${leadsTo}; after an event-based gateway the engines accept only message, timer, signal and conditional catch events and refuse the file`, `\`bpmn set <file> ${tid} trigger=message message=<MessageName>\` (or trigger=timer timer=PT1H).`, [tid, fid]);
-        continue;
-      }
-      const ref = kind === 'message' ? peek<El>(defs[0], 'messageRef') : kind === 'signal' ? peek<El>(defs[0], 'signalRef') : undefined;
-      const name = nameOf(ref);
-      if (!name) continue;
-      const key = `${kind}\u0000${name}`;
-      const first = names.get(key);
-      if (first) {
-        this.push('deploy', 'W_C7_DEPLOY_EVENT_GATEWAY', gw, undefined, `dup:${kind}:${name}`, `Branches ${idOf(first)} and ${tid} of event-based gateway ${id} wait for the same ${kind} "${name}"; the engines refuse the file`, `\`bpmn set <file> ${tid} ${kind}=<OtherName>\`, or remove one branch.`, [idOf(first)!, tid]);
-      } else {
-        names.set(key, target);
-      }
-    }
-  }
-
-  checkExclusiveGateway(gw: El): void {
-    const id = idOf(gw)!;
-    const outgoing = this.outgoing.get(gw) ?? [];
-    const def = peek<El>(gw, 'default');
-    const hasCond = (flow: El): boolean => !!peek<El>(flow, 'conditionExpression');
-    const conditionedDefault = (flow: El): void => {
-      this.push('deploy', 'W_C7_DEPLOY_EXCLUSIVE_GATEWAY', gw, undefined, `default:${idOf(flow)}`, `Default flow ${idOf(flow)} of exclusive gateway ${id} has a condition; the engines refuse the file`, `\`bpmn set <file> ${idOf(flow)} condition=\`.`, [idOf(flow)!]);
-    };
-    if (!outgoing.length) {
-      this.push('deploy', 'W_C7_DEPLOY_EXCLUSIVE_GATEWAY', gw, undefined, 'none', `Exclusive gateway ${id} has no outgoing flow; the engines refuse the file`, `Continue it: \`bpmn add <file> <kind> "<Name>" --after ${id}\`.`);
-      return;
-    }
-    if (outgoing.length === 1) {
-      const flow = outgoing[0]!;
-      if (hasCond(flow) && flow !== def) {
-        this.push('deploy', 'W_C7_DEPLOY_EXCLUSIVE_GATEWAY', gw, undefined, `single:${idOf(flow)}`, `Exclusive gateway ${id} has a single outgoing flow ${idOf(flow)} with a condition; the engines refuse the file`, `\`bpmn set <file> ${idOf(flow)} condition=\`.`, [idOf(flow)!]);
-      }
-      if (hasCond(flow) && flow === def) conditionedDefault(flow);
-      return;
-    }
-    const unconditioned: El[] = [];
-    for (const flow of outgoing) {
-      if (flow === def) {
-        if (hasCond(flow)) conditionedDefault(flow);
-        continue;
-      }
-      if (!hasCond(flow)) unconditioned.push(flow);
-    }
-    if (def || unconditioned.length > 1) {
-      for (const flow of unconditioned) {
-        this.push('deploy', 'W_C7_DEPLOY_EXCLUSIVE_GATEWAY', gw, undefined, `uncond:${idOf(flow)}`, `Flow ${idOf(flow)} of exclusive gateway ${id} has no condition and is not the default flow${def ? '' : ` (${unconditioned.length} such flows)`}; the engines refuse the file`, `\`bpmn set <file> ${idOf(flow)} ${sh('condition=${...}')}\`${def ? '' : ` or make one of them the default: \`bpmn set <file> ${idOf(flow)} default=true\``}.`, [idOf(flow)!]);
-      }
-    } else if (unconditioned.length === 1) {
-      const flow = unconditioned[0]!;
-      this.push('practice', 'W_C7_EXCLUSIVE_GATEWAY_DEFAULT', gw, undefined, `implicit:${idOf(flow)}`, `Flow ${idOf(flow)} of exclusive gateway ${id} has no condition and is not the default flow; the engines take it as the default and log a warning`, `\`bpmn set <file> ${idOf(flow)} default=true\`.`, [idOf(flow)!]);
-    }
-  }
-
-  /** The engines ignore complex gateways; one that nothing connects deploys. */
-  checkComplexGateway(el: El): void {
-    const id = idOf(el)!;
-    const incoming = this.incoming.get(el) ?? [];
-    const flows = [...incoming, ...(this.outgoing.get(el) ?? [])];
-    if (!flows.length) return;
-    this.push('deploy', 'W_C7_DEPLOY_COMPLEX_GATEWAY', el, undefined, 'complexGateway', `Complex gateway ${id} is connected; the engines do not run complex gateways and refuse the file (invalid ${incoming.length ? 'destination' : 'source'} '${id}' of sequence flow ${idOf(flows[0])})`, `\`bpmn retype <file> ${id} inclusiveGateway\` (or exclusiveGateway: one path).`, flows.map(idOf).filter((nodeId): nodeId is string => !!nodeId));
-  }
-
-  /**
-   * The engines skip an ad-hoc sub-process with its content and refuse one with a sequence flow or
-   * a boundary event. Its multi-instance loop is parsed first: the loop rules hold, and Camunda 7
-   * and CIB seven refuse any loop on it (Operaton deploys a valid one).
-   */
-  checkAdHoc(el: El): void {
-    const id = idOf(el)!;
-    const flows = [...(this.incoming.get(el) ?? []), ...(this.outgoing.get(el) ?? [])];
-    const scope = this.doc.scopeOf(el);
-    const boundaries = scope ? this.doc.flowNodes(scope).filter((node) => this.kit.is(node, 'bpmn:BoundaryEvent') && peek<El>(node, 'attachedToRef') === el) : [];
-    const loop = this.isMultiInstance(el);
-    this.implementation.checkMultiInstance(el);
-    if (!flows.length && !boundaries.length && (!loop || this.operaton)) return;
-    const parts = [flows.length ? `sequence flow${flows.length > 1 ? 's' : ''} ${flows.map(idOf).join(', ')}` : '', boundaries.length ? `boundary event${boundaries.length > 1 ? 's' : ''} ${boundaries.map(idOf).join(', ')}` : ''].filter(Boolean);
-    const connected = parts.length > 0;
-    const message = connected
-      ? `Ad-hoc sub-process ${id} is connected (${parts.join(' and ')}); the engines do not run ad-hoc sub-processes and refuse the file (${flows.length ? `invalid ${(this.incoming.get(el) ?? []).length ? 'destination' : 'source'} '${id}' of sequence flow ${idOf(flows[0])}` : 'invalid reference in boundary event'})`
-      : `Ad-hoc sub-process ${id} has a multi-instance loop; the engines do not run ad-hoc sub-processes, and Camunda 7 and CIB seven refuse the file (ENGINE-01009, "activity" is null)`;
-    const retype = `Make it an embedded sub-process: \`bpmn retype <file> ${id} subProcess\`, then give its content a start event and flows (\`bpmn add <file> startEvent "<Name>" --in ${id}\`, \`bpmn connect <file> <fromId> <toId>\`)`;
-    this.push('deploy', 'W_C7_DEPLOY_AD_HOC_SUBPROCESS', el, undefined, 'adHoc', message, connected ? `${retype}.` : `${retype}, or drop the loop: \`bpmn set <file> ${id} loop=none\`.`, [...flows, ...boundaries].map(idOf).filter((elementId): elementId is string => !!elementId));
-  }
-}
diff --git a/src/domain/validation/profiles/c7/C7ImplementationRules.ts b/src/domain/validation/profiles/c7/C7ImplementationRules.ts
deleted file mode 100644
index 61a28a08..00000000
--- a/src/domain/validation/profiles/c7/C7ImplementationRules.ts
+++ /dev/null
@@ -1,292 +0,0 @@
-import type { El } from '../../../document/utils/moddle.js';
-import { attr, idOf, isGeneric, peek } from '../../utils/element.js';
-import { sh } from '../../utils/hint.js';
-import { nonEmpty } from '../../utils/value.js';
-import { C7Rules } from './C7Rules.js';
-
-type FieldValue = { kind: 'string' | 'expression'; value: string } | { problem: string };
-
-const SHELL_FLAGS = ['wait', 'redirectError', 'cleanEnv'];
-const BINDINGS = ['latest', 'deployment', 'version', 'versionTag'];
-const CASE_BINDINGS = ['latest', 'deployment', 'version'];
-const FORM_BINDINGS = ['deployment', 'latest', 'version'];
-const DECISION_MAPPERS = ['singleEntry', 'singleResult', 'collectEntries', 'resultList'];
-const TTL_MAX = 2147483647;
-
-/**
- * How activities and processes are implemented and bound: delegates, external and shell tasks,
- * called elements and decisions, forms, multi-instance loops, priorities, history time to live.
- */
-export class C7ImplementationRules extends C7Rules {
-  private isExpression(value: string): boolean {
-    return /[$#]\{/.test(value);
-  }
-
-  private isNumber(value: string): boolean {
-    return /^[+-]?\d+$/.test(value.trim()) && value.trim() === value;
-  }
-
-  /**
-   * A camunda:field's value as the engines parse it: stringValue / camunda:string first, then
-   * expression / camunda:expression. None, or attribute and element of one kind together, is
-   * refused where the engines read fields. An element without text counts as a value.
-   */
-  private fieldValue(field: El): FieldValue {
-    const pick = (attrName: string, child: string): { value?: string; problem?: string } => {
-      const attributeValue = attr(field, attrName);
-      const kids = this.children(field, child);
-      if (attributeValue !== undefined && kids.length) {
-        return { problem: `both the attribute ${attrName} and a ${this.prefix}:${child} element` };
-      }
-      if (kids.length) {
-        const text = peek<unknown>(kids[0], '$body');
-        return { value: typeof text === 'string' ? text : '' };
-      }
-      return attributeValue !== undefined && attributeValue.length > 0 ? { value: attributeValue } : {};
-    };
-    const stringValue = pick('stringValue', 'string');
-    if (stringValue.problem) return { problem: stringValue.problem };
-    if (stringValue.value !== undefined) {
-      return { kind: 'string', value: stringValue.value };
-    }
-    const expression = pick('expression', 'expression');
-    if (expression.problem) return { problem: expression.problem };
-    if (expression.value !== undefined) {
-      return { kind: 'expression', value: expression.value };
-    }
-    return { problem: 'no value' };
-  }
-
-  /**
-   * Whether the engines parse the camunda:field elements of an implementation: a class or a
-   * delegate expression (an expression wins and reads none), a shell task; never an external task.
-   */
-  fieldsRead(el: El, opts: { type?: string } = {}): boolean {
-    if (opts.type !== undefined) return opts.type.toLowerCase() === 'shell';
-    const get = (attributeName: string): string | undefined => (isGeneric(el) ? attr(el, attributeName) : this.c7(el, attributeName));
-    if (nonEmpty(get('class'))) return true;
-    return get('expression') === undefined && nonEmpty(get('delegateExpression'));
-  }
-
-  /**
-   * Fields without a value where the engines read them; `add` is the `ext add` type argument that
-   * replaces one field.
-   */
-  checkFieldValues(host: El, owner: El | undefined, fields: El[], label: string, add: string | undefined): void {
-    fields.forEach((field, index) => {
-      const fieldValue = this.fieldValue(field);
-      if (!('problem' in fieldValue)) return;
-      const name = attr(field, 'name');
-      const hint = add && name !== undefined ? `Give it one: \`bpmn ext add <file> ${add} name=${sh(name)} stringValue=<value>\` (replaces the field of that name; or ${sh('expression=${...}')}).` : `Give it a stringValue or an expression in the XML.`;
-      this.push('deploy', 'W_C7_DEPLOY_EXTENSION', host, owner, `field:${name ?? `#${index}`}`, `${this.prefix}:field${name !== undefined ? ` "${name}"` : ''} of ${label} has ${fieldValue.problem}; the engines refuse the file (a field needs stringValue, expression, a ${this.prefix}:string or a ${this.prefix}:expression)`, hint);
-    });
-  }
-
-  /** camunda:type="shell": a command field, fixed values only, true/false flags. */
-  private checkShell(el: El, owner: El | undefined, label: string, add: string | undefined): void {
-    const prefix = this.prefix;
-    const fields = this.camundaExt(el, 'field');
-    if (!fields.some((field) => attr(field, 'name') === 'command')) {
-      this.push('deploy', 'W_C7_DEPLOY_IMPLEMENTATION', el, owner, 'shell:command', `${label} is a shell task without a ${prefix}:field named command; the engines refuse the file`, add ? `\`bpmn ext add <file> ${add} name=command stringValue=<command>\`.` : 'Add a command field in the XML.');
-    }
-    for (const field of fields) {
-      const name = attr(field, 'name') ?? '';
-      const fieldValue = this.fieldValue(field);
-      if ('problem' in fieldValue) continue;
-      if (fieldValue.kind === 'expression') {
-        this.push('deploy', 'W_C7_DEPLOY_IMPLEMENTATION', el, owner, `shell:${name}`, `${prefix}:field "${name}" of shell task ${label} is an expression; the shell task takes fixed values only and the engines refuse the file`, add ? `\`bpmn ext add <file> ${add} name=${sh(name)} stringValue=<value>\`.` : 'Use a stringValue.');
-      } else if (SHELL_FLAGS.includes(name) && !['true', 'false'].includes(fieldValue.value.toLowerCase())) {
-        this.push('deploy', 'W_C7_DEPLOY_IMPLEMENTATION', el, owner, `shell:${name}`, `${prefix}:field "${name}" of shell task ${label} is "${fieldValue.value}", not true or false; the engines refuse the file`, add ? `\`bpmn ext add <file> ${add} name=${name} stringValue=true\` (or false).` : 'Use true or false.');
-      }
-    }
-  }
-
-  private hasConnector(...hosts: Array<El | undefined>): boolean {
-    return hosts.some((host) => !!host && this.camundaExt(host, 'connector').length > 0);
-  }
-
-  private validTtl(ttl: string): boolean {
-    const match = /^\+?(\d+)$/.exec(ttl) ?? /^P(\d+)D$/.exec(ttl);
-    return !!match && Number(match[1]) <= TTL_MAX;
-  }
-
-  checkProcess(proc: El): void {
-    const id = idOf(proc) ?? '<processId>';
-    const ttl = this.c7(proc, 'historyTimeToLive');
-    const hint = `\`bpmn set <file> ${id} ${this.prefix}:historyTimeToLive=180\` (days, like Camunda Modeler; P180D works too).`;
-    if (!nonEmpty(ttl)) {
-      this.push('deploy', 'W_C7_DEPLOY_HISTORY_TTL', proc, undefined, 'ttl', `Executable process ${id} has no ${this.prefix}:historyTimeToLive; Camunda 7.20+, CIB seven and Operaton refuse to deploy it (ENGINE-12018)`, hint);
-    } else if (!this.validTtl(ttl)) {
-      this.push('deploy', 'W_C7_DEPLOY_HISTORY_TTL', proc, undefined, 'ttl', `${this.prefix}:historyTimeToLive="${ttl}" of process ${id} is not a number of days (or P<n>D); the engines refuse it`, hint);
-    }
-    this.checkPriorities(proc, undefined, ['jobPriority', 'taskPriority']);
-  }
-
-  /** jobPriority / taskPriority: a number or an expression, checked when the file is deployed. */
-  checkPriorities(el: El, owner: El | undefined, names: string[]): void {
-    const addr = this.addressOf(el, owner);
-    for (const name of names) {
-      const value = this.c7(el, name);
-      if (value === undefined || this.isNumber(value) || this.isExpression(value)) {
-        continue;
-      }
-      if (!this.kit.camunda.attr(name)?.owners.some((ownerType) => this.kit.is(el, ownerType))) {
-        continue;
-      }
-      this.push('deploy', 'W_C7_DEPLOY_BAD_VALUE', el, owner, `attr:${name}`, `${this.prefix}:${name}="${value}" on ${this.describe(el, owner)} is not a number or expression; the engines refuse it`, addr ? `\`bpmn set <file> ${addr.id} ${sh(`${addr.prefix}${this.prefix}:${name}=50`)}\` (an integer or \${...}).` : 'Use an integer.');
-    }
-  }
-
-  checkServiceLike(el: El): void {
-    this.checkImplementation(el, undefined, this.describe(el, undefined), { decisionRef: this.kit.is(el, 'bpmn:BusinessRuleTask') });
-  }
-
-  /**
-   * Implementation of a task, or of the message definition of a message throw / end event.
-   * Hints that add a camunda:field pass an `ext add` type argument keyed by name, so it replaces the field.
-   */
-  checkImplementation(el: El, owner: El | undefined, label: string, opts: { decisionRef?: boolean; event?: El } = {}): void {
-    const addr = this.addressOf(el, owner);
-    const set = (kv: string): string => (addr ? `\`bpmn set <file> ${addr.id} ${kv.split(' ').map((assignment) => sh(`${addr.prefix}${assignment}`)).join(' ')}\`` : 'edit the XML');
-    const type = this.c7(el, 'type');
-    const topic = this.c7(el, 'topic');
-    const external = type !== undefined && type.toLowerCase() === 'external';
-    const shell = type !== undefined && type.toLowerCase() === 'shell';
-    const prefix = this.prefix;
-    const fieldAdd = addr ? `${addr.id} ${sh(`${addr.prefix}${prefix}:field`)}` : undefined;
-    if (type !== undefined && !external && !shell) {
-      const mail = type.toLowerCase() === 'mail' ? ' (the standard engine distributions cannot load the mail task)' : '';
-      this.push('deploy', 'W_C7_DEPLOY_IMPLEMENTATION', el, owner, 'impl:type', `${prefix}:type="${type}" on ${label} is not supported (only "external" and "shell")${mail}; the engines refuse the file`, `Use an external task: ${set(`${prefix}:type=external ${prefix}:topic=<topic>`)}, or remove it: ${set(`${prefix}:type=`)}.`);
-      return;
-    }
-    if (shell) this.checkShell(el, owner, label, fieldAdd);
-    if (this.fieldsRead(el, { type })) {
-      this.checkFieldValues(el, owner, this.camundaExt(el, 'field'), label, fieldAdd);
-    }
-    const impl =
-      ['class', 'delegateExpression', 'expression'].some((attributeName) => nonEmpty(this.c7(el, attributeName))) ||
-      external ||
-      shell ||
-      this.hasConnector(el, opts.event) ||
-      (opts.decisionRef === true && this.c7(el, 'decisionRef') !== undefined);
-    if (!impl) {
-      if (opts.event) {
-        const misplaced = ['class', 'delegateExpression', 'expression', 'type', 'topic'].some((attributeName) => this.c7(opts.event, attributeName) !== undefined);
-        if (!misplaced) {
-          this.push('runtime', 'W_C7_MESSAGE_NO_IMPLEMENTATION', el, owner, 'impl', `${label} has no implementation: it sends nothing and behaves like a none event at run time`, `Give it one: ${set(`${prefix}:type=external ${prefix}:topic=<topic>`)} (or ${prefix}:delegateExpression=\${...}).`);
-        }
-        return;
-      }
-      const hint = topic !== undefined ? `It has a ${prefix}:topic but no ${prefix}:type: ${set(`${prefix}:type=external`)}.` : `Give it one: ${set(`${prefix}:type=external ${prefix}:topic=<topic>`)} (or ${prefix}:delegateExpression=\${...}, ${prefix}:class=..., ${prefix}:expression=\${...}${opts.decisionRef ? `, ${prefix}:decisionRef=<decisionId>` : ''}).`;
-      this.push('deploy', 'W_C7_DEPLOY_IMPLEMENTATION', el, owner, 'impl', `${label} has no implementation (${prefix}:class, delegateExpression, expression, type=external${opts.decisionRef ? ', decisionRef' : ''} or a connector); the engines refuse the file`, hint);
-      return;
-    }
-    if (external && topic === undefined) {
-      this.push('deploy', 'W_C7_DEPLOY_EXTERNAL_TOPIC', el, owner, 'topic', `${label} is an external task without ${prefix}:topic; the engines refuse the file`, `${set(`${prefix}:topic=<topic>`)}.`);
-    } else if (external && topic === '') {
-      this.push('runtime', 'W_C7_BAD_VALUE', el, owner, 'attr:topic', `${label} is an external task with an empty ${prefix}:topic; no worker can fetch it`, `${set(`${prefix}:topic=<topic>`)}.`);
-    }
-    if (this.c7(el, 'resultVariable') !== undefined && (nonEmpty(this.c7(el, 'class')) || nonEmpty(this.c7(el, 'delegateExpression')))) {
-      this.push('deploy', 'W_C7_DEPLOY_RESULT_VARIABLE', el, owner, 'resultVariable', `${label} combines ${prefix}:resultVariable with ${nonEmpty(this.c7(el, 'class')) ? `${prefix}:class` : `${prefix}:delegateExpression`}; the engines support a result variable only with ${prefix}:expression and refuse the file`, `Remove it: ${set(`${prefix}:resultVariable=`)} (or switch to ${prefix}:expression=\${...}).`);
-    }
-    if (external) this.checkPriorities(el, owner, ['taskPriority']);
-  }
-
-  private checkBinding(el: El, binding: string, version: string, versionTag: string | undefined, allowed: string[]): void {
-    const id = idOf(el)!;
-    const prefix = this.prefix;
-    const bindingValue = this.c7(el, binding);
-    if (bindingValue === undefined) return;
-    if (bindingValue === 'version' && this.c7(el, version) === undefined) {
-      this.push('deploy', 'W_C7_DEPLOY_BINDING_VERSION', el, undefined, binding, `${this.describe(el, undefined)} has ${prefix}:${binding}="version" but no ${prefix}:${version}; the engines refuse the file`, `\`bpmn set <file> ${id} ${prefix}:${version}=<n>\` (or \`${prefix}:${binding}=latest\`).`);
-    } else if (bindingValue === 'versionTag' && versionTag && this.c7(el, versionTag) === undefined) {
-      this.push('deploy', 'W_C7_DEPLOY_BINDING_VERSION', el, undefined, binding, `${this.describe(el, undefined)} has ${prefix}:${binding}="versionTag" but no ${prefix}:${versionTag}; the engines refuse the file`, `\`bpmn set <file> ${id} ${prefix}:${versionTag}=<tag>\` (or \`${prefix}:${binding}=latest\`).`);
-    } else if (!allowed.includes(bindingValue)) {
-      this.push('runtime', 'W_C7_BAD_VALUE', el, undefined, `attr:${binding}`, `${prefix}:${binding}="${bindingValue}" on ${this.describe(el, undefined)} is not one of ${allowed.join(', ')}; the engines accept the file but cannot resolve the reference as intended`, `\`bpmn set <file> ${id} ${prefix}:${binding}=latest\`.`);
-    }
-  }
-
-  checkCallActivity(el: El): void {
-    const id = idOf(el)!;
-    const prefix = this.prefix;
-    const called = peek<string>(el, 'calledElement');
-    const caseRef = this.c7(el, 'caseRef');
-    if (called === undefined && caseRef === undefined) {
-      this.push('deploy', 'W_C7_DEPLOY_CALLED_ELEMENT', el, undefined, 'calledElement', `Call activity ${id} has no calledElement (nor ${prefix}:caseRef); the engines refuse the file`, `\`bpmn set <file> ${id} calledElement=<processId>\`.`);
-    } else if (called !== undefined && caseRef !== undefined) {
-      this.push('deploy', 'W_C7_DEPLOY_CALLED_ELEMENT', el, undefined, 'calledElement+caseRef', `Call activity ${id} has both calledElement and ${prefix}:caseRef; the engines refuse the file`, `Keep one: \`bpmn set <file> ${id} ${prefix}:caseRef=\`.`);
-    } else if (called === '') {
-      this.push('runtime', 'W_C7_BAD_VALUE', el, undefined, 'attr:calledElement', `Call activity ${id} has an empty calledElement; it fails when it runs`, `\`bpmn set <file> ${id} calledElement=<processId>\`.`);
-    }
-    this.checkBinding(el, 'calledElementBinding', 'calledElementVersion', 'calledElementVersionTag', BINDINGS);
-    this.checkBinding(el, 'caseBinding', 'caseVersion', undefined, CASE_BINDINGS);
-  }
-
-  checkBusinessRule(el: El): void {
-    if (this.c7(el, 'decisionRef') === undefined) return;
-    this.checkBinding(el, 'decisionRefBinding', 'decisionRefVersion', 'decisionRefVersionTag', BINDINGS);
-    const map = this.c7(el, 'mapDecisionResult');
-    if (map !== undefined && !DECISION_MAPPERS.includes(map)) {
-      this.push('deploy', 'W_C7_DEPLOY_BAD_VALUE', el, undefined, 'attr:mapDecisionResult', `${this.prefix}:mapDecisionResult="${map}" on ${this.describe(el, undefined)} is not one of ${DECISION_MAPPERS.join(', ')}; the engines refuse the file`, `\`bpmn set <file> ${idOf(el)} ${this.prefix}:mapDecisionResult=singleEntry\` (or another of the four).`);
-    }
-  }
-
-  checkForms(el: El): void {
-    const id = idOf(el)!;
-    const prefix = this.prefix;
-    const formRef = this.c7(el, 'formRef');
-    if (formRef === undefined) return;
-    if (this.c7(el, 'formKey') !== undefined) {
-      this.push('deploy', 'W_C7_DEPLOY_FORM', el, undefined, 'formKey+formRef', `${this.describe(el, undefined)} has both ${prefix}:formKey and ${prefix}:formRef; the engines refuse the file`, `Keep one: \`bpmn set <file> ${id} ${prefix}:formKey=\` (or ${prefix}:formRef=).`);
-    }
-    const binding = this.c7(el, 'formRefBinding');
-    if (binding === undefined || !FORM_BINDINGS.includes(binding)) {
-      this.push('deploy', 'W_C7_DEPLOY_FORM', el, undefined, 'formRefBinding', `${this.describe(el, undefined)} has ${prefix}:formRef but ${binding === undefined ? `no ${prefix}:formRefBinding` : `${prefix}:formRefBinding="${binding}"`} (one of ${FORM_BINDINGS.join(', ')} is required); the engines refuse the file`, `\`bpmn set <file> ${id} ${prefix}:formRefBinding=latest\`.`);
-    } else if (binding === 'version' && this.c7(el, 'formRefVersion') === undefined) {
-      this.push('deploy', 'W_C7_DEPLOY_BINDING_VERSION', el, undefined, 'formRefBinding', `${this.describe(el, undefined)} has ${prefix}:formRefBinding="version" but no ${prefix}:formRefVersion; the engines refuse the file`, `\`bpmn set <file> ${id} ${prefix}:formRefVersion=<n>\` (or ${prefix}:formRefBinding=latest).`);
-    }
-  }
-
-  /** Checks the multi-instance settings; the engines read loopDataInputRef as a variable name, so one bpmn-moddle reported on import counts as set. */
-  checkMultiInstance(activity: El): void {
-    const loop = peek<El>(activity, 'loopCharacteristics');
-    if (!this.kit.is(loop, 'bpmn:MultiInstanceLoopCharacteristics')) return;
-    const id = idOf(activity)!;
-    const prefix = this.prefix;
-    const card = peek<El>(loop, 'loopCardinality');
-    const collection = this.c7(loop, 'collection');
-    const dataInput = peek<unknown>(loop, 'loopDataInputRef') ?? this.doc.importWarnings.some((warning) => (warning as { element?: unknown }).element === loop && /loopDataInputRef/.test(String((warning as { property?: unknown }).property ?? '')));
-    const elementVariable = this.c7(loop, 'elementVariable');
-    if (!card && collection === undefined && !dataInput) {
-      const misplaced = this.c7(activity, 'collection');
-      const message = `Multi-instance ${this.describe(activity, undefined)} has neither a loop cardinality nor ${prefix}:collection${misplaced !== undefined ? ` (${prefix}:collection sits on the activity, not on the loop)` : ''}; the engines refuse the file`;
-      const hint =
-        misplaced !== undefined
-          ? `Move it onto the loop: \`bpmn set <file> ${id} ${prefix}:collection= ${sh(`loop.${prefix}:collection=${misplaced}`)}${this.c7(activity, 'elementVariable') !== undefined ? ` ${prefix}:elementVariable= ${sh(`loop.${prefix}:elementVariable=${this.c7(activity, 'elementVariable')}`)}` : ''}\`.`
-          : `\`bpmn set <file> ${id} ${sh(`loop.${prefix}:collection=\${items}`)} loop.${prefix}:elementVariable=item\` (or \`bpmn set <file> ${id} cardinality=3\`).`;
-      this.push('deploy', 'W_C7_DEPLOY_MULTI_INSTANCE', activity, undefined, 'mi', message, hint);
-      return;
-    }
-    if (card && !nonEmpty(peek<string>(card, 'body')) && collection === undefined && !dataInput) {
-      this.push('deploy', 'W_C7_DEPLOY_MULTI_INSTANCE', activity, undefined, 'mi:cardinality', `Multi-instance ${this.describe(activity, undefined)} has an empty loop cardinality; the engines refuse the file`, `\`bpmn set <file> ${id} cardinality=3\` (a number or \${...}).`);
-    }
-    if (elementVariable !== undefined && collection === undefined && !dataInput) {
-      this.push('deploy', 'W_C7_DEPLOY_MULTI_INSTANCE', activity, undefined, 'mi:elementVariable', `Multi-instance ${this.describe(activity, undefined)} has ${prefix}:elementVariable but no ${prefix}:collection; the engines refuse the file`, `\`bpmn set <file> ${id} ${sh(`loop.${prefix}:collection=\${items}`)}\` (or remove it: \`bpmn set <file> ${id} loop.${prefix}:elementVariable=\`).`);
-    }
-  }
-
-  checkScriptTask(el: El): void {
-    if (nonEmpty(peek<string>(el, 'script')) || this.c7(el, 'resource') !== undefined) {
-      return;
-    }
-    this.push('deploy', 'W_C7_DEPLOY_SCRIPT', el, undefined, 'script', `Script task ${idOf(el)} has neither a script nor ${this.prefix}:resource; the engines refuse the file`, `\`bpmn set <file> ${idOf(el)} scriptFormat=groovy ${sh('script=...')}\` (or ${this.prefix}:resource=deployment://<file>).`);
-  }
-
-  checkUserTaskPriority(el: El): void {
-    const priority = this.c7(el, 'priority');
-    if (priority === undefined || this.isNumber(priority) || this.isExpression(priority)) {
-      return;
-    }
-    this.push('runtime', 'W_C7_BAD_VALUE', el, undefined, 'attr:priority', `${this.prefix}:priority="${priority}" on ${this.describe(el, undefined)} is not a number or expression; creating the task fails`, `\`bpmn set <file> ${idOf(el)} ${this.prefix}:priority=50\`.`);
-  }
-}
diff --git a/src/domain/validation/profiles/c7/C7Rules.ts b/src/domain/validation/profiles/c7/C7Rules.ts
deleted file mode 100644
index 8b1136a7..00000000
--- a/src/domain/validation/profiles/c7/C7Rules.ts
+++ /dev/null
@@ -1,161 +0,0 @@
-import type { El } from '../../../document/utils/moddle.js';
-import { EngineRules, type Address } from '../EngineRules.js';
-import { attr, idOf, isGeneric, list, localName, peek } from '../../utils/element.js';
-import { lowerFirst, sh, slotted } from '../../utils/hint.js';
-import { nonEmpty } from '../../utils/value.js';
-import { extAddArgs } from '../../utils/c7-hint.js';
-
-export const SERVICE_LIKE = ['bpmn:ServiceTask', 'bpmn:SendTask', 'bpmn:BusinessRuleTask'];
-
-/** Attributes that pick one item of a repeatable type, in the order a selector prefers them. */
-const SELECTOR_KEYS = ['id', 'name', 'event', 'target', 'source', 'errorRef'];
-
-/**
- * Base of the Camunda 7 rule classes (also CIB seven and Operaton): how the engines read
- * camunda content and event definitions, and how hints address it.
- */
-export abstract class C7Rules extends EngineRules {
-  protected override addressOf(el: El, owner: El | undefined): Address | undefined {
-    if (owner && el !== owner && !idOf(owner)) return undefined;
-    return super.addressOf(el, owner);
-  }
-
-  /** `userTask userTask_x`, `the multiInstanceLoopCharacteristics of userTask userTask_x` */
-  protected describe(el: El, owner: El | undefined): string {
-    const id = idOf(el);
-    const kind = this.kit.isBpmnElement(el) ? this.kit.kindLabel(el).replace(/^bpmn:/, '') : el.$type;
-    const kindName = lowerFirst(kind);
-    if (id) return `${kindName} ${id}`;
-    return owner ? `the ${kindName} of ${this.describe(owner, undefined)}` : kindName;
-  }
-
-  /**
-   * Value of the camunda attribute `local` of a BPMN element. An operaton:* attribute wins
-   * over the camunda one, like Operaton reads them (Camunda 7 and CIB seven ignore it).
-   */
-  protected c7(el: El | undefined, local: string): string | undefined {
-    if (!el) return undefined;
-    let fallback: string | undefined;
-    for (const [key, rawValue] of Object.entries(el.$attrs ?? {})) {
-      if (key.slice(key.indexOf(':') + 1) !== local) continue;
-      const uri = this.ns.uriOfName(key);
-      if (!this.kit.camunda.reads(uri)) continue;
-      const value = rawValue === undefined || rawValue === null ? undefined : String(rawValue);
-      if (uri === this.kit.OPERATON_URI) return value;
-      fallback ??= value;
-    }
-    return fallback;
-  }
-
-  /** Top-level camunda extension elements of type `local`. */
-  protected camundaExt(el: El, local: string): El[] {
-    return this.extensionValues(el)
-      .filter((extValue) => extValue.uri && this.kit.camunda.reads(extValue.uri) && extValue.local === local)
-      .map((extValue) => extValue.el);
-  }
-
-  protected children(el: El, local?: string): El[] {
-    const kids = peek<unknown[]>(el, '$children');
-    if (!Array.isArray(kids)) return [];
-    return (kids as El[]).filter((child) => {
-      if (!child || typeof child !== 'object' || typeof child.$type !== 'string' || !isGeneric(child)) {
-        return false;
-      }
-      const uri = this.ns.uriOfElement(child);
-      return this.kit.camunda.reads(uri) && (local === undefined || localName(child.$type) === local);
-    });
-  }
-
-  protected isMultiInstance(el: El | undefined): boolean {
-    return this.kit.is(peek<El>(el, 'loopCharacteristics'), 'bpmn:MultiInstanceLoopCharacteristics');
-  }
-
-  /** `ext remove` selector of a top-level extension element: a unique attribute, else its index. */
-  protected selectorOf(host: El, vendorElement: El): string {
-    const same = this.extensionValues(host)
-      .map((extValue) => extValue.el)
-      .filter((element) => element.$type === vendorElement.$type);
-    for (const key of SELECTOR_KEYS) {
-      const val = attr(vendorElement, key);
-      if (val === undefined || val === '' || same.filter((sibling) => attr(sibling, key) === val).length !== 1) {
-        continue;
-      }
-      return `${vendorElement.$type}[${key}=${/^[\w.:-]+$/.test(val) ? val : `"${val.replace(/"/g, '\\"')}"`}]`;
-    }
-    return `${vendorElement.$type}[${Math.max(0, same.indexOf(vendorElement))}]`;
-  }
-
-  /**
-   * How to rebuild the top-level extension element `v` of `host`. A single-instance type is
-   * replaced as a whole (`--replace`); a repeatable one is removed by its own selector and added
-   * again, as `--replace` would remove its siblings. `fix` puts placeholders in for attributes.
-   */
-  protected extHint(host: El, owner: El | undefined, vendorElement: El, local: string, fix: Record<string, string> = {}): string {
-    const addr = this.addressOf(host, owner);
-    if (!addr) return 'Fix it in the XML.';
-    const slot = addr.prefix;
-    const type = vendorElement.$type;
-    if (this.kit.camunda.isSingle(local)) {
-      return `See it with \`bpmn ext list <file> ${addr.id} --json\`, then rebuild it: \`bpmn ext add <file> ${addr.id} ${slotted(slot, type)} --replace --xml '<${type}>...</${type}>'\`.`;
-    }
-    const flat = extAddArgs(vendorElement, type, fix);
-    const again = flat ? `\`bpmn ext add <file> ${addr.id} ${slotted(slot, flat)}\`` : `\`bpmn ext add <file> ${addr.id} ${slotted(slot, type)} --xml '<${type} ...>...</${type}>'\` (\`bpmn ext list <file> ${addr.id} --json\` shows it)`;
-    return `Replace just this one (--replace would remove every ${type}): \`bpmn ext remove <file> ${addr.id} ${sh(`${slot}${this.selectorOf(host, vendorElement)}`)}\`, then ${again}.`;
-  }
-
-  /**
-   * The order in which the engines pick the one event definition they act on when an event has
-   * several (engine-checked, each pair in both XML orders): the first kind present wins, the others
-   * are not even parsed. Undefined where the order is not known (every definition is checked then).
-   */
-  private actingOrder(el: El): string[] | undefined {
-    if (this.kit.is(el, 'bpmn:IntermediateCatchEvent')) {
-      return ['Timer', 'Signal', 'Message', 'Link', 'Conditional'];
-    }
-    if (this.kit.is(el, 'bpmn:BoundaryEvent')) {
-      return ['Timer', 'Signal', 'Message', 'Conditional'];
-    }
-    if (this.kit.is(el, 'bpmn:IntermediateThrowEvent')) {
-      return ['Signal', 'Message'];
-    }
-    if (this.kit.is(el, 'bpmn:EndEvent')) return ['Message', 'Signal'];
-    if (this.kit.is(el, 'bpmn:StartEvent')) {
-      const parent = el.$parent as El | undefined;
-      if (parent && this.kit.isEventSubProcess(parent)) {
-        return ['Message', 'Signal', 'Timer', 'Conditional'];
-      }
-      if (parent && this.kit.is(parent, 'bpmn:Process')) {
-        return ['Timer', 'Message', 'Signal', 'Conditional'];
-      }
-    }
-    return undefined;
-  }
-
-  /** The definition the engines act on when `el` has several (undefined: one, or order unknown). */
-  protected actingDefinition(el: El): El | undefined {
-    const defs = list(el, 'eventDefinitions');
-    const order = defs.length > 1 ? this.actingOrder(el) : undefined;
-    if (!order) return undefined;
-    const kinds = defs.map((definition) => order.findIndex((kind) => this.kit.is(definition, `bpmn:${kind}EventDefinition`)));
-    if (kinds.some((kind) => kind === -1)) return undefined;
-    return defs[kinds.indexOf(Math.min(...kinds))];
-  }
-
-  /** The event definitions the engines read: the acting one of several, else all. */
-  protected actedOn(el: El): El[] {
-    const acting = this.actingDefinition(el);
-    return acting ? [acting] : list(el, 'eventDefinitions');
-  }
-
-  protected definitionOf(el: El, type: string): El | undefined {
-    return this.actedOn(el).find((definition) => this.kit.is(definition, type));
-  }
-
-  /**
-   * A condition the engines cannot evaluate: no expression text (blank counts) and no script
-   * resource. They deploy it; evaluating it fails.
-   */
-  protected emptyCondition(expr: El): boolean {
-    return !nonEmpty(peek<string>(expr, 'body')) && !nonEmpty(this.c7(expr, 'resource'));
-  }
-}
diff --git a/src/domain/validation/profiles/c7/C7SchemaRules.ts b/src/domain/validation/profiles/c7/C7SchemaRules.ts
deleted file mode 100644
index fd44323a..00000000
--- a/src/domain/validation/profiles/c7/C7SchemaRules.ts
+++ /dev/null
@@ -1,80 +0,0 @@
-import type { El } from '../../../document/utils/moddle.js';
-import { idOf, list, peek, TIMER_ELEMENTS, triggerName } from '../../utils/element.js';
-import { sh } from '../../utils/hint.js';
-import { C7Rules } from './C7Rules.js';
-
-/**
- * What the BPMN schema refuses anywhere in the file: the engines validate the whole file against
- * it, non-executable processes, ignored event definitions and the diagram included.
- */
-export class C7SchemaRules extends C7Rules {
-  /**
-   * Attributes without a namespace prefix that BPMN does not define (cvc-complex-type.3.2.2);
-   * vendor attributes need their prefix.
-   */
-  checkSchemaAttributes(): void {
-    for (const { el, owner, id, di, addr, keys } of this.unprefixedAttributes()) {
-      for (const key of keys) {
-        const vendor = this.kit.camunda.attr(key);
-        const fits = !!vendor && vendor.owners.some((ownerType) => this.kit.is(el, ownerType)) && !!id && el === owner;
-        const where = el === owner ? this.describe(el, undefined) : `${el.$type}${id ? ` in ${id}` : ''}`;
-        const remove = addr ? `\`bpmn set <file> ${addr.id} ${sh(`${addr.prefix}${key}=`)}\`` : undefined;
-        /**
-         * an unprefixed decision link (bpmn-cli's calledDecision, or calledElement read as one):
-         * `set calledDecision=` writes the engines' spelling, unless another implementation stays
-         */
-        const implemented = Object.keys(el.$attrs ?? {}).some((attributeName) => /^[\w.-]+:(class|delegateExpression|expression|type)$/.test(attributeName) && this.kit.camunda.reads(this.ns.uriOfName(attributeName)));
-        const link = el === owner && !!id && !implemented && this.kit.is(el, 'bpmn:BusinessRuleTask') && (key === 'calledDecision' || key === 'calledElement') ? new this.kit.DecisionLinkReader(this.doc).linkOf(el) : undefined;
-        const hint = link
-          ? `Write the decision link in the engines' spelling: \`bpmn set <file> ${id} ${sh(`calledDecision=${link.value}`)}\` (${this.prefix}:decisionRef; the unprefixed ${key} is removed).`
-          : fits
-          ? `Use the vendor attribute instead: \`bpmn set <file> ${id} ${sh(`${key}=`)} ${sh(`${this.prefix}:${key}=${String(el.$attrs[key] ?? '')}`)}\`.`
-          : remove
-            ? `Remove it: ${remove} (vendor attributes need their namespace prefix, e.g. ${this.prefix}:<name>).`
-            : di
-              ? `Remove ${key}="..." from the XML of ${id ?? 'the diagram element'}, or redraw the diagram, which writes new diagram elements: \`bpmn layout <file>\` (the hand-made layout is lost).`
-              : `Remove ${key}="..." from the XML${id ? ` of ${id}` : ''} (vendor attributes need their namespace prefix, e.g. ${this.prefix}:<name>).`;
-        this.push('deploy', 'W_C7_DEPLOY_SCHEMA', el, owner, `schema:${key}`, `${where} has the attribute ${key}, which the BPMN schema does not define${fits ? ` (did you mean ${this.prefix}:${key}?)` : ''}; the engines validate the file against the schema and refuse it`, hint);
-      }
-    }
-  }
-
-  /**
-   * What the schema requires of every event definition, also one the engines would ignore: a
-   * conditional definition has a condition, a link definition a name, a timer at most one of
-   * timeDate, timeCycle and timeDuration.
-   * A message names `Conditional event X`, or among several definitions `The conditional definition of <event>`.
-   */
-  checkSchemaEventDefinitions(): void {
-    for (const def of this.kit.walk(this.doc.definitions, { bpmnOnly: true })) {
-      if (!this.kit.is(def, 'bpmn:EventDefinition')) continue;
-      const parent = def.$parent as El | undefined;
-      const event = parent && this.kit.is(parent, 'bpmn:Event') && idOf(parent) ? parent : undefined;
-      const id = idOf(event);
-      const defs = list(event, 'eventDefinitions');
-      const subject = defs.length > 1 ? `#${defs.indexOf(def)}` : '';
-      /** the fix, or how to drop this definition when the engines act on another one */
-      const fix = (cmd: string, keeps: string): string => {
-        if (!id) return 'Fix it in the XML.';
-        if (defs.length < 2) {
-          return `\`bpmn set <file> ${id} ${cmd}\`${keeps ? ` (${keeps})` : ''}.`;
-        }
-        const acting = this.actingDefinition(event!);
-        const only = `\`bpmn set <file> ${id} ${cmd}\` (keeps only the ${triggerName(def)} definition)`;
-        if (!acting || acting === def) return `${only}.`;
-        return `The engines act on the ${triggerName(acting)} definition and ignore this one, but they validate it too: drop it with \`bpmn set <file> ${id} trigger=${triggerName(acting)}\` (keeps only the ${triggerName(acting)}), or ${only}.`;
-      };
-      const label = id ? this.describe(event!, undefined) : `${def.$type}${idOf(def) ? ` ${idOf(def)}` : ''}`;
-      const what = (single: string): string => (defs.length > 1 ? `The ${triggerName(def)} definition of ${label}` : id ? `${single} ${id}` : label);
-      if (this.kit.is(def, 'bpmn:ConditionalEventDefinition') && !peek<El>(def, 'condition')) {
-        this.push('deploy', 'W_C7_DEPLOY_EVENT_DEFINITION', event ?? def, undefined, `condition${subject}`, `${what('Conditional event')} has no condition element, which the BPMN schema requires; the engines refuse the file`, fix(sh('when=${expression}'), ''));
-      } else if (this.kit.is(def, 'bpmn:LinkEventDefinition') && (peek<string>(def, 'name') === undefined || peek<string>(def, 'name') === null)) {
-        this.push('deploy', 'W_C7_DEPLOY_LINK', event ?? def, undefined, `link:name${subject}`, `${what('Link event')} has no link name, which the BPMN schema requires; the engines refuse the file`, fix('link=<Name>', 'the throw and the catch event of a pair share the name'));
-      } else if (this.kit.is(def, 'bpmn:TimerEventDefinition')) {
-        const set = TIMER_ELEMENTS.filter((timerKind) => peek<El>(def, timerKind));
-        if (set.length < 2) continue;
-        this.push('deploy', 'W_C7_DEPLOY_EVENT_DEFINITION', event ?? def, undefined, `timer:elements${subject}`, `${what('Timer event')} has ${set.join(' and ')}; the BPMN schema allows only one of timeDate, timeCycle and timeDuration, and the engines refuse the file`, fix('timer=<value>', 'R/PT1H is a cycle, PT1H a duration, else a date; the other elements go'));
-      }
-    }
-  }
-}
diff --git a/src/domain/validation/profiles/c8/C8EventRules.ts b/src/domain/validation/profiles/c8/C8EventRules.ts
deleted file mode 100644
index 87d3e30a..00000000
--- a/src/domain/validation/profiles/c8/C8EventRules.ts
+++ /dev/null
@@ -1,445 +0,0 @@
-import type { El } from '../../../document/utils/moddle.js';
-import { LinkEvents } from '../LinkEvents.js';
-import type { RuleRun } from '../RuleRun.js';
-import { TimerValue } from '../TimerValue.js';
-import { attr, idOf, list, localName, nameOf, peek, TIMER_ELEMENTS, triggerName } from '../../utils/element.js';
-import { sh } from '../../utils/hint.js';
-import { blank, feelOf, isFeel, missing, nameAttr } from '../../utils/c8-value.js';
-import { C8Rules } from './C8Rules.js';
-import type { C8TaskRules } from './C8TaskRules.js';
-
-/** Events and their triggers: definitions, timers, subscriptions, errors, links, start events. */
-export class C8EventRules extends C8Rules {
-  constructor(
-    run: RuleRun,
-    prefix: string,
-    private readonly tasks: C8TaskRules,
-  ) {
-    super(run, prefix);
-  }
-
-  private nonInterrupting(el: El): boolean {
-    if (this.kit.is(el, 'bpmn:BoundaryEvent')) {
-      return peek<boolean>(el, 'cancelActivity') === false;
-    }
-    if (this.kit.is(el, 'bpmn:StartEvent')) {
-      return peek<boolean>(el, 'isInterrupting') === false;
-    }
-    return false;
-  }
-
-  checkBoundaryHost(el: El): void {
-    const host = peek<El>(el, 'attachedToRef');
-    if (host && peek<boolean>(host, 'isForCompensation') === true) {
-      this.push('deploy', 'W_C8_DEPLOY_BOUNDARY_HOST', el, undefined, 'compensationHost', `Boundary event ${idOf(el)} is attached to the compensation handler ${idOf(host)}; Camunda 8 refuses boundary events on compensation handlers`, `Remove it: \`bpmn remove <file> ${idOf(el)}\` (or attach it to a normal activity: \`bpmn move <file> ${idOf(el)} --on <activityId>\`).`, [idOf(host)!]);
-    }
-  }
-
-  /**
-   * Checks a timer definition. Two timer kinds on one definition are left to the schema error
-   * the engine reports first; a value that fails tells the right form without a real date-time
-   * or with a cron field out of its range apart.
-   */
-  private checkTimer(el: El, def: El): void {
-    const id = idOf(el)!;
-    const label = this.describe(el);
-    const kinds = TIMER_ELEMENTS.filter((timerKind) => peek<El>(def, timerKind));
-    if (kinds.length !== 1) {
-      if (!kinds.length) {
-        this.push('deploy', 'W_C8_DEPLOY_TIMER', el, undefined, 'timer', `Timer of ${label} has no date, cycle or duration; Camunda 8 refuses the file`, `\`bpmn set <file> ${id} timer=PT1H\` (a duration; R/PT1H is a cycle, an ISO date-time with offset a date).`);
-      }
-      return;
-    }
-    const kind = kinds[0]!;
-    const value = (peek<string>(peek<El>(def, kind), 'body') ?? '').trim();
-    const catchEvent = this.kit.is(el, 'bpmn:IntermediateCatchEvent');
-    if (kind === 'timeCycle' && catchEvent) {
-      this.push('deploy', 'W_C8_DEPLOY_TIMER', el, undefined, 'timer:cycle', `Timer catch event ${id} has a cycle; Camunda 8 allows only a duration or a date on intermediate timer catch events and refuses the file`, `\`bpmn set <file> ${id} timer=PT1H\` (a duration, or a date-time).`);
-      return;
-    }
-    if (kind === 'timeCycle' && (this.kit.is(el, 'bpmn:BoundaryEvent') || (this.kit.is(el, 'bpmn:StartEvent') && this.kit.isEventSubProcess(el.$parent as El))) && !this.nonInterrupting(el)) {
-      this.push('deploy', 'W_C8_DEPLOY_TIMER', el, undefined, 'timer:interruptingCycle', `${label} is an interrupting timer with a cycle; Camunda 8 refuses interrupting cycles`, `Make it non-interrupting (\`bpmn set <file> ${id} nonInterrupting=true\`) or use a duration (\`bpmn set <file> ${id} timer=PT1H\`).`);
-    }
-    if (isFeel(value) || value === '') {
-      this.checkFeel(el, undefined, 'timer', `The ${kind} of ${label}`, value, `\`bpmn set <file> ${id} ${sh('timer==<FEEL expression>')}\` (check the FEEL syntax).`);
-      if (value === '') {
-        this.push('deploy', 'W_C8_DEPLOY_TIMER', el, undefined, 'timer:value', `The ${kind} of ${label} is empty; Camunda 8 refuses the file`, `\`bpmn set <file> ${id} timer=PT1H\`.`);
-      }
-      return;
-    }
-    const timer = new TimerValue(value);
-    const ok = kind === 'timeDuration' ? timer.isDuration() : kind === 'timeDate' ? timer.isDateTime() : timer.isCycle();
-    const range = ok ? undefined : kind === 'timeDate' ? timer.dateTimeRangeProblem() : kind === 'timeCycle' ? timer.cycleRangeProblem() : undefined;
-    if (range) {
-      this.push('deploy', 'W_C8_DEPLOY_TIMER', el, undefined, 'timer:value', `The ${kind} "${value}" of ${label} is no valid ${kind === 'timeDate' || !/^\S+( +\S+){5}$/.test(value) ? 'date-time' : 'cron expression'}: ${range}; Camunda 8 refuses the file`, `\`bpmn set <file> ${id} ${sh(`timer=${kind === 'timeDate' ? '2030-12-31T10:00:00Z' : 'R/PT1H'}`)}\` (with a value in range).`);
-    } else if (!ok) {
-      const expected = kind === 'timeDuration' ? 'an ISO 8601 duration (PT1H, P2D)' : kind === 'timeDate' ? 'an ISO 8601 date-time with offset (2030-12-31T10:00:00Z, ...+01:00)' : 'a repeating interval (R/PT1H, R5/2030-01-01T08:00:00Z/P1D) or a 6-field cron expression (0 0 9 * * MON)';
-      this.push('deploy', 'W_C8_DEPLOY_TIMER', el, undefined, 'timer:value', `The ${kind} "${value}" of ${label} is not ${expected}; Camunda 8 refuses the file`, `\`bpmn set <file> ${id} ${sh(`timer=${kind === 'timeDuration' ? 'PT1H' : kind === 'timeDate' ? '2030-12-31T10:00:00Z' : 'R/PT1H'}`)}\` (or a FEEL expression: ${sh('timer==<expression>')} with --timer-kind ${kind.replace('time', '').toLowerCase()}).`);
-    }
-  }
-
-  checkEvent(el: El): void {
-    const defs = list(el, 'eventDefinitions');
-    if (defs.length > 1) {
-      const id = idOf(el)!;
-      this.push('deploy', 'W_C8_DEPLOY_EVENT_DEFINITION', el, undefined, 'definitions', `${this.describe(el)} has ${defs.length} event definitions (${defs.map(triggerName).join(', ')}); Camunda 8 allows one and refuses the file`, `Keep one: \`bpmn set <file> ${id} trigger=<${defs.map(triggerName).join('|')}>\` (keeps that definition, drops the others), and model each other trigger as its own event.`);
-      return;
-    }
-    const def = defs[0];
-    if (!def) {
-      this.checkMissingDefinition(el);
-      return;
-    }
-    if (this.reportUnsupportedPosition(el, def)) return;
-    this.checkDefinitionId(el, def);
-    this.checkDefinition(el, def);
-  }
-
-  private checkMissingDefinition(el: El): void {
-    const id = idOf(el)!;
-    const parent = el.$parent as El | undefined;
-    if (this.kit.is(el, 'bpmn:IntermediateCatchEvent') || this.kit.is(el, 'bpmn:BoundaryEvent')) {
-      this.push('deploy', 'W_C8_DEPLOY_EVENT_DEFINITION', el, undefined, 'none', `${this.describe(el)} has no event definition; Camunda 8 refuses ${this.kit.is(el, 'bpmn:BoundaryEvent') ? 'boundary' : 'intermediate catch'} events without a trigger`, `Give it one: \`bpmn set <file> ${id} trigger=timer timer=PT1H\` (or message, signal, ...).`);
-    }
-    if (this.kit.is(el, 'bpmn:StartEvent') && this.kit.isEventSubProcess(parent)) {
-      this.push('deploy', 'W_C8_DEPLOY_EVENT_DEFINITION', el, undefined, 'eventSubStart', `Start event ${id} of event sub-process ${idOf(parent)} has no trigger; Camunda 8 needs a message, timer, error, signal, escalation or conditional start there and refuses the file`, `\`bpmn set <file> ${id} trigger=message message=<MessageName>\` (or timer, error, signal, escalation, conditional).`);
-    }
-  }
-
-  /** Definition kinds a position does not support; true when one was reported. */
-  private reportUnsupportedPosition(el: El, def: El): boolean {
-    const id = idOf(el)!;
-    const parent = el.$parent as El | undefined;
-    const trigger = triggerName(def);
-    if (this.kit.is(def, 'bpmn:CancelEventDefinition')) {
-      this.push('deploy', 'W_C8_DEPLOY_UNSUPPORTED', el, undefined, 'cancel', `${this.describe(el)} is a cancel event; Camunda 8 does not support cancel events (nor transactions) and refuses the file`, `\`bpmn set <file> ${id} trigger=${this.kit.is(el, 'bpmn:BoundaryEvent') ? 'error' : 'none'}\`${this.kit.is(el, 'bpmn:BoundaryEvent') ? ' (an error boundary event)' : ''}.`);
-      return true;
-    }
-    if (!this.kit.is(el, 'bpmn:StartEvent')) return false;
-    if (parent && this.kit.is(parent, 'bpmn:SubProcess') && !this.kit.isEventSubProcess(parent) && !this.kit.is(parent, 'bpmn:AdHocSubProcess')) {
-      this.push('deploy', 'W_C8_DEPLOY_START_EVENT', el, undefined, 'subStartType', `Start event ${id} of sub-process ${idOf(parent)} has a ${trigger} trigger; Camunda 8 allows only a none start event in an embedded sub-process and refuses the file`, `\`bpmn set <file> ${id} trigger=none\` (an event sub-process takes triggered starts: \`bpmn add <file> eventSubProcess:${trigger} ... --in ${idOf(parent)}\`).`);
-      return true;
-    }
-    if (this.kit.isEventSubProcess(parent) && this.kit.is(def, 'bpmn:CompensateEventDefinition')) {
-      this.push('deploy', 'W_C8_DEPLOY_EVENT_DEFINITION', el, undefined, 'eventSubStart', `Start event ${id} of event sub-process ${idOf(parent)} has a compensation trigger; Camunda 8 needs a message, timer, error, signal, escalation or conditional start there and refuses the file`, `\`bpmn set <file> ${id} trigger=<message|timer|error|signal|escalation|conditional>\`.`);
-      return true;
-    }
-    return false;
-  }
-
-  /** Definitions the engine needs an id on (8.9 fails on them otherwise). */
-  private checkDefinitionId(el: El, def: El): void {
-    const needsId = this.kit.is(def, 'bpmn:ConditionalEventDefinition') || this.kit.is(def, 'bpmn:CompensateEventDefinition') || (this.kit.is(def, 'bpmn:LinkEventDefinition') && this.kit.is(el, 'bpmn:CatchEvent'));
-    if (!needsId || idOf(def)) return;
-    const id = idOf(el)!;
-    this.push('deploy', 'W_C8_DEPLOY_EVENT_DEFINITION', el, undefined, 'definitionId', `The ${triggerName(def)} event definition of ${this.describe(el)} has no id; Camunda 8.9 refuses the file (an internal error: "Cannot invoke String.getBytes ... value is null")`, `\`bpmn set <file> ${id} definition.id=${localName(def.$type)}_${id.replace(/^[A-Za-z]+_/, '')}\` (Camunda Modeler gives every event definition an id).`);
-  }
-
-  private checkDefinition(el: El, def: El): void {
-    if (this.kit.is(def, 'bpmn:MessageEventDefinition')) {
-      this.checkMessageDefinition(el, def);
-    } else if (this.kit.is(def, 'bpmn:TimerEventDefinition')) {
-      this.checkTimer(el, def);
-    } else if (this.kit.is(def, 'bpmn:SignalEventDefinition')) {
-      this.checkSignalDefinition(el, def);
-    } else if (this.kit.is(def, 'bpmn:ErrorEventDefinition')) {
-      this.checkErrorDefinition(el, def);
-    } else if (this.kit.is(def, 'bpmn:EscalationEventDefinition')) {
-      this.checkEscalationDefinition(el, def);
-    } else if (this.kit.is(def, 'bpmn:CompensateEventDefinition')) {
-      this.checkCompensateDefinition(el, def);
-    } else if (this.kit.is(def, 'bpmn:ConditionalEventDefinition')) {
-      this.checkConditionalDefinition(el, def);
-    }
-  }
-
-  private checkMessageDefinition(el: El, def: El): void {
-    if (this.kit.is(el, 'bpmn:ThrowEvent')) {
-      this.tasks.checkMessageThrow(el, def);
-    } else {
-      this.checkMessageCatch(el);
-    }
-  }
-
-  private checkSignalDefinition(el: El, def: El): void {
-    const id = idOf(el)!;
-    const label = this.describe(el);
-    const sig = peek<El>(def, 'signalRef');
-    if (!sig) {
-      this.push('deploy', 'W_C8_DEPLOY_SIGNAL', el, undefined, 'signalRef', `${label} has no signal; Camunda 8 refuses the file`, `\`bpmn set <file> ${id} signal=<SignalName>\`.`);
-    } else if (!nameAttr(sig)) {
-      this.push('deploy', 'W_C8_DEPLOY_SIGNAL', el, undefined, 'signalName', `Signal ${idOf(sig)} of ${label} has no name; Camunda 8 refuses the file`, `\`bpmn set <file> ${idOf(sig)} name=<SignalName>\`.`, [idOf(sig)!]);
-    } else if (this.kit.is(el, 'bpmn:StartEvent') && isFeel(nameOf(sig))) {
-      this.push('deploy', 'W_C8_DEPLOY_SIGNAL', el, undefined, 'signalName', `Start event ${id} catches the signal "${nameOf(sig)}", a FEEL expression; Camunda 8 needs a static signal name on start events and refuses the file`, `\`bpmn set <file> ${idOf(sig)} name=<SignalName>\`.`, [idOf(sig)!]);
-    }
-  }
-
-  private checkErrorDefinition(el: El, def: El): void {
-    if (this.kit.is(el, 'bpmn:ThrowEvent')) {
-      this.checkThrownError(el, def);
-    } else {
-      this.checkCaughtError(el, def);
-    }
-  }
-
-  private checkThrownError(el: El, def: El): void {
-    const id = idOf(el)!;
-    const label = this.describe(el);
-    const err = peek<El>(def, 'errorRef');
-    if (!err) {
-      this.push('deploy', 'W_C8_DEPLOY_ERROR', el, undefined, 'errorRef', `${label} throws no error (no errorRef); Camunda 8 refuses the file`, `\`bpmn set <file> ${id} error=<ErrorName> errorCode=<CODE>\`.`);
-    } else if (missing(peek<string>(err, 'errorCode'))) {
-      this.push('deploy', 'W_C8_DEPLOY_ERROR', el, undefined, 'errorCode', `Error ${idOf(err)} thrown by ${label} has no errorCode; Camunda 8 refuses the file`, `\`bpmn set <file> ${id} errorCode=<CODE>\`.`, [idOf(err)!]);
-    }
-  }
-
-  private checkCaughtError(el: El, def: El): void {
-    const id = idOf(el)!;
-    const label = this.describe(el);
-    const err = peek<El>(def, 'errorRef');
-    const code = peek<string>(err, 'errorCode');
-    if (isFeel(code)) {
-      this.push('deploy', 'W_C8_DEPLOY_ERROR', el, undefined, 'errorCode', `${label} catches the error code "${code}", an expression; Camunda 8 needs a static code on catching error events and refuses the file`, `\`bpmn set <file> ${id} errorCode=<CODE>\` (or no code: it catches every error).`, err ? [idOf(err)!] : []);
-    }
-    if (this.nonInterrupting(el)) {
-      this.push('deploy', 'W_C8_DEPLOY_ERROR', el, undefined, 'nonInterrupting', `${label} is a non-interrupting error event; Camunda 8 refuses it (error events always interrupt)`, `\`bpmn set <file> ${id} nonInterrupting=false\`.`);
-    }
-  }
-
-  private checkEscalationDefinition(el: El, def: El): void {
-    if (this.kit.is(el, 'bpmn:ThrowEvent')) {
-      this.checkThrownEscalation(el, def);
-    } else if (this.kit.is(el, 'bpmn:BoundaryEvent')) {
-      this.checkEscalationHost(el);
-    }
-  }
-
-  private checkThrownEscalation(el: El, def: El): void {
-    const id = idOf(el)!;
-    const label = this.describe(el);
-    const esc = peek<El>(def, 'escalationRef');
-    if (!esc) {
-      this.push('deploy', 'W_C8_DEPLOY_ESCALATION', el, undefined, 'escalationRef', `${label} throws no escalation (no escalationRef); Camunda 8 refuses the file`, `\`bpmn set <file> ${id} escalation=<Name> escalationCode=<CODE>\`.`);
-    } else if (missing(peek<string>(esc, 'escalationCode'))) {
-      this.push('deploy', 'W_C8_DEPLOY_ESCALATION', el, undefined, 'escalationCode', `Escalation ${idOf(esc)} thrown by ${label} has no escalationCode; Camunda 8 refuses the file`, `\`bpmn set <file> ${id} escalationCode=<CODE>\`.`, [idOf(esc)!]);
-    }
-  }
-
-  private checkEscalationHost(el: El): void {
-    const host = peek<El>(el, 'attachedToRef');
-    if (!host || this.kit.is(host, 'bpmn:SubProcess') || this.kit.is(host, 'bpmn:CallActivity')) {
-      return;
-    }
-    const id = idOf(el)!;
-    this.push('deploy', 'W_C8_DEPLOY_ESCALATION', el, undefined, 'escalationHost', `Escalation boundary event ${id} is attached to ${this.describe(host)}; Camunda 8 allows it only on sub-processes and call activities and refuses the file`, `Attach it elsewhere (\`bpmn move <file> ${id} --on <subProcessId>\`) or remove it: \`bpmn remove <file> ${id}\`.`, [idOf(host)!]);
-  }
-
-  private checkCompensateDefinition(el: El, def: El): void {
-    if (this.kit.is(el, 'bpmn:ThrowEvent')) this.checkCompensationRef(el, def);
-    if (this.kit.is(el, 'bpmn:BoundaryEvent')) this.checkCompensationBoundary(el);
-  }
-
-  private checkConditionalDefinition(el: El, def: El): void {
-    const id = idOf(el)!;
-    const body = peek<string>(peek<El>(def, 'condition'), 'body');
-    this.checkFeel(el, undefined, 'condition', `The condition of conditional event ${id}`, body, `\`bpmn set <file> ${id} ${sh(`when==${feelOf((body ?? '').trim().slice(1))}`)}\` (check the FEEL syntax).`);
-    if (!peek<El>(def, 'condition') || isFeel(body)) return;
-    this.push('deploy', 'W_C8_DEPLOY_EXPRESSION', el, undefined, 'condition', `The condition "${(body ?? '').trim()}" of conditional event ${id} is no FEEL expression; Camunda 8 needs one starting with = and refuses the file`, `\`bpmn set <file> ${id} ${sh(`when==${feelOf(body ?? '')}`)}\` (check the FEEL syntax).`);
-  }
-
-  /** Checks a message catch event; two subscriptions are reported as W_C8_DEPLOY_DUPLICATE_EXTENSION on the message, not here. */
-  checkMessageCatch(el: El): void {
-    const id = idOf(el)!;
-    const label = this.describe(el);
-    const msg = this.messageOf(el);
-    if (!msg) {
-      this.push('deploy', 'W_C8_DEPLOY_MESSAGE', el, undefined, 'messageRef', `${label} has no message; Camunda 8 refuses the file`, `\`bpmn set <file> ${id} message=<MessageName>\` (creates the bpmn:Message), then give it a correlation key: \`bpmn ext add <file> <messageId> ${this.zeebeName('subscription')} correlationKey==<expression>\`.`);
-      return;
-    }
-    const mid = idOf(msg)!;
-    const name = nameAttr(msg);
-    if (!name) {
-      this.push('deploy', 'W_C8_DEPLOY_MESSAGE', el, undefined, 'messageName', `Message ${mid} of ${label} has no name; Camunda 8 refuses the file`, `\`bpmn set <file> ${mid} name=<MessageName>\`.`, [mid]);
-      return;
-    }
-    const processStart = this.kit.is(el, 'bpmn:StartEvent') && this.kit.is(el.$parent as El, 'bpmn:Process');
-    if (processStart) {
-      if (isFeel(name)) {
-        this.push('deploy', 'W_C8_DEPLOY_MESSAGE', el, undefined, 'messageName', `Start event ${id} catches the message "${name}", a FEEL expression; Camunda 8 needs a static message name on process start events and refuses the file`, `\`bpmn set <file> ${mid} name=<MessageName>\`.`, [mid]);
-      }
-      return;
-    }
-    const subs = this.zeebe(msg, 'subscription');
-    if (subs.length > 1) return;
-    if (!subs.length) {
-      this.push('deploy', 'W_C8_DEPLOY_MESSAGE', el, undefined, `subscription:${mid}`, `Message ${mid} ("${name}") of ${label} has no ${this.zeebeName('subscription')}: Camunda 8 needs one with the correlation key that matches a message to an instance and refuses the file`, `\`bpmn ext add <file> ${mid} ${this.zeebeName('subscription')} correlationKey==<expression>\` (e.g. correlationKey==orderId).`, [mid]);
-      return;
-    }
-    const key = attr(subs[0], 'correlationKey');
-    if (blank(key)) {
-      this.push('deploy', 'W_C8_DEPLOY_MESSAGE', el, undefined, `correlationKey:${mid}`, `The ${this.zeebeName('subscription')} of message ${mid} ("${name}") has no correlationKey; Camunda 8 refuses the file`, this.fixHint(msg, undefined, subs[0]!, { correlationKey: '=<expression>' }), [mid]);
-    } else if (!isFeel(key)) {
-      this.push('deploy', 'W_C8_DEPLOY_EXPRESSION', el, undefined, `correlationKey:${mid}`, `The correlationKey "${key}" of message ${mid} is a static value; Camunda 8 needs a FEEL expression (=${key!.trim()}) and refuses the file`, this.fixHint(msg, undefined, subs[0]!, { correlationKey: `=${key!.trim()}` }), [mid]);
-    }
-  }
-
-  /** A compensation throw event's activityRef must name an activity of its own scope. */
-  private checkCompensationRef(el: El, def: El): void {
-    const ref = peek<El>(def, 'activityRef');
-    if (!ref) return;
-    const scope = this.doc.scopeOf(el);
-    if (this.doc.scopeOf(ref) === scope) return;
-    this.push('deploy', 'W_C8_DEPLOY_EVENT_DEFINITION', el, undefined, 'activityRef', `Compensation event ${idOf(el)} names ${idOf(ref)}, which is not in its own scope ${idOf(scope)}; Camunda 8 refuses the file`, `\`bpmn set <file> ${idOf(el)} definition.activityRef=<activityId>\` (an activity of ${idOf(scope)}), or \`definition.activityRef=\` to compensate the whole scope.`, [idOf(ref)!]);
-  }
-
-  /** A compensation boundary event needs an association to its handler and no outgoing flow. */
-  private checkCompensationBoundary(el: El): void {
-    const id = idOf(el)!;
-    const scope = this.doc.scopeOf(el);
-    const associated = list(scope, 'artifacts').some((artifact) => this.kit.is(artifact, 'bpmn:Association') && peek<El>(artifact, 'sourceRef') === el);
-    const out = this.outgoing.get(el) ?? [];
-    if (!associated || out.length) {
-      this.push('deploy', 'W_C8_DEPLOY_EVENT_DEFINITION', el, undefined, 'compensationBoundary', `Compensation boundary event ${id} ${!associated ? 'has no association to a compensation handler' : 'has an outgoing sequence flow'}; Camunda 8 refuses the file`, !associated ? `Connect it to its handler (an activity with isForCompensation=true): \`bpmn connect <file> ${id} <handlerId>\`.` : `Remove the flow (\`bpmn remove <file> ${idOf(out[0])} --no-bridge\`) and connect the handler instead: \`bpmn connect <file> ${id} <handlerId>\`.`);
-    }
-  }
-
-  checkStartEvents(scope: El): void {
-    const id = idOf(scope)!;
-    const starts = this.doc.flowNodes(scope).filter((node) => this.kit.is(node, 'bpmn:StartEvent'));
-    if (this.kit.is(scope, 'bpmn:Process')) {
-      if (!starts.length) {
-        this.push('deploy', 'W_C8_DEPLOY_START_EVENT', scope, undefined, 'noStart', `Process ${id} has no start event; Camunda 8 refuses the file`, `\`bpmn add <file> startEvent "<Name>" --before <firstNodeId>\` (or --in ${id}).`);
-        return;
-      }
-      const none = starts.filter((start) => !list(start, 'eventDefinitions').length);
-      for (const extra of none.slice(1)) {
-        this.push('deploy', 'W_C8_DEPLOY_START_EVENT', extra, undefined, 'noneStart', `Process ${id} has ${none.length} none start events (${none.map(idOf).join(', ')}); Camunda 8 allows one and refuses the file`, `Remove ${idOf(extra)} (\`bpmn remove <file> ${idOf(extra)}\`) or give it a trigger: \`bpmn set <file> ${idOf(extra)} trigger=message message=<MessageName>\`.`, [idOf(none[0])!]);
-      }
-      return;
-    }
-    if (this.kit.is(scope, 'bpmn:AdHocSubProcess') || this.kit.is(scope, 'bpmn:Transaction')) {
-      return;
-    }
-    const event = this.kit.isEventSubProcess(scope);
-    if (starts.length !== 1) {
-      this.push('deploy', 'W_C8_DEPLOY_START_EVENT', scope, undefined, 'startCount', `${event ? 'Event sub-process' : 'Sub-process'} ${id} has ${starts.length ? `${starts.length} start events` : 'no start event'}; Camunda 8 needs exactly one and refuses the file`, starts.length ? `Keep one: \`bpmn remove <file> ${idOf(starts[1])}\`.` : event ? `\`bpmn add <file> startEvent:message "<Name>" --in ${id} --message <MessageName>\` (or timer, error, signal, escalation, conditional).` : `\`bpmn add <file> startEvent "<Name>" --in ${id}\`, then connect it to the first node.`);
-    }
-  }
-
-  /**
-   * Message names caught twice in one scope, signal names on two starts / one activity's
-   * boundaries, error codes twice in one scope.
-   * The groups are the boundary events of one activity (with the activity itself when it is a
-   * receive task), the branches of an event-based gateway, the event sub-process starts of the
-   * scope and the start events of a process.
-   */
-  checkSubscriptionScopes(scope: El): void {
-    const nodes = this.doc.flowNodes(scope);
-    const literal = (name: string | undefined): name is string => !!name && !isFeel(name);
-    const defOf = (el: El, type: string): El | undefined => {
-      const defs = list(el, 'eventDefinitions');
-      return defs.length === 1 && this.kit.is(defs[0], type) ? defs[0] : undefined;
-    };
-    const report = (els: El[], kind: 'message' | 'signal', name: string, where: string, code: string, subjectPrefix: string): void => {
-      const [first, ...rest] = els;
-      for (const el of rest) {
-        this.push('deploy', code, el, undefined, `${subjectPrefix}:${name}`, `${this.describe(el)} waits for the ${kind} "${name}" like ${this.describe(first!)} ${where}; Camunda 8 refuses one ${kind} name twice there`, `Use another ${kind}: \`bpmn set <file> ${idOf(el)} ${kind}=<Other${kind === 'message' ? 'Message' : 'Signal'}>\`${kind === 'message' ? ` (and a ${this.zeebeName('subscription')} on it)` : ''}.`, [idOf(first!)!]);
-      }
-    };
-    const group = (els: El[], kind: 'message' | 'signal', where: string, code: string, subjectPrefix: string): void => {
-      const byName = new Map<string, El[]>();
-      for (const el of els) {
-        const def = defOf(el, kind === 'message' ? 'bpmn:MessageEventDefinition' : 'bpmn:SignalEventDefinition');
-        const name = kind === 'message' ? nameOf(this.kit.is(el, 'bpmn:ReceiveTask') ? peek<El>(el, 'messageRef') : peek<El>(def, 'messageRef')) : nameOf(peek<El>(def, 'signalRef'));
-        if (!literal(name)) continue;
-        byName.set(name, [...(byName.get(name) ?? []), el]);
-      }
-      for (const [name, list_] of byName) {
-        if (list_.length > 1) report(list_, kind, name, where, code, subjectPrefix);
-      }
-    };
-    for (const act of nodes.filter((node) => this.kit.is(node, 'bpmn:Activity'))) {
-      const boundaries = nodes.filter((node) => this.kit.is(node, 'bpmn:BoundaryEvent') && peek<El>(node, 'attachedToRef') === act);
-      if (!boundaries.length) continue;
-      group([...(this.kit.is(act, 'bpmn:ReceiveTask') ? [act] : []), ...boundaries], 'message', `on ${idOf(act)}`, 'W_C8_DEPLOY_MESSAGE', `boundaryMessage:${idOf(act)}`);
-      group(boundaries, 'signal', `on ${idOf(act)}`, 'W_C8_DEPLOY_SIGNAL', `boundarySignal:${idOf(act)}`);
-      this.checkErrorCodes(boundaries, `the boundary events of ${idOf(act)}`);
-    }
-    for (const gw of nodes.filter((node) => this.kit.is(node, 'bpmn:EventBasedGateway'))) {
-      const targets = (this.outgoing.get(gw) ?? []).map((flow) => peek<El>(flow, 'targetRef')).filter((target): target is El => !!target && this.kit.is(target, 'bpmn:IntermediateCatchEvent'));
-      group(targets, 'message', `after event-based gateway ${idOf(gw)}`, 'W_C8_DEPLOY_MESSAGE', `gatewayMessage:${idOf(gw)}`);
-    }
-    const eventSubStarts = nodes.filter((node) => this.kit.isEventSubProcess(node)).flatMap((sp) => this.doc.flowNodes(sp).filter((node) => this.kit.is(node, 'bpmn:StartEvent')));
-    group(eventSubStarts, 'message', `in the event sub-processes of ${idOf(scope)}`, 'W_C8_DEPLOY_MESSAGE', `eventSubMessage:${idOf(scope)}`);
-    this.checkErrorCodes(eventSubStarts, `the event sub-processes of ${idOf(scope)}`);
-    if (this.kit.is(scope, 'bpmn:Process')) {
-      const starts = nodes.filter((node) => this.kit.is(node, 'bpmn:StartEvent'));
-      group(starts, 'message', `in process ${idOf(scope)}`, 'W_C8_DEPLOY_MESSAGE', 'startMessage');
-      group(starts, 'signal', `in process ${idOf(scope)}`, 'W_C8_DEPLOY_SIGNAL', 'startSignal');
-    }
-  }
-
-  /** Two error catch events with one code (or two without code) in one scope. */
-  private checkErrorCodes(events: El[], where: string): void {
-    const seen = new Map<string, El>();
-    for (const el of events) {
-      const defs = list(el, 'eventDefinitions');
-      if (defs.length !== 1 || !this.kit.is(defs[0], 'bpmn:ErrorEventDefinition')) {
-        continue;
-      }
-      const code = peek<string>(peek<El>(defs[0], 'errorRef'), 'errorCode');
-      const key = blank(code) ? '' : code!;
-      const first = seen.get(key);
-      if (first) {
-        this.push('deploy', 'W_C8_DEPLOY_ERROR', el, undefined, `errorCode:${key}`, key ? `${this.describe(el)} catches the error code "${key}" like ${this.describe(first)} (${where}); Camunda 8 refuses one code twice in a scope` : `${this.describe(el)} and ${this.describe(first)} both catch every error (no error code) (${where}); Camunda 8 allows one catch-all per scope`, `Catch another error: \`bpmn set <file> ${idOf(el)} error=<OtherError> errorCode=<OTHER_CODE>\` (the events share no bpmn:Error then), or remove one of them.`, [idOf(first)!]);
-      } else {
-        seen.set(key, el);
-      }
-    }
-  }
-
-  /**
-   * Link events: a throw needs a catch of its name in its own (sub-)process; catch names are
-   * unique in a process.
-   */
-  checkLinks(proc: El): void {
-    const links = new LinkEvents(this.doc, this.kit, this.allFlowNodes(proc), (node) => {
-      const defs = list(node, 'eventDefinitions');
-      return defs.length === 1 && this.kit.is(defs[0], 'bpmn:LinkEventDefinition') ? peek<string>(defs[0], 'name') : undefined;
-    });
-    for (const { el, name, scope } of links.unmatchedThrows()) {
-      this.push('deploy', 'W_C8_DEPLOY_LINK', el, undefined, `link:${name}`, `Link throw event ${idOf(el)} goes to "${name}", but ${idOf(scope)} has no link catch event of that name; Camunda 8 refuses the file`, `\`bpmn add <file> intermediateCatchEvent:link "<Name>" --in ${idOf(scope)} --link ${sh(name)}\`, then continue from it (or rename the link: \`bpmn set <file> ${idOf(el)} link=<Name>\`).`);
-    }
-    for (const { first, el, name } of links.duplicateCatches()) {
-      this.push('deploy', 'W_C8_DEPLOY_LINK', el, undefined, `linkCatch:${name}`, `Link catch events ${idOf(first)} and ${idOf(el)} share the name "${name}" in process ${idOf(proc)}; Camunda 8 refuses the file`, `\`bpmn set <file> ${idOf(el)} link=<OtherName>\` (and its throw events).`, [idOf(first)!]);
-    }
-  }
-
-  /** Every flow node of a scope and of its nested sub-processes, in document order. */
-  private allFlowNodes(scope: El): El[] {
-    return this.doc.flowNodes(scope).flatMap((node) => (this.kit.is(node, 'bpmn:SubProcess') ? [node, ...this.allFlowNodes(node)] : [node]));
-  }
-
-  /**
-   * The names of the messages and signals the file's elements use: Camunda 8 parses one starting
-   * with = as FEEL at deploy.
-   */
-  checkFeelNames(): void {
-    const used = new Set<El>();
-    for (const el of this.kit.walk(this.doc.definitions, { bpmnOnly: true })) {
-      if (!this.kit.is(el, 'bpmn:FlowNode')) continue;
-      const msg = this.messageOf(el);
-      if (msg) used.add(msg);
-      for (const def of list(el, 'eventDefinitions')) {
-        const sig = this.kit.is(def, 'bpmn:SignalEventDefinition') ? peek<El>(def, 'signalRef') : undefined;
-        if (sig) used.add(sig);
-      }
-    }
-    for (const ref of used) {
-      const id = idOf(ref);
-      if (!id) continue;
-      const what = this.kit.is(ref, 'bpmn:Signal') ? 'signal' : 'message';
-      this.checkFeel(ref, undefined, 'name', `The name of ${what} ${id}`, nameAttr(ref), `\`bpmn set <file> ${id} ${sh('name==<FEEL expression>')}\` (check the FEEL syntax), or a static name.`);
-    }
-  }
-}
diff --git a/src/domain/validation/profiles/c8/C8ExtensionRules.ts b/src/domain/validation/profiles/c8/C8ExtensionRules.ts
deleted file mode 100644
index 3cc9836d..00000000
--- a/src/domain/validation/profiles/c8/C8ExtensionRules.ts
+++ /dev/null
@@ -1,392 +0,0 @@
-import type { El } from '../../../document/utils/moddle.js';
-import type { ExtValue } from '../EngineRules.js';
-import { TimerValue } from '../TimerValue.js';
-import { attr, idOf, list, localName } from '../../utils/element.js';
-import { didYouMean, lowerFirst, sh } from '../../utils/hint.js';
-import { blank, feelOf, isFeel, missing } from '../../utils/c8-value.js';
-import { C8Rules } from './C8Rules.js';
-
-/** Zeebe attributes Camunda 8 parses as FEEL when they start with = (engine-checked). */
-const FEEL_ATTRS: Record<string, string[]> = {
-  taskDefinition: ['type', 'retries'],
-  input: ['source'],
-  output: ['source'],
-  loopCharacteristics: ['inputCollection', 'outputElement'],
-  calledElement: ['processId'],
-  calledDecision: ['decisionId'],
-  script: ['expression'],
-  subscription: ['correlationKey'],
-  assignmentDefinition: ['assignee', 'candidateGroups', 'candidateUsers'],
-  taskSchedule: ['dueDate', 'followUpDate'],
-  priorityDefinition: ['priority'],
-  adHoc: ['activeElementsCollection', 'outputElement'],
-};
-
-/** Camunda 7 attributes that have a Camunda 8 counterpart, for hints. */
-const C8_EQUIVALENT: Record<string, string> = {
-  assignee: 'zeebe:assignmentDefinition assignee=<assignee>',
-  candidateGroups: 'zeebe:assignmentDefinition candidateGroups=<groups>',
-  candidateUsers: 'zeebe:assignmentDefinition candidateUsers=<users>',
-  dueDate: 'zeebe:taskSchedule dueDate=<date>',
-  followUpDate: 'zeebe:taskSchedule followUpDate=<date>',
-  priority: 'zeebe:priorityDefinition priority=<0..100>',
-  formKey: 'zeebe:formDefinition formId=<formId>',
-  topic: 'zeebe:taskDefinition type=<jobType>',
-  type: 'zeebe:taskDefinition type=<jobType>',
-  class: 'zeebe:taskDefinition type=<jobType>',
-  delegateExpression: 'zeebe:taskDefinition type=<jobType>',
-  expression: 'zeebe:taskDefinition type=<jobType>',
-  decisionRef: 'zeebe:calledDecision decisionId=<decisionId> resultVariable=<variable>',
-  inputOutput: 'zeebe:input source==<expression> target=<variable>',
-  versionTag: 'zeebe:versionTag value=<tag>',
-};
-
-const BINDING_TYPES = ['deployment', 'latest', 'versionTag'];
-const PATH = /^[a-zA-Z_][a-zA-Z0-9_]*(\.[a-zA-Z_][a-zA-Z0-9_]*)*$/;
-const TASK_LISTENER_EVENTS = ['creating', 'assigning', 'updating', 'completing', 'canceling', 'create', 'assignment', 'update', 'complete', 'cancel'];
-
-/**
- * Zeebe attributes and extension elements: Camunda 7 content, unknown or misplaced zeebe content,
- * FEEL slips, and the engine rules on mappings, headers, listeners and schedules.
- */
-export class C8ExtensionRules extends C8Rules {
-  private foreignHint(el: El, owner: El | undefined, local: string, remove: string): string {
-    const equivalent = C8_EQUIVALENT[local];
-    return `Remove it: ${remove}${equivalent ? `; Camunda 8 reads ${this.extAdd(el, owner, equivalent.replace(/^zeebe:/, `${this.prefix}:`))}` : ''}.`;
-  }
-
-  /**
-   * zeebe:* / camunda:* / operaton:* attributes of a BPMN element.
-   * An unknown one that belongs to a zeebe extension element allowed there (zeebe:assignee) is pointed to it.
-   */
-  checkAttributes(el: El, owner: El | undefined): void {
-    const addr = this.addressOf(el, owner);
-    const where = this.describe(el, owner);
-    for (const key of Object.keys(el.$attrs ?? {})) {
-      const uri = this.ns.uriOfName(key);
-      if (!uri) continue;
-      const local = localName(key);
-      const unset = addr ? `\`bpmn set <file> ${addr.id} ${sh(`${addr.prefix}${key}=`)}\`` : 'edit the XML';
-      if (this.kit.camunda.uris.has(uri)) {
-        this.push('runtime', 'W_C8_FOREIGN_CONTENT', el, owner, `attr:${key}`, `${where} carries the Camunda 7 attribute ${key}, which Camunda 8 ignores`, this.foreignHint(el, owner, local, unset));
-        continue;
-      }
-      if (uri !== this.kit.zeebe.uri) continue;
-      const def = this.kit.zeebe.attr(local);
-      if (!def) {
-        const home = this.kit.zeebe.typeNames().find((typeName) => this.kit.zeebe.allowedOn(typeName, el) === true && this.kit.zeebe.type(typeName)!.attributes.some((attribute) => attribute.name === local));
-        const guess = home ? undefined : didYouMean(local, this.kit.zeebe.attrs().map((attribute) => localName(attribute.name)));
-        const value = String(el.$attrs[key] ?? '');
-        this.push(
-          'runtime',
-          'W_C8_UNKNOWN_ATTRIBUTE',
-          el,
-          owner,
-          `attr:${key}`,
-          `${where} has the unknown attribute ${key}${guess ? ` (did you mean ${this.prefix}:${guess}?)` : ''}; Camunda 8 ignores it${home ? ` (it reads ${local} on the ${this.zeebeName(localName(home))} extension element)` : ' (most zeebe settings are extension elements: `bpmn kinds`, `bpmn guide`)'}`,
-          home ? `Move it: ${unset}, then ${this.extAdd(el, owner, `${this.zeebeName(localName(home))} ${sh(`${local}=${value}`)}`)}.` : `Remove it: ${unset}.`,
-        );
-        continue;
-      }
-      if (!def.owners.some((ownerType) => this.kit.is(el, ownerType))) {
-        this.push('runtime', 'W_C8_MISPLACED_ATTRIBUTE', el, owner, `attr:${key}`, `${key} on ${where} has no effect: Camunda 8 reads it on ${def.owners.map((ownerType) => lowerFirst(localName(ownerType))).join(', ')} only`, `Remove it: ${unset}.`);
-      }
-    }
-  }
-
-  /** The messages the catch events of the executable processes read: their subscription content. */
-  checkCaughtMessages(executable: El[]): void {
-    const catching = executable.flatMap((proc) => [...this.kit.walk(proc, { bpmnOnly: true })]).filter((el) => this.kit.is(el, 'bpmn:Event') || this.kit.is(el, 'bpmn:ReceiveTask'));
-    const caught = new Set(catching.map((el) => this.messageOf(el)).filter((message): message is El => !!message));
-    for (const message of caught) {
-      this.checkAttributes(message, undefined);
-      this.checkExtensions(message, undefined);
-    }
-  }
-
-  /** Input mappings Camunda 8 ignores on these hosts (output mappings work there). */
-  private inputsIgnored(host: El): string | undefined {
-    if (this.kit.is(host, 'bpmn:StartEvent')) return 'start events';
-    if (this.kit.is(host, 'bpmn:BoundaryEvent')) return 'boundary events';
-    const defs = list(host, 'eventDefinitions');
-    if (this.kit.is(host, 'bpmn:IntermediateThrowEvent') && !defs.length) {
-      return 'none intermediate throw events';
-    }
-    if (this.kit.is(host, 'bpmn:EndEvent') && !defs.length) {
-      return 'none end events';
-    }
-    return undefined;
-  }
-
-  /**
-   * Extension elements of one BPMN element: foreign, unknown, misplaced, duplicates; then the
-   * content of each zeebe element.
-   * Input mappings are reported where the engine reads only outputs.
-   */
-  checkExtensions(host: El, owner: El | undefined): void {
-    const values = this.extensionValues(host);
-    if (!values.length) return;
-    const addr = this.addressOf(host, owner);
-    const where = this.describe(host, owner);
-    const remove = (extValue: ExtValue): string => (addr ? `\`bpmn ext remove <file> ${addr.id} ${sh(`${addr.prefix}${extValue.index}`)}\`` : 'remove it from the XML');
-    const counts = new Map<string, number>();
-    for (const extValue of values) {
-      if (!extValue.uri) continue;
-      if (this.kit.camunda.uris.has(extValue.uri)) {
-        this.push('runtime', 'W_C8_FOREIGN_CONTENT', host, owner, `ext:${extValue.el.$type}#${extValue.index}`, `${where} contains the Camunda 7 extension ${extValue.el.$type}, which Camunda 8 ignores`, this.foreignHint(host, owner, extValue.local, remove(extValue)));
-        continue;
-      }
-      if (extValue.uri !== this.kit.zeebe.uri) continue;
-      const zeebeType = this.kit.zeebe.type(extValue.local);
-      if (!zeebeType) {
-        const guess = didYouMean(extValue.local, this.kit.zeebe.typeNames().map(localName));
-        this.push('runtime', 'W_C8_UNKNOWN_ELEMENT', host, owner, `ext:${extValue.local}`, `${where} has the unknown extension element ${this.zeebeName(extValue.local)}${guess ? ` (did you mean ${this.zeebeName(guess)}?)` : ''}; Camunda 8 ignores it`, `Remove it (${remove(extValue)})${guess && addr ? ` and add the right one: ${this.extAdd(host, owner, `${this.zeebeName(guess)} ...`)}` : ''}.`);
-        continue;
-      }
-      if (this.kit.zeebe.nestedOnly(extValue.local)) {
-        const container = this.kit.zeebe.containersOf(extValue.local)[0]!;
-        this.push('runtime', 'W_C8_MISPLACED_EXTENSION', host, owner, `ext:${extValue.local}`, `${this.zeebeName(extValue.local)} sits directly in the extension elements of ${where}, but belongs inside ${this.zeebeName(localName(container))}; Camunda 8 ignores it`, `Remove it (${remove(extValue)}) and add it again, \`bpmn ext add\` files it into its container: ${this.extAdd(host, owner, `${this.zeebeName(extValue.local)} ...`)}.`);
-        continue;
-      }
-      if (extValue.local === 'executionListeners' && this.kit.is(host, 'bpmn:SequenceFlow')) {
-        this.push('deploy', 'W_C8_DEPLOY_LISTENER', host, owner, 'listener:flow', `${where} has execution listeners; Camunda 8 supports them on processes, activities, events and gateways, not on sequence flows, and refuses the file`, `Remove them (${remove(extValue)}) and put them on the flow's source or target.`);
-        continue;
-      }
-      if (this.kit.zeebe.allowedOn(extValue.local, host) === false) {
-        const hosts = zeebeType.allowedIn.filter((allowedHost) => allowedHost.startsWith('bpmn:')).map((allowedHost) => lowerFirst(localName(allowedHost)));
-        this.push('runtime', 'W_C8_MISPLACED_EXTENSION', host, owner, `ext:${extValue.local}`, `${this.zeebeName(extValue.local)} on ${where} has no effect: Camunda 8 reads it on ${hosts.length > 5 ? `${hosts.slice(0, 5).join(', ')}, ...` : hosts.join(', ')} only`, `Remove it: ${remove(extValue)}.`);
-        continue;
-      }
-      counts.set(extValue.local, (counts.get(extValue.local) ?? 0) + 1);
-      this.checkZeebeElement(host, owner, extValue.el, '');
-    }
-    for (const [local, count] of counts) {
-      if (count < 2 || !this.kit.zeebe.isSingle(local)) continue;
-      this.push('deploy', 'W_C8_DEPLOY_DUPLICATE_EXTENSION', host, owner, `dup:${local}`, `${where} has ${count} ${this.zeebeName(local)} elements; Camunda 8 reads one and refuses the file`, `Merge them into one: ${lowerFirst(this.rebuildHint(host, owner, this.zeebeName(local)).replace(/^See it/, 'See them'))}`);
-    }
-    const ignored = this.inputsIgnored(host);
-    if (ignored) {
-      for (const io of this.zeebe(host, 'ioMapping')) {
-        for (const input of this.kids(io, 'input')) {
-          const target = attr(input, 'target') ?? '';
-          this.push('runtime', 'W_C8_MISPLACED_EXTENSION', host, owner, `input:${target}`, `The input mapping ${target ? `to ${target} ` : ''}on ${where} has no effect: Camunda 8 ignores input mappings on ${ignored} (output mappings work there)`, addr ?`Remove it: \`bpmn ext remove <file> ${addr.id} ${sh(`${addr.prefix}${this.zeebeName('input')}[target=${target}]`)}\` (set the variable in an activity before it, or as an output mapping of the element before).` : 'Remove it from the XML.');
-        }
-      }
-    }
-  }
-
-  /**
-   * Attributes and children of a zeebe element (known names, placement), recursively; then the
-   * engine rules on its content.
-   * For a mapping the hint gives the corrected one, as it is replaced by its target.
-   */
-  private checkZeebeElement(host: El, owner: El | undefined, zeebeElement: El, path: string): void {
-    const local = localName(zeebeElement.$type);
-    const zeebeType = this.kit.zeebe.type(local);
-    if (!zeebeType) return;
-    const where = `${this.zeebeName(local)}${path ? ` (in ${path})` : ''} of ${this.describe(host, owner)}`;
-    const names = new Set(zeebeType.attributes.map((attribute) => attribute.name));
-    for (const attributeKey of Object.keys(zeebeElement as unknown as Record<string, unknown>)) {
-      if (attributeKey.startsWith('$') || attributeKey.startsWith('xmlns') || attributeKey.includes(':')) {
-        continue;
-      }
-      if (names.has(attributeKey)) continue;
-      const guess = didYouMean(attributeKey, [...names]);
-      this.push('runtime', 'W_C8_UNKNOWN_ATTRIBUTE', host, owner, `ext:${path}/${local}@${attributeKey}`, `${where} has the unknown attribute ${attributeKey}${guess ? ` (did you mean ${guess}?)` : ''}; Camunda 8 ignores it`, this.rebuildHint(host, owner, this.zeebeName(path ? path.split(' > ')[0]!.replace(/^[^:]+:/, '') : local)));
-    }
-    for (const feelAttribute of FEEL_ATTRS[local] ?? []) {
-      const value = attr(zeebeElement, feelAttribute);
-      const target = attr(zeebeElement, 'target');
-      const fix =
-        (local === 'input' || local === 'output') && target && isFeel(value)
-          ? `${this.extAdd(host, owner, `${this.zeebeName(local)} ${sh(`source==${feelOf(value!.trim().slice(1)).trim()}`)} target=${sh(target)}`)} (replaces the mapping of that target; check the FEEL syntax).`
-          : path
-            ? this.rebuildHint(host, owner, this.zeebeName(localName(path.split(' > ')[0]!)))
-            : this.fixHint(host, owner, zeebeElement, { [feelAttribute]: '=<FEEL expression>' });
-      this.checkFeel(host, owner, `${path}/${local}@${feelAttribute}`, `${feelAttribute} of ${where}`, value, fix);
-    }
-    for (const child of this.kids(zeebeElement)) {
-      const cl = localName(child.$type);
-      const childPath = path ? `${path} > ${this.zeebeName(local)}` : this.zeebeName(local);
-      if (!zeebeType.children.includes(`zeebe:${cl}`)) {
-        const known = this.kit.zeebe.type(cl);
-        this.push('runtime', known ? 'W_C8_MISPLACED_EXTENSION' : 'W_C8_UNKNOWN_ELEMENT', host, owner, `ext:${childPath}/${cl}`, known ? `${this.zeebeName(cl)} does not belong inside ${this.zeebeName(local)} (${where}); Camunda 8 ignores it` : `${where} contains the unknown element ${this.zeebeName(cl)}; Camunda 8 ignores it`, this.rebuildHint(host, owner, this.zeebeName(path ? localName(path.split(' > ')[0]!) : local)));
-        continue;
-      }
-      this.checkZeebeElement(host, owner, child, childPath);
-    }
-    if (!path) this.checkContent(host, owner, zeebeElement, local);
-  }
-
-  /** Engine rules on the content of one top-level zeebe element. */
-  private checkContent(host: El, owner: El | undefined, zeebeElement: El, local: string): void {
-    this.checkBinding(host, owner, zeebeElement, local);
-    this.contentChecks[local]?.(host, owner, zeebeElement);
-  }
-
-  private readonly contentChecks: Record<string, (host: El, owner: El | undefined, zeebeElement: El) => void> = {
-    ioMapping: (host, owner, zeebeElement) => this.checkIoMapping(host, owner, zeebeElement),
-    taskHeaders: (host, owner, zeebeElement) => this.checkHeaders(host, owner, zeebeElement, ''),
-    executionListeners: (host, owner, zeebeElement) => this.checkExecutionListeners(host, owner, zeebeElement),
-    taskListeners: (host, owner, zeebeElement) => this.checkTaskListeners(host, owner, zeebeElement),
-    linkedResources: (host, owner, zeebeElement) => this.checkLinkedResources(host, owner, zeebeElement),
-    adHoc: (host, owner, zeebeElement) => this.checkAdHoc(host, owner, zeebeElement),
-    conditionalFilter: (host, owner, zeebeElement) => this.checkConditionalFilter(host, owner, zeebeElement),
-    priorityDefinition: (host, owner, zeebeElement) => this.checkPriority(host, owner, zeebeElement),
-    taskSchedule: (host, owner, zeebeElement) => this.checkTaskSchedule(host, owner, zeebeElement),
-  };
-
-  private checkBinding(host: El, owner: El | undefined, zeebeElement: El, local: string): void {
-    const where = this.describe(host, owner);
-    const binding = attr(zeebeElement, 'bindingType');
-    if (binding === undefined || !['calledDecision', 'calledElement', 'formDefinition'].includes(local)) {
-      return;
-    }
-    if (!BINDING_TYPES.includes(binding)) {
-      this.push('deploy', 'W_C8_DEPLOY_EXTENSION', host, owner, `${local}:bindingType`, `${this.zeebeName(local)} of ${where} has bindingType="${binding}"; Camunda 8 accepts ${BINDING_TYPES.join(', ')} only and refuses the file`, this.fixHint(host, owner, zeebeElement, { bindingType: 'latest' }));
-    } else if (binding === 'versionTag' && blank(attr(zeebeElement, 'versionTag'))) {
-      this.push('deploy', 'W_C8_DEPLOY_EXTENSION', host, owner, `${local}:versionTag`, `${this.zeebeName(local)} of ${where} has bindingType="versionTag" but no versionTag; Camunda 8 refuses the file`, this.fixHint(host, owner, zeebeElement, { versionTag: '<versionTag>' }));
-    }
-  }
-
-  private checkIoMapping(host: El, owner: El | undefined, zeebeElement: El): void {
-    const where = this.describe(host, owner);
-    const addr = this.addressOf(host, owner);
-    for (const [kind, label] of [
-      ['input', 'input'],
-      ['output', 'output'],
-    ] as const) {
-      this.kids(zeebeElement, kind).forEach((mapping, index) => {
-        const target = attr(mapping, 'target');
-        const sel = target ? `${this.zeebeName(kind)}[target=${target}]` : `${this.zeebeName('ioMapping')}/${this.zeebeName(kind)}[${index}]`;
-        if (blank(target)) {
-          this.push('deploy', 'W_C8_DEPLOY_EXTENSION', host, owner, `${kind}#${index}:target`, `The ${label} mapping ${index + 1} of ${where} has no target; Camunda 8 refuses the file`, addr ? `Remove it (\`bpmn ext remove <file> ${addr.id} ${sh(`${addr.prefix}${sel}`)}\`) and add it with a target: ${this.extAdd(host, owner, `${this.zeebeName(kind)} source==<expression> target=<variable>`)}.` : 'Fix it in the XML.');
-        } else if (!PATH.test(target!.trim())) {
-          this.push('deploy', 'W_C8_DEPLOY_EXTENSION', host, owner, `${kind}:${target}:target`, `The ${label} mapping target "${target}" of ${where} is not a variable name or path (a.b.c); Camunda 8 refuses the file`, addr ? `Remove it (\`bpmn ext remove <file> ${addr.id} ${sh(`${addr.prefix}${sel}`)}\`) and add it with a valid target: ${this.extAdd(host, owner, `${this.zeebeName(kind)} source=${sh(attr(mapping, 'source') ?? '=<expression>')} target=<variable>`)}.` : 'Fix it in the XML.');
-        }
-        if (kind === 'output' && blank(attr(mapping, 'source'))) {
-          this.push('deploy', 'W_C8_DEPLOY_EXTENSION', host, owner, `output:${target ?? index}:source`, `The output mapping ${target ? `to ${target} ` : ''}of ${where} has no source; Camunda 8 refuses the file`, `${this.extAdd(host, owner, `${this.zeebeName('output')} source==<expression> target=${target ?? '<variable>'}`)} (replaces the mapping of that target).`);
-        }
-      });
-    }
-  }
-
-  private checkExecutionListeners(host: El, owner: El | undefined, zeebeElement: El): void {
-    const where = this.describe(host, owner);
-    const addr = this.addressOf(host, owner);
-    this.kids(zeebeElement, 'executionListener').forEach((listener, index) => {
-      const ev = attr(listener, 'eventType');
-      const label = `Execution listener ${index + 1}${ev ? ` (${ev})` : ''} of ${where}`;
-      const sel = addr ? `\`bpmn ext remove <file> ${addr.id} ${sh(`${addr.prefix}${this.zeebeName('executionListeners')}/${this.zeebeName('executionListener')}[${index}]`)}\`` : 'remove it from the XML';
-      const again = (fix: string): string => `${sel}, then ${this.extAdd(host, owner, `${this.zeebeName('executionListeners')}/${this.zeebeName('executionListener')} ${fix}`)}`;
-      if (missing(attr(listener, 'type'))) {
-        this.push('deploy', 'W_C8_DEPLOY_LISTENER', host, owner, `listener:${index}:type`, `${label} has no type (the job type of its worker); Camunda 8 refuses the file`, `Rebuild it: ${again(`eventType=${ev ?? '<start|end>'} type=<jobType>`)}.`);
-      }
-      if (ev === undefined || ev.trim() === '') {
-        this.push('deploy', 'W_C8_DEPLOY_LISTENER', host, owner, `listener:${index}:eventType`, `${label} has no eventType; Camunda 8 refuses the file`, `Rebuild it: ${again(`eventType=<start|end> type=${attr(listener, 'type') ?? '<jobType>'}`)}.`);
-      } else if (ev !== 'start' && ev !== 'end') {
-        this.push('deploy', 'W_C8_DEPLOY_LISTENER', host, owner, `listener:${index}:eventType`, `${label}: eventType "${ev}" is not start or end; Camunda 8 refuses the file`, `Rebuild it: ${again(`eventType=<start|end> type=${attr(listener, 'type') ?? '<jobType>'}`)}.`);
-      } else if (ev === 'start' && (this.kit.is(host, 'bpmn:StartEvent') || this.kit.is(host, 'bpmn:BoundaryEvent'))) {
-        this.push('deploy', 'W_C8_DEPLOY_LISTENER', host, owner, `listener:${index}:start`, `${label}: Camunda 8 does not support start listeners on ${this.kit.is(host, 'bpmn:StartEvent') ? 'start' : 'boundary'} events and refuses the file`, `Make it an end listener or remove it: ${again(`eventType=end type=${attr(listener, 'type') ?? '<jobType>'}`)}.`);
-      } else if (ev === 'end' && this.kit.is(host, 'bpmn:Gateway')) {
-        this.push('deploy', 'W_C8_DEPLOY_LISTENER', host, owner, `listener:${index}:end`, `${label}: Camunda 8 does not support end listeners on gateways and refuses the file`, `Make it a start listener or remove it: ${again(`eventType=start type=${attr(listener, 'type') ?? '<jobType>'}`)}.`);
-      }
-      for (const taskHeaders of this.kids(listener, 'taskHeaders')) {
-        this.checkHeaders(host, owner, taskHeaders, `execution listener ${index + 1}`);
-      }
-    });
-  }
-
-  private checkTaskListeners(host: El, owner: El | undefined, zeebeElement: El): void {
-    const where = this.describe(host, owner);
-    if (!this.zeebe(host, 'userTask').length) {
-      this.push('deploy', 'W_C8_DEPLOY_LISTENER', host, owner, 'taskListeners:job', `${where} has task listeners but is a job worker user task (no ${this.zeebeName('userTask')}); Camunda 8 allows task listeners on Camunda user tasks only and refuses the file`, `Make it a Camunda user task: ${this.extAdd(host, owner, this.zeebeName('userTask'))} (or remove the listeners: \`bpmn ext remove <file> ${idOf(host)} ${this.zeebeName('taskListeners')}\`).`);
-    }
-    this.kids(zeebeElement, 'taskListener').forEach((listener, index) => {
-      const ev = attr(listener, 'eventType');
-      const label = `Task listener ${index + 1}${ev ? ` (${ev})` : ''} of ${where}`;
-      const again = (fix: string): string => `\`bpmn ext remove <file> ${idOf(host)} ${sh(`${this.zeebeName('taskListeners')}/${this.zeebeName('taskListener')}[${index}]`)}\`, then ${this.extAdd(host, owner, `${this.zeebeName('taskListeners')}/${this.zeebeName('taskListener')} ${fix}`)}`;
-      if (missing(attr(listener, 'type'))) {
-        this.push('deploy', 'W_C8_DEPLOY_LISTENER', host, owner, `taskListener:${index}:type`, `${label} has no type (the job type of its worker); Camunda 8 refuses the file`, `Rebuild it: ${again(`eventType=${ev ?? '<event>'} type=<jobType>`)}.`);
-      }
-      if (blank(ev)) {
-        this.push('deploy', 'W_C8_DEPLOY_LISTENER', host, owner, `taskListener:${index}:eventType`, `${label} has no eventType; Camunda 8 refuses the file`, `Rebuild it: ${again(`eventType=<creating|assigning|updating|completing|canceling> type=${attr(listener, 'type') ?? '<jobType>'}`)}.`);
-      } else if (!TASK_LISTENER_EVENTS.includes(ev!)) {
-        this.push('deploy', 'W_C8_DEPLOY_LISTENER', host, owner, `taskListener:${index}:eventType`, `${label}: eventType "${ev}" is not one of creating, assigning, updating, completing, canceling; Camunda 8 refuses the file`, `Rebuild it: ${again(`eventType=<creating|assigning|updating|completing|canceling> type=${attr(listener, 'type') ?? '<jobType>'}`)}.`);
-      }
-    });
-  }
-
-  private checkLinkedResources(host: El, owner: El | undefined, zeebeElement: El): void {
-    const where = this.describe(host, owner);
-    const rebuild = (): string => this.rebuildHint(host, owner, this.zeebeName('linkedResources'));
-    this.kids(zeebeElement, 'linkedResource').forEach((resource, index) => {
-      if (missing(attr(resource, 'resourceType'))) {
-        this.push('deploy', 'W_C8_DEPLOY_EXTENSION', host, owner, `linkedResource:${index}:resourceType`, `Linked resource ${attr(resource, 'linkName') ?? index + 1} of ${where} has no resourceType; Camunda 8 refuses the file`, rebuild());
-      }
-      const bindingType = attr(resource, 'bindingType');
-      if (bindingType !== undefined && !BINDING_TYPES.includes(bindingType)) {
-        this.push('deploy', 'W_C8_DEPLOY_EXTENSION', host, owner, `linkedResource:${index}:bindingType`, `Linked resource ${attr(resource, 'linkName') ?? index + 1} of ${where} has bindingType="${bindingType}"; Camunda 8 accepts ${BINDING_TYPES.join(', ')} only and refuses the file`, rebuild());
-      } else if (bindingType === 'versionTag' && blank(attr(resource, 'versionTag'))) {
-        this.push('deploy', 'W_C8_DEPLOY_EXTENSION', host, owner, `linkedResource:${index}:versionTag`, `Linked resource ${attr(resource, 'linkName') ?? index + 1} of ${where} has bindingType="versionTag" but no versionTag; Camunda 8 refuses the file`, rebuild());
-      }
-    });
-  }
-
-  private checkAdHoc(host: El, owner: El | undefined, zeebeElement: El): void {
-    const where = this.describe(host, owner);
-    const oc = attr(zeebeElement, 'outputCollection');
-    const oe = attr(zeebeElement, 'outputElement');
-    if ((oc === undefined) === (oe === undefined)) return;
-    this.push('deploy', 'W_C8_DEPLOY_EXTENSION', host, owner, 'adHoc:output', `${this.zeebeName('adHoc')} of ${where} has ${oc !== undefined ? 'an outputCollection without outputElement' : 'an outputElement without outputCollection'}; Camunda 8 refuses the file`, `${this.extAdd(host, owner, `${this.zeebeName('adHoc')} ${oc !== undefined ? 'outputElement==<expression>' : 'outputCollection=<variable>'}`)}.`);
-  }
-
-  private checkConditionalFilter(host: El, owner: El | undefined, zeebeElement: El): void {
-    const where = this.describe(host, owner);
-    const rebuild = (): string => this.rebuildHint(host, owner, this.zeebeName('conditionalFilter'));
-    const events = attr(zeebeElement, 'variableEvents');
-    if (events === undefined) return;
-    const bad = events.split(',').map((eventName) => eventName.trim()).filter((eventName) => eventName && eventName !== 'create' && eventName !== 'update');
-    if (bad.length) {
-      this.push('deploy', 'W_C8_DEPLOY_EXTENSION', host, owner, 'conditionalFilter:variableEvents', `${this.zeebeName('conditionalFilter')} of ${where} lists the variable events ${bad.join(', ')}; Camunda 8 knows create and update only and refuses the file`, `${rebuild()} (variableEvents=create,update)`);
-    }
-  }
-
-  private checkPriority(host: El, owner: El | undefined, zeebeElement: El): void {
-    const where = this.describe(host, owner);
-    const prio = attr(zeebeElement, 'priority');
-    if (prio === undefined || prio === '' || isFeel(prio) || (/^\s*\d+\s*$/.test(prio) && Number(prio) <= 100)) {
-      return;
-    }
-    this.push('deploy', 'W_C8_DEPLOY_USER_TASK', host, owner, 'priority', `${this.zeebeName('priorityDefinition')} of ${where} has priority "${prio}"; Camunda 8 needs a number from 0 to 100 (or an expression) and refuses the file`, this.fixHint(host, owner, zeebeElement, { priority: '50' }));
-  }
-
-  private checkTaskSchedule(host: El, owner: El | undefined, zeebeElement: El): void {
-    const where = this.describe(host, owner);
-    for (const dateAttribute of ['dueDate', 'followUpDate']) {
-      const dateValue = attr(zeebeElement, dateAttribute);
-      if (dateValue !== undefined && !isFeel(dateValue) && dateValue.trim() !== '' && !new TimerValue(dateValue).isDateTime()) {
-        this.push('deploy', 'W_C8_DEPLOY_USER_TASK', host, owner, `taskSchedule:${dateAttribute}`, `${this.zeebeName('taskSchedule')} of ${where} has ${dateAttribute}="${dateValue}", which is no ISO 8601 date-time with offset (2030-03-02T15:35+02:00); Camunda 8 refuses the file`, this.fixHint(host, owner, zeebeElement, { [dateAttribute]: '2030-03-02T15:35+02:00' }).replace(/\.$/, ' (or an expression: =<FEEL>).'));
-      }
-    }
-  }
-
-  /** Task headers: duplicate keys (refused), headers without key or value (dropped). */
-  private checkHeaders(host: El, owner: El | undefined, headers: El, inWhat: string): void {
-    const where = `${inWhat ? `${inWhat} of ` : ''}${this.describe(host, owner)}`;
-    const seen = new Set<string>();
-    this.kids(headers, 'header').forEach((header, index) => {
-      const key = attr(header, 'key');
-      const value = attr(header, 'value');
-      if (blank(key) || blank(value)) {
-        this.push('runtime', 'W_C8_BAD_VALUE', host, owner, `header:${inWhat}:${index}`, `Task header ${key ? `"${key}"` : index + 1} of ${where} has no ${blank(key) ? 'key' : 'value'}; Camunda 8 drops it, the job does not carry it`, idOf(host) && !inWhat ? `${blank(key) ? `Remove it (\`bpmn ext remove <file> ${idOf(host)} ${sh(`${this.zeebeName('taskHeaders')}/${this.zeebeName('header')}[${index}]`)}\`) and add it with a key` : 'Give it a value'}: ${this.extAdd(host, owner, `${this.zeebeName('header')} key=${key ?? '<key>'} value=<value>`)}.` : 'Fix it in the XML.');
-      }
-      if (key !== undefined && !blank(key)) {
-        if (seen.has(key)) {
-          this.push('deploy', 'W_C8_DEPLOY_EXTENSION', host, owner, `header:${inWhat}:dup:${key}`, `${where} has the task header "${key}" twice; Camunda 8 refuses the file`, idOf(host) && !inWhat ? `Keep one: \`bpmn ext remove <file> ${idOf(host)} ${sh(`${this.zeebeName('taskHeaders')}/${this.zeebeName('header')}[${index}]`)}\`.` : 'Remove one in the XML.');
-        }
-        seen.add(key);
-      }
-    });
-  }
-}
diff --git a/src/domain/validation/profiles/c8/C8FlowRules.ts b/src/domain/validation/profiles/c8/C8FlowRules.ts
deleted file mode 100644
index ef2b62a4..00000000
--- a/src/domain/validation/profiles/c8/C8FlowRules.ts
+++ /dev/null
@@ -1,102 +0,0 @@
-import type { Trigger } from '../../../document/Kinds.js';
-import type { El } from '../../../document/utils/moddle.js';
-import type { RuleRun } from '../RuleRun.js';
-import { idOf, list, nameOf, peek, triggerName } from '../../utils/element.js';
-import { sh } from '../../utils/hint.js';
-import { feelOf, isFeel } from '../../utils/c8-value.js';
-import { C8Rules } from './C8Rules.js';
-
-/** Sequence flows, gateways and sub-process kinds Camunda 8 runs differently or not at all. */
-export class C8FlowRules extends C8Rules {
-  /** flows whose source does not list them in the file's text: flow -> source */
-  private readonly unlisted = new Map<El, El>();
-
-  constructor(run: RuleRun, prefix: string) {
-    super(run, prefix);
-    const { doc } = run;
-    if (doc.source) {
-      for (const entry of run.kit.unkeptEntries(doc.definitions, doc.source.mirror)) {
-        if (entry.direction === 'outgoing') this.unlisted.set(entry.flow, entry.node);
-      }
-    }
-  }
-
-  checkTransaction(el: El): void {
-    this.push('deploy', 'W_C8_DEPLOY_UNSUPPORTED', el, undefined, 'transaction', `${this.describe(el)} is a transaction; Camunda 8 does not support transactions and refuses the file`, `\`bpmn retype <file> ${idOf(el)} subProcess\` (an embedded sub-process).`);
-  }
-
-  checkComplexGateway(el: El): void {
-    this.push('deploy', 'W_C8_DEPLOY_UNSUPPORTED', el, undefined, 'complexGateway', `Complex gateway ${idOf(el)}: Camunda 8 does not support complex gateways and refuses the file`, `\`bpmn retype <file> ${idOf(el)} inclusiveGateway\` (or exclusiveGateway: one path).`);
-  }
-
-  /** Checks an ad-hoc sub-process; a static completion condition is refused at deploy (unlike a multi-instance one). */
-  checkAdHoc(el: El): void {
-    const id = idOf(el)!;
-    const nodes = this.doc.flowNodes(el);
-    for (const node of nodes) {
-      if (this.kit.is(node, 'bpmn:StartEvent') || this.kit.is(node, 'bpmn:EndEvent')) {
-        this.push('deploy', 'W_C8_DEPLOY_AD_HOC_SUBPROCESS', el, undefined, `adHoc:${idOf(node)}`, `Ad-hoc sub-process ${id} contains the ${this.kit.is(node, 'bpmn:StartEvent') ? 'start' : 'end'} event ${idOf(node)}; Camunda 8 refuses start and end events in ad-hoc sub-processes`, `\`bpmn remove <file> ${idOf(node)}\`.`, [idOf(node)!]);
-      }
-    }
-    if (!nodes.some((node) => this.kit.is(node, 'bpmn:Activity'))) {
-      this.push('deploy', 'W_C8_DEPLOY_AD_HOC_SUBPROCESS', el, undefined, 'adHoc:empty', `Ad-hoc sub-process ${id} contains no activity; Camunda 8 refuses the file`, `\`bpmn add <file> serviceTask "<Name>" --in ${id}\`.`);
-    }
-    const cc = peek<El>(el, 'completionCondition');
-    if (cc) {
-      const body = peek<string>(cc, 'body') ?? '';
-      const fix = `\`bpmn set <file> ${id} ${sh(`completion==${feelOf(isFeel(body) ? body.trim().slice(1) : body)}`)}\` (check the FEEL syntax)`;
-      if (!isFeel(body)) {
-        this.push('deploy', 'W_C8_DEPLOY_EXPRESSION', el, undefined, 'adHoc:completion', `The completion condition "${body.trim()}" of ad-hoc sub-process ${id} is no FEEL expression; Camunda 8 needs one starting with = and refuses the file`, `${fix}, or remove it: \`bpmn set <file> ${id} completion=\`.`);
-      } else {
-        this.checkFeel(el, undefined, 'adHoc:completion', `The completion condition of ad-hoc sub-process ${id}`, body, `${fix}.`);
-      }
-    }
-  }
-
-  /** Checks the condition of a sequence flow; out of complex gateways it is W_C8_DEPLOY_UNSUPPORTED, out of parallel / event-based ones W_CONDITION_IGNORED. */
-  checkFlow(flow: El): void {
-    const cond = peek<El>(flow, 'conditionExpression');
-    if (!cond) return;
-    const id = idOf(flow)!;
-    const body = peek<string>(cond, 'body') ?? '';
-    const source = peek<El>(flow, 'sourceRef');
-    this.checkFeel(flow, undefined, 'condition', `The condition of sequence flow ${id}`, body, `\`bpmn set <file> ${id} ${sh(`condition==${feelOf(body.trim().slice(1))}`)}\` (check the FEEL syntax: and / or, = for equality, not(...)).`);
-    if (!isFeel(body)) {
-      this.push('deploy', 'W_C8_DEPLOY_EXPRESSION', flow, undefined, 'condition', `The condition "${body.trim()}" of sequence flow ${id} is no FEEL expression; Camunda 8 needs one starting with = and refuses the file`, body.trim() ? `\`bpmn set <file> ${id} ${sh(`condition==${feelOf(body)}`)}\` (check the FEEL syntax: and / or, = for equality).` : `Give it one (\`bpmn set <file> ${id} ${sh('condition== <expression>')}\`) or remove it (\`bpmn set <file> ${id} condition=\`).`);
-    }
-    if (source && !this.kit.is(source, 'bpmn:Gateway')) {
-      this.push('runtime', 'W_C8_CONDITION_IGNORED', flow, undefined, 'conditionIgnored', `Sequence flow ${id} out of ${this.describe(source)} has a condition; Camunda 8 evaluates conditions at exclusive and inclusive gateways only and always takes this flow`, `Remove it (\`bpmn set <file> ${id} condition=\`), or branch with a gateway: \`bpmn add <file> exclusiveGateway "<Question?>" --after ${idOf(source)}\`, then move the condition onto its flows.`);
-    }
-  }
-
-  checkBranchingGateway(gw: El): void {
-    const flows = this.outgoing.get(gw) ?? [];
-    if (flows.length < 2) return;
-    const def = peek<El>(gw, 'default');
-    for (const flow of flows) {
-      if (flow === def || peek<El>(flow, 'conditionExpression')) continue;
-      this.push('runtime', 'W_C8_EXCLUSIVE_GATEWAY', gw, undefined, `noCondition:${idOf(flow)}`, `Sequence flow ${idOf(flow)} out of ${this.describe(gw)} has no condition and is not the default flow: Camunda 8 never takes it (an instance where no condition holds gets an incident)`, `Make it the default flow (\`bpmn set <file> ${idOf(flow)} default=true\`) or give it a condition: \`bpmn set <file> ${idOf(flow)} ${sh('condition== <expression>')}\`.`, [idOf(flow)!]);
-    }
-  }
-
-  /** Checks an event-based gateway; the engine counts its <bpmn:outgoing> entries, which a file may leave out. */
-  checkEventGateway(gw: El): void {
-    const id = idOf(gw)!;
-    const flows = this.outgoing.get(gw) ?? [];
-    const listed = flows.filter((flow) => !this.unlisted.has(flow) || this.unlisted.get(flow) !== gw);
-    if (flows.length < 2) {
-      this.push('deploy', 'W_C8_DEPLOY_EVENT_GATEWAY', gw, undefined, 'branches', `Event-based gateway ${id} has ${flows.length} outgoing flow${flows.length === 1 ? '' : 's'}; Camunda 8 needs at least two and refuses the file`, `Add a branch: \`bpmn add <file> intermediateCatchEvent:timer "<Timeout>" --after ${id} --timer PT1H\`.`);
-    } else if (listed.length < 2) {
-      this.push('deploy', 'W_C8_DEPLOY_EVENT_GATEWAY', gw, undefined, 'branches', `Event-based gateway ${id} has ${flows.length} outgoing flows, but the file lists ${listed.length} of them as its <bpmn:outgoing> entries; Camunda 8 counts the listed ones and refuses the file`, `Add the missing <bpmn:outgoing>${flows.filter((flow) => !listed.includes(flow)).map(idOf).join('</bpmn:outgoing>, <bpmn:outgoing>')}</bpmn:outgoing> entries to ${id} in the XML (Camunda Modeler writes them; this file leaves the lists out, and \`bpmn\` keeps a file's style).`);
-    }
-    for (const flow of flows) {
-      const target = peek<El>(flow, 'targetRef');
-      if (!target) continue;
-      const defs = list(target, 'eventDefinitions');
-      const ok = this.kit.is(target, 'bpmn:IntermediateCatchEvent') && defs.length === 1 && this.kit.EVENT_GATEWAY_TRIGGERS.includes(triggerName(defs[0]!) as Trigger);
-      if (!ok) {
-        this.push('deploy', 'W_C8_DEPLOY_EVENT_GATEWAY', gw, undefined, `target:${idOf(target)}`, `Event-based gateway ${id} leads to ${this.describe(target)}; Camunda 8 allows only message, timer, signal and conditional intermediate catch events after it and refuses the file`, this.kit.is(target, 'bpmn:ReceiveTask') ? `Use a message catch event: \`bpmn retype <file> ${idOf(target)} intermediateCatchEvent:message --message ${sh(nameOf(this.messageOf(target)) ?? '<MessageName>')}\`.` : `Put a catch event in between: \`bpmn add <file> intermediateCatchEvent:message "<Name>" --flow ${idOf(flow)} --message <MessageName>\` (or retype ${idOf(target)}).`, [idOf(target)!, idOf(flow)!]);
-      }
-    }
-  }
-}
diff --git a/src/domain/validation/profiles/c8/C8Rules.ts b/src/domain/validation/profiles/c8/C8Rules.ts
deleted file mode 100644
index 764ce0c0..00000000
--- a/src/domain/validation/profiles/c8/C8Rules.ts
+++ /dev/null
@@ -1,91 +0,0 @@
-import type { El } from '../../../document/utils/moddle.js';
-import { EngineRules } from '../EngineRules.js';
-import { FeelExpression } from '../FeelExpression.js';
-import { idOf, isGeneric, list, localName, peek } from '../../utils/element.js';
-import { lowerFirst, sh, slotted } from '../../utils/hint.js';
-import { isFeel } from '../../utils/c8-value.js';
-
-/** Base of the Camunda 8 rule classes: how Zeebe reads zeebe content, and how hints rebuild it. */
-export abstract class C8Rules extends EngineRules {
-  /** `userTask userTask_x`, `the multiInstanceLoopCharacteristics of userTask userTask_x` */
-  protected describe(el: El, owner?: El): string {
-    const id = idOf(el);
-    const kind = this.kit.isBpmnElement(el) ? lowerFirst(this.kit.kindLabel(el).replace(/^bpmn:/, '')) : el.$type;
-    if (id) return `${kind} ${id}`;
-    return owner ? `the ${lowerFirst(localName(el.$type))} of ${this.describe(owner)}` : kind;
-  }
-
-  /** Top-level zeebe extension elements of type `local`. */
-  protected zeebe(el: El | undefined, local: string): El[] {
-    return this.extensionValues(el)
-      .filter((extValue) => extValue.uri === this.kit.zeebe.uri && extValue.local === local)
-      .map((extValue) => extValue.el);
-  }
-
-  /** Zeebe children of a generic element (all, or of type `local`). */
-  protected kids(el: El, local?: string): El[] {
-    const raw = peek<unknown[]>(el, '$children');
-    if (!Array.isArray(raw)) return [];
-    return (raw as El[]).filter((child) => child && typeof child.$type === 'string' && isGeneric(child) && this.ns.uriOfElement(child) === this.kit.zeebe.uri && (local === undefined || localName(child.$type) === local));
-  }
-
-  /** `<prefix>:taskDefinition` in the file's spelling. */
-  protected zeebeName(local: string): string {
-    return `${this.prefix}:${local}`;
-  }
-
-  protected messageOf(el: El): El | undefined {
-    if (this.kit.is(el, 'bpmn:ReceiveTask') || this.kit.is(el, 'bpmn:SendTask')) {
-      return peek<El>(el, 'messageRef');
-    }
-    const def = list(el, 'eventDefinitions').find((definition) => this.kit.is(definition, 'bpmn:MessageEventDefinition'));
-    return peek<El>(def, 'messageRef');
-  }
-
-  /** `bpmn ext add <file> <id> <args>` for an element (with its slot prefix for a nested one). */
-  protected extAdd(el: El, owner: El | undefined, args: string): string {
-    const addr = this.addressOf(el, owner);
-    if (!addr) return 'edit the XML';
-    return `\`bpmn ext add <file> ${addr.id} ${slotted(addr.prefix, args)}\``;
-  }
-
-  /**
-   * `bpmn ext add` that rebuilds the flat zeebe element `v` with `fix` laid over its attributes
-   * (`--replace` replaces it as a whole, so it carries every attribute); undefined with children.
-   */
-  private replaceCommand(host: El, owner: El | undefined, zeebeElement: El, fix: Record<string, string>): string | undefined {
-    if (this.kids(zeebeElement).length) return undefined;
-    const attrs: Record<string, string> = {};
-    for (const [key, val] of Object.entries(zeebeElement as unknown as Record<string, unknown>)) {
-      if (key.startsWith('$') || key.startsWith('xmlns') || val === undefined || val === null || typeof val === 'object') {
-        continue;
-      }
-      attrs[key] = String(val);
-    }
-    Object.assign(attrs, fix);
-    const args = Object.entries(attrs).map(([key, val]) => sh(`${key}=${val}`));
-    return this.extAdd(host, owner, [zeebeElement.$type, ...args, '--replace'].join(' '));
-  }
-
-  /** The replace command for `v`, or the list-and-rebuild hint when it has children. */
-  protected fixHint(host: El, owner: El | undefined, zeebeElement: El, fix: Record<string, string>): string {
-    const cmd = this.replaceCommand(host, owner, zeebeElement, fix);
-    return cmd ? `${cmd}.` : this.rebuildHint(host, owner, zeebeElement.$type);
-  }
-
-  /** How to rebuild a zeebe element with its content: list it, then add it again with --replace. */
-  protected rebuildHint(host: El, owner: El | undefined, type: string): string {
-    const addr = this.addressOf(host, owner);
-    if (!addr) return 'Fix it in the XML.';
-    return `See it with \`bpmn ext list <file> ${addr.id} --json\`, then rebuild it: \`bpmn ext add <file> ${addr.id} ${sh(`${addr.prefix}${type}`)} --replace --xml '<${type} ...>...</${type}>'\`.`;
-  }
-
-  /** Reports a FEEL value (=...) with a slip FeelExpression finds; true when it reported one. */
-  protected checkFeel(el: El, owner: El | undefined, subject: string, what: string, value: string | undefined, fix: string): boolean {
-    if (!isFeel(value)) return false;
-    const problem = new FeelExpression(value!.trim().slice(1)).problem();
-    if (!problem) return false;
-    this.push('deploy', 'W_C8_DEPLOY_EXPRESSION', el, owner, `feel:${subject}`, `${what} "${value!.trim()}" is no valid FEEL: ${problem}; Camunda 8 parses it at deploy and refuses the file`, fix);
-    return true;
-  }
-}
diff --git a/src/domain/validation/profiles/c8/C8SchemaRules.ts b/src/domain/validation/profiles/c8/C8SchemaRules.ts
deleted file mode 100644
index c41fad9c..00000000
--- a/src/domain/validation/profiles/c8/C8SchemaRules.ts
+++ /dev/null
@@ -1,105 +0,0 @@
-import type { El } from '../../../document/utils/moddle.js';
-import { NCNAME, type SchemaTextIssue } from '../SchemaText.js';
-import { idOf, isGeneric, list, localName, peek } from '../../utils/element.js';
-import { sh } from '../../utils/hint.js';
-import { missing } from '../../utils/c8-value.js';
-import { C8Rules } from './C8Rules.js';
-
-/** What Camunda 8 checks of the file as a whole: an executable process, the BPMN schema, ids. */
-export class C8SchemaRules extends C8Rules {
-  checkExecutable(processes: El[], executable: El[]): void {
-    if (!processes.length || executable.length) return;
-    const first = processes[0]!;
-    const what = processes.length === 1 ? `Process ${idOf(first)} is not executable` : `None of the ${processes.length} processes is executable`;
-    this.push('deploy', 'W_C8_DEPLOY_EXECUTABLE', first, undefined, 'executable', `${what} (no isExecutable="true"); Camunda 8 refuses to deploy a file without an executable process`, `\`bpmn set <file> ${idOf(first)} isExecutable=true\`.`);
-  }
-
-  /**
-   * Attributes without a namespace prefix that BPMN does not define, and extension elements on
-   * bpmn:definitions: Camunda 8 validates the file against the BPMN schema (cvc-complex-type).
-   */
-  checkSchema(): void {
-    if (list(peek<El>(this.doc.definitions, 'extensionElements'), 'values').length) {
-      this.push('deploy', 'W_C8_DEPLOY_SCHEMA', this.doc.definitions, undefined, 'definitions', `bpmn:definitions carries bpmn:extensionElements, which the BPMN schema does not allow there; Camunda 8 refuses the file`, `Move the content to the process: \`bpmn ext remove <file> ${idOf(this.doc.definitions) ?? '<definitionsId>'} <type>\`, then \`bpmn ext add <file> <processId> <type> ...\`.`);
-    }
-    for (const { el, owner, id, di, addr, keys } of this.unprefixedAttributes()) {
-      for (const key of keys) {
-        const where = el === owner ? this.describe(el) : `${el.$type}${id ? ` in ${id}` : ''}`;
-        const link = el === owner && !!id && this.kit.is(el, 'bpmn:BusinessRuleTask') && (key === 'calledDecision' || key === 'calledElement') ? new this.kit.DecisionLinkReader(this.doc).linkOf(el) : undefined;
-        const remove = addr ? `\`bpmn set <file> ${addr.id} ${sh(`${addr.prefix}${key}=`)}\`` : undefined;
-        const hint = link
-          ? `Write the decision link the Camunda 8 way: \`bpmn set <file> ${id} ${sh(`calledDecision=${link.value}`)}\` (${this.zeebeName('calledDecision')}; the unprefixed ${key} is removed; give it a resultVariable).`
-          : remove
-            ? `Remove it: ${remove} (vendor attributes need their namespace prefix; Camunda 8 settings are mostly ${this.prefix}: extension elements).`
-            : di
-              ? `Remove ${key}="..." from the XML of ${id ?? 'the diagram element'}, or redraw the diagram: \`bpmn layout <file>\` (the hand-made layout is lost).`
-              : `Remove ${key}="..." from the XML${id ? ` of ${id}` : ''}.`;
-        this.push('deploy', 'W_C8_DEPLOY_SCHEMA', el, owner, `schema:${key}`, `${where} has the attribute ${key}, which the BPMN schema does not define; Camunda 8 validates the file against the schema and refuses it`, hint);
-      }
-    }
-  }
-
-  /**
-   * An id the BPMN schema does not allow: bpmn-moddle reads `prefix:name` ids, Camunda 8 refuses
-   * them (cvc-datatype-valid).
-   */
-  checkIds(): void {
-    for (const el of this.kit.walk(this.doc.definitions)) {
-      if (isGeneric(el)) continue;
-      const id = peek<string>(el, 'id');
-      if (typeof id !== 'string' || !id || NCNAME.test(id.trim())) continue;
-      const di = this.kit.isDiElement(el);
-      const fixed = id.replace(/[^A-Za-z0-9_.-]+/g, '_').replace(/^(?=[^A-Za-z_])/, '_');
-      this.push('deploy', 'W_C8_DEPLOY_SCHEMA', el, undefined, `id:${id}`, `${di ? el.$type : this.describe(el)} has the id "${id}", which is no XML NCName (${id.includes(':') ? 'a colon is not allowed in an id' : 'letters, digits, _ . - and no leading digit'}); Camunda 8 validates the file against the BPMN schema and refuses it`, di ? `Rename it in the XML (or redraw the diagram: \`bpmn layout <file>\`).` : `\`bpmn set <file> ${sh(id)} id=${fixed}\`.`);
-    }
-  }
-
-  /**
-   * Child element order and IDREFs that name no id, read from the file's text (SchemaText): the
-   * model shows neither, Camunda 8 refuses both. An issue of an element an edit removed is gone.
-   * An invalid id is reported here only for an element bpmn-moddle could not read; checkIds reports the others.
-   */
-  checkSchemaText(issues: SchemaTextIssue[]): void {
-    for (const issue of issues) {
-      if (issue.kind === 'id') {
-        if (this.doc.get(issue.value!)) continue;
-        this.push('deploy', 'W_C8_DEPLOY_SCHEMA', this.doc.definitions, undefined, `id:${issue.value}`, `<bpmn:${issue.element}> has the id "${issue.value}", which is no XML NCName (${issue.value!.includes(':') ? 'a colon is not allowed in an id' : 'letters, digits, _ . - and no leading digit'}); bpmn-moddle cannot read the element (an import warning) and Camunda 8 validates the file against the BPMN schema and refuses it`, `Rename it in the XML (and every reference to it), e.g. to ${issue.value!.replace(/[^A-Za-z0-9_.-]+/g, '_').replace(/^(?=[^A-Za-z_])/, '_')}.`);
-        continue;
-      }
-      const owner = issue.owner !== undefined ? this.doc.get(issue.owner) : undefined;
-      if (issue.owner !== undefined && !owner) continue;
-      const where = owner ? this.describe(owner) : `<${issue.element}>`;
-      if (issue.kind === 'boolean') {
-        const what = owner && issue.element !== localName(owner.$type).replace(/^./, (firstLetter) => firstLetter.toLowerCase()) ? `<${issue.element.startsWith('BPMN') ? 'bpmndi' : 'bpmn'}:${issue.element}> of ${where}` : where;
-        this.push('deploy', 'W_C8_DEPLOY_SCHEMA', owner ?? this.doc.definitions, undefined, `boolean:${issue.element}:${issue.ref}`, `${what[0]!.toUpperCase()}${what.slice(1)} has ${issue.ref}="${issue.value}", which is no xsd:boolean (true or false; bpmn-moddle reads it as false); Camunda 8 validates the file against the BPMN schema and refuses it`, `Write ${issue.ref}="true" or ${issue.ref}="false" in the XML of ${owner ? idOf(owner) : `<${issue.element}>`}.`);
-        continue;
-      }
-      if (issue.kind === 'order') {
-        const what = owner && issue.element !== localName(owner.$type).replace(/^./, (firstLetter) => firstLetter.toLowerCase()) ? `<bpmn:${issue.element}> of ${where}` : where;
-        this.push('deploy', 'W_C8_DEPLOY_SCHEMA', owner ?? this.doc.definitions, undefined, `order:${issue.element}/${issue.child}`, `In ${what}, <bpmn:${issue.child}> comes after <bpmn:${issue.before}>; the BPMN schema puts ${issue.child} before ${issue.before}, and Camunda 8 validates the file against the schema and refuses it`, `Move <bpmn:${issue.child}> before <bpmn:${issue.before}> in the XML of ${owner ? idOf(owner) : `<${issue.element}>`} (Camunda Modeler and \`bpmn\` write that order for the elements they create or change).`);
-      } else {
-        const ref = issue.attribute ? `${issue.ref}="${issue.value}"` : `<bpmn:${issue.ref}>${issue.value}</bpmn:${issue.ref}>`;
-        this.push('deploy', 'W_C8_DEPLOY_SCHEMA', owner ?? this.doc.definitions, undefined, `idref:${issue.ref}:${issue.value}`, `${where[0]!.toUpperCase()}${where.slice(1)} has ${ref}, but the file has no element with the id ${issue.value}; Camunda 8 checks such references against the ids of the file (cvc-id.1) and refuses it`, `Remove ${ref} from ${issue.owner ?? `<bpmn:${issue.element}>`} in the XML, or point it at an element of the file (bpmn-moddle drops the reference when it reads the file: \`bpmn\` refuses to write the file without --force, and a forced write leaves it out).`);
-      }
-    }
-  }
-
-  /**
-   * Every event definition of the file: a conditional one needs a condition, a link one a name.
-   * A missing link name is refused by the schema, an empty one by Camunda 8 ("must be present and not empty").
-   */
-  checkSchemaEventDefinitions(): void {
-    for (const def of this.kit.walk(this.doc.definitions, { bpmnOnly: true })) {
-      if (!this.kit.is(def, 'bpmn:EventDefinition')) continue;
-      const event = def.$parent as El | undefined;
-      const id = idOf(event);
-      const label = id ? this.describe(event!) : def.$type;
-      if (this.kit.is(def, 'bpmn:ConditionalEventDefinition') && !peek<El>(def, 'condition')) {
-        this.push('deploy', 'W_C8_DEPLOY_EVENT_DEFINITION', event ?? def, undefined, 'schema:condition', `The conditional event definition of ${label} has no condition element, which the BPMN schema requires; Camunda 8 refuses the file`, id ? `\`bpmn set <file> ${id} ${sh('when== <expression>')}\`.` : 'Fix it in the XML.');
-      } else if (this.kit.is(def, 'bpmn:LinkEventDefinition') && missing(peek<string>(def, 'name'))) {
-        const none = peek<string>(def, 'name') === undefined || peek<string>(def, 'name') === null;
-        this.push('deploy', 'W_C8_DEPLOY_LINK', event ?? def, undefined, 'schema:linkName', `The link event definition of ${label} has ${none ? 'no name, which the BPMN schema requires' : 'an empty name'}; Camunda 8 refuses the file`, id ? `\`bpmn set <file> ${id} link=<Name>\` (the throw and the catch event of a pair share the name).` : 'Fix it in the XML.');
-      }
-    }
-  }
-}
diff --git a/src/domain/validation/profiles/c8/C8TaskRules.ts b/src/domain/validation/profiles/c8/C8TaskRules.ts
deleted file mode 100644
index 3eefa469..00000000
--- a/src/domain/validation/profiles/c8/C8TaskRules.ts
+++ /dev/null
@@ -1,174 +0,0 @@
-import type { El } from '../../../document/utils/moddle.js';
-import { attr, idOf, peek } from '../../utils/element.js';
-import { sh } from '../../utils/hint.js';
-import { blank, feelOf, isFeel, missing, nameAttr } from '../../utils/c8-value.js';
-import { C8Rules } from './C8Rules.js';
-
-/** How tasks are implemented: jobs, scripts, decisions, published messages, user tasks, loops. */
-export class C8TaskRules extends C8Rules {
-  /** A job: exactly one zeebe:taskDefinition with a type (static job retries checked too). */
-  private checkTaskDefinition(el: El, label: string, alternative?: { local: string; count: number; text: string }): void {
-    const tds = this.zeebe(el, 'taskDefinition');
-    const id = idOf(el)!;
-    const alt = alternative?.count ?? 0;
-    if (tds.length === 0 && alt === 0) {
-      this.push('deploy', 'W_C8_DEPLOY_IMPLEMENTATION', el, undefined, 'impl', `${label} has no ${this.zeebeName('taskDefinition')}${alternative ? ` (nor ${alternative.text})` : ''}: Camunda 8 needs the job type a worker subscribes to and refuses the file`, `Give it a job type: \`bpmn ext add <file> ${id} ${this.zeebeName('taskDefinition')} type=<jobType>\`${alternative?.local === 'script' ? ` (or a FEEL script: \`bpmn ext add <file> ${id} ${this.zeebeName('script')} expression==<expression> resultVariable=<variable>\`)` : alternative?.local === 'calledDecision' ? ` (or call a DMN decision: \`bpmn ext add <file> ${id} ${this.zeebeName('calledDecision')} decisionId=<decisionId> resultVariable=<variable>\`)` : ''}.`);
-      return;
-    }
-    if (tds.length && alt) {
-      this.push('deploy', 'W_C8_DEPLOY_IMPLEMENTATION', el, undefined, 'impl:both', `${label} has both a ${this.zeebeName('taskDefinition')} and ${alternative!.text}; Camunda 8 needs exactly one of them and refuses the file`, `Keep one: \`bpmn ext remove <file> ${id} ${this.zeebeName('taskDefinition')}\` (or \`bpmn ext remove <file> ${id} ${this.zeebeName(alternative!.local)}\`).`);
-    }
-    for (const td of tds.slice(0, 1)) {
-      const type = attr(td, 'type');
-      if (missing(type)) {
-        this.push('deploy', 'W_C8_DEPLOY_IMPLEMENTATION', el, undefined, 'impl:type', `The ${this.zeebeName('taskDefinition')} of ${label} has no type; Camunda 8 refuses the file`, this.fixHint(el, undefined, td, { type: '<jobType>' }));
-      }
-      const retries = attr(td, 'retries');
-      if (retries !== undefined && !isFeel(retries) && !/^\s*-?\d+\s*$/.test(retries)) {
-        this.push('runtime', 'W_C8_BAD_VALUE', el, undefined, 'retries', `The ${this.zeebeName('taskDefinition')} of ${label} has retries="${retries}", which is no number; it deploys, but every instance gets an incident when it reaches ${id}`, this.fixHint(el, undefined, td, { retries: '3' }));
-      }
-    }
-  }
-
-  /** The message a send task / message throw or end event references needs a name. */
-  private checkThrownMessage(el: El, label: string): void {
-    const msg = this.messageOf(el);
-    if (msg && !nameAttr(msg)) {
-      this.push('deploy', 'W_C8_DEPLOY_IMPLEMENTATION', el, undefined, 'messageName', `Message ${idOf(msg)} of ${label} has no name; Camunda 8 refuses the file`, `\`bpmn set <file> ${idOf(msg)} name=<MessageName>\`.`, [idOf(msg)!]);
-    }
-  }
-
-  checkServiceLike(el: El): void {
-    const label = this.describe(el);
-    const id = idOf(el)!;
-    if (this.kit.is(el, 'bpmn:ServiceTask')) {
-      this.checkTaskDefinition(el, label);
-    } else if (this.kit.is(el, 'bpmn:SendTask')) {
-      const pm = this.zeebe(el, 'publishMessage');
-      this.checkTaskDefinition(el, label, { local: 'publishMessage', count: pm.length, text: `a ${this.zeebeName('publishMessage')}` });
-      this.checkThrownMessage(el, label);
-      if (pm.length && !this.zeebe(el, 'taskDefinition').length) {
-        this.checkPublishMessage(el, el, pm[0]!, label);
-      }
-    } else if (this.kit.is(el, 'bpmn:ScriptTask')) {
-      const scripts = this.zeebe(el, 'script');
-      this.checkTaskDefinition(el, label, { local: 'script', count: scripts.length, text: `a ${this.zeebeName('script')}` });
-      const script = scripts[0];
-      if (script && !this.zeebe(el, 'taskDefinition').length) {
-        const expr = attr(script, 'expression');
-        if (blank(expr)) {
-          this.push('deploy', 'W_C8_DEPLOY_IMPLEMENTATION', el, undefined, 'script:expression', `The ${this.zeebeName('script')} of ${label} has no expression; Camunda 8 refuses the file`, this.fixHint(el, undefined, script, { expression: '=<expression>' }));
-        } else if (!isFeel(expr)) {
-          this.push('deploy', 'W_C8_DEPLOY_EXPRESSION', el, undefined, 'script:expression', `The ${this.zeebeName('script')} expression "${expr}" of ${label} is a static value; Camunda 8 needs a FEEL expression starting with = and refuses the file`, this.fixHint(el, undefined, script, { expression: `=${expr!.trim()}` }));
-        }
-        if (missing(attr(script, 'resultVariable'))) {
-          this.push('deploy', 'W_C8_DEPLOY_IMPLEMENTATION', el, undefined, 'script:resultVariable', `The ${this.zeebeName('script')} of ${label} has no resultVariable; Camunda 8 refuses the file`, this.fixHint(el, undefined, script, { resultVariable: '<variable>' }));
-        }
-      }
-    } else if (this.kit.is(el, 'bpmn:BusinessRuleTask')) {
-      const calls = this.zeebe(el, 'calledDecision');
-      this.checkTaskDefinition(el, label, { local: 'calledDecision', count: calls.length, text: `a ${this.zeebeName('calledDecision')}` });
-      const call = calls[0];
-      if (call && !this.zeebe(el, 'taskDefinition').length) {
-        if (missing(attr(call, 'decisionId'))) {
-          this.push('deploy', 'W_C8_DEPLOY_IMPLEMENTATION', el, undefined, 'decision:decisionId', `The ${this.zeebeName('calledDecision')} of ${label} has no decisionId; Camunda 8 refuses the file`, `\`bpmn set <file> ${id} calledDecision=<decisionId>\`.`);
-        }
-        if (missing(attr(call, 'resultVariable'))) {
-          this.push('deploy', 'W_C8_DEPLOY_IMPLEMENTATION', el, undefined, 'decision:resultVariable', `The ${this.zeebeName('calledDecision')} of ${label} has no resultVariable; Camunda 8 refuses the file`, this.fixHint(el, undefined, call, { resultVariable: '<variable>' }));
-        }
-      }
-    }
-  }
-
-  /** A message throw / end event: a job, or a zeebe:publishMessage in its message definition. */
-  checkMessageThrow(el: El, def: El): void {
-    const label = this.describe(el);
-    const pm = this.zeebe(def, 'publishMessage');
-    this.checkTaskDefinition(el, label, { local: 'publishMessage', count: pm.length, text: `a ${this.zeebeName('publishMessage')} in its message event definition` });
-    this.checkThrownMessage(el, label);
-    if (pm.length && !this.zeebe(el, 'taskDefinition').length) {
-      this.checkPublishMessage(el, def, pm[0]!, label);
-    }
-  }
-
-  /** zeebe:publishMessage: Camunda 8.9 checks it (message, correlationKey) but does not run it. */
-  private checkPublishMessage(el: El, host: El, pm: El, label: string): void {
-    const id = idOf(el)!;
-    if (!this.messageOf(el)) {
-      this.push('deploy', 'W_C8_DEPLOY_MESSAGE', el, undefined, 'publish:messageRef', `${label} publishes no message (no message reference); Camunda 8 refuses the file`, `\`bpmn set <file> ${id} message=<MessageName>\`.`);
-    }
-    if (missing(attr(pm, 'correlationKey'))) {
-      this.push('deploy', 'W_C8_DEPLOY_MESSAGE', el, undefined, 'publish:correlationKey', `The ${this.zeebeName('publishMessage')} of ${label} has no correlationKey; Camunda 8 refuses the file`, `${this.extAdd(host, host === el ? undefined : el, `${this.zeebeName('publishMessage')} correlationKey==<expression>`)}.`);
-    }
-    const send = this.kit.is(el, 'bpmn:SendTask');
-    this.push('runtime', 'W_C8_UNSUPPORTED_IMPLEMENTATION', el, undefined, 'publishMessage', `${label} publishes its message with ${this.zeebeName('publishMessage')}: Camunda 8.9 accepts the file but does not run it (${send ? 'the instance gets an incident: only job worker send tasks are supported' : 'the event completes without sending anything'})`, `Use a job worker: \`bpmn ext remove <file> ${id} ${send ? '' : 'definition.'}${this.zeebeName('publishMessage')}\`, then \`bpmn ext add <file> ${id} ${this.zeebeName('taskDefinition')} type=<jobType>\`.`);
-  }
-
-  checkCallActivity(el: El): void {
-    const id = idOf(el)!;
-    const calls = this.zeebe(el, 'calledElement');
-    const bpmnCalled = peek<string>(el, 'calledElement');
-    if (!calls.length) {
-      this.push('deploy', 'W_C8_DEPLOY_CALLED_ELEMENT', el, undefined, 'calledElement', `Call activity ${id} has no ${this.zeebeName('calledElement')}${bpmnCalled ? ` (Camunda 8 does not read the BPMN calledElement="${bpmnCalled}")` : ''}; Camunda 8 refuses the file`, `\`bpmn ext add <file> ${id} ${this.zeebeName('calledElement')} processId=${sh(bpmnCalled || '<processId>')} propagateAllChildVariables=false\`.`);
-      return;
-    }
-    if (missing(attr(calls[0], 'processId'))) {
-      this.push('deploy', 'W_C8_DEPLOY_CALLED_ELEMENT', el, undefined, 'processId', `The ${this.zeebeName('calledElement')} of call activity ${id} has no processId; Camunda 8 refuses the file`, this.fixHint(el, undefined, calls[0]!, { processId: '<processId>' }));
-    }
-  }
-
-  checkUserTask(el: El): void {
-    const id = idOf(el)!;
-    const label = this.describe(el);
-    const camunda = this.zeebe(el, 'userTask').length > 0;
-    if (!camunda) {
-      this.push('practice', 'W_C8_JOB_WORKER_USER_TASK', el, undefined, 'jobWorkerUserTask', `${label} has no ${this.zeebeName('userTask')}: Camunda 8 creates a job of type io.camunda.zeebe:userTask for it instead of a user task, which the v2 user task API (/v2/user-tasks) and Tasklist in V2 mode do not list`, `Make it a Camunda user task: \`bpmn ext add <file> ${id} ${this.zeebeName('userTask')}\` (a form then needs formId or externalReference instead of an embedded formKey).`);
-    }
-    const form = this.zeebe(el, 'formDefinition')[0];
-    if (!form) return;
-    const has = (attribute: string): boolean => !blank(attr(form, attribute));
-    const [one, other] = camunda ? ['formId', 'externalReference'] : ['formId', 'formKey'];
-    if (has(one!) === has(other!)) {
-      const what = has(one!) ? `both ${one} and ${other}` : camunda && has('formKey') ? 'only an embedded formKey, which Camunda user tasks do not read' : `neither ${one} nor ${other}`;
-      this.push('deploy', 'W_C8_DEPLOY_USER_TASK', el, undefined, 'form', `The ${this.zeebeName('formDefinition')} of ${camunda ? 'Camunda' : 'job worker'} user task ${id} has ${what}; Camunda 8 needs exactly one of ${one} and ${other} and refuses the file`, `Rebuild it with one of them: \`bpmn ext add <file> ${id} ${this.zeebeName('formDefinition')} formId=<formId> --replace\` (${camunda ? 'a linked form deployed with the process, or externalReference=<url>' : 'a linked form, or formKey=<key>'}).`);
-    }
-  }
-
-  checkMultiInstance(activity: El): void {
-    const loop = peek<El>(activity, 'loopCharacteristics');
-    const id = idOf(activity)!;
-    if (this.kit.is(loop, 'bpmn:StandardLoopCharacteristics')) {
-      this.push('runtime', 'W_C8_STANDARD_LOOP', activity, undefined, 'standardLoop', `${this.describe(activity)} has a standard loop; Camunda 8 does not support standard loops and runs the activity once`, `Remove it (\`bpmn set <file> ${id} loop=none\`) and model the loop with a gateway, or make it a multi-instance: \`bpmn set <file> ${id} loop=sequential\`, then \`bpmn ext add <file> ${id} loop.${this.zeebeName('loopCharacteristics')} inputCollection==<items> inputElement=<item>\`.`);
-      return;
-    }
-    if (!this.kit.is(loop, 'bpmn:MultiInstanceLoopCharacteristics')) return;
-    const zl = this.zeebe(loop!, 'loopCharacteristics');
-    const add = `\`bpmn ext add <file> ${id} loop.${this.zeebeName('loopCharacteristics')} inputCollection==<items> inputElement=<item>\``;
-    if (!zl.length) {
-      this.push('deploy', 'W_C8_DEPLOY_MULTI_INSTANCE', activity, undefined, 'mi', `Multi-instance ${this.describe(activity)} has no ${this.zeebeName('loopCharacteristics')} on its loop (a BPMN loop cardinality or a camunda:collection is not read); Camunda 8 refuses the file`, `${add} (outputCollection=<results> outputElement==<expression> collects results).`);
-    } else {
-      const zeebeLoop = zl[0]!;
-      const input = attr(zeebeLoop, 'inputCollection');
-      if (blank(input)) {
-        this.push('deploy', 'W_C8_DEPLOY_MULTI_INSTANCE', activity, undefined, 'mi:inputCollection', `The ${this.zeebeName('loopCharacteristics')} of multi-instance ${this.describe(activity)} has no inputCollection; Camunda 8 refuses the file`, this.fixHint(loop!, activity, zeebeLoop, { inputCollection: '=<items>' }));
-      } else if (!isFeel(input)) {
-        this.push('deploy', 'W_C8_DEPLOY_EXPRESSION', activity, undefined, 'mi:inputCollection', `inputCollection="${input}" of multi-instance ${this.describe(activity)} is a static value; Camunda 8 needs a FEEL expression (=${input!.trim()}) and refuses the file`, this.fixHint(loop!, activity, zeebeLoop, { inputCollection: `=${input!.trim()}` }));
-      }
-      const oc = attr(zeebeLoop, 'outputCollection');
-      const oe = attr(zeebeLoop, 'outputElement');
-      if ((oc === undefined) !== (oe === undefined)) {
-        this.push('deploy', 'W_C8_DEPLOY_MULTI_INSTANCE', activity, undefined, 'mi:output', `The ${this.zeebeName('loopCharacteristics')} of multi-instance ${this.describe(activity)} has ${oc !== undefined ? 'an outputCollection without outputElement' : 'an outputElement without outputCollection'}; Camunda 8 refuses the file`, `\`bpmn ext add <file> ${id} loop.${this.zeebeName('loopCharacteristics')} ${oc !== undefined ? 'outputElement==<expression>' : 'outputCollection=<variable>'}\`.`);
-      } else if (oe !== undefined && !isFeel(oe)) {
-        this.push('deploy', 'W_C8_DEPLOY_EXPRESSION', activity, undefined, 'mi:outputElement', `outputElement="${oe}" of multi-instance ${this.describe(activity)} is a static value; Camunda 8 needs a FEEL expression (=${oe.trim()}) and refuses the file`, this.fixHint(loop!, activity, zeebeLoop, { outputElement: `=${oe.trim()}` }));
-      }
-    }
-    const cc = peek<El>(loop, 'completionCondition');
-    const body = peek<string>(cc, 'body');
-    if (cc) {
-      this.checkFeel(activity, undefined, 'mi:completion', `The completion condition of multi-instance ${this.describe(activity)}`, body, `\`bpmn set <file> ${id} ${sh(`completion==${feelOf((body ?? '').trim().slice(1))}`)}\` (check the FEEL syntax).`);
-    }
-    if (cc && !isFeel(body)) {
-      this.push('runtime', 'W_C8_EXPRESSION', activity, undefined, 'mi:completion', `The completion condition "${body ?? ''}" of multi-instance ${this.describe(activity)} is no FEEL expression (=...); it deploys, but every completed instance gets an incident (expected a boolean, got a string)`, `\`bpmn set <file> ${id} ${sh(`completion==${feelOf(body ?? '')}`)}\` (check the FEEL syntax).`);
-    }
-  }
-}
diff --git a/src/domain/validation/profiles/rule-kit.ts b/src/domain/validation/profiles/rule-kit.ts
deleted file mode 100644
index d68e04de..00000000
--- a/src/domain/validation/profiles/rule-kit.ts
+++ /dev/null
@@ -1,41 +0,0 @@
-import { EVENT_GATEWAY_TRIGGERS, ignoresConditions, isEventSubProcess, kindLabel } from '../../document/Kinds.js';
-import { unkeptEntries } from '../../document/utils/mirror.js';
-import { BPMN_NS, createModdle, is, isBpmnElement, isDiElement, walk } from '../../document/utils/moddle.js';
-import { DecisionLinkReader } from '../../editing/properties/DecisionLinkReader.js';
-import { decodeXml, elementChildren, readXmlText } from '../../document/utils/text-reader.js';
-import { XmlTextError } from '../../document/xml/XmlTextError.js';
-import { CAMUNDA, OPERATON_URI } from '../../document/vendor/CamundaDescriptor.js';
-import { DocumentNamespaces } from '../../document/vendor/DocumentNamespaces.js';
-import { makeFinding } from '../../document/utils/finding.js';
-import { ZEEBE } from '../../document/vendor/ZeebeDescriptor.js';
-
-/**
- * The core helpers the lazily loaded engine rules get handed instead of importing them:
- * a module shared by core and rule chunk lands in the host's entry chunk, and a host that
- * awaits a profile at top level would then wait for itself forever.
- */
-export const RULE_KIT = {
-  BPMN_NS,
-  createModdle,
-  is,
-  isBpmnElement,
-  isDiElement,
-  walk,
-  kindLabel,
-  isEventSubProcess,
-  ignoresConditions,
-  EVENT_GATEWAY_TRIGGERS,
-  makeFinding,
-  unkeptEntries,
-  DecisionLinkReader,
-  OPERATON_URI,
-  DocumentNamespaces,
-  camunda: CAMUNDA,
-  zeebe: ZEEBE,
-  decodeXml,
-  elementChildren,
-  readXmlText,
-  XmlTextError,
-};
-
-export type RuleKit = typeof RULE_KIT;
diff --git a/src/domain/validation/utils/c7-hint.ts b/src/domain/validation/utils/c7-hint.ts
deleted file mode 100644
index f436661a..00000000
--- a/src/domain/validation/utils/c7-hint.ts
+++ /dev/null
@@ -1,27 +0,0 @@
-import type { El } from '../../document/utils/moddle.js';
-import { peek } from './element.js';
-import { lowerFirst, sh } from './hint.js';
-
-/**
- * `bpmn ext add` arguments that re-create a flat generic element (attributes and body),
- * or undefined when it has children; `fix` replaces attribute values (placeholders).
- */
-export function extAddArgs(vendorElement: El, type: string, fix: Record<string, string> = {}): string | undefined {
-  const kids = peek<unknown[]>(vendorElement, '$children');
-  if (Array.isArray(kids) && kids.length) return undefined;
-  const entries = Object.entries(vendorElement as unknown as Record<string, unknown>).filter(([key]) => !key.startsWith('$') && !key.startsWith('xmlns'));
-  for (const key of Object.keys(fix)) {
-    if (!entries.some(([existingKey]) => existingKey === key)) {
-      entries.push([key, fix[key]]);
-    }
-  }
-  const attrs = entries.map(([key, val]) => sh(`${key}=${key in fix ? fix[key] : String(val)}`));
-  const body = peek<string>(vendorElement, '$body');
-  return [type, ...attrs, ...(body !== undefined ? ['--body', sh(String(body))] : [])].join(' ');
-}
-
-/** `userTask, sendTask, ...` for BPMN types (`bpmn:UserTask`), at most four of them. */
-export function kindsText(owners: string[]): string {
-  const names = owners.map((ownerType) => lowerFirst(ownerType.replace(/^bpmn:/, '')));
-  return names.length > 4 ? `${names.slice(0, 4).join(', ')}, ...` : names.join(', ');
-}
diff --git a/src/domain/validation/utils/c8-value.ts b/src/domain/validation/utils/c8-value.ts
deleted file mode 100644
index d7535aff..00000000
--- a/src/domain/validation/utils/c8-value.ts
+++ /dev/null
@@ -1,38 +0,0 @@
-import type { El } from '../../document/utils/moddle.js';
-import { peek } from './element.js';
-import { nonEmpty } from './value.js';
-
-/** No value or only white space. */
-export function blank(value: string | undefined): boolean {
-  return !nonEmpty(value);
-}
-
-/**
- * No value at all: Camunda 8 refuses a missing or empty name, job type, code,
- * process / decision id or result variable, but deploys one of white space (8.9.22).
- */
-export function missing(value: string | undefined): boolean {
-  return value === undefined || value === null || value === '';
-}
-
-/** A FEEL expression: the value starts with `=`. */
-export function isFeel(value: string | undefined): boolean {
-  return value !== undefined && value.trim().startsWith('=');
-}
-
-/**
- * `${a && b}` -> ` a and b` (a starting point for FEEL; the hint asks to check it).
- * Single-quoted JUEL strings become double-quoted FEEL strings.
- */
-export function feelOf(juel: string): string {
-  const match = /^\s*[$#]\{([\s\S]*)\}\s*$/.exec(juel);
-  const inner = (match ? match[1]! : juel).trim();
-  const quoted = inner.replace(/'((?:[^'\\]|\\.)*)'/g, (_m, text: string) => `"${text.replace(/"/g, '\\"')}"`);
-  return ` ${quoted.replace(/&&/g, 'and').replace(/\|\|/g, 'or').replace(/==/g, '=').replace(/!\s*\((?!=)/g, 'not(').replace(/!(?!=)\s*([\w.]+)/g, 'not($1)')}`;
-}
-
-/** The name as written, or undefined when there is none (unlike nameOf, white space is a name). */
-export function nameAttr(el: El | undefined): string | undefined {
-  const name = peek<string>(el, 'name');
-  return typeof name === 'string' && name !== '' ? name : undefined;
-}
diff --git a/src/domain/validation/utils/element.ts b/src/domain/validation/utils/element.ts
deleted file mode 100644
index 7b6326cc..00000000
--- a/src/domain/validation/utils/element.ts
+++ /dev/null
@@ -1,42 +0,0 @@
-import type { El } from '../../document/utils/moddle.js';
-
-export function peek<TValue>(el: El | undefined, prop: string): TValue | undefined {
-  return el ? ((el as unknown as Record<string, unknown>)[prop] as TValue | undefined) : undefined;
-}
-
-export function list(el: El | undefined, prop: string): El[] {
-  const propValue = peek<unknown>(el, prop);
-  return Array.isArray(propValue) ? (propValue as El[]) : [];
-}
-
-export function idOf(el: El | undefined): string | undefined {
-  const id = peek<string>(el, 'id');
-  return typeof id === 'string' && id ? id : undefined;
-}
-
-export function isGeneric(el: El): boolean {
-  return !!(el.$descriptor as { isGeneric?: boolean }).isGeneric;
-}
-
-export function localName(type: string): string {
-  return type.slice(type.indexOf(':') + 1);
-}
-
-/** An attribute of a generic vendor element (plain name, e.g. `event`). */
-export function attr(el: El | undefined, name: string): string | undefined {
-  const propValue = peek<unknown>(el, name);
-  return propValue === undefined || propValue === null ? undefined : String(propValue);
-}
-
-export function nameOf(el: El | undefined): string | undefined {
-  const name = peek<string>(el, 'name');
-  return typeof name === 'string' && name.trim() !== '' ? name : undefined;
-}
-
-/** `message`, `timer`, ... (the trigger name `bpmn set trigger=` takes) of an event definition. */
-export function triggerName(def: El): string {
-  return localName(def.$type).replace(/EventDefinition$/, '').replace(/^./, (firstChar) => firstChar.toLowerCase());
-}
-
-export const TIMER_ELEMENTS = ['timeDate', 'timeCycle', 'timeDuration'];
-
diff --git a/src/domain/validation/utils/hint.ts b/src/domain/validation/utils/hint.ts
deleted file mode 100644
index 5a6feaab..00000000
--- a/src/domain/validation/utils/hint.ts
+++ /dev/null
@@ -1,44 +0,0 @@
-/** Quotes a shell argument when the shell would interpret it (a `<placeholder>` stays as it is). */
-export function sh(arg: string): string {
-  return /^[A-Za-z0-9_.:=,/@+-]*(<[a-zA-Z]+>)?$/.test(arg) ? arg : `'${arg.replace(/'/g, `'\\''`)}'`;
-}
-
-/** `<slot><first argument>` shell-quoted (`'definition[1].camunda:field'`), the rest as is. */
-export function slotted(slot: string, args: string): string {
-  const space = args.indexOf(' ');
-  return space === -1 ? sh(`${slot}${args}`) : `${sh(`${slot}${args.slice(0, space)}`)}${args.slice(space)}`;
-}
-
-export function lowerFirst(text: string): string {
-  return text.charAt(0).toLowerCase() + text.slice(1);
-}
-
-/** Levenshtein distance, case-insensitive. */
-function distance(left: string, right: string): number {
-  const source = left.toLowerCase();
-  const target = right.toLowerCase();
-  const row = Array.from({ length: target.length + 1 }, (_entry, targetIndex) => targetIndex);
-  for (let sourceIndex = 1; sourceIndex <= source.length; sourceIndex++) {
-    let prev = row[0]!;
-    row[0] = sourceIndex;
-    for (let targetIndex = 1; targetIndex <= target.length; targetIndex++) {
-      const tmp = row[targetIndex]!;
-      row[targetIndex] = Math.min(row[targetIndex]! + 1, row[targetIndex - 1]! + 1, prev + (source[sourceIndex - 1] === target[targetIndex - 1] ? 0 : 1));
-      prev = tmp;
-    }
-  }
-  return row[target.length]!;
-}
-
-/** The closest candidate within a small edit distance, preferring `preferred`. */
-export function didYouMean(name: string, candidates: string[], preferred: string[] = []): string | undefined {
-  const limit = Math.max(1, Math.floor(name.length / 4));
-  let best: { candidate: string; distance: number } | undefined;
-  for (const candidate of [...preferred, ...candidates]) {
-    const dist = distance(name, candidate);
-    if (dist <= limit && (!best || dist < best.distance)) {
-      best = { candidate, distance: dist };
-    }
-  }
-  return best?.candidate;
-}
diff --git a/src/domain/validation/utils/value.ts b/src/domain/validation/utils/value.ts
deleted file mode 100644
index c4deaf56..00000000
--- a/src/domain/validation/utils/value.ts
+++ /dev/null
@@ -1,3 +0,0 @@
-export function nonEmpty(text: string | undefined): text is string {
-  return typeof text === 'string' && text.trim() !== '';
-}
diff --git a/src/index.ts b/src/index.ts
index a7c5bf2a..9294c210 100644
--- a/src/index.ts
+++ b/src/index.ts
@@ -9,7 +9,7 @@ import type { ChangeSet } from './domain/document/ChangeSet.js';
 import type { EditCommand } from './domain/commands/types.js';
 import type { CheckResult } from './application/port/in/ValidateDocumentUseCase.js';
 import type { MutationResult } from './domain/batch/types.js';
-import type { ValidateOptions, ValidationResult } from './domain/validation/StructuralValidator.js';
+import type { ValidationResult } from './domain/validation/StructuralValidator.js';
 import type { IdConventions } from './domain/document/ids/IdConventions.js';
 import type { ConventionsView, Undeclared } from './domain/document/ids/ConventionsTable.js';
 import type { BpmnlintRuleSetting, BpmnlintSeverity, BpmnlintConfig, BpmnlintEngine, ResolvedBpmnlintConfig } from './adapters/out/bpmnlint/bpmnlint-contract.js';
@@ -17,8 +17,7 @@ import type { NamedValidator, ValidatorFinding } from './domain/validation/valid
 import type { El, Model } from './domain/document/utils/moddle.js';
 import type { LayoutMetrics, LayoutProblem } from './domain/diagram/utils/problems.js';
 import type { Warning } from './domain/document/BpmnError.js';
-import type { Platform, PlatformChoice, PlatformInfo } from './domain/document/vendor/PlatformDetection.js';
-import type { ProfileReport } from './domain/validation/profiles/PlatformProfiles.js';
+import type { PlatformInfo } from './domain/document/vendor/PlatformDetection.js';
 import { AgentGuide } from './adapters/in/report/AgentGuide.js';
 import { KindsReference } from './adapters/in/report/KindsReference.js';
 import type { PreservedText } from './domain/document/xml/TextPreservation.js';
@@ -41,6 +40,7 @@ import { EditDocumentService } from './application/service/EditDocumentService.j
 import { RelayoutDiagramService } from './application/service/RelayoutDiagramService.js';
 import { NoProjectSettings } from './adapters/out/memory/NoProjectSettings.js';
 import { NoDocumentFiles } from './adapters/out/memory/NoDocumentFiles.js';
+import { BpmnlintEngineLint } from './adapters/out/bpmnlint/BpmnlintEngineLint.js';
 import { DetailText } from './adapters/in/report/DetailText.js';
 import { LayoutText } from './adapters/in/report/LayoutText.js';
 import { ModelViewText } from './adapters/in/report/ModelViewText.js';
@@ -57,6 +57,7 @@ import type { ExtensionInfo } from './domain/document/ExtensionLister.js';
 import type { LayoutOptions, LayoutResult } from './domain/diagram/layout/FullLayout.js';
 const NO_PROJECT = new NoProjectSettings();
 const NO_FILES = new NoDocumentFiles();
+const ENGINE = new BpmnlintEngineLint();
 /* the in-memory API: strings in, strings / data out */
 export { mutateDoc, layoutDoc, checkDoc, applyToXml, newXml, layoutXml, validateXml, viewXml, showXml, conventionsXml, metricsXml, findXml, extensionsXml, type EditOptions, type EditResult, type EditReport, type LayoutXmlOptions, type ShownView, type ValidateXmlOptions, type ViewOptions } from './api.js';
 export { type MutationReport, type MutationReportLike, type MutationSummary, type ValidationReport, type WarningReport } from './adapters/in/report/command-report.js';
@@ -116,7 +117,7 @@ export { type LayoutDocOptions } from './application/port/in/RelayoutDiagramUseC
 export type { ValidationDelta } from './domain/validation/FindingBaseline.js';
 /* text-preserving output, for hosts that serialise models themselves */
 export { type PreservedText } from './domain/document/xml/TextPreservation.js';
-export function preserveText(original: string, baseline: string, next: string): Promise<PreservedText> { return new EditDocumentService(NO_PROJECT, NO_FILES).preserveText({ original, baseline, next }); }
+export function preserveText(original: string, baseline: string, next: string): Promise<PreservedText> { return new EditDocumentService(NO_PROJECT, NO_FILES, ENGINE).preserveText({ original, baseline, next }); }
 /* a host's validators, run inside the write transaction and by validate */
 export type { NamedValidator, Validator, ValidatorContext, ValidatorFinding, ValidatorFn, ValidatorIssue, ValidatorReport, ValidatorSeverity } from './domain/validation/validators.js';
 /* the project's bpmnlint configuration as an advisory validator; bpmnlint itself is injected */
@@ -156,12 +157,12 @@ export function conventionsView(
 export type { DecisionLink } from './domain/editing/properties/DecisionLinkReader.js';
 
 export { ChangeSet, type Change } from './domain/document/ChangeSet.js';
-export type { ValidateOptions, ValidationResult } from './domain/validation/StructuralValidator.js';
-/** Structural validation and lint of a document, with the platform profile on request. */
-export function validateDoc(doc: Doc, opts: ValidateOptions = {}): ValidationResult { return new ValidateDocumentService(NO_PROJECT, NO_FILES).validateStructure({ ...opts, doc }); }
-/* the platform profile: Camunda 7 / 8 rules, loaded on demand */
+export type { ValidationResult } from './domain/validation/StructuralValidator.js';
+/** Structural validation and lint of a document; the Camunda 7 / 8 rules run in checkDoc and every write. */
+export function validateDoc(doc: Doc): ValidationResult { return new ValidateDocumentService(NO_PROJECT, NO_FILES, ENGINE).validateStructure({ doc }); }
+/* the platform: Camunda 7 / 8 rules, bpmnlint rules that load on demand */
 export { PLATFORM_CHOICES, TARGETS, type Platform, type PlatformChoice, type PlatformInfo } from './domain/document/vendor/PlatformDetection.js';
-export type { PlatformSummary, ProfileReport } from './domain/validation/profiles/PlatformProfiles.js';
+export type { PlatformSummary } from './domain/validation/PlatformCheck.js';
 export type { ProfileFinding, Severity } from './domain/document/Finding.js';
 export type { ExtensionInfo } from './domain/document/ExtensionLister.js';
 export { type ModelView, type ElementDetail, type DetailMessageFlow, type DetailData, type FindHit } from './domain/views/model-view.js';
@@ -209,30 +210,12 @@ export function parseOps(input: unknown): EditCommand[] {
   return new RunCommandsService().parseCommands({ input });
 }
 
-/**
- * Loads the engine rules of `platform` (cached), needed before the synchronous runProfile and
- * validateDoc; the async API loads them itself. A failed load (E_PROFILE_LOAD) is retried later.
- */
-export function loadProfile(platform: Platform): Promise<void> {
-  return new ValidateDocumentService(NO_PROJECT, NO_FILES).loadProfile({ platform });
-}
-
-/** Loads the engine rules of several platforms (default: all). */
-export function loadProfiles(platforms?: readonly Exclude<Platform, 'none'>[]): Promise<void> {
-  return new ValidateDocumentService(NO_PROJECT, NO_FILES).loadProfiles(platforms !== undefined ? { platforms } : {});
-}
-
-/** Runs the profile of the document's platform (or `choice`); its rules must be loaded. */
-export function runProfile(doc: Doc, choice?: PlatformChoice): ProfileReport {
-  return new ValidateDocumentService(NO_PROJECT, NO_FILES).runProfile({ doc, ...(choice !== undefined ? { choice } : {}) });
-}
-
 /**
  * Detects the target engine: modeler:executionPlatform, else the vendor namespace the content
  * uses, else a declared one.
  */
 export function detectPlatform(doc: Doc): PlatformInfo {
-  return new ValidateDocumentService(NO_PROJECT, NO_FILES).detectPlatform({ doc });
+  return new ValidateDocumentService(NO_PROJECT, NO_FILES, ENGINE).detectPlatform({ doc });
 }
 
 /** `bpmn guide`: the agent cheat sheet. */
@@ -290,5 +273,5 @@ export function locateProblems(defs: El, problems: readonly LayoutProblem[]): La
  * treat the returned XML as the truth and re-parse it if you need DI.
  */
 export function layoutModel(model: Model, opts: LayoutOptions = {}): Promise<LayoutResult> {
-  return new RelayoutDiagramService(NO_PROJECT, NO_FILES).layoutModel({ ...opts, model });
+  return new RelayoutDiagramService(NO_PROJECT, NO_FILES, ENGINE).layoutModel({ ...opts, model });
 }
diff --git a/src/node.ts b/src/node.ts
index 02d242f1..aab684d8 100644
--- a/src/node.ts
+++ b/src/node.ts
@@ -21,6 +21,7 @@ import { EditDocumentService } from './application/service/EditDocumentService.j
 import { ReadDocumentService } from './application/service/ReadDocumentService.js';
 import { RelayoutDiagramService } from './application/service/RelayoutDiagramService.js';
 import { ValidateDocumentService } from './application/service/ValidateDocumentService.js';
+import { BpmnlintEngineLint } from './adapters/out/bpmnlint/BpmnlintEngineLint.js';
 import { ProjectBpmnlint, type BpmnlintSettings } from './adapters/out/files/ProjectBpmnlint.js';
 import type { FileBpmnlintOptions, ProjectIdConventions } from './application/port/out/LoadProjectSettingsPort.js';
 import { FileDocumentStore } from './adapters/out/files/FileDocumentStore.js';
@@ -28,6 +29,7 @@ import { BpmnlintProjectSettings } from './adapters/out/files/BpmnlintProjectSet
 
 const FILES = new FileDocumentStore();
 const PROJECT = new BpmnlintProjectSettings();
+const ENGINE = new BpmnlintEngineLint();
 
 export * from './index.js';
 export { readXml, decodeXmlBytes, writeAtomic } from './adapters/out/files/utils/files.js';
@@ -39,18 +41,18 @@ export function readDoc(file: string): Promise<Doc> { return new ReadDocumentSer
 /** Loads a file; fails with E_IMPORT_LOSSY when bpmn-moddle dropped content, unless force. */
 export function loadDoc(file: string, opts: { force?: boolean } = {}): Promise<Doc> { return new ReadDocumentService(FILES).read({ source: { file }, lossless: true, ...opts }); }
 /** Loads a file, applies ops and writes it back (or to opts.out). */
-export function mutateFile(file: string, ops: EditCommand[], opts: FileMutationOptions = {}): Promise<MutationResult> { return new EditDocumentService(PROJECT, FILES).edit({ ...opts, source: { file }, commands: ops }); }
+export function mutateFile(file: string, ops: EditCommand[], opts: FileMutationOptions = {}): Promise<MutationResult> { return new EditDocumentService(PROJECT, FILES, ENGINE).edit({ ...opts, source: { file }, commands: ops }); }
 /** Applies ops to a loaded document and writes it to opts.out ?? doc.file. */
-export function mutateDocToFile(doc: Doc, ops: EditCommand[], opts: FileMutationOptions = {}): Promise<MutationResult> { return new EditDocumentService(PROJECT, FILES).edit({ ...opts, source: { doc }, commands: ops }); }
+export function mutateDocToFile(doc: Doc, ops: EditCommand[], opts: FileMutationOptions = {}): Promise<MutationResult> { return new EditDocumentService(PROJECT, FILES, ENGINE).edit({ ...opts, source: { doc }, commands: ops }); }
 /** `bpmn layout`: redraws a file (or with `tidy` only removes overlaps) and writes it back. */
-export function layoutFile(file: string, opts: FileLayoutOptions = {}): Promise<MutationResult> { return new RelayoutDiagramService(PROJECT, FILES).relayout({ ...opts, source: { file } }); }
+export function layoutFile(file: string, opts: FileLayoutOptions = {}): Promise<MutationResult> { return new RelayoutDiagramService(PROJECT, FILES, ENGINE).relayout({ ...opts, source: { file } }); }
 /** `bpmn validate`: validates a file and dry-runs the layout without writing anything. */
-export function checkFile(file: string, opts: FileCheckOptions = {}): Promise<CheckResult> { return new ValidateDocumentService(PROJECT, FILES).validate({ ...opts, source: { file } }); }
+export function checkFile(file: string, opts: FileCheckOptions = {}): Promise<CheckResult> { return new ValidateDocumentService(PROJECT, FILES, ENGINE).validate({ ...opts, source: { file } }); }
 /**
  * checkFile for a document read elsewhere (`bpmn validate -`); without a file
  * the .bpmnlintrc is looked up from `opts.lintFrom`.
  */
-export function checkLoadedDoc(doc: Doc, opts: FileCheckOptions = {}): Promise<CheckResult> { return new ValidateDocumentService(PROJECT, FILES).validate({ ...opts, source: { doc } }); }
+export function checkLoadedDoc(doc: Doc, opts: FileCheckOptions = {}): Promise<CheckResult> { return new ValidateDocumentService(PROJECT, FILES, ENGINE).validate({ ...opts, source: { doc } }); }
 export { type PngImage, type PngRenderResult } from './adapters/out/files/PngRenderer.js';
 export { BPMNLINT_CONFIG_FILE } from './adapters/out/files/ConfigLookup.js';
 export type { BpmnlintChain, BpmnlintTier } from './adapters/out/files/ChainResolver.js';
diff --git a/src/types/engine-rules.d.ts b/src/types/engine-rules.d.ts
new file mode 100644
index 00000000..68016b76
--- /dev/null
+++ b/src/types/engine-rules.d.ts
@@ -0,0 +1,99 @@
+/** The untyped packages bpmn-cli's engine rules import: camunda-compat's configs, rules and helpers, bpmnlint-utils and bpmnlint's rules. */
+
+declare module 'bpmnlint-utils' {
+  /** Inheritance-aware moddle type test. An unqualified type is read as `bpmn:<type>`. */
+  export function is(node: unknown, type: string): boolean;
+  export function isAny(node: unknown, types: string[]): boolean;
+}
+
+
+declare module 'bpmnlint/rules/*' {
+  const rule: unknown;
+  export default rule;
+}
+
+declare module 'bpmnlint-plugin-camunda-compat' {
+  /** The plugin index — `configs` is plain data keyed by `<platform>-<version>`. */
+  const plugin: {
+    configs: Record<string, { rules?: Record<string, unknown>; extends?: string | string[] }>;
+    rules: Record<string, unknown>;
+  };
+  export default plugin;
+}
+
+/** Every camunda-compat rule module (camunda-cloud/* and camunda-platform/*). */
+declare module 'bpmnlint-plugin-camunda-compat/rules/*' {
+  const rule: unknown;
+  export default rule;
+}
+
+
+/** camunda-compat's report helper: reports each error on `node`, adding the element's name. */
+declare module 'bpmnlint-plugin-camunda-compat/rules/utils/reporter.js' {
+  export function reportErrors(
+    node: unknown,
+    reporter: { report(id: string, message: string, details?: object): void },
+    errors: CompatError | CompatError[],
+  ): void;
+
+  /** One problem as camunda-compat describes it: its message, the path to it, its error type. */
+  export interface CompatError {
+    message: string;
+    path?: (string | number)[] | null;
+    data: { type: string; [key: string]: unknown };
+    [key: string]: unknown;
+  }
+}
+
+/** camunda-compat's error types, the `data.type` of every report (`camunda.propertyRequired`, ...). */
+declare module 'bpmnlint-plugin-camunda-compat/rules/utils/error-types.js' {
+  export const ERROR_TYPES: Readonly<{
+    CHILD_ELEMENT_OF_TYPE_REQUIRED: string;
+    CHILD_ELEMENT_TYPE_NOT_ALLOWED: string;
+    CONNECTORS_PROPERTY_VALUE_NOT_ALLOWED: string;
+    ELEMENT_COLLAPSED_NOT_ALLOWED: string;
+    ELEMENT_MULTIPLE_NOT_ALLOWED: string;
+    ELEMENT_TYPE_NOT_ALLOWED: string;
+    ELEMENT_PROPERTY_VALUE_DUPLICATED: string;
+    EVENT_BASED_GATEWAY_TARGET_NOT_ALLOWED: string;
+    EXPRESSION_NOT_ALLOWED: string;
+    EXPRESSION_REQUIRED: string;
+    EXPRESSION_VALUE_NOT_ALLOWED: string;
+    EXTENSION_ELEMENT_NOT_ALLOWED: string;
+    EXTENSION_ELEMENT_REQUIRED: string;
+    FEEL_EXPRESSION_INVALID: string;
+    FEEL_EXPRESSION_UNSUPPORTED_FUNCTION: string;
+    LOOP_NOT_ALLOWED: string;
+    ATTACHED_TO_REF_ELEMENT_TYPE_NOT_ALLOWED: string;
+    PROPERTY_DEPENDENT_REQUIRED: string;
+    PROPERTY_NOT_ALLOWED: string;
+    PROPERTY_DEPRECATED: string;
+    PROPERTY_REQUIRED: string;
+    PROPERTY_TYPE_NOT_ALLOWED: string;
+    PROPERTY_VALUE_DUPLICATED: string;
+    PROPERTY_VALUES_DUPLICATED: string;
+    PROPERTY_VALUE_NOT_ALLOWED: string;
+    PROPERTY_VALUE_REQUIRED: string;
+    SECRET_EXPRESSION_FORMAT_DEPRECATED: string;
+    SECRET_EXPRESSION_FORMAT_LEGACY: string;
+    SECRET_REFERENCE_STRING_LITERAL_NOT_ALLOWED: string;
+    SECRET_REFERENCE_INSIDE_LIST_NOT_ALLOWED: string;
+    SECRET_REFERENCE_INSIDE_IF_BRANCH_CONTEXT_NOT_ALLOWED: string;
+    AGENT_FEEL_FUNCTION_NAME_INVALID: string;
+    AGENT_FEEL_KEY_MISSING: string;
+    AGENT_FEEL_KEY_TYPE_INVALID: string;
+    AGENT_FEEL_KEY_PREFIX_MISSING: string;
+    AGENT_FEEL_DESCRIPTION_TYPE_INVALID: string;
+    AGENT_FEEL_WRONG_CONTEXT: string;
+    AGENT_FEEL_KEY_SEGMENTS_INVALID: string;
+    AGENT_FEEL_KEY_DUPLICATE: string;
+    AGENT_FEEL_NON_ENTRY_ELEMENT: string;
+    AGENT_TOOL_OUTPUT_KEY_INVALID: string;
+    AGENT_TOOL_OUTPUT_KEY_CASING_INVALID: string;
+    AGENT_TOOL_OUTPUT_KEY_OVERWRITE: string;
+    AGENT_TOOL_RESULT_MISSING: string;
+    AGENT_TOOL_DOCUMENTATION_MISSING: string;
+  }>;
+}
+
+/** camunda-compat's element checks, returning errors for `reportErrors`. */
diff --git a/src/types/vendor.d.ts b/src/types/vendor.d.ts
index 269cd733..59c86a5e 100644
--- a/src/types/vendor.d.ts
+++ b/src/types/vendor.d.ts
@@ -30,3 +30,9 @@ declare module 'bpmn-moddle' {
     toXML(element: ModdleElement, options?: { format?: boolean; preamble?: boolean }): Promise<{ xml: string }>;
   }
 }
+
+declare module 'bpmnlint/lib/linter.js' {
+  /** bpmnlint's linter; bpmn-cli types what it uses in adapters/out/bpmnlint/bpmnlint-contract.ts */
+  const Linter: new (options: { config?: unknown; resolver: unknown; transformRule?: unknown }) => { lint(root: unknown): Promise<Record<string, unknown[]>> };
+  export default Linter;
+}
diff --git a/test/adapters/out/bpmnlint/engine-codes.test.ts b/test/adapters/out/bpmnlint/engine-codes.test.ts
new file mode 100644
index 00000000..42d482c0
--- /dev/null
+++ b/test/adapters/out/bpmnlint/engine-codes.test.ts
@@ -0,0 +1,34 @@
+import { compatRules as c7CompatRules } from '@miragon/bpmnlint-plugin-rules/camunda-7';
+import { compatRules as c8CompatRules } from '@miragon/bpmnlint-plugin-rules/camunda-8';
+import { describe, expect, it } from 'vitest';
+import { ENGINE_KIT } from '../../../../src/adapters/out/bpmnlint/engine-kit.js';
+import { CompatVerdicts } from '../../../../src/adapters/out/bpmnlint/engine/run/CompatVerdicts.js';
+import { EngineCodes } from '../../../../src/adapters/out/bpmnlint/engine/run/EngineCodes.js';
+import { Camunda7Rules } from '../../../../src/adapters/out/bpmnlint/engine/rules/c7/Camunda7Rules.js';
+import { Camunda8Rules } from '../../../../src/adapters/out/bpmnlint/engine/rules/c8/Camunda8Rules.js';
+
+const ENGINES = [
+  { platform: 'c7', entry: Camunda7Rules.entry(ENGINE_KIT), compatRules: c7CompatRules, major: 7 },
+  { platform: 'c8', entry: Camunda8Rules.entry(ENGINE_KIT), compatRules: c8CompatRules, major: 8 },
+] as const;
+
+describe('every engine rule has a bpmn-cli code', () => {
+  for (const { platform, entry, compatRules, major } of ENGINES) {
+    it(`${platform}: the rules of every camunda-compat version, and each rule of bpmn-cli's own`, () => {
+      const rules = new Set<string>();
+      const verdicts = new CompatVerdicts(ENGINE_KIT, platform, undefined as never, {}, undefined);
+      for (let minor = 0; minor < 40; minor++) {
+        for (const rule of verdicts.rules(compatRules(`${major}.${minor}`))) {
+          rules.add(rule.name);
+        }
+      }
+      expect(rules.size).toBeGreaterThan(0);
+      expect([...rules].filter((rule) => EngineCodes.codeOf(platform, rule, { data: {} } as never) === EngineCodes.UNMAPPED[platform]).sort()).toEqual([]);
+      const tabled = Object.values(EngineCodes.TABLE[platform]).flat().map((rule) => rule.split('#')[0]!).map((rule) => (rule.includes('/') ? rule : `camunda-compat/${rule}`));
+      expect(tabled.filter((rule) => !rules.has(rule)).sort()).toEqual([]);
+      const own = entry.rules(undefined).filter((rule) => rule.name.startsWith('bpmn-cli/'));
+      expect(own.length).toBeGreaterThan(4);
+      expect(Object.values(entry.codes).filter(([code]) => !code.startsWith(`W_${platform.toUpperCase()}_`))).toEqual([]);
+    });
+  }
+});
diff --git a/test/adapters/out/bpmnlint/engine/rules/c7/C7AdHocSubProcessNoFlowsRule.test.ts b/test/adapters/out/bpmnlint/engine/rules/c7/C7AdHocSubProcessNoFlowsRule.test.ts
new file mode 100644
index 00000000..a388a8f0
--- /dev/null
+++ b/test/adapters/out/bpmnlint/engine/rules/c7/C7AdHocSubProcessNoFlowsRule.test.ts
@@ -0,0 +1,114 @@
+import { ERROR_TYPES } from 'bpmnlint-plugin-camunda-compat/rules/utils/error-types.js';
+import { describe } from 'vitest';
+import rule from '../../../../../../../src/adapters/out/bpmnlint/engine/rules/c7/C7AdHocSubProcessNoFlowsRule.js';
+import { engineModel, verifyEngineRule } from '../../../../../../helpers/engine-model.js';
+
+describe('c7-ad-hoc-sub-process-no-flows', () => {
+  const flow = (id: string, from: string, target: string) =>
+    `<bpmn:sequenceFlow id="${id}" sourceRef="${from}" targetRef="${target}" />`;
+  const userTask = (id: string) => `<bpmn:userTask id="${id}" />`;
+  const around = (node: string) =>
+    `<bpmn:startEvent id="Start" />${flow('F1', 'Start', 'SP')}${node}${flow('F2', 'SP', 'End')}<bpmn:endEvent id="End" />`;
+  const beside = (extra: string) =>
+    `<bpmn:startEvent id="Start" />${flow('F1', 'Start', 'U')}${userTask('U')}${flow('F2', 'U', 'End')}<bpmn:endEvent id="End" />${extra}`;
+  const TIMER =
+    '<bpmn:timerEventDefinition id="TDef"><bpmn:timeDuration xsi:type="bpmn:tFormalExpression">PT1H</bpmn:timeDuration></bpmn:timerEventDefinition>';
+  const REFUSED = 'the engines do not run ad-hoc sub-processes and refuse the file';
+  const connected = (parts: string, refusal: string) => ({
+    id: 'SP',
+    message: `Ad-hoc sub-process SP is connected (${parts}); ${REFUSED} (${refusal})`,
+    type: ERROR_TYPES.ELEMENT_TYPE_NOT_ALLOWED,
+  });
+
+  verifyEngineRule(rule, {
+    valid: [
+      {
+        name: 'an ad-hoc sub-process that nothing connects: its content is skipped',
+        moddleElement: engineModel(
+          'c7',
+          beside(
+            `<bpmn:adHocSubProcess id="SP"><bpmn:serviceTask id="X" /><bpmn:scriptTask id="Y" /><bpmn:subProcess id="Z">${userTask('Z1')}</bpmn:subProcess><bpmn:startEvent id="A1" /><bpmn:startEvent id="A2" />${flow('a1', 'A1', 'X')}${flow('a2', 'A2', 'X')}</bpmn:adHocSubProcess>`,
+          ),
+        ),
+      },
+      {
+        name: 'an ad-hoc sub-process that nothing connects: broken settings on it are skipped too',
+        moddleElement: engineModel(
+          'c7',
+          beside(
+            `<bpmn:adHocSubProcess id="SP" camunda:asyncBefore="true" camunda:jobPriority="abc"><bpmn:extensionElements><camunda:failedJobRetryTimeCycle>R1/PT1M</camunda:failedJobRetryTimeCycle><camunda:failedJobRetryTimeCycle>R2/PT1M</camunda:failedJobRetryTimeCycle><camunda:executionListener event="start" /></bpmn:extensionElements>${userTask('T')}</bpmn:adHocSubProcess>`,
+          ),
+        ),
+      },
+      {
+        name: 'a connected ad-hoc sub-process inside an ad-hoc sub-process (skipped with its parent)',
+        moddleElement: engineModel(
+          'c7',
+          beside(
+            `<bpmn:adHocSubProcess id="AH">${around(`<bpmn:adHocSubProcess id="SP">${userTask('T')}</bpmn:adHocSubProcess>`)}</bpmn:adHocSubProcess>`,
+          ),
+        ),
+      },
+      {
+        name: 'a connected ad-hoc sub-process in a non-executable process',
+        moddleElement: engineModel(
+          'c7',
+          around(`<bpmn:adHocSubProcess id="SP">${userTask('T')}</bpmn:adHocSubProcess>`),
+          { processAttributes: 'isExecutable="false"' },
+        ),
+      },
+      {
+        name: 'a connected embedded sub-process',
+        moddleElement: engineModel(
+          'c7',
+          around(`<bpmn:subProcess id="SP">${userTask('T')}</bpmn:subProcess>`),
+        ),
+      },
+      {
+        name: 'a Camunda 8 diagram',
+        moddleElement: engineModel(
+          'c8',
+          around(`<bpmn:adHocSubProcess id="SP">${userTask('T')}</bpmn:adHocSubProcess>`),
+        ),
+      },
+    ],
+    invalid: [
+      {
+        name: 'an ad-hoc sub-process with sequence flows',
+        moddleElement: engineModel(
+          'c7',
+          around(`<bpmn:adHocSubProcess id="SP">${userTask('T')}</bpmn:adHocSubProcess>`),
+        ),
+        report: connected('sequence flows F1, F2', "invalid destination 'SP' of sequence flow F1"),
+      },
+      {
+        name: 'an empty ad-hoc sub-process with an incoming flow only',
+        moddleElement: engineModel(
+          'c7',
+          `<bpmn:startEvent id="Start" />${flow('F1', 'Start', 'SP')}<bpmn:adHocSubProcess id="SP" />`,
+        ),
+        report: connected('sequence flow F1', "invalid destination 'SP' of sequence flow F1"),
+      },
+      {
+        name: 'an ad-hoc sub-process with an outgoing flow only',
+        moddleElement: engineModel(
+          'c7',
+          beside(
+            `<bpmn:adHocSubProcess id="SP">${userTask('T')}</bpmn:adHocSubProcess>${flow('F3', 'SP', 'End')}`,
+          ),
+        ),
+        report: connected('sequence flow F3', "invalid source 'SP' of sequence flow F3"),
+      },
+      {
+        name: 'an ad-hoc sub-process with a boundary event',
+        moddleElement: engineModel(
+          'c7',
+          beside(
+            `<bpmn:adHocSubProcess id="SP">${userTask('T')}</bpmn:adHocSubProcess><bpmn:boundaryEvent id="B" attachedToRef="SP">${TIMER}</bpmn:boundaryEvent>`,
+          ),
+        ),
+        report: connected('boundary event B', 'invalid reference in boundary event'),
+      },
+    ],
+  });
+});
diff --git a/test/adapters/out/bpmnlint/engine/rules/c7/C7AdHocSubProcessNoMultiInstanceRule.test.ts b/test/adapters/out/bpmnlint/engine/rules/c7/C7AdHocSubProcessNoMultiInstanceRule.test.ts
new file mode 100644
index 00000000..ab27fee0
--- /dev/null
+++ b/test/adapters/out/bpmnlint/engine/rules/c7/C7AdHocSubProcessNoMultiInstanceRule.test.ts
@@ -0,0 +1,103 @@
+import { ERROR_TYPES } from 'bpmnlint-plugin-camunda-compat/rules/utils/error-types.js';
+import { describe } from 'vitest';
+import rule from '../../../../../../../src/adapters/out/bpmnlint/engine/rules/c7/C7AdHocSubProcessNoMultiInstanceRule.js';
+import { engineModel, verifyEngineRule } from '../../../../../../helpers/engine-model.js';
+
+describe('c7-ad-hoc-sub-process-no-multi-instance', () => {
+  const flow = (id: string, from: string, target: string) =>
+    `<bpmn:sequenceFlow id="${id}" sourceRef="${from}" targetRef="${target}" />`;
+  const userTask = (id: string) => `<bpmn:userTask id="${id}" />`;
+  const around = (node: string) =>
+    `<bpmn:startEvent id="Start" />${flow('F1', 'Start', 'SP')}${node}${flow('F2', 'SP', 'End')}<bpmn:endEvent id="End" />`;
+  const beside = (extra: string) =>
+    `<bpmn:startEvent id="Start" />${flow('F1', 'Start', 'U')}${userTask('U')}${flow('F2', 'U', 'End')}<bpmn:endEvent id="End" />${extra}`;
+  const LOOP =
+    '<bpmn:multiInstanceLoopCharacteristics><bpmn:loopCardinality>2</bpmn:loopCardinality></bpmn:multiInstanceLoopCharacteristics>';
+  const REFUSED = 'the engines do not run ad-hoc sub-processes and refuse the file';
+  const connected = (parts: string, refusal: string) => ({
+    id: 'SP',
+    message: `Ad-hoc sub-process SP is connected (${parts}); ${REFUSED} (${refusal})`,
+    type: ERROR_TYPES.ELEMENT_TYPE_NOT_ALLOWED,
+  });
+  const LOOP_REPORT = {
+    id: 'SP',
+    message:
+      'Ad-hoc sub-process SP has a multi-instance loop; the engines do not run ad-hoc sub-processes, and Camunda 7 and CIB seven refuse the file (ENGINE-01009, "activity" is null)',
+    path: ['loopCharacteristics'],
+    type: ERROR_TYPES.PROPERTY_NOT_ALLOWED,
+  };
+
+  verifyEngineRule(rule, {
+    valid: [
+      {
+        name: 'an ad-hoc sub-process that nothing connects: its content is skipped',
+        moddleElement: engineModel(
+          'c7',
+          beside(
+            `<bpmn:adHocSubProcess id="SP"><bpmn:serviceTask id="X" /><bpmn:scriptTask id="Y" /><bpmn:subProcess id="Z">${userTask('Z1')}</bpmn:subProcess><bpmn:startEvent id="A1" /><bpmn:startEvent id="A2" />${flow('a1', 'A1', 'X')}${flow('a2', 'A2', 'X')}</bpmn:adHocSubProcess>`,
+          ),
+        ),
+      },
+      {
+        name: 'an ad-hoc sub-process that nothing connects: broken settings on it are skipped too',
+        moddleElement: engineModel(
+          'c7',
+          beside(
+            `<bpmn:adHocSubProcess id="SP" camunda:asyncBefore="true" camunda:jobPriority="abc"><bpmn:extensionElements><camunda:failedJobRetryTimeCycle>R1/PT1M</camunda:failedJobRetryTimeCycle><camunda:failedJobRetryTimeCycle>R2/PT1M</camunda:failedJobRetryTimeCycle><camunda:executionListener event="start" /></bpmn:extensionElements>${userTask('T')}</bpmn:adHocSubProcess>`,
+          ),
+        ),
+      },
+      {
+        name: 'a connected ad-hoc sub-process inside an ad-hoc sub-process (skipped with its parent)',
+        moddleElement: engineModel(
+          'c7',
+          beside(
+            `<bpmn:adHocSubProcess id="AH">${around(`<bpmn:adHocSubProcess id="SP">${userTask('T')}</bpmn:adHocSubProcess>`)}</bpmn:adHocSubProcess>`,
+          ),
+        ),
+      },
+      {
+        name: 'a connected ad-hoc sub-process in a non-executable process',
+        moddleElement: engineModel(
+          'c7',
+          around(`<bpmn:adHocSubProcess id="SP">${userTask('T')}</bpmn:adHocSubProcess>`),
+          { processAttributes: 'isExecutable="false"' },
+        ),
+      },
+      {
+        name: 'a connected embedded sub-process',
+        moddleElement: engineModel(
+          'c7',
+          around(`<bpmn:subProcess id="SP">${userTask('T')}</bpmn:subProcess>`),
+        ),
+      },
+      {
+        name: 'a Camunda 8 diagram',
+        moddleElement: engineModel(
+          'c8',
+          around(`<bpmn:adHocSubProcess id="SP">${userTask('T')}</bpmn:adHocSubProcess>`),
+        ),
+      },
+    ],
+    invalid: [
+      {
+        name: 'an ad-hoc sub-process with a valid multi-instance loop',
+        moddleElement: engineModel(
+          'c7',
+          beside(`<bpmn:adHocSubProcess id="SP">${LOOP}${userTask('T')}</bpmn:adHocSubProcess>`),
+        ),
+        report: LOOP_REPORT,
+      },
+      {
+        name: 'an ad-hoc sub-process with a multi-instance loop without cardinality',
+        moddleElement: engineModel(
+          'c7',
+          beside(
+            `<bpmn:adHocSubProcess id="SP"><bpmn:multiInstanceLoopCharacteristics />${userTask('T')}</bpmn:adHocSubProcess>`,
+          ),
+        ),
+        report: LOOP_REPORT,
+      },
+    ],
+  });
+});
diff --git a/test/adapters/out/bpmnlint/engine/rules/c7/C7BindingKnownRule.test.ts b/test/adapters/out/bpmnlint/engine/rules/c7/C7BindingKnownRule.test.ts
new file mode 100644
index 00000000..67fcd37f
--- /dev/null
+++ b/test/adapters/out/bpmnlint/engine/rules/c7/C7BindingKnownRule.test.ts
@@ -0,0 +1,109 @@
+import { ERROR_TYPES } from 'bpmnlint-plugin-camunda-compat/rules/utils/error-types.js';
+import { describe } from 'vitest';
+import rule from '../../../../../../../src/adapters/out/bpmnlint/engine/rules/c7/C7BindingKnownRule.js';
+import { engineModel, verifyEngineRule } from '../../../../../../helpers/engine-model.js';
+
+describe('c7-binding-known', () => {
+  const conditional = (variableEvents: string) =>
+    `<bpmn:intermediateCatchEvent id="event_wait"><bpmn:conditionalEventDefinition camunda:variableEvents="${variableEvents}"><bpmn:condition xsi:type="bpmn:tFormalExpression">\${ready}</bpmn:condition></bpmn:conditionalEventDefinition></bpmn:intermediateCatchEvent>`;
+
+  verifyEngineRule(rule, {
+    valid: [
+      {
+        name: 'Camunda Modeler style values',
+        moddleElement: engineModel(
+          'c7',
+          `<bpmn:serviceTask id="serviceTask_a" camunda:type="external" camunda:topic="chargeCard" />
+          <bpmn:userTask id="userTask_b" camunda:priority="\${priority}" />
+          <bpmn:userTask id="userTask_c" camunda:priority="50" />
+          <bpmn:callActivity id="callActivity_d" calledElement="other" camunda:calledElementBinding="versionTag" camunda:calledElementVersionTag="1.0" camunda:caseBinding="deployment" />
+          <bpmn:businessRuleTask id="businessRuleTask_e" camunda:decisionRef="risk" camunda:decisionRefBinding="latest" />
+          ${conditional('create, update')}`,
+        ),
+      },
+      {
+        name: 'a missing version is c7-binding-needs-version, a missing calledElement c7-call-activity-one-called-element',
+        moddleElement: engineModel(
+          'c7',
+          `<bpmn:callActivity id="callActivity_d" calledElement="other" camunda:calledElementBinding="version" />
+          <bpmn:callActivity id="callActivity_e" />
+          <bpmn:callActivity id="callActivity_f" calledElement="" camunda:caseRef="case" />`,
+        ),
+      },
+      {
+        name: 'a decisionRefBinding without decisionRef is not read',
+        moddleElement: engineModel(
+          'c7',
+          '<bpmn:businessRuleTask id="businessRuleTask_e" camunda:class="org.example.Rule" camunda:decisionRefBinding="foo" />',
+        ),
+      },
+      {
+        name: 'a variable event on a definition the engines do not act on',
+        moddleElement: engineModel(
+          'c7',
+          `<bpmn:intermediateCatchEvent id="event_wait"><bpmn:timerEventDefinition><bpmn:timeDuration xsi:type="bpmn:tFormalExpression">PT1H</bpmn:timeDuration></bpmn:timerEventDefinition><bpmn:conditionalEventDefinition camunda:variableEvents="change"><bpmn:condition xsi:type="bpmn:tFormalExpression">\${ready}</bpmn:condition></bpmn:conditionalEventDefinition></bpmn:intermediateCatchEvent>`,
+        ),
+      },
+      {
+        name: 'a non-executable process',
+        moddleElement: engineModel(
+          'c7',
+          '<bpmn:userTask id="userTask_b" camunda:priority="high" />',
+          {
+            processAttributes: 'isExecutable="false"',
+          },
+        ),
+      },
+      {
+        name: 'a Camunda 8 diagram',
+        moddleElement: engineModel(
+          'c8',
+          '<bpmn:userTask id="userTask_b" camunda:priority="high" />',
+          {
+            definitionsAttributes: 'xmlns:camunda="http://camunda.org/schema/1.0/bpmn"',
+          },
+        ),
+      },
+    ],
+    invalid: [
+      {
+        name: 'unknown binding values',
+        moddleElement: engineModel(
+          'c7',
+          `<bpmn:callActivity id="callActivity_d" calledElement="other" camunda:calledElementBinding="foo" />
+          <bpmn:businessRuleTask id="businessRuleTask_e" camunda:decisionRef="risk" camunda:decisionRefBinding="foo" />`,
+        ),
+        report: [
+          {
+            id: 'callActivity_d',
+            message:
+              'camunda:calledElementBinding="foo" on callActivity callActivity_d is not one of latest, deployment, version, versionTag; the engines accept the file but cannot resolve the reference as intended',
+            path: ['calledElementBinding'],
+            type: ERROR_TYPES.PROPERTY_VALUE_NOT_ALLOWED,
+          },
+          {
+            id: 'businessRuleTask_e',
+            message:
+              'camunda:decisionRefBinding="foo" on businessRuleTask businessRuleTask_e is not one of latest, deployment, version, versionTag; the engines accept the file but cannot resolve the reference as intended',
+            path: ['decisionRefBinding'],
+            type: ERROR_TYPES.PROPERTY_VALUE_NOT_ALLOWED,
+          },
+        ],
+      },
+      {
+        name: 'a caseBinding of versionTag',
+        moddleElement: engineModel(
+          'c7',
+          '<bpmn:callActivity id="callActivity_d" camunda:caseRef="case" camunda:caseBinding="versionTag" />',
+        ),
+        report: {
+          id: 'callActivity_d',
+          message:
+            'camunda:caseBinding="versionTag" on callActivity callActivity_d is not one of latest, deployment, version; the engines accept the file but cannot resolve the reference as intended',
+          path: ['caseBinding'],
+          type: ERROR_TYPES.PROPERTY_VALUE_NOT_ALLOWED,
+        },
+      },
+    ],
+  });
+});
diff --git a/test/adapters/out/bpmnlint/engine/rules/c7/C7BindingNeedsVersionRule.test.ts b/test/adapters/out/bpmnlint/engine/rules/c7/C7BindingNeedsVersionRule.test.ts
new file mode 100644
index 00000000..2272ffa4
--- /dev/null
+++ b/test/adapters/out/bpmnlint/engine/rules/c7/C7BindingNeedsVersionRule.test.ts
@@ -0,0 +1,133 @@
+import { ERROR_TYPES } from 'bpmnlint-plugin-camunda-compat/rules/utils/error-types.js';
+import { describe } from 'vitest';
+import rule from '../../../../../../../src/adapters/out/bpmnlint/engine/rules/c7/C7BindingNeedsVersionRule.js';
+import { engineModel, verifyEngineRule } from '../../../../../../helpers/engine-model.js';
+
+describe('c7-binding-needs-version', () => {
+  const MISSING = (where: string, binding: string, value: string, missing: string) =>
+    `${where} has camunda:${binding}="${value}" but no camunda:${missing}; the engines refuse the file`;
+
+  verifyEngineRule(rule, {
+    valid: [
+      {
+        name: 'bindings with the version or tag they bind to',
+        moddleElement: engineModel(
+          'c7',
+          `<bpmn:callActivity id="callActivity_a" calledElement="other" camunda:calledElementBinding="version" camunda:calledElementVersion="3" />
+          <bpmn:callActivity id="callActivity_b" calledElement="other" camunda:calledElementBinding="versionTag" camunda:calledElementVersionTag="1.0" />
+          <bpmn:businessRuleTask id="businessRuleTask_c" camunda:decisionRef="risk" camunda:decisionRefBinding="versionTag" camunda:decisionRefVersionTag="1.0" />
+          <bpmn:userTask id="userTask_d" camunda:formRef="form" camunda:formRefBinding="version" camunda:formRefVersion="2" />
+          <bpmn:callActivity id="callActivity_e" calledElement="other" camunda:calledElementBinding="latest" />`,
+        ),
+      },
+      {
+        name: 'a caseBinding of versionTag (c7-binding-known)',
+        moddleElement: engineModel(
+          'c7',
+          '<bpmn:callActivity id="callActivity_a" camunda:caseRef="case" camunda:caseBinding="versionTag" />',
+        ),
+      },
+      {
+        name: 'a decisionRefBinding without decisionRef, a formRefBinding without formRef',
+        moddleElement: engineModel(
+          'c7',
+          `<bpmn:businessRuleTask id="businessRuleTask_c" camunda:class="org.example.Rule" camunda:decisionRefBinding="version" />
+          <bpmn:userTask id="userTask_d" camunda:formRefBinding="version" />`,
+        ),
+      },
+      {
+        name: 'a non-executable process',
+        moddleElement: engineModel(
+          'c7',
+          '<bpmn:callActivity id="callActivity_a" calledElement="other" camunda:calledElementBinding="version" />',
+          { processAttributes: 'isExecutable="false"' },
+        ),
+      },
+      {
+        name: 'a Camunda 8 diagram',
+        moddleElement: engineModel(
+          'c8',
+          '<bpmn:callActivity id="callActivity_a" calledElement="other" camunda:calledElementBinding="version" />',
+          { definitionsAttributes: 'xmlns:camunda="http://camunda.org/schema/1.0/bpmn"' },
+        ),
+      },
+    ],
+    invalid: [
+      {
+        name: 'calledElementBinding=version without version',
+        moddleElement: engineModel(
+          'c7',
+          '<bpmn:callActivity id="callActivity_a" calledElement="other" camunda:calledElementBinding="version" />',
+        ),
+        report: {
+          id: 'callActivity_a',
+          message: MISSING(
+            'callActivity callActivity_a',
+            'calledElementBinding',
+            'version',
+            'calledElementVersion',
+          ),
+          path: ['calledElementVersion'],
+          type: ERROR_TYPES.PROPERTY_DEPENDENT_REQUIRED,
+        },
+      },
+      {
+        name: 'calledElementBinding=versionTag and caseBinding=version without them',
+        moddleElement: engineModel(
+          'c7',
+          '<bpmn:callActivity id="callActivity_a" calledElement="other" camunda:calledElementBinding="versionTag" camunda:caseBinding="version" />',
+        ),
+        report: [
+          {
+            id: 'callActivity_a',
+            message: MISSING(
+              'callActivity callActivity_a',
+              'calledElementBinding',
+              'versionTag',
+              'calledElementVersionTag',
+            ),
+            path: ['calledElementVersionTag'],
+            type: ERROR_TYPES.PROPERTY_DEPENDENT_REQUIRED,
+          },
+          {
+            id: 'callActivity_a',
+            message: MISSING('callActivity callActivity_a', 'caseBinding', 'version', 'caseVersion'),
+            path: ['caseVersion'],
+            type: ERROR_TYPES.PROPERTY_DEPENDENT_REQUIRED,
+          },
+        ],
+      },
+      {
+        name: 'decisionRefBinding=versionTag without tag',
+        moddleElement: engineModel(
+          'c7',
+          '<bpmn:businessRuleTask id="businessRuleTask_c" camunda:decisionRef="risk" camunda:decisionRefBinding="versionTag" />',
+        ),
+        report: {
+          id: 'businessRuleTask_c',
+          message: MISSING(
+            'businessRuleTask businessRuleTask_c',
+            'decisionRefBinding',
+            'versionTag',
+            'decisionRefVersionTag',
+          ),
+          path: ['decisionRefVersionTag'],
+          type: ERROR_TYPES.PROPERTY_DEPENDENT_REQUIRED,
+        },
+      },
+      {
+        name: 'formRefBinding=version without formRefVersion on a start event',
+        moddleElement: engineModel(
+          'c7',
+          '<bpmn:startEvent id="startEvent_a" camunda:formRef="form" camunda:formRefBinding="version" />',
+        ),
+        report: {
+          id: 'startEvent_a',
+          message: MISSING('startEvent startEvent_a', 'formRefBinding', 'version', 'formRefVersion'),
+          path: ['formRefVersion'],
+          type: ERROR_TYPES.PROPERTY_DEPENDENT_REQUIRED,
+        },
+      },
+    ],
+  });
+});
diff --git a/test/adapters/out/bpmnlint/engine/rules/c7/C7CallActivityOneCalledElementRule.test.ts b/test/adapters/out/bpmnlint/engine/rules/c7/C7CallActivityOneCalledElementRule.test.ts
new file mode 100644
index 00000000..e6ecea4a
--- /dev/null
+++ b/test/adapters/out/bpmnlint/engine/rules/c7/C7CallActivityOneCalledElementRule.test.ts
@@ -0,0 +1,70 @@
+import { ERROR_TYPES } from 'bpmnlint-plugin-camunda-compat/rules/utils/error-types.js';
+import { describe } from 'vitest';
+import rule from '../../../../../../../src/adapters/out/bpmnlint/engine/rules/c7/C7CallActivityOneCalledElementRule.js';
+import { engineModel, verifyEngineRule } from '../../../../../../helpers/engine-model.js';
+
+describe('c7-call-activity-one-called-element', () => {
+  verifyEngineRule(rule, {
+    valid: [
+      {
+        name: 'a called process or a called case',
+        moddleElement: engineModel(
+          'c7',
+          `<bpmn:callActivity id="callActivity_a" calledElement="other" />
+          <bpmn:callActivity id="callActivity_b" camunda:caseRef="case" />`,
+        ),
+      },
+      {
+        name: 'an empty calledElement (c7-bad-value)',
+        moddleElement: engineModel(
+          'c7',
+          '<bpmn:callActivity id="callActivity_a" calledElement="" />',
+        ),
+      },
+      {
+        name: 'a non-executable process',
+        moddleElement: engineModel('c7', '<bpmn:callActivity id="callActivity_a" />', {
+          processAttributes: 'isExecutable="false"',
+        }),
+      },
+      {
+        name: 'a call activity in an ad-hoc sub-process',
+        moddleElement: engineModel(
+          'c7',
+          '<bpmn:adHocSubProcess id="adHocSubProcess_x"><bpmn:callActivity id="callActivity_a" /></bpmn:adHocSubProcess>',
+        ),
+      },
+      {
+        name: 'a Camunda 8 diagram',
+        moddleElement: engineModel('c8', '<bpmn:callActivity id="callActivity_a" />'),
+      },
+    ],
+    invalid: [
+      {
+        name: 'a call activity without calledElement',
+        moddleElement: engineModel('c7', '<bpmn:callActivity id="callActivity_a" />'),
+        report: {
+          id: 'callActivity_a',
+          message:
+            'Call activity callActivity_a has no calledElement (nor camunda:caseRef); the engines refuse the file',
+          path: ['calledElement'],
+          type: ERROR_TYPES.PROPERTY_REQUIRED,
+        },
+      },
+      {
+        name: 'a call activity with calledElement and caseRef',
+        moddleElement: engineModel(
+          'c7',
+          '<bpmn:callActivity id="callActivity_a" calledElement="other" camunda:caseRef="case" />',
+        ),
+        report: {
+          id: 'callActivity_a',
+          message:
+            'Call activity callActivity_a has both calledElement and camunda:caseRef; the engines refuse the file',
+          path: ['caseRef'],
+          type: ERROR_TYPES.PROPERTY_NOT_ALLOWED,
+        },
+      },
+    ],
+  });
+});
diff --git a/test/adapters/out/bpmnlint/engine/rules/c7/C7CallMappingNeedsSourceAndTargetRule.test.ts b/test/adapters/out/bpmnlint/engine/rules/c7/C7CallMappingNeedsSourceAndTargetRule.test.ts
new file mode 100644
index 00000000..1df86da9
--- /dev/null
+++ b/test/adapters/out/bpmnlint/engine/rules/c7/C7CallMappingNeedsSourceAndTargetRule.test.ts
@@ -0,0 +1,124 @@
+import { ERROR_TYPES } from 'bpmnlint-plugin-camunda-compat/rules/utils/error-types.js';
+import { describe } from 'vitest';
+import rule from '../../../../../../../src/adapters/out/bpmnlint/engine/rules/c7/C7CallMappingNeedsSourceAndTargetRule.js';
+import { engineModel, verifyEngineRule } from '../../../../../../helpers/engine-model.js';
+
+describe('c7-call-mapping-needs-source-and-target', () => {
+  const ext = (inner: string) => `<bpmn:extensionElements>${inner}</bpmn:extensionElements>`;
+  const ROOTS =
+    '<bpmn:signal id="signal_go" name="go" /><bpmn:message id="message_paid" name="paid" />';
+  const REQUIRED = ERROR_TYPES.PROPERTY_REQUIRED;
+  const callActivity = (inner: string) =>
+    `<bpmn:callActivity id="callActivity_ship" calledElement="ship">${ext(inner)}</bpmn:callActivity>`;
+  const serviceTask = (attributes: string, inner: string) =>
+    `<bpmn:serviceTask id="serviceTask_charge" ${attributes}>${ext(inner)}</bpmn:serviceTask>`;
+  const userTask = (inner: string) =>
+    `<bpmn:userTask id="userTask_review">${ext(inner)}</bpmn:userTask>`;
+  const report = (id: string, message: string, path: (string | number)[], type = REQUIRED) => ({
+    id,
+    message,
+    path,
+    type,
+  });
+
+  verifyEngineRule(rule, {
+    valid: [
+      {
+        name: 'complete bindings, mappings, connector and form',
+        moddleElement: engineModel(
+          'c7',
+          callActivity(
+            '<camunda:in source="a" target="a" /><camunda:in sourceExpression="${b}" target="b" /><camunda:in businessKey="${key}" /><camunda:out variables="all" />',
+          ) +
+            serviceTask(
+              'camunda:class="a.B"',
+              '<camunda:field name="a" stringValue="x" /><camunda:field name="b"><camunda:string /></camunda:field><camunda:field name="c" expression="${c}" /><camunda:inputOutput><camunda:inputParameter name="p">1</camunda:inputParameter></camunda:inputOutput>',
+            ) +
+            '<bpmn:sendTask id="sendTask_notify"><bpmn:extensionElements><camunda:connector><camunda:connectorId>mail</camunda:connectorId></camunda:connector></bpmn:extensionElements></bpmn:sendTask>' +
+            userTask(
+              '<camunda:formData><camunda:formField id="a" type="string" /><camunda:formField id="b" type="date" /></camunda:formData>',
+            ),
+        ),
+      },
+      {
+        name: 'fields the engines do not read: an expression or external implementation, an expression listener',
+        moddleElement: engineModel(
+          'c7',
+          serviceTask('camunda:expression="${true}"', '<camunda:field name="a" />') +
+            serviceTask(
+              'camunda:type="external" camunda:topic="charge"',
+              '<camunda:field name="a" />',
+            ).replace('serviceTask_charge', 'serviceTask_refund') +
+            userTask(
+              '<camunda:taskListener event="create" expression="${l}" delegateExpression="${d}"><camunda:field name="a" /></camunda:taskListener>',
+            ),
+        ),
+      },
+      {
+        name: 'an incomplete binding where the engines do not read it (c7-camunda-extension-placement)',
+        moddleElement: engineModel(
+          'c7',
+          serviceTask('camunda:expression="${true}"', '<camunda:in source="a" />'),
+        ),
+      },
+      {
+        name: 'incomplete content in a non-executable process',
+        moddleElement: engineModel('c7', callActivity('<camunda:in source="a" />'), {
+          processAttributes: 'isExecutable="false"',
+        }),
+      },
+      {
+        name: 'incomplete content inside an ad-hoc sub-process of an executable process',
+        moddleElement: engineModel(
+          'c7',
+          `<bpmn:adHocSubProcess id="adHocSubProcess_steps">${callActivity('<camunda:in source="a" />')}</bpmn:adHocSubProcess>`,
+        ),
+      },
+      {
+        name: 'fields of a message definition the event does not act on',
+        moddleElement: engineModel(
+          'c7',
+          `<bpmn:intermediateThrowEvent id="intermediateThrowEvent_notify"><bpmn:signalEventDefinition signalRef="signal_go" /><bpmn:messageEventDefinition messageRef="message_paid" camunda:class="a.B">${ext('<camunda:field name="a" />')}</bpmn:messageEventDefinition></bpmn:intermediateThrowEvent>`,
+          { roots: ROOTS },
+        ),
+      },
+      {
+        name: 'a Camunda 8 diagram',
+        moddleElement: engineModel('c8', '<bpmn:callActivity id="callActivity_ship" />'),
+      },
+    ],
+    invalid: [
+      {
+        name: 'camunda:in with a source but no target',
+        moddleElement: engineModel('c7', callActivity('<camunda:in source="a" />')),
+        report: report(
+          'callActivity_ship',
+          'camunda:in of callActivity callActivity_ship has no target (and no variables="all" / businessKey); the engines refuse the file',
+          ['extensionElements', 'values', 0, 'target'],
+        ),
+      },
+      {
+        name: 'camunda:out without source and target',
+        moddleElement: engineModel('c7', callActivity('<camunda:out local="true" />')),
+        report: report(
+          'callActivity_ship',
+          'camunda:out of callActivity callActivity_ship has no source or sourceExpression and target (and no variables="all"); the engines refuse the file',
+          ['extensionElements', 'values', 0],
+        ),
+      },
+      {
+        name: 'camunda:in without target on a signal throw event definition',
+        moddleElement: engineModel(
+          'c7',
+          `<bpmn:intermediateThrowEvent id="intermediateThrowEvent_go"><bpmn:signalEventDefinition signalRef="signal_go">${ext('<camunda:in source="a" target="a" /><camunda:in source="b" />')}</bpmn:signalEventDefinition></bpmn:intermediateThrowEvent>`,
+          { roots: ROOTS },
+        ),
+        report: report(
+          'intermediateThrowEvent_go',
+          'camunda:in of the signalEventDefinition of intermediateThrowEvent:signal intermediateThrowEvent_go has no target (and no variables="all" / businessKey); the engines refuse the file',
+          ['eventDefinitions', 0, 'extensionElements', 'values', 1, 'target'],
+        ),
+      },
+    ],
+  });
+});
diff --git a/test/adapters/out/bpmnlint/engine/rules/c7/C7CamundaAttributeKnownRule.test.ts b/test/adapters/out/bpmnlint/engine/rules/c7/C7CamundaAttributeKnownRule.test.ts
new file mode 100644
index 00000000..cfc35cda
--- /dev/null
+++ b/test/adapters/out/bpmnlint/engine/rules/c7/C7CamundaAttributeKnownRule.test.ts
@@ -0,0 +1,136 @@
+import { ERROR_TYPES } from 'bpmnlint-plugin-camunda-compat/rules/utils/error-types.js';
+import { describe } from 'vitest';
+import rule from '../../../../../../../src/adapters/out/bpmnlint/engine/rules/c7/C7CamundaAttributeKnownRule.js';
+import { engineModel, verifyEngineRule } from '../../../../../../helpers/engine-model.js';
+
+describe('c7-camunda-attribute-known', () => {
+  const ext = (inner: string) => `<bpmn:extensionElements>${inner}</bpmn:extensionElements>`;
+  const TIMER =
+    '<bpmn:timerEventDefinition id="timerEventDefinition_wait"><bpmn:timeDuration xsi:type="bpmn:tFormalExpression">PT1H</bpmn:timeDuration></bpmn:timerEventDefinition>';
+
+  verifyEngineRule(rule, {
+    valid: [
+      {
+        name: 'a typo in a non-executable process (the engines skip it)',
+        moddleElement: engineModel(
+          'c7',
+          '<bpmn:userTask id="userTask_review" camunda:asignee="demo" />',
+          {
+            processAttributes: 'isExecutable="false"',
+          },
+        ),
+      },
+      {
+        name: 'known camunda attributes and extension elements',
+        moddleElement: engineModel(
+          'c7',
+          `<bpmn:userTask id="userTask_review" camunda:assignee="demo">${ext('<camunda:inputOutput><camunda:inputParameter name="a">1</camunda:inputParameter></camunda:inputOutput>')}</bpmn:userTask>`,
+        ),
+      },
+      {
+        name: 'a known camunda attribute on an element it does not apply to (c7-camunda-attribute-placement)',
+        moddleElement: engineModel(
+          'c7',
+          '<bpmn:serviceTask id="serviceTask_charge" camunda:assignee="demo" />',
+        ),
+      },
+      {
+        name: 'an unknown attribute inside an extension element the engines do not read there',
+        moddleElement: engineModel(
+          'c7',
+          `<bpmn:serviceTask id="serviceTask_charge" camunda:expression="\${true}">${ext('<camunda:taskListener event="create" class="a.B" foo="1" />')}</bpmn:serviceTask>`,
+        ),
+      },
+      {
+        name: 'an unknown attribute inside an ad-hoc sub-process of an executable process',
+        moddleElement: engineModel(
+          'c7',
+          '<bpmn:adHocSubProcess id="adHocSubProcess_steps"><bpmn:userTask id="userTask_review" camunda:asignee="demo" /></bpmn:adHocSubProcess>',
+        ),
+      },
+      {
+        name: 'an attribute without prefix (c7-schema)',
+        moddleElement: engineModel('c7', '<bpmn:userTask id="userTask_review" asignee="demo" />'),
+      },
+      {
+        name: 'a Camunda 8 diagram',
+        moddleElement: engineModel('c8', '<bpmn:userTask id="userTask_review" />'),
+      },
+    ],
+    invalid: [
+      {
+        name: 'a typo on a user task',
+        moddleElement: engineModel(
+          'c7',
+          '<bpmn:userTask id="userTask_review" camunda:asignee="demo" />',
+        ),
+        report: {
+          id: 'userTask_review',
+          message:
+            'userTask userTask_review has the unknown attribute camunda:asignee (did you mean camunda:assignee?); the engines ignore it',
+          path: ['camunda:asignee'],
+          type: ERROR_TYPES.PROPERTY_NOT_ALLOWED,
+        },
+      },
+      {
+        name: 'a typo of an attribute of another element type, on an event definition',
+        moddleElement: engineModel(
+          'c7',
+          `<bpmn:intermediateCatchEvent id="intermediateCatchEvent_wait"><bpmn:messageEventDefinition id="messageEventDefinition_wait" messageRef="message_paid" camunda:asyncc="true" />${TIMER}</bpmn:intermediateCatchEvent>`,
+          { roots: '<bpmn:message id="message_paid" name="paid" />' },
+        ),
+        report: {
+          id: 'intermediateCatchEvent_wait',
+          message:
+            'messageEventDefinition messageEventDefinition_wait has the unknown attribute camunda:asyncc (did you mean camunda:async? It applies to activity, gateway, event, multiInstanceLoopCharacteristics, ... only.); the engines ignore it',
+          path: ['eventDefinitions', 0, 'camunda:asyncc'],
+          type: ERROR_TYPES.PROPERTY_NOT_ALLOWED,
+        },
+      },
+      {
+        name: 'an unknown attribute far from every known one',
+        moddleElement: engineModel(
+          'c7',
+          '<bpmn:userTask id="userTask_review" camunda:somethingElse="1" />',
+        ),
+        report: {
+          id: 'userTask_review',
+          message:
+            'userTask userTask_review has the unknown attribute camunda:somethingElse; the engines ignore it',
+          path: ['camunda:somethingElse'],
+          type: ERROR_TYPES.PROPERTY_NOT_ALLOWED,
+        },
+      },
+      {
+        name: 'unknown attributes on camunda extension elements, nested ones included',
+        moddleElement: engineModel(
+          'c7',
+          `<bpmn:userTask id="userTask_review">${ext('<camunda:inputOutput><camunda:inputParameter name="a" nme="b" foo="1">1</camunda:inputParameter></camunda:inputOutput><camunda:executionListener event="start" clas="a.B" expression="${x}" />')}</bpmn:userTask>`,
+        ),
+        report: [
+          {
+            id: 'userTask_review',
+            message:
+              'camunda:inputParameter (in camunda:inputOutput) of userTask userTask_review has the unknown attribute nme (did you mean name?); the engines ignore it',
+            path: ['extensionElements', 'values', 0, 'inputParameters', 0, 'nme'],
+            type: ERROR_TYPES.PROPERTY_NOT_ALLOWED,
+          },
+          {
+            id: 'userTask_review',
+            message:
+              'camunda:inputParameter (in camunda:inputOutput) of userTask userTask_review has the unknown attribute foo; the engines ignore it',
+            path: ['extensionElements', 'values', 0, 'inputParameters', 0, 'foo'],
+            type: ERROR_TYPES.PROPERTY_NOT_ALLOWED,
+          },
+          {
+            id: 'userTask_review',
+            message:
+              'camunda:executionListener of userTask userTask_review has the unknown attribute clas (did you mean class?); the engines ignore it',
+            path: ['extensionElements', 'values', 1, 'clas'],
+            type: ERROR_TYPES.PROPERTY_NOT_ALLOWED,
+          },
+        ],
+      },
+    ],
+  });
+});
diff --git a/test/adapters/out/bpmnlint/engine/rules/c7/C7CamundaAttributePlacementRule.test.ts b/test/adapters/out/bpmnlint/engine/rules/c7/C7CamundaAttributePlacementRule.test.ts
new file mode 100644
index 00000000..052a5c01
--- /dev/null
+++ b/test/adapters/out/bpmnlint/engine/rules/c7/C7CamundaAttributePlacementRule.test.ts
@@ -0,0 +1,179 @@
+import { ERROR_TYPES } from 'bpmnlint-plugin-camunda-compat/rules/utils/error-types.js';
+import { describe } from 'vitest';
+import rule from '../../../../../../../src/adapters/out/bpmnlint/engine/rules/c7/C7CamundaAttributePlacementRule.js';
+import { engineModel, verifyEngineRule } from '../../../../../../helpers/engine-model.js';
+
+describe('c7-camunda-attribute-placement', () => {
+  const ROOTS = `<bpmn:message id="message_paid" name="paid" /><bpmn:signal id="signal_go" name="go" />
+    <bpmn:escalation id="escalation_late" name="late" escalationCode="E1" /><bpmn:error id="error_failed" name="failed" errorCode="E1" />`;
+  const TIMER = (attributes = '') =>
+    `<bpmn:timerEventDefinition id="timerEventDefinition_wait" ${attributes}><bpmn:timeDuration xsi:type="bpmn:tFormalExpression">PT1H</bpmn:timeDuration></bpmn:timerEventDefinition>`;
+  const PROPERTY_NOT_ALLOWED = ERROR_TYPES.PROPERTY_NOT_ALLOWED;
+
+  verifyEngineRule(rule, {
+    valid: [
+      {
+        name: 'a misplaced attribute in a non-executable process (the engines skip it)',
+        moddleElement: engineModel(
+          'c7',
+          '<bpmn:serviceTask id="serviceTask_charge" camunda:assignee="demo" />',
+          {
+            processAttributes: 'isExecutable="false"',
+          },
+        ),
+      },
+      {
+        name: 'attributes where the engines read them',
+        moddleElement: engineModel(
+          'c7',
+          `<bpmn:userTask id="userTask_review" camunda:assignee="demo"><bpmn:multiInstanceLoopCharacteristics camunda:collection="\${items}" camunda:elementVariable="item" /></bpmn:userTask>
+           <bpmn:intermediateThrowEvent id="intermediateThrowEvent_notify"><bpmn:messageEventDefinition messageRef="message_paid" camunda:class="a.B" /></bpmn:intermediateThrowEvent>
+           <bpmn:boundaryEvent id="boundaryEvent_failed" attachedToRef="userTask_review"><bpmn:errorEventDefinition errorRef="error_failed" camunda:errorCodeVariable="code" /></bpmn:boundaryEvent>`,
+          { roots: ROOTS },
+        ),
+      },
+      {
+        name: 'a signal catch event definition without camunda:async (its default does not count)',
+        moddleElement: engineModel(
+          'c7',
+          '<bpmn:intermediateCatchEvent id="intermediateCatchEvent_go"><bpmn:signalEventDefinition signalRef="signal_go" /></bpmn:intermediateCatchEvent>',
+          { roots: ROOTS },
+        ),
+      },
+      {
+        name: 'an unknown camunda attribute (c7-camunda-attribute-known)',
+        moddleElement: engineModel(
+          'c7',
+          '<bpmn:userTask id="userTask_review" camunda:asignee="demo" />',
+        ),
+      },
+      {
+        name: 'a misplaced attribute inside an ad-hoc sub-process of an executable process',
+        moddleElement: engineModel(
+          'c7',
+          '<bpmn:adHocSubProcess id="adHocSubProcess_steps"><bpmn:serviceTask id="serviceTask_charge" camunda:assignee="demo" /></bpmn:adHocSubProcess>',
+        ),
+      },
+      {
+        name: 'a Camunda 8 diagram',
+        moddleElement: engineModel('c8', '<bpmn:serviceTask id="serviceTask_charge" />'),
+      },
+    ],
+    invalid: [
+      {
+        name: 'camunda:assignee on a service task',
+        moddleElement: engineModel(
+          'c7',
+          '<bpmn:serviceTask id="serviceTask_charge" camunda:expression="${true}" camunda:assignee="demo" />',
+        ),
+        report: {
+          id: 'serviceTask_charge',
+          message:
+            'camunda:assignee on serviceTask serviceTask_charge has no effect: the engines read it on userTask only',
+          path: ['camunda:assignee'],
+          type: PROPERTY_NOT_ALLOWED,
+        },
+      },
+      {
+        name: 'the multi-instance collection on the activity instead of the loop',
+        moddleElement: engineModel(
+          'c7',
+          '<bpmn:userTask id="userTask_review" camunda:collection="${items}" camunda:elementVariable="item"><bpmn:multiInstanceLoopCharacteristics /></bpmn:userTask>',
+        ),
+        report: [
+          {
+            id: 'userTask_review',
+            message:
+              'camunda:collection on userTask userTask_review has no effect: the engines read it on multiInstanceLoopCharacteristics only',
+            path: ['camunda:collection'],
+            type: PROPERTY_NOT_ALLOWED,
+          },
+          {
+            id: 'userTask_review',
+            message:
+              'camunda:elementVariable on userTask userTask_review has no effect: the engines read it on multiInstanceLoopCharacteristics only',
+            path: ['camunda:elementVariable'],
+            type: PROPERTY_NOT_ALLOWED,
+          },
+        ],
+      },
+      {
+        name: 'errorCodeVariable on the event instead of its definition',
+        moddleElement: engineModel(
+          'c7',
+          '<bpmn:userTask id="userTask_review" /><bpmn:boundaryEvent id="boundaryEvent_failed" attachedToRef="userTask_review" camunda:errorCodeVariable="code"><bpmn:errorEventDefinition errorRef="error_failed" /></bpmn:boundaryEvent>',
+          { roots: ROOTS },
+        ),
+        report: {
+          id: 'boundaryEvent_failed',
+          message:
+            'camunda:errorCodeVariable on boundaryEvent:error boundaryEvent_failed has no effect: the engines read it on errorEventDefinition only',
+          path: ['camunda:errorCodeVariable'],
+          type: PROPERTY_NOT_ALLOWED,
+        },
+      },
+      {
+        name: 'a job priority on a timer definition, reported on its event',
+        moddleElement: engineModel(
+          'c7',
+          `<bpmn:intermediateCatchEvent id="intermediateCatchEvent_wait">${TIMER('camunda:jobPriority="high"')}</bpmn:intermediateCatchEvent>`,
+        ),
+        report: {
+          id: 'intermediateCatchEvent_wait',
+          message:
+            'camunda:jobPriority on timerEventDefinition timerEventDefinition_wait has no effect: the engines read it on process, activity, gateway, event, ... only',
+          path: ['eventDefinitions', 0, 'camunda:jobPriority'],
+          type: PROPERTY_NOT_ALLOWED,
+        },
+      },
+      {
+        name: 'throw-only and catch-only settings on the wrong side',
+        moddleElement: engineModel(
+          'c7',
+          `<bpmn:intermediateCatchEvent id="intermediateCatchEvent_paid"><bpmn:messageEventDefinition messageRef="message_paid" camunda:type="external" camunda:topic="t" /></bpmn:intermediateCatchEvent>
+           <bpmn:intermediateCatchEvent id="intermediateCatchEvent_go"><bpmn:signalEventDefinition signalRef="signal_go" camunda:async="false" /></bpmn:intermediateCatchEvent>
+           <bpmn:intermediateThrowEvent id="intermediateThrowEvent_late"><bpmn:escalationEventDefinition escalationRef="escalation_late" camunda:escalationCodeVariable="c" /></bpmn:intermediateThrowEvent>
+           <bpmn:endEvent id="endEvent_failed"><bpmn:errorEventDefinition errorRef="error_failed" camunda:errorCodeVariable="c" /></bpmn:endEvent>`,
+          { roots: ROOTS },
+        ),
+        report: [
+          {
+            id: 'intermediateCatchEvent_paid',
+            message:
+              'camunda:type on the messageEventDefinition of intermediateCatchEvent:message intermediateCatchEvent_paid has no effect: the engines read it on message throw and end events only',
+            path: ['eventDefinitions', 0, 'camunda:type'],
+            type: PROPERTY_NOT_ALLOWED,
+          },
+          {
+            id: 'intermediateCatchEvent_paid',
+            message:
+              'camunda:topic on the messageEventDefinition of intermediateCatchEvent:message intermediateCatchEvent_paid has no effect: the engines read it on message throw and end events only',
+            path: ['eventDefinitions', 0, 'camunda:topic'],
+            type: PROPERTY_NOT_ALLOWED,
+          },
+          {
+            id: 'intermediateCatchEvent_go',
+            message:
+              'camunda:async on the signalEventDefinition of intermediateCatchEvent:signal intermediateCatchEvent_go has no effect: the engines read it on signal throw and end events only',
+            path: ['eventDefinitions', 0, 'camunda:async'],
+            type: PROPERTY_NOT_ALLOWED,
+          },
+          {
+            id: 'intermediateThrowEvent_late',
+            message:
+              'camunda:escalationCodeVariable on the escalationEventDefinition of intermediateThrowEvent:escalation intermediateThrowEvent_late has no effect: the engines read it on escalation boundary and escalation start events only',
+            path: ['eventDefinitions', 0, 'camunda:escalationCodeVariable'],
+            type: PROPERTY_NOT_ALLOWED,
+          },
+          {
+            id: 'endEvent_failed',
+            message:
+              'camunda:errorCodeVariable on the errorEventDefinition of endEvent:error endEvent_failed has no effect: the engines read it on error boundary and error start events only',
+            path: ['eventDefinitions', 0, 'camunda:errorCodeVariable'],
+            type: PROPERTY_NOT_ALLOWED,
+          },
+        ],
+      },
+    ],
+  });
+});
diff --git a/test/adapters/out/bpmnlint/engine/rules/c7/C7CamundaExtensionPlacementRule.test.ts b/test/adapters/out/bpmnlint/engine/rules/c7/C7CamundaExtensionPlacementRule.test.ts
new file mode 100644
index 00000000..9bad8c9a
--- /dev/null
+++ b/test/adapters/out/bpmnlint/engine/rules/c7/C7CamundaExtensionPlacementRule.test.ts
@@ -0,0 +1,161 @@
+import { ERROR_TYPES } from 'bpmnlint-plugin-camunda-compat/rules/utils/error-types.js';
+import { describe } from 'vitest';
+import rule from '../../../../../../../src/adapters/out/bpmnlint/engine/rules/c7/C7CamundaExtensionPlacementRule.js';
+import { engineModel, verifyEngineRule } from '../../../../../../helpers/engine-model.js';
+
+describe('c7-camunda-extension-placement', () => {
+  const ext = (inner: string) => `<bpmn:extensionElements>${inner}</bpmn:extensionElements>`;
+  const MAPPING =
+    '<camunda:inputOutput><camunda:inputParameter name="a">1</camunda:inputParameter></camunda:inputOutput>';
+  const RETRY = '<camunda:failedJobRetryTimeCycle>R3/PT1M</camunda:failedJobRetryTimeCycle>';
+  const NOT_ALLOWED = ERROR_TYPES.EXTENSION_ELEMENT_NOT_ALLOWED;
+  const task = (inner: string) =>
+    `<bpmn:serviceTask id="serviceTask_charge" camunda:expression="\${true}">${ext(inner)}</bpmn:serviceTask>`;
+  const timerCatch = (definitionId: string) =>
+    `<bpmn:intermediateCatchEvent id="intermediateCatchEvent_wait"><bpmn:timerEventDefinition ${definitionId}>${ext(RETRY)}<bpmn:timeDuration xsi:type="bpmn:tFormalExpression">PT1H</bpmn:timeDuration></bpmn:timerEventDefinition></bpmn:intermediateCatchEvent>`;
+  const RETRY_HOSTS = 'activity, gateway, event, multiInstanceLoopCharacteristics';
+
+  verifyEngineRule(rule, {
+    valid: [
+      {
+        name: 'a misplaced extension element in a non-executable process (the engines skip it)',
+        moddleElement: engineModel('c7', task('<camunda:formData />'), {
+          processAttributes: 'isExecutable="false"',
+        }),
+      },
+      {
+        name: 'extension elements where the engines read them',
+        moddleElement: engineModel(
+          'c7',
+          `${ext('<camunda:executionListener event="start" class="a.B" /><camunda:potentialStarter />')}
+           <bpmn:userTask id="userTask_review">${ext(`${MAPPING}<camunda:taskListener event="create" class="a.B" /><camunda:formData /><camunda:properties><camunda:property name="a" value="1" /></camunda:properties>`)}</bpmn:userTask>
+           <bpmn:serviceTask id="serviceTask_charge" camunda:type="external" camunda:topic="charge">${ext('<camunda:errorEventDefinition id="errorEventDefinition_failed" expression="${true}" />')}</bpmn:serviceTask>
+           <bpmn:callActivity id="callActivity_ship" calledElement="ship">${ext('<camunda:in variables="all" /><camunda:out variables="all" />')}</bpmn:callActivity>`,
+        ),
+      },
+      {
+        name: 'a parameter loose in the extension elements (the typed parse drops it)',
+        moddleElement: engineModel(
+          'c7',
+          task('<camunda:inputParameter name="a">x</camunda:inputParameter>'),
+        ),
+      },
+      {
+        name: 'a misplaced extension element inside an ad-hoc sub-process of an executable process',
+        moddleElement: engineModel(
+          'c7',
+          `<bpmn:adHocSubProcess id="adHocSubProcess_steps">${task('<camunda:formData />')}</bpmn:adHocSubProcess>`,
+        ),
+      },
+      {
+        name: 'a Camunda 8 diagram',
+        moddleElement: engineModel('c8', '<bpmn:serviceTask id="serviceTask_charge" />'),
+      },
+    ],
+    invalid: [
+      {
+        name: 'a task listener, camunda:in and formData on a service task',
+        moddleElement: engineModel(
+          'c7',
+          task(
+            '<camunda:taskListener event="create" class="a.B" /><camunda:in variables="all" /><camunda:formData />',
+          ),
+        ),
+        report: [
+          {
+            id: 'serviceTask_charge',
+            message:
+              'camunda:taskListener on serviceTask serviceTask_charge has no effect: the engines read it on userTask only',
+            path: ['extensionElements', 'values', 0],
+            type: NOT_ALLOWED,
+          },
+          {
+            id: 'serviceTask_charge',
+            message:
+              'camunda:in on serviceTask serviceTask_charge has no effect: the engines read it on callActivity, signalEventDefinition only',
+            path: ['extensionElements', 'values', 1],
+            type: NOT_ALLOWED,
+          },
+          {
+            id: 'serviceTask_charge',
+            message:
+              'camunda:formData on serviceTask serviceTask_charge has no effect: the engines read it on startEvent, userTask only',
+            path: ['extensionElements', 'values', 2],
+            type: NOT_ALLOWED,
+          },
+        ],
+      },
+      {
+        name: 'camunda:inputOutput on the process',
+        moddleElement: engineModel('c7', `${ext(MAPPING)}<bpmn:userTask id="userTask_review" />`),
+        report: {
+          id: 'process_test',
+          message:
+            'camunda:inputOutput on process process_test has no effect: the engines read it on flowNode, camunda:connector only',
+          path: ['extensionElements', 'values', 0],
+          type: NOT_ALLOWED,
+        },
+      },
+      {
+        name: 'camunda:field on a message catch event definition',
+        moddleElement: engineModel(
+          'c7',
+          `<bpmn:intermediateCatchEvent id="intermediateCatchEvent_paid"><bpmn:messageEventDefinition messageRef="message_paid">${ext('<camunda:field name="a" stringValue="x" />')}</bpmn:messageEventDefinition></bpmn:intermediateCatchEvent>`,
+          { roots: '<bpmn:message id="message_paid" name="paid" />' },
+        ),
+        report: {
+          id: 'intermediateCatchEvent_paid',
+          message:
+            'camunda:field on the messageEventDefinition of intermediateCatchEvent:message intermediateCatchEvent_paid has no effect: the engines read it on message throw and end events only',
+          path: ['eventDefinitions', 0, 'extensionElements', 'values', 0],
+          type: NOT_ALLOWED,
+        },
+      },
+      {
+        name: 'a retry cycle on a timer definition without an id',
+        moddleElement: engineModel('c7', timerCatch('')),
+        report: {
+          id: 'intermediateCatchEvent_wait',
+          message: `camunda:failedJobRetryTimeCycle on the timerEventDefinition of intermediateCatchEvent:timer intermediateCatchEvent_wait has no effect: the engines read it on ${RETRY_HOSTS} only`,
+          path: ['eventDefinitions', 0, 'extensionElements', 'values', 0],
+          type: NOT_ALLOWED,
+        },
+      },
+      {
+        name: 'a retry cycle on a timer definition with an id',
+        moddleElement: engineModel('c7', timerCatch('id="timerEventDefinition_wait"')),
+        report: {
+          id: 'intermediateCatchEvent_wait',
+          message: `camunda:failedJobRetryTimeCycle on timerEventDefinition timerEventDefinition_wait has no effect: the engines read it on ${RETRY_HOSTS} only`,
+          path: ['eventDefinitions', 0, 'extensionElements', 'values', 0],
+          type: NOT_ALLOWED,
+        },
+      },
+      {
+        name: 'a task listener on a multi-instance loop (its retry cycle is read)',
+        moddleElement: engineModel(
+          'c7',
+          `<bpmn:userTask id="userTask_review"><bpmn:multiInstanceLoopCharacteristics camunda:collection="\${items}" camunda:elementVariable="item">${ext(`${RETRY}<camunda:taskListener event="create" expression="\${x}" />`)}</bpmn:multiInstanceLoopCharacteristics></bpmn:userTask>`,
+        ),
+        report: {
+          id: 'userTask_review',
+          message:
+            'camunda:taskListener on the multiInstanceLoopCharacteristics of userTask userTask_review has no effect: the engines read it on userTask only',
+          path: ['loopCharacteristics', 'extensionElements', 'values', 1],
+          type: NOT_ALLOWED,
+        },
+      },
+      {
+        name: 'a property loose in the extension elements',
+        moddleElement: engineModel('c7', task('<camunda:property name="a" value="1" />')),
+        report: {
+          id: 'serviceTask_charge',
+          message:
+            'camunda:property sits directly in the extension elements of serviceTask serviceTask_charge, but belongs inside camunda:properties; the engines ignore it',
+          path: ['extensionElements', 'values', 0],
+          type: NOT_ALLOWED,
+        },
+      },
+    ],
+  });
+});
diff --git a/test/adapters/out/bpmnlint/engine/rules/c7/C7CamundaReferenceResolvesRule.test.ts b/test/adapters/out/bpmnlint/engine/rules/c7/C7CamundaReferenceResolvesRule.test.ts
new file mode 100644
index 00000000..7aa70adc
--- /dev/null
+++ b/test/adapters/out/bpmnlint/engine/rules/c7/C7CamundaReferenceResolvesRule.test.ts
@@ -0,0 +1,75 @@
+import { ERROR_TYPES } from 'bpmnlint-plugin-camunda-compat/rules/utils/error-types.js';
+import { describe } from 'vitest';
+import { C7Diagram } from '../../../../../../../src/adapters/out/bpmnlint/engine/rules/c7/support/C7Diagram.js';
+import rule from '../../../../../../../src/adapters/out/bpmnlint/engine/rules/c7/C7CamundaReferenceResolvesRule.js';
+import { engineModel, verifyEngineRule } from '../../../../../../helpers/engine-model.js';
+
+describe('c7-camunda-reference-resolves', () => {
+  const withUnresolvedReferences = (model: ReturnType<typeof engineModel>) =>
+    model.then((parsed) => {
+      C7Diagram.record(parsed.root, { operaton: false, prefix: 'camunda' }, parsed.warnings);
+      return parsed;
+    });
+  const ROOTS =
+    '<bpmn:error id="error_failed" name="failed" errorCode="E1" /><bpmn:message id="message_paid" name="paid" />';
+  const task = (errorRef: string) =>
+    `<bpmn:serviceTask id="serviceTask_charge" camunda:type="external" camunda:topic="charge"><bpmn:extensionElements><camunda:errorEventDefinition id="errorEventDefinition_failed" errorRef="${errorRef}" expression="\${true}" /></bpmn:extensionElements></bpmn:serviceTask>`;
+
+  verifyEngineRule(rule, {
+    valid: [
+      {
+        name: 'an errorRef to a message in a non-executable process (the engines skip it)',
+        moddleElement: engineModel('c7', task('message_paid'), {
+          roots: ROOTS,
+          processAttributes: 'isExecutable="false"',
+        }),
+      },
+      {
+        name: 'an errorRef to a bpmn:Error',
+        moddleElement: engineModel('c7', task('error_failed'), { roots: ROOTS }),
+      },
+      {
+        name: 'an errorRef to no element the engine run has not handed over',
+        moddleElement: engineModel('c7', task('error_gone'), { roots: ROOTS }),
+      },
+      {
+        name: 'a dangling reference inside an ad-hoc sub-process of an executable process',
+        moddleElement: engineModel(
+          'c7',
+          `<bpmn:adHocSubProcess id="adHocSubProcess_steps">${task('message_paid')}</bpmn:adHocSubProcess>`,
+          {
+            roots: ROOTS,
+          },
+        ),
+      },
+      {
+        name: 'a Camunda 8 diagram',
+        moddleElement: engineModel('c8', '<bpmn:serviceTask id="serviceTask_charge" />'),
+      },
+    ],
+    invalid: [
+      {
+        name: 'an errorRef to no element (the typed parse drops it, the engine run hands it over)',
+        moddleElement: withUnresolvedReferences(engineModel('c7', task('error_gone'), { roots: ROOTS })),
+        report: {
+          id: 'serviceTask_charge',
+          message:
+            'camunda:errorEventDefinition of serviceTask serviceTask_charge references errorRef="error_gone", which is not a bpmn:Error in the file; the engines ignore the mapping when it runs',
+          path: ['extensionElements', 'values', 0, 'errorRef'],
+          type: ERROR_TYPES.PROPERTY_VALUE_NOT_ALLOWED,
+        },
+      },
+      {
+        name: 'an errorRef to a message',
+        moddleElement: engineModel('c7', task('message_paid'), { roots: ROOTS }),
+        report: {
+          id: 'serviceTask_charge',
+          message:
+            'camunda:errorEventDefinition of serviceTask serviceTask_charge references errorRef="message_paid", which is not a bpmn:Error in the file; the engines ignore the mapping when it runs',
+          path: ['extensionElements', 'values', 0, 'errorRef'],
+          type: ERROR_TYPES.PROPERTY_VALUE_NOT_ALLOWED,
+        },
+      },
+    ],
+  });
+});
diff --git a/test/adapters/out/bpmnlint/engine/rules/c7/C7CompensationNamesOwnActivityRule.test.ts b/test/adapters/out/bpmnlint/engine/rules/c7/C7CompensationNamesOwnActivityRule.test.ts
new file mode 100644
index 00000000..e63d8e92
--- /dev/null
+++ b/test/adapters/out/bpmnlint/engine/rules/c7/C7CompensationNamesOwnActivityRule.test.ts
@@ -0,0 +1,121 @@
+import { ERROR_TYPES } from 'bpmnlint-plugin-camunda-compat/rules/utils/error-types.js';
+import { describe } from 'vitest';
+import rule from '../../../../../../../src/adapters/out/bpmnlint/engine/rules/c7/C7CompensationNamesOwnActivityRule.js';
+import { engineModel, verifyEngineRule } from '../../../../../../helpers/engine-model.js';
+
+describe('c7-compensation-names-own-activity', () => {
+  const ROOTS = '<bpmn:message id="M" name="Pay" />';
+  const TIMER =
+    '<bpmn:timerEventDefinition id="TDef"><bpmn:timeDuration xsi:type="bpmn:tFormalExpression">PT1H</bpmn:timeDuration></bpmn:timerEventDefinition>';
+  const EMPTY_TIMER = '<bpmn:timerEventDefinition id="TDef" />';
+  const TWO_TIMES =
+    '<bpmn:timerEventDefinition id="TDef"><bpmn:timeDate xsi:type="bpmn:tFormalExpression">2030-01-01T00:00:00Z</bpmn:timeDate><bpmn:timeDuration xsi:type="bpmn:tFormalExpression">PT1H</bpmn:timeDuration></bpmn:timerEventDefinition>';
+  const COND_NONE = '<bpmn:conditionalEventDefinition id="CDef" />';
+  const MSG = '<bpmn:messageEventDefinition id="MDef" messageRef="M" />';
+  const START = '<bpmn:startEvent id="Start" />';
+  const catchWith = (defs: string) =>
+    `${START}<bpmn:intermediateCatchEvent id="W">${defs}</bpmn:intermediateCatchEvent>`;
+  const eventSubStart = (defs: string) =>
+    `${START}<bpmn:subProcess id="ES" triggeredByEvent="true"><bpmn:startEvent id="W" isInterrupting="false">${defs}</bpmn:startEvent></bpmn:subProcess>`;
+  const flow = (id: string, source: string, target: string) =>
+    `<bpmn:sequenceFlow id="${id}" sourceRef="${source}" targetRef="${target}" />`;
+  const compensation = (ref: string, where: 'process' | 'sub' | 'end' | 'eventSub' = 'process') => {
+    const thr = `<bpmn:intermediateThrowEvent id="Th"><bpmn:compensateEventDefinition activityRef="${ref}" /></bpmn:intermediateThrowEvent>`;
+    const sub = `<bpmn:subProcess id="Sub"><bpmn:startEvent id="SS" /><bpmn:userTask id="Inner" />${where === 'sub' ? thr : ''}</bpmn:subProcess>`;
+    const end =
+      where === 'end'
+        ? `<bpmn:endEvent id="End"><bpmn:compensateEventDefinition activityRef="${ref}" /></bpmn:endEvent>`
+        : '<bpmn:endEvent id="End" />';
+    const eventSub =
+      where === 'eventSub'
+        ? `<bpmn:subProcess id="ES" triggeredByEvent="true"><bpmn:startEvent id="ESS" isInterrupting="false">${MSG}</bpmn:startEvent>${thr}</bpmn:subProcess>`
+        : '';
+    return engineModel(
+      'c7',
+      `${START}<bpmn:userTask id="Host" />${sub}${where === 'process' ? thr : ''}${end}${eventSub}${flow('F0', 'Start', 'Host')}`,
+      { roots: ROOTS },
+    );
+  };
+  const compensationReport = (id: string, named: string) => ({
+    id,
+    message: `Compensation event ${id} names activityRef ${named}; the engines compensate only activities of the throw event's own (sub-)process and refuse the file`,
+    path: ['eventDefinitions', 0, 'activityRef'],
+    type: ERROR_TYPES.PROPERTY_VALUE_NOT_ALLOWED,
+  });
+
+  verifyEngineRule(rule, {
+    valid: [
+      {
+        name: 'a timer with a duration and a conditional event with a condition',
+        moddleElement: engineModel(
+          'c7',
+          catchWith(TIMER) +
+            '<bpmn:intermediateCatchEvent id="C"><bpmn:conditionalEventDefinition><bpmn:condition xsi:type="bpmn:tFormalExpression">${ready}</bpmn:condition></bpmn:conditionalEventDefinition></bpmn:intermediateCatchEvent>',
+        ),
+      },
+      {
+        name: 'event sub-process start: the message acts, an empty timer is ignored',
+        moddleElement: engineModel('c7', eventSubStart(MSG + EMPTY_TIMER), { roots: ROOTS }),
+      },
+      {
+        name: 'a timer without value in a non-executable process',
+        moddleElement: engineModel('c7', catchWith(EMPTY_TIMER), {
+          processAttributes: 'isExecutable="false"',
+        }),
+      },
+      {
+        name: 'a timer without value in an ad-hoc sub-process',
+        moddleElement: engineModel(
+          'c7',
+          `<bpmn:adHocSubProcess id="AH">${catchWith(EMPTY_TIMER)}</bpmn:adHocSubProcess>`,
+        ),
+      },
+      {
+        name: 'compensation of the sub-process from its own scope',
+        moddleElement: compensation('Sub'),
+      },
+      {
+        name: 'compensation of an activity of the own scope',
+        moddleElement: compensation('Host'),
+      },
+      {
+        name: 'compensation from an event sub-process of an activity of its parent scope',
+        moddleElement: compensation('Host', 'eventSub'),
+      },
+      {
+        name: 'compensation inside a sub-process of its own activity',
+        moddleElement: compensation('Inner', 'sub'),
+      },
+      {
+        name: 'a Camunda 8 diagram',
+        moddleElement: engineModel(
+          'c8',
+          catchWith(COND_NONE) +
+            `<bpmn:intermediateCatchEvent id="T">${TWO_TIMES}</bpmn:intermediateCatchEvent>`,
+        ),
+      },
+    ],
+    invalid: [
+      {
+        name: 'compensation of an activity inside a sub-process from the process',
+        moddleElement: compensation('Inner'),
+        report: compensationReport('Th', 'userTask Inner, which is not in process_test'),
+      },
+      {
+        name: 'compensation end event naming an activity inside a sub-process',
+        moddleElement: compensation('Inner', 'end'),
+        report: compensationReport('End', 'userTask Inner, which is not in process_test'),
+      },
+      {
+        name: 'compensation of a process activity from inside a sub-process',
+        moddleElement: compensation('Host', 'sub'),
+        report: compensationReport('Th', 'userTask Host, which is not in Sub'),
+      },
+      {
+        name: 'compensation naming a sequence flow',
+        moddleElement: compensation('F0'),
+        report: compensationReport('Th', 'F0, which is not a flow node'),
+      },
+    ],
+  });
+});
diff --git a/test/adapters/out/bpmnlint/engine/rules/c7/C7ComplexGatewayNoFlowsRule.test.ts b/test/adapters/out/bpmnlint/engine/rules/c7/C7ComplexGatewayNoFlowsRule.test.ts
new file mode 100644
index 00000000..6e2250fe
--- /dev/null
+++ b/test/adapters/out/bpmnlint/engine/rules/c7/C7ComplexGatewayNoFlowsRule.test.ts
@@ -0,0 +1,54 @@
+import { ERROR_TYPES } from 'bpmnlint-plugin-camunda-compat/rules/utils/error-types.js';
+import { describe } from 'vitest';
+import rule from '../../../../../../../src/adapters/out/bpmnlint/engine/rules/c7/C7ComplexGatewayNoFlowsRule.js';
+import { engineModel, verifyEngineRule } from '../../../../../../helpers/engine-model.js';
+
+describe('c7-complex-gateway-no-flows', () => {
+  const flow = (id: string, from: string, target: string) =>
+    `<bpmn:sequenceFlow id="${id}" sourceRef="${from}" targetRef="${target}" />`;
+  const around = (node: string) =>
+    `<bpmn:startEvent id="Start" />${flow('F1', 'Start', 'SP')}${node}${flow('F2', 'SP', 'End')}<bpmn:endEvent id="End" />`;
+  const beside = (extra: string) =>
+    `<bpmn:startEvent id="Start" />${flow('F1', 'Start', 'U')}<bpmn:userTask id="U" />${flow('F2', 'U', 'End')}<bpmn:endEvent id="End" />${extra}`;
+  const COMPLEX = '<bpmn:complexGateway id="SP" />';
+  const report = (end: string, flowId: string) => ({
+    id: 'SP',
+    message: `Complex gateway SP is connected; the engines do not run complex gateways and refuse the file (invalid ${end} 'SP' of sequence flow ${flowId})`,
+    type: ERROR_TYPES.ELEMENT_TYPE_NOT_ALLOWED,
+  });
+
+  verifyEngineRule(rule, {
+    valid: [
+      {
+        name: 'a complex gateway that nothing connects',
+        moddleElement: engineModel('c7', beside(COMPLEX)),
+      },
+      {
+        name: 'a connected complex gateway in a non-executable process',
+        moddleElement: engineModel('c7', around(COMPLEX), {
+          processAttributes: 'isExecutable="false"',
+        }),
+      },
+      {
+        name: 'a connected complex gateway in an ad-hoc sub-process',
+        moddleElement: engineModel(
+          'c7',
+          `<bpmn:adHocSubProcess id="AH">${around(COMPLEX)}</bpmn:adHocSubProcess>`,
+        ),
+      },
+      { name: 'a Camunda 8 diagram', moddleElement: engineModel('c8', around(COMPLEX)) },
+    ],
+    invalid: [
+      {
+        name: 'a complex gateway with sequence flows',
+        moddleElement: engineModel('c7', around(COMPLEX)),
+        report: report('destination', 'F1'),
+      },
+      {
+        name: 'a complex gateway with an outgoing flow only',
+        moddleElement: engineModel('c7', beside(`${COMPLEX}${flow('F3', 'SP', 'End')}`)),
+        report: report('source', 'F3'),
+      },
+    ],
+  });
+});
diff --git a/test/adapters/out/bpmnlint/engine/rules/c7/C7ConditionalEventNeedsConditionRule.test.ts b/test/adapters/out/bpmnlint/engine/rules/c7/C7ConditionalEventNeedsConditionRule.test.ts
new file mode 100644
index 00000000..27e3e706
--- /dev/null
+++ b/test/adapters/out/bpmnlint/engine/rules/c7/C7ConditionalEventNeedsConditionRule.test.ts
@@ -0,0 +1,139 @@
+import { ERROR_TYPES } from 'bpmnlint-plugin-camunda-compat/rules/utils/error-types.js';
+import { describe } from 'vitest';
+import rule from '../../../../../../../src/adapters/out/bpmnlint/engine/rules/c7/C7ConditionalEventNeedsConditionRule.js';
+import { engineModel, verifyEngineRule } from '../../../../../../helpers/engine-model.js';
+
+describe('c7-conditional-event-needs-condition', () => {
+  const ROOTS = '<bpmn:message id="M" name="Pay" />';
+  const TIMER =
+    '<bpmn:timerEventDefinition id="TDef"><bpmn:timeDuration xsi:type="bpmn:tFormalExpression">PT1H</bpmn:timeDuration></bpmn:timerEventDefinition>';
+  const EMPTY_TIMER = '<bpmn:timerEventDefinition id="TDef" />';
+  const TWO_TIMES =
+    '<bpmn:timerEventDefinition id="TDef"><bpmn:timeDate xsi:type="bpmn:tFormalExpression">2030-01-01T00:00:00Z</bpmn:timeDate><bpmn:timeDuration xsi:type="bpmn:tFormalExpression">PT1H</bpmn:timeDuration></bpmn:timerEventDefinition>';
+  const COND_NONE = '<bpmn:conditionalEventDefinition id="CDef" />';
+  const MSG = '<bpmn:messageEventDefinition id="MDef" messageRef="M" />';
+  const START = '<bpmn:startEvent id="Start" />';
+  const catchWith = (defs: string) =>
+    `${START}<bpmn:intermediateCatchEvent id="W">${defs}</bpmn:intermediateCatchEvent>`;
+  const eventSubStart = (defs: string) =>
+    `${START}<bpmn:subProcess id="ES" triggeredByEvent="true"><bpmn:startEvent id="W" isInterrupting="false">${defs}</bpmn:startEvent></bpmn:subProcess>`;
+  const flow = (id: string, source: string, target: string) =>
+    `<bpmn:sequenceFlow id="${id}" sourceRef="${source}" targetRef="${target}" />`;
+  const compensation = (ref: string, where: 'process' | 'sub' | 'end' | 'eventSub' = 'process') => {
+    const thr = `<bpmn:intermediateThrowEvent id="Th"><bpmn:compensateEventDefinition activityRef="${ref}" /></bpmn:intermediateThrowEvent>`;
+    const sub = `<bpmn:subProcess id="Sub"><bpmn:startEvent id="SS" /><bpmn:userTask id="Inner" />${where === 'sub' ? thr : ''}</bpmn:subProcess>`;
+    const end =
+      where === 'end'
+        ? `<bpmn:endEvent id="End"><bpmn:compensateEventDefinition activityRef="${ref}" /></bpmn:endEvent>`
+        : '<bpmn:endEvent id="End" />';
+    const eventSub =
+      where === 'eventSub'
+        ? `<bpmn:subProcess id="ES" triggeredByEvent="true"><bpmn:startEvent id="ESS" isInterrupting="false">${MSG}</bpmn:startEvent>${thr}</bpmn:subProcess>`
+        : '';
+    return engineModel(
+      'c7',
+      `${START}<bpmn:userTask id="Host" />${sub}${where === 'process' ? thr : ''}${end}${eventSub}${flow('F0', 'Start', 'Host')}`,
+      { roots: ROOTS },
+    );
+  };
+  const schemaCondition = (id: string, subject: string, index: number) => ({
+    id,
+    message: `${subject} has no condition element, which the BPMN schema requires; the engines refuse the file`,
+    path: ['eventDefinitions', index, 'condition'],
+    type: ERROR_TYPES.PROPERTY_REQUIRED,
+  });
+
+  verifyEngineRule(rule, {
+    valid: [
+      {
+        name: 'a timer with a duration and a conditional event with a condition',
+        moddleElement: engineModel(
+          'c7',
+          catchWith(TIMER) +
+            '<bpmn:intermediateCatchEvent id="C"><bpmn:conditionalEventDefinition><bpmn:condition xsi:type="bpmn:tFormalExpression">${ready}</bpmn:condition></bpmn:conditionalEventDefinition></bpmn:intermediateCatchEvent>',
+        ),
+      },
+      {
+        name: 'event sub-process start: the message acts, an empty timer is ignored',
+        moddleElement: engineModel('c7', eventSubStart(MSG + EMPTY_TIMER), { roots: ROOTS }),
+      },
+      {
+        name: 'a timer without value in a non-executable process',
+        moddleElement: engineModel('c7', catchWith(EMPTY_TIMER), {
+          processAttributes: 'isExecutable="false"',
+        }),
+      },
+      {
+        name: 'a timer without value in an ad-hoc sub-process',
+        moddleElement: engineModel(
+          'c7',
+          `<bpmn:adHocSubProcess id="AH">${catchWith(EMPTY_TIMER)}</bpmn:adHocSubProcess>`,
+        ),
+      },
+      {
+        name: 'compensation of the sub-process from its own scope',
+        moddleElement: compensation('Sub'),
+      },
+      {
+        name: 'compensation of an activity of the own scope',
+        moddleElement: compensation('Host'),
+      },
+      {
+        name: 'compensation from an event sub-process of an activity of its parent scope',
+        moddleElement: compensation('Host', 'eventSub'),
+      },
+      {
+        name: 'compensation inside a sub-process of its own activity',
+        moddleElement: compensation('Inner', 'sub'),
+      },
+      {
+        name: 'a Camunda 8 diagram',
+        moddleElement: engineModel(
+          'c8',
+          catchWith(COND_NONE) +
+            `<bpmn:intermediateCatchEvent id="T">${TWO_TIMES}</bpmn:intermediateCatchEvent>`,
+        ),
+      },
+    ],
+    invalid: [
+      {
+        name: 'conditional event without a condition element',
+        moddleElement: engineModel('c7', catchWith(COND_NONE)),
+        report: schemaCondition('W', 'Conditional event W', 0),
+      },
+      {
+        name: 'timer + conditional without condition (intermediate catch)',
+        moddleElement: engineModel('c7', catchWith(TIMER + COND_NONE)),
+        report: schemaCondition('W', 'The conditional definition of intermediateCatchEvent:timer W', 1),
+      },
+      {
+        name: 'conditional without condition + timer (intermediate catch, the timer acts)',
+        moddleElement: engineModel('c7', catchWith(COND_NONE + TIMER)),
+        report: schemaCondition('W', 'The conditional definition of intermediateCatchEvent:conditional W', 0),
+      },
+      {
+        name: 'timer + conditional without condition (boundary event)',
+        moddleElement: engineModel(
+          'c7',
+          `${START}<bpmn:userTask id="U" /><bpmn:boundaryEvent id="W" attachedToRef="U">${TIMER}${COND_NONE}</bpmn:boundaryEvent>`,
+        ),
+        report: schemaCondition('W', 'The conditional definition of boundaryEvent:timer W', 1),
+      },
+      {
+        name: 'timer + conditional without condition (process start event)',
+        moddleElement: engineModel(
+          'c7',
+          `<bpmn:startEvent id="W">${TIMER}${COND_NONE}</bpmn:startEvent>`,
+        ),
+        report: schemaCondition('W', 'The conditional definition of startEvent:timer W', 1),
+      },
+      {
+        name: 'conditional without condition in a non-executable process',
+        moddleElement: engineModel('c7', catchWith(COND_NONE).replace('id="W"', 'id="O_W"'), {
+          processAttributes: 'isExecutable="false"',
+        }),
+        report: schemaCondition('O_W', 'Conditional event O_W', 0),
+      },
+    ],
+  });
+});
diff --git a/test/adapters/out/bpmnlint/engine/rules/c7/C7ConnectorNeedsIdRule.test.ts b/test/adapters/out/bpmnlint/engine/rules/c7/C7ConnectorNeedsIdRule.test.ts
new file mode 100644
index 00000000..01ed4008
--- /dev/null
+++ b/test/adapters/out/bpmnlint/engine/rules/c7/C7ConnectorNeedsIdRule.test.ts
@@ -0,0 +1,108 @@
+import { ERROR_TYPES } from 'bpmnlint-plugin-camunda-compat/rules/utils/error-types.js';
+import { describe } from 'vitest';
+import rule from '../../../../../../../src/adapters/out/bpmnlint/engine/rules/c7/C7ConnectorNeedsIdRule.js';
+import { engineModel, verifyEngineRule } from '../../../../../../helpers/engine-model.js';
+
+describe('c7-connector-needs-id', () => {
+  const ext = (inner: string) => `<bpmn:extensionElements>${inner}</bpmn:extensionElements>`;
+  const ROOTS =
+    '<bpmn:signal id="signal_go" name="go" /><bpmn:message id="message_paid" name="paid" />';
+  const REQUIRED = ERROR_TYPES.PROPERTY_REQUIRED;
+  const callActivity = (inner: string) =>
+    `<bpmn:callActivity id="callActivity_ship" calledElement="ship">${ext(inner)}</bpmn:callActivity>`;
+  const serviceTask = (attributes: string, inner: string) =>
+    `<bpmn:serviceTask id="serviceTask_charge" ${attributes}>${ext(inner)}</bpmn:serviceTask>`;
+  const userTask = (inner: string) =>
+    `<bpmn:userTask id="userTask_review">${ext(inner)}</bpmn:userTask>`;
+  const report = (id: string, message: string, path: (string | number)[], type = REQUIRED) => ({
+    id,
+    message,
+    path,
+    type,
+  });
+
+  verifyEngineRule(rule, {
+    valid: [
+      {
+        name: 'complete bindings, mappings, connector and form',
+        moddleElement: engineModel(
+          'c7',
+          callActivity(
+            '<camunda:in source="a" target="a" /><camunda:in sourceExpression="${b}" target="b" /><camunda:in businessKey="${key}" /><camunda:out variables="all" />',
+          ) +
+            serviceTask(
+              'camunda:class="a.B"',
+              '<camunda:field name="a" stringValue="x" /><camunda:field name="b"><camunda:string /></camunda:field><camunda:field name="c" expression="${c}" /><camunda:inputOutput><camunda:inputParameter name="p">1</camunda:inputParameter></camunda:inputOutput>',
+            ) +
+            '<bpmn:sendTask id="sendTask_notify"><bpmn:extensionElements><camunda:connector><camunda:connectorId>mail</camunda:connectorId></camunda:connector></bpmn:extensionElements></bpmn:sendTask>' +
+            userTask(
+              '<camunda:formData><camunda:formField id="a" type="string" /><camunda:formField id="b" type="date" /></camunda:formData>',
+            ),
+        ),
+      },
+      {
+        name: 'fields the engines do not read: an expression or external implementation, an expression listener',
+        moddleElement: engineModel(
+          'c7',
+          serviceTask('camunda:expression="${true}"', '<camunda:field name="a" />') +
+            serviceTask(
+              'camunda:type="external" camunda:topic="charge"',
+              '<camunda:field name="a" />',
+            ).replace('serviceTask_charge', 'serviceTask_refund') +
+            userTask(
+              '<camunda:taskListener event="create" expression="${l}" delegateExpression="${d}"><camunda:field name="a" /></camunda:taskListener>',
+            ),
+        ),
+      },
+      {
+        name: 'an incomplete binding where the engines do not read it (c7-camunda-extension-placement)',
+        moddleElement: engineModel(
+          'c7',
+          serviceTask('camunda:expression="${true}"', '<camunda:in source="a" />'),
+        ),
+      },
+      {
+        name: 'incomplete content in a non-executable process',
+        moddleElement: engineModel('c7', callActivity('<camunda:in source="a" />'), {
+          processAttributes: 'isExecutable="false"',
+        }),
+      },
+      {
+        name: 'incomplete content inside an ad-hoc sub-process of an executable process',
+        moddleElement: engineModel(
+          'c7',
+          `<bpmn:adHocSubProcess id="adHocSubProcess_steps">${callActivity('<camunda:in source="a" />')}</bpmn:adHocSubProcess>`,
+        ),
+      },
+      {
+        name: 'fields of a message definition the event does not act on',
+        moddleElement: engineModel(
+          'c7',
+          `<bpmn:intermediateThrowEvent id="intermediateThrowEvent_notify"><bpmn:signalEventDefinition signalRef="signal_go" /><bpmn:messageEventDefinition messageRef="message_paid" camunda:class="a.B">${ext('<camunda:field name="a" />')}</bpmn:messageEventDefinition></bpmn:intermediateThrowEvent>`,
+          { roots: ROOTS },
+        ),
+      },
+      {
+        name: 'a Camunda 8 diagram',
+        moddleElement: engineModel('c8', '<bpmn:callActivity id="callActivity_ship" />'),
+      },
+    ],
+    invalid: [
+      {
+        name: 'a connector without connectorId, with a nameless parameter',
+        moddleElement: engineModel(
+          'c7',
+          serviceTask(
+            '',
+            '<camunda:connector><camunda:inputOutput><camunda:outputParameter>1</camunda:outputParameter></camunda:inputOutput></camunda:connector>',
+          ),
+        ),
+        report: report(
+            'serviceTask_charge',
+            'camunda:connector of serviceTask serviceTask_charge has no camunda:connectorId; the engines refuse the file',
+            ['extensionElements', 'values', 0, 'connectorId'],
+          ),
+      },
+    ],
+  });
+});
diff --git a/test/adapters/out/bpmnlint/engine/rules/c7/C7DecisionResultMapperKnownRule.test.ts b/test/adapters/out/bpmnlint/engine/rules/c7/C7DecisionResultMapperKnownRule.test.ts
new file mode 100644
index 00000000..838733c1
--- /dev/null
+++ b/test/adapters/out/bpmnlint/engine/rules/c7/C7DecisionResultMapperKnownRule.test.ts
@@ -0,0 +1,81 @@
+import { ERROR_TYPES } from 'bpmnlint-plugin-camunda-compat/rules/utils/error-types.js';
+import { describe } from 'vitest';
+import rule from '../../../../../../../src/adapters/out/bpmnlint/engine/rules/c7/C7DecisionResultMapperKnownRule.js';
+import { engineModel, verifyEngineRule } from '../../../../../../helpers/engine-model.js';
+
+describe('c7-decision-result-mapper-known', () => {
+  verifyEngineRule(rule, {
+    valid: [
+      {
+        name: 'priorities as numbers and expressions, a known decision result mapper',
+        moddleElement: engineModel(
+          'c7',
+          `<bpmn:serviceTask id="serviceTask_a" camunda:type="external" camunda:topic="chargeCard" camunda:taskPriority="5" camunda:asyncBefore="true" camunda:jobPriority="\${priority}" />
+          <bpmn:businessRuleTask id="businessRuleTask_b" camunda:decisionRef="risk" camunda:mapDecisionResult="collectEntries" />
+          <bpmn:userTask id="userTask_c"><bpmn:multiInstanceLoopCharacteristics camunda:collection="\${items}" camunda:elementVariable="item" camunda:jobPriority="-3" /></bpmn:userTask>`,
+          {
+            processAttributes:
+              'isExecutable="true" camunda:jobPriority="10" camunda:taskPriority="#{priority}"',
+          },
+        ),
+      },
+      {
+        name: 'a mapDecisionResult without decisionRef is not read',
+        moddleElement: engineModel(
+          'c7',
+          '<bpmn:businessRuleTask id="businessRuleTask_b" camunda:class="org.example.Rule" camunda:mapDecisionResult="foo" />',
+        ),
+      },
+      {
+        name: 'a taskPriority where the engines do not read it',
+        moddleElement: engineModel(
+          'c7',
+          '<bpmn:serviceTask id="serviceTask_a" camunda:class="org.example.Bean" camunda:taskPriority="high" /><bpmn:userTask id="userTask_c" camunda:taskPriority="high" />',
+        ),
+      },
+      {
+        name: 'an ad-hoc sub-process and its content',
+        moddleElement: engineModel(
+          'c7',
+          '<bpmn:adHocSubProcess id="adHocSubProcess_x" camunda:jobPriority="high"><bpmn:userTask id="userTask_c" camunda:jobPriority="high" /></bpmn:adHocSubProcess>',
+        ),
+      },
+      {
+        name: 'a non-executable process',
+        moddleElement: engineModel(
+          'c7',
+          '<bpmn:userTask id="userTask_c" camunda:jobPriority="high" />',
+          {
+            processAttributes: 'isExecutable="false" camunda:jobPriority="high"',
+          },
+        ),
+      },
+      {
+        name: 'a Camunda 8 diagram',
+        moddleElement: engineModel(
+          'c8',
+          '<bpmn:userTask id="userTask_c" camunda:jobPriority="high" />',
+          {
+            definitionsAttributes: 'xmlns:camunda="http://camunda.org/schema/1.0/bpmn"',
+          },
+        ),
+      },
+    ],
+    invalid: [
+      {
+        name: 'a mapDecisionResult not one of the four',
+        moddleElement: engineModel(
+          'c7',
+          '<bpmn:businessRuleTask id="businessRuleTask_b" camunda:decisionRef="risk" camunda:mapDecisionResult="foo" />',
+        ),
+        report: {
+          id: 'businessRuleTask_b',
+          message:
+            'camunda:mapDecisionResult="foo" on businessRuleTask businessRuleTask_b is not one of singleEntry, singleResult, collectEntries, resultList; the engines refuse the file',
+          path: ['mapDecisionResult'],
+          type: ERROR_TYPES.PROPERTY_VALUE_NOT_ALLOWED,
+        },
+      },
+    ],
+  });
+});
diff --git a/test/adapters/out/bpmnlint/engine/rules/c7/C7ElementVariableNeedsCollectionRule.test.ts b/test/adapters/out/bpmnlint/engine/rules/c7/C7ElementVariableNeedsCollectionRule.test.ts
new file mode 100644
index 00000000..3ff56167
--- /dev/null
+++ b/test/adapters/out/bpmnlint/engine/rules/c7/C7ElementVariableNeedsCollectionRule.test.ts
@@ -0,0 +1,62 @@
+import { ERROR_TYPES } from 'bpmnlint-plugin-camunda-compat/rules/utils/error-types.js';
+import { describe } from 'vitest';
+import rule from '../../../../../../../src/adapters/out/bpmnlint/engine/rules/c7/C7ElementVariableNeedsCollectionRule.js';
+import { engineModel, verifyEngineRule } from '../../../../../../helpers/engine-model.js';
+
+describe('c7-element-variable-needs-collection', () => {
+  verifyEngineRule(rule, {
+    valid: [
+      {
+        name: 'a collection, a cardinality or a loopDataInputRef',
+        moddleElement: engineModel(
+          'c7',
+          `<bpmn:userTask id="userTask_a"><bpmn:multiInstanceLoopCharacteristics camunda:collection="\${items}" camunda:elementVariable="item" /></bpmn:userTask>
+          <bpmn:userTask id="userTask_b"><bpmn:multiInstanceLoopCharacteristics><bpmn:loopCardinality>3</bpmn:loopCardinality></bpmn:multiInstanceLoopCharacteristics></bpmn:userTask>
+          <bpmn:userTask id="userTask_c"><bpmn:ioSpecification><bpmn:dataInput id="dataInput_items" /><bpmn:inputSet><bpmn:dataInputRefs>dataInput_items</bpmn:dataInputRefs></bpmn:inputSet><bpmn:outputSet /></bpmn:ioSpecification><bpmn:multiInstanceLoopCharacteristics><bpmn:loopDataInputRef>dataInput_items</bpmn:loopDataInputRef></bpmn:multiInstanceLoopCharacteristics></bpmn:userTask>
+          <bpmn:userTask id="userTask_d"><bpmn:multiInstanceLoopCharacteristics camunda:collection="\${items}"><bpmn:loopCardinality /></bpmn:multiInstanceLoopCharacteristics></bpmn:userTask>
+          <bpmn:userTask id="userTask_e"><bpmn:standardLoopCharacteristics /></bpmn:userTask>`,
+        ),
+      },
+      {
+        name: 'a loop inside an ad-hoc sub-process',
+        moddleElement: engineModel(
+          'c7',
+          '<bpmn:adHocSubProcess id="adHocSubProcess_x"><bpmn:userTask id="userTask_a"><bpmn:multiInstanceLoopCharacteristics /></bpmn:userTask></bpmn:adHocSubProcess>',
+        ),
+      },
+      {
+        name: 'a non-executable process',
+        moddleElement: engineModel(
+          'c7',
+          '<bpmn:userTask id="userTask_a"><bpmn:multiInstanceLoopCharacteristics /></bpmn:userTask>',
+          {
+            processAttributes: 'isExecutable="false"',
+          },
+        ),
+      },
+      {
+        name: 'a Camunda 8 diagram',
+        moddleElement: engineModel(
+          'c8',
+          '<bpmn:userTask id="userTask_a"><bpmn:multiInstanceLoopCharacteristics /></bpmn:userTask>',
+        ),
+      },
+    ],
+    invalid: [
+      {
+        name: 'an element variable without collection',
+        moddleElement: engineModel(
+          'c7',
+          '<bpmn:userTask id="userTask_a"><bpmn:multiInstanceLoopCharacteristics camunda:elementVariable="item"><bpmn:loopCardinality>3</bpmn:loopCardinality></bpmn:multiInstanceLoopCharacteristics></bpmn:userTask>',
+        ),
+        report: {
+          id: 'userTask_a',
+          message:
+            'Multi-instance userTask userTask_a has camunda:elementVariable but no camunda:collection; the engines refuse the file',
+          path: ['loopCharacteristics', 'collection'],
+          type: ERROR_TYPES.PROPERTY_DEPENDENT_REQUIRED,
+        },
+      },
+    ],
+  });
+});
diff --git a/test/adapters/out/bpmnlint/engine/rules/c7/C7ErrorEndEventNeedsErrorRule.test.ts b/test/adapters/out/bpmnlint/engine/rules/c7/C7ErrorEndEventNeedsErrorRule.test.ts
new file mode 100644
index 00000000..94d0cf15
--- /dev/null
+++ b/test/adapters/out/bpmnlint/engine/rules/c7/C7ErrorEndEventNeedsErrorRule.test.ts
@@ -0,0 +1,60 @@
+import { ERROR_TYPES } from 'bpmnlint-plugin-camunda-compat/rules/utils/error-types.js';
+import { describe } from 'vitest';
+import rule from '../../../../../../../src/adapters/out/bpmnlint/engine/rules/c7/C7ErrorEndEventNeedsErrorRule.js';
+import { engineModel, verifyEngineRule } from '../../../../../../helpers/engine-model.js';
+
+describe('c7-error-end-event-needs-error', () => {
+  const ERRORS =
+    '<bpmn:error id="Err" name="Err" /><bpmn:error id="ErrBlank" name="Blank" errorCode=" " /><bpmn:error id="ErrCoded" name="Coded" errorCode="E1" />';
+  const START = '<bpmn:startEvent id="Start" />';
+  const errorEnd = (definition: string) =>
+    `${START}<bpmn:endEvent id="End">${definition}</bpmn:endEvent>`;
+  const error = (ref?: string) => `<bpmn:errorEventDefinition${ref ? ` errorRef="${ref}"` : ''} />`;
+
+  verifyEngineRule(rule, {
+    valid: [
+      {
+        name: 'an error end event whose error has an errorCode',
+        moddleElement: engineModel('c7', errorEnd(error('ErrCoded')), { roots: ERRORS }),
+      },
+      {
+        name: 'an error boundary event without errorCode catches everything',
+        moddleElement: engineModel(
+          'c7',
+          `${START}<bpmn:userTask id="X" /><bpmn:boundaryEvent id="B" attachedToRef="X">${error('Err')}</bpmn:boundaryEvent>`,
+          { roots: ERRORS },
+        ),
+      },
+      {
+        name: 'an error end event without errorCode in a non-executable process',
+        moddleElement: engineModel('c7', errorEnd(error('Err')), {
+          roots: ERRORS,
+          processAttributes: 'isExecutable="false"',
+        }),
+      },
+      {
+        name: 'an error end event without errorRef in an ad-hoc sub-process',
+        moddleElement: engineModel(
+          'c7',
+          `<bpmn:adHocSubProcess id="AH">${errorEnd(error())}</bpmn:adHocSubProcess>`,
+        ),
+      },
+      {
+        name: 'a Camunda 8 diagram',
+        moddleElement: engineModel('c8', errorEnd(error()), { roots: ERRORS }),
+      },
+    ],
+    invalid: [
+      {
+        name: 'an error end event without errorRef',
+        moddleElement: engineModel('c7', errorEnd(error())),
+        report: {
+          id: 'End',
+          message: 'endEvent:error End throws no error (no errorRef); the engines refuse the file',
+          path: ['eventDefinitions', 0, 'errorRef'],
+          type: ERROR_TYPES.PROPERTY_REQUIRED,
+        },
+      },
+    ],
+  });
+});
diff --git a/test/adapters/out/bpmnlint/engine/rules/c7/C7ErrorNeedsCodeRule.test.ts b/test/adapters/out/bpmnlint/engine/rules/c7/C7ErrorNeedsCodeRule.test.ts
new file mode 100644
index 00000000..aa6747e5
--- /dev/null
+++ b/test/adapters/out/bpmnlint/engine/rules/c7/C7ErrorNeedsCodeRule.test.ts
@@ -0,0 +1,71 @@
+import { ERROR_TYPES } from 'bpmnlint-plugin-camunda-compat/rules/utils/error-types.js';
+import { describe } from 'vitest';
+import rule from '../../../../../../../src/adapters/out/bpmnlint/engine/rules/c7/C7ErrorNeedsCodeRule.js';
+import { engineModel, verifyEngineRule } from '../../../../../../helpers/engine-model.js';
+
+describe('c7-error-needs-code', () => {
+  const ERRORS =
+    '<bpmn:error id="Err" name="Err" /><bpmn:error id="ErrBlank" name="Blank" errorCode=" " /><bpmn:error id="ErrCoded" name="Coded" errorCode="E1" />';
+  const START = '<bpmn:startEvent id="Start" />';
+  const errorEnd = (definition: string) =>
+    `${START}<bpmn:endEvent id="End">${definition}</bpmn:endEvent>`;
+  const error = (ref?: string) => `<bpmn:errorEventDefinition${ref ? ` errorRef="${ref}"` : ''} />`;
+
+  verifyEngineRule(rule, {
+    valid: [
+      {
+        name: 'an error end event whose error has an errorCode',
+        moddleElement: engineModel('c7', errorEnd(error('ErrCoded')), { roots: ERRORS }),
+      },
+      {
+        name: 'an error boundary event without errorCode catches everything',
+        moddleElement: engineModel(
+          'c7',
+          `${START}<bpmn:userTask id="X" /><bpmn:boundaryEvent id="B" attachedToRef="X">${error('Err')}</bpmn:boundaryEvent>`,
+          { roots: ERRORS },
+        ),
+      },
+      {
+        name: 'an error end event without errorCode in a non-executable process',
+        moddleElement: engineModel('c7', errorEnd(error('Err')), {
+          roots: ERRORS,
+          processAttributes: 'isExecutable="false"',
+        }),
+      },
+      {
+        name: 'an error end event without errorRef in an ad-hoc sub-process',
+        moddleElement: engineModel(
+          'c7',
+          `<bpmn:adHocSubProcess id="AH">${errorEnd(error())}</bpmn:adHocSubProcess>`,
+        ),
+      },
+      {
+        name: 'a Camunda 8 diagram',
+        moddleElement: engineModel('c8', errorEnd(error()), { roots: ERRORS }),
+      },
+    ],
+    invalid: [
+      {
+        name: 'an error end event whose error has no errorCode',
+        moddleElement: engineModel('c7', errorEnd(error('Err')), { roots: ERRORS }),
+        report: {
+          id: 'End',
+          message: 'Error Err thrown by endEvent:error End has no errorCode; the engines refuse the file',
+          path: ['eventDefinitions', 0, 'errorRef', 'errorCode'],
+          type: ERROR_TYPES.PROPERTY_REQUIRED,
+        },
+      },
+      {
+        name: 'an error end event whose errorCode is blank',
+        moddleElement: engineModel('c7', errorEnd(error('ErrBlank')), { roots: ERRORS }),
+        report: {
+          id: 'End',
+          message:
+            'Error ErrBlank thrown by endEvent:error End has no errorCode; the engines refuse the file',
+          path: ['eventDefinitions', 0, 'errorRef', 'errorCode'],
+          type: ERROR_TYPES.PROPERTY_REQUIRED,
+        },
+      },
+    ],
+  });
+});
diff --git a/test/adapters/out/bpmnlint/engine/rules/c7/C7EscalationBoundaryHostAllowedRule.test.ts b/test/adapters/out/bpmnlint/engine/rules/c7/C7EscalationBoundaryHostAllowedRule.test.ts
new file mode 100644
index 00000000..4d10cc8f
--- /dev/null
+++ b/test/adapters/out/bpmnlint/engine/rules/c7/C7EscalationBoundaryHostAllowedRule.test.ts
@@ -0,0 +1,79 @@
+import { ERROR_TYPES } from 'bpmnlint-plugin-camunda-compat/rules/utils/error-types.js';
+import { describe } from 'vitest';
+import rule from '../../../../../../../src/adapters/out/bpmnlint/engine/rules/c7/C7EscalationBoundaryHostAllowedRule.js';
+import { engineModel, verifyEngineRule } from '../../../../../../helpers/engine-model.js';
+
+describe('c7-escalation-boundary-host-allowed', () => {
+  const ESCALATIONS =
+    '<bpmn:escalation id="Esc" name="Esc" /><bpmn:escalation id="EscCoded" name="Coded" escalationCode="E" />';
+  const START = '<bpmn:startEvent id="Start" />';
+  const escalation = (ref?: string) =>
+    `<bpmn:escalationEventDefinition${ref ? ` escalationRef="${ref}"` : ''} />`;
+  const escalationEnd = (definition: string) =>
+    `${START}<bpmn:endEvent id="End">${definition}</bpmn:endEvent>`;
+  const onHost = (host: string) =>
+    `${START}${host}<bpmn:boundaryEvent id="B" attachedToRef="X">${escalation('EscCoded')}</bpmn:boundaryEvent>`;
+  const SERVICE_TASK = '<bpmn:serviceTask id="X" camunda:expression="${true}" />';
+
+  verifyEngineRule(rule, {
+    valid: [
+      {
+        name: 'an escalation end event whose escalation has an escalationCode',
+        moddleElement: engineModel('c7', escalationEnd(escalation('EscCoded')), {
+          roots: ESCALATIONS,
+        }),
+      },
+      {
+        name: 'an escalation boundary event on a sub-process',
+        moddleElement: engineModel('c7', onHost('<bpmn:subProcess id="X" />'), {
+          roots: ESCALATIONS,
+        }),
+      },
+      {
+        name: 'an escalation boundary event on a call activity',
+        moddleElement: engineModel(
+          'c7',
+          onHost('<bpmn:callActivity id="X" calledElement="other" />'),
+          {
+            roots: ESCALATIONS,
+          },
+        ),
+      },
+      {
+        name: 'an escalation boundary event on a user task',
+        moddleElement: engineModel('c7', onHost('<bpmn:userTask id="X" />'), { roots: ESCALATIONS }),
+      },
+      {
+        name: 'an escalation boundary event on a service task in a non-executable process',
+        moddleElement: engineModel('c7', onHost(SERVICE_TASK), {
+          roots: ESCALATIONS,
+          processAttributes: 'isExecutable="false"',
+        }),
+      },
+      {
+        name: 'an escalation end event without escalationRef in an ad-hoc sub-process',
+        moddleElement: engineModel(
+          'c7',
+          `<bpmn:adHocSubProcess id="AH">${escalationEnd(escalation())}</bpmn:adHocSubProcess>`,
+        ),
+      },
+      {
+        name: 'a Camunda 8 diagram',
+        moddleElement: engineModel('c8', escalationEnd(escalation('Esc')), { roots: ESCALATIONS }),
+      },
+    ],
+    invalid: [
+      {
+        name: 'an escalation boundary event on a service task',
+        moddleElement: engineModel('c7', onHost(SERVICE_TASK), { roots: ESCALATIONS }),
+        report: {
+          id: 'B',
+          message:
+            'Escalation boundary event B is attached to serviceTask X; the engines allow it only on sub-processes, call activities and user tasks and refuse the file',
+          path: ['attachedToRef'],
+          type: ERROR_TYPES.ATTACHED_TO_REF_ELEMENT_TYPE_NOT_ALLOWED,
+        },
+      },
+    ],
+  });
+});
diff --git a/test/adapters/out/bpmnlint/engine/rules/c7/C7EscalationNeedsCodeRule.test.ts b/test/adapters/out/bpmnlint/engine/rules/c7/C7EscalationNeedsCodeRule.test.ts
new file mode 100644
index 00000000..4e5edee8
--- /dev/null
+++ b/test/adapters/out/bpmnlint/engine/rules/c7/C7EscalationNeedsCodeRule.test.ts
@@ -0,0 +1,79 @@
+import { ERROR_TYPES } from 'bpmnlint-plugin-camunda-compat/rules/utils/error-types.js';
+import { describe } from 'vitest';
+import rule from '../../../../../../../src/adapters/out/bpmnlint/engine/rules/c7/C7EscalationNeedsCodeRule.js';
+import { engineModel, verifyEngineRule } from '../../../../../../helpers/engine-model.js';
+
+describe('c7-escalation-needs-code', () => {
+  const ESCALATIONS =
+    '<bpmn:escalation id="Esc" name="Esc" /><bpmn:escalation id="EscCoded" name="Coded" escalationCode="E" />';
+  const START = '<bpmn:startEvent id="Start" />';
+  const escalation = (ref?: string) =>
+    `<bpmn:escalationEventDefinition${ref ? ` escalationRef="${ref}"` : ''} />`;
+  const escalationEnd = (definition: string) =>
+    `${START}<bpmn:endEvent id="End">${definition}</bpmn:endEvent>`;
+  const onHost = (host: string) =>
+    `${START}${host}<bpmn:boundaryEvent id="B" attachedToRef="X">${escalation('EscCoded')}</bpmn:boundaryEvent>`;
+  const SERVICE_TASK = '<bpmn:serviceTask id="X" camunda:expression="${true}" />';
+
+  verifyEngineRule(rule, {
+    valid: [
+      {
+        name: 'an escalation end event whose escalation has an escalationCode',
+        moddleElement: engineModel('c7', escalationEnd(escalation('EscCoded')), {
+          roots: ESCALATIONS,
+        }),
+      },
+      {
+        name: 'an escalation boundary event on a sub-process',
+        moddleElement: engineModel('c7', onHost('<bpmn:subProcess id="X" />'), {
+          roots: ESCALATIONS,
+        }),
+      },
+      {
+        name: 'an escalation boundary event on a call activity',
+        moddleElement: engineModel(
+          'c7',
+          onHost('<bpmn:callActivity id="X" calledElement="other" />'),
+          {
+            roots: ESCALATIONS,
+          },
+        ),
+      },
+      {
+        name: 'an escalation boundary event on a user task',
+        moddleElement: engineModel('c7', onHost('<bpmn:userTask id="X" />'), { roots: ESCALATIONS }),
+      },
+      {
+        name: 'an escalation boundary event on a service task in a non-executable process',
+        moddleElement: engineModel('c7', onHost(SERVICE_TASK), {
+          roots: ESCALATIONS,
+          processAttributes: 'isExecutable="false"',
+        }),
+      },
+      {
+        name: 'an escalation end event without escalationRef in an ad-hoc sub-process',
+        moddleElement: engineModel(
+          'c7',
+          `<bpmn:adHocSubProcess id="AH">${escalationEnd(escalation())}</bpmn:adHocSubProcess>`,
+        ),
+      },
+      {
+        name: 'a Camunda 8 diagram',
+        moddleElement: engineModel('c8', escalationEnd(escalation('Esc')), { roots: ESCALATIONS }),
+      },
+    ],
+    invalid: [
+      {
+        name: 'an escalation end event without escalationCode',
+        moddleElement: engineModel('c7', escalationEnd(escalation('Esc')), { roots: ESCALATIONS }),
+        report: {
+          id: 'End',
+          message:
+            'Escalation Esc thrown by endEvent:escalation End has no escalationCode; the engines refuse the file',
+          path: ['eventDefinitions', 0, 'escalationRef', 'escalationCode'],
+          type: ERROR_TYPES.PROPERTY_REQUIRED,
+        },
+      },
+    ],
+  });
+});
diff --git a/test/adapters/out/bpmnlint/engine/rules/c7/C7EscalationThrowNeedsEscalationRule.test.ts b/test/adapters/out/bpmnlint/engine/rules/c7/C7EscalationThrowNeedsEscalationRule.test.ts
new file mode 100644
index 00000000..591c234f
--- /dev/null
+++ b/test/adapters/out/bpmnlint/engine/rules/c7/C7EscalationThrowNeedsEscalationRule.test.ts
@@ -0,0 +1,82 @@
+import { ERROR_TYPES } from 'bpmnlint-plugin-camunda-compat/rules/utils/error-types.js';
+import { describe } from 'vitest';
+import rule from '../../../../../../../src/adapters/out/bpmnlint/engine/rules/c7/C7EscalationThrowNeedsEscalationRule.js';
+import { engineModel, verifyEngineRule } from '../../../../../../helpers/engine-model.js';
+
+describe('c7-escalation-throw-needs-escalation', () => {
+  const ESCALATIONS =
+    '<bpmn:escalation id="Esc" name="Esc" /><bpmn:escalation id="EscCoded" name="Coded" escalationCode="E" />';
+  const START = '<bpmn:startEvent id="Start" />';
+  const escalation = (ref?: string) =>
+    `<bpmn:escalationEventDefinition${ref ? ` escalationRef="${ref}"` : ''} />`;
+  const escalationEnd = (definition: string) =>
+    `${START}<bpmn:endEvent id="End">${definition}</bpmn:endEvent>`;
+  const onHost = (host: string) =>
+    `${START}${host}<bpmn:boundaryEvent id="B" attachedToRef="X">${escalation('EscCoded')}</bpmn:boundaryEvent>`;
+  const SERVICE_TASK = '<bpmn:serviceTask id="X" camunda:expression="${true}" />';
+
+  verifyEngineRule(rule, {
+    valid: [
+      {
+        name: 'an escalation end event whose escalation has an escalationCode',
+        moddleElement: engineModel('c7', escalationEnd(escalation('EscCoded')), {
+          roots: ESCALATIONS,
+        }),
+      },
+      {
+        name: 'an escalation boundary event on a sub-process',
+        moddleElement: engineModel('c7', onHost('<bpmn:subProcess id="X" />'), {
+          roots: ESCALATIONS,
+        }),
+      },
+      {
+        name: 'an escalation boundary event on a call activity',
+        moddleElement: engineModel(
+          'c7',
+          onHost('<bpmn:callActivity id="X" calledElement="other" />'),
+          {
+            roots: ESCALATIONS,
+          },
+        ),
+      },
+      {
+        name: 'an escalation boundary event on a user task',
+        moddleElement: engineModel('c7', onHost('<bpmn:userTask id="X" />'), { roots: ESCALATIONS }),
+      },
+      {
+        name: 'an escalation boundary event on a service task in a non-executable process',
+        moddleElement: engineModel('c7', onHost(SERVICE_TASK), {
+          roots: ESCALATIONS,
+          processAttributes: 'isExecutable="false"',
+        }),
+      },
+      {
+        name: 'an escalation end event without escalationRef in an ad-hoc sub-process',
+        moddleElement: engineModel(
+          'c7',
+          `<bpmn:adHocSubProcess id="AH">${escalationEnd(escalation())}</bpmn:adHocSubProcess>`,
+        ),
+      },
+      {
+        name: 'a Camunda 8 diagram',
+        moddleElement: engineModel('c8', escalationEnd(escalation('Esc')), { roots: ESCALATIONS }),
+      },
+    ],
+    invalid: [
+      {
+        name: 'an escalation throw event without escalationRef',
+        moddleElement: engineModel(
+          'c7',
+          `${START}<bpmn:intermediateThrowEvent id="T">${escalation()}</bpmn:intermediateThrowEvent>`,
+        ),
+        report: {
+          id: 'T',
+          message:
+            'intermediateThrowEvent:escalation T throws no escalation (no escalationRef); the engines refuse the file',
+          path: ['eventDefinitions', 0, 'escalationRef'],
+          type: ERROR_TYPES.PROPERTY_REQUIRED,
+        },
+      },
+    ],
+  });
+});
diff --git a/test/adapters/out/bpmnlint/engine/rules/c7/C7EventGatewayBranchesUniqueRule.test.ts b/test/adapters/out/bpmnlint/engine/rules/c7/C7EventGatewayBranchesUniqueRule.test.ts
new file mode 100644
index 00000000..5b972f7a
--- /dev/null
+++ b/test/adapters/out/bpmnlint/engine/rules/c7/C7EventGatewayBranchesUniqueRule.test.ts
@@ -0,0 +1,108 @@
+import { ERROR_TYPES } from 'bpmnlint-plugin-camunda-compat/rules/utils/error-types.js';
+import { describe } from 'vitest';
+import rule from '../../../../../../../src/adapters/out/bpmnlint/engine/rules/c7/C7EventGatewayBranchesUniqueRule.js';
+import { engineModel, verifyEngineRule } from '../../../../../../helpers/engine-model.js';
+
+describe('c7-event-gateway-branches-unique', () => {
+  const MESSAGES =
+    '<bpmn:message id="M1" name="M1" /><bpmn:message id="M1b" name="M1" /><bpmn:message id="M2" name="M2" /><bpmn:signal id="S1" name="Go" /><bpmn:signal id="S1b" name="Go" />';
+  const TIMER =
+    '<bpmn:timerEventDefinition><bpmn:timeDuration xsi:type="bpmn:tFormalExpression">PT1H</bpmn:timeDuration></bpmn:timerEventDefinition>';
+  const catchEvent = (definitions: string) =>
+    `<bpmn:intermediateCatchEvent id="{id}">${definitions}</bpmn:intermediateCatchEvent>`;
+  const TIMER_CATCH = catchEvent(TIMER);
+  const msgCatch = (ref: string) => catchEvent(`<bpmn:messageEventDefinition messageRef="${ref}" />`);
+  const signalCatch = (ref: string) =>
+    catchEvent(`<bpmn:signalEventDefinition signalRef="${ref}" />`);
+  const LINK = '<bpmn:linkEventDefinition name="L" />';
+  const COND =
+    '<bpmn:conditionalEventDefinition><bpmn:condition xsi:type="bpmn:tFormalExpression">${ready}</bpmn:condition></bpmn:conditionalEventDefinition>';
+  const eventGateway = (targets: string[], extra = '') => {
+    const branches = targets.map(
+      (target, index) => `<bpmn:sequenceFlow id="G${index}" sourceRef="G" targetRef="T${index}" />
+      ${target.replace('{id}', `T${index}`)}
+      <bpmn:sequenceFlow id="E${index}" sourceRef="T${index}" targetRef="End${index}" />
+      <bpmn:endEvent id="End${index}" />`,
+    );
+    return `<bpmn:startEvent id="Start" />
+      <bpmn:sequenceFlow id="F1" sourceRef="Start" targetRef="G" />
+      <bpmn:eventBasedGateway id="G" />
+      ${branches.join('\n')}${extra}`;
+  };
+  const model = (xml: string, options = {}) =>
+    engineModel('c7', xml, { roots: MESSAGES, ...options });
+
+  verifyEngineRule(rule, {
+    valid: [
+      {
+        name: 'timer and message branches',
+        moddleElement: model(eventGateway([TIMER_CATCH, msgCatch('M1')])),
+      },
+      {
+        name: 'signal and conditional branches',
+        moddleElement: model(eventGateway([signalCatch('S1'), catchEvent(COND)])),
+      },
+      {
+        name: 'a message + timer catch event (the timer acts)',
+        moddleElement: model(
+          eventGateway([
+            TIMER_CATCH,
+            catchEvent(`<bpmn:messageEventDefinition messageRef="M1" />${TIMER}`),
+          ]),
+        ),
+      },
+      {
+        name: 'a link + timer catch event (the timer acts)',
+        moddleElement: model(eventGateway([msgCatch('M1'), catchEvent(LINK + TIMER)])),
+      },
+      {
+        name: 'two branches wait for different message names',
+        moddleElement: model(eventGateway([msgCatch('M1'), msgCatch('M2')])),
+      },
+      {
+        name: 'a message branch and a signal branch with the same name',
+        moddleElement: engineModel('c7', eventGateway([msgCatch('M1'), signalCatch('S1')]), {
+          roots: '<bpmn:message id="M1" name="Go" /><bpmn:signal id="S1" name="Go" />',
+        }),
+      },
+      {
+        name: 'a user task after an event-based gateway in a non-executable process',
+        moddleElement: model(eventGateway([TIMER_CATCH, '<bpmn:userTask id="{id}" />']), {
+          processAttributes: 'isExecutable="false"',
+        }),
+      },
+      {
+        name: 'a user task after an event-based gateway in an ad-hoc sub-process',
+        moddleElement: model(
+          `<bpmn:adHocSubProcess id="AH">${eventGateway([TIMER_CATCH, '<bpmn:userTask id="{id}" />'])}</bpmn:adHocSubProcess>`,
+        ),
+      },
+      {
+        name: 'a Camunda 8 diagram',
+        moddleElement: engineModel('c8', eventGateway([TIMER_CATCH, '<bpmn:userTask id="{id}" />'])),
+      },
+    ],
+    invalid: [
+      {
+        name: 'two gateway branches wait for the same message name',
+        moddleElement: model(eventGateway([msgCatch('M1'), msgCatch('M1b')])),
+        report: {
+          id: 'G',
+          message:
+            'Branches T0 and T1 of event-based gateway G wait for the same message "M1"; the engines refuse the file',
+          type: ERROR_TYPES.ELEMENT_PROPERTY_VALUE_DUPLICATED,
+        },
+      },
+      {
+        name: 'two gateway branches wait for the same signal name',
+        moddleElement: model(eventGateway([signalCatch('S1'), signalCatch('S1b')])),
+        report: {
+          id: 'G',
+          message:
+            'Branches T0 and T1 of event-based gateway G wait for the same signal "Go"; the engines refuse the file',
+          type: ERROR_TYPES.ELEMENT_PROPERTY_VALUE_DUPLICATED,
+        },
+      },
+    ],
+  });
+});
diff --git a/test/adapters/out/bpmnlint/engine/rules/c7/C7EventGatewayTargetAllowedRule.test.ts b/test/adapters/out/bpmnlint/engine/rules/c7/C7EventGatewayTargetAllowedRule.test.ts
new file mode 100644
index 00000000..a8c1eda1
--- /dev/null
+++ b/test/adapters/out/bpmnlint/engine/rules/c7/C7EventGatewayTargetAllowedRule.test.ts
@@ -0,0 +1,125 @@
+import { ERROR_TYPES } from 'bpmnlint-plugin-camunda-compat/rules/utils/error-types.js';
+import { describe } from 'vitest';
+import rule from '../../../../../../../src/adapters/out/bpmnlint/engine/rules/c7/C7EventGatewayTargetAllowedRule.js';
+import { engineModel, verifyEngineRule } from '../../../../../../helpers/engine-model.js';
+
+describe('c7-event-gateway-target-allowed', () => {
+  const MESSAGES =
+    '<bpmn:message id="M1" name="M1" /><bpmn:message id="M1b" name="M1" /><bpmn:message id="M2" name="M2" /><bpmn:signal id="S1" name="Go" /><bpmn:signal id="S1b" name="Go" />';
+  const TIMER =
+    '<bpmn:timerEventDefinition><bpmn:timeDuration xsi:type="bpmn:tFormalExpression">PT1H</bpmn:timeDuration></bpmn:timerEventDefinition>';
+  const catchEvent = (definitions: string) =>
+    `<bpmn:intermediateCatchEvent id="{id}">${definitions}</bpmn:intermediateCatchEvent>`;
+  const TIMER_CATCH = catchEvent(TIMER);
+  const msgCatch = (ref: string) => catchEvent(`<bpmn:messageEventDefinition messageRef="${ref}" />`);
+  const signalCatch = (ref: string) =>
+    catchEvent(`<bpmn:signalEventDefinition signalRef="${ref}" />`);
+  const LINK = '<bpmn:linkEventDefinition name="L" />';
+  const COND =
+    '<bpmn:conditionalEventDefinition><bpmn:condition xsi:type="bpmn:tFormalExpression">${ready}</bpmn:condition></bpmn:conditionalEventDefinition>';
+  const eventGateway = (targets: string[], extra = '') => {
+    const branches = targets.map(
+      (target, index) => `<bpmn:sequenceFlow id="G${index}" sourceRef="G" targetRef="T${index}" />
+      ${target.replace('{id}', `T${index}`)}
+      <bpmn:sequenceFlow id="E${index}" sourceRef="T${index}" targetRef="End${index}" />
+      <bpmn:endEvent id="End${index}" />`,
+    );
+    return `<bpmn:startEvent id="Start" />
+      <bpmn:sequenceFlow id="F1" sourceRef="Start" targetRef="G" />
+      <bpmn:eventBasedGateway id="G" />
+      ${branches.join('\n')}${extra}`;
+  };
+  const model = (xml: string, options = {}) =>
+    engineModel('c7', xml, { roots: MESSAGES, ...options });
+  const notCatchEvent = (target: string) => ({
+    id: 'G',
+    message: `Event-based gateway G leads to ${target}; the engines accept only intermediate catch events (message, timer, signal, conditional) there and refuse the file`,
+    type: ERROR_TYPES.EVENT_BASED_GATEWAY_TARGET_NOT_ALLOWED,
+  });
+  const wrongTrigger = (target: string) => ({
+    id: 'G',
+    message: `Event-based gateway G leads to ${target}; after an event-based gateway the engines accept only message, timer, signal and conditional catch events and refuse the file`,
+    type: ERROR_TYPES.EVENT_BASED_GATEWAY_TARGET_NOT_ALLOWED,
+  });
+
+  verifyEngineRule(rule, {
+    valid: [
+      {
+        name: 'timer and message branches',
+        moddleElement: model(eventGateway([TIMER_CATCH, msgCatch('M1')])),
+      },
+      {
+        name: 'signal and conditional branches',
+        moddleElement: model(eventGateway([signalCatch('S1'), catchEvent(COND)])),
+      },
+      {
+        name: 'a message + timer catch event (the timer acts)',
+        moddleElement: model(
+          eventGateway([
+            TIMER_CATCH,
+            catchEvent(`<bpmn:messageEventDefinition messageRef="M1" />${TIMER}`),
+          ]),
+        ),
+      },
+      {
+        name: 'a link + timer catch event (the timer acts)',
+        moddleElement: model(eventGateway([msgCatch('M1'), catchEvent(LINK + TIMER)])),
+      },
+      {
+        name: 'two branches wait for different message names',
+        moddleElement: model(eventGateway([msgCatch('M1'), msgCatch('M2')])),
+      },
+      {
+        name: 'a message branch and a signal branch with the same name',
+        moddleElement: engineModel('c7', eventGateway([msgCatch('M1'), signalCatch('S1')]), {
+          roots: '<bpmn:message id="M1" name="Go" /><bpmn:signal id="S1" name="Go" />',
+        }),
+      },
+      {
+        name: 'a user task after an event-based gateway in a non-executable process',
+        moddleElement: model(eventGateway([TIMER_CATCH, '<bpmn:userTask id="{id}" />']), {
+          processAttributes: 'isExecutable="false"',
+        }),
+      },
+      {
+        name: 'a user task after an event-based gateway in an ad-hoc sub-process',
+        moddleElement: model(
+          `<bpmn:adHocSubProcess id="AH">${eventGateway([TIMER_CATCH, '<bpmn:userTask id="{id}" />'])}</bpmn:adHocSubProcess>`,
+        ),
+      },
+      {
+        name: 'a Camunda 8 diagram',
+        moddleElement: engineModel('c8', eventGateway([TIMER_CATCH, '<bpmn:userTask id="{id}" />'])),
+      },
+    ],
+    invalid: [
+      {
+        name: 'a receive task after an event-based gateway',
+        moddleElement: model(
+          eventGateway([TIMER_CATCH, '<bpmn:receiveTask id="{id}" messageRef="M1" />']),
+        ),
+        report: notCatchEvent('receiveTask T1'),
+      },
+      {
+        name: 'a user task after an event-based gateway',
+        moddleElement: model(eventGateway([TIMER_CATCH, '<bpmn:userTask id="{id}" />'])),
+        report: notCatchEvent('userTask T1'),
+      },
+      {
+        name: 'a link catch event after an event-based gateway',
+        moddleElement: model(eventGateway([TIMER_CATCH, catchEvent(LINK)])),
+        report: wrongTrigger('intermediateCatchEvent:link T1'),
+      },
+      {
+        name: 'a link + conditional catch event (the link acts)',
+        moddleElement: model(eventGateway([TIMER_CATCH, catchEvent(LINK + COND)])),
+        report: wrongTrigger('intermediateCatchEvent:link T1'),
+      },
+      {
+        name: 'a catch event without event definition',
+        moddleElement: model(eventGateway([TIMER_CATCH, catchEvent('')])),
+        report: wrongTrigger('intermediateCatchEvent T1'),
+      },
+    ],
+  });
+});
diff --git a/test/adapters/out/bpmnlint/engine/rules/c7/C7ExclusiveGatewayDefaultNoConditionRule.test.ts b/test/adapters/out/bpmnlint/engine/rules/c7/C7ExclusiveGatewayDefaultNoConditionRule.test.ts
new file mode 100644
index 00000000..62e68543
--- /dev/null
+++ b/test/adapters/out/bpmnlint/engine/rules/c7/C7ExclusiveGatewayDefaultNoConditionRule.test.ts
@@ -0,0 +1,84 @@
+import { ERROR_TYPES } from 'bpmnlint-plugin-camunda-compat/rules/utils/error-types.js';
+import { describe } from 'vitest';
+import rule from '../../../../../../../src/adapters/out/bpmnlint/engine/rules/c7/C7ExclusiveGatewayDefaultNoConditionRule.js';
+import { engineModel, verifyEngineRule } from '../../../../../../helpers/engine-model.js';
+
+describe('c7-exclusive-gateway-default-no-condition', () => {
+  const exclusive = (conditions: Array<string | null>, defaultFlow?: string) => {
+    const branches = conditions.map((condition, index) => {
+      const expression = condition
+        ? `<bpmn:conditionExpression xsi:type="bpmn:tFormalExpression">${condition}</bpmn:conditionExpression>`
+        : '';
+      return `<bpmn:sequenceFlow id="S${index}" sourceRef="G" targetRef="End${index}">${expression}</bpmn:sequenceFlow><bpmn:endEvent id="End${index}" />`;
+    });
+    return `<bpmn:startEvent id="Start" />
+      <bpmn:sequenceFlow id="F1" sourceRef="Start" targetRef="G" />
+      <bpmn:exclusiveGateway id="G"${defaultFlow ? ` default="${defaultFlow}"` : ''} />
+      ${branches.join('\n')}`;
+  };
+  const REFUSED = 'the engines refuse the file';
+  const conditionedDefault = (flowId: string) => ({
+    id: 'G',
+    message: `Default flow ${flowId} of exclusive gateway G has a condition; ${REFUSED}`,
+    type: ERROR_TYPES.PROPERTY_NOT_ALLOWED,
+  });
+
+  verifyEngineRule(rule, {
+    valid: [
+      {
+        name: 'conditions plus a default flow',
+        moddleElement: engineModel('c7', exclusive(['${a}', null], 'S1')),
+      },
+      {
+        name: 'one flow without condition and no default (c7-exclusive-gateway-needs-default reports it)',
+        moddleElement: engineModel('c7', exclusive(['${a}', null])),
+      },
+      {
+        name: 'a single outgoing flow without condition',
+        moddleElement: engineModel('c7', exclusive([null])),
+      },
+      {
+        name: 'a single default flow without condition',
+        moddleElement: engineModel('c7', exclusive([null], 'S0')),
+      },
+      {
+        name: 'two flows without condition in a non-executable process',
+        moddleElement: engineModel('c7', exclusive(['${a}', null, null]), {
+          processAttributes: 'isExecutable="false"',
+        }),
+      },
+      {
+        name: 'two flows without condition in an ad-hoc sub-process',
+        moddleElement: engineModel(
+          'c7',
+          `<bpmn:adHocSubProcess id="AH">${exclusive(['${a}', null, null])}</bpmn:adHocSubProcess>`,
+        ),
+      },
+      {
+        name: 'a Camunda 8 diagram',
+        moddleElement: engineModel('c8', exclusive(['${a}', null, null])),
+      },
+    ],
+    invalid: [
+      {
+        name: 'a single outgoing flow with a condition',
+        moddleElement: engineModel('c7', exclusive(['${a}'])),
+        report: {
+          id: 'G',
+          message: `Exclusive gateway G has a single outgoing flow S0 with a condition; ${REFUSED}`,
+          type: ERROR_TYPES.PROPERTY_NOT_ALLOWED,
+        },
+      },
+      {
+        name: 'a single default flow with a condition',
+        moddleElement: engineModel('c7', exclusive(['${a}'], 'S0')),
+        report: conditionedDefault('S0'),
+      },
+      {
+        name: 'a conditional default flow',
+        moddleElement: engineModel('c7', exclusive(['${a}', '${b}'], 'S1')),
+        report: conditionedDefault('S1'),
+      },
+    ],
+  });
+});
diff --git a/test/adapters/out/bpmnlint/engine/rules/c7/C7ExclusiveGatewayNeedsConditionsRule.test.ts b/test/adapters/out/bpmnlint/engine/rules/c7/C7ExclusiveGatewayNeedsConditionsRule.test.ts
new file mode 100644
index 00000000..da187935
--- /dev/null
+++ b/test/adapters/out/bpmnlint/engine/rules/c7/C7ExclusiveGatewayNeedsConditionsRule.test.ts
@@ -0,0 +1,75 @@
+import { ERROR_TYPES } from 'bpmnlint-plugin-camunda-compat/rules/utils/error-types.js';
+import { describe } from 'vitest';
+import rule from '../../../../../../../src/adapters/out/bpmnlint/engine/rules/c7/C7ExclusiveGatewayNeedsConditionsRule.js';
+import { engineModel, verifyEngineRule } from '../../../../../../helpers/engine-model.js';
+
+describe('c7-exclusive-gateway-needs-conditions', () => {
+  const exclusive = (conditions: Array<string | null>, defaultFlow?: string) => {
+    const branches = conditions.map((condition, index) => {
+      const expression = condition
+        ? `<bpmn:conditionExpression xsi:type="bpmn:tFormalExpression">${condition}</bpmn:conditionExpression>`
+        : '';
+      return `<bpmn:sequenceFlow id="S${index}" sourceRef="G" targetRef="End${index}">${expression}</bpmn:sequenceFlow><bpmn:endEvent id="End${index}" />`;
+    });
+    return `<bpmn:startEvent id="Start" />
+      <bpmn:sequenceFlow id="F1" sourceRef="Start" targetRef="G" />
+      <bpmn:exclusiveGateway id="G"${defaultFlow ? ` default="${defaultFlow}"` : ''} />
+      ${branches.join('\n')}`;
+  };
+  const REFUSED = 'the engines refuse the file';
+  const unconditioned = (flowId: string, count = '') => ({
+    id: 'G',
+    message: `Flow ${flowId} of exclusive gateway G has no condition and is not the default flow${count}; ${REFUSED}`,
+    type: ERROR_TYPES.PROPERTY_REQUIRED,
+  });
+
+  verifyEngineRule(rule, {
+    valid: [
+      {
+        name: 'conditions plus a default flow',
+        moddleElement: engineModel('c7', exclusive(['${a}', null], 'S1')),
+      },
+      {
+        name: 'one flow without condition and no default (c7-exclusive-gateway-needs-default reports it)',
+        moddleElement: engineModel('c7', exclusive(['${a}', null])),
+      },
+      {
+        name: 'a single outgoing flow without condition',
+        moddleElement: engineModel('c7', exclusive([null])),
+      },
+      {
+        name: 'a single default flow without condition',
+        moddleElement: engineModel('c7', exclusive([null], 'S0')),
+      },
+      {
+        name: 'two flows without condition in a non-executable process',
+        moddleElement: engineModel('c7', exclusive(['${a}', null, null]), {
+          processAttributes: 'isExecutable="false"',
+        }),
+      },
+      {
+        name: 'two flows without condition in an ad-hoc sub-process',
+        moddleElement: engineModel(
+          'c7',
+          `<bpmn:adHocSubProcess id="AH">${exclusive(['${a}', null, null])}</bpmn:adHocSubProcess>`,
+        ),
+      },
+      {
+        name: 'a Camunda 8 diagram',
+        moddleElement: engineModel('c8', exclusive(['${a}', null, null])),
+      },
+    ],
+    invalid: [
+      {
+        name: 'a flow without condition next to the default flow',
+        moddleElement: engineModel('c7', exclusive(['${a}', null, null], 'S2')),
+        report: unconditioned('S1'),
+      },
+      {
+        name: 'two flows without condition',
+        moddleElement: engineModel('c7', exclusive(['${a}', null, null])),
+        report: [unconditioned('S1', ' (2 such flows)'), unconditioned('S2', ' (2 such flows)')],
+      },
+    ],
+  });
+});
diff --git a/test/adapters/out/bpmnlint/engine/rules/c7/C7ExclusiveGatewayNeedsDefaultRule.test.ts b/test/adapters/out/bpmnlint/engine/rules/c7/C7ExclusiveGatewayNeedsDefaultRule.test.ts
new file mode 100644
index 00000000..6b4b0b05
--- /dev/null
+++ b/test/adapters/out/bpmnlint/engine/rules/c7/C7ExclusiveGatewayNeedsDefaultRule.test.ts
@@ -0,0 +1,67 @@
+import { ERROR_TYPES } from 'bpmnlint-plugin-camunda-compat/rules/utils/error-types.js';
+import { describe } from 'vitest';
+import rule from '../../../../../../../src/adapters/out/bpmnlint/engine/rules/c7/C7ExclusiveGatewayNeedsDefaultRule.js';
+import { engineModel, verifyEngineRule } from '../../../../../../helpers/engine-model.js';
+
+describe('c7-exclusive-gateway-needs-default', () => {
+  const exclusive = (conditions: Array<string | null>, defaultFlow?: string) => {
+    const branches = conditions.map((condition, index) => {
+      const expression = condition
+        ? `<bpmn:conditionExpression xsi:type="bpmn:tFormalExpression">${condition}</bpmn:conditionExpression>`
+        : '';
+      return `<bpmn:sequenceFlow id="S${index}" sourceRef="G" targetRef="End${index}">${expression}</bpmn:sequenceFlow><bpmn:endEvent id="End${index}" />`;
+    });
+    return `<bpmn:startEvent id="Start" />
+      <bpmn:sequenceFlow id="F1" sourceRef="Start" targetRef="G" />
+      <bpmn:exclusiveGateway id="G"${defaultFlow ? ` default="${defaultFlow}"` : ''} />
+      ${branches.join('\n')}`;
+  };
+
+  verifyEngineRule(rule, {
+    valid: [
+      {
+        name: 'conditions plus a default flow',
+        moddleElement: engineModel('c7', exclusive(['${a}', null], 'S1')),
+      },
+      {
+        name: 'every flow has a condition',
+        moddleElement: engineModel('c7', exclusive(['${a}', '${b}'])),
+      },
+      {
+        name: 'a single outgoing flow without condition',
+        moddleElement: engineModel('c7', exclusive([null])),
+      },
+      {
+        name: 'two flows without condition (c7-exclusive-gateway-needs-conditions reports it)',
+        moddleElement: engineModel('c7', exclusive(['${a}', null, null])),
+      },
+      {
+        name: 'one flow without condition and no default in a non-executable process',
+        moddleElement: engineModel('c7', exclusive(['${a}', null]), {
+          processAttributes: 'isExecutable="false"',
+        }),
+      },
+      {
+        name: 'one flow without condition and no default in an ad-hoc sub-process',
+        moddleElement: engineModel(
+          'c7',
+          `<bpmn:adHocSubProcess id="AH">${exclusive(['${a}', null])}</bpmn:adHocSubProcess>`,
+        ),
+      },
+      { name: 'a Camunda 8 diagram', moddleElement: engineModel('c8', exclusive(['${a}', null])) },
+    ],
+    invalid: [
+      {
+        name: 'one flow without condition and no default',
+        moddleElement: engineModel('c7', exclusive(['${a}', null])),
+        report: {
+          id: 'G',
+          message:
+            'Flow S1 of exclusive gateway G has no condition and is not the default flow; the engines take it as the default and log a warning',
+          path: ['default'],
+          type: ERROR_TYPES.PROPERTY_REQUIRED,
+        },
+      },
+    ],
+  });
+});
diff --git a/test/adapters/out/bpmnlint/engine/rules/c7/C7ExclusiveGatewayNeedsOutgoingRule.test.ts b/test/adapters/out/bpmnlint/engine/rules/c7/C7ExclusiveGatewayNeedsOutgoingRule.test.ts
new file mode 100644
index 00000000..544499b5
--- /dev/null
+++ b/test/adapters/out/bpmnlint/engine/rules/c7/C7ExclusiveGatewayNeedsOutgoingRule.test.ts
@@ -0,0 +1,73 @@
+import { ERROR_TYPES } from 'bpmnlint-plugin-camunda-compat/rules/utils/error-types.js';
+import { describe } from 'vitest';
+import rule from '../../../../../../../src/adapters/out/bpmnlint/engine/rules/c7/C7ExclusiveGatewayNeedsOutgoingRule.js';
+import { engineModel, verifyEngineRule } from '../../../../../../helpers/engine-model.js';
+
+describe('c7-exclusive-gateway-needs-outgoing', () => {
+  const exclusive = (conditions: Array<string | null>, defaultFlow?: string) => {
+    const branches = conditions.map((condition, index) => {
+      const expression = condition
+        ? `<bpmn:conditionExpression xsi:type="bpmn:tFormalExpression">${condition}</bpmn:conditionExpression>`
+        : '';
+      return `<bpmn:sequenceFlow id="S${index}" sourceRef="G" targetRef="End${index}">${expression}</bpmn:sequenceFlow><bpmn:endEvent id="End${index}" />`;
+    });
+    return `<bpmn:startEvent id="Start" />
+      <bpmn:sequenceFlow id="F1" sourceRef="Start" targetRef="G" />
+      <bpmn:exclusiveGateway id="G"${defaultFlow ? ` default="${defaultFlow}"` : ''} />
+      ${branches.join('\n')}`;
+  };
+  const REFUSED = 'the engines refuse the file';
+
+  verifyEngineRule(rule, {
+    valid: [
+      {
+        name: 'conditions plus a default flow',
+        moddleElement: engineModel('c7', exclusive(['${a}', null], 'S1')),
+      },
+      {
+        name: 'one flow without condition and no default (c7-exclusive-gateway-needs-default reports it)',
+        moddleElement: engineModel('c7', exclusive(['${a}', null])),
+      },
+      {
+        name: 'a single outgoing flow without condition',
+        moddleElement: engineModel('c7', exclusive([null])),
+      },
+      {
+        name: 'a single default flow without condition',
+        moddleElement: engineModel('c7', exclusive([null], 'S0')),
+      },
+      {
+        name: 'two flows without condition in a non-executable process',
+        moddleElement: engineModel('c7', exclusive(['${a}', null, null]), {
+          processAttributes: 'isExecutable="false"',
+        }),
+      },
+      {
+        name: 'two flows without condition in an ad-hoc sub-process',
+        moddleElement: engineModel(
+          'c7',
+          `<bpmn:adHocSubProcess id="AH">${exclusive(['${a}', null, null])}</bpmn:adHocSubProcess>`,
+        ),
+      },
+      {
+        name: 'a Camunda 8 diagram',
+        moddleElement: engineModel('c8', exclusive(['${a}', null, null])),
+      },
+    ],
+    invalid: [
+      {
+        name: 'no outgoing flow',
+        moddleElement: engineModel(
+          'c7',
+          '<bpmn:startEvent id="Start" /><bpmn:sequenceFlow id="F1" sourceRef="Start" targetRef="G" /><bpmn:exclusiveGateway id="G" />',
+        ),
+        report: {
+          id: 'G',
+          message: `Exclusive gateway G has no outgoing flow; ${REFUSED}`,
+          path: ['outgoing'],
+          type: ERROR_TYPES.PROPERTY_REQUIRED,
+        },
+      },
+    ],
+  });
+});
diff --git a/test/adapters/out/bpmnlint/engine/rules/c7/C7ExternalTaskNeedsTopicRule.test.ts b/test/adapters/out/bpmnlint/engine/rules/c7/C7ExternalTaskNeedsTopicRule.test.ts
new file mode 100644
index 00000000..52c22a6f
--- /dev/null
+++ b/test/adapters/out/bpmnlint/engine/rules/c7/C7ExternalTaskNeedsTopicRule.test.ts
@@ -0,0 +1,76 @@
+import { ERROR_TYPES } from 'bpmnlint-plugin-camunda-compat/rules/utils/error-types.js';
+import { describe } from 'vitest';
+import rule from '../../../../../../../src/adapters/out/bpmnlint/engine/rules/c7/C7ExternalTaskNeedsTopicRule.js';
+import { engineModel, verifyEngineRule } from '../../../../../../helpers/engine-model.js';
+
+describe('c7-external-task-needs-topic', () => {
+  verifyEngineRule(rule, {
+    valid: [
+      {
+        name: 'external tasks and message events with a topic',
+        moddleElement: engineModel(
+          'c7',
+          `<bpmn:serviceTask id="serviceTask_charge" camunda:type="external" camunda:topic="chargeCard" />
+          <bpmn:endEvent id="endEvent_done"><bpmn:messageEventDefinition camunda:type="External" camunda:topic="notify" /></bpmn:endEvent>`,
+        ),
+      },
+      {
+        name: 'an empty topic (c7-bad-value)',
+        moddleElement: engineModel(
+          'c7',
+          '<bpmn:serviceTask id="serviceTask_charge" camunda:type="external" camunda:topic="" />',
+        ),
+      },
+      {
+        name: 'a non-executable process',
+        moddleElement: engineModel(
+          'c7',
+          '<bpmn:serviceTask id="serviceTask_charge" camunda:type="external" />',
+          {
+            processAttributes: 'isExecutable="false"',
+          },
+        ),
+      },
+      {
+        name: 'a Camunda 8 diagram',
+        moddleElement: engineModel(
+          'c8',
+          '<bpmn:serviceTask id="serviceTask_charge" camunda:type="external" />',
+          {
+            definitionsAttributes: 'xmlns:camunda="http://camunda.org/schema/1.0/bpmn"',
+          },
+        ),
+      },
+    ],
+    invalid: [
+      {
+        name: 'an external task without topic',
+        moddleElement: engineModel(
+          'c7',
+          '<bpmn:serviceTask id="serviceTask_charge" camunda:type="external" />',
+        ),
+        report: {
+          id: 'serviceTask_charge',
+          message:
+            'serviceTask serviceTask_charge is an external task without camunda:topic; the engines refuse the file',
+          path: ['topic'],
+          type: ERROR_TYPES.PROPERTY_REQUIRED,
+        },
+      },
+      {
+        name: 'an external message end event without topic',
+        moddleElement: engineModel(
+          'c7',
+          '<bpmn:endEvent id="endEvent_done"><bpmn:messageEventDefinition camunda:type="external" /></bpmn:endEvent>',
+        ),
+        report: {
+          id: 'endEvent_done',
+          message:
+            'endEvent:message endEvent_done is an external task without camunda:topic; the engines refuse the file',
+          path: ['eventDefinitions', 0, 'topic'],
+          type: ERROR_TYPES.PROPERTY_REQUIRED,
+        },
+      },
+    ],
+  });
+});
diff --git a/test/adapters/out/bpmnlint/engine/rules/c7/C7FieldNeedsOneValueRule.test.ts b/test/adapters/out/bpmnlint/engine/rules/c7/C7FieldNeedsOneValueRule.test.ts
new file mode 100644
index 00000000..718cb8a7
--- /dev/null
+++ b/test/adapters/out/bpmnlint/engine/rules/c7/C7FieldNeedsOneValueRule.test.ts
@@ -0,0 +1,162 @@
+import { ERROR_TYPES } from 'bpmnlint-plugin-camunda-compat/rules/utils/error-types.js';
+import { describe } from 'vitest';
+import rule from '../../../../../../../src/adapters/out/bpmnlint/engine/rules/c7/C7FieldNeedsOneValueRule.js';
+import { engineModel, verifyEngineRule } from '../../../../../../helpers/engine-model.js';
+
+describe('c7-field-needs-one-value', () => {
+  const ext = (inner: string) => `<bpmn:extensionElements>${inner}</bpmn:extensionElements>`;
+  const ROOTS =
+    '<bpmn:signal id="signal_go" name="go" /><bpmn:message id="message_paid" name="paid" />';
+  const FIELD_NEEDS =
+    '(a field needs stringValue, expression, a camunda:string or a camunda:expression)';
+  const REQUIRED = ERROR_TYPES.PROPERTY_REQUIRED;
+  const callActivity = (inner: string) =>
+    `<bpmn:callActivity id="callActivity_ship" calledElement="ship">${ext(inner)}</bpmn:callActivity>`;
+  const serviceTask = (attributes: string, inner: string) =>
+    `<bpmn:serviceTask id="serviceTask_charge" ${attributes}>${ext(inner)}</bpmn:serviceTask>`;
+  const userTask = (inner: string) =>
+    `<bpmn:userTask id="userTask_review">${ext(inner)}</bpmn:userTask>`;
+  const report = (id: string, message: string, path: (string | number)[], type = REQUIRED) => ({
+    id,
+    message,
+    path,
+    type,
+  });
+
+  verifyEngineRule(rule, {
+    valid: [
+      {
+        name: 'complete bindings, mappings, connector and form',
+        moddleElement: engineModel(
+          'c7',
+          callActivity(
+            '<camunda:in source="a" target="a" /><camunda:in sourceExpression="${b}" target="b" /><camunda:in businessKey="${key}" /><camunda:out variables="all" />',
+          ) +
+            serviceTask(
+              'camunda:class="a.B"',
+              '<camunda:field name="a" stringValue="x" /><camunda:field name="b"><camunda:string /></camunda:field><camunda:field name="c" expression="${c}" /><camunda:inputOutput><camunda:inputParameter name="p">1</camunda:inputParameter></camunda:inputOutput>',
+            ) +
+            '<bpmn:sendTask id="sendTask_notify"><bpmn:extensionElements><camunda:connector><camunda:connectorId>mail</camunda:connectorId></camunda:connector></bpmn:extensionElements></bpmn:sendTask>' +
+            userTask(
+              '<camunda:formData><camunda:formField id="a" type="string" /><camunda:formField id="b" type="date" /></camunda:formData>',
+            ),
+        ),
+      },
+      {
+        name: 'fields the engines do not read: an expression or external implementation, an expression listener',
+        moddleElement: engineModel(
+          'c7',
+          serviceTask('camunda:expression="${true}"', '<camunda:field name="a" />') +
+            serviceTask(
+              'camunda:type="external" camunda:topic="charge"',
+              '<camunda:field name="a" />',
+            ).replace('serviceTask_charge', 'serviceTask_refund') +
+            userTask(
+              '<camunda:taskListener event="create" expression="${l}" delegateExpression="${d}"><camunda:field name="a" /></camunda:taskListener>',
+            ),
+        ),
+      },
+      {
+        name: 'an incomplete binding where the engines do not read it (c7-camunda-extension-placement)',
+        moddleElement: engineModel(
+          'c7',
+          serviceTask('camunda:expression="${true}"', '<camunda:in source="a" />'),
+        ),
+      },
+      {
+        name: 'incomplete content in a non-executable process',
+        moddleElement: engineModel('c7', callActivity('<camunda:in source="a" />'), {
+          processAttributes: 'isExecutable="false"',
+        }),
+      },
+      {
+        name: 'incomplete content inside an ad-hoc sub-process of an executable process',
+        moddleElement: engineModel(
+          'c7',
+          `<bpmn:adHocSubProcess id="adHocSubProcess_steps">${callActivity('<camunda:in source="a" />')}</bpmn:adHocSubProcess>`,
+        ),
+      },
+      {
+        name: 'fields of a message definition the event does not act on',
+        moddleElement: engineModel(
+          'c7',
+          `<bpmn:intermediateThrowEvent id="intermediateThrowEvent_notify"><bpmn:signalEventDefinition signalRef="signal_go" /><bpmn:messageEventDefinition messageRef="message_paid" camunda:class="a.B">${ext('<camunda:field name="a" />')}</bpmn:messageEventDefinition></bpmn:intermediateThrowEvent>`,
+          { roots: ROOTS },
+        ),
+      },
+      {
+        name: 'a Camunda 8 diagram',
+        moddleElement: engineModel('c8', '<bpmn:callActivity id="callActivity_ship" />'),
+      },
+    ],
+    invalid: [
+      {
+        name: 'a class implementation with a field without value',
+        moddleElement: engineModel(
+          'c7',
+          serviceTask('camunda:class="org.example.X"', '<camunda:field name="a" stringValue="" />'),
+        ),
+        report: report(
+          'serviceTask_charge',
+          `camunda:field "a" of serviceTask serviceTask_charge has no value; the engines refuse the file ${FIELD_NEEDS}`,
+          ['extensionElements', 'values', 0],
+        ),
+      },
+      {
+        name: 'a shell task with a field without value',
+        moddleElement: engineModel(
+          'c7',
+          serviceTask('camunda:type="shell"', '<camunda:field name="command" />'),
+        ),
+        report: report(
+          'serviceTask_charge',
+          `camunda:field "command" of serviceTask serviceTask_charge has no value; the engines refuse the file ${FIELD_NEEDS}`,
+          ['extensionElements', 'values', 0],
+        ),
+      },
+      {
+        name: 'a field with stringValue and a camunda:string element',
+        moddleElement: engineModel(
+          'c7',
+          serviceTask(
+            'camunda:class="org.example.X"',
+            '<camunda:field name="a" stringValue="x"><camunda:string>y</camunda:string></camunda:field>',
+          ),
+        ),
+        report: report(
+          'serviceTask_charge',
+          `camunda:field "a" of serviceTask serviceTask_charge has both the attribute stringValue and a camunda:string element; the engines refuse the file ${FIELD_NEEDS}`,
+          ['extensionElements', 'values', 0, 'string'],
+          ERROR_TYPES.PROPERTY_NOT_ALLOWED,
+        ),
+      },
+      {
+        name: 'a delegate expression task listener with a field without value',
+        moddleElement: engineModel(
+          'c7',
+          userTask(
+            '<camunda:taskListener event="create" delegateExpression="${l}"><camunda:field name="a" /></camunda:taskListener>',
+          ),
+        ),
+        report: report(
+          'userTask_review',
+          `camunda:field "a" of camunda:taskListener (event create) of userTask userTask_review has no value; the engines refuse the file ${FIELD_NEEDS}`,
+          ['extensionElements', 'values', 0, 'fields', 0],
+        ),
+      },
+      {
+        name: 'a message end event with a class and a field without value',
+        moddleElement: engineModel(
+          'c7',
+          `<bpmn:endEvent id="endEvent_notified"><bpmn:messageEventDefinition messageRef="message_paid" camunda:class="a.B">${ext('<camunda:field />')}</bpmn:messageEventDefinition></bpmn:endEvent>`,
+          { roots: ROOTS },
+        ),
+        report: report(
+          'endEvent_notified',
+          `camunda:field of endEvent:message endEvent_notified has no value; the engines refuse the file ${FIELD_NEEDS}`,
+          ['eventDefinitions', 0, 'extensionElements', 'values', 0],
+        ),
+      },
+    ],
+  });
+});
diff --git a/test/adapters/out/bpmnlint/engine/rules/c7/C7FormFieldNeedsIdAndTypeRule.test.ts b/test/adapters/out/bpmnlint/engine/rules/c7/C7FormFieldNeedsIdAndTypeRule.test.ts
new file mode 100644
index 00000000..1c1bc52b
--- /dev/null
+++ b/test/adapters/out/bpmnlint/engine/rules/c7/C7FormFieldNeedsIdAndTypeRule.test.ts
@@ -0,0 +1,120 @@
+import { ERROR_TYPES } from 'bpmnlint-plugin-camunda-compat/rules/utils/error-types.js';
+import { describe } from 'vitest';
+import rule from '../../../../../../../src/adapters/out/bpmnlint/engine/rules/c7/C7FormFieldNeedsIdAndTypeRule.js';
+import { engineModel, verifyEngineRule } from '../../../../../../helpers/engine-model.js';
+
+describe('c7-form-field-needs-id-and-type', () => {
+  const ext = (inner: string) => `<bpmn:extensionElements>${inner}</bpmn:extensionElements>`;
+  const ROOTS =
+    '<bpmn:signal id="signal_go" name="go" /><bpmn:message id="message_paid" name="paid" />';
+  const REQUIRED = ERROR_TYPES.PROPERTY_REQUIRED;
+  const callActivity = (inner: string) =>
+    `<bpmn:callActivity id="callActivity_ship" calledElement="ship">${ext(inner)}</bpmn:callActivity>`;
+  const serviceTask = (attributes: string, inner: string) =>
+    `<bpmn:serviceTask id="serviceTask_charge" ${attributes}>${ext(inner)}</bpmn:serviceTask>`;
+  const userTask = (inner: string) =>
+    `<bpmn:userTask id="userTask_review">${ext(inner)}</bpmn:userTask>`;
+  const report = (id: string, message: string, path: (string | number)[], type = REQUIRED) => ({
+    id,
+    message,
+    path,
+    type,
+  });
+
+  verifyEngineRule(rule, {
+    valid: [
+      {
+        name: 'complete bindings, mappings, connector and form',
+        moddleElement: engineModel(
+          'c7',
+          callActivity(
+            '<camunda:in source="a" target="a" /><camunda:in sourceExpression="${b}" target="b" /><camunda:in businessKey="${key}" /><camunda:out variables="all" />',
+          ) +
+            serviceTask(
+              'camunda:class="a.B"',
+              '<camunda:field name="a" stringValue="x" /><camunda:field name="b"><camunda:string /></camunda:field><camunda:field name="c" expression="${c}" /><camunda:inputOutput><camunda:inputParameter name="p">1</camunda:inputParameter></camunda:inputOutput>',
+            ) +
+            '<bpmn:sendTask id="sendTask_notify"><bpmn:extensionElements><camunda:connector><camunda:connectorId>mail</camunda:connectorId></camunda:connector></bpmn:extensionElements></bpmn:sendTask>' +
+            userTask(
+              '<camunda:formData><camunda:formField id="a" type="string" /><camunda:formField id="b" type="date" /></camunda:formData>',
+            ),
+        ),
+      },
+      {
+        name: 'fields the engines do not read: an expression or external implementation, an expression listener',
+        moddleElement: engineModel(
+          'c7',
+          serviceTask('camunda:expression="${true}"', '<camunda:field name="a" />') +
+            serviceTask(
+              'camunda:type="external" camunda:topic="charge"',
+              '<camunda:field name="a" />',
+            ).replace('serviceTask_charge', 'serviceTask_refund') +
+            userTask(
+              '<camunda:taskListener event="create" expression="${l}" delegateExpression="${d}"><camunda:field name="a" /></camunda:taskListener>',
+            ),
+        ),
+      },
+      {
+        name: 'an incomplete binding where the engines do not read it (c7-camunda-extension-placement)',
+        moddleElement: engineModel(
+          'c7',
+          serviceTask('camunda:expression="${true}"', '<camunda:in source="a" />'),
+        ),
+      },
+      {
+        name: 'incomplete content in a non-executable process',
+        moddleElement: engineModel('c7', callActivity('<camunda:in source="a" />'), {
+          processAttributes: 'isExecutable="false"',
+        }),
+      },
+      {
+        name: 'incomplete content inside an ad-hoc sub-process of an executable process',
+        moddleElement: engineModel(
+          'c7',
+          `<bpmn:adHocSubProcess id="adHocSubProcess_steps">${callActivity('<camunda:in source="a" />')}</bpmn:adHocSubProcess>`,
+        ),
+      },
+      {
+        name: 'fields of a message definition the event does not act on',
+        moddleElement: engineModel(
+          'c7',
+          `<bpmn:intermediateThrowEvent id="intermediateThrowEvent_notify"><bpmn:signalEventDefinition signalRef="signal_go" /><bpmn:messageEventDefinition messageRef="message_paid" camunda:class="a.B">${ext('<camunda:field name="a" />')}</bpmn:messageEventDefinition></bpmn:intermediateThrowEvent>`,
+          { roots: ROOTS },
+        ),
+      },
+      {
+        name: 'a Camunda 8 diagram',
+        moddleElement: engineModel('c8', '<bpmn:callActivity id="callActivity_ship" />'),
+      },
+    ],
+    invalid: [
+      {
+        name: 'a form field without type, and one with a type the engines do not know',
+        moddleElement: engineModel(
+          'c7',
+          userTask(
+            '<camunda:formData><camunda:formField id="a" /><camunda:formField id="b" type="String" /><camunda:formField id="c" type="date" /><camunda:formField type="long" /></camunda:formData>',
+          ),
+        ),
+        report: [
+          report(
+            'userTask_review',
+            'Form field a of userTask userTask_review has no type; the engines refuse the file',
+            ['extensionElements', 'values', 0, 'fields', 0, 'type'],
+          ),
+          report(
+            'userTask_review',
+            'Form field b of userTask userTask_review has type "String", which is not one of the built-in form types string, long, boolean, date, enum; the engines refuse the file (unless a plugin registers it as a custom form type)',
+            ['extensionElements', 'values', 0, 'fields', 1, 'type'],
+            ERROR_TYPES.PROPERTY_VALUE_NOT_ALLOWED,
+          ),
+          report(
+            'userTask_review',
+            'Form field 4 of userTask userTask_review has no id; the engines refuse the file',
+            ['extensionElements', 'values', 0, 'fields', 3, 'id'],
+          ),
+        ],
+      },
+    ],
+  });
+});
diff --git a/test/adapters/out/bpmnlint/engine/rules/c7/C7FormRefNeedsBindingRule.test.ts b/test/adapters/out/bpmnlint/engine/rules/c7/C7FormRefNeedsBindingRule.test.ts
new file mode 100644
index 00000000..1d40a7c3
--- /dev/null
+++ b/test/adapters/out/bpmnlint/engine/rules/c7/C7FormRefNeedsBindingRule.test.ts
@@ -0,0 +1,66 @@
+import { ERROR_TYPES } from 'bpmnlint-plugin-camunda-compat/rules/utils/error-types.js';
+import { describe } from 'vitest';
+import rule from '../../../../../../../src/adapters/out/bpmnlint/engine/rules/c7/C7FormRefNeedsBindingRule.js';
+import { engineModel, verifyEngineRule } from '../../../../../../helpers/engine-model.js';
+
+describe('c7-form-ref-needs-binding', () => {
+  verifyEngineRule(rule, {
+    valid: [
+      {
+        name: 'a form key, or a form reference with a binding',
+        moddleElement: engineModel(
+          'c7',
+          `<bpmn:userTask id="userTask_a" camunda:formKey="embedded:app:forms/a.html" />
+          <bpmn:userTask id="userTask_b" camunda:formRef="form" camunda:formRefBinding="latest" />
+          <bpmn:startEvent id="startEvent_c" camunda:formRef="form" camunda:formRefBinding="deployment" />`,
+        ),
+      },
+      {
+        name: 'a version binding without version (c7-binding-needs-version)',
+        moddleElement: engineModel(
+          'c7',
+          '<bpmn:userTask id="userTask_b" camunda:formRef="form" camunda:formRefBinding="version" />',
+        ),
+      },
+      {
+        name: 'a non-executable process',
+        moddleElement: engineModel('c7', '<bpmn:userTask id="userTask_b" camunda:formRef="form" />', {
+          processAttributes: 'isExecutable="false"',
+        }),
+      },
+      {
+        name: 'a Camunda 8 diagram',
+        moddleElement: engineModel('c8', '<bpmn:userTask id="userTask_b" camunda:formRef="form" />', {
+          definitionsAttributes: 'xmlns:camunda="http://camunda.org/schema/1.0/bpmn"',
+        }),
+      },
+    ],
+    invalid: [
+      {
+        name: 'a formRef without formRefBinding',
+        moddleElement: engineModel('c7', '<bpmn:userTask id="userTask_b" camunda:formRef="form" />'),
+        report: {
+          id: 'userTask_b',
+          message:
+            'userTask userTask_b has camunda:formRef but no camunda:formRefBinding (one of deployment, latest, version is required); the engines refuse the file',
+          path: ['formRefBinding'],
+          type: ERROR_TYPES.PROPERTY_REQUIRED,
+        },
+      },
+      {
+        name: 'a formRefBinding of versionTag on a start event',
+        moddleElement: engineModel(
+          'c7',
+          '<bpmn:startEvent id="startEvent_c" camunda:formRef="form" camunda:formRefBinding="versionTag" />',
+        ),
+        report: {
+          id: 'startEvent_c',
+          message:
+            'startEvent startEvent_c has camunda:formRef but camunda:formRefBinding="versionTag" (one of deployment, latest, version is required); the engines refuse the file',
+          path: ['formRefBinding'],
+          type: ERROR_TYPES.PROPERTY_VALUE_NOT_ALLOWED,
+        },
+      },
+    ],
+  });
+});
diff --git a/test/adapters/out/bpmnlint/engine/rules/c7/C7FormRefNoFormKeyRule.test.ts b/test/adapters/out/bpmnlint/engine/rules/c7/C7FormRefNoFormKeyRule.test.ts
new file mode 100644
index 00000000..d4fbf2f0
--- /dev/null
+++ b/test/adapters/out/bpmnlint/engine/rules/c7/C7FormRefNoFormKeyRule.test.ts
@@ -0,0 +1,55 @@
+import { ERROR_TYPES } from 'bpmnlint-plugin-camunda-compat/rules/utils/error-types.js';
+import { describe } from 'vitest';
+import rule from '../../../../../../../src/adapters/out/bpmnlint/engine/rules/c7/C7FormRefNoFormKeyRule.js';
+import { engineModel, verifyEngineRule } from '../../../../../../helpers/engine-model.js';
+
+describe('c7-form-ref-no-form-key', () => {
+  verifyEngineRule(rule, {
+    valid: [
+      {
+        name: 'a form key, or a form reference with a binding',
+        moddleElement: engineModel(
+          'c7',
+          `<bpmn:userTask id="userTask_a" camunda:formKey="embedded:app:forms/a.html" />
+          <bpmn:userTask id="userTask_b" camunda:formRef="form" camunda:formRefBinding="latest" />
+          <bpmn:startEvent id="startEvent_c" camunda:formRef="form" camunda:formRefBinding="deployment" />`,
+        ),
+      },
+      {
+        name: 'a version binding without version (c7-binding-needs-version)',
+        moddleElement: engineModel(
+          'c7',
+          '<bpmn:userTask id="userTask_b" camunda:formRef="form" camunda:formRefBinding="version" />',
+        ),
+      },
+      {
+        name: 'a non-executable process',
+        moddleElement: engineModel('c7', '<bpmn:userTask id="userTask_b" camunda:formRef="form" />', {
+          processAttributes: 'isExecutable="false"',
+        }),
+      },
+      {
+        name: 'a Camunda 8 diagram',
+        moddleElement: engineModel('c8', '<bpmn:userTask id="userTask_b" camunda:formRef="form" />', {
+          definitionsAttributes: 'xmlns:camunda="http://camunda.org/schema/1.0/bpmn"',
+        }),
+      },
+    ],
+    invalid: [
+      {
+        name: 'formKey and formRef together',
+        moddleElement: engineModel(
+          'c7',
+          '<bpmn:userTask id="userTask_b" camunda:formKey="key" camunda:formRef="form" camunda:formRefBinding="latest" />',
+        ),
+        report: {
+          id: 'userTask_b',
+          message:
+            'userTask userTask_b has both camunda:formKey and camunda:formRef; the engines refuse the file',
+          path: ['formKey'],
+          type: ERROR_TYPES.PROPERTY_NOT_ALLOWED,
+        },
+      },
+    ],
+  });
+});
diff --git a/test/adapters/out/bpmnlint/engine/rules/c7/C7HistoryTimeToLiveValidRule.test.ts b/test/adapters/out/bpmnlint/engine/rules/c7/C7HistoryTimeToLiveValidRule.test.ts
new file mode 100644
index 00000000..5bfd8d4f
--- /dev/null
+++ b/test/adapters/out/bpmnlint/engine/rules/c7/C7HistoryTimeToLiveValidRule.test.ts
@@ -0,0 +1,41 @@
+import { ERROR_TYPES } from 'bpmnlint-plugin-camunda-compat/rules/utils/error-types.js';
+import { describe } from 'vitest';
+import rule from '../../../../../../../src/adapters/out/bpmnlint/engine/rules/c7/C7HistoryTimeToLiveValidRule.js';
+import { engineModel, verifyEngineRule } from '../../../../../../helpers/engine-model.js';
+
+describe('c7-history-time-to-live-valid', () => {
+  const withTimeToLive = (value: string, executable = 'true') =>
+    engineModel('c7', '', {
+      processAttributes: `isExecutable="${executable}" camunda:historyTimeToLive="${value}"`,
+    });
+
+  verifyEngineRule(rule, {
+    valid: [
+      { name: 'a number of days', moddleElement: withTimeToLive('180') },
+      { name: 'zero days', moddleElement: withTimeToLive('0') },
+      { name: 'P<n>D', moddleElement: withTimeToLive('P30D') },
+      { name: 'no history time to live (camunda-compat)', moddleElement: engineModel('c7', '') },
+      { name: 'an empty history time to live (camunda-compat)', moddleElement: withTimeToLive('') },
+      { name: 'a non-executable process', moddleElement: withTimeToLive('PT5H', 'false') },
+      {
+        name: 'a Camunda 8 diagram',
+        moddleElement: engineModel('c8', '', {
+          processAttributes: 'isExecutable="true" camunda:historyTimeToLive="PT5H"',
+          definitionsAttributes: 'xmlns:camunda="http://camunda.org/schema/1.0/bpmn"',
+        }),
+      },
+    ],
+    invalid: [
+      ...['PT5H', 'abc', '2147483648', '-1'].map((value) => ({
+        name: `a history time to live of ${value}`,
+        moddleElement: withTimeToLive(value),
+        report: {
+          id: 'process_test',
+          message: `camunda:historyTimeToLive="${value}" of process process_test is not a number of days (or P<n>D); the engines refuse it`,
+          path: ['historyTimeToLive'],
+          type: ERROR_TYPES.PROPERTY_VALUE_NOT_ALLOWED,
+        },
+      })),
+    ],
+  });
+});
diff --git a/test/adapters/out/bpmnlint/engine/rules/c7/C7IoMappingHostAllowedRule.test.ts b/test/adapters/out/bpmnlint/engine/rules/c7/C7IoMappingHostAllowedRule.test.ts
new file mode 100644
index 00000000..f577be89
--- /dev/null
+++ b/test/adapters/out/bpmnlint/engine/rules/c7/C7IoMappingHostAllowedRule.test.ts
@@ -0,0 +1,110 @@
+import { ERROR_TYPES } from 'bpmnlint-plugin-camunda-compat/rules/utils/error-types.js';
+import { describe } from 'vitest';
+import rule from '../../../../../../../src/adapters/out/bpmnlint/engine/rules/c7/C7IoMappingHostAllowedRule.js';
+import { engineModel, verifyEngineRule } from '../../../../../../helpers/engine-model.js';
+
+describe('c7-io-mapping-host-allowed', () => {
+  const ext = (inner: string) => `<bpmn:extensionElements>${inner}</bpmn:extensionElements>`;
+  const MAPPING = ext(
+    '<camunda:inputOutput><camunda:inputParameter name="a">1</camunda:inputParameter></camunda:inputOutput>',
+  );
+  const OUTPUT_MAPPING = ext(
+    '<camunda:inputOutput><camunda:outputParameter name="o">1</camunda:outputParameter></camunda:inputOutput>',
+  );
+  const TIMER =
+    '<bpmn:timerEventDefinition><bpmn:timeDuration xsi:type="bpmn:tFormalExpression">PT1H</bpmn:timeDuration></bpmn:timerEventDefinition>';
+  const MULTI_INSTANCE =
+    '<bpmn:multiInstanceLoopCharacteristics camunda:collection="${items}" camunda:elementVariable="item" />';
+  const NOT_ALLOWED = ERROR_TYPES.EXTENSION_ELEMENT_NOT_ALLOWED;
+
+  verifyEngineRule(rule, {
+    valid: [
+      {
+        name: 'mappings on tasks and input mappings on an end event',
+        moddleElement: engineModel(
+          'c7',
+          `<bpmn:userTask id="userTask_review">${OUTPUT_MAPPING}</bpmn:userTask><bpmn:userTask id="userTask_check">${MAPPING}${MULTI_INSTANCE}</bpmn:userTask><bpmn:endEvent id="endEvent_done">${MAPPING}</bpmn:endEvent>`,
+        ),
+      },
+      {
+        name: 'a mapping on a start event in a non-executable process',
+        moddleElement: engineModel(
+          'c7',
+          `<bpmn:startEvent id="startEvent_go">${MAPPING}</bpmn:startEvent>`,
+          {
+            processAttributes: 'isExecutable="false"',
+          },
+        ),
+      },
+      {
+        name: 'a mapping on a gateway inside an ad-hoc sub-process of an executable process',
+        moddleElement: engineModel(
+          'c7',
+          `<bpmn:adHocSubProcess id="adHocSubProcess_steps"><bpmn:parallelGateway id="parallelGateway_split">${MAPPING}</bpmn:parallelGateway></bpmn:adHocSubProcess>`,
+        ),
+      },
+      {
+        name: 'a Camunda 8 diagram',
+        moddleElement: engineModel('c8', '<bpmn:startEvent id="startEvent_go" />'),
+      },
+    ],
+    invalid: [
+      {
+        name: 'a mapping on a start event',
+        moddleElement: engineModel(
+          'c7',
+          `<bpmn:startEvent id="startEvent_go">${MAPPING}</bpmn:startEvent>`,
+        ),
+        report: {
+          id: 'startEvent_go',
+          message:
+            'camunda:inputOutput on startEvent startEvent_go: the engines do not support input/output mappings on a startEvent and refuse the file',
+          path: ['extensionElements', 'values', 0],
+          type: NOT_ALLOWED,
+        },
+      },
+      {
+        name: 'a mapping on a boundary event',
+        moddleElement: engineModel(
+          'c7',
+          `<bpmn:userTask id="userTask_review" /><bpmn:boundaryEvent id="boundaryEvent_late" attachedToRef="userTask_review">${MAPPING}${TIMER}</bpmn:boundaryEvent>`,
+        ),
+        report: {
+          id: 'boundaryEvent_late',
+          message:
+            'camunda:inputOutput on boundaryEvent:timer boundaryEvent_late: the engines do not support input/output mappings on a boundaryEvent:timer and refuse the file',
+          path: ['extensionElements', 'values', 0],
+          type: NOT_ALLOWED,
+        },
+      },
+      {
+        name: 'a mapping on a gateway',
+        moddleElement: engineModel(
+          'c7',
+          `<bpmn:parallelGateway id="parallelGateway_split">${MAPPING}</bpmn:parallelGateway>`,
+        ),
+        report: {
+          id: 'parallelGateway_split',
+          message:
+            'camunda:inputOutput on parallelGateway parallelGateway_split: the engines do not support input/output mappings on a parallelGateway and refuse the file',
+          path: ['extensionElements', 'values', 0],
+          type: NOT_ALLOWED,
+        },
+      },
+      {
+        name: 'a mapping on an event sub-process',
+        moddleElement: engineModel(
+          'c7',
+          `<bpmn:subProcess id="subProcess_cancel" triggeredByEvent="true">${MAPPING}<bpmn:startEvent id="startEvent_cancel">${TIMER}</bpmn:startEvent></bpmn:subProcess>`,
+        ),
+        report: {
+          id: 'subProcess_cancel',
+          message:
+            'camunda:inputOutput on eventSubProcess subProcess_cancel: the engines do not support input/output mappings on an event sub-process and refuse the file',
+          path: ['extensionElements', 'values', 0],
+          type: NOT_ALLOWED,
+        },
+      },
+    ],
+  });
+});
diff --git a/test/adapters/out/bpmnlint/engine/rules/c7/C7IoParameterNeedsNameRule.test.ts b/test/adapters/out/bpmnlint/engine/rules/c7/C7IoParameterNeedsNameRule.test.ts
new file mode 100644
index 00000000..91a490a6
--- /dev/null
+++ b/test/adapters/out/bpmnlint/engine/rules/c7/C7IoParameterNeedsNameRule.test.ts
@@ -0,0 +1,123 @@
+import { ERROR_TYPES } from 'bpmnlint-plugin-camunda-compat/rules/utils/error-types.js';
+import { describe } from 'vitest';
+import rule from '../../../../../../../src/adapters/out/bpmnlint/engine/rules/c7/C7IoParameterNeedsNameRule.js';
+import { engineModel, verifyEngineRule } from '../../../../../../helpers/engine-model.js';
+
+describe('c7-io-parameter-needs-name', () => {
+  const ext = (inner: string) => `<bpmn:extensionElements>${inner}</bpmn:extensionElements>`;
+  const ROOTS =
+    '<bpmn:signal id="signal_go" name="go" /><bpmn:message id="message_paid" name="paid" />';
+  const REQUIRED = ERROR_TYPES.PROPERTY_REQUIRED;
+  const callActivity = (inner: string) =>
+    `<bpmn:callActivity id="callActivity_ship" calledElement="ship">${ext(inner)}</bpmn:callActivity>`;
+  const serviceTask = (attributes: string, inner: string) =>
+    `<bpmn:serviceTask id="serviceTask_charge" ${attributes}>${ext(inner)}</bpmn:serviceTask>`;
+  const userTask = (inner: string) =>
+    `<bpmn:userTask id="userTask_review">${ext(inner)}</bpmn:userTask>`;
+  const report = (id: string, message: string, path: (string | number)[], type = REQUIRED) => ({
+    id,
+    message,
+    path,
+    type,
+  });
+
+  verifyEngineRule(rule, {
+    valid: [
+      {
+        name: 'complete bindings, mappings, connector and form',
+        moddleElement: engineModel(
+          'c7',
+          callActivity(
+            '<camunda:in source="a" target="a" /><camunda:in sourceExpression="${b}" target="b" /><camunda:in businessKey="${key}" /><camunda:out variables="all" />',
+          ) +
+            serviceTask(
+              'camunda:class="a.B"',
+              '<camunda:field name="a" stringValue="x" /><camunda:field name="b"><camunda:string /></camunda:field><camunda:field name="c" expression="${c}" /><camunda:inputOutput><camunda:inputParameter name="p">1</camunda:inputParameter></camunda:inputOutput>',
+            ) +
+            '<bpmn:sendTask id="sendTask_notify"><bpmn:extensionElements><camunda:connector><camunda:connectorId>mail</camunda:connectorId></camunda:connector></bpmn:extensionElements></bpmn:sendTask>' +
+            userTask(
+              '<camunda:formData><camunda:formField id="a" type="string" /><camunda:formField id="b" type="date" /></camunda:formData>',
+            ),
+        ),
+      },
+      {
+        name: 'fields the engines do not read: an expression or external implementation, an expression listener',
+        moddleElement: engineModel(
+          'c7',
+          serviceTask('camunda:expression="${true}"', '<camunda:field name="a" />') +
+            serviceTask(
+              'camunda:type="external" camunda:topic="charge"',
+              '<camunda:field name="a" />',
+            ).replace('serviceTask_charge', 'serviceTask_refund') +
+            userTask(
+              '<camunda:taskListener event="create" expression="${l}" delegateExpression="${d}"><camunda:field name="a" /></camunda:taskListener>',
+            ),
+        ),
+      },
+      {
+        name: 'an incomplete binding where the engines do not read it (c7-camunda-extension-placement)',
+        moddleElement: engineModel(
+          'c7',
+          serviceTask('camunda:expression="${true}"', '<camunda:in source="a" />'),
+        ),
+      },
+      {
+        name: 'incomplete content in a non-executable process',
+        moddleElement: engineModel('c7', callActivity('<camunda:in source="a" />'), {
+          processAttributes: 'isExecutable="false"',
+        }),
+      },
+      {
+        name: 'incomplete content inside an ad-hoc sub-process of an executable process',
+        moddleElement: engineModel(
+          'c7',
+          `<bpmn:adHocSubProcess id="adHocSubProcess_steps">${callActivity('<camunda:in source="a" />')}</bpmn:adHocSubProcess>`,
+        ),
+      },
+      {
+        name: 'fields of a message definition the event does not act on',
+        moddleElement: engineModel(
+          'c7',
+          `<bpmn:intermediateThrowEvent id="intermediateThrowEvent_notify"><bpmn:signalEventDefinition signalRef="signal_go" /><bpmn:messageEventDefinition messageRef="message_paid" camunda:class="a.B">${ext('<camunda:field name="a" />')}</bpmn:messageEventDefinition></bpmn:intermediateThrowEvent>`,
+          { roots: ROOTS },
+        ),
+      },
+      {
+        name: 'a Camunda 8 diagram',
+        moddleElement: engineModel('c8', '<bpmn:callActivity id="callActivity_ship" />'),
+      },
+    ],
+    invalid: [
+      {
+        name: 'an input parameter without name',
+        moddleElement: engineModel(
+          'c7',
+          serviceTask(
+            'camunda:expression="${true}"',
+            '<camunda:inputOutput><camunda:inputParameter>1</camunda:inputParameter></camunda:inputOutput>',
+          ),
+        ),
+        report: report(
+          'serviceTask_charge',
+          'camunda:inputParameter 1 of serviceTask serviceTask_charge has no name; the engines refuse the file',
+          ['extensionElements', 'values', 0, 'inputParameters', 0, 'name'],
+        ),
+      },
+      {
+        name: 'a connector without connectorId, with a nameless parameter',
+        moddleElement: engineModel(
+          'c7',
+          serviceTask(
+            '',
+            '<camunda:connector><camunda:inputOutput><camunda:outputParameter>1</camunda:outputParameter></camunda:inputOutput></camunda:connector>',
+          ),
+        ),
+        report: report(
+            'serviceTask_charge',
+            'camunda:outputParameter 1 of serviceTask serviceTask_charge has no name; the engines refuse the file',
+            ['extensionElements', 'values', 0, 'inputOutput', 'outputParameters', 0, 'name'],
+          ),
+      },
+    ],
+  });
+});
diff --git a/test/adapters/out/bpmnlint/engine/rules/c7/C7JobPriorityValidRule.test.ts b/test/adapters/out/bpmnlint/engine/rules/c7/C7JobPriorityValidRule.test.ts
new file mode 100644
index 00000000..d7e832aa
--- /dev/null
+++ b/test/adapters/out/bpmnlint/engine/rules/c7/C7JobPriorityValidRule.test.ts
@@ -0,0 +1,138 @@
+import { ERROR_TYPES } from 'bpmnlint-plugin-camunda-compat/rules/utils/error-types.js';
+import { describe } from 'vitest';
+import rule from '../../../../../../../src/adapters/out/bpmnlint/engine/rules/c7/C7JobPriorityValidRule.js';
+import { engineModel, verifyEngineRule } from '../../../../../../helpers/engine-model.js';
+
+describe('c7-job-priority-valid', () => {
+  const NOT_A_NUMBER = (attribute: string, value: string, where: string) =>
+    `camunda:${attribute}="${value}" on ${where} is not a number or expression; the engines refuse it`;
+
+  verifyEngineRule(rule, {
+    valid: [
+      {
+        name: 'priorities as numbers and expressions, a known decision result mapper',
+        moddleElement: engineModel(
+          'c7',
+          `<bpmn:serviceTask id="serviceTask_a" camunda:type="external" camunda:topic="chargeCard" camunda:taskPriority="5" camunda:asyncBefore="true" camunda:jobPriority="\${priority}" />
+          <bpmn:businessRuleTask id="businessRuleTask_b" camunda:decisionRef="risk" camunda:mapDecisionResult="collectEntries" />
+          <bpmn:userTask id="userTask_c"><bpmn:multiInstanceLoopCharacteristics camunda:collection="\${items}" camunda:elementVariable="item" camunda:jobPriority="-3" /></bpmn:userTask>`,
+          {
+            processAttributes:
+              'isExecutable="true" camunda:jobPriority="10" camunda:taskPriority="#{priority}"',
+          },
+        ),
+      },
+      {
+        name: 'a mapDecisionResult without decisionRef is not read',
+        moddleElement: engineModel(
+          'c7',
+          '<bpmn:businessRuleTask id="businessRuleTask_b" camunda:class="org.example.Rule" camunda:mapDecisionResult="foo" />',
+        ),
+      },
+      {
+        name: 'a taskPriority where the engines do not read it',
+        moddleElement: engineModel(
+          'c7',
+          '<bpmn:serviceTask id="serviceTask_a" camunda:class="org.example.Bean" camunda:taskPriority="high" /><bpmn:userTask id="userTask_c" camunda:taskPriority="high" />',
+        ),
+      },
+      {
+        name: 'an ad-hoc sub-process and its content',
+        moddleElement: engineModel(
+          'c7',
+          '<bpmn:adHocSubProcess id="adHocSubProcess_x" camunda:jobPriority="high"><bpmn:userTask id="userTask_c" camunda:jobPriority="high" /></bpmn:adHocSubProcess>',
+        ),
+      },
+      {
+        name: 'a non-executable process',
+        moddleElement: engineModel(
+          'c7',
+          '<bpmn:userTask id="userTask_c" camunda:jobPriority="high" />',
+          {
+            processAttributes: 'isExecutable="false" camunda:jobPriority="high"',
+          },
+        ),
+      },
+      {
+        name: 'a Camunda 8 diagram',
+        moddleElement: engineModel(
+          'c8',
+          '<bpmn:userTask id="userTask_c" camunda:jobPriority="high" />',
+          {
+            definitionsAttributes: 'xmlns:camunda="http://camunda.org/schema/1.0/bpmn"',
+          },
+        ),
+      },
+    ],
+    invalid: [
+      {
+        name: 'a jobPriority that is not a number',
+        moddleElement: engineModel(
+          'c7',
+          '<bpmn:serviceTask id="serviceTask_a" camunda:class="org.example.Bean" camunda:asyncBefore="true" camunda:jobPriority="high" />',
+        ),
+        report: {
+          id: 'serviceTask_a',
+          message: NOT_A_NUMBER('jobPriority', 'high', 'serviceTask serviceTask_a'),
+          path: ['jobPriority'],
+          type: ERROR_TYPES.PROPERTY_VALUE_NOT_ALLOWED,
+        },
+      },
+      {
+        name: 'process priorities that are not numbers',
+        moddleElement: engineModel('c7', '', {
+          processAttributes:
+            'isExecutable="true" camunda:jobPriority="high" camunda:taskPriority="1.5"',
+        }),
+        report: [
+          {
+            id: 'process_test',
+            message: NOT_A_NUMBER('jobPriority', 'high', 'process process_test'),
+            path: ['jobPriority'],
+            type: ERROR_TYPES.PROPERTY_VALUE_NOT_ALLOWED,
+          },
+          {
+            id: 'process_test',
+            message: NOT_A_NUMBER('taskPriority', '1.5', 'process process_test'),
+            path: ['taskPriority'],
+            type: ERROR_TYPES.PROPERTY_VALUE_NOT_ALLOWED,
+          },
+        ],
+      },
+      {
+        name: 'a jobPriority on the multi-instance loop',
+        moddleElement: engineModel(
+          'c7',
+          '<bpmn:userTask id="userTask_c"><bpmn:multiInstanceLoopCharacteristics camunda:collection="${items}" camunda:jobPriority=" 5" /></bpmn:userTask>',
+        ),
+        report: {
+          id: 'userTask_c',
+          message: NOT_A_NUMBER(
+            'jobPriority',
+            ' 5',
+            'the multiInstanceLoopCharacteristics of userTask userTask_c',
+          ),
+          path: ['loopCharacteristics', 'jobPriority'],
+          type: ERROR_TYPES.PROPERTY_VALUE_NOT_ALLOWED,
+        },
+      },
+      {
+        name: 'a taskPriority of an external message end event',
+        moddleElement: engineModel(
+          'c7',
+          '<bpmn:endEvent id="endEvent_done"><bpmn:messageEventDefinition camunda:type="external" camunda:topic="notify" camunda:taskPriority="high" /></bpmn:endEvent>',
+        ),
+        report: {
+          id: 'endEvent_done',
+          message: NOT_A_NUMBER(
+            'taskPriority',
+            'high',
+            'the messageEventDefinition of endEvent:message endEvent_done',
+          ),
+          path: ['eventDefinitions', 0, 'taskPriority'],
+          type: ERROR_TYPES.PROPERTY_VALUE_NOT_ALLOWED,
+        },
+      },
+    ],
+  });
+});
diff --git a/test/adapters/out/bpmnlint/engine/rules/c7/C7LinkCatchNameUniqueRule.test.ts b/test/adapters/out/bpmnlint/engine/rules/c7/C7LinkCatchNameUniqueRule.test.ts
new file mode 100644
index 00000000..e3c080da
--- /dev/null
+++ b/test/adapters/out/bpmnlint/engine/rules/c7/C7LinkCatchNameUniqueRule.test.ts
@@ -0,0 +1,81 @@
+import { ERROR_TYPES } from 'bpmnlint-plugin-camunda-compat/rules/utils/error-types.js';
+import { describe } from 'vitest';
+import rule from '../../../../../../../src/adapters/out/bpmnlint/engine/rules/c7/C7LinkCatchNameUniqueRule.js';
+import { engineModel, verifyEngineRule } from '../../../../../../helpers/engine-model.js';
+
+describe('c7-link-catch-name-unique', () => {
+  const link = (name?: string) =>
+    `<bpmn:linkEventDefinition${name === undefined ? '' : ` name="${name}"`} />`;
+  const linkThrow = (id: string, name?: string) =>
+    `<bpmn:intermediateThrowEvent id="${id}">${link(name)}</bpmn:intermediateThrowEvent>`;
+  const linkCatch = (id: string, name?: string) =>
+    `<bpmn:intermediateCatchEvent id="${id}">${link(name)}</bpmn:intermediateCatchEvent>`;
+  const flow = (id: string, source: string, target: string) =>
+    `<bpmn:sequenceFlow id="${id}" sourceRef="${source}" targetRef="${target}" />`;
+  const START = '<bpmn:startEvent id="Start" />';
+  const reachedThrow = (id: string, name: string) =>
+    `${START}${flow(`F_${id}`, 'Start', id)}${linkThrow(id, name)}`;
+  const subProcess = (id: string, inner: string) =>
+    `<bpmn:subProcess id="${id}"><bpmn:startEvent id="${id}_S" />${inner}</bpmn:subProcess>`;
+  const target = (id: string, missing: string, scope = 'process_test') => ({
+    id,
+    message: `Link throw event ${id} jumps to "L1", but ${missing}; the engines resolve links within one (sub-)process (${scope}) and refuse the file`,
+    path: ['eventDefinitions', 0, 'name'],
+    type: ERROR_TYPES.PROPERTY_VALUE_NOT_ALLOWED,
+  });
+  const duplicateCatch = (first: string, id: string) => ({
+    id,
+    message: `Link catch events ${first} and ${id} are both named "L1"; the engines refuse two link catch events with one name in a process (sub-processes included)`,
+    path: ['eventDefinitions', 0, 'name'],
+    type: ERROR_TYPES.ELEMENT_PROPERTY_VALUE_DUPLICATED,
+  });
+
+  verifyEngineRule(rule, {
+    valid: [
+      {
+        name: 'a link pair, an unconnected throw event, a catch event without throw, an empty name',
+        moddleElement: engineModel(
+          'c7',
+          `${reachedThrow('L', 'L1')}${linkCatch('C1', 'L1')}${linkThrow('Lonely', 'Nowhere')}${linkCatch('C2', 'L2')}${linkCatch('C3', '')}`,
+        ),
+      },
+      {
+        name: 'duplicate catch names and an unmatched throw in a non-executable process',
+        moddleElement: engineModel(
+          'c7',
+          `${reachedThrow('L', 'Nowhere')}${linkCatch('C1', 'L1')}${linkCatch('C2', 'L1')}`,
+          { processAttributes: 'isExecutable="false"' },
+        ),
+      },
+      {
+        name: 'duplicate catch names and an unmatched throw in an ad-hoc sub-process',
+        moddleElement: engineModel(
+          'c7',
+          `${linkCatch('C1', 'L1')}<bpmn:adHocSubProcess id="AH">${reachedThrow('L', 'Nowhere')}${linkCatch('C2', 'L1')}</bpmn:adHocSubProcess>`,
+        ),
+      },
+      {
+        name: 'a Camunda 8 diagram',
+        moddleElement: engineModel('c8', `${reachedThrow('L', 'Nowhere')}${linkCatch('C1')}`),
+      },
+    ],
+    invalid: [
+      {
+        name: 'two link catch events with one name',
+        moddleElement: engineModel(
+          'c7',
+          `${reachedThrow('L', 'L1')}${linkCatch('C1', 'L1')}${linkCatch('C2', 'L1')}`,
+        ),
+        report: duplicateCatch('C1', 'C2'),
+      },
+      {
+        name: 'link catch events with one name in two sub-processes',
+        moddleElement: engineModel(
+          'c7',
+          `${START}${subProcess('Sub1', linkCatch('C1', 'L1'))}${subProcess('Sub2', linkCatch('C2', 'L1'))}`,
+        ),
+        report: duplicateCatch('C1', 'C2'),
+      },
+    ],
+  });
+});
diff --git a/test/adapters/out/bpmnlint/engine/rules/c7/C7LinkEventNeedsNameRule.test.ts b/test/adapters/out/bpmnlint/engine/rules/c7/C7LinkEventNeedsNameRule.test.ts
new file mode 100644
index 00000000..73261cf3
--- /dev/null
+++ b/test/adapters/out/bpmnlint/engine/rules/c7/C7LinkEventNeedsNameRule.test.ts
@@ -0,0 +1,85 @@
+import { ERROR_TYPES } from 'bpmnlint-plugin-camunda-compat/rules/utils/error-types.js';
+import { describe } from 'vitest';
+import rule from '../../../../../../../src/adapters/out/bpmnlint/engine/rules/c7/C7LinkEventNeedsNameRule.js';
+import { engineModel, verifyEngineRule } from '../../../../../../helpers/engine-model.js';
+
+describe('c7-link-event-needs-name', () => {
+  const TIMER =
+    '<bpmn:timerEventDefinition id="TDef"><bpmn:timeDuration xsi:type="bpmn:tFormalExpression">PT1H</bpmn:timeDuration></bpmn:timerEventDefinition>';
+  const link = (name?: string) =>
+    `<bpmn:linkEventDefinition${name === undefined ? '' : ` name="${name}"`} />`;
+  const linkThrow = (id: string, name?: string) =>
+    `<bpmn:intermediateThrowEvent id="${id}">${link(name)}</bpmn:intermediateThrowEvent>`;
+  const linkCatch = (id: string, name?: string) =>
+    `<bpmn:intermediateCatchEvent id="${id}">${link(name)}</bpmn:intermediateCatchEvent>`;
+  const flow = (id: string, source: string, target: string) =>
+    `<bpmn:sequenceFlow id="${id}" sourceRef="${source}" targetRef="${target}" />`;
+  const START = '<bpmn:startEvent id="Start" />';
+  const reachedThrow = (id: string, name: string) =>
+    `${START}${flow(`F_${id}`, 'Start', id)}${linkThrow(id, name)}`;
+  const target = (id: string, missing: string, scope = 'process_test') => ({
+    id,
+    message: `Link throw event ${id} jumps to "L1", but ${missing}; the engines resolve links within one (sub-)process (${scope}) and refuse the file`,
+    path: ['eventDefinitions', 0, 'name'],
+    type: ERROR_TYPES.PROPERTY_VALUE_NOT_ALLOWED,
+  });
+  const noName = (id: string, subject: string, index = 0) => ({
+    id,
+    message: `${subject} has no link name, which the BPMN schema requires; the engines refuse the file`,
+    path: ['eventDefinitions', index, 'name'],
+    type: ERROR_TYPES.PROPERTY_REQUIRED,
+  });
+
+  verifyEngineRule(rule, {
+    valid: [
+      {
+        name: 'a link pair, an unconnected throw event, a catch event without throw, an empty name',
+        moddleElement: engineModel(
+          'c7',
+          `${reachedThrow('L', 'L1')}${linkCatch('C1', 'L1')}${linkThrow('Lonely', 'Nowhere')}${linkCatch('C2', 'L2')}${linkCatch('C3', '')}`,
+        ),
+      },
+      {
+        name: 'duplicate catch names and an unmatched throw in a non-executable process',
+        moddleElement: engineModel(
+          'c7',
+          `${reachedThrow('L', 'Nowhere')}${linkCatch('C1', 'L1')}${linkCatch('C2', 'L1')}`,
+          { processAttributes: 'isExecutable="false"' },
+        ),
+      },
+      {
+        name: 'duplicate catch names and an unmatched throw in an ad-hoc sub-process',
+        moddleElement: engineModel(
+          'c7',
+          `${linkCatch('C1', 'L1')}<bpmn:adHocSubProcess id="AH">${reachedThrow('L', 'Nowhere')}${linkCatch('C2', 'L1')}</bpmn:adHocSubProcess>`,
+        ),
+      },
+      {
+        name: 'a Camunda 8 diagram',
+        moddleElement: engineModel('c8', `${reachedThrow('L', 'Nowhere')}${linkCatch('C1')}`),
+      },
+    ],
+    invalid: [
+      {
+        name: 'a link catch event without a name',
+        moddleElement: engineModel('c7', `${START}${linkCatch('C1')}`),
+        report: noName('C1', 'Link event C1'),
+      },
+      {
+        name: 'timer + link without name (intermediate catch)',
+        moddleElement: engineModel(
+          'c7',
+          `${START}<bpmn:intermediateCatchEvent id="W">${TIMER}<bpmn:linkEventDefinition id="LDef" /></bpmn:intermediateCatchEvent>`,
+        ),
+        report: noName('W', 'The link definition of intermediateCatchEvent:timer W', 1),
+      },
+      {
+        name: 'a link without name in a non-executable process',
+        moddleElement: engineModel('c7', `${START}${linkThrow('O_W')}`, {
+          processAttributes: 'isExecutable="false"',
+        }),
+        report: noName('O_W', 'Link event O_W'),
+      },
+    ],
+  });
+});
diff --git a/test/adapters/out/bpmnlint/engine/rules/c7/C7LinkThrowNeedsCatchRule.test.ts b/test/adapters/out/bpmnlint/engine/rules/c7/C7LinkThrowNeedsCatchRule.test.ts
new file mode 100644
index 00000000..614364e5
--- /dev/null
+++ b/test/adapters/out/bpmnlint/engine/rules/c7/C7LinkThrowNeedsCatchRule.test.ts
@@ -0,0 +1,80 @@
+import { ERROR_TYPES } from 'bpmnlint-plugin-camunda-compat/rules/utils/error-types.js';
+import { describe } from 'vitest';
+import rule from '../../../../../../../src/adapters/out/bpmnlint/engine/rules/c7/C7LinkThrowNeedsCatchRule.js';
+import { engineModel, verifyEngineRule } from '../../../../../../helpers/engine-model.js';
+
+describe('c7-link-throw-needs-catch', () => {
+  const link = (name?: string) =>
+    `<bpmn:linkEventDefinition${name === undefined ? '' : ` name="${name}"`} />`;
+  const linkThrow = (id: string, name?: string) =>
+    `<bpmn:intermediateThrowEvent id="${id}">${link(name)}</bpmn:intermediateThrowEvent>`;
+  const linkCatch = (id: string, name?: string) =>
+    `<bpmn:intermediateCatchEvent id="${id}">${link(name)}</bpmn:intermediateCatchEvent>`;
+  const flow = (id: string, source: string, target: string) =>
+    `<bpmn:sequenceFlow id="${id}" sourceRef="${source}" targetRef="${target}" />`;
+  const START = '<bpmn:startEvent id="Start" />';
+  const reachedThrow = (id: string, name: string) =>
+    `${START}${flow(`F_${id}`, 'Start', id)}${linkThrow(id, name)}`;
+  const subProcess = (id: string, inner: string) =>
+    `<bpmn:subProcess id="${id}"><bpmn:startEvent id="${id}_S" />${inner}</bpmn:subProcess>`;
+  const target = (id: string, missing: string, scope = 'process_test') => ({
+    id,
+    message: `Link throw event ${id} jumps to "L1", but ${missing}; the engines resolve links within one (sub-)process (${scope}) and refuse the file`,
+    path: ['eventDefinitions', 0, 'name'],
+    type: ERROR_TYPES.PROPERTY_VALUE_NOT_ALLOWED,
+  });
+
+  verifyEngineRule(rule, {
+    valid: [
+      {
+        name: 'a link pair, an unconnected throw event, a catch event without throw, an empty name',
+        moddleElement: engineModel(
+          'c7',
+          `${reachedThrow('L', 'L1')}${linkCatch('C1', 'L1')}${linkThrow('Lonely', 'Nowhere')}${linkCatch('C2', 'L2')}${linkCatch('C3', '')}`,
+        ),
+      },
+      {
+        name: 'duplicate catch names and an unmatched throw in a non-executable process',
+        moddleElement: engineModel(
+          'c7',
+          `${reachedThrow('L', 'Nowhere')}${linkCatch('C1', 'L1')}${linkCatch('C2', 'L1')}`,
+          { processAttributes: 'isExecutable="false"' },
+        ),
+      },
+      {
+        name: 'duplicate catch names and an unmatched throw in an ad-hoc sub-process',
+        moddleElement: engineModel(
+          'c7',
+          `${linkCatch('C1', 'L1')}<bpmn:adHocSubProcess id="AH">${reachedThrow('L', 'Nowhere')}${linkCatch('C2', 'L1')}</bpmn:adHocSubProcess>`,
+        ),
+      },
+      {
+        name: 'a Camunda 8 diagram',
+        moddleElement: engineModel('c8', `${reachedThrow('L', 'Nowhere')}${linkCatch('C1')}`),
+      },
+    ],
+    invalid: [
+      {
+        name: 'a link throw event without a catch event',
+        moddleElement: engineModel('c7', reachedThrow('L', 'L1')),
+        report: target('L', 'no link catch event has that name'),
+      },
+      {
+        name: 'a link throw event in the process, its catch event in a sub-process',
+        moddleElement: engineModel(
+          'c7',
+          `${reachedThrow('L', 'L1')}${subProcess('Sub', linkCatch('C1', 'L1'))}`,
+        ),
+        report: target('L', 'the catch event of that name (C1) is in another scope'),
+      },
+      {
+        name: 'a link throw event in a sub-process, its catch event in the process',
+        moddleElement: engineModel(
+          'c7',
+          `${START}${linkCatch('C1', 'L1')}${subProcess('Sub', `${flow('F_L', 'Sub_S', 'L')}${linkThrow('L', 'L1')}`)}`,
+        ),
+        report: target('L', 'the catch event of that name (C1) is in another scope', 'Sub'),
+      },
+    ],
+  });
+});
diff --git a/test/adapters/out/bpmnlint/engine/rules/c7/C7ListenerEventKnownRule.test.ts b/test/adapters/out/bpmnlint/engine/rules/c7/C7ListenerEventKnownRule.test.ts
new file mode 100644
index 00000000..b0a49500
--- /dev/null
+++ b/test/adapters/out/bpmnlint/engine/rules/c7/C7ListenerEventKnownRule.test.ts
@@ -0,0 +1,112 @@
+import { ERROR_TYPES } from 'bpmnlint-plugin-camunda-compat/rules/utils/error-types.js';
+import { describe } from 'vitest';
+import rule from '../../../../../../../src/adapters/out/bpmnlint/engine/rules/c7/C7ListenerEventKnownRule.js';
+import { engineModel, verifyEngineRule } from '../../../../../../helpers/engine-model.js';
+
+describe('c7-listener-event-known', () => {
+  const ext = (inner: string) => `<bpmn:extensionElements>${inner}</bpmn:extensionElements>`;
+  const TIMER =
+    '<bpmn:timerEventDefinition><bpmn:timeDuration xsi:type="bpmn:tFormalExpression">PT1H</bpmn:timeDuration></bpmn:timerEventDefinition>';
+  const userTask = (inner: string) =>
+    `<bpmn:userTask id="userTask_review">${ext(inner)}</bpmn:userTask>`;
+  const serviceTask = (inner: string) =>
+    `<bpmn:serviceTask id="serviceTask_charge" camunda:expression="\${true}">${ext(inner)}</bpmn:serviceTask>`;
+  const timeout = (attributes: string, inner = TIMER) =>
+    userTask(
+      `<camunda:taskListener event="timeout" expression="\${true}" ${attributes}>${inner}</camunda:taskListener>`,
+    );
+  const REQUIRED = ERROR_TYPES.PROPERTY_REQUIRED;
+
+  verifyEngineRule(rule, {
+    valid: [
+      {
+        name: 'listeners with an implementation and a known event',
+        moddleElement: engineModel(
+          'c7',
+          serviceTask(
+            '<camunda:executionListener event="start" class="a.B" /><camunda:executionListener event="end"><camunda:script scriptFormat="groovy">x</camunda:script></camunda:executionListener>',
+          ) + userTask('<camunda:taskListener event="assignment" delegateExpression="${l}" />'),
+        ),
+      },
+      {
+        name: 'a timeout task listener with timer and id',
+        moddleElement: engineModel('c7', timeout('id="taskListener_remind"')),
+      },
+      {
+        name: 'a timeout task listener with an empty id',
+        moddleElement: engineModel('c7', timeout('id=""')),
+      },
+      {
+        name: 'an execution listener on a sequence flow takes any event',
+        moddleElement: engineModel(
+          'c7',
+          `<bpmn:userTask id="userTask_review" /><bpmn:endEvent id="endEvent_done" /><bpmn:sequenceFlow id="flow_done" sourceRef="userTask_review" targetRef="endEvent_done">${ext('<camunda:executionListener class="a.B" />')}</bpmn:sequenceFlow>`,
+        ),
+      },
+      {
+        name: 'a task listener where the engines do not read it (c7-camunda-extension-placement)',
+        moddleElement: engineModel('c7', serviceTask('<camunda:taskListener event="nope" />')),
+      },
+      {
+        name: 'a listener in a non-executable process',
+        moddleElement: engineModel('c7', serviceTask('<camunda:executionListener event="start" />'), {
+          processAttributes: 'isExecutable="false"',
+        }),
+      },
+      {
+        name: 'a listener inside an ad-hoc sub-process of an executable process',
+        moddleElement: engineModel(
+          'c7',
+          `<bpmn:adHocSubProcess id="adHocSubProcess_steps">${serviceTask('<camunda:executionListener event="start" />')}</bpmn:adHocSubProcess>`,
+        ),
+      },
+      {
+        name: 'a Camunda 8 diagram',
+        moddleElement: engineModel('c8', '<bpmn:userTask id="userTask_review" />'),
+      },
+    ],
+    invalid: [
+      {
+        name: 'an execution listener with event take on a task',
+        moddleElement: engineModel(
+          'c7',
+          serviceTask('<camunda:executionListener event="take" class="a.B" />'),
+        ),
+        report: {
+          id: 'serviceTask_charge',
+          message:
+            'camunda:executionListener (event take) of serviceTask serviceTask_charge: event "take" is not one of start, end; the engines refuse the file',
+          path: ['extensionElements', 'values', 0, 'event'],
+          type: ERROR_TYPES.PROPERTY_VALUE_NOT_ALLOWED,
+        },
+      },
+      {
+        name: 'an execution listener with an unknown event next to a valid one',
+        moddleElement: engineModel(
+          'c7',
+          userTask(
+            '<camunda:executionListener event="end" expression="${a}" /><camunda:executionListener event="finish" expression="${b}" />',
+          ),
+        ),
+        report: {
+          id: 'userTask_review',
+          message:
+            'camunda:executionListener (event finish) of userTask userTask_review: event "finish" is not one of start, end; the engines refuse the file',
+          path: ['extensionElements', 'values', 1, 'event'],
+          type: ERROR_TYPES.PROPERTY_VALUE_NOT_ALLOWED,
+        },
+      },
+      {
+        name: 'a task listener without event',
+        moddleElement: engineModel('c7', userTask('<camunda:taskListener class="a.B" />')),
+        report: {
+          id: 'userTask_review',
+          message:
+            'camunda:taskListener of userTask userTask_review has no event; the engines refuse the file',
+          path: ['extensionElements', 'values', 0, 'event'],
+          type: REQUIRED,
+        },
+      },
+    ],
+  });
+});
diff --git a/test/adapters/out/bpmnlint/engine/rules/c7/C7ListenerNeedsImplementationRule.test.ts b/test/adapters/out/bpmnlint/engine/rules/c7/C7ListenerNeedsImplementationRule.test.ts
new file mode 100644
index 00000000..f157ee01
--- /dev/null
+++ b/test/adapters/out/bpmnlint/engine/rules/c7/C7ListenerNeedsImplementationRule.test.ts
@@ -0,0 +1,96 @@
+import { ERROR_TYPES } from 'bpmnlint-plugin-camunda-compat/rules/utils/error-types.js';
+import { describe } from 'vitest';
+import rule from '../../../../../../../src/adapters/out/bpmnlint/engine/rules/c7/C7ListenerNeedsImplementationRule.js';
+import { engineModel, verifyEngineRule } from '../../../../../../helpers/engine-model.js';
+
+describe('c7-listener-needs-implementation', () => {
+  const ext = (inner: string) => `<bpmn:extensionElements>${inner}</bpmn:extensionElements>`;
+  const TIMER =
+    '<bpmn:timerEventDefinition><bpmn:timeDuration xsi:type="bpmn:tFormalExpression">PT1H</bpmn:timeDuration></bpmn:timerEventDefinition>';
+  const userTask = (inner: string) =>
+    `<bpmn:userTask id="userTask_review">${ext(inner)}</bpmn:userTask>`;
+  const serviceTask = (inner: string) =>
+    `<bpmn:serviceTask id="serviceTask_charge" camunda:expression="\${true}">${ext(inner)}</bpmn:serviceTask>`;
+  const timeout = (attributes: string, inner = TIMER) =>
+    userTask(
+      `<camunda:taskListener event="timeout" expression="\${true}" ${attributes}>${inner}</camunda:taskListener>`,
+    );
+  const REQUIRED = ERROR_TYPES.PROPERTY_REQUIRED;
+
+  verifyEngineRule(rule, {
+    valid: [
+      {
+        name: 'listeners with an implementation and a known event',
+        moddleElement: engineModel(
+          'c7',
+          serviceTask(
+            '<camunda:executionListener event="start" class="a.B" /><camunda:executionListener event="end"><camunda:script scriptFormat="groovy">x</camunda:script></camunda:executionListener>',
+          ) + userTask('<camunda:taskListener event="assignment" delegateExpression="${l}" />'),
+        ),
+      },
+      {
+        name: 'a timeout task listener with timer and id',
+        moddleElement: engineModel('c7', timeout('id="taskListener_remind"')),
+      },
+      {
+        name: 'a timeout task listener with an empty id',
+        moddleElement: engineModel('c7', timeout('id=""')),
+      },
+      {
+        name: 'an execution listener on a sequence flow takes any event',
+        moddleElement: engineModel(
+          'c7',
+          `<bpmn:userTask id="userTask_review" /><bpmn:endEvent id="endEvent_done" /><bpmn:sequenceFlow id="flow_done" sourceRef="userTask_review" targetRef="endEvent_done">${ext('<camunda:executionListener class="a.B" />')}</bpmn:sequenceFlow>`,
+        ),
+      },
+      {
+        name: 'a task listener where the engines do not read it (c7-camunda-extension-placement)',
+        moddleElement: engineModel('c7', serviceTask('<camunda:taskListener event="nope" />')),
+      },
+      {
+        name: 'a listener in a non-executable process',
+        moddleElement: engineModel('c7', serviceTask('<camunda:executionListener event="start" />'), {
+          processAttributes: 'isExecutable="false"',
+        }),
+      },
+      {
+        name: 'a listener inside an ad-hoc sub-process of an executable process',
+        moddleElement: engineModel(
+          'c7',
+          `<bpmn:adHocSubProcess id="adHocSubProcess_steps">${serviceTask('<camunda:executionListener event="start" />')}</bpmn:adHocSubProcess>`,
+        ),
+      },
+      {
+        name: 'a Camunda 8 diagram',
+        moddleElement: engineModel('c8', '<bpmn:userTask id="userTask_review" />'),
+      },
+    ],
+    invalid: [
+      {
+        name: 'an execution listener without implementation',
+        moddleElement: engineModel('c7', serviceTask('<camunda:executionListener event="start" />')),
+        report: {
+          id: 'serviceTask_charge',
+          message:
+            'camunda:executionListener (event start) of serviceTask serviceTask_charge has no class, expression, delegateExpression or script; the engines refuse the file',
+          path: ['extensionElements', 'values', 0],
+          type: REQUIRED,
+        },
+      },
+      {
+        name: 'an execution listener on the process without implementation',
+        moddleElement: engineModel(
+          'c7',
+          `${ext('<camunda:executionListener event="end" />')}<bpmn:userTask id="userTask_review" />`,
+        ),
+        report: {
+          id: 'process_test',
+          message:
+            'camunda:executionListener (event end) of process process_test has no class, expression, delegateExpression or script; the engines refuse the file',
+          path: ['extensionElements', 'values', 0],
+          type: REQUIRED,
+        },
+      },
+    ],
+  });
+});
diff --git a/test/adapters/out/bpmnlint/engine/rules/c7/C7ListenerScriptNeedsFormatRule.test.ts b/test/adapters/out/bpmnlint/engine/rules/c7/C7ListenerScriptNeedsFormatRule.test.ts
new file mode 100644
index 00000000..51dca075
--- /dev/null
+++ b/test/adapters/out/bpmnlint/engine/rules/c7/C7ListenerScriptNeedsFormatRule.test.ts
@@ -0,0 +1,87 @@
+import { ERROR_TYPES } from 'bpmnlint-plugin-camunda-compat/rules/utils/error-types.js';
+import { describe } from 'vitest';
+import rule from '../../../../../../../src/adapters/out/bpmnlint/engine/rules/c7/C7ListenerScriptNeedsFormatRule.js';
+import { engineModel, verifyEngineRule } from '../../../../../../helpers/engine-model.js';
+
+describe('c7-listener-script-needs-format', () => {
+  const ext = (inner: string) => `<bpmn:extensionElements>${inner}</bpmn:extensionElements>`;
+  const TIMER =
+    '<bpmn:timerEventDefinition><bpmn:timeDuration xsi:type="bpmn:tFormalExpression">PT1H</bpmn:timeDuration></bpmn:timerEventDefinition>';
+  const userTask = (inner: string) =>
+    `<bpmn:userTask id="userTask_review">${ext(inner)}</bpmn:userTask>`;
+  const serviceTask = (inner: string) =>
+    `<bpmn:serviceTask id="serviceTask_charge" camunda:expression="\${true}">${ext(inner)}</bpmn:serviceTask>`;
+  const timeout = (attributes: string, inner = TIMER) =>
+    userTask(
+      `<camunda:taskListener event="timeout" expression="\${true}" ${attributes}>${inner}</camunda:taskListener>`,
+    );
+  const REQUIRED = ERROR_TYPES.PROPERTY_REQUIRED;
+
+  verifyEngineRule(rule, {
+    valid: [
+      {
+        name: 'listeners with an implementation and a known event',
+        moddleElement: engineModel(
+          'c7',
+          serviceTask(
+            '<camunda:executionListener event="start" class="a.B" /><camunda:executionListener event="end"><camunda:script scriptFormat="groovy">x</camunda:script></camunda:executionListener>',
+          ) + userTask('<camunda:taskListener event="assignment" delegateExpression="${l}" />'),
+        ),
+      },
+      {
+        name: 'a timeout task listener with timer and id',
+        moddleElement: engineModel('c7', timeout('id="taskListener_remind"')),
+      },
+      {
+        name: 'a timeout task listener with an empty id',
+        moddleElement: engineModel('c7', timeout('id=""')),
+      },
+      {
+        name: 'an execution listener on a sequence flow takes any event',
+        moddleElement: engineModel(
+          'c7',
+          `<bpmn:userTask id="userTask_review" /><bpmn:endEvent id="endEvent_done" /><bpmn:sequenceFlow id="flow_done" sourceRef="userTask_review" targetRef="endEvent_done">${ext('<camunda:executionListener class="a.B" />')}</bpmn:sequenceFlow>`,
+        ),
+      },
+      {
+        name: 'a task listener where the engines do not read it (c7-camunda-extension-placement)',
+        moddleElement: engineModel('c7', serviceTask('<camunda:taskListener event="nope" />')),
+      },
+      {
+        name: 'a listener in a non-executable process',
+        moddleElement: engineModel('c7', serviceTask('<camunda:executionListener event="start" />'), {
+          processAttributes: 'isExecutable="false"',
+        }),
+      },
+      {
+        name: 'a listener inside an ad-hoc sub-process of an executable process',
+        moddleElement: engineModel(
+          'c7',
+          `<bpmn:adHocSubProcess id="adHocSubProcess_steps">${serviceTask('<camunda:executionListener event="start" />')}</bpmn:adHocSubProcess>`,
+        ),
+      },
+      {
+        name: 'a Camunda 8 diagram',
+        moddleElement: engineModel('c8', '<bpmn:userTask id="userTask_review" />'),
+      },
+    ],
+    invalid: [
+      {
+        name: 'a script listener without scriptFormat',
+        moddleElement: engineModel(
+          'c7',
+          userTask(
+            '<camunda:executionListener event="start"><camunda:script>x</camunda:script></camunda:executionListener>',
+          ),
+        ),
+        report: {
+          id: 'userTask_review',
+          message:
+            'The script of camunda:executionListener (event start) of userTask userTask_review has no scriptFormat; the engines refuse the file',
+          path: ['extensionElements', 'values', 0, 'script', 'scriptFormat'],
+          type: REQUIRED,
+        },
+      },
+    ],
+  });
+});
diff --git a/test/adapters/out/bpmnlint/engine/rules/c7/C7MessageEventNeedsMessageRule.test.ts b/test/adapters/out/bpmnlint/engine/rules/c7/C7MessageEventNeedsMessageRule.test.ts
new file mode 100644
index 00000000..6f615c8f
--- /dev/null
+++ b/test/adapters/out/bpmnlint/engine/rules/c7/C7MessageEventNeedsMessageRule.test.ts
@@ -0,0 +1,97 @@
+import { ERROR_TYPES } from 'bpmnlint-plugin-camunda-compat/rules/utils/error-types.js';
+import { describe } from 'vitest';
+import rule from '../../../../../../../src/adapters/out/bpmnlint/engine/rules/c7/C7MessageEventNeedsMessageRule.js';
+import { engineModel, verifyEngineRule } from '../../../../../../helpers/engine-model.js';
+
+describe('c7-message-event-needs-message', () => {
+  const ROOTS =
+    '<bpmn:message id="M" name="Pay" /><bpmn:message id="M2" name="Pay2" /><bpmn:message id="M3" name="Pay" /><bpmn:message id="MN" />';
+  const TIMER =
+    '<bpmn:timerEventDefinition><bpmn:timeDuration xsi:type="bpmn:tFormalExpression">PT1H</bpmn:timeDuration></bpmn:timerEventDefinition>';
+  const message = (ref?: string) =>
+    `<bpmn:messageEventDefinition${ref ? ` messageRef="${ref}"` : ''} />`;
+  const START = '<bpmn:startEvent id="Start" />';
+  const catchEvent = (defs: string) =>
+    `${START}<bpmn:intermediateCatchEvent id="X">${defs}</bpmn:intermediateCatchEvent>`;
+  const boundary = (id: string, host: string, defs: string) =>
+    `<bpmn:boundaryEvent id="${id}" attachedToRef="${host}" cancelActivity="false">${defs}</bpmn:boundaryEvent>`;
+  const eventSub = (id: string, defs: string) =>
+    `<bpmn:subProcess id="${id}" triggeredByEvent="true"><bpmn:startEvent id="${id}_S" isInterrupting="false">${defs}</bpmn:startEvent></bpmn:subProcess>`;
+  const subProcess = (inner: string) =>
+    `<bpmn:subProcess id="Sub"><bpmn:startEvent id="Sub_S" />${inner}</bpmn:subProcess>`;
+
+  verifyEngineRule(rule, {
+    valid: [
+      {
+        name: 'a catch event with a named message',
+        moddleElement: engineModel('c7', catchEvent(message('M')), { roots: ROOTS }),
+      },
+      {
+        name: 'a receive task without message',
+        moddleElement: engineModel('c7', `${START}<bpmn:receiveTask id="X" />`),
+      },
+      {
+        name: 'a message throw event without message (an implementation question)',
+        moddleElement: engineModel(
+          'c7',
+          `${START}<bpmn:intermediateThrowEvent id="X"><bpmn:messageEventDefinition camunda:expression="\${true}" /></bpmn:intermediateThrowEvent>`,
+        ),
+      },
+      {
+        name: 'timer + a message without messageRef: the ignored message is not parsed',
+        moddleElement: engineModel('c7', catchEvent(TIMER + message())),
+      },
+      {
+        name: 'separate scopes: start and event sub-process, start and boundary, multi-instance receive task and its boundary',
+        moddleElement: engineModel(
+          'c7',
+          `<bpmn:startEvent id="Start">${message('M')}</bpmn:startEvent>
+          <bpmn:receiveTask id="T" messageRef="M"><bpmn:multiInstanceLoopCharacteristics><bpmn:loopCardinality>2</bpmn:loopCardinality></bpmn:multiInstanceLoopCharacteristics></bpmn:receiveTask>
+          ${boundary('B1', 'T', message('M'))}
+          <bpmn:userTask id="U" />${boundary('B2', 'U', message('M3'))}
+          ${eventSub('ES', message('M'))}`,
+          { roots: ROOTS },
+        ),
+      },
+      {
+        name: 'a catch event without message in a non-executable process',
+        moddleElement: engineModel('c7', catchEvent(message()), {
+          processAttributes: 'isExecutable="false"',
+        }),
+      },
+      {
+        name: 'a catch event without message in an ad-hoc sub-process',
+        moddleElement: engineModel(
+          'c7',
+          `<bpmn:adHocSubProcess id="AH">${catchEvent(message())}</bpmn:adHocSubProcess>`,
+        ),
+      },
+      {
+        name: 'a Camunda 8 diagram',
+        moddleElement: engineModel('c8', catchEvent(message('MN')), { roots: ROOTS }),
+      },
+    ],
+    invalid: [
+      {
+        name: 'message catch event without message',
+        moddleElement: engineModel('c7', catchEvent(message())),
+        report: {
+          id: 'X',
+          message: 'intermediateCatchEvent:message X has no message; the engines refuse the file',
+          path: ['eventDefinitions', 0, 'messageRef'],
+          type: ERROR_TYPES.PROPERTY_REQUIRED,
+        },
+      },
+      {
+        name: 'event sub-process start: a message without messageRef acts',
+        moddleElement: engineModel('c7', `${START}${eventSub('ES', TIMER + message())}`),
+        report: {
+          id: 'ES_S',
+          message: 'startEvent:timer ES_S has no message; the engines refuse the file',
+          path: ['eventDefinitions', 1, 'messageRef'],
+          type: ERROR_TYPES.PROPERTY_REQUIRED,
+        },
+      },
+    ],
+  });
+});
diff --git a/test/adapters/out/bpmnlint/engine/rules/c7/C7MessageNeedsNameRule.test.ts b/test/adapters/out/bpmnlint/engine/rules/c7/C7MessageNeedsNameRule.test.ts
new file mode 100644
index 00000000..1b7041c1
--- /dev/null
+++ b/test/adapters/out/bpmnlint/engine/rules/c7/C7MessageNeedsNameRule.test.ts
@@ -0,0 +1,99 @@
+import { ERROR_TYPES } from 'bpmnlint-plugin-camunda-compat/rules/utils/error-types.js';
+import { describe } from 'vitest';
+import rule from '../../../../../../../src/adapters/out/bpmnlint/engine/rules/c7/C7MessageNeedsNameRule.js';
+import { engineModel, verifyEngineRule } from '../../../../../../helpers/engine-model.js';
+
+describe('c7-message-needs-name', () => {
+  const ROOTS =
+    '<bpmn:message id="M" name="Pay" /><bpmn:message id="M2" name="Pay2" /><bpmn:message id="M3" name="Pay" /><bpmn:message id="MN" />';
+  const TIMER =
+    '<bpmn:timerEventDefinition><bpmn:timeDuration xsi:type="bpmn:tFormalExpression">PT1H</bpmn:timeDuration></bpmn:timerEventDefinition>';
+  const message = (ref?: string) =>
+    `<bpmn:messageEventDefinition${ref ? ` messageRef="${ref}"` : ''} />`;
+  const START = '<bpmn:startEvent id="Start" />';
+  const catchEvent = (defs: string) =>
+    `${START}<bpmn:intermediateCatchEvent id="X">${defs}</bpmn:intermediateCatchEvent>`;
+  const boundary = (id: string, host: string, defs: string) =>
+    `<bpmn:boundaryEvent id="${id}" attachedToRef="${host}" cancelActivity="false">${defs}</bpmn:boundaryEvent>`;
+  const eventSub = (id: string, defs: string) =>
+    `<bpmn:subProcess id="${id}" triggeredByEvent="true"><bpmn:startEvent id="${id}_S" isInterrupting="false">${defs}</bpmn:startEvent></bpmn:subProcess>`;
+  const subProcess = (inner: string) =>
+    `<bpmn:subProcess id="Sub"><bpmn:startEvent id="Sub_S" />${inner}</bpmn:subProcess>`;
+
+  verifyEngineRule(rule, {
+    valid: [
+      {
+        name: 'a catch event with a named message',
+        moddleElement: engineModel('c7', catchEvent(message('M')), { roots: ROOTS }),
+      },
+      {
+        name: 'a receive task without message',
+        moddleElement: engineModel('c7', `${START}<bpmn:receiveTask id="X" />`),
+      },
+      {
+        name: 'a message throw event without message (an implementation question)',
+        moddleElement: engineModel(
+          'c7',
+          `${START}<bpmn:intermediateThrowEvent id="X"><bpmn:messageEventDefinition camunda:expression="\${true}" /></bpmn:intermediateThrowEvent>`,
+        ),
+      },
+      {
+        name: 'timer + a message without messageRef: the ignored message is not parsed',
+        moddleElement: engineModel('c7', catchEvent(TIMER + message())),
+      },
+      {
+        name: 'separate scopes: start and event sub-process, start and boundary, multi-instance receive task and its boundary',
+        moddleElement: engineModel(
+          'c7',
+          `<bpmn:startEvent id="Start">${message('M')}</bpmn:startEvent>
+          <bpmn:receiveTask id="T" messageRef="M"><bpmn:multiInstanceLoopCharacteristics><bpmn:loopCardinality>2</bpmn:loopCardinality></bpmn:multiInstanceLoopCharacteristics></bpmn:receiveTask>
+          ${boundary('B1', 'T', message('M'))}
+          <bpmn:userTask id="U" />${boundary('B2', 'U', message('M3'))}
+          ${eventSub('ES', message('M'))}`,
+          { roots: ROOTS },
+        ),
+      },
+      {
+        name: 'a catch event without message in a non-executable process',
+        moddleElement: engineModel('c7', catchEvent(message()), {
+          processAttributes: 'isExecutable="false"',
+        }),
+      },
+      {
+        name: 'a catch event without message in an ad-hoc sub-process',
+        moddleElement: engineModel(
+          'c7',
+          `<bpmn:adHocSubProcess id="AH">${catchEvent(message())}</bpmn:adHocSubProcess>`,
+        ),
+      },
+      {
+        name: 'a Camunda 8 diagram',
+        moddleElement: engineModel('c8', catchEvent(message('MN')), { roots: ROOTS }),
+      },
+    ],
+    invalid: [
+      {
+        name: 'message without name',
+        moddleElement: engineModel('c7', catchEvent(message('MN')), { roots: ROOTS }),
+        report: {
+          id: 'X',
+          message: 'Message MN of intermediateCatchEvent:message X has no name; the engines refuse the file',
+          path: ['eventDefinitions', 0, 'messageRef', 'name'],
+          type: ERROR_TYPES.PROPERTY_REQUIRED,
+        },
+      },
+      {
+        name: 'receive task whose message has no name',
+        moddleElement: engineModel('c7', `${START}<bpmn:receiveTask id="X" messageRef="MN" />`, {
+          roots: ROOTS,
+        }),
+        report: {
+          id: 'X',
+          message: 'Message MN of receive task X has no name; the engines refuse the file',
+          path: ['messageRef', 'name'],
+          type: ERROR_TYPES.PROPERTY_REQUIRED,
+        },
+      },
+    ],
+  });
+});
diff --git a/test/adapters/out/bpmnlint/engine/rules/c7/C7MessageSubscriptionUniqueRule.test.ts b/test/adapters/out/bpmnlint/engine/rules/c7/C7MessageSubscriptionUniqueRule.test.ts
new file mode 100644
index 00000000..f33a7b1e
--- /dev/null
+++ b/test/adapters/out/bpmnlint/engine/rules/c7/C7MessageSubscriptionUniqueRule.test.ts
@@ -0,0 +1,110 @@
+import { ERROR_TYPES } from 'bpmnlint-plugin-camunda-compat/rules/utils/error-types.js';
+import { describe } from 'vitest';
+import rule from '../../../../../../../src/adapters/out/bpmnlint/engine/rules/c7/C7MessageSubscriptionUniqueRule.js';
+import { engineModel, verifyEngineRule } from '../../../../../../helpers/engine-model.js';
+
+describe('c7-message-subscription-unique', () => {
+  const ROOTS =
+    '<bpmn:message id="M" name="Pay" /><bpmn:message id="M2" name="Pay2" /><bpmn:message id="M3" name="Pay" /><bpmn:message id="MN" />';
+  const TIMER =
+    '<bpmn:timerEventDefinition><bpmn:timeDuration xsi:type="bpmn:tFormalExpression">PT1H</bpmn:timeDuration></bpmn:timerEventDefinition>';
+  const message = (ref?: string) =>
+    `<bpmn:messageEventDefinition${ref ? ` messageRef="${ref}"` : ''} />`;
+  const START = '<bpmn:startEvent id="Start" />';
+  const catchEvent = (defs: string) =>
+    `${START}<bpmn:intermediateCatchEvent id="X">${defs}</bpmn:intermediateCatchEvent>`;
+  const boundary = (id: string, host: string, defs: string) =>
+    `<bpmn:boundaryEvent id="${id}" attachedToRef="${host}" cancelActivity="false">${defs}</bpmn:boundaryEvent>`;
+  const eventSub = (id: string, defs: string) =>
+    `<bpmn:subProcess id="${id}" triggeredByEvent="true"><bpmn:startEvent id="${id}_S" isInterrupting="false">${defs}</bpmn:startEvent></bpmn:subProcess>`;
+  const subProcess = (inner: string) =>
+    `<bpmn:subProcess id="Sub"><bpmn:startEvent id="Sub_S" />${inner}</bpmn:subProcess>`;
+  const duplicate = (id: string, first: string, path: (string | number)[]) => ({
+    id,
+    message: `${id.startsWith('B') ? 'boundaryEvent' : 'startEvent'}:message ${id} waits for message "Pay" like ${first} in the same scope; the engines refuse two message subscriptions with one name`,
+    path,
+    type: ERROR_TYPES.ELEMENT_PROPERTY_VALUE_DUPLICATED,
+  });
+
+  verifyEngineRule(rule, {
+    valid: [
+      {
+        name: 'a catch event with a named message',
+        moddleElement: engineModel('c7', catchEvent(message('M')), { roots: ROOTS }),
+      },
+      {
+        name: 'a receive task without message',
+        moddleElement: engineModel('c7', `${START}<bpmn:receiveTask id="X" />`),
+      },
+      {
+        name: 'a message throw event without message (an implementation question)',
+        moddleElement: engineModel(
+          'c7',
+          `${START}<bpmn:intermediateThrowEvent id="X"><bpmn:messageEventDefinition camunda:expression="\${true}" /></bpmn:intermediateThrowEvent>`,
+        ),
+      },
+      {
+        name: 'timer + a message without messageRef: the ignored message is not parsed',
+        moddleElement: engineModel('c7', catchEvent(TIMER + message())),
+      },
+      {
+        name: 'separate scopes: start and event sub-process, start and boundary, multi-instance receive task and its boundary',
+        moddleElement: engineModel(
+          'c7',
+          `<bpmn:startEvent id="Start">${message('M')}</bpmn:startEvent>
+          <bpmn:receiveTask id="T" messageRef="M"><bpmn:multiInstanceLoopCharacteristics><bpmn:loopCardinality>2</bpmn:loopCardinality></bpmn:multiInstanceLoopCharacteristics></bpmn:receiveTask>
+          ${boundary('B1', 'T', message('M'))}
+          <bpmn:userTask id="U" />${boundary('B2', 'U', message('M3'))}
+          ${eventSub('ES', message('M'))}`,
+          { roots: ROOTS },
+        ),
+      },
+      {
+        name: 'a catch event without message in a non-executable process',
+        moddleElement: engineModel('c7', catchEvent(message()), {
+          processAttributes: 'isExecutable="false"',
+        }),
+      },
+      {
+        name: 'a catch event without message in an ad-hoc sub-process',
+        moddleElement: engineModel(
+          'c7',
+          `<bpmn:adHocSubProcess id="AH">${catchEvent(message())}</bpmn:adHocSubProcess>`,
+        ),
+      },
+      {
+        name: 'a Camunda 8 diagram',
+        moddleElement: engineModel('c8', catchEvent(message('MN')), { roots: ROOTS }),
+      },
+    ],
+    invalid: [
+      {
+        name: 'two message start events with one message name',
+        moddleElement: engineModel(
+          'c7',
+          `<bpmn:startEvent id="S1">${message('M')}</bpmn:startEvent><bpmn:startEvent id="S2">${message('M3')}</bpmn:startEvent>`,
+          { roots: ROOTS },
+        ),
+        report: duplicate('S2', 'S1', ['eventDefinitions', 0, 'messageRef']),
+      },
+      {
+        name: 'boundary event on a sub-process and an event sub-process in it, one message',
+        moddleElement: engineModel(
+          'c7',
+          `${START}${subProcess(eventSub('ES', message('M')))}${boundary('B1', 'Sub', message('M'))}`,
+          { roots: ROOTS },
+        ),
+        report: duplicate('B1', 'ES_S', ['eventDefinitions', 0, 'messageRef']),
+      },
+      {
+        name: 'receive task and a boundary event on it, one message name',
+        moddleElement: engineModel(
+          'c7',
+          `${START}<bpmn:receiveTask id="T" messageRef="M" />${boundary('B1', 'T', message('M3'))}`,
+          { roots: ROOTS },
+        ),
+        report: duplicate('B1', 'T', ['eventDefinitions', 0, 'messageRef']),
+      },
+    ],
+  });
+});
diff --git a/test/adapters/out/bpmnlint/engine/rules/c7/C7MessageThrowNeedsImplementationRule.test.ts b/test/adapters/out/bpmnlint/engine/rules/c7/C7MessageThrowNeedsImplementationRule.test.ts
new file mode 100644
index 00000000..bedfd9e9
--- /dev/null
+++ b/test/adapters/out/bpmnlint/engine/rules/c7/C7MessageThrowNeedsImplementationRule.test.ts
@@ -0,0 +1,95 @@
+import { ERROR_TYPES } from 'bpmnlint-plugin-camunda-compat/rules/utils/error-types.js';
+import { describe } from 'vitest';
+import rule from '../../../../../../../src/adapters/out/bpmnlint/engine/rules/c7/C7MessageThrowNeedsImplementationRule.js';
+import { engineModel, verifyEngineRule } from '../../../../../../helpers/engine-model.js';
+
+describe('c7-message-throw-needs-implementation', () => {
+  const throwEvent = (definition: string, attributes = '') =>
+    `<bpmn:intermediateThrowEvent id="event_notify" ${attributes}>${definition}</bpmn:intermediateThrowEvent>`;
+  const REPORT = (id: string, label: string, index = 0) => ({
+    id,
+    message: `${label} has no implementation: it sends nothing and behaves like a none event at run time`,
+    path: ['eventDefinitions', index, 'type'],
+    type: ERROR_TYPES.PROPERTY_REQUIRED,
+  });
+
+  verifyEngineRule(rule, {
+    valid: [
+      {
+        name: 'message throw events with an external topic, a delegate and a connector',
+        moddleElement: engineModel(
+          'c7',
+          `<bpmn:intermediateThrowEvent id="event_a"><bpmn:messageEventDefinition camunda:type="external" camunda:topic="notify" /></bpmn:intermediateThrowEvent>
+          <bpmn:endEvent id="event_b"><bpmn:messageEventDefinition camunda:delegateExpression="\${notify}" /></bpmn:endEvent>
+          <bpmn:endEvent id="event_c"><bpmn:extensionElements><camunda:connector><camunda:connectorId>mail-send</camunda:connectorId></camunda:connector></bpmn:extensionElements><bpmn:messageEventDefinition /></bpmn:endEvent>`,
+        ),
+      },
+      {
+        name: 'the implementation sits on the event (c7-camunda-attribute-placement)',
+        moddleElement: engineModel(
+          'c7',
+          throwEvent('<bpmn:messageEventDefinition />', 'camunda:delegateExpression="${notify}"'),
+        ),
+      },
+      {
+        name: 'an unsupported type (c7-task-type-supported)',
+        moddleElement: engineModel(
+          'c7',
+          throwEvent('<bpmn:messageEventDefinition camunda:type="foo" />'),
+        ),
+      },
+      {
+        name: 'a message catch event',
+        moddleElement: engineModel(
+          'c7',
+          '<bpmn:intermediateCatchEvent id="event_wait"><bpmn:messageEventDefinition messageRef="message_paid" /></bpmn:intermediateCatchEvent>',
+          { roots: '<bpmn:message id="message_paid" name="paid" />' },
+        ),
+      },
+      {
+        name: 'a throw event whose signal the engines act on instead of the message',
+        moddleElement: engineModel(
+          'c7',
+          throwEvent(
+            '<bpmn:messageEventDefinition /><bpmn:signalEventDefinition signalRef="signal_done" />',
+          ),
+          { roots: '<bpmn:signal id="signal_done" name="done" />' },
+        ),
+      },
+      {
+        name: 'a non-executable process',
+        moddleElement: engineModel('c7', throwEvent('<bpmn:messageEventDefinition />'), {
+          processAttributes: 'isExecutable="false"',
+        }),
+      },
+      {
+        name: 'a Camunda 8 diagram',
+        moddleElement: engineModel('c8', throwEvent('<bpmn:messageEventDefinition />')),
+      },
+    ],
+    invalid: [
+      {
+        name: 'a message throw event without implementation',
+        moddleElement: engineModel('c7', throwEvent('<bpmn:messageEventDefinition />')),
+        report: REPORT('event_notify', 'intermediateThrowEvent:message event_notify'),
+      },
+      {
+        name: 'a message end event without implementation',
+        moddleElement: engineModel(
+          'c7',
+          '<bpmn:endEvent id="event_done"><bpmn:messageEventDefinition id="messageEventDefinition_done" /></bpmn:endEvent>',
+        ),
+        report: REPORT('event_done', 'endEvent:message event_done'),
+      },
+      {
+        name: 'an end event whose message the engines act on before the signal',
+        moddleElement: engineModel(
+          'c7',
+          '<bpmn:endEvent id="event_done"><bpmn:signalEventDefinition signalRef="signal_done" /><bpmn:messageEventDefinition /></bpmn:endEvent>',
+          { roots: '<bpmn:signal id="signal_done" name="done" />' },
+        ),
+        report: REPORT('event_done', 'endEvent:signal event_done', 1),
+      },
+    ],
+  });
+});
diff --git a/test/adapters/out/bpmnlint/engine/rules/c7/C7MultiInstanceNeedsCardinalityOrCollectionRule.test.ts b/test/adapters/out/bpmnlint/engine/rules/c7/C7MultiInstanceNeedsCardinalityOrCollectionRule.test.ts
new file mode 100644
index 00000000..ed6477fb
--- /dev/null
+++ b/test/adapters/out/bpmnlint/engine/rules/c7/C7MultiInstanceNeedsCardinalityOrCollectionRule.test.ts
@@ -0,0 +1,99 @@
+import { ERROR_TYPES } from 'bpmnlint-plugin-camunda-compat/rules/utils/error-types.js';
+import { describe } from 'vitest';
+import rule from '../../../../../../../src/adapters/out/bpmnlint/engine/rules/c7/C7MultiInstanceNeedsCardinalityOrCollectionRule.js';
+import { engineModel, verifyEngineRule } from '../../../../../../helpers/engine-model.js';
+
+describe('c7-multi-instance-needs-cardinality-or-collection', () => {
+  const NO_INPUT = (id: string, misplaced = '') => ({
+    id,
+    message: `Multi-instance userTask ${id} has neither a loop cardinality nor camunda:collection${misplaced}; the engines refuse the file`,
+    path: ['loopCharacteristics', 'collection'],
+    type: ERROR_TYPES.PROPERTY_REQUIRED,
+  });
+
+  verifyEngineRule(rule, {
+    valid: [
+      {
+        name: 'a collection, a cardinality or a loopDataInputRef',
+        moddleElement: engineModel(
+          'c7',
+          `<bpmn:userTask id="userTask_a"><bpmn:multiInstanceLoopCharacteristics camunda:collection="\${items}" camunda:elementVariable="item" /></bpmn:userTask>
+          <bpmn:userTask id="userTask_b"><bpmn:multiInstanceLoopCharacteristics><bpmn:loopCardinality>3</bpmn:loopCardinality></bpmn:multiInstanceLoopCharacteristics></bpmn:userTask>
+          <bpmn:userTask id="userTask_c"><bpmn:ioSpecification><bpmn:dataInput id="dataInput_items" /><bpmn:inputSet><bpmn:dataInputRefs>dataInput_items</bpmn:dataInputRefs></bpmn:inputSet><bpmn:outputSet /></bpmn:ioSpecification><bpmn:multiInstanceLoopCharacteristics><bpmn:loopDataInputRef>dataInput_items</bpmn:loopDataInputRef></bpmn:multiInstanceLoopCharacteristics></bpmn:userTask>
+          <bpmn:userTask id="userTask_d"><bpmn:multiInstanceLoopCharacteristics camunda:collection="\${items}"><bpmn:loopCardinality /></bpmn:multiInstanceLoopCharacteristics></bpmn:userTask>
+          <bpmn:userTask id="userTask_e"><bpmn:standardLoopCharacteristics /></bpmn:userTask>`,
+        ),
+      },
+      {
+        name: 'a loop inside an ad-hoc sub-process',
+        moddleElement: engineModel(
+          'c7',
+          '<bpmn:adHocSubProcess id="adHocSubProcess_x"><bpmn:userTask id="userTask_a"><bpmn:multiInstanceLoopCharacteristics /></bpmn:userTask></bpmn:adHocSubProcess>',
+        ),
+      },
+      {
+        name: 'a non-executable process',
+        moddleElement: engineModel(
+          'c7',
+          '<bpmn:userTask id="userTask_a"><bpmn:multiInstanceLoopCharacteristics /></bpmn:userTask>',
+          {
+            processAttributes: 'isExecutable="false"',
+          },
+        ),
+      },
+      {
+        name: 'a Camunda 8 diagram',
+        moddleElement: engineModel(
+          'c8',
+          '<bpmn:userTask id="userTask_a"><bpmn:multiInstanceLoopCharacteristics /></bpmn:userTask>',
+        ),
+      },
+    ],
+    invalid: [
+      {
+        name: 'a multi-instance loop without cardinality or collection',
+        moddleElement: engineModel(
+          'c7',
+          '<bpmn:userTask id="userTask_a"><bpmn:multiInstanceLoopCharacteristics /></bpmn:userTask>',
+        ),
+        report: NO_INPUT('userTask_a'),
+      },
+      {
+        name: 'the collection on the task instead of the loop',
+        moddleElement: engineModel(
+          'c7',
+          '<bpmn:userTask id="userTask_a" camunda:collection="${items}" camunda:elementVariable="item"><bpmn:multiInstanceLoopCharacteristics /></bpmn:userTask>',
+        ),
+        report: NO_INPUT('userTask_a', ' (camunda:collection sits on the activity, not on the loop)'),
+      },
+      {
+        name: 'an empty loop cardinality',
+        moddleElement: engineModel(
+          'c7',
+          '<bpmn:userTask id="userTask_a"><bpmn:multiInstanceLoopCharacteristics><bpmn:loopCardinality xsi:type="bpmn:tFormalExpression"> </bpmn:loopCardinality></bpmn:multiInstanceLoopCharacteristics></bpmn:userTask>',
+        ),
+        report: {
+          id: 'userTask_a',
+          message:
+            'Multi-instance userTask userTask_a has an empty loop cardinality; the engines refuse the file',
+          path: ['loopCharacteristics', 'loopCardinality'],
+          type: ERROR_TYPES.EXPRESSION_REQUIRED,
+        },
+      },
+      {
+        name: 'an ad-hoc sub-process with a loop without cardinality',
+        moddleElement: engineModel(
+          'c7',
+          '<bpmn:adHocSubProcess id="adHocSubProcess_x"><bpmn:multiInstanceLoopCharacteristics /><bpmn:userTask id="userTask_a" /></bpmn:adHocSubProcess>',
+        ),
+        report: {
+          id: 'adHocSubProcess_x',
+          message:
+            'Multi-instance adHocSubProcess adHocSubProcess_x has neither a loop cardinality nor camunda:collection; the engines refuse the file',
+          path: ['loopCharacteristics', 'collection'],
+          type: ERROR_TYPES.PROPERTY_REQUIRED,
+        },
+      },
+    ],
+  });
+});
diff --git a/test/adapters/out/bpmnlint/engine/rules/c7/C7NoZeebeContentRule.test.ts b/test/adapters/out/bpmnlint/engine/rules/c7/C7NoZeebeContentRule.test.ts
new file mode 100644
index 00000000..e21b679c
--- /dev/null
+++ b/test/adapters/out/bpmnlint/engine/rules/c7/C7NoZeebeContentRule.test.ts
@@ -0,0 +1,121 @@
+import { ERROR_TYPES } from 'bpmnlint-plugin-camunda-compat/rules/utils/error-types.js';
+import { describe } from 'vitest';
+import rule from '../../../../../../../src/adapters/out/bpmnlint/engine/rules/c7/C7NoZeebeContentRule.js';
+import { engineModel, verifyEngineRule } from '../../../../../../helpers/engine-model.js';
+
+describe('c7-no-zeebe-content', () => {
+  const ZEEBE = 'xmlns:zeebe="http://camunda.org/schema/zeebe/1.0"';
+  const ext = (inner: string) => `<bpmn:extensionElements>${inner}</bpmn:extensionElements>`;
+  const task = (attributes: string, inner = '') =>
+    `<bpmn:serviceTask id="serviceTask_charge" camunda:expression="\${true}" ${attributes}>${inner}</bpmn:serviceTask>`;
+
+  verifyEngineRule(rule, {
+    valid: [
+      {
+        name: 'a zeebe attribute in a non-executable process (the engines skip it)',
+        moddleElement: engineModel('c7', task('zeebe:retries="3"'), {
+          definitionsAttributes: ZEEBE,
+          processAttributes: 'isExecutable="false"',
+        }),
+      },
+      {
+        name: 'camunda content only',
+        moddleElement: engineModel('c7', task('camunda:asyncBefore="true"')),
+      },
+      {
+        name: 'zeebe content inside an extension element the engines do not read there',
+        moddleElement: engineModel(
+          'c7',
+          task('', ext('<camunda:taskListener event="create" class="a.B" zeebe:retries="3" />')),
+          {
+            definitionsAttributes: ZEEBE,
+          },
+        ),
+      },
+      {
+        name: 'zeebe content inside an ad-hoc sub-process of an executable process',
+        moddleElement: engineModel(
+          'c7',
+          `<bpmn:adHocSubProcess id="adHocSubProcess_steps" zeebe:retries="3">${task('zeebe:retries="3"')}</bpmn:adHocSubProcess>`,
+          {
+            definitionsAttributes: ZEEBE,
+          },
+        ),
+      },
+      {
+        name: 'a Camunda 8 diagram',
+        moddleElement: engineModel(
+          'c8',
+          '<bpmn:serviceTask id="serviceTask_charge" zeebe:retries="3"><bpmn:extensionElements><zeebe:taskDefinition type="charge" /></bpmn:extensionElements></bpmn:serviceTask>',
+        ),
+      },
+    ],
+    invalid: [
+      {
+        name: 'a zeebe attribute and a zeebe extension element on a task',
+        moddleElement: engineModel(
+          'c7',
+          task('zeebe:retries="3"', ext('<zeebe:taskDefinition type="x" />')),
+          {
+            definitionsAttributes: ZEEBE,
+          },
+        ),
+        report: [
+          {
+            id: 'serviceTask_charge',
+            message:
+              'serviceTask serviceTask_charge carries the Camunda 8 attribute zeebe:retries, which Camunda 7 ignores',
+            path: ['zeebe:retries'],
+            type: ERROR_TYPES.PROPERTY_NOT_ALLOWED,
+          },
+          {
+            id: 'serviceTask_charge',
+            message:
+              'serviceTask serviceTask_charge contains the Camunda 8 extension zeebe:taskDefinition, which Camunda 7 ignores',
+            path: ['extensionElements', 'values', 0],
+            type: ERROR_TYPES.EXTENSION_ELEMENT_NOT_ALLOWED,
+          },
+        ],
+      },
+      {
+        name: 'zeebe attributes on camunda extension elements, nested ones included',
+        moddleElement: engineModel(
+          'c7',
+          `<bpmn:userTask id="userTask_review">${ext('<camunda:inputOutput zeebe:foo="1"><camunda:inputParameter name="a" zeebe:bar="2">1</camunda:inputParameter></camunda:inputOutput>')}</bpmn:userTask>`,
+          { definitionsAttributes: ZEEBE },
+        ),
+        report: [
+          {
+            id: 'userTask_review',
+            message:
+              'camunda:inputOutput of userTask userTask_review carries the Camunda 8 attribute zeebe:foo, which Camunda 7 ignores',
+            path: ['extensionElements', 'values', 0, 'zeebe:foo'],
+            type: ERROR_TYPES.PROPERTY_NOT_ALLOWED,
+          },
+          {
+            id: 'userTask_review',
+            message:
+              'camunda:inputParameter (in camunda:inputOutput) of userTask userTask_review carries the Camunda 8 attribute zeebe:bar, which Camunda 7 ignores',
+            path: ['extensionElements', 'values', 0, 'inputParameters', 0, 'zeebe:bar'],
+            type: ERROR_TYPES.PROPERTY_NOT_ALLOWED,
+          },
+        ],
+      },
+      {
+        name: 'a zeebe attribute on an event definition, reported on its event',
+        moddleElement: engineModel(
+          'c7',
+          '<bpmn:intermediateCatchEvent id="intermediateCatchEvent_wait"><bpmn:timerEventDefinition zeebe:foo="1"><bpmn:timeDuration xsi:type="bpmn:tFormalExpression">PT1H</bpmn:timeDuration></bpmn:timerEventDefinition></bpmn:intermediateCatchEvent>',
+          { definitionsAttributes: ZEEBE },
+        ),
+        report: {
+          id: 'intermediateCatchEvent_wait',
+          message:
+            'the timerEventDefinition of intermediateCatchEvent:timer intermediateCatchEvent_wait carries the Camunda 8 attribute zeebe:foo, which Camunda 7 ignores',
+          path: ['eventDefinitions', 0, 'zeebe:foo'],
+          type: ERROR_TYPES.PROPERTY_NOT_ALLOWED,
+        },
+      },
+    ],
+  });
+});
diff --git a/test/adapters/out/bpmnlint/engine/rules/c7/C7OutputMappingHostAllowedRule.test.ts b/test/adapters/out/bpmnlint/engine/rules/c7/C7OutputMappingHostAllowedRule.test.ts
new file mode 100644
index 00000000..0124b7a3
--- /dev/null
+++ b/test/adapters/out/bpmnlint/engine/rules/c7/C7OutputMappingHostAllowedRule.test.ts
@@ -0,0 +1,79 @@
+import { ERROR_TYPES } from 'bpmnlint-plugin-camunda-compat/rules/utils/error-types.js';
+import { describe } from 'vitest';
+import rule from '../../../../../../../src/adapters/out/bpmnlint/engine/rules/c7/C7OutputMappingHostAllowedRule.js';
+import { engineModel, verifyEngineRule } from '../../../../../../helpers/engine-model.js';
+
+describe('c7-output-mapping-host-allowed', () => {
+  const ext = (inner: string) => `<bpmn:extensionElements>${inner}</bpmn:extensionElements>`;
+  const MAPPING = ext(
+    '<camunda:inputOutput><camunda:inputParameter name="a">1</camunda:inputParameter></camunda:inputOutput>',
+  );
+  const OUTPUT_MAPPING = ext(
+    '<camunda:inputOutput><camunda:outputParameter name="o">1</camunda:outputParameter></camunda:inputOutput>',
+  );
+  const MULTI_INSTANCE =
+    '<bpmn:multiInstanceLoopCharacteristics camunda:collection="${items}" camunda:elementVariable="item" />';
+
+  verifyEngineRule(rule, {
+    valid: [
+      {
+        name: 'mappings on tasks and input mappings on an end event',
+        moddleElement: engineModel(
+          'c7',
+          `<bpmn:userTask id="userTask_review">${OUTPUT_MAPPING}</bpmn:userTask><bpmn:userTask id="userTask_check">${MAPPING}${MULTI_INSTANCE}</bpmn:userTask><bpmn:endEvent id="endEvent_done">${MAPPING}</bpmn:endEvent>`,
+        ),
+      },
+      {
+        name: 'a mapping on a start event in a non-executable process',
+        moddleElement: engineModel(
+          'c7',
+          `<bpmn:startEvent id="startEvent_go">${MAPPING}</bpmn:startEvent>`,
+          {
+            processAttributes: 'isExecutable="false"',
+          },
+        ),
+      },
+      {
+        name: 'a mapping on a gateway inside an ad-hoc sub-process of an executable process',
+        moddleElement: engineModel(
+          'c7',
+          `<bpmn:adHocSubProcess id="adHocSubProcess_steps"><bpmn:parallelGateway id="parallelGateway_split">${MAPPING}</bpmn:parallelGateway></bpmn:adHocSubProcess>`,
+        ),
+      },
+      {
+        name: 'a Camunda 8 diagram',
+        moddleElement: engineModel('c8', '<bpmn:startEvent id="startEvent_go" />'),
+      },
+    ],
+    invalid: [
+      {
+        name: 'an output parameter on an end event',
+        moddleElement: engineModel(
+          'c7',
+          `<bpmn:endEvent id="endEvent_done">${OUTPUT_MAPPING}</bpmn:endEvent>`,
+        ),
+        report: {
+          id: 'endEvent_done',
+          message:
+            'camunda:outputParameter on end event endEvent_done: the engines refuse output mappings on end events',
+          path: ['extensionElements', 'values', 0, 'outputParameters'],
+          type: ERROR_TYPES.PROPERTY_NOT_ALLOWED,
+        },
+      },
+      {
+        name: 'an output parameter on a multi-instance task',
+        moddleElement: engineModel(
+          'c7',
+          `<bpmn:userTask id="userTask_review">${OUTPUT_MAPPING}${MULTI_INSTANCE}</bpmn:userTask>`,
+        ),
+        report: {
+          id: 'userTask_review',
+          message:
+            'camunda:outputParameter on multi-instance userTask userTask_review: the engines refuse output mappings on multi-instance activities',
+          path: ['extensionElements', 'values', 0, 'outputParameters'],
+          type: ERROR_TYPES.PROPERTY_NOT_ALLOWED,
+        },
+      },
+    ],
+  });
+});
diff --git a/test/adapters/out/bpmnlint/engine/rules/c7/C7ResultVariableNeedsExpressionRule.test.ts b/test/adapters/out/bpmnlint/engine/rules/c7/C7ResultVariableNeedsExpressionRule.test.ts
new file mode 100644
index 00000000..587ebaaa
--- /dev/null
+++ b/test/adapters/out/bpmnlint/engine/rules/c7/C7ResultVariableNeedsExpressionRule.test.ts
@@ -0,0 +1,66 @@
+import { ERROR_TYPES } from 'bpmnlint-plugin-camunda-compat/rules/utils/error-types.js';
+import { describe } from 'vitest';
+import rule from '../../../../../../../src/adapters/out/bpmnlint/engine/rules/c7/C7ResultVariableNeedsExpressionRule.js';
+import { engineModel, verifyEngineRule } from '../../../../../../helpers/engine-model.js';
+
+describe('c7-result-variable-needs-expression', () => {
+  verifyEngineRule(rule, {
+    valid: [
+      {
+        name: 'a result variable with an expression, a decision or a script',
+        moddleElement: engineModel(
+          'c7',
+          `<bpmn:serviceTask id="serviceTask_a" camunda:expression="\${bean.run()}" camunda:resultVariable="result" />
+          <bpmn:businessRuleTask id="businessRuleTask_b" camunda:decisionRef="risk" camunda:resultVariable="result" camunda:mapDecisionResult="singleResult" />
+          <bpmn:scriptTask id="scriptTask_c" scriptFormat="groovy" camunda:resultVariable="result"><bpmn:script>1</bpmn:script></bpmn:scriptTask>`,
+        ),
+      },
+      {
+        name: 'a non-executable process',
+        moddleElement: engineModel(
+          'c7',
+          '<bpmn:serviceTask id="serviceTask_a" camunda:class="org.example.Bean" camunda:resultVariable="result" />',
+          { processAttributes: 'isExecutable="false"' },
+        ),
+      },
+      {
+        name: 'a Camunda 8 diagram',
+        moddleElement: engineModel(
+          'c8',
+          '<bpmn:serviceTask id="serviceTask_a" camunda:class="org.example.Bean" camunda:resultVariable="result" />',
+          { definitionsAttributes: 'xmlns:camunda="http://camunda.org/schema/1.0/bpmn"' },
+        ),
+      },
+    ],
+    invalid: [
+      {
+        name: 'a class with a result variable',
+        moddleElement: engineModel(
+          'c7',
+          '<bpmn:serviceTask id="serviceTask_a" camunda:class="org.example.Bean" camunda:resultVariable="result" />',
+        ),
+        report: {
+          id: 'serviceTask_a',
+          message:
+            'serviceTask serviceTask_a combines camunda:resultVariable with camunda:class; the engines support a result variable only with camunda:expression and refuse the file',
+          path: ['resultVariable'],
+          type: ERROR_TYPES.PROPERTY_NOT_ALLOWED,
+        },
+      },
+      {
+        name: 'a delegate expression with a result variable on a message end event',
+        moddleElement: engineModel(
+          'c7',
+          '<bpmn:endEvent id="endEvent_done"><bpmn:messageEventDefinition camunda:delegateExpression="${notify}" camunda:resultVariable="result" /></bpmn:endEvent>',
+        ),
+        report: {
+          id: 'endEvent_done',
+          message:
+            'endEvent:message endEvent_done combines camunda:resultVariable with camunda:delegateExpression; the engines support a result variable only with camunda:expression and refuse the file',
+          path: ['eventDefinitions', 0, 'resultVariable'],
+          type: ERROR_TYPES.PROPERTY_NOT_ALLOWED,
+        },
+      },
+    ],
+  });
+});
diff --git a/test/adapters/out/bpmnlint/engine/rules/c7/C7ScopeNeedsStartEventRule.test.ts b/test/adapters/out/bpmnlint/engine/rules/c7/C7ScopeNeedsStartEventRule.test.ts
new file mode 100644
index 00000000..b7499c09
--- /dev/null
+++ b/test/adapters/out/bpmnlint/engine/rules/c7/C7ScopeNeedsStartEventRule.test.ts
@@ -0,0 +1,111 @@
+import { ERROR_TYPES } from 'bpmnlint-plugin-camunda-compat/rules/utils/error-types.js';
+import { describe } from 'vitest';
+import rule from '../../../../../../../src/adapters/out/bpmnlint/engine/rules/c7/C7ScopeNeedsStartEventRule.js';
+import { engineModel, verifyEngineRule } from '../../../../../../helpers/engine-model.js';
+
+describe('c7-scope-needs-start-event', () => {
+  const ROOTS =
+    '<bpmn:signal id="Sig" name="Go" /><bpmn:message id="M" name="Pay" /><bpmn:message id="M2" name="Pay2" />';
+  const MESSAGE = '<bpmn:messageEventDefinition messageRef="M" />';
+  const flow = (id: string, source: string, target: string) =>
+    `<bpmn:sequenceFlow id="${id}" sourceRef="${source}" targetRef="${target}" />`;
+  const BODY = `<bpmn:userTask id="T" /><bpmn:endEvent id="End" />${flow('F1', 'T', 'End')}`;
+  const START = '<bpmn:startEvent id="Start" />';
+  const missing = (id: string, message: string) => ({
+    id,
+    message,
+    path: ['flowElements'],
+    type: ERROR_TYPES.CHILD_ELEMENT_OF_TYPE_REQUIRED,
+  });
+
+  verifyEngineRule(rule, {
+    valid: [
+      {
+        name: 'none, message and signal start events',
+        moddleElement: engineModel(
+          'c7',
+          `${START}<bpmn:startEvent id="S2">${MESSAGE}</bpmn:startEvent><bpmn:startEvent id="S3"><bpmn:signalEventDefinition signalRef="Sig" /></bpmn:startEvent>${BODY}`,
+          { roots: ROOTS },
+        ),
+      },
+      {
+        name: 'a transaction without start event (c7-transaction-needs-start-event)',
+        moddleElement: engineModel(
+          'c7',
+          `${START}<bpmn:transaction id="SP"><bpmn:userTask id="U" /></bpmn:transaction>`,
+        ),
+      },
+      {
+        name: 'an event sub-process without start event',
+        moddleElement: engineModel(
+          'c7',
+          `${START}<bpmn:subProcess id="ES" triggeredByEvent="true" />`,
+        ),
+      },
+      {
+        name: 'an ad-hoc sub-process: its content is skipped',
+        moddleElement: engineModel(
+          'c7',
+          `${START}<bpmn:adHocSubProcess id="SP"><bpmn:serviceTask id="X" /><bpmn:subProcess id="Z"><bpmn:userTask id="Z1" /></bpmn:subProcess><bpmn:startEvent id="A1" /><bpmn:startEvent id="A2" /></bpmn:adHocSubProcess>`,
+        ),
+      },
+      {
+        name: 'a non-executable process without start event',
+        moddleElement: engineModel('c7', BODY, { processAttributes: 'isExecutable="false"' }),
+      },
+      {
+        name: 'a Camunda 8 diagram',
+        moddleElement: engineModel('c8', `${START}<bpmn:startEvent id="S2" />${BODY}`),
+      },
+    ],
+    invalid: [
+      {
+        name: 'process with nodes but no start event',
+        moddleElement: engineModel('c7', BODY),
+        report: missing(
+          'process_test',
+          'Process process_test has no start event; the engines refuse the file (process must define a startEvent element)',
+        ),
+      },
+      {
+        name: 'process with only an event sub-process',
+        moddleElement: engineModel(
+          'c7',
+          `<bpmn:subProcess id="ES" triggeredByEvent="true"><bpmn:startEvent id="ES_S">${MESSAGE}</bpmn:startEvent></bpmn:subProcess>`,
+          { roots: ROOTS },
+        ),
+        report: missing(
+          'process_test',
+          'Process process_test has no start event; the engines refuse the file (process must define a startEvent element)',
+        ),
+      },
+      {
+        name: 'empty process',
+        moddleElement: engineModel('c7', ''),
+        report: missing(
+          'process_test',
+          'Process process_test is empty, without a start event; the engines refuse the file (process must define a startEvent element)',
+        ),
+      },
+      {
+        name: 'sub-process with a task but no start event',
+        moddleElement: engineModel(
+          'c7',
+          `${START}<bpmn:subProcess id="Sub"><bpmn:userTask id="ST" /></bpmn:subProcess>`,
+        ),
+        report: missing(
+          'Sub',
+          'Sub-process Sub has no start event; the engines refuse the file (subProcess must define a startEvent element)',
+        ),
+      },
+      {
+        name: 'empty sub-process',
+        moddleElement: engineModel('c7', `${START}<bpmn:subProcess id="SP" />`),
+        report: missing(
+          'SP',
+          'Sub-process SP is empty, without a start event; the engines refuse the file (subProcess must define a startEvent element)',
+        ),
+      },
+    ],
+  });
+});
diff --git a/test/adapters/out/bpmnlint/engine/rules/c7/C7ScriptTaskNeedsScriptRule.test.ts b/test/adapters/out/bpmnlint/engine/rules/c7/C7ScriptTaskNeedsScriptRule.test.ts
new file mode 100644
index 00000000..20a09772
--- /dev/null
+++ b/test/adapters/out/bpmnlint/engine/rules/c7/C7ScriptTaskNeedsScriptRule.test.ts
@@ -0,0 +1,62 @@
+import { ERROR_TYPES } from 'bpmnlint-plugin-camunda-compat/rules/utils/error-types.js';
+import { describe } from 'vitest';
+import rule from '../../../../../../../src/adapters/out/bpmnlint/engine/rules/c7/C7ScriptTaskNeedsScriptRule.js';
+import { engineModel, verifyEngineRule } from '../../../../../../helpers/engine-model.js';
+
+describe('c7-script-task-needs-script', () => {
+  const REPORT = {
+    id: 'scriptTask_a',
+    message:
+      'Script task scriptTask_a has neither a script nor camunda:resource; the engines refuse the file',
+    path: ['script'],
+    type: ERROR_TYPES.PROPERTY_REQUIRED,
+  };
+
+  verifyEngineRule(rule, {
+    valid: [
+      {
+        name: 'an inline script or a script resource',
+        moddleElement: engineModel(
+          'c7',
+          `<bpmn:scriptTask id="scriptTask_a" scriptFormat="groovy"><bpmn:script>println 1</bpmn:script></bpmn:scriptTask>
+          <bpmn:scriptTask id="scriptTask_b" scriptFormat="groovy" camunda:resource="deployment://b.groovy" />`,
+        ),
+      },
+      {
+        name: 'a non-executable process',
+        moddleElement: engineModel(
+          'c7',
+          '<bpmn:scriptTask id="scriptTask_a" scriptFormat="groovy" />',
+          {
+            processAttributes: 'isExecutable="false"',
+          },
+        ),
+      },
+      {
+        name: 'a Camunda 8 diagram',
+        moddleElement: engineModel(
+          'c8',
+          '<bpmn:scriptTask id="scriptTask_a" scriptFormat="groovy" />',
+        ),
+      },
+    ],
+    invalid: [
+      {
+        name: 'a script task without script',
+        moddleElement: engineModel(
+          'c7',
+          '<bpmn:scriptTask id="scriptTask_a" scriptFormat="groovy" />',
+        ),
+        report: REPORT,
+      },
+      {
+        name: 'a script task with a blank script',
+        moddleElement: engineModel(
+          'c7',
+          '<bpmn:scriptTask id="scriptTask_a" scriptFormat="groovy"><bpmn:script>  </bpmn:script></bpmn:scriptTask>',
+        ),
+        report: REPORT,
+      },
+    ],
+  });
+});
diff --git a/test/adapters/out/bpmnlint/engine/rules/c7/C7ShellFieldValuesFixedRule.test.ts b/test/adapters/out/bpmnlint/engine/rules/c7/C7ShellFieldValuesFixedRule.test.ts
new file mode 100644
index 00000000..7f3f1b32
--- /dev/null
+++ b/test/adapters/out/bpmnlint/engine/rules/c7/C7ShellFieldValuesFixedRule.test.ts
@@ -0,0 +1,129 @@
+import { ERROR_TYPES } from 'bpmnlint-plugin-camunda-compat/rules/utils/error-types.js';
+import { describe } from 'vitest';
+import rule from '../../../../../../../src/adapters/out/bpmnlint/engine/rules/c7/C7ShellFieldValuesFixedRule.js';
+import { engineModel, verifyEngineRule } from '../../../../../../helpers/engine-model.js';
+
+describe('c7-shell-field-values-fixed', () => {
+  const ext = (content: string) => `<bpmn:extensionElements>${content}</bpmn:extensionElements>`;
+  const COMMAND =
+    '<camunda:field name="command"><camunda:string>echo</camunda:string></camunda:field>';
+  const shell = (fields: string, tag = 'serviceTask', type = 'shell') =>
+    `<bpmn:${tag} id="serviceTask_runScript" camunda:type="${type}">${ext(fields)}</bpmn:${tag}>`;
+
+  verifyEngineRule(rule, {
+    valid: [
+      {
+        name: 'tasks implemented by a delegate, an expression, an external topic, a connector or a decision',
+        moddleElement: engineModel(
+          'c7',
+          `<bpmn:serviceTask id="serviceTask_a" camunda:class="org.example.Charge" />
+          <bpmn:serviceTask id="serviceTask_b" camunda:delegateExpression="\${charge}" />
+          <bpmn:serviceTask id="serviceTask_c" camunda:expression="\${charge.run()}" />
+          <bpmn:serviceTask id="serviceTask_d" camunda:type="external" camunda:topic="chargeCard" />
+          <bpmn:serviceTask id="serviceTask_e">${ext('<camunda:connector><camunda:connectorId>http-connector</camunda:connectorId></camunda:connector>')}</bpmn:serviceTask>
+          <bpmn:businessRuleTask id="businessRuleTask_f" camunda:decisionRef="risk" camunda:mapDecisionResult="singleEntry" />
+          <bpmn:sendTask id="sendTask_g" camunda:type="External" camunda:topic="notify" />`,
+        ),
+      },
+      { name: 'a shell task with a command field', moddleElement: engineModel('c7', shell(COMMAND)) },
+      {
+        name: 'SHELL on a send task with a stringValue command and wait=TRUE',
+        moddleElement: engineModel(
+          'c7',
+          shell(
+            '<camunda:field name="command" stringValue="echo" /><camunda:field name="wait" stringValue="TRUE" />',
+            'sendTask',
+            'SHELL',
+          ),
+        ),
+      },
+      {
+        name: 'a shell message end event',
+        moddleElement: engineModel(
+          'c7',
+          `<bpmn:endEvent id="endEvent_done"><bpmn:messageEventDefinition camunda:type="shell">${ext(COMMAND)}</bpmn:messageEventDefinition></bpmn:endEvent>`,
+        ),
+      },
+      {
+        name: 'a shell field without a value (left to c7-field-needs-one-value)',
+        moddleElement: engineModel('c7', shell(`${COMMAND}<camunda:field name="wait" />`)),
+      },
+      {
+        name: 'a message throw event without implementation (c7-message-throw-needs-implementation)',
+        moddleElement: engineModel(
+          'c7',
+          '<bpmn:intermediateThrowEvent id="event_notify"><bpmn:messageEventDefinition /></bpmn:intermediateThrowEvent>',
+        ),
+      },
+      {
+        name: 'a service task without implementation in a non-executable process',
+        moddleElement: engineModel('c7', '<bpmn:serviceTask id="serviceTask_x" />', {
+          processAttributes: 'isExecutable="false"',
+        }),
+      },
+      {
+        name: 'a service task without implementation in an ad-hoc sub-process',
+        moddleElement: engineModel(
+          'c7',
+          '<bpmn:adHocSubProcess id="adHocSubProcess_x"><bpmn:serviceTask id="serviceTask_x" /></bpmn:adHocSubProcess>',
+        ),
+      },
+      {
+        name: 'a Camunda 8 diagram',
+        moddleElement: engineModel(
+          'c8',
+          '<bpmn:serviceTask id="serviceTask_x" camunda:type="foo" />',
+          {
+            definitionsAttributes: 'xmlns:camunda="http://camunda.org/schema/1.0/bpmn"',
+          },
+        ),
+      },
+    ],
+    invalid: [
+      {
+        name: 'a shell task with an expression field',
+        moddleElement: engineModel(
+          'c7',
+          shell('<camunda:field name="command" expression="${cmd}" />'),
+        ),
+        report: {
+          id: 'serviceTask_runScript',
+          message:
+            'camunda:field "command" of shell task serviceTask serviceTask_runScript is an expression; the shell task takes fixed values only and the engines refuse the file',
+          path: ['extensionElements', 'values', 0, 'expression'],
+          type: ERROR_TYPES.PROPERTY_NOT_ALLOWED,
+        },
+      },
+      {
+        name: 'a shell task with wait=maybe',
+        moddleElement: engineModel(
+          'c7',
+          shell(
+            `${COMMAND}<camunda:field name="wait"><camunda:string>maybe</camunda:string></camunda:field>`,
+          ),
+        ),
+        report: {
+          id: 'serviceTask_runScript',
+          message:
+            'camunda:field "wait" of shell task serviceTask serviceTask_runScript is "maybe", not true or false; the engines refuse the file',
+          path: ['extensionElements', 'values', 1, 'string'],
+          type: ERROR_TYPES.PROPERTY_VALUE_NOT_ALLOWED,
+        },
+      },
+      {
+        name: 'a shell task with cleanEnv="no" as attribute',
+        moddleElement: engineModel(
+          'c7',
+          shell(`${COMMAND}<camunda:field name="cleanEnv" stringValue="no" />`),
+        ),
+        report: {
+          id: 'serviceTask_runScript',
+          message:
+            'camunda:field "cleanEnv" of shell task serviceTask serviceTask_runScript is "no", not true or false; the engines refuse the file',
+          path: ['extensionElements', 'values', 1, 'stringValue'],
+          type: ERROR_TYPES.PROPERTY_VALUE_NOT_ALLOWED,
+        },
+      },
+    ],
+  });
+});
diff --git a/test/adapters/out/bpmnlint/engine/rules/c7/C7ShellTaskNeedsCommandRule.test.ts b/test/adapters/out/bpmnlint/engine/rules/c7/C7ShellTaskNeedsCommandRule.test.ts
new file mode 100644
index 00000000..e9629274
--- /dev/null
+++ b/test/adapters/out/bpmnlint/engine/rules/c7/C7ShellTaskNeedsCommandRule.test.ts
@@ -0,0 +1,96 @@
+import { ERROR_TYPES } from 'bpmnlint-plugin-camunda-compat/rules/utils/error-types.js';
+import { describe } from 'vitest';
+import rule from '../../../../../../../src/adapters/out/bpmnlint/engine/rules/c7/C7ShellTaskNeedsCommandRule.js';
+import { engineModel, verifyEngineRule } from '../../../../../../helpers/engine-model.js';
+
+describe('c7-shell-task-needs-command', () => {
+  const ext = (content: string) => `<bpmn:extensionElements>${content}</bpmn:extensionElements>`;
+  const COMMAND =
+    '<camunda:field name="command"><camunda:string>echo</camunda:string></camunda:field>';
+  const shell = (fields: string, tag = 'serviceTask', type = 'shell') =>
+    `<bpmn:${tag} id="serviceTask_runScript" camunda:type="${type}">${ext(fields)}</bpmn:${tag}>`;
+
+  verifyEngineRule(rule, {
+    valid: [
+      {
+        name: 'tasks implemented by a delegate, an expression, an external topic, a connector or a decision',
+        moddleElement: engineModel(
+          'c7',
+          `<bpmn:serviceTask id="serviceTask_a" camunda:class="org.example.Charge" />
+          <bpmn:serviceTask id="serviceTask_b" camunda:delegateExpression="\${charge}" />
+          <bpmn:serviceTask id="serviceTask_c" camunda:expression="\${charge.run()}" />
+          <bpmn:serviceTask id="serviceTask_d" camunda:type="external" camunda:topic="chargeCard" />
+          <bpmn:serviceTask id="serviceTask_e">${ext('<camunda:connector><camunda:connectorId>http-connector</camunda:connectorId></camunda:connector>')}</bpmn:serviceTask>
+          <bpmn:businessRuleTask id="businessRuleTask_f" camunda:decisionRef="risk" camunda:mapDecisionResult="singleEntry" />
+          <bpmn:sendTask id="sendTask_g" camunda:type="External" camunda:topic="notify" />`,
+        ),
+      },
+      { name: 'a shell task with a command field', moddleElement: engineModel('c7', shell(COMMAND)) },
+      {
+        name: 'SHELL on a send task with a stringValue command and wait=TRUE',
+        moddleElement: engineModel(
+          'c7',
+          shell(
+            '<camunda:field name="command" stringValue="echo" /><camunda:field name="wait" stringValue="TRUE" />',
+            'sendTask',
+            'SHELL',
+          ),
+        ),
+      },
+      {
+        name: 'a shell message end event',
+        moddleElement: engineModel(
+          'c7',
+          `<bpmn:endEvent id="endEvent_done"><bpmn:messageEventDefinition camunda:type="shell">${ext(COMMAND)}</bpmn:messageEventDefinition></bpmn:endEvent>`,
+        ),
+      },
+      {
+        name: 'a shell field without a value (left to c7-field-needs-one-value)',
+        moddleElement: engineModel('c7', shell(`${COMMAND}<camunda:field name="wait" />`)),
+      },
+      {
+        name: 'a message throw event without implementation (c7-message-throw-needs-implementation)',
+        moddleElement: engineModel(
+          'c7',
+          '<bpmn:intermediateThrowEvent id="event_notify"><bpmn:messageEventDefinition /></bpmn:intermediateThrowEvent>',
+        ),
+      },
+      {
+        name: 'a service task without implementation in a non-executable process',
+        moddleElement: engineModel('c7', '<bpmn:serviceTask id="serviceTask_x" />', {
+          processAttributes: 'isExecutable="false"',
+        }),
+      },
+      {
+        name: 'a service task without implementation in an ad-hoc sub-process',
+        moddleElement: engineModel(
+          'c7',
+          '<bpmn:adHocSubProcess id="adHocSubProcess_x"><bpmn:serviceTask id="serviceTask_x" /></bpmn:adHocSubProcess>',
+        ),
+      },
+      {
+        name: 'a Camunda 8 diagram',
+        moddleElement: engineModel(
+          'c8',
+          '<bpmn:serviceTask id="serviceTask_x" camunda:type="foo" />',
+          {
+            definitionsAttributes: 'xmlns:camunda="http://camunda.org/schema/1.0/bpmn"',
+          },
+        ),
+      },
+    ],
+    invalid: [
+      {
+        name: 'a shell task without a command field',
+        moddleElement: engineModel('c7', shell('')),
+        report: {
+          id: 'serviceTask_runScript',
+          message:
+            'serviceTask serviceTask_runScript is a shell task without a camunda:field named command; the engines refuse the file',
+          path: ['extensionElements'],
+          type: ERROR_TYPES.EXTENSION_ELEMENT_REQUIRED,
+        },
+      },
+    ],
+  });
+});
diff --git a/test/adapters/out/bpmnlint/engine/rules/c7/C7SignalEventNeedsSignalRule.test.ts b/test/adapters/out/bpmnlint/engine/rules/c7/C7SignalEventNeedsSignalRule.test.ts
new file mode 100644
index 00000000..9f664f7b
--- /dev/null
+++ b/test/adapters/out/bpmnlint/engine/rules/c7/C7SignalEventNeedsSignalRule.test.ts
@@ -0,0 +1,92 @@
+import { ERROR_TYPES } from 'bpmnlint-plugin-camunda-compat/rules/utils/error-types.js';
+import { describe } from 'vitest';
+import rule from '../../../../../../../src/adapters/out/bpmnlint/engine/rules/c7/C7SignalEventNeedsSignalRule.js';
+import { engineModel, verifyEngineRule } from '../../../../../../helpers/engine-model.js';
+
+describe('c7-signal-event-needs-signal', () => {
+  const ROOTS = '<bpmn:signal id="Sig" name="Go" /><bpmn:signal id="SN" />';
+  const signal = (ref?: string) =>
+    `<bpmn:signalEventDefinition${ref ? ` signalRef="${ref}"` : ''} />`;
+  const START = '<bpmn:startEvent id="Start" />';
+  const catchEvent = (defs: string) =>
+    `${START}<bpmn:intermediateCatchEvent id="X">${defs}</bpmn:intermediateCatchEvent>`;
+  const boundary = (id: string, host: string, defs: string) =>
+    `<bpmn:boundaryEvent id="${id}" attachedToRef="${host}" cancelActivity="false">${defs}</bpmn:boundaryEvent>`;
+  const eventSub = (id: string, defs: string) =>
+    `<bpmn:subProcess id="${id}" triggeredByEvent="true"><bpmn:startEvent id="${id}_S" isInterrupting="false">${defs}</bpmn:startEvent></bpmn:subProcess>`;
+  const MESSAGE_EXPRESSION = '<bpmn:messageEventDefinition camunda:expression="${true}" />';
+  const TWO_NAMED_S = '<bpmn:signal id="Sig1" name="S" /><bpmn:signal id="Sig2" name="S" />';
+
+  verifyEngineRule(rule, {
+    valid: [
+      {
+        name: 'a catch event with a named signal',
+        moddleElement: engineModel('c7', catchEvent(signal('Sig')), { roots: ROOTS }),
+      },
+      {
+        name: 'end event: the message acts, the ignored signal without signalRef is not parsed',
+        moddleElement: engineModel(
+          'c7',
+          `${START}<bpmn:endEvent id="End">${MESSAGE_EXPRESSION}${signal()}</bpmn:endEvent>`,
+        ),
+      },
+      {
+        name: 'separate scopes: start and event sub-process, start and boundary',
+        moddleElement: engineModel(
+          'c7',
+          `<bpmn:startEvent id="Start">${signal('Sig')}</bpmn:startEvent><bpmn:userTask id="U" />${boundary('B2', 'U', signal('Sig'))}${eventSub('ES', signal('Sig'))}`,
+          { roots: ROOTS },
+        ),
+      },
+      {
+        name: 'two root signals with one name in a file without an executable process',
+        moddleElement: engineModel('c7', START, {
+          roots: TWO_NAMED_S,
+          processAttributes: 'isExecutable="false"',
+        }),
+      },
+      {
+        name: 'a catch event without signal in a non-executable process',
+        moddleElement: engineModel('c7', catchEvent(signal()), {
+          processAttributes: 'isExecutable="false"',
+        }),
+      },
+      {
+        name: 'a catch event without signal in an ad-hoc sub-process',
+        moddleElement: engineModel(
+          'c7',
+          `<bpmn:adHocSubProcess id="AH">${catchEvent(signal())}</bpmn:adHocSubProcess>`,
+        ),
+      },
+      {
+        name: 'a Camunda 8 diagram',
+        moddleElement: engineModel('c8', catchEvent(signal('SN')), { roots: ROOTS + TWO_NAMED_S }),
+      },
+    ],
+    invalid: [
+      {
+        name: 'signal catch event without signal',
+        moddleElement: engineModel('c7', catchEvent(signal())),
+        report: {
+          id: 'X',
+          message: 'intermediateCatchEvent:signal X has no signal; the engines refuse the file',
+          path: ['eventDefinitions', 0, 'signalRef'],
+          type: ERROR_TYPES.PROPERTY_REQUIRED,
+        },
+      },
+      {
+        name: 'intermediate throw event: the acting signal without signalRef is refused',
+        moddleElement: engineModel(
+          'c7',
+          `${START}<bpmn:intermediateThrowEvent id="T">${signal()}${MESSAGE_EXPRESSION}</bpmn:intermediateThrowEvent>`,
+        ),
+        report: {
+          id: 'T',
+          message: 'intermediateThrowEvent:signal T has no signal; the engines refuse the file',
+          path: ['eventDefinitions', 0, 'signalRef'],
+          type: ERROR_TYPES.PROPERTY_REQUIRED,
+        },
+      },
+    ],
+  });
+});
diff --git a/test/adapters/out/bpmnlint/engine/rules/c7/C7SignalNameUniqueRule.test.ts b/test/adapters/out/bpmnlint/engine/rules/c7/C7SignalNameUniqueRule.test.ts
new file mode 100644
index 00000000..6cb455a1
--- /dev/null
+++ b/test/adapters/out/bpmnlint/engine/rules/c7/C7SignalNameUniqueRule.test.ts
@@ -0,0 +1,90 @@
+import { ERROR_TYPES } from 'bpmnlint-plugin-camunda-compat/rules/utils/error-types.js';
+import { describe } from 'vitest';
+import rule from '../../../../../../../src/adapters/out/bpmnlint/engine/rules/c7/C7SignalNameUniqueRule.js';
+import { engineModel, verifyEngineRule } from '../../../../../../helpers/engine-model.js';
+
+describe('c7-signal-name-unique', () => {
+  const ROOTS = '<bpmn:signal id="Sig" name="Go" /><bpmn:signal id="SN" />';
+  const signal = (ref?: string) =>
+    `<bpmn:signalEventDefinition${ref ? ` signalRef="${ref}"` : ''} />`;
+  const START = '<bpmn:startEvent id="Start" />';
+  const catchEvent = (defs: string) =>
+    `${START}<bpmn:intermediateCatchEvent id="X">${defs}</bpmn:intermediateCatchEvent>`;
+  const boundary = (id: string, host: string, defs: string) =>
+    `<bpmn:boundaryEvent id="${id}" attachedToRef="${host}" cancelActivity="false">${defs}</bpmn:boundaryEvent>`;
+  const eventSub = (id: string, defs: string) =>
+    `<bpmn:subProcess id="${id}" triggeredByEvent="true"><bpmn:startEvent id="${id}_S" isInterrupting="false">${defs}</bpmn:startEvent></bpmn:subProcess>`;
+  const MESSAGE_EXPRESSION = '<bpmn:messageEventDefinition camunda:expression="${true}" />';
+  const TWO_NAMED_S = '<bpmn:signal id="Sig1" name="S" /><bpmn:signal id="Sig2" name="S" />';
+  const duplicate = (id: string, kind: string, first: string) => ({
+    id,
+    message: `${kind}:signal ${id} waits for signal "Go" like ${first} in the same scope; the engines refuse two signal subscriptions with one name`,
+    path: ['eventDefinitions', 0, 'signalRef'],
+    type: ERROR_TYPES.ELEMENT_PROPERTY_VALUE_DUPLICATED,
+  });
+
+  verifyEngineRule(rule, {
+    valid: [
+      {
+        name: 'a catch event with a named signal',
+        moddleElement: engineModel('c7', catchEvent(signal('Sig')), { roots: ROOTS }),
+      },
+      {
+        name: 'end event: the message acts, the ignored signal without signalRef is not parsed',
+        moddleElement: engineModel(
+          'c7',
+          `${START}<bpmn:endEvent id="End">${MESSAGE_EXPRESSION}${signal()}</bpmn:endEvent>`,
+        ),
+      },
+      {
+        name: 'separate scopes: start and event sub-process, start and boundary',
+        moddleElement: engineModel(
+          'c7',
+          `<bpmn:startEvent id="Start">${signal('Sig')}</bpmn:startEvent><bpmn:userTask id="U" />${boundary('B2', 'U', signal('Sig'))}${eventSub('ES', signal('Sig'))}`,
+          { roots: ROOTS },
+        ),
+      },
+      {
+        name: 'two root signals with one name in a file without an executable process',
+        moddleElement: engineModel('c7', START, {
+          roots: TWO_NAMED_S,
+          processAttributes: 'isExecutable="false"',
+        }),
+      },
+      {
+        name: 'a catch event without signal in a non-executable process',
+        moddleElement: engineModel('c7', catchEvent(signal()), {
+          processAttributes: 'isExecutable="false"',
+        }),
+      },
+      {
+        name: 'a catch event without signal in an ad-hoc sub-process',
+        moddleElement: engineModel(
+          'c7',
+          `<bpmn:adHocSubProcess id="AH">${catchEvent(signal())}</bpmn:adHocSubProcess>`,
+        ),
+      },
+      {
+        name: 'a Camunda 8 diagram',
+        moddleElement: engineModel('c8', catchEvent(signal('SN')), { roots: ROOTS + TWO_NAMED_S }),
+      },
+    ],
+    invalid: [
+      {
+        name: 'two root signals with one name',
+        moddleElement: engineModel(
+          'c7',
+          `${START}<bpmn:intermediateThrowEvent id="X">${signal('Sig1')}</bpmn:intermediateThrowEvent>`,
+          { roots: TWO_NAMED_S },
+        ),
+        report: {
+          id: 'Sig2',
+          message:
+            'Signals Sig1 and Sig2 are both named "S"; the engines refuse duplicate signal names',
+          path: ['name'],
+          type: ERROR_TYPES.ELEMENT_PROPERTY_VALUE_DUPLICATED,
+        },
+      },
+    ],
+  });
+});
diff --git a/test/adapters/out/bpmnlint/engine/rules/c7/C7SignalNeedsNameRule.test.ts b/test/adapters/out/bpmnlint/engine/rules/c7/C7SignalNeedsNameRule.test.ts
new file mode 100644
index 00000000..9ad6c49f
--- /dev/null
+++ b/test/adapters/out/bpmnlint/engine/rules/c7/C7SignalNeedsNameRule.test.ts
@@ -0,0 +1,79 @@
+import { ERROR_TYPES } from 'bpmnlint-plugin-camunda-compat/rules/utils/error-types.js';
+import { describe } from 'vitest';
+import rule from '../../../../../../../src/adapters/out/bpmnlint/engine/rules/c7/C7SignalNeedsNameRule.js';
+import { engineModel, verifyEngineRule } from '../../../../../../helpers/engine-model.js';
+
+describe('c7-signal-needs-name', () => {
+  const ROOTS = '<bpmn:signal id="Sig" name="Go" /><bpmn:signal id="SN" />';
+  const signal = (ref?: string) =>
+    `<bpmn:signalEventDefinition${ref ? ` signalRef="${ref}"` : ''} />`;
+  const START = '<bpmn:startEvent id="Start" />';
+  const catchEvent = (defs: string) =>
+    `${START}<bpmn:intermediateCatchEvent id="X">${defs}</bpmn:intermediateCatchEvent>`;
+  const boundary = (id: string, host: string, defs: string) =>
+    `<bpmn:boundaryEvent id="${id}" attachedToRef="${host}" cancelActivity="false">${defs}</bpmn:boundaryEvent>`;
+  const eventSub = (id: string, defs: string) =>
+    `<bpmn:subProcess id="${id}" triggeredByEvent="true"><bpmn:startEvent id="${id}_S" isInterrupting="false">${defs}</bpmn:startEvent></bpmn:subProcess>`;
+  const MESSAGE_EXPRESSION = '<bpmn:messageEventDefinition camunda:expression="${true}" />';
+  const TWO_NAMED_S = '<bpmn:signal id="Sig1" name="S" /><bpmn:signal id="Sig2" name="S" />';
+
+  verifyEngineRule(rule, {
+    valid: [
+      {
+        name: 'a catch event with a named signal',
+        moddleElement: engineModel('c7', catchEvent(signal('Sig')), { roots: ROOTS }),
+      },
+      {
+        name: 'end event: the message acts, the ignored signal without signalRef is not parsed',
+        moddleElement: engineModel(
+          'c7',
+          `${START}<bpmn:endEvent id="End">${MESSAGE_EXPRESSION}${signal()}</bpmn:endEvent>`,
+        ),
+      },
+      {
+        name: 'separate scopes: start and event sub-process, start and boundary',
+        moddleElement: engineModel(
+          'c7',
+          `<bpmn:startEvent id="Start">${signal('Sig')}</bpmn:startEvent><bpmn:userTask id="U" />${boundary('B2', 'U', signal('Sig'))}${eventSub('ES', signal('Sig'))}`,
+          { roots: ROOTS },
+        ),
+      },
+      {
+        name: 'two root signals with one name in a file without an executable process',
+        moddleElement: engineModel('c7', START, {
+          roots: TWO_NAMED_S,
+          processAttributes: 'isExecutable="false"',
+        }),
+      },
+      {
+        name: 'a catch event without signal in a non-executable process',
+        moddleElement: engineModel('c7', catchEvent(signal()), {
+          processAttributes: 'isExecutable="false"',
+        }),
+      },
+      {
+        name: 'a catch event without signal in an ad-hoc sub-process',
+        moddleElement: engineModel(
+          'c7',
+          `<bpmn:adHocSubProcess id="AH">${catchEvent(signal())}</bpmn:adHocSubProcess>`,
+        ),
+      },
+      {
+        name: 'a Camunda 8 diagram',
+        moddleElement: engineModel('c8', catchEvent(signal('SN')), { roots: ROOTS + TWO_NAMED_S }),
+      },
+    ],
+    invalid: [
+      {
+        name: 'signal without name',
+        moddleElement: engineModel('c7', catchEvent(signal('SN')), { roots: ROOTS }),
+        report: {
+          id: 'X',
+          message: 'Signal SN of intermediateCatchEvent:signal X has no name; the engines refuse the file',
+          path: ['eventDefinitions', 0, 'signalRef', 'name'],
+          type: ERROR_TYPES.PROPERTY_REQUIRED,
+        },
+      },
+    ],
+  });
+});
diff --git a/test/adapters/out/bpmnlint/engine/rules/c7/C7SignalSubscriptionUniqueRule.test.ts b/test/adapters/out/bpmnlint/engine/rules/c7/C7SignalSubscriptionUniqueRule.test.ts
new file mode 100644
index 00000000..c9523287
--- /dev/null
+++ b/test/adapters/out/bpmnlint/engine/rules/c7/C7SignalSubscriptionUniqueRule.test.ts
@@ -0,0 +1,111 @@
+import { ERROR_TYPES } from 'bpmnlint-plugin-camunda-compat/rules/utils/error-types.js';
+import { describe } from 'vitest';
+import rule from '../../../../../../../src/adapters/out/bpmnlint/engine/rules/c7/C7SignalSubscriptionUniqueRule.js';
+import { engineModel, verifyEngineRule } from '../../../../../../helpers/engine-model.js';
+
+describe('c7-signal-subscription-unique', () => {
+  const ROOTS = '<bpmn:signal id="Sig" name="Go" /><bpmn:signal id="SN" />';
+  const signal = (ref?: string) =>
+    `<bpmn:signalEventDefinition${ref ? ` signalRef="${ref}"` : ''} />`;
+  const START = '<bpmn:startEvent id="Start" />';
+  const catchEvent = (defs: string) =>
+    `${START}<bpmn:intermediateCatchEvent id="X">${defs}</bpmn:intermediateCatchEvent>`;
+  const boundary = (id: string, host: string, defs: string) =>
+    `<bpmn:boundaryEvent id="${id}" attachedToRef="${host}" cancelActivity="false">${defs}</bpmn:boundaryEvent>`;
+  const eventSub = (id: string, defs: string) =>
+    `<bpmn:subProcess id="${id}" triggeredByEvent="true"><bpmn:startEvent id="${id}_S" isInterrupting="false">${defs}</bpmn:startEvent></bpmn:subProcess>`;
+  const MESSAGE_EXPRESSION = '<bpmn:messageEventDefinition camunda:expression="${true}" />';
+  const TWO_NAMED_S = '<bpmn:signal id="Sig1" name="S" /><bpmn:signal id="Sig2" name="S" />';
+  const duplicate = (id: string, kind: string, first: string) => ({
+    id,
+    message: `${kind}:signal ${id} waits for signal "Go" like ${first} in the same scope; the engines refuse two signal subscriptions with one name`,
+    path: ['eventDefinitions', 0, 'signalRef'],
+    type: ERROR_TYPES.ELEMENT_PROPERTY_VALUE_DUPLICATED,
+  });
+
+  verifyEngineRule(rule, {
+    valid: [
+      {
+        name: 'a catch event with a named signal',
+        moddleElement: engineModel('c7', catchEvent(signal('Sig')), { roots: ROOTS }),
+      },
+      {
+        name: 'end event: the message acts, the ignored signal without signalRef is not parsed',
+        moddleElement: engineModel(
+          'c7',
+          `${START}<bpmn:endEvent id="End">${MESSAGE_EXPRESSION}${signal()}</bpmn:endEvent>`,
+        ),
+      },
+      {
+        name: 'separate scopes: start and event sub-process, start and boundary',
+        moddleElement: engineModel(
+          'c7',
+          `<bpmn:startEvent id="Start">${signal('Sig')}</bpmn:startEvent><bpmn:userTask id="U" />${boundary('B2', 'U', signal('Sig'))}${eventSub('ES', signal('Sig'))}`,
+          { roots: ROOTS },
+        ),
+      },
+      {
+        name: 'two root signals with one name in a file without an executable process',
+        moddleElement: engineModel('c7', START, {
+          roots: TWO_NAMED_S,
+          processAttributes: 'isExecutable="false"',
+        }),
+      },
+      {
+        name: 'a catch event without signal in a non-executable process',
+        moddleElement: engineModel('c7', catchEvent(signal()), {
+          processAttributes: 'isExecutable="false"',
+        }),
+      },
+      {
+        name: 'a catch event without signal in an ad-hoc sub-process',
+        moddleElement: engineModel(
+          'c7',
+          `<bpmn:adHocSubProcess id="AH">${catchEvent(signal())}</bpmn:adHocSubProcess>`,
+        ),
+      },
+      {
+        name: 'a Camunda 8 diagram',
+        moddleElement: engineModel('c8', catchEvent(signal('SN')), { roots: ROOTS + TWO_NAMED_S }),
+      },
+    ],
+    invalid: [
+      {
+        name: 'two signal start events on one signal',
+        moddleElement: engineModel(
+          'c7',
+          `<bpmn:startEvent id="Start">${signal('Sig')}</bpmn:startEvent><bpmn:startEvent id="S2">${signal('Sig')}</bpmn:startEvent>`,
+          { roots: ROOTS },
+        ),
+        report: duplicate('S2', 'startEvent', 'Start'),
+      },
+      {
+        name: 'two signal boundary events on one host',
+        moddleElement: engineModel(
+          'c7',
+          `${START}<bpmn:userTask id="T" />${boundary('B1', 'T', signal('Sig'))}${boundary('B2', 'T', signal('Sig'))}`,
+          { roots: ROOTS },
+        ),
+        report: duplicate('B2', 'boundaryEvent', 'B1'),
+      },
+      {
+        name: 'two event sub-processes on one signal',
+        moddleElement: engineModel(
+          'c7',
+          `${START}${eventSub('ES1', signal('Sig'))}${eventSub('ES2', signal('Sig'))}`,
+          { roots: ROOTS },
+        ),
+        report: duplicate('ES2_S', 'startEvent', 'ES1_S'),
+      },
+      {
+        name: 'boundary event on a sub-process and an event sub-process in it, one signal',
+        moddleElement: engineModel(
+          'c7',
+          `${START}<bpmn:subProcess id="Sub"><bpmn:startEvent id="Sub_S" />${eventSub('ES', signal('Sig'))}</bpmn:subProcess>${boundary('B1', 'Sub', signal('Sig'))}`,
+          { roots: ROOTS },
+        ),
+        report: duplicate('B1', 'boundaryEvent', 'ES_S'),
+      },
+    ],
+  });
+});
diff --git a/test/adapters/out/bpmnlint/engine/rules/c7/C7StartEventUniqueRule.test.ts b/test/adapters/out/bpmnlint/engine/rules/c7/C7StartEventUniqueRule.test.ts
new file mode 100644
index 00000000..e1a42359
--- /dev/null
+++ b/test/adapters/out/bpmnlint/engine/rules/c7/C7StartEventUniqueRule.test.ts
@@ -0,0 +1,136 @@
+import { ERROR_TYPES } from 'bpmnlint-plugin-camunda-compat/rules/utils/error-types.js';
+import { describe } from 'vitest';
+import rule from '../../../../../../../src/adapters/out/bpmnlint/engine/rules/c7/C7StartEventUniqueRule.js';
+import { engineModel, verifyEngineRule } from '../../../../../../helpers/engine-model.js';
+
+describe('c7-start-event-unique', () => {
+  const ROOTS =
+    '<bpmn:signal id="Sig" name="Go" /><bpmn:message id="M" name="Pay" /><bpmn:message id="M2" name="Pay2" />';
+  const CYCLE =
+    '<bpmn:timerEventDefinition><bpmn:timeCycle xsi:type="bpmn:tFormalExpression">R/PT1H</bpmn:timeCycle></bpmn:timerEventDefinition>';
+  const MESSAGE = '<bpmn:messageEventDefinition messageRef="M" />';
+  const flow = (id: string, source: string, target: string) =>
+    `<bpmn:sequenceFlow id="${id}" sourceRef="${source}" targetRef="${target}" />`;
+  const BODY = `<bpmn:userTask id="T" /><bpmn:endEvent id="End" />${flow('F1', 'T', 'End')}`;
+  const twoStarts = (prefix: string) =>
+    `<bpmn:startEvent id="${prefix}_S0" /><bpmn:startEvent id="${prefix}_S1" /><bpmn:endEvent id="${prefix}_E" />${flow(`${prefix}_f0`, `${prefix}_S0`, `${prefix}_E`)}${flow(`${prefix}_f1`, `${prefix}_S1`, `${prefix}_E`)}`;
+  const START = '<bpmn:startEvent id="Start" />';
+  const extra = (id: string, message: string) => ({
+    id,
+    message,
+    type: ERROR_TYPES.ELEMENT_MULTIPLE_NOT_ALLOWED,
+  });
+  const secondOfProcess = (id: string) =>
+    extra(
+      id,
+      `Start event ${id} is a second none or timer start event of process process_test (with Start); the engines allow only one and refuse the file`,
+    );
+
+  verifyEngineRule(rule, {
+    valid: [
+      {
+        name: 'none, message and signal start events',
+        moddleElement: engineModel(
+          'c7',
+          `${START}<bpmn:startEvent id="S2">${MESSAGE}</bpmn:startEvent><bpmn:startEvent id="S3"><bpmn:signalEventDefinition signalRef="Sig" /></bpmn:startEvent>${BODY}`,
+          { roots: ROOTS },
+        ),
+      },
+      {
+        name: 'a transaction without start event (c7-transaction-needs-start-event)',
+        moddleElement: engineModel(
+          'c7',
+          `${START}<bpmn:transaction id="SP"><bpmn:userTask id="U" /></bpmn:transaction>`,
+        ),
+      },
+      {
+        name: 'an event sub-process without start event',
+        moddleElement: engineModel(
+          'c7',
+          `${START}<bpmn:subProcess id="ES" triggeredByEvent="true" />`,
+        ),
+      },
+      {
+        name: 'an ad-hoc sub-process: its content is skipped',
+        moddleElement: engineModel(
+          'c7',
+          `${START}<bpmn:adHocSubProcess id="SP"><bpmn:serviceTask id="X" /><bpmn:subProcess id="Z"><bpmn:userTask id="Z1" /></bpmn:subProcess><bpmn:startEvent id="A1" /><bpmn:startEvent id="A2" /></bpmn:adHocSubProcess>`,
+        ),
+      },
+      {
+        name: 'a non-executable process without start event',
+        moddleElement: engineModel('c7', BODY, { processAttributes: 'isExecutable="false"' }),
+      },
+      {
+        name: 'a Camunda 8 diagram',
+        moddleElement: engineModel('c8', `${START}<bpmn:startEvent id="S2" />${BODY}`),
+      },
+    ],
+    invalid: [
+      {
+        name: 'two none start events',
+        moddleElement: engineModel('c7', `${START}<bpmn:startEvent id="S2" />${BODY}`),
+        report: secondOfProcess('S2'),
+      },
+      {
+        name: 'none and timer start event',
+        moddleElement: engineModel(
+          'c7',
+          `${START}<bpmn:startEvent id="S2">${CYCLE}</bpmn:startEvent>${BODY}`,
+        ),
+        report: secondOfProcess('S2'),
+      },
+      {
+        name: 'two timer start events',
+        moddleElement: engineModel(
+          'c7',
+          `<bpmn:startEvent id="Start">${CYCLE}</bpmn:startEvent><bpmn:startEvent id="S2">${CYCLE}</bpmn:startEvent>${BODY}`,
+        ),
+        report: secondOfProcess('S2'),
+      },
+      {
+        name: 'a message + timer start event is a second timer start event',
+        moddleElement: engineModel(
+          'c7',
+          `${START}<bpmn:startEvent id="S2">${MESSAGE}${CYCLE}</bpmn:startEvent>${BODY}`,
+          { roots: ROOTS },
+        ),
+        report: secondOfProcess('S2'),
+      },
+      {
+        name: 'sub-process with two start events',
+        moddleElement: engineModel(
+          'c7',
+          `${START}<bpmn:subProcess id="Sub">${twoStarts('Sub')}</bpmn:subProcess>`,
+        ),
+        report: extra(
+          'Sub_S1',
+          'Sub-process Sub has 2 start events (Sub_S0, Sub_S1); the engines allow only one in a sub-process and refuse the file',
+        ),
+      },
+      {
+        name: 'transaction with two start events',
+        moddleElement: engineModel(
+          'c7',
+          `${START}<bpmn:transaction id="Sub">${twoStarts('Sub')}</bpmn:transaction>`,
+        ),
+        report: extra(
+          'Sub_S1',
+          'Transaction Sub has 2 start events (Sub_S0, Sub_S1); the engines allow only one in a sub-process and refuse the file',
+        ),
+      },
+      {
+        name: 'event sub-process with two message start events',
+        moddleElement: engineModel(
+          'c7',
+          `${START}<bpmn:subProcess id="ES" triggeredByEvent="true"><bpmn:startEvent id="ES1">${MESSAGE}</bpmn:startEvent><bpmn:startEvent id="ES2"><bpmn:messageEventDefinition messageRef="M2" /></bpmn:startEvent></bpmn:subProcess>`,
+          { roots: ROOTS },
+        ),
+        report: extra(
+          'ES2',
+          'Event sub-process ES has 2 start events (ES1, ES2); the engines allow only one in a sub-process and refuse the file',
+        ),
+      },
+    ],
+  });
+});
diff --git a/test/adapters/out/bpmnlint/engine/rules/c7/C7TaskNeedsImplementationRule.test.ts b/test/adapters/out/bpmnlint/engine/rules/c7/C7TaskNeedsImplementationRule.test.ts
new file mode 100644
index 00000000..3161cf75
--- /dev/null
+++ b/test/adapters/out/bpmnlint/engine/rules/c7/C7TaskNeedsImplementationRule.test.ts
@@ -0,0 +1,133 @@
+import { ERROR_TYPES } from 'bpmnlint-plugin-camunda-compat/rules/utils/error-types.js';
+import { describe } from 'vitest';
+import rule from '../../../../../../../src/adapters/out/bpmnlint/engine/rules/c7/C7TaskNeedsImplementationRule.js';
+import { engineModel, verifyEngineRule } from '../../../../../../helpers/engine-model.js';
+
+describe('c7-task-needs-implementation', () => {
+  const ext = (content: string) => `<bpmn:extensionElements>${content}</bpmn:extensionElements>`;
+  const COMMAND =
+    '<camunda:field name="command"><camunda:string>echo</camunda:string></camunda:field>';
+  const shell = (fields: string, tag = 'serviceTask', type = 'shell') =>
+    `<bpmn:${tag} id="serviceTask_runScript" camunda:type="${type}">${ext(fields)}</bpmn:${tag}>`;
+  const MISSING = (label: string, decision = '') =>
+    `${label} has no implementation (camunda:class, delegateExpression, expression, type=external${decision} or a connector); the engines refuse the file`;
+
+  verifyEngineRule(rule, {
+    valid: [
+      {
+        name: 'tasks implemented by a delegate, an expression, an external topic, a connector or a decision',
+        moddleElement: engineModel(
+          'c7',
+          `<bpmn:serviceTask id="serviceTask_a" camunda:class="org.example.Charge" />
+          <bpmn:serviceTask id="serviceTask_b" camunda:delegateExpression="\${charge}" />
+          <bpmn:serviceTask id="serviceTask_c" camunda:expression="\${charge.run()}" />
+          <bpmn:serviceTask id="serviceTask_d" camunda:type="external" camunda:topic="chargeCard" />
+          <bpmn:serviceTask id="serviceTask_e">${ext('<camunda:connector><camunda:connectorId>http-connector</camunda:connectorId></camunda:connector>')}</bpmn:serviceTask>
+          <bpmn:businessRuleTask id="businessRuleTask_f" camunda:decisionRef="risk" camunda:mapDecisionResult="singleEntry" />
+          <bpmn:sendTask id="sendTask_g" camunda:type="External" camunda:topic="notify" />`,
+        ),
+      },
+      { name: 'a shell task with a command field', moddleElement: engineModel('c7', shell(COMMAND)) },
+      {
+        name: 'SHELL on a send task with a stringValue command and wait=TRUE',
+        moddleElement: engineModel(
+          'c7',
+          shell(
+            '<camunda:field name="command" stringValue="echo" /><camunda:field name="wait" stringValue="TRUE" />',
+            'sendTask',
+            'SHELL',
+          ),
+        ),
+      },
+      {
+        name: 'a shell message end event',
+        moddleElement: engineModel(
+          'c7',
+          `<bpmn:endEvent id="endEvent_done"><bpmn:messageEventDefinition camunda:type="shell">${ext(COMMAND)}</bpmn:messageEventDefinition></bpmn:endEvent>`,
+        ),
+      },
+      {
+        name: 'a shell field without a value (left to c7-field-needs-one-value)',
+        moddleElement: engineModel('c7', shell(`${COMMAND}<camunda:field name="wait" />`)),
+      },
+      {
+        name: 'a message throw event without implementation (c7-message-throw-needs-implementation)',
+        moddleElement: engineModel(
+          'c7',
+          '<bpmn:intermediateThrowEvent id="event_notify"><bpmn:messageEventDefinition /></bpmn:intermediateThrowEvent>',
+        ),
+      },
+      {
+        name: 'a service task without implementation in a non-executable process',
+        moddleElement: engineModel('c7', '<bpmn:serviceTask id="serviceTask_x" />', {
+          processAttributes: 'isExecutable="false"',
+        }),
+      },
+      {
+        name: 'a service task without implementation in an ad-hoc sub-process',
+        moddleElement: engineModel(
+          'c7',
+          '<bpmn:adHocSubProcess id="adHocSubProcess_x"><bpmn:serviceTask id="serviceTask_x" /></bpmn:adHocSubProcess>',
+        ),
+      },
+      {
+        name: 'a Camunda 8 diagram',
+        moddleElement: engineModel(
+          'c8',
+          '<bpmn:serviceTask id="serviceTask_x" camunda:type="foo" />',
+          {
+            definitionsAttributes: 'xmlns:camunda="http://camunda.org/schema/1.0/bpmn"',
+          },
+        ),
+      },
+    ],
+    invalid: [
+      ...['serviceTask', 'sendTask'].map((tag) => ({
+        name: `a ${tag} without implementation`,
+        moddleElement: engineModel('c7', `<bpmn:${tag} id="task_x" />`),
+        report: {
+          id: 'task_x',
+          message: MISSING(`${tag} task_x`),
+          path: ['type'],
+          type: ERROR_TYPES.PROPERTY_REQUIRED,
+        },
+      })),
+      {
+        name: 'a business rule task without decisionRef or implementation',
+        moddleElement: engineModel('c7', '<bpmn:businessRuleTask id="businessRuleTask_x" />'),
+        report: {
+          id: 'businessRuleTask_x',
+          message: MISSING('businessRuleTask businessRuleTask_x', ', decisionRef'),
+          path: ['type'],
+          type: ERROR_TYPES.PROPERTY_REQUIRED,
+        },
+      },
+      {
+        name: 'a topic without type=external',
+        moddleElement: engineModel(
+          'c7',
+          '<bpmn:serviceTask id="serviceTask_x" camunda:topic="chargeCard" />',
+        ),
+        report: {
+          id: 'serviceTask_x',
+          message: MISSING('serviceTask serviceTask_x'),
+          path: ['type'],
+          type: ERROR_TYPES.PROPERTY_REQUIRED,
+        },
+      },
+      {
+        name: 'an empty expression counts as none',
+        moddleElement: engineModel(
+          'c7',
+          '<bpmn:serviceTask id="serviceTask_x" camunda:expression="" />',
+        ),
+        report: {
+          id: 'serviceTask_x',
+          message: MISSING('serviceTask serviceTask_x'),
+          path: ['type'],
+          type: ERROR_TYPES.PROPERTY_REQUIRED,
+        },
+      },
+    ],
+  });
+});
diff --git a/test/adapters/out/bpmnlint/engine/rules/c7/C7TaskTypeSupportedRule.test.ts b/test/adapters/out/bpmnlint/engine/rules/c7/C7TaskTypeSupportedRule.test.ts
new file mode 100644
index 00000000..9a4edef9
--- /dev/null
+++ b/test/adapters/out/bpmnlint/engine/rules/c7/C7TaskTypeSupportedRule.test.ts
@@ -0,0 +1,131 @@
+import { ERROR_TYPES } from 'bpmnlint-plugin-camunda-compat/rules/utils/error-types.js';
+import { describe } from 'vitest';
+import rule from '../../../../../../../src/adapters/out/bpmnlint/engine/rules/c7/C7TaskTypeSupportedRule.js';
+import { engineModel, verifyEngineRule } from '../../../../../../helpers/engine-model.js';
+
+describe('c7-task-type-supported', () => {
+  const ext = (content: string) => `<bpmn:extensionElements>${content}</bpmn:extensionElements>`;
+  const COMMAND =
+    '<camunda:field name="command"><camunda:string>echo</camunda:string></camunda:field>';
+  const shell = (fields: string, tag = 'serviceTask', type = 'shell') =>
+    `<bpmn:${tag} id="serviceTask_runScript" camunda:type="${type}">${ext(fields)}</bpmn:${tag}>`;
+
+  verifyEngineRule(rule, {
+    valid: [
+      {
+        name: 'tasks implemented by a delegate, an expression, an external topic, a connector or a decision',
+        moddleElement: engineModel(
+          'c7',
+          `<bpmn:serviceTask id="serviceTask_a" camunda:class="org.example.Charge" />
+          <bpmn:serviceTask id="serviceTask_b" camunda:delegateExpression="\${charge}" />
+          <bpmn:serviceTask id="serviceTask_c" camunda:expression="\${charge.run()}" />
+          <bpmn:serviceTask id="serviceTask_d" camunda:type="external" camunda:topic="chargeCard" />
+          <bpmn:serviceTask id="serviceTask_e">${ext('<camunda:connector><camunda:connectorId>http-connector</camunda:connectorId></camunda:connector>')}</bpmn:serviceTask>
+          <bpmn:businessRuleTask id="businessRuleTask_f" camunda:decisionRef="risk" camunda:mapDecisionResult="singleEntry" />
+          <bpmn:sendTask id="sendTask_g" camunda:type="External" camunda:topic="notify" />`,
+        ),
+      },
+      { name: 'a shell task with a command field', moddleElement: engineModel('c7', shell(COMMAND)) },
+      {
+        name: 'SHELL on a send task with a stringValue command and wait=TRUE',
+        moddleElement: engineModel(
+          'c7',
+          shell(
+            '<camunda:field name="command" stringValue="echo" /><camunda:field name="wait" stringValue="TRUE" />',
+            'sendTask',
+            'SHELL',
+          ),
+        ),
+      },
+      {
+        name: 'a shell message end event',
+        moddleElement: engineModel(
+          'c7',
+          `<bpmn:endEvent id="endEvent_done"><bpmn:messageEventDefinition camunda:type="shell">${ext(COMMAND)}</bpmn:messageEventDefinition></bpmn:endEvent>`,
+        ),
+      },
+      {
+        name: 'a shell field without a value (left to c7-field-needs-one-value)',
+        moddleElement: engineModel('c7', shell(`${COMMAND}<camunda:field name="wait" />`)),
+      },
+      {
+        name: 'a message throw event without implementation (c7-message-throw-needs-implementation)',
+        moddleElement: engineModel(
+          'c7',
+          '<bpmn:intermediateThrowEvent id="event_notify"><bpmn:messageEventDefinition /></bpmn:intermediateThrowEvent>',
+        ),
+      },
+      {
+        name: 'a service task without implementation in a non-executable process',
+        moddleElement: engineModel('c7', '<bpmn:serviceTask id="serviceTask_x" />', {
+          processAttributes: 'isExecutable="false"',
+        }),
+      },
+      {
+        name: 'a service task without implementation in an ad-hoc sub-process',
+        moddleElement: engineModel(
+          'c7',
+          '<bpmn:adHocSubProcess id="adHocSubProcess_x"><bpmn:serviceTask id="serviceTask_x" /></bpmn:adHocSubProcess>',
+        ),
+      },
+      {
+        name: 'a Camunda 8 diagram',
+        moddleElement: engineModel(
+          'c8',
+          '<bpmn:serviceTask id="serviceTask_x" camunda:type="foo" />',
+          {
+            definitionsAttributes: 'xmlns:camunda="http://camunda.org/schema/1.0/bpmn"',
+          },
+        ),
+      },
+    ],
+    invalid: [
+      {
+        name: 'a camunda:type other than external or shell',
+        moddleElement: engineModel(
+          'c7',
+          '<bpmn:serviceTask id="serviceTask_x" camunda:type="foo" camunda:topic="t" />',
+        ),
+        report: {
+          id: 'serviceTask_x',
+          message:
+            'camunda:type="foo" on serviceTask serviceTask_x is not supported (only "external" and "shell"); the engines refuse the file',
+          path: ['type'],
+          type: ERROR_TYPES.PROPERTY_VALUE_NOT_ALLOWED,
+        },
+      },
+      {
+        name: 'a mail task',
+        moddleElement: engineModel(
+          'c7',
+          shell(
+            '<camunda:field name="to" stringValue="a@b.c" /><camunda:field name="text" stringValue="x" />',
+            'serviceTask',
+            'mail',
+          ),
+        ),
+        report: {
+          id: 'serviceTask_runScript',
+          message:
+            'camunda:type="mail" on serviceTask serviceTask_runScript is not supported (only "external" and "shell") (the standard engine distributions cannot load the mail task); the engines refuse the file',
+          path: ['type'],
+          type: ERROR_TYPES.PROPERTY_VALUE_NOT_ALLOWED,
+        },
+      },
+      {
+        name: 'a message end event with an unsupported type',
+        moddleElement: engineModel(
+          'c7',
+          '<bpmn:endEvent id="endEvent_done"><bpmn:messageEventDefinition camunda:type="foo" /></bpmn:endEvent>',
+        ),
+        report: {
+          id: 'endEvent_done',
+          message:
+            'camunda:type="foo" on endEvent:message endEvent_done is not supported (only "external" and "shell"); the engines refuse the file',
+          path: ['eventDefinitions', 0, 'type'],
+          type: ERROR_TYPES.PROPERTY_VALUE_NOT_ALLOWED,
+        },
+      },
+    ],
+  });
+});
diff --git a/test/adapters/out/bpmnlint/engine/rules/c7/C7TimeoutListenerNeedsTimerAndIdRule.test.ts b/test/adapters/out/bpmnlint/engine/rules/c7/C7TimeoutListenerNeedsTimerAndIdRule.test.ts
new file mode 100644
index 00000000..76d3c5aa
--- /dev/null
+++ b/test/adapters/out/bpmnlint/engine/rules/c7/C7TimeoutListenerNeedsTimerAndIdRule.test.ts
@@ -0,0 +1,93 @@
+import { ERROR_TYPES } from 'bpmnlint-plugin-camunda-compat/rules/utils/error-types.js';
+import { describe } from 'vitest';
+import rule from '../../../../../../../src/adapters/out/bpmnlint/engine/rules/c7/C7TimeoutListenerNeedsTimerAndIdRule.js';
+import { engineModel, verifyEngineRule } from '../../../../../../helpers/engine-model.js';
+
+describe('c7-timeout-listener-needs-timer-and-id', () => {
+  const ext = (inner: string) => `<bpmn:extensionElements>${inner}</bpmn:extensionElements>`;
+  const TIMER =
+    '<bpmn:timerEventDefinition><bpmn:timeDuration xsi:type="bpmn:tFormalExpression">PT1H</bpmn:timeDuration></bpmn:timerEventDefinition>';
+  const userTask = (inner: string) =>
+    `<bpmn:userTask id="userTask_review">${ext(inner)}</bpmn:userTask>`;
+  const serviceTask = (inner: string) =>
+    `<bpmn:serviceTask id="serviceTask_charge" camunda:expression="\${true}">${ext(inner)}</bpmn:serviceTask>`;
+  const timeout = (attributes: string, inner = TIMER) =>
+    userTask(
+      `<camunda:taskListener event="timeout" expression="\${true}" ${attributes}>${inner}</camunda:taskListener>`,
+    );
+  const REQUIRED = ERROR_TYPES.PROPERTY_REQUIRED;
+
+  verifyEngineRule(rule, {
+    valid: [
+      {
+        name: 'listeners with an implementation and a known event',
+        moddleElement: engineModel(
+          'c7',
+          serviceTask(
+            '<camunda:executionListener event="start" class="a.B" /><camunda:executionListener event="end"><camunda:script scriptFormat="groovy">x</camunda:script></camunda:executionListener>',
+          ) + userTask('<camunda:taskListener event="assignment" delegateExpression="${l}" />'),
+        ),
+      },
+      {
+        name: 'a timeout task listener with timer and id',
+        moddleElement: engineModel('c7', timeout('id="taskListener_remind"')),
+      },
+      {
+        name: 'a timeout task listener with an empty id',
+        moddleElement: engineModel('c7', timeout('id=""')),
+      },
+      {
+        name: 'an execution listener on a sequence flow takes any event',
+        moddleElement: engineModel(
+          'c7',
+          `<bpmn:userTask id="userTask_review" /><bpmn:endEvent id="endEvent_done" /><bpmn:sequenceFlow id="flow_done" sourceRef="userTask_review" targetRef="endEvent_done">${ext('<camunda:executionListener class="a.B" />')}</bpmn:sequenceFlow>`,
+        ),
+      },
+      {
+        name: 'a task listener where the engines do not read it (c7-camunda-extension-placement)',
+        moddleElement: engineModel('c7', serviceTask('<camunda:taskListener event="nope" />')),
+      },
+      {
+        name: 'a listener in a non-executable process',
+        moddleElement: engineModel('c7', serviceTask('<camunda:executionListener event="start" />'), {
+          processAttributes: 'isExecutable="false"',
+        }),
+      },
+      {
+        name: 'a listener inside an ad-hoc sub-process of an executable process',
+        moddleElement: engineModel(
+          'c7',
+          `<bpmn:adHocSubProcess id="adHocSubProcess_steps">${serviceTask('<camunda:executionListener event="start" />')}</bpmn:adHocSubProcess>`,
+        ),
+      },
+      {
+        name: 'a Camunda 8 diagram',
+        moddleElement: engineModel('c8', '<bpmn:userTask id="userTask_review" />'),
+      },
+    ],
+    invalid: [
+      {
+        name: 'a timeout task listener without timer',
+        moddleElement: engineModel('c7', timeout('id="taskListener_remind"', '')),
+        report: {
+          id: 'userTask_review',
+          message:
+            'camunda:taskListener (event timeout) of userTask userTask_review has no bpmn:timerEventDefinition; the engines refuse the file',
+          path: ['extensionElements', 'values', 0, 'eventDefinitions'],
+          type: ERROR_TYPES.CHILD_ELEMENT_OF_TYPE_REQUIRED,
+        },
+      },
+      {
+        name: 'a timeout task listener without id',
+        moddleElement: engineModel('c7', timeout('')),
+        report: {
+          id: 'userTask_review',
+          message:
+            'camunda:taskListener (event timeout) of userTask userTask_review has no id, which the engines require on timeout task listeners; they refuse the file',
+          path: ['extensionElements', 'values', 0, 'id'],
+          type: REQUIRED,
+        },
+      },
+    ],
+  });
+});
diff --git a/test/adapters/out/bpmnlint/engine/rules/c7/C7TimerNeedsOneTimeValueRule.test.ts b/test/adapters/out/bpmnlint/engine/rules/c7/C7TimerNeedsOneTimeValueRule.test.ts
new file mode 100644
index 00000000..27ddc140
--- /dev/null
+++ b/test/adapters/out/bpmnlint/engine/rules/c7/C7TimerNeedsOneTimeValueRule.test.ts
@@ -0,0 +1,139 @@
+import { ERROR_TYPES } from 'bpmnlint-plugin-camunda-compat/rules/utils/error-types.js';
+import { describe } from 'vitest';
+import rule from '../../../../../../../src/adapters/out/bpmnlint/engine/rules/c7/C7TimerNeedsOneTimeValueRule.js';
+import { engineModel, verifyEngineRule } from '../../../../../../helpers/engine-model.js';
+
+describe('c7-timer-needs-one-time-value', () => {
+  const ROOTS = '<bpmn:message id="M" name="Pay" />';
+  const TIMER =
+    '<bpmn:timerEventDefinition id="TDef"><bpmn:timeDuration xsi:type="bpmn:tFormalExpression">PT1H</bpmn:timeDuration></bpmn:timerEventDefinition>';
+  const EMPTY_TIMER = '<bpmn:timerEventDefinition id="TDef" />';
+  const TWO_TIMES =
+    '<bpmn:timerEventDefinition id="TDef"><bpmn:timeDate xsi:type="bpmn:tFormalExpression">2030-01-01T00:00:00Z</bpmn:timeDate><bpmn:timeDuration xsi:type="bpmn:tFormalExpression">PT1H</bpmn:timeDuration></bpmn:timerEventDefinition>';
+  const COND_NONE = '<bpmn:conditionalEventDefinition id="CDef" />';
+  const MSG = '<bpmn:messageEventDefinition id="MDef" messageRef="M" />';
+  const START = '<bpmn:startEvent id="Start" />';
+  const catchWith = (defs: string) =>
+    `${START}<bpmn:intermediateCatchEvent id="W">${defs}</bpmn:intermediateCatchEvent>`;
+  const eventSubStart = (defs: string) =>
+    `${START}<bpmn:subProcess id="ES" triggeredByEvent="true"><bpmn:startEvent id="W" isInterrupting="false">${defs}</bpmn:startEvent></bpmn:subProcess>`;
+  const flow = (id: string, source: string, target: string) =>
+    `<bpmn:sequenceFlow id="${id}" sourceRef="${source}" targetRef="${target}" />`;
+  const compensation = (ref: string, where: 'process' | 'sub' | 'end' | 'eventSub' = 'process') => {
+    const thr = `<bpmn:intermediateThrowEvent id="Th"><bpmn:compensateEventDefinition activityRef="${ref}" /></bpmn:intermediateThrowEvent>`;
+    const sub = `<bpmn:subProcess id="Sub"><bpmn:startEvent id="SS" /><bpmn:userTask id="Inner" />${where === 'sub' ? thr : ''}</bpmn:subProcess>`;
+    const end =
+      where === 'end'
+        ? `<bpmn:endEvent id="End"><bpmn:compensateEventDefinition activityRef="${ref}" /></bpmn:endEvent>`
+        : '<bpmn:endEvent id="End" />';
+    const eventSub =
+      where === 'eventSub'
+        ? `<bpmn:subProcess id="ES" triggeredByEvent="true"><bpmn:startEvent id="ESS" isInterrupting="false">${MSG}</bpmn:startEvent>${thr}</bpmn:subProcess>`
+        : '';
+    return engineModel(
+      'c7',
+      `${START}<bpmn:userTask id="Host" />${sub}${where === 'process' ? thr : ''}${end}${eventSub}${flow('F0', 'Start', 'Host')}`,
+      { roots: ROOTS },
+    );
+  };
+
+  verifyEngineRule(rule, {
+    valid: [
+      {
+        name: 'a timer with a duration and a conditional event with a condition',
+        moddleElement: engineModel(
+          'c7',
+          catchWith(TIMER) +
+            '<bpmn:intermediateCatchEvent id="C"><bpmn:conditionalEventDefinition><bpmn:condition xsi:type="bpmn:tFormalExpression">${ready}</bpmn:condition></bpmn:conditionalEventDefinition></bpmn:intermediateCatchEvent>',
+        ),
+      },
+      {
+        name: 'event sub-process start: the message acts, an empty timer is ignored',
+        moddleElement: engineModel('c7', eventSubStart(MSG + EMPTY_TIMER), { roots: ROOTS }),
+      },
+      {
+        name: 'a timer without value in a non-executable process',
+        moddleElement: engineModel('c7', catchWith(EMPTY_TIMER), {
+          processAttributes: 'isExecutable="false"',
+        }),
+      },
+      {
+        name: 'a timer without value in an ad-hoc sub-process',
+        moddleElement: engineModel(
+          'c7',
+          `<bpmn:adHocSubProcess id="AH">${catchWith(EMPTY_TIMER)}</bpmn:adHocSubProcess>`,
+        ),
+      },
+      {
+        name: 'compensation of the sub-process from its own scope',
+        moddleElement: compensation('Sub'),
+      },
+      {
+        name: 'compensation of an activity of the own scope',
+        moddleElement: compensation('Host'),
+      },
+      {
+        name: 'compensation from an event sub-process of an activity of its parent scope',
+        moddleElement: compensation('Host', 'eventSub'),
+      },
+      {
+        name: 'compensation inside a sub-process of its own activity',
+        moddleElement: compensation('Inner', 'sub'),
+      },
+      {
+        name: 'a Camunda 8 diagram',
+        moddleElement: engineModel(
+          'c8',
+          catchWith(COND_NONE) +
+            `<bpmn:intermediateCatchEvent id="T">${TWO_TIMES}</bpmn:intermediateCatchEvent>`,
+        ),
+      },
+    ],
+    invalid: [
+      {
+        name: 'timer without value',
+        moddleElement: engineModel('c7', catchWith(EMPTY_TIMER)),
+        report: {
+          id: 'W',
+          message:
+            'Timer of intermediateCatchEvent:timer W has no date, cycle or duration; the engines refuse the file',
+          path: ['eventDefinitions', 0],
+          type: ERROR_TYPES.PROPERTY_REQUIRED,
+        },
+      },
+      {
+        name: 'message + an empty timer: the acting timer is parsed',
+        moddleElement: engineModel('c7', catchWith(MSG + EMPTY_TIMER), { roots: ROOTS }),
+        report: {
+          id: 'W',
+          message:
+            'Timer of intermediateCatchEvent:message W has no date, cycle or duration; the engines refuse the file',
+          path: ['eventDefinitions', 1],
+          type: ERROR_TYPES.PROPERTY_REQUIRED,
+        },
+      },
+      {
+        name: 'timer with timeDate and timeDuration',
+        moddleElement: engineModel('c7', catchWith(TWO_TIMES)),
+        report: {
+          id: 'W',
+          message:
+            'Timer event W has timeDate and timeDuration; the BPMN schema allows only one of timeDate, timeCycle and timeDuration, and the engines refuse the file',
+          path: ['eventDefinitions', 0],
+          type: ERROR_TYPES.ELEMENT_MULTIPLE_NOT_ALLOWED,
+        },
+      },
+      {
+        name: 'event sub-process start: message acts, an ignored timer with two time elements',
+        moddleElement: engineModel('c7', eventSubStart(MSG + TWO_TIMES), { roots: ROOTS }),
+        report: {
+          id: 'W',
+          message:
+            'The timer definition of startEvent:message W has timeDate and timeDuration; the BPMN schema allows only one of timeDate, timeCycle and timeDuration, and the engines refuse the file',
+          path: ['eventDefinitions', 1],
+          type: ERROR_TYPES.ELEMENT_MULTIPLE_NOT_ALLOWED,
+        },
+      },
+    ],
+  });
+});
diff --git a/test/adapters/out/bpmnlint/engine/rules/c7/C7TransactionNeedsStartEventRule.test.ts b/test/adapters/out/bpmnlint/engine/rules/c7/C7TransactionNeedsStartEventRule.test.ts
new file mode 100644
index 00000000..28a079f9
--- /dev/null
+++ b/test/adapters/out/bpmnlint/engine/rules/c7/C7TransactionNeedsStartEventRule.test.ts
@@ -0,0 +1,75 @@
+import { ERROR_TYPES } from 'bpmnlint-plugin-camunda-compat/rules/utils/error-types.js';
+import { describe } from 'vitest';
+import rule from '../../../../../../../src/adapters/out/bpmnlint/engine/rules/c7/C7TransactionNeedsStartEventRule.js';
+import { engineModel, verifyEngineRule } from '../../../../../../helpers/engine-model.js';
+
+describe('c7-transaction-needs-start-event', () => {
+  const MESSAGES = '<bpmn:message id="M1" name="Verify1" />';
+  const START = '<bpmn:startEvent id="Start" />';
+  const transaction = (inner: string) =>
+    `${START}<bpmn:transaction id="SP">${inner}</bpmn:transaction>`;
+  const WITH_START =
+    '<bpmn:startEvent id="SS" /><bpmn:userTask id="T" /><bpmn:endEvent id="SE" /><bpmn:sequenceFlow id="s1" sourceRef="SS" targetRef="T" /><bpmn:sequenceFlow id="s2" sourceRef="T" targetRef="SE" />';
+  const report = (what: string) => ({
+    id: 'SP',
+    message: `Transaction SP ${what}: it deploys, but every instance that reaches it fails ("No initial activity found for subprocess SP")`,
+    path: ['flowElements'],
+    type: ERROR_TYPES.CHILD_ELEMENT_OF_TYPE_REQUIRED,
+  });
+
+  verifyEngineRule(rule, {
+    valid: [
+      {
+        name: 'a transaction with a start event',
+        moddleElement: engineModel('c7', transaction(WITH_START)),
+      },
+      {
+        name: 'an embedded sub-process without start event (c7-scope-needs-start-event)',
+        moddleElement: engineModel(
+          'c7',
+          `${START}<bpmn:subProcess id="SP"><bpmn:userTask id="T" /></bpmn:subProcess>`,
+        ),
+      },
+      {
+        name: 'a transaction without start event in a non-executable process',
+        moddleElement: engineModel('c7', transaction('<bpmn:userTask id="T" />'), {
+          processAttributes: 'isExecutable="false"',
+        }),
+      },
+      {
+        name: 'a transaction without start event in an ad-hoc sub-process',
+        moddleElement: engineModel(
+          'c7',
+          `<bpmn:adHocSubProcess id="AH">${transaction('<bpmn:userTask id="T" />')}</bpmn:adHocSubProcess>`,
+        ),
+      },
+      {
+        name: 'a Camunda 8 diagram',
+        moddleElement: engineModel('c8', transaction('<bpmn:userTask id="T" />')),
+      },
+    ],
+    invalid: [
+      {
+        name: 'a transaction with a task but no start event',
+        moddleElement: engineModel('c7', transaction('<bpmn:userTask id="T" />')),
+        report: report('has no start event'),
+      },
+      {
+        name: 'an empty transaction',
+        moddleElement: engineModel('c7', `${START}<bpmn:transaction id="SP" />`),
+        report: report('is empty, without a start event'),
+      },
+      {
+        name: 'a transaction with only an event sub-process',
+        moddleElement: engineModel(
+          'c7',
+          transaction(
+            '<bpmn:subProcess id="ES" triggeredByEvent="true"><bpmn:startEvent id="ESS" isInterrupting="false"><bpmn:messageEventDefinition messageRef="M1" /></bpmn:startEvent><bpmn:endEvent id="ESE" /><bpmn:sequenceFlow id="e1" sourceRef="ESS" targetRef="ESE" /></bpmn:subProcess>',
+          ),
+          { roots: MESSAGES },
+        ),
+        report: report('has no start event'),
+      },
+    ],
+  });
+});
diff --git a/test/adapters/out/bpmnlint/engine/rules/c7/C7UserTaskPriorityValidRule.test.ts b/test/adapters/out/bpmnlint/engine/rules/c7/C7UserTaskPriorityValidRule.test.ts
new file mode 100644
index 00000000..e3bc0afb
--- /dev/null
+++ b/test/adapters/out/bpmnlint/engine/rules/c7/C7UserTaskPriorityValidRule.test.ts
@@ -0,0 +1,82 @@
+import { ERROR_TYPES } from 'bpmnlint-plugin-camunda-compat/rules/utils/error-types.js';
+import { describe } from 'vitest';
+import rule from '../../../../../../../src/adapters/out/bpmnlint/engine/rules/c7/C7UserTaskPriorityValidRule.js';
+import { engineModel, verifyEngineRule } from '../../../../../../helpers/engine-model.js';
+
+describe('c7-user-task-priority-valid', () => {
+  const conditional = (variableEvents: string) =>
+    `<bpmn:intermediateCatchEvent id="event_wait"><bpmn:conditionalEventDefinition camunda:variableEvents="${variableEvents}"><bpmn:condition xsi:type="bpmn:tFormalExpression">\${ready}</bpmn:condition></bpmn:conditionalEventDefinition></bpmn:intermediateCatchEvent>`;
+
+  verifyEngineRule(rule, {
+    valid: [
+      {
+        name: 'Camunda Modeler style values',
+        moddleElement: engineModel(
+          'c7',
+          `<bpmn:serviceTask id="serviceTask_a" camunda:type="external" camunda:topic="chargeCard" />
+          <bpmn:userTask id="userTask_b" camunda:priority="\${priority}" />
+          <bpmn:userTask id="userTask_c" camunda:priority="50" />
+          <bpmn:callActivity id="callActivity_d" calledElement="other" camunda:calledElementBinding="versionTag" camunda:calledElementVersionTag="1.0" camunda:caseBinding="deployment" />
+          <bpmn:businessRuleTask id="businessRuleTask_e" camunda:decisionRef="risk" camunda:decisionRefBinding="latest" />
+          ${conditional('create, update')}`,
+        ),
+      },
+      {
+        name: 'a missing version is c7-binding-needs-version, a missing calledElement c7-call-activity-one-called-element',
+        moddleElement: engineModel(
+          'c7',
+          `<bpmn:callActivity id="callActivity_d" calledElement="other" camunda:calledElementBinding="version" />
+          <bpmn:callActivity id="callActivity_e" />
+          <bpmn:callActivity id="callActivity_f" calledElement="" camunda:caseRef="case" />`,
+        ),
+      },
+      {
+        name: 'a decisionRefBinding without decisionRef is not read',
+        moddleElement: engineModel(
+          'c7',
+          '<bpmn:businessRuleTask id="businessRuleTask_e" camunda:class="org.example.Rule" camunda:decisionRefBinding="foo" />',
+        ),
+      },
+      {
+        name: 'a variable event on a definition the engines do not act on',
+        moddleElement: engineModel(
+          'c7',
+          `<bpmn:intermediateCatchEvent id="event_wait"><bpmn:timerEventDefinition><bpmn:timeDuration xsi:type="bpmn:tFormalExpression">PT1H</bpmn:timeDuration></bpmn:timerEventDefinition><bpmn:conditionalEventDefinition camunda:variableEvents="change"><bpmn:condition xsi:type="bpmn:tFormalExpression">\${ready}</bpmn:condition></bpmn:conditionalEventDefinition></bpmn:intermediateCatchEvent>`,
+        ),
+      },
+      {
+        name: 'a non-executable process',
+        moddleElement: engineModel(
+          'c7',
+          '<bpmn:userTask id="userTask_b" camunda:priority="high" />',
+          {
+            processAttributes: 'isExecutable="false"',
+          },
+        ),
+      },
+      {
+        name: 'a Camunda 8 diagram',
+        moddleElement: engineModel(
+          'c8',
+          '<bpmn:userTask id="userTask_b" camunda:priority="high" />',
+          {
+            definitionsAttributes: 'xmlns:camunda="http://camunda.org/schema/1.0/bpmn"',
+          },
+        ),
+      },
+    ],
+    invalid: [
+      {
+        name: 'a user task priority that is not a number or expression',
+        moddleElement: engineModel('c7', '<bpmn:userTask id="userTask_b" camunda:priority="high" />'),
+        report: {
+          id: 'userTask_b',
+          message:
+            'camunda:priority="high" on userTask userTask_b is not a number or expression; creating the task fails',
+          path: ['priority'],
+          type: ERROR_TYPES.PROPERTY_VALUE_NOT_ALLOWED,
+        },
+      },
+    ],
+  });
+});
diff --git a/test/adapters/out/bpmnlint/engine/rules/c7/C7VariableEventsKnownRule.test.ts b/test/adapters/out/bpmnlint/engine/rules/c7/C7VariableEventsKnownRule.test.ts
new file mode 100644
index 00000000..c8546377
--- /dev/null
+++ b/test/adapters/out/bpmnlint/engine/rules/c7/C7VariableEventsKnownRule.test.ts
@@ -0,0 +1,82 @@
+import { ERROR_TYPES } from 'bpmnlint-plugin-camunda-compat/rules/utils/error-types.js';
+import { describe } from 'vitest';
+import rule from '../../../../../../../src/adapters/out/bpmnlint/engine/rules/c7/C7VariableEventsKnownRule.js';
+import { engineModel, verifyEngineRule } from '../../../../../../helpers/engine-model.js';
+
+describe('c7-variable-events-known', () => {
+  const conditional = (variableEvents: string) =>
+    `<bpmn:intermediateCatchEvent id="event_wait"><bpmn:conditionalEventDefinition camunda:variableEvents="${variableEvents}"><bpmn:condition xsi:type="bpmn:tFormalExpression">\${ready}</bpmn:condition></bpmn:conditionalEventDefinition></bpmn:intermediateCatchEvent>`;
+
+  verifyEngineRule(rule, {
+    valid: [
+      {
+        name: 'Camunda Modeler style values',
+        moddleElement: engineModel(
+          'c7',
+          `<bpmn:serviceTask id="serviceTask_a" camunda:type="external" camunda:topic="chargeCard" />
+          <bpmn:userTask id="userTask_b" camunda:priority="\${priority}" />
+          <bpmn:userTask id="userTask_c" camunda:priority="50" />
+          <bpmn:callActivity id="callActivity_d" calledElement="other" camunda:calledElementBinding="versionTag" camunda:calledElementVersionTag="1.0" camunda:caseBinding="deployment" />
+          <bpmn:businessRuleTask id="businessRuleTask_e" camunda:decisionRef="risk" camunda:decisionRefBinding="latest" />
+          ${conditional('create, update')}`,
+        ),
+      },
+      {
+        name: 'a missing version is c7-binding-needs-version, a missing calledElement c7-call-activity-one-called-element',
+        moddleElement: engineModel(
+          'c7',
+          `<bpmn:callActivity id="callActivity_d" calledElement="other" camunda:calledElementBinding="version" />
+          <bpmn:callActivity id="callActivity_e" />
+          <bpmn:callActivity id="callActivity_f" calledElement="" camunda:caseRef="case" />`,
+        ),
+      },
+      {
+        name: 'a decisionRefBinding without decisionRef is not read',
+        moddleElement: engineModel(
+          'c7',
+          '<bpmn:businessRuleTask id="businessRuleTask_e" camunda:class="org.example.Rule" camunda:decisionRefBinding="foo" />',
+        ),
+      },
+      {
+        name: 'a variable event on a definition the engines do not act on',
+        moddleElement: engineModel(
+          'c7',
+          `<bpmn:intermediateCatchEvent id="event_wait"><bpmn:timerEventDefinition><bpmn:timeDuration xsi:type="bpmn:tFormalExpression">PT1H</bpmn:timeDuration></bpmn:timerEventDefinition><bpmn:conditionalEventDefinition camunda:variableEvents="change"><bpmn:condition xsi:type="bpmn:tFormalExpression">\${ready}</bpmn:condition></bpmn:conditionalEventDefinition></bpmn:intermediateCatchEvent>`,
+        ),
+      },
+      {
+        name: 'a non-executable process',
+        moddleElement: engineModel(
+          'c7',
+          '<bpmn:userTask id="userTask_b" camunda:priority="high" />',
+          {
+            processAttributes: 'isExecutable="false"',
+          },
+        ),
+      },
+      {
+        name: 'a Camunda 8 diagram',
+        moddleElement: engineModel(
+          'c8',
+          '<bpmn:userTask id="userTask_b" camunda:priority="high" />',
+          {
+            definitionsAttributes: 'xmlns:camunda="http://camunda.org/schema/1.0/bpmn"',
+          },
+        ),
+      },
+    ],
+    invalid: [
+      {
+        name: 'a variable event the engines do not know',
+        moddleElement: engineModel('c7', conditional('create, change')),
+        report: {
+          id: 'event_wait',
+          message:
+            'camunda:variableEvents="create, change" of intermediateCatchEvent:conditional event_wait lists change; only create, update, delete trigger the condition',
+          path: ['eventDefinitions', 0, 'variableEvents'],
+          type: ERROR_TYPES.PROPERTY_VALUE_NOT_ALLOWED,
+        },
+      },
+    ],
+  });
+});
diff --git a/test/adapters/out/bpmnlint/engine/rules/c8/C8AdHocSubProcessNoStartOrEndEventRule.test.ts b/test/adapters/out/bpmnlint/engine/rules/c8/C8AdHocSubProcessNoStartOrEndEventRule.test.ts
new file mode 100644
index 00000000..624d5862
--- /dev/null
+++ b/test/adapters/out/bpmnlint/engine/rules/c8/C8AdHocSubProcessNoStartOrEndEventRule.test.ts
@@ -0,0 +1,77 @@
+import { ERROR_TYPES } from 'bpmnlint-plugin-camunda-compat/rules/utils/error-types.js';
+import { describe } from 'vitest';
+import rule from '../../../../../../../src/adapters/out/bpmnlint/engine/rules/c8/C8AdHocSubProcessNoStartOrEndEventRule.js';
+import { engineModel, verifyEngineRule } from '../../../../../../helpers/engine-model.js';
+
+describe('c8-ad-hoc-sub-process-no-start-or-end-event', () => {
+  const chain = (...middle: string[]) => `
+    <bpmn:startEvent id="Start" />
+    <bpmn:sequenceFlow id="F1" sourceRef="Start" targetRef="X" />
+    ${middle.join('\n')}
+    <bpmn:sequenceFlow id="F2" sourceRef="X" targetRef="End" />
+    <bpmn:endEvent id="End" />`;
+  const WITH_START = chain(
+    '<bpmn:adHocSubProcess id="X"><bpmn:task id="A1" /><bpmn:startEvent id="AS" /></bpmn:adHocSubProcess>',
+  );
+
+  verifyEngineRule(rule, {
+    valid: [
+      {
+        name: 'an ad-hoc sub-process with activities only',
+        moddleElement: engineModel(
+          'c8',
+          chain(
+            '<bpmn:adHocSubProcess id="X"><bpmn:task id="A1" /><bpmn:serviceTask id="A2" /></bpmn:adHocSubProcess>',
+          ),
+        ),
+      },
+      {
+        name: 'an ad-hoc sub-process without activity (camunda-compat ad-hoc-sub-process)',
+        moddleElement: engineModel('c8', chain('<bpmn:adHocSubProcess id="X" />')),
+      },
+      {
+        name: 'a start event in an ad-hoc sub-process of a process that is not executable',
+        moddleElement: engineModel('c8', WITH_START, { processAttributes: 'isExecutable="false"' }),
+      },
+      { name: 'a Camunda 7 diagram', moddleElement: engineModel('c7', WITH_START) },
+    ],
+    invalid: [
+      {
+        name: 'an ad-hoc sub-process with a start event',
+        moddleElement: engineModel('c8', WITH_START),
+        report: {
+          id: 'X',
+          message:
+            'Ad-hoc sub-process X contains the start event AS; Camunda 8 refuses start and end events in ad-hoc sub-processes',
+          path: ['flowElements', 1],
+          type: ERROR_TYPES.ELEMENT_TYPE_NOT_ALLOWED,
+        },
+      },
+      {
+        name: 'an ad-hoc sub-process with a start and an end event',
+        moddleElement: engineModel(
+          'c8',
+          chain(
+            '<bpmn:adHocSubProcess id="X"><bpmn:startEvent id="AS" /><bpmn:task id="A1" /><bpmn:endEvent id="AE" /></bpmn:adHocSubProcess>',
+          ),
+        ),
+        report: [
+          {
+            id: 'X',
+            message:
+              'Ad-hoc sub-process X contains the start event AS; Camunda 8 refuses start and end events in ad-hoc sub-processes',
+            path: ['flowElements', 0],
+            type: ERROR_TYPES.ELEMENT_TYPE_NOT_ALLOWED,
+          },
+          {
+            id: 'X',
+            message:
+              'Ad-hoc sub-process X contains the end event AE; Camunda 8 refuses start and end events in ad-hoc sub-processes',
+            path: ['flowElements', 2],
+            type: ERROR_TYPES.ELEMENT_TYPE_NOT_ALLOWED,
+          },
+        ],
+      },
+    ],
+  });
+});
diff --git a/test/adapters/out/bpmnlint/engine/rules/c8/C8BindingTypeKnownRule.test.ts b/test/adapters/out/bpmnlint/engine/rules/c8/C8BindingTypeKnownRule.test.ts
new file mode 100644
index 00000000..5986ce00
--- /dev/null
+++ b/test/adapters/out/bpmnlint/engine/rules/c8/C8BindingTypeKnownRule.test.ts
@@ -0,0 +1,115 @@
+import { ERROR_TYPES } from 'bpmnlint-plugin-camunda-compat/rules/utils/error-types.js';
+import { describe } from 'vitest';
+import rule from '../../../../../../../src/adapters/out/bpmnlint/engine/rules/c8/C8BindingTypeKnownRule.js';
+import { engineModel, verifyEngineRule } from '../../../../../../helpers/engine-model.js';
+
+describe('c8-binding-type-known', () => {
+  const ext = (inner: string) => `<bpmn:extensionElements>${inner}</bpmn:extensionElements>`;
+  const SERVICE_TASK = (extra = '') =>
+    `<bpmn:serviceTask id="serviceTask_charge">${ext(`<zeebe:taskDefinition type="charge" />${extra}`)}</bpmn:serviceTask>`;
+  const HEADERS = (...keys: string[]) =>
+    `<zeebe:taskHeaders>${keys.map((key, index) => `<zeebe:header key="${key}" value="v${index}" />`).join('')}</zeebe:taskHeaders>`;
+  const CONDITIONAL = (filter: string) => `
+    <bpmn:intermediateCatchEvent id="event_stockChanged">
+      <bpmn:conditionalEventDefinition id="conditionalEventDefinition_stockChanged">
+        ${ext(filter)}
+        <bpmn:condition xsi:type="bpmn:tFormalExpression">= stock &gt; 0</bpmn:condition>
+      </bpmn:conditionalEventDefinition>
+    </bpmn:intermediateCatchEvent>`;
+
+  verifyEngineRule(rule, {
+    valid: [
+      {
+        name: 'every binding type, a version tag where it binds by version tag',
+        moddleElement: engineModel(
+          'c8',
+          `<bpmn:callActivity id="callActivity_ship">${ext('<zeebe:calledElement processId="ship" bindingType="deployment" />')}</bpmn:callActivity>
+          <bpmn:businessRuleTask id="businessRuleTask_rate">${ext('<zeebe:calledDecision decisionId="rate" resultVariable="rate" bindingType="latest" />')}</bpmn:businessRuleTask>
+          <bpmn:userTask id="userTask_review">${ext('<zeebe:userTask /><zeebe:formDefinition formId="review" bindingType="versionTag" versionTag="v1" />')}</bpmn:userTask>`,
+        ),
+      },
+      {
+        name: 'a version tag binding without version tag on a business rule task (camunda-compat reports it)',
+        moddleElement: engineModel(
+          'c8',
+          `<bpmn:businessRuleTask id="businessRuleTask_rate">${ext('<zeebe:calledDecision decisionId="rate" resultVariable="rate" bindingType="versionTag" />')}</bpmn:businessRuleTask>`,
+        ),
+      },
+      {
+        name: 'a complete linked resource, variable events create and update',
+        moddleElement: engineModel(
+          'c8',
+          `${SERVICE_TASK('<zeebe:linkedResources><zeebe:linkedResource resourceId="r" resourceType="RPA" linkName="robot" bindingType="versionTag" versionTag="v1" /></zeebe:linkedResources>')}
+          ${CONDITIONAL('<zeebe:conditionalFilter variableNames="stock" variableEvents="create, update" />')}`,
+        ),
+      },
+      {
+        name: 'a task header key twice in the first header list (camunda-compat reports it)',
+        moddleElement: engineModel('c8', SERVICE_TASK(HEADERS('region', 'region'))),
+      },
+      {
+        name: 'mappings without target or source (camunda-compat reports them)',
+        moddleElement: engineModel(
+          'c8',
+          SERVICE_TASK(
+            '<zeebe:ioMapping><zeebe:input source="=a" /><zeebe:input source="=a" target=" " /><zeebe:output source="=a" target="1x" /><zeebe:output target="a" /></zeebe:ioMapping>',
+          ),
+        ),
+      },
+      {
+        name: 'an unknown binding type in a non-executable process',
+        moddleElement: engineModel(
+          'c8',
+          `<bpmn:callActivity id="callActivity_ship">${ext('<zeebe:calledElement processId="ship" bindingType="foo" />')}</bpmn:callActivity>`,
+          { processAttributes: 'isExecutable="false"' },
+        ),
+      },
+      {
+        name: 'a linked resource on a user task (c8-zeebe-extension-placement reports it)',
+        moddleElement: engineModel(
+          'c8',
+          `<bpmn:userTask id="userTask_review">${ext('<zeebe:userTask /><zeebe:linkedResources><zeebe:linkedResource resourceId="r" /></zeebe:linkedResources>')}</bpmn:userTask>`,
+        ),
+      },
+      {
+        name: 'a Camunda 7 diagram',
+        moddleElement: engineModel(
+          'c7',
+          '<bpmn:callActivity id="callActivity_ship" calledElement="ship" camunda:calledElementBinding="foo" />',
+        ),
+      },
+    ],
+    invalid: [
+      {
+        name: 'an unknown binding type',
+        moddleElement: engineModel(
+          'c8',
+          `<bpmn:callActivity id="callActivity_ship">${ext('<zeebe:calledElement processId="ship" bindingType="foo" />')}</bpmn:callActivity>`,
+        ),
+        report: {
+          id: 'callActivity_ship',
+          message:
+            'zeebe:calledElement of callActivity callActivity_ship has bindingType="foo"; Camunda 8 accepts deployment, latest, versionTag only and refuses the file',
+          path: ['extensionElements', 'values', 0, 'bindingType'],
+          type: ERROR_TYPES.PROPERTY_VALUE_NOT_ALLOWED,
+        },
+      },
+      {
+        name: 'linked resources with an unknown binding type and without version tag',
+        moddleElement: engineModel(
+          'c8',
+          SERVICE_TASK(
+            '<zeebe:linkedResources><zeebe:linkedResource resourceId="r" resourceType="RPA" bindingType="foo" /><zeebe:linkedResource resourceId="s" resourceType="RPA" bindingType="versionTag" /></zeebe:linkedResources>',
+          ),
+        ),
+        report: {
+            id: 'serviceTask_charge',
+            message:
+              'Linked resource 1 of serviceTask serviceTask_charge has bindingType="foo"; Camunda 8 accepts deployment, latest, versionTag only and refuses the file',
+            path: ['extensionElements', 'values', 1, 'values', 0, 'bindingType'],
+            type: ERROR_TYPES.PROPERTY_VALUE_NOT_ALLOWED,
+          },
+      },
+    ],
+  });
+});
diff --git a/test/adapters/out/bpmnlint/engine/rules/c8/C8CompensationBoundaryNeedsAssociationRule.test.ts b/test/adapters/out/bpmnlint/engine/rules/c8/C8CompensationBoundaryNeedsAssociationRule.test.ts
new file mode 100644
index 00000000..af64d6d8
--- /dev/null
+++ b/test/adapters/out/bpmnlint/engine/rules/c8/C8CompensationBoundaryNeedsAssociationRule.test.ts
@@ -0,0 +1,149 @@
+import { ERROR_TYPES } from 'bpmnlint-plugin-camunda-compat/rules/utils/error-types.js';
+import { describe } from 'vitest';
+import rule from '../../../../../../../src/adapters/out/bpmnlint/engine/rules/c8/C8CompensationBoundaryNeedsAssociationRule.js';
+import { engineModel, verifyEngineRule } from '../../../../../../helpers/engine-model.js';
+
+describe('c8-compensation-boundary-needs-association', () => {
+  const TIMER =
+    '<bpmn:timerEventDefinition id="timer_X"><bpmn:timeDuration xsi:type="bpmn:tFormalExpression">PT1H</bpmn:timeDuration></bpmn:timerEventDefinition>';
+  const MESSAGE = '<bpmn:message id="M1" name="M1" />';
+  const CONDITION = '<bpmn:condition xsi:type="bpmn:tFormalExpression">= x &gt; 1</bpmn:condition>';
+  const chain = (middle: string, extra = '') => `
+    <bpmn:startEvent id="Start" />
+    <bpmn:sequenceFlow id="F1" sourceRef="Start" targetRef="X" />
+    ${middle}
+    <bpmn:sequenceFlow id="F2" sourceRef="X" targetRef="End" />
+    <bpmn:endEvent id="End" />
+    ${extra}`;
+  const eventSubProcess = (start: string) => `
+    <bpmn:startEvent id="Start" />
+    <bpmn:sequenceFlow id="F1" sourceRef="Start" targetRef="End" />
+    <bpmn:endEvent id="End" />
+    <bpmn:subProcess id="ESP" triggeredByEvent="true">
+      ${start}
+      <bpmn:sequenceFlow id="ESP_F" sourceRef="ESP_S" targetRef="ESP_E" />
+      <bpmn:endEvent id="ESP_E" />
+    </bpmn:subProcess>`;
+  const COMPENSATION = (
+    boundaryDefinition = '<bpmn:compensateEventDefinition id="CB" />',
+    throwDefinition = '<bpmn:compensateEventDefinition id="CT" />',
+    association = true,
+    boundaryFlow = '',
+  ) => `
+    <bpmn:startEvent id="Start" />
+    <bpmn:sequenceFlow id="F1" sourceRef="Start" targetRef="X" />
+    <bpmn:serviceTask id="X" />
+    <bpmn:boundaryEvent id="B" attachedToRef="X">${boundaryDefinition}</bpmn:boundaryEvent>
+    <bpmn:serviceTask id="H" isForCompensation="true" />
+    <bpmn:sequenceFlow id="F2" sourceRef="X" targetRef="T" />
+    <bpmn:intermediateThrowEvent id="T">${throwDefinition}</bpmn:intermediateThrowEvent>
+    <bpmn:sequenceFlow id="F3" sourceRef="T" targetRef="End" />
+    <bpmn:endEvent id="End" />
+    ${boundaryFlow}
+    ${association ? '<bpmn:association id="A" associationDirection="One" sourceRef="B" targetRef="H" />' : ''}`;
+  const LINKS = (throwDefinition: string, catchDefinition: string) => `
+    <bpmn:startEvent id="Start" />
+    <bpmn:sequenceFlow id="F1" sourceRef="Start" targetRef="X" />
+    <bpmn:intermediateThrowEvent id="X">${throwDefinition}</bpmn:intermediateThrowEvent>
+    <bpmn:intermediateCatchEvent id="C">${catchDefinition}</bpmn:intermediateCatchEvent>
+    <bpmn:sequenceFlow id="FC" sourceRef="C" targetRef="End" />
+    <bpmn:endEvent id="End" />`;
+  const TWO_DEFINITIONS = chain(
+    `<bpmn:intermediateCatchEvent id="X">${TIMER}<bpmn:messageEventDefinition id="MD" messageRef="M1" /></bpmn:intermediateCatchEvent>`,
+  );
+
+  verifyEngineRule(rule, {
+    valid: [
+      {
+        name: 'an event sub-process with a message start event',
+        moddleElement: engineModel(
+          'c8',
+          eventSubProcess(
+            '<bpmn:startEvent id="ESP_S"><bpmn:messageEventDefinition id="MD" messageRef="M1" /></bpmn:startEvent>',
+          ),
+          { roots: MESSAGE },
+        ),
+      },
+      {
+        name: 'conditional events with definition ids',
+        moddleElement: engineModel(
+          'c8',
+          chain(
+            `<bpmn:intermediateCatchEvent id="X"><bpmn:conditionalEventDefinition id="CD1">${CONDITION}</bpmn:conditionalEventDefinition></bpmn:intermediateCatchEvent>`,
+          ),
+        ),
+      },
+      { name: 'compensation with definition ids', moddleElement: engineModel('c8', COMPENSATION()) },
+      {
+        name: 'a link pair with definition ids',
+        moddleElement: engineModel(
+          'c8',
+          LINKS(
+            '<bpmn:linkEventDefinition id="L1" name="L" />',
+            '<bpmn:linkEventDefinition id="L2" name="L" />',
+          ),
+        ),
+      },
+      {
+        name: 'a link throw definition without id',
+        moddleElement: engineModel(
+          'c8',
+          LINKS(
+            '<bpmn:linkEventDefinition name="L" />',
+            '<bpmn:linkEventDefinition id="L2" name="L" />',
+          ),
+        ),
+      },
+      {
+        name: 'catch and boundary events without definition (camunda-compat element-type)',
+        moddleElement: engineModel(
+          'c8',
+          chain(
+            '<bpmn:intermediateCatchEvent id="X" />',
+            '<bpmn:task id="Y" /><bpmn:boundaryEvent id="B" attachedToRef="Y" />',
+          ),
+        ),
+      },
+      {
+        name: 'an event sub-process start with a compensation trigger (camunda-compat element-type)',
+        moddleElement: engineModel(
+          'c8',
+          eventSubProcess(
+            '<bpmn:startEvent id="ESP_S"><bpmn:compensateEventDefinition /></bpmn:startEvent>',
+          ),
+        ),
+      },
+      {
+        name: 'two definitions in a process that is not executable',
+        moddleElement: engineModel('c8', TWO_DEFINITIONS, {
+          roots: MESSAGE,
+          processAttributes: 'isExecutable="false"',
+        }),
+      },
+      {
+        name: 'two definitions inside a transaction',
+        moddleElement: engineModel(
+          'c8',
+          `<bpmn:transaction id="TX"><bpmn:intermediateCatchEvent id="X">${TIMER}<bpmn:messageEventDefinition id="MD" messageRef="M1" /></bpmn:intermediateCatchEvent></bpmn:transaction>`,
+          { roots: MESSAGE },
+        ),
+      },
+      {
+        name: 'a Camunda 7 diagram',
+        moddleElement: engineModel('c7', TWO_DEFINITIONS, { roots: MESSAGE }),
+      },
+    ],
+    invalid: [
+      {
+        name: 'a compensation boundary event without handler',
+        moddleElement: engineModel('c8', COMPENSATION(undefined, undefined, false)),
+        report: {
+          id: 'B',
+          message:
+            'Compensation boundary event B has no association to a compensation handler; Camunda 8 refuses the file',
+          type: ERROR_TYPES.CHILD_ELEMENT_OF_TYPE_REQUIRED,
+        },
+      },
+    ],
+  });
+});
diff --git a/test/adapters/out/bpmnlint/engine/rules/c8/C8CompensationBoundaryNoOutgoingFlowRule.test.ts b/test/adapters/out/bpmnlint/engine/rules/c8/C8CompensationBoundaryNoOutgoingFlowRule.test.ts
new file mode 100644
index 00000000..674cb558
--- /dev/null
+++ b/test/adapters/out/bpmnlint/engine/rules/c8/C8CompensationBoundaryNoOutgoingFlowRule.test.ts
@@ -0,0 +1,158 @@
+import { ERROR_TYPES } from 'bpmnlint-plugin-camunda-compat/rules/utils/error-types.js';
+import { describe } from 'vitest';
+import rule from '../../../../../../../src/adapters/out/bpmnlint/engine/rules/c8/C8CompensationBoundaryNoOutgoingFlowRule.js';
+import { engineModel, verifyEngineRule } from '../../../../../../helpers/engine-model.js';
+
+describe('c8-compensation-boundary-no-outgoing-flow', () => {
+  const TIMER =
+    '<bpmn:timerEventDefinition id="timer_X"><bpmn:timeDuration xsi:type="bpmn:tFormalExpression">PT1H</bpmn:timeDuration></bpmn:timerEventDefinition>';
+  const MESSAGE = '<bpmn:message id="M1" name="M1" />';
+  const CONDITION = '<bpmn:condition xsi:type="bpmn:tFormalExpression">= x &gt; 1</bpmn:condition>';
+  const chain = (middle: string, extra = '') => `
+    <bpmn:startEvent id="Start" />
+    <bpmn:sequenceFlow id="F1" sourceRef="Start" targetRef="X" />
+    ${middle}
+    <bpmn:sequenceFlow id="F2" sourceRef="X" targetRef="End" />
+    <bpmn:endEvent id="End" />
+    ${extra}`;
+  const eventSubProcess = (start: string) => `
+    <bpmn:startEvent id="Start" />
+    <bpmn:sequenceFlow id="F1" sourceRef="Start" targetRef="End" />
+    <bpmn:endEvent id="End" />
+    <bpmn:subProcess id="ESP" triggeredByEvent="true">
+      ${start}
+      <bpmn:sequenceFlow id="ESP_F" sourceRef="ESP_S" targetRef="ESP_E" />
+      <bpmn:endEvent id="ESP_E" />
+    </bpmn:subProcess>`;
+  const COMPENSATION = (
+    boundaryDefinition = '<bpmn:compensateEventDefinition id="CB" />',
+    throwDefinition = '<bpmn:compensateEventDefinition id="CT" />',
+    association = true,
+    boundaryFlow = '',
+  ) => `
+    <bpmn:startEvent id="Start" />
+    <bpmn:sequenceFlow id="F1" sourceRef="Start" targetRef="X" />
+    <bpmn:serviceTask id="X" />
+    <bpmn:boundaryEvent id="B" attachedToRef="X">${boundaryDefinition}</bpmn:boundaryEvent>
+    <bpmn:serviceTask id="H" isForCompensation="true" />
+    <bpmn:sequenceFlow id="F2" sourceRef="X" targetRef="T" />
+    <bpmn:intermediateThrowEvent id="T">${throwDefinition}</bpmn:intermediateThrowEvent>
+    <bpmn:sequenceFlow id="F3" sourceRef="T" targetRef="End" />
+    <bpmn:endEvent id="End" />
+    ${boundaryFlow}
+    ${association ? '<bpmn:association id="A" associationDirection="One" sourceRef="B" targetRef="H" />' : ''}`;
+  const LINKS = (throwDefinition: string, catchDefinition: string) => `
+    <bpmn:startEvent id="Start" />
+    <bpmn:sequenceFlow id="F1" sourceRef="Start" targetRef="X" />
+    <bpmn:intermediateThrowEvent id="X">${throwDefinition}</bpmn:intermediateThrowEvent>
+    <bpmn:intermediateCatchEvent id="C">${catchDefinition}</bpmn:intermediateCatchEvent>
+    <bpmn:sequenceFlow id="FC" sourceRef="C" targetRef="End" />
+    <bpmn:endEvent id="End" />`;
+  const TWO_DEFINITIONS = chain(
+    `<bpmn:intermediateCatchEvent id="X">${TIMER}<bpmn:messageEventDefinition id="MD" messageRef="M1" /></bpmn:intermediateCatchEvent>`,
+  );
+
+  verifyEngineRule(rule, {
+    valid: [
+      {
+        name: 'an event sub-process with a message start event',
+        moddleElement: engineModel(
+          'c8',
+          eventSubProcess(
+            '<bpmn:startEvent id="ESP_S"><bpmn:messageEventDefinition id="MD" messageRef="M1" /></bpmn:startEvent>',
+          ),
+          { roots: MESSAGE },
+        ),
+      },
+      {
+        name: 'conditional events with definition ids',
+        moddleElement: engineModel(
+          'c8',
+          chain(
+            `<bpmn:intermediateCatchEvent id="X"><bpmn:conditionalEventDefinition id="CD1">${CONDITION}</bpmn:conditionalEventDefinition></bpmn:intermediateCatchEvent>`,
+          ),
+        ),
+      },
+      { name: 'compensation with definition ids', moddleElement: engineModel('c8', COMPENSATION()) },
+      {
+        name: 'a link pair with definition ids',
+        moddleElement: engineModel(
+          'c8',
+          LINKS(
+            '<bpmn:linkEventDefinition id="L1" name="L" />',
+            '<bpmn:linkEventDefinition id="L2" name="L" />',
+          ),
+        ),
+      },
+      {
+        name: 'a link throw definition without id',
+        moddleElement: engineModel(
+          'c8',
+          LINKS(
+            '<bpmn:linkEventDefinition name="L" />',
+            '<bpmn:linkEventDefinition id="L2" name="L" />',
+          ),
+        ),
+      },
+      {
+        name: 'catch and boundary events without definition (camunda-compat element-type)',
+        moddleElement: engineModel(
+          'c8',
+          chain(
+            '<bpmn:intermediateCatchEvent id="X" />',
+            '<bpmn:task id="Y" /><bpmn:boundaryEvent id="B" attachedToRef="Y" />',
+          ),
+        ),
+      },
+      {
+        name: 'an event sub-process start with a compensation trigger (camunda-compat element-type)',
+        moddleElement: engineModel(
+          'c8',
+          eventSubProcess(
+            '<bpmn:startEvent id="ESP_S"><bpmn:compensateEventDefinition /></bpmn:startEvent>',
+          ),
+        ),
+      },
+      {
+        name: 'two definitions in a process that is not executable',
+        moddleElement: engineModel('c8', TWO_DEFINITIONS, {
+          roots: MESSAGE,
+          processAttributes: 'isExecutable="false"',
+        }),
+      },
+      {
+        name: 'two definitions inside a transaction',
+        moddleElement: engineModel(
+          'c8',
+          `<bpmn:transaction id="TX"><bpmn:intermediateCatchEvent id="X">${TIMER}<bpmn:messageEventDefinition id="MD" messageRef="M1" /></bpmn:intermediateCatchEvent></bpmn:transaction>`,
+          { roots: MESSAGE },
+        ),
+      },
+      {
+        name: 'a Camunda 7 diagram',
+        moddleElement: engineModel('c7', TWO_DEFINITIONS, { roots: MESSAGE }),
+      },
+    ],
+    invalid: [
+      {
+        name: 'a compensation boundary event with an outgoing sequence flow',
+        moddleElement: engineModel(
+          'c8',
+          COMPENSATION(
+            undefined,
+            undefined,
+            true,
+            '<bpmn:sequenceFlow id="F4" sourceRef="B" targetRef="End" />',
+          ),
+        ),
+        report: {
+          id: 'B',
+          message:
+            'Compensation boundary event B has an outgoing sequence flow; Camunda 8 refuses the file',
+          path: ['outgoing'],
+          type: ERROR_TYPES.PROPERTY_NOT_ALLOWED,
+        },
+      },
+    ],
+  });
+});
diff --git a/test/adapters/out/bpmnlint/engine/rules/c8/C8CompensationNamesOwnActivityRule.test.ts b/test/adapters/out/bpmnlint/engine/rules/c8/C8CompensationNamesOwnActivityRule.test.ts
new file mode 100644
index 00000000..06600c57
--- /dev/null
+++ b/test/adapters/out/bpmnlint/engine/rules/c8/C8CompensationNamesOwnActivityRule.test.ts
@@ -0,0 +1,158 @@
+import { ERROR_TYPES } from 'bpmnlint-plugin-camunda-compat/rules/utils/error-types.js';
+import { describe } from 'vitest';
+import rule from '../../../../../../../src/adapters/out/bpmnlint/engine/rules/c8/C8CompensationNamesOwnActivityRule.js';
+import { engineModel, verifyEngineRule } from '../../../../../../helpers/engine-model.js';
+
+describe('c8-compensation-names-own-activity', () => {
+  const TIMER =
+    '<bpmn:timerEventDefinition id="timer_X"><bpmn:timeDuration xsi:type="bpmn:tFormalExpression">PT1H</bpmn:timeDuration></bpmn:timerEventDefinition>';
+  const MESSAGE = '<bpmn:message id="M1" name="M1" />';
+  const CONDITION = '<bpmn:condition xsi:type="bpmn:tFormalExpression">= x &gt; 1</bpmn:condition>';
+  const chain = (middle: string, extra = '') => `
+    <bpmn:startEvent id="Start" />
+    <bpmn:sequenceFlow id="F1" sourceRef="Start" targetRef="X" />
+    ${middle}
+    <bpmn:sequenceFlow id="F2" sourceRef="X" targetRef="End" />
+    <bpmn:endEvent id="End" />
+    ${extra}`;
+  const eventSubProcess = (start: string) => `
+    <bpmn:startEvent id="Start" />
+    <bpmn:sequenceFlow id="F1" sourceRef="Start" targetRef="End" />
+    <bpmn:endEvent id="End" />
+    <bpmn:subProcess id="ESP" triggeredByEvent="true">
+      ${start}
+      <bpmn:sequenceFlow id="ESP_F" sourceRef="ESP_S" targetRef="ESP_E" />
+      <bpmn:endEvent id="ESP_E" />
+    </bpmn:subProcess>`;
+  const COMPENSATION = (
+    boundaryDefinition = '<bpmn:compensateEventDefinition id="CB" />',
+    throwDefinition = '<bpmn:compensateEventDefinition id="CT" />',
+    association = true,
+    boundaryFlow = '',
+  ) => `
+    <bpmn:startEvent id="Start" />
+    <bpmn:sequenceFlow id="F1" sourceRef="Start" targetRef="X" />
+    <bpmn:serviceTask id="X" />
+    <bpmn:boundaryEvent id="B" attachedToRef="X">${boundaryDefinition}</bpmn:boundaryEvent>
+    <bpmn:serviceTask id="H" isForCompensation="true" />
+    <bpmn:sequenceFlow id="F2" sourceRef="X" targetRef="T" />
+    <bpmn:intermediateThrowEvent id="T">${throwDefinition}</bpmn:intermediateThrowEvent>
+    <bpmn:sequenceFlow id="F3" sourceRef="T" targetRef="End" />
+    <bpmn:endEvent id="End" />
+    ${boundaryFlow}
+    ${association ? '<bpmn:association id="A" associationDirection="One" sourceRef="B" targetRef="H" />' : ''}`;
+  const LINKS = (throwDefinition: string, catchDefinition: string) => `
+    <bpmn:startEvent id="Start" />
+    <bpmn:sequenceFlow id="F1" sourceRef="Start" targetRef="X" />
+    <bpmn:intermediateThrowEvent id="X">${throwDefinition}</bpmn:intermediateThrowEvent>
+    <bpmn:intermediateCatchEvent id="C">${catchDefinition}</bpmn:intermediateCatchEvent>
+    <bpmn:sequenceFlow id="FC" sourceRef="C" targetRef="End" />
+    <bpmn:endEvent id="End" />`;
+  const TWO_DEFINITIONS = chain(
+    `<bpmn:intermediateCatchEvent id="X">${TIMER}<bpmn:messageEventDefinition id="MD" messageRef="M1" /></bpmn:intermediateCatchEvent>`,
+  );
+
+  verifyEngineRule(rule, {
+    valid: [
+      {
+        name: 'an event sub-process with a message start event',
+        moddleElement: engineModel(
+          'c8',
+          eventSubProcess(
+            '<bpmn:startEvent id="ESP_S"><bpmn:messageEventDefinition id="MD" messageRef="M1" /></bpmn:startEvent>',
+          ),
+          { roots: MESSAGE },
+        ),
+      },
+      {
+        name: 'conditional events with definition ids',
+        moddleElement: engineModel(
+          'c8',
+          chain(
+            `<bpmn:intermediateCatchEvent id="X"><bpmn:conditionalEventDefinition id="CD1">${CONDITION}</bpmn:conditionalEventDefinition></bpmn:intermediateCatchEvent>`,
+          ),
+        ),
+      },
+      { name: 'compensation with definition ids', moddleElement: engineModel('c8', COMPENSATION()) },
+      {
+        name: 'a link pair with definition ids',
+        moddleElement: engineModel(
+          'c8',
+          LINKS(
+            '<bpmn:linkEventDefinition id="L1" name="L" />',
+            '<bpmn:linkEventDefinition id="L2" name="L" />',
+          ),
+        ),
+      },
+      {
+        name: 'a link throw definition without id',
+        moddleElement: engineModel(
+          'c8',
+          LINKS(
+            '<bpmn:linkEventDefinition name="L" />',
+            '<bpmn:linkEventDefinition id="L2" name="L" />',
+          ),
+        ),
+      },
+      {
+        name: 'catch and boundary events without definition (camunda-compat element-type)',
+        moddleElement: engineModel(
+          'c8',
+          chain(
+            '<bpmn:intermediateCatchEvent id="X" />',
+            '<bpmn:task id="Y" /><bpmn:boundaryEvent id="B" attachedToRef="Y" />',
+          ),
+        ),
+      },
+      {
+        name: 'an event sub-process start with a compensation trigger (camunda-compat element-type)',
+        moddleElement: engineModel(
+          'c8',
+          eventSubProcess(
+            '<bpmn:startEvent id="ESP_S"><bpmn:compensateEventDefinition /></bpmn:startEvent>',
+          ),
+        ),
+      },
+      {
+        name: 'two definitions in a process that is not executable',
+        moddleElement: engineModel('c8', TWO_DEFINITIONS, {
+          roots: MESSAGE,
+          processAttributes: 'isExecutable="false"',
+        }),
+      },
+      {
+        name: 'two definitions inside a transaction',
+        moddleElement: engineModel(
+          'c8',
+          `<bpmn:transaction id="TX"><bpmn:intermediateCatchEvent id="X">${TIMER}<bpmn:messageEventDefinition id="MD" messageRef="M1" /></bpmn:intermediateCatchEvent></bpmn:transaction>`,
+          { roots: MESSAGE },
+        ),
+      },
+      {
+        name: 'a Camunda 7 diagram',
+        moddleElement: engineModel('c7', TWO_DEFINITIONS, { roots: MESSAGE }),
+      },
+    ],
+    invalid: [
+      {
+        name: 'a compensation throw event naming an activity of another scope',
+        moddleElement: engineModel(
+          'c8',
+          COMPENSATION(
+            undefined,
+            '<bpmn:compensateEventDefinition id="CT" activityRef="Inner" />',
+            true,
+            '<bpmn:subProcess id="Sub"><bpmn:task id="Inner" /></bpmn:subProcess>',
+          ),
+        ),
+        report: {
+          id: 'T',
+          message:
+            'Compensation event T names Inner, which is not in its own scope process_test; Camunda 8 refuses the file',
+          path: ['eventDefinitions', 0, 'activityRef'],
+          type: ERROR_TYPES.PROPERTY_VALUE_NOT_ALLOWED,
+        },
+      },
+    ],
+  });
+});
diff --git a/test/adapters/out/bpmnlint/engine/rules/c8/C8ConditionNeedsFeelRule.test.ts b/test/adapters/out/bpmnlint/engine/rules/c8/C8ConditionNeedsFeelRule.test.ts
new file mode 100644
index 00000000..74a3892f
--- /dev/null
+++ b/test/adapters/out/bpmnlint/engine/rules/c8/C8ConditionNeedsFeelRule.test.ts
@@ -0,0 +1,237 @@
+import { ERROR_TYPES } from 'bpmnlint-plugin-camunda-compat/rules/utils/error-types.js';
+import rule from '../../../../../../../src/adapters/out/bpmnlint/engine/rules/c8/C8ConditionNeedsFeelRule.js';
+import { engineModel, verifyEngineRule } from '../../../../../../helpers/engine-model.js';
+
+const BAD = '= (a';
+const REFUSED = 'Camunda 8 parses it at deploy and refuses the file';
+const NEEDS_FEEL = 'Camunda 8 needs one starting with = and refuses the file';
+const ext = (inner: string) => `<bpmn:extensionElements>${inner}</bpmn:extensionElements>`;
+const JOB = '<zeebe:taskDefinition type="work" />';
+const escape = (text: string) =>
+  text.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;');
+const chain = (middle: string) => `
+  <bpmn:startEvent id="startEvent_start" />
+  <bpmn:sequenceFlow id="flow_toX" sourceRef="startEvent_start" targetRef="X" />
+  ${middle}
+  <bpmn:sequenceFlow id="flow_fromX" sourceRef="X" targetRef="endEvent_end" />
+  <bpmn:endEvent id="endEvent_end" />`;
+const gateway = (condition: string) => `
+  <bpmn:startEvent id="startEvent_start" />
+  <bpmn:sequenceFlow id="flow_toGateway" sourceRef="startEvent_start" targetRef="G" />
+  <bpmn:exclusiveGateway id="G" default="SD" />
+  <bpmn:sequenceFlow id="SD" sourceRef="G" targetRef="endEvent_default" />
+  <bpmn:endEvent id="endEvent_default" />
+  <bpmn:sequenceFlow id="S0" sourceRef="G" targetRef="endEvent_s0">
+    <bpmn:conditionExpression xsi:type="bpmn:tFormalExpression">${escape(condition)}</bpmn:conditionExpression>
+  </bpmn:sequenceFlow>
+  <bpmn:endEvent id="endEvent_s0" />`;
+const adHoc = (inner: string, zeebe = '') =>
+  chain(
+    `<bpmn:adHocSubProcess id="X">${zeebe ? ext(zeebe) : ''}<bpmn:task id="A1" />${inner}</bpmn:adHocSubProcess>`,
+  );
+const completion = (body: string) =>
+  `<bpmn:completionCondition xsi:type="bpmn:tFormalExpression">${escape(body)}</bpmn:completionCondition>`;
+const multiInstance = (zeebeLoop: string, inner = '') =>
+  chain(
+    `<bpmn:serviceTask id="X">${ext(JOB)}<bpmn:multiInstanceLoopCharacteristics>${ext(zeebeLoop)}${inner}</bpmn:multiInstanceLoopCharacteristics></bpmn:serviceTask>`,
+  );
+const timer = (kind: string, value: string) =>
+  `<bpmn:timerEventDefinition id="TD1"><bpmn:${kind} xsi:type="bpmn:tFormalExpression">${escape(value)}</bpmn:${kind}></bpmn:timerEventDefinition>`;
+const conditional = (condition: string) =>
+  `<bpmn:conditionalEventDefinition id="CD1"><bpmn:condition xsi:type="bpmn:tFormalExpression">${escape(condition)}</bpmn:condition></bpmn:conditionalEventDefinition>`;
+const message = (name: string, key: string | null = '=orderId') =>
+  `<bpmn:message id="M1" name="${escape(name)}">${key === null ? '' : ext(`<zeebe:subscription correlationKey="${escape(key)}" />`)}</bpmn:message>`;
+const feel = (
+  id: string,
+  what: string,
+  value: string,
+  problem: string,
+  path: (string | number)[],
+) => ({
+  id,
+  message: `${what} "${value}" is no valid FEEL: ${problem}; ${REFUSED}`,
+  path,
+  type: ERROR_TYPES.FEEL_EXPRESSION_INVALID,
+});
+const notFeel = (id: string, message: string, path: (string | number)[]) => ({
+  id,
+  message,
+  path,
+  type: ERROR_TYPES.EXPRESSION_REQUIRED,
+});
+
+verifyEngineRule(rule, {
+  valid: [
+    ...[
+      '= x andy',
+      '= x in [1..5]',
+      '= x in (> 1, < 5)',
+      '= {a: 1}.a = 1',
+      '= string length(x) > 2',
+    ].map((condition) => ({
+      name: `a condition FEEL accepts: ${condition}`,
+      moddleElement: engineModel('c8', gateway(condition)),
+    })),
+    {
+      name: 'a FEEL completion condition of an ad-hoc sub-process',
+      moddleElement: engineModel('c8', adHoc(completion('= a and b'))),
+    },
+    {
+      name: 'attributes Camunda 8 does not parse at deploy (listener type, header value)',
+      moddleElement: engineModel(
+        'c8',
+        chain(
+          `<bpmn:serviceTask id="X">${ext(`${JOB}<zeebe:taskHeaders><zeebe:header key="k" value="${BAD}" /></zeebe:taskHeaders><zeebe:executionListeners><zeebe:executionListener eventType="end" type="${BAD}" /></zeebe:executionListeners>`)}</bpmn:serviceTask>`,
+        ),
+      ),
+    },
+    {
+      name: 'a FEEL timer value',
+      moddleElement: engineModel(
+        'c8',
+        chain(
+          `<bpmn:intermediateCatchEvent id="X">${timer('timeDuration', '=wait')}</bpmn:intermediateCatchEvent>`,
+        ),
+      ),
+    },
+    {
+      name: 'FEEL values in the multi-instance and the script',
+      moddleElement: engineModel(
+        'c8',
+        multiInstance(
+          '<zeebe:loopCharacteristics inputCollection="=items" outputCollection="out" outputElement="=result" />',
+          completion('= done'),
+        ) +
+          `<bpmn:scriptTask id="Y">${ext('<zeebe:script expression="=1 + 1" resultVariable="r" />')}</bpmn:scriptTask>`,
+      ),
+    },
+    {
+      name: 'a multi-instance completion condition that is no FEEL (a runtime matter, c8-multi-instance-completion-needs-feel)',
+      moddleElement: engineModel(
+        'c8',
+        multiInstance(
+          '<zeebe:loopCharacteristics inputCollection="=items" />',
+          completion('${done}'),
+        ),
+      ),
+    },
+    {
+      name: 'a JUEL condition in a process that is not executable',
+      moddleElement: engineModel('c8', gateway('${x > 1}'), {
+        processAttributes: 'isExecutable="false"',
+      }),
+    },
+    {
+      name: 'a JUEL condition inside a transaction (refused as a whole)',
+      moddleElement: engineModel(
+        'c8',
+        `<bpmn:transaction id="X">${gateway('${x > 1}')}</bpmn:transaction>`,
+      ),
+    },
+    {
+      name: 'a zeebe:script on a service task (not read there)',
+      moddleElement: engineModel(
+        'c8',
+        chain(
+          `<bpmn:serviceTask id="X">${ext(`${JOB}<zeebe:script expression="${BAD}" resultVariable="r" />`)}</bpmn:serviceTask>`,
+        ),
+      ),
+    },
+    {
+      name: 'a zeebe:input outside its zeebe:ioMapping (not read)',
+      moddleElement: engineModel(
+        'c8',
+        chain(
+          `<bpmn:serviceTask id="X">${ext(`${JOB}<zeebe:input source="${BAD}" target="a" />`)}</bpmn:serviceTask>`,
+        ),
+      ),
+    },
+    {
+      name: 'a script with a job (the job runs, the script is not read)',
+      moddleElement: engineModel(
+        'c8',
+        chain(
+          `<bpmn:scriptTask id="X">${ext(`${JOB}<zeebe:script expression="1 + 1" resultVariable="r" />`)}</bpmn:scriptTask>`,
+        ),
+      ),
+    },
+    {
+      name: 'a message no element uses, with a FEEL slip in its name and key',
+      moddleElement: engineModel('c8', chain('<bpmn:task id="X" />'), { roots: message(BAD, BAD) }),
+    },
+    {
+      name: 'a timer cycle on an intermediate catch event (refused for the cycle)',
+      moddleElement: engineModel(
+        'c8',
+        chain(
+          `<bpmn:intermediateCatchEvent id="X">${timer('timeCycle', BAD)}</bpmn:intermediateCatchEvent>`,
+        ),
+      ),
+    },
+    {
+      name: 'a static correlation key on the message of a process start event (not read there)',
+      moddleElement: engineModel(
+        'c8',
+        `<bpmn:startEvent id="S"><bpmn:messageEventDefinition id="MD" messageRef="M1" /></bpmn:startEvent>
+         <bpmn:sequenceFlow id="F" sourceRef="S" targetRef="E" /><bpmn:endEvent id="E" />`,
+        { roots: message('Paid', 'orderId') },
+      ),
+    },
+    {
+      name: 'an event with two definitions (refused for that)',
+      moddleElement: engineModel(
+        'c8',
+        chain(
+          `<bpmn:intermediateCatchEvent id="X">${conditional('true')}${timer('timeDuration', 'PT1H')}</bpmn:intermediateCatchEvent>`,
+        ),
+      ),
+    },
+    {
+      name: 'a Camunda 7 diagram',
+      moddleElement: engineModel('c7', gateway('${x > 1}')),
+    },
+  ],
+  invalid: [
+    {
+      name: 'a JUEL condition',
+      moddleElement: engineModel('c8', gateway('${x > 1}')),
+      report: notFeel(
+        'S0',
+        `The condition "\${x > 1}" of sequence flow S0 is no FEEL expression; ${NEEDS_FEEL}`,
+        ['conditionExpression'],
+      ),
+    },
+    {
+      name: 'an ad-hoc completion condition in JUEL',
+      moddleElement: engineModel('c8', adHoc(completion('${done}'))),
+      report: notFeel(
+        'X',
+        `The completion condition "\${done}" of ad-hoc sub-process X is no FEEL expression; ${NEEDS_FEEL}`,
+        ['completionCondition'],
+      ),
+    },
+    {
+      name: 'a static ad-hoc completion condition',
+      moddleElement: engineModel('c8', adHoc(completion('true'))),
+      report: notFeel(
+        'X',
+        `The completion condition "true" of ad-hoc sub-process X is no FEEL expression; ${NEEDS_FEEL}`,
+        ['completionCondition'],
+      ),
+    },
+    {
+      name: 'a static condition of a conditional event',
+      moddleElement: engineModel(
+        'c8',
+        chain(
+          `<bpmn:intermediateCatchEvent id="X">${conditional('true')}</bpmn:intermediateCatchEvent>`,
+        ),
+      ),
+      report: notFeel(
+        'X',
+        `The condition "true" of conditional event X is no FEEL expression; ${NEEDS_FEEL}`,
+        ['eventDefinitions', 0, 'condition'],
+      ),
+    },
+  ],
+});
diff --git a/test/adapters/out/bpmnlint/engine/rules/c8/C8ConditionalEventNeedsConditionRule.test.ts b/test/adapters/out/bpmnlint/engine/rules/c8/C8ConditionalEventNeedsConditionRule.test.ts
new file mode 100644
index 00000000..7eb83333
--- /dev/null
+++ b/test/adapters/out/bpmnlint/engine/rules/c8/C8ConditionalEventNeedsConditionRule.test.ts
@@ -0,0 +1,161 @@
+import { ERROR_TYPES } from 'bpmnlint-plugin-camunda-compat/rules/utils/error-types.js';
+import { describe } from 'vitest';
+import rule from '../../../../../../../src/adapters/out/bpmnlint/engine/rules/c8/C8ConditionalEventNeedsConditionRule.js';
+import { engineModel, verifyEngineRule } from '../../../../../../helpers/engine-model.js';
+
+describe('c8-conditional-event-needs-condition', () => {
+  const TIMER =
+    '<bpmn:timerEventDefinition id="timer_X"><bpmn:timeDuration xsi:type="bpmn:tFormalExpression">PT1H</bpmn:timeDuration></bpmn:timerEventDefinition>';
+  const MESSAGE = '<bpmn:message id="M1" name="M1" />';
+  const CONDITION = '<bpmn:condition xsi:type="bpmn:tFormalExpression">= x &gt; 1</bpmn:condition>';
+  const chain = (middle: string, extra = '') => `
+    <bpmn:startEvent id="Start" />
+    <bpmn:sequenceFlow id="F1" sourceRef="Start" targetRef="X" />
+    ${middle}
+    <bpmn:sequenceFlow id="F2" sourceRef="X" targetRef="End" />
+    <bpmn:endEvent id="End" />
+    ${extra}`;
+  const eventSubProcess = (start: string) => `
+    <bpmn:startEvent id="Start" />
+    <bpmn:sequenceFlow id="F1" sourceRef="Start" targetRef="End" />
+    <bpmn:endEvent id="End" />
+    <bpmn:subProcess id="ESP" triggeredByEvent="true">
+      ${start}
+      <bpmn:sequenceFlow id="ESP_F" sourceRef="ESP_S" targetRef="ESP_E" />
+      <bpmn:endEvent id="ESP_E" />
+    </bpmn:subProcess>`;
+  const COMPENSATION = (
+    boundaryDefinition = '<bpmn:compensateEventDefinition id="CB" />',
+    throwDefinition = '<bpmn:compensateEventDefinition id="CT" />',
+    association = true,
+    boundaryFlow = '',
+  ) => `
+    <bpmn:startEvent id="Start" />
+    <bpmn:sequenceFlow id="F1" sourceRef="Start" targetRef="X" />
+    <bpmn:serviceTask id="X" />
+    <bpmn:boundaryEvent id="B" attachedToRef="X">${boundaryDefinition}</bpmn:boundaryEvent>
+    <bpmn:serviceTask id="H" isForCompensation="true" />
+    <bpmn:sequenceFlow id="F2" sourceRef="X" targetRef="T" />
+    <bpmn:intermediateThrowEvent id="T">${throwDefinition}</bpmn:intermediateThrowEvent>
+    <bpmn:sequenceFlow id="F3" sourceRef="T" targetRef="End" />
+    <bpmn:endEvent id="End" />
+    ${boundaryFlow}
+    ${association ? '<bpmn:association id="A" associationDirection="One" sourceRef="B" targetRef="H" />' : ''}`;
+  const LINKS = (throwDefinition: string, catchDefinition: string) => `
+    <bpmn:startEvent id="Start" />
+    <bpmn:sequenceFlow id="F1" sourceRef="Start" targetRef="X" />
+    <bpmn:intermediateThrowEvent id="X">${throwDefinition}</bpmn:intermediateThrowEvent>
+    <bpmn:intermediateCatchEvent id="C">${catchDefinition}</bpmn:intermediateCatchEvent>
+    <bpmn:sequenceFlow id="FC" sourceRef="C" targetRef="End" />
+    <bpmn:endEvent id="End" />`;
+  const TWO_DEFINITIONS = chain(
+    `<bpmn:intermediateCatchEvent id="X">${TIMER}<bpmn:messageEventDefinition id="MD" messageRef="M1" /></bpmn:intermediateCatchEvent>`,
+  );
+  const CONDITION_MISSING = chain(
+    '<bpmn:intermediateCatchEvent id="X"><bpmn:conditionalEventDefinition id="CD1" /></bpmn:intermediateCatchEvent>',
+  );
+  const conditionMissingReport = {
+    id: 'X',
+    message:
+      'The conditional event definition of intermediateCatchEvent:conditional X has no condition element, which the BPMN schema requires; Camunda 8 refuses the file',
+    path: ['eventDefinitions', 0, 'condition'],
+    type: ERROR_TYPES.PROPERTY_REQUIRED,
+  };
+
+  verifyEngineRule(rule, {
+    valid: [
+      {
+        name: 'an event sub-process with a message start event',
+        moddleElement: engineModel(
+          'c8',
+          eventSubProcess(
+            '<bpmn:startEvent id="ESP_S"><bpmn:messageEventDefinition id="MD" messageRef="M1" /></bpmn:startEvent>',
+          ),
+          { roots: MESSAGE },
+        ),
+      },
+      {
+        name: 'conditional events with definition ids',
+        moddleElement: engineModel(
+          'c8',
+          chain(
+            `<bpmn:intermediateCatchEvent id="X"><bpmn:conditionalEventDefinition id="CD1">${CONDITION}</bpmn:conditionalEventDefinition></bpmn:intermediateCatchEvent>`,
+          ),
+        ),
+      },
+      { name: 'compensation with definition ids', moddleElement: engineModel('c8', COMPENSATION()) },
+      {
+        name: 'a link pair with definition ids',
+        moddleElement: engineModel(
+          'c8',
+          LINKS(
+            '<bpmn:linkEventDefinition id="L1" name="L" />',
+            '<bpmn:linkEventDefinition id="L2" name="L" />',
+          ),
+        ),
+      },
+      {
+        name: 'a link throw definition without id',
+        moddleElement: engineModel(
+          'c8',
+          LINKS(
+            '<bpmn:linkEventDefinition name="L" />',
+            '<bpmn:linkEventDefinition id="L2" name="L" />',
+          ),
+        ),
+      },
+      {
+        name: 'catch and boundary events without definition (camunda-compat element-type)',
+        moddleElement: engineModel(
+          'c8',
+          chain(
+            '<bpmn:intermediateCatchEvent id="X" />',
+            '<bpmn:task id="Y" /><bpmn:boundaryEvent id="B" attachedToRef="Y" />',
+          ),
+        ),
+      },
+      {
+        name: 'an event sub-process start with a compensation trigger (camunda-compat element-type)',
+        moddleElement: engineModel(
+          'c8',
+          eventSubProcess(
+            '<bpmn:startEvent id="ESP_S"><bpmn:compensateEventDefinition /></bpmn:startEvent>',
+          ),
+        ),
+      },
+      {
+        name: 'two definitions in a process that is not executable',
+        moddleElement: engineModel('c8', TWO_DEFINITIONS, {
+          roots: MESSAGE,
+          processAttributes: 'isExecutable="false"',
+        }),
+      },
+      {
+        name: 'two definitions inside a transaction',
+        moddleElement: engineModel(
+          'c8',
+          `<bpmn:transaction id="TX"><bpmn:intermediateCatchEvent id="X">${TIMER}<bpmn:messageEventDefinition id="MD" messageRef="M1" /></bpmn:intermediateCatchEvent></bpmn:transaction>`,
+          { roots: MESSAGE },
+        ),
+      },
+      {
+        name: 'a Camunda 7 diagram',
+        moddleElement: engineModel('c7', TWO_DEFINITIONS, { roots: MESSAGE }),
+      },
+    ],
+    invalid: [
+      {
+        name: 'a conditional event definition without condition',
+        moddleElement: engineModel('c8', CONDITION_MISSING),
+        report: conditionMissingReport,
+      },
+      {
+        name: 'a conditional event definition without condition in a process that is not executable',
+        moddleElement: engineModel('c8', CONDITION_MISSING, {
+          processAttributes: 'isExecutable="false"',
+        }),
+        report: conditionMissingReport,
+      },
+    ],
+  });
+});
diff --git a/test/adapters/out/bpmnlint/engine/rules/c8/C8ConditionalFilterEventsKnownRule.test.ts b/test/adapters/out/bpmnlint/engine/rules/c8/C8ConditionalFilterEventsKnownRule.test.ts
new file mode 100644
index 00000000..9bf18c8e
--- /dev/null
+++ b/test/adapters/out/bpmnlint/engine/rules/c8/C8ConditionalFilterEventsKnownRule.test.ts
@@ -0,0 +1,101 @@
+import { ERROR_TYPES } from 'bpmnlint-plugin-camunda-compat/rules/utils/error-types.js';
+import { describe } from 'vitest';
+import rule from '../../../../../../../src/adapters/out/bpmnlint/engine/rules/c8/C8ConditionalFilterEventsKnownRule.js';
+import { engineModel, verifyEngineRule } from '../../../../../../helpers/engine-model.js';
+
+describe('c8-conditional-filter-events-known', () => {
+  const ext = (inner: string) => `<bpmn:extensionElements>${inner}</bpmn:extensionElements>`;
+  const SERVICE_TASK = (extra = '') =>
+    `<bpmn:serviceTask id="serviceTask_charge">${ext(`<zeebe:taskDefinition type="charge" />${extra}`)}</bpmn:serviceTask>`;
+  const HEADERS = (...keys: string[]) =>
+    `<zeebe:taskHeaders>${keys.map((key, index) => `<zeebe:header key="${key}" value="v${index}" />`).join('')}</zeebe:taskHeaders>`;
+  const CONDITIONAL = (filter: string) => `
+    <bpmn:intermediateCatchEvent id="event_stockChanged">
+      <bpmn:conditionalEventDefinition id="conditionalEventDefinition_stockChanged">
+        ${ext(filter)}
+        <bpmn:condition xsi:type="bpmn:tFormalExpression">= stock &gt; 0</bpmn:condition>
+      </bpmn:conditionalEventDefinition>
+    </bpmn:intermediateCatchEvent>`;
+
+  verifyEngineRule(rule, {
+    valid: [
+      {
+        name: 'every binding type, a version tag where it binds by version tag',
+        moddleElement: engineModel(
+          'c8',
+          `<bpmn:callActivity id="callActivity_ship">${ext('<zeebe:calledElement processId="ship" bindingType="deployment" />')}</bpmn:callActivity>
+          <bpmn:businessRuleTask id="businessRuleTask_rate">${ext('<zeebe:calledDecision decisionId="rate" resultVariable="rate" bindingType="latest" />')}</bpmn:businessRuleTask>
+          <bpmn:userTask id="userTask_review">${ext('<zeebe:userTask /><zeebe:formDefinition formId="review" bindingType="versionTag" versionTag="v1" />')}</bpmn:userTask>`,
+        ),
+      },
+      {
+        name: 'a version tag binding without version tag on a business rule task (camunda-compat reports it)',
+        moddleElement: engineModel(
+          'c8',
+          `<bpmn:businessRuleTask id="businessRuleTask_rate">${ext('<zeebe:calledDecision decisionId="rate" resultVariable="rate" bindingType="versionTag" />')}</bpmn:businessRuleTask>`,
+        ),
+      },
+      {
+        name: 'a complete linked resource, variable events create and update',
+        moddleElement: engineModel(
+          'c8',
+          `${SERVICE_TASK('<zeebe:linkedResources><zeebe:linkedResource resourceId="r" resourceType="RPA" linkName="robot" bindingType="versionTag" versionTag="v1" /></zeebe:linkedResources>')}
+          ${CONDITIONAL('<zeebe:conditionalFilter variableNames="stock" variableEvents="create, update" />')}`,
+        ),
+      },
+      {
+        name: 'a task header key twice in the first header list (camunda-compat reports it)',
+        moddleElement: engineModel('c8', SERVICE_TASK(HEADERS('region', 'region'))),
+      },
+      {
+        name: 'mappings without target or source (camunda-compat reports them)',
+        moddleElement: engineModel(
+          'c8',
+          SERVICE_TASK(
+            '<zeebe:ioMapping><zeebe:input source="=a" /><zeebe:input source="=a" target=" " /><zeebe:output source="=a" target="1x" /><zeebe:output target="a" /></zeebe:ioMapping>',
+          ),
+        ),
+      },
+      {
+        name: 'an unknown binding type in a non-executable process',
+        moddleElement: engineModel(
+          'c8',
+          `<bpmn:callActivity id="callActivity_ship">${ext('<zeebe:calledElement processId="ship" bindingType="foo" />')}</bpmn:callActivity>`,
+          { processAttributes: 'isExecutable="false"' },
+        ),
+      },
+      {
+        name: 'a linked resource on a user task (c8-zeebe-extension-placement reports it)',
+        moddleElement: engineModel(
+          'c8',
+          `<bpmn:userTask id="userTask_review">${ext('<zeebe:userTask /><zeebe:linkedResources><zeebe:linkedResource resourceId="r" /></zeebe:linkedResources>')}</bpmn:userTask>`,
+        ),
+      },
+      {
+        name: 'a Camunda 7 diagram',
+        moddleElement: engineModel(
+          'c7',
+          '<bpmn:callActivity id="callActivity_ship" calledElement="ship" camunda:calledElementBinding="foo" />',
+        ),
+      },
+    ],
+    invalid: [
+      {
+        name: 'an unknown variable event',
+        moddleElement: engineModel(
+          'c8',
+          CONDITIONAL(
+            '<zeebe:conditionalFilter variableNames="stock" variableEvents="create, foo" />',
+          ),
+        ),
+        report: {
+          id: 'event_stockChanged',
+          message:
+            'zeebe:conditionalFilter of conditionalEventDefinition conditionalEventDefinition_stockChanged lists the variable events foo; Camunda 8 knows create and update only and refuses the file',
+          path: ['eventDefinitions', 0, 'extensionElements', 'values', 0, 'variableEvents'],
+          type: ERROR_TYPES.PROPERTY_VALUE_NOT_ALLOWED,
+        },
+      },
+    ],
+  });
+});
diff --git a/test/adapters/out/bpmnlint/engine/rules/c8/C8CorrelationKeyNeedsFeelRule.test.ts b/test/adapters/out/bpmnlint/engine/rules/c8/C8CorrelationKeyNeedsFeelRule.test.ts
new file mode 100644
index 00000000..8420e6d4
--- /dev/null
+++ b/test/adapters/out/bpmnlint/engine/rules/c8/C8CorrelationKeyNeedsFeelRule.test.ts
@@ -0,0 +1,221 @@
+import { ERROR_TYPES } from 'bpmnlint-plugin-camunda-compat/rules/utils/error-types.js';
+import rule from '../../../../../../../src/adapters/out/bpmnlint/engine/rules/c8/C8CorrelationKeyNeedsFeelRule.js';
+import { engineModel, verifyEngineRule } from '../../../../../../helpers/engine-model.js';
+
+const BAD = '= (a';
+const REFUSED = 'Camunda 8 parses it at deploy and refuses the file';
+const ext = (inner: string) => `<bpmn:extensionElements>${inner}</bpmn:extensionElements>`;
+const JOB = '<zeebe:taskDefinition type="work" />';
+const escape = (text: string) =>
+  text.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;');
+const chain = (middle: string) => `
+  <bpmn:startEvent id="startEvent_start" />
+  <bpmn:sequenceFlow id="flow_toX" sourceRef="startEvent_start" targetRef="X" />
+  ${middle}
+  <bpmn:sequenceFlow id="flow_fromX" sourceRef="X" targetRef="endEvent_end" />
+  <bpmn:endEvent id="endEvent_end" />`;
+const gateway = (condition: string) => `
+  <bpmn:startEvent id="startEvent_start" />
+  <bpmn:sequenceFlow id="flow_toGateway" sourceRef="startEvent_start" targetRef="G" />
+  <bpmn:exclusiveGateway id="G" default="SD" />
+  <bpmn:sequenceFlow id="SD" sourceRef="G" targetRef="endEvent_default" />
+  <bpmn:endEvent id="endEvent_default" />
+  <bpmn:sequenceFlow id="S0" sourceRef="G" targetRef="endEvent_s0">
+    <bpmn:conditionExpression xsi:type="bpmn:tFormalExpression">${escape(condition)}</bpmn:conditionExpression>
+  </bpmn:sequenceFlow>
+  <bpmn:endEvent id="endEvent_s0" />`;
+const adHoc = (inner: string, zeebe = '') =>
+  chain(
+    `<bpmn:adHocSubProcess id="X">${zeebe ? ext(zeebe) : ''}<bpmn:task id="A1" />${inner}</bpmn:adHocSubProcess>`,
+  );
+const completion = (body: string) =>
+  `<bpmn:completionCondition xsi:type="bpmn:tFormalExpression">${escape(body)}</bpmn:completionCondition>`;
+const multiInstance = (zeebeLoop: string, inner = '') =>
+  chain(
+    `<bpmn:serviceTask id="X">${ext(JOB)}<bpmn:multiInstanceLoopCharacteristics>${ext(zeebeLoop)}${inner}</bpmn:multiInstanceLoopCharacteristics></bpmn:serviceTask>`,
+  );
+const timer = (kind: string, value: string) =>
+  `<bpmn:timerEventDefinition id="TD1"><bpmn:${kind} xsi:type="bpmn:tFormalExpression">${escape(value)}</bpmn:${kind}></bpmn:timerEventDefinition>`;
+const conditional = (condition: string) =>
+  `<bpmn:conditionalEventDefinition id="CD1"><bpmn:condition xsi:type="bpmn:tFormalExpression">${escape(condition)}</bpmn:condition></bpmn:conditionalEventDefinition>`;
+const message = (name: string, key: string | null = '=orderId') =>
+  `<bpmn:message id="M1" name="${escape(name)}">${key === null ? '' : ext(`<zeebe:subscription correlationKey="${escape(key)}" />`)}</bpmn:message>`;
+const feel = (
+  id: string,
+  what: string,
+  value: string,
+  problem: string,
+  path: (string | number)[],
+) => ({
+  id,
+  message: `${what} "${value}" is no valid FEEL: ${problem}; ${REFUSED}`,
+  path,
+  type: ERROR_TYPES.FEEL_EXPRESSION_INVALID,
+});
+const notFeel = (id: string, message: string, path: (string | number)[]) => ({
+  id,
+  message,
+  path,
+  type: ERROR_TYPES.EXPRESSION_REQUIRED,
+});
+
+verifyEngineRule(rule, {
+  valid: [
+    ...[
+      '= x andy',
+      '= x in [1..5]',
+      '= x in (> 1, < 5)',
+      '= {a: 1}.a = 1',
+      '= string length(x) > 2',
+    ].map((condition) => ({
+      name: `a condition FEEL accepts: ${condition}`,
+      moddleElement: engineModel('c8', gateway(condition)),
+    })),
+    {
+      name: 'a FEEL completion condition of an ad-hoc sub-process',
+      moddleElement: engineModel('c8', adHoc(completion('= a and b'))),
+    },
+    {
+      name: 'attributes Camunda 8 does not parse at deploy (listener type, header value)',
+      moddleElement: engineModel(
+        'c8',
+        chain(
+          `<bpmn:serviceTask id="X">${ext(`${JOB}<zeebe:taskHeaders><zeebe:header key="k" value="${BAD}" /></zeebe:taskHeaders><zeebe:executionListeners><zeebe:executionListener eventType="end" type="${BAD}" /></zeebe:executionListeners>`)}</bpmn:serviceTask>`,
+        ),
+      ),
+    },
+    {
+      name: 'a FEEL timer value',
+      moddleElement: engineModel(
+        'c8',
+        chain(
+          `<bpmn:intermediateCatchEvent id="X">${timer('timeDuration', '=wait')}</bpmn:intermediateCatchEvent>`,
+        ),
+      ),
+    },
+    {
+      name: 'FEEL values in the multi-instance and the script',
+      moddleElement: engineModel(
+        'c8',
+        multiInstance(
+          '<zeebe:loopCharacteristics inputCollection="=items" outputCollection="out" outputElement="=result" />',
+          completion('= done'),
+        ) +
+          `<bpmn:scriptTask id="Y">${ext('<zeebe:script expression="=1 + 1" resultVariable="r" />')}</bpmn:scriptTask>`,
+      ),
+    },
+    {
+      name: 'a multi-instance completion condition that is no FEEL (a runtime matter, c8-multi-instance-completion-needs-feel)',
+      moddleElement: engineModel(
+        'c8',
+        multiInstance(
+          '<zeebe:loopCharacteristics inputCollection="=items" />',
+          completion('${done}'),
+        ),
+      ),
+    },
+    {
+      name: 'a JUEL condition in a process that is not executable',
+      moddleElement: engineModel('c8', gateway('${x > 1}'), {
+        processAttributes: 'isExecutable="false"',
+      }),
+    },
+    {
+      name: 'a JUEL condition inside a transaction (refused as a whole)',
+      moddleElement: engineModel(
+        'c8',
+        `<bpmn:transaction id="X">${gateway('${x > 1}')}</bpmn:transaction>`,
+      ),
+    },
+    {
+      name: 'a zeebe:script on a service task (not read there)',
+      moddleElement: engineModel(
+        'c8',
+        chain(
+          `<bpmn:serviceTask id="X">${ext(`${JOB}<zeebe:script expression="${BAD}" resultVariable="r" />`)}</bpmn:serviceTask>`,
+        ),
+      ),
+    },
+    {
+      name: 'a zeebe:input outside its zeebe:ioMapping (not read)',
+      moddleElement: engineModel(
+        'c8',
+        chain(
+          `<bpmn:serviceTask id="X">${ext(`${JOB}<zeebe:input source="${BAD}" target="a" />`)}</bpmn:serviceTask>`,
+        ),
+      ),
+    },
+    {
+      name: 'a script with a job (the job runs, the script is not read)',
+      moddleElement: engineModel(
+        'c8',
+        chain(
+          `<bpmn:scriptTask id="X">${ext(`${JOB}<zeebe:script expression="1 + 1" resultVariable="r" />`)}</bpmn:scriptTask>`,
+        ),
+      ),
+    },
+    {
+      name: 'a message no element uses, with a FEEL slip in its name and key',
+      moddleElement: engineModel('c8', chain('<bpmn:task id="X" />'), { roots: message(BAD, BAD) }),
+    },
+    {
+      name: 'a timer cycle on an intermediate catch event (refused for the cycle)',
+      moddleElement: engineModel(
+        'c8',
+        chain(
+          `<bpmn:intermediateCatchEvent id="X">${timer('timeCycle', BAD)}</bpmn:intermediateCatchEvent>`,
+        ),
+      ),
+    },
+    {
+      name: 'a static correlation key on the message of a process start event (not read there)',
+      moddleElement: engineModel(
+        'c8',
+        `<bpmn:startEvent id="S"><bpmn:messageEventDefinition id="MD" messageRef="M1" /></bpmn:startEvent>
+         <bpmn:sequenceFlow id="F" sourceRef="S" targetRef="E" /><bpmn:endEvent id="E" />`,
+        { roots: message('Paid', 'orderId') },
+      ),
+    },
+    {
+      name: 'an event with two definitions (refused for that)',
+      moddleElement: engineModel(
+        'c8',
+        chain(
+          `<bpmn:intermediateCatchEvent id="X">${conditional('true')}${timer('timeDuration', 'PT1H')}</bpmn:intermediateCatchEvent>`,
+        ),
+      ),
+    },
+    {
+      name: 'a Camunda 7 diagram',
+      moddleElement: engineModel('c7', gateway('${x > 1}')),
+    },
+  ],
+  invalid: [
+    {
+      name: 'a static correlation key of a receive task',
+      moddleElement: engineModel('c8', chain('<bpmn:receiveTask id="X" messageRef="M1" />'), {
+        roots: message('Paid', 'orderId'),
+      }),
+      report: notFeel(
+        'X',
+        'The correlationKey "orderId" of message M1 is a static value; Camunda 8 needs a FEEL expression (=orderId) and refuses the file',
+        ['messageRef', 'extensionElements', 'values', 0, 'correlationKey'],
+      ),
+    },
+    {
+      name: 'a static correlation key of a message catch event',
+      moddleElement: engineModel(
+        'c8',
+        chain(
+          '<bpmn:intermediateCatchEvent id="X"><bpmn:messageEventDefinition id="MD" messageRef="M1" /></bpmn:intermediateCatchEvent>',
+        ),
+        { roots: message('Paid', 'orderId') },
+      ),
+      report: notFeel(
+        'X',
+        'The correlationKey "orderId" of message M1 is a static value; Camunda 8 needs a FEEL expression (=orderId) and refuses the file',
+        ['eventDefinitions', 0, 'messageRef', 'extensionElements', 'values', 0, 'correlationKey'],
+      ),
+    },
+  ],
+});
diff --git a/test/adapters/out/bpmnlint/engine/rules/c8/C8EmbeddedStartEventNoTriggerRule.test.ts b/test/adapters/out/bpmnlint/engine/rules/c8/C8EmbeddedStartEventNoTriggerRule.test.ts
new file mode 100644
index 00000000..902b03de
--- /dev/null
+++ b/test/adapters/out/bpmnlint/engine/rules/c8/C8EmbeddedStartEventNoTriggerRule.test.ts
@@ -0,0 +1,81 @@
+import { ERROR_TYPES } from 'bpmnlint-plugin-camunda-compat/rules/utils/error-types.js';
+import { describe } from 'vitest';
+import rule from '../../../../../../../src/adapters/out/bpmnlint/engine/rules/c8/C8EmbeddedStartEventNoTriggerRule.js';
+import { engineModel, verifyEngineRule } from '../../../../../../helpers/engine-model.js';
+
+describe('c8-embedded-start-event-no-trigger', () => {
+  const TIMER =
+    '<bpmn:timerEventDefinition id="timer_YS"><bpmn:timeCycle xsi:type="bpmn:tFormalExpression">R/PT1H</bpmn:timeCycle></bpmn:timerEventDefinition>';
+  const chain = (...middle: string[]) => `
+    <bpmn:startEvent id="Start" />
+    <bpmn:sequenceFlow id="F1" sourceRef="Start" targetRef="X" />
+    ${middle.join('\n')}
+    <bpmn:sequenceFlow id="F2" sourceRef="X" targetRef="End" />
+    <bpmn:endEvent id="End" />`;
+  const inner = (prefix: string, start = '') =>
+    `<bpmn:startEvent id="${prefix}S">${start}</bpmn:startEvent><bpmn:sequenceFlow id="${prefix}F" sourceRef="${prefix}S" targetRef="${prefix}E" /><bpmn:endEvent id="${prefix}E" />`;
+  const TIMER_START = chain(`<bpmn:subProcess id="X">${inner('Y', TIMER)}</bpmn:subProcess>`);
+
+  verifyEngineRule(rule, {
+    valid: [
+      {
+        name: 'a sub-process with one none start event',
+        moddleElement: engineModel(
+          'c8',
+          chain(`<bpmn:subProcess id="X">${inner('I')}</bpmn:subProcess>`),
+        ),
+      },
+      {
+        name: 'an event sub-process with a timer start event',
+        moddleElement: engineModel(
+          'c8',
+          chain(
+            '<bpmn:task id="X" />',
+            `<bpmn:subProcess id="ESP" triggeredByEvent="true">${inner('Y', TIMER)}</bpmn:subProcess>`,
+          ),
+        ),
+      },
+      {
+        name: 'a sub-process without start event (bpmnlint start-event-required)',
+        moddleElement: engineModel(
+          'c8',
+          chain('<bpmn:subProcess id="X"><bpmn:task id="A1" /></bpmn:subProcess>'),
+        ),
+      },
+      {
+        name: 'two none start events in a process (camunda-compat no-multiple-none-start-events)',
+        moddleElement: engineModel(
+          'c8',
+          `${chain('<bpmn:task id="X" />')}<bpmn:startEvent id="S2" /><bpmn:sequenceFlow id="F9" sourceRef="S2" targetRef="End" />`,
+        ),
+      },
+      {
+        name: 'start events in an ad-hoc sub-process',
+        moddleElement: engineModel(
+          'c8',
+          chain(
+            `<bpmn:adHocSubProcess id="X"><bpmn:startEvent id="AS">${TIMER}</bpmn:startEvent><bpmn:startEvent id="AS2" /></bpmn:adHocSubProcess>`,
+          ),
+        ),
+      },
+      {
+        name: 'a timer start in a sub-process of a process that is not executable',
+        moddleElement: engineModel('c8', TIMER_START, { processAttributes: 'isExecutable="false"' }),
+      },
+      { name: 'a Camunda 7 diagram', moddleElement: engineModel('c7', TIMER_START) },
+    ],
+    invalid: [
+      {
+        name: 'a sub-process with a timer start event',
+        moddleElement: engineModel('c8', TIMER_START),
+        report: {
+          id: 'YS',
+          message:
+            'Start event YS of sub-process X has a timer trigger; Camunda 8 allows only a none start event in an embedded sub-process and refuses the file',
+          path: ['eventDefinitions', 0],
+          type: ERROR_TYPES.ELEMENT_TYPE_NOT_ALLOWED,
+        },
+      },
+    ],
+  });
+});
diff --git a/test/adapters/out/bpmnlint/engine/rules/c8/C8ErrorCatchNeedsStaticCodeRule.test.ts b/test/adapters/out/bpmnlint/engine/rules/c8/C8ErrorCatchNeedsStaticCodeRule.test.ts
new file mode 100644
index 00000000..e86b2fb9
--- /dev/null
+++ b/test/adapters/out/bpmnlint/engine/rules/c8/C8ErrorCatchNeedsStaticCodeRule.test.ts
@@ -0,0 +1,78 @@
+import { ERROR_TYPES } from 'bpmnlint-plugin-camunda-compat/rules/utils/error-types.js';
+import { describe } from 'vitest';
+import rule from '../../../../../../../src/adapters/out/bpmnlint/engine/rules/c8/C8ErrorCatchNeedsStaticCodeRule.js';
+import { engineModel, verifyEngineRule } from '../../../../../../helpers/engine-model.js';
+
+describe('c8-error-catch-needs-static-code', () => {
+  const ERROR_DEFINITION = (id: string, ref?: string) =>
+    `<bpmn:errorEventDefinition id="${id}"${ref ? ` errorRef="${ref}"` : ''} />`;
+  const ERROR = (code?: string) =>
+    `<bpmn:error id="Err" name="E"${code === undefined ? '' : ` errorCode="${code}"`} />`;
+  const boundaries = (definitions: string[], attributes = '', end = '') => `
+    <bpmn:startEvent id="Start" />
+    <bpmn:sequenceFlow id="F1" sourceRef="Start" targetRef="X" />
+    <bpmn:serviceTask id="X" />
+    <bpmn:sequenceFlow id="F2" sourceRef="X" targetRef="End" />
+    <bpmn:endEvent id="End">${end}</bpmn:endEvent>
+    ${definitions.map((definition, index) => `<bpmn:boundaryEvent id="B${index}" attachedToRef="X"${attributes}>${definition}</bpmn:boundaryEvent>`).join('\n')}`;
+  const TWO_BOUNDARIES = boundaries([ERROR_DEFINITION('ED0', 'Err'), ERROR_DEFINITION('ED1', 'Err')]);
+
+  verifyEngineRule(rule, {
+    valid: [
+      {
+        name: 'an error boundary event with a static code',
+        moddleElement: engineModel('c8', boundaries([ERROR_DEFINITION('ED0', 'Err')]), {
+          roots: ERROR('C'),
+        }),
+      },
+      {
+        name: 'a FEEL error code on a throw event',
+        moddleElement: engineModel('c8', boundaries([], '', ERROR_DEFINITION('ED', 'Err')), {
+          roots: ERROR('=code'),
+        }),
+      },
+      {
+        name: 'two error boundary events with different codes on different activities',
+        moddleElement: engineModel(
+          'c8',
+          `${boundaries([ERROR_DEFINITION('ED0', 'Err')])}<bpmn:task id="Y" /><bpmn:boundaryEvent id="BY" attachedToRef="Y">${ERROR_DEFINITION('EDY', 'Err')}</bpmn:boundaryEvent>`,
+          { roots: ERROR('C') },
+        ),
+      },
+      {
+        name: 'a thrown error without code (camunda-compat error-reference)',
+        moddleElement: engineModel('c8', boundaries([], '', ERROR_DEFINITION('ED', 'Err')), {
+          roots: ERROR(),
+        }),
+      },
+      {
+        name: 'two error boundary events with one code in a process that is not executable',
+        moddleElement: engineModel('c8', TWO_BOUNDARIES, {
+          roots: ERROR('C'),
+          processAttributes: 'isExecutable="false"',
+        }),
+      },
+      {
+        name: 'a Camunda 7 diagram',
+        moddleElement: engineModel('c7', TWO_BOUNDARIES, { roots: ERROR('C') }),
+      },
+    ],
+    invalid: [
+      {
+        name: 'an error boundary event catching a FEEL code',
+        moddleElement: engineModel(
+          'c8',
+          boundaries([ERROR_DEFINITION('ED0', 'Err')], '', ERROR_DEFINITION('ED', 'Err')),
+          { roots: ERROR('=code') },
+        ),
+        report: {
+          id: 'B0',
+          message:
+            'boundaryEvent:error B0 catches the error code "=code", an expression; Camunda 8 needs a static code on catching error events and refuses the file',
+          path: ['eventDefinitions', 0, 'errorRef', 'errorCode'],
+          type: ERROR_TYPES.EXPRESSION_NOT_ALLOWED,
+        },
+      },
+    ],
+  });
+});
diff --git a/test/adapters/out/bpmnlint/engine/rules/c8/C8ErrorCodeUniqueRule.test.ts b/test/adapters/out/bpmnlint/engine/rules/c8/C8ErrorCodeUniqueRule.test.ts
new file mode 100644
index 00000000..07dec7b5
--- /dev/null
+++ b/test/adapters/out/bpmnlint/engine/rules/c8/C8ErrorCodeUniqueRule.test.ts
@@ -0,0 +1,108 @@
+import { ERROR_TYPES } from 'bpmnlint-plugin-camunda-compat/rules/utils/error-types.js';
+import { describe } from 'vitest';
+import rule from '../../../../../../../src/adapters/out/bpmnlint/engine/rules/c8/C8ErrorCodeUniqueRule.js';
+import { engineModel, verifyEngineRule } from '../../../../../../helpers/engine-model.js';
+
+describe('c8-error-code-unique', () => {
+  const ERROR_DEFINITION = (id: string, ref?: string) =>
+    `<bpmn:errorEventDefinition id="${id}"${ref ? ` errorRef="${ref}"` : ''} />`;
+  const ERROR = (code?: string) =>
+    `<bpmn:error id="Err" name="E"${code === undefined ? '' : ` errorCode="${code}"`} />`;
+  const boundaries = (definitions: string[], attributes = '', end = '') => `
+    <bpmn:startEvent id="Start" />
+    <bpmn:sequenceFlow id="F1" sourceRef="Start" targetRef="X" />
+    <bpmn:serviceTask id="X" />
+    <bpmn:sequenceFlow id="F2" sourceRef="X" targetRef="End" />
+    <bpmn:endEvent id="End">${end}</bpmn:endEvent>
+    ${definitions.map((definition, index) => `<bpmn:boundaryEvent id="B${index}" attachedToRef="X"${attributes}>${definition}</bpmn:boundaryEvent>`).join('\n')}`;
+  const eventSubProcesses = (...definitions: string[]) => `
+    <bpmn:startEvent id="Start" />
+    <bpmn:sequenceFlow id="F1" sourceRef="Start" targetRef="End" />
+    <bpmn:endEvent id="End" />
+    ${definitions.map((definition, index) => `<bpmn:subProcess id="ESP${index}" triggeredByEvent="true"><bpmn:startEvent id="ESP${index}_S">${definition}</bpmn:startEvent></bpmn:subProcess>`).join('\n')}`;
+  const TWO_BOUNDARIES = boundaries([ERROR_DEFINITION('ED0', 'Err'), ERROR_DEFINITION('ED1', 'Err')]);
+
+  verifyEngineRule(rule, {
+    valid: [
+      {
+        name: 'an error boundary event with a static code',
+        moddleElement: engineModel('c8', boundaries([ERROR_DEFINITION('ED0', 'Err')]), {
+          roots: ERROR('C'),
+        }),
+      },
+      {
+        name: 'a FEEL error code on a throw event',
+        moddleElement: engineModel('c8', boundaries([], '', ERROR_DEFINITION('ED', 'Err')), {
+          roots: ERROR('=code'),
+        }),
+      },
+      {
+        name: 'two error boundary events with different codes on different activities',
+        moddleElement: engineModel(
+          'c8',
+          `${boundaries([ERROR_DEFINITION('ED0', 'Err')])}<bpmn:task id="Y" /><bpmn:boundaryEvent id="BY" attachedToRef="Y">${ERROR_DEFINITION('EDY', 'Err')}</bpmn:boundaryEvent>`,
+          { roots: ERROR('C') },
+        ),
+      },
+      {
+        name: 'a thrown error without code (camunda-compat error-reference)',
+        moddleElement: engineModel('c8', boundaries([], '', ERROR_DEFINITION('ED', 'Err')), {
+          roots: ERROR(),
+        }),
+      },
+      {
+        name: 'two error boundary events with one code in a process that is not executable',
+        moddleElement: engineModel('c8', TWO_BOUNDARIES, {
+          roots: ERROR('C'),
+          processAttributes: 'isExecutable="false"',
+        }),
+      },
+      {
+        name: 'a Camunda 7 diagram',
+        moddleElement: engineModel('c7', TWO_BOUNDARIES, { roots: ERROR('C') }),
+      },
+    ],
+    invalid: [
+      {
+        name: 'two error boundary events with one code',
+        moddleElement: engineModel('c8', TWO_BOUNDARIES, { roots: ERROR('C') }),
+        report: {
+          id: 'B1',
+          message:
+            'boundaryEvent:error B1 catches the error code "C" like boundaryEvent:error B0 (the boundary events of X); Camunda 8 refuses one code twice in a scope',
+          path: ['eventDefinitions', 0, 'errorRef'],
+          type: ERROR_TYPES.ELEMENT_PROPERTY_VALUE_DUPLICATED,
+        },
+      },
+      {
+        name: 'two catch-all error boundary events',
+        moddleElement: engineModel(
+          'c8',
+          boundaries([ERROR_DEFINITION('ED0'), ERROR_DEFINITION('ED1')]),
+        ),
+        report: {
+          id: 'B1',
+          message:
+            'boundaryEvent:error B1 and boundaryEvent:error B0 both catch every error (no error code) (the boundary events of X); Camunda 8 allows one catch-all per scope',
+          path: ['eventDefinitions', 0, 'errorRef'],
+          type: ERROR_TYPES.ELEMENT_PROPERTY_VALUE_DUPLICATED,
+        },
+      },
+      {
+        name: 'two error event sub-processes with one code',
+        moddleElement: engineModel(
+          'c8',
+          eventSubProcesses(ERROR_DEFINITION('ED0', 'Err'), ERROR_DEFINITION('ED1', 'Err')),
+          { roots: ERROR('C') },
+        ),
+        report: {
+          id: 'ESP1_S',
+          message:
+            'startEvent:error ESP1_S catches the error code "C" like startEvent:error ESP0_S (the event sub-processes of process_test); Camunda 8 refuses one code twice in a scope',
+          path: ['eventDefinitions', 0, 'errorRef'],
+          type: ERROR_TYPES.ELEMENT_PROPERTY_VALUE_DUPLICATED,
+        },
+      },
+    ],
+  });
+});
diff --git a/test/adapters/out/bpmnlint/engine/rules/c8/C8ErrorEventInterruptingRule.test.ts b/test/adapters/out/bpmnlint/engine/rules/c8/C8ErrorEventInterruptingRule.test.ts
new file mode 100644
index 00000000..f92619a6
--- /dev/null
+++ b/test/adapters/out/bpmnlint/engine/rules/c8/C8ErrorEventInterruptingRule.test.ts
@@ -0,0 +1,99 @@
+import { ERROR_TYPES } from 'bpmnlint-plugin-camunda-compat/rules/utils/error-types.js';
+import { describe } from 'vitest';
+import rule from '../../../../../../../src/adapters/out/bpmnlint/engine/rules/c8/C8ErrorEventInterruptingRule.js';
+import { engineModel, verifyEngineRule } from '../../../../../../helpers/engine-model.js';
+
+describe('c8-error-event-interrupting', () => {
+  const ERROR_DEFINITION = (id: string, ref?: string) =>
+    `<bpmn:errorEventDefinition id="${id}"${ref ? ` errorRef="${ref}"` : ''} />`;
+  const ERROR = (code?: string) =>
+    `<bpmn:error id="Err" name="E"${code === undefined ? '' : ` errorCode="${code}"`} />`;
+  const boundaries = (definitions: string[], attributes = '', end = '') => `
+    <bpmn:startEvent id="Start" />
+    <bpmn:sequenceFlow id="F1" sourceRef="Start" targetRef="X" />
+    <bpmn:serviceTask id="X" />
+    <bpmn:sequenceFlow id="F2" sourceRef="X" targetRef="End" />
+    <bpmn:endEvent id="End">${end}</bpmn:endEvent>
+    ${definitions.map((definition, index) => `<bpmn:boundaryEvent id="B${index}" attachedToRef="X"${attributes}>${definition}</bpmn:boundaryEvent>`).join('\n')}`;
+  const eventSubProcesses = (...definitions: string[]) => `
+    <bpmn:startEvent id="Start" />
+    <bpmn:sequenceFlow id="F1" sourceRef="Start" targetRef="End" />
+    <bpmn:endEvent id="End" />
+    ${definitions.map((definition, index) => `<bpmn:subProcess id="ESP${index}" triggeredByEvent="true"><bpmn:startEvent id="ESP${index}_S">${definition}</bpmn:startEvent></bpmn:subProcess>`).join('\n')}`;
+  const TWO_BOUNDARIES = boundaries([ERROR_DEFINITION('ED0', 'Err'), ERROR_DEFINITION('ED1', 'Err')]);
+
+  verifyEngineRule(rule, {
+    valid: [
+      {
+        name: 'an error boundary event with a static code',
+        moddleElement: engineModel('c8', boundaries([ERROR_DEFINITION('ED0', 'Err')]), {
+          roots: ERROR('C'),
+        }),
+      },
+      {
+        name: 'a FEEL error code on a throw event',
+        moddleElement: engineModel('c8', boundaries([], '', ERROR_DEFINITION('ED', 'Err')), {
+          roots: ERROR('=code'),
+        }),
+      },
+      {
+        name: 'two error boundary events with different codes on different activities',
+        moddleElement: engineModel(
+          'c8',
+          `${boundaries([ERROR_DEFINITION('ED0', 'Err')])}<bpmn:task id="Y" /><bpmn:boundaryEvent id="BY" attachedToRef="Y">${ERROR_DEFINITION('EDY', 'Err')}</bpmn:boundaryEvent>`,
+          { roots: ERROR('C') },
+        ),
+      },
+      {
+        name: 'a thrown error without code (camunda-compat error-reference)',
+        moddleElement: engineModel('c8', boundaries([], '', ERROR_DEFINITION('ED', 'Err')), {
+          roots: ERROR(),
+        }),
+      },
+      {
+        name: 'two error boundary events with one code in a process that is not executable',
+        moddleElement: engineModel('c8', TWO_BOUNDARIES, {
+          roots: ERROR('C'),
+          processAttributes: 'isExecutable="false"',
+        }),
+      },
+      {
+        name: 'a Camunda 7 diagram',
+        moddleElement: engineModel('c7', TWO_BOUNDARIES, { roots: ERROR('C') }),
+      },
+    ],
+    invalid: [
+      {
+        name: 'a non-interrupting error boundary event',
+        moddleElement: engineModel(
+          'c8',
+          boundaries([ERROR_DEFINITION('ED0')], ' cancelActivity="false"'),
+        ),
+        report: {
+          id: 'B0',
+          message:
+            'boundaryEvent:error B0 is a non-interrupting error event; Camunda 8 refuses it (error events always interrupt)',
+          path: ['cancelActivity'],
+          type: ERROR_TYPES.PROPERTY_VALUE_NOT_ALLOWED,
+        },
+      },
+      {
+        name: 'a non-interrupting error start event of an event sub-process',
+        moddleElement: engineModel(
+          'c8',
+          eventSubProcesses(ERROR_DEFINITION('ED0')).replace(
+            '<bpmn:startEvent id="ESP0_S">',
+            '<bpmn:startEvent id="ESP0_S" isInterrupting="false">',
+          ),
+        ),
+        report: {
+          id: 'ESP0_S',
+          message:
+            'startEvent:error ESP0_S is a non-interrupting error event; Camunda 8 refuses it (error events always interrupt)',
+          path: ['isInterrupting'],
+          type: ERROR_TYPES.PROPERTY_VALUE_NOT_ALLOWED,
+        },
+      },
+    ],
+  });
+});
diff --git a/test/adapters/out/bpmnlint/engine/rules/c8/C8EventGatewayNeedsTwoBranchesRule.test.ts b/test/adapters/out/bpmnlint/engine/rules/c8/C8EventGatewayNeedsTwoBranchesRule.test.ts
new file mode 100644
index 00000000..493d760b
--- /dev/null
+++ b/test/adapters/out/bpmnlint/engine/rules/c8/C8EventGatewayNeedsTwoBranchesRule.test.ts
@@ -0,0 +1,72 @@
+import { ERROR_TYPES } from 'bpmnlint-plugin-camunda-compat/rules/utils/error-types.js';
+import { describe } from 'vitest';
+import rule from '../../../../../../../src/adapters/out/bpmnlint/engine/rules/c8/C8EventGatewayNeedsTwoBranchesRule.js';
+import { engineModel, verifyEngineRule } from '../../../../../../helpers/engine-model.js';
+
+describe('c8-event-gateway-needs-two-branches', () => {
+  const TIMER_CATCH =
+    '<bpmn:intermediateCatchEvent id="{id}">{in}<bpmn:timerEventDefinition id="timer_{id}"><bpmn:timeDuration xsi:type="bpmn:tFormalExpression">PT1H</bpmn:timeDuration></bpmn:timerEventDefinition></bpmn:intermediateCatchEvent>';
+  const MESSAGE_CATCH =
+    '<bpmn:intermediateCatchEvent id="{id}">{in}<bpmn:messageEventDefinition id="message_{id}" messageRef="M1" /></bpmn:intermediateCatchEvent>';
+  const MESSAGE = '<bpmn:message id="M1" name="M1" />';
+  function eventGateway(targets: string[], listed = targets.length): string {
+    const outgoing = targets
+      .slice(0, listed)
+      .map((_target, index) => `<bpmn:outgoing>G${index}</bpmn:outgoing>`)
+      .join('');
+    return `
+    <bpmn:startEvent id="Start"><bpmn:outgoing>F1</bpmn:outgoing></bpmn:startEvent>
+    <bpmn:sequenceFlow id="F1" sourceRef="Start" targetRef="G" />
+    <bpmn:eventBasedGateway id="G"><bpmn:incoming>F1</bpmn:incoming>${outgoing}</bpmn:eventBasedGateway>
+    ${targets
+      .map(
+        (target, index) => `
+    <bpmn:sequenceFlow id="G${index}" sourceRef="G" targetRef="T${index}" />
+    ${target.replaceAll('{id}', `T${index}`).replace('{in}', `<bpmn:incoming>G${index}</bpmn:incoming>`)}
+    <bpmn:sequenceFlow id="E${index}" sourceRef="T${index}" targetRef="End${index}" />
+    <bpmn:endEvent id="End${index}" />`,
+      )
+      .join('')}`;
+  }
+  const ONE_BRANCH = eventGateway([TIMER_CATCH]);
+
+  verifyEngineRule(rule, {
+    valid: [
+      {
+        name: 'an event-based gateway with a timer and a message branch',
+        moddleElement: engineModel('c8', eventGateway([TIMER_CATCH, MESSAGE_CATCH]), {
+          roots: MESSAGE,
+        }),
+      },
+      {
+        name: 'a receive task after the gateway (camunda-compat event-based-gateway-target)',
+        moddleElement: engineModel(
+          'c8',
+          eventGateway([
+            TIMER_CATCH,
+            '<bpmn:receiveTask id="{id}" messageRef="M1">{in}</bpmn:receiveTask>',
+          ]),
+          { roots: MESSAGE },
+        ),
+      },
+      {
+        name: 'an event-based gateway with one branch in a process that is not executable',
+        moddleElement: engineModel('c8', ONE_BRANCH, { processAttributes: 'isExecutable="false"' }),
+      },
+      { name: 'a Camunda 7 diagram', moddleElement: engineModel('c7', ONE_BRANCH) },
+    ],
+    invalid: [
+      {
+        name: 'an event-based gateway with one branch',
+        moddleElement: engineModel('c8', ONE_BRANCH),
+        report: {
+          id: 'G',
+          message:
+            'Event-based gateway G has 1 outgoing flow; Camunda 8 needs at least two and refuses the file',
+          path: ['outgoing'],
+          type: ERROR_TYPES.PROPERTY_REQUIRED,
+        },
+      },
+    ],
+  });
+});
diff --git a/test/adapters/out/bpmnlint/engine/rules/c8/C8EventGatewayTargetAllowedRule.test.ts b/test/adapters/out/bpmnlint/engine/rules/c8/C8EventGatewayTargetAllowedRule.test.ts
new file mode 100644
index 00000000..3029d4bc
--- /dev/null
+++ b/test/adapters/out/bpmnlint/engine/rules/c8/C8EventGatewayTargetAllowedRule.test.ts
@@ -0,0 +1,90 @@
+import { ERROR_TYPES } from 'bpmnlint-plugin-camunda-compat/rules/utils/error-types.js';
+import { describe } from 'vitest';
+import rule from '../../../../../../../src/adapters/out/bpmnlint/engine/rules/c8/C8EventGatewayTargetAllowedRule.js';
+import { engineModel, verifyEngineRule } from '../../../../../../helpers/engine-model.js';
+
+describe('c8-event-gateway-target-allowed', () => {
+  const TIMER_CATCH =
+    '<bpmn:intermediateCatchEvent id="{id}">{in}<bpmn:timerEventDefinition id="timer_{id}"><bpmn:timeDuration xsi:type="bpmn:tFormalExpression">PT1H</bpmn:timeDuration></bpmn:timerEventDefinition></bpmn:intermediateCatchEvent>';
+  const MESSAGE_CATCH =
+    '<bpmn:intermediateCatchEvent id="{id}">{in}<bpmn:messageEventDefinition id="message_{id}" messageRef="M1" /></bpmn:intermediateCatchEvent>';
+  const MESSAGE = '<bpmn:message id="M1" name="M1" />';
+  function eventGateway(targets: string[], listed = targets.length): string {
+    const outgoing = targets
+      .slice(0, listed)
+      .map((_target, index) => `<bpmn:outgoing>G${index}</bpmn:outgoing>`)
+      .join('');
+    return `
+    <bpmn:startEvent id="Start"><bpmn:outgoing>F1</bpmn:outgoing></bpmn:startEvent>
+    <bpmn:sequenceFlow id="F1" sourceRef="Start" targetRef="G" />
+    <bpmn:eventBasedGateway id="G"><bpmn:incoming>F1</bpmn:incoming>${outgoing}</bpmn:eventBasedGateway>
+    ${targets
+      .map(
+        (target, index) => `
+    <bpmn:sequenceFlow id="G${index}" sourceRef="G" targetRef="T${index}" />
+    ${target.replaceAll('{id}', `T${index}`).replace('{in}', `<bpmn:incoming>G${index}</bpmn:incoming>`)}
+    <bpmn:sequenceFlow id="E${index}" sourceRef="T${index}" targetRef="End${index}" />
+    <bpmn:endEvent id="End${index}" />`,
+      )
+      .join('')}`;
+  }
+  const ONE_BRANCH = eventGateway([TIMER_CATCH]);
+
+  verifyEngineRule(rule, {
+    valid: [
+      {
+        name: 'an event-based gateway with a timer and a message branch',
+        moddleElement: engineModel('c8', eventGateway([TIMER_CATCH, MESSAGE_CATCH]), {
+          roots: MESSAGE,
+        }),
+      },
+      {
+        name: 'a receive task after the gateway (camunda-compat event-based-gateway-target)',
+        moddleElement: engineModel(
+          'c8',
+          eventGateway([
+            TIMER_CATCH,
+            '<bpmn:receiveTask id="{id}" messageRef="M1">{in}</bpmn:receiveTask>',
+          ]),
+          { roots: MESSAGE },
+        ),
+      },
+      {
+        name: 'an event-based gateway with one branch in a process that is not executable',
+        moddleElement: engineModel('c8', ONE_BRANCH, { processAttributes: 'isExecutable="false"' }),
+      },
+      { name: 'a Camunda 7 diagram', moddleElement: engineModel('c7', ONE_BRANCH) },
+    ],
+    invalid: [
+      {
+        name: 'an event-based gateway leading to a task and to a catch event with two definitions',
+        moddleElement: engineModel(
+          'c8',
+          eventGateway([
+            TIMER_CATCH,
+            '<bpmn:task id="{id}">{in}</bpmn:task>',
+            TIMER_CATCH.replace(
+              '</bpmn:intermediateCatchEvent>',
+              '<bpmn:messageEventDefinition id="second_{id}" messageRef="M1" /></bpmn:intermediateCatchEvent>',
+            ),
+          ]),
+          { roots: MESSAGE },
+        ),
+        report: [
+          {
+            id: 'G',
+            message:
+              'Event-based gateway G leads to task T1; Camunda 8 allows only message, timer, signal and conditional intermediate catch events after it and refuses the file',
+            type: ERROR_TYPES.EVENT_BASED_GATEWAY_TARGET_NOT_ALLOWED,
+          },
+          {
+            id: 'G',
+            message:
+              'Event-based gateway G leads to intermediateCatchEvent:timer T2; Camunda 8 allows only message, timer, signal and conditional intermediate catch events after it and refuses the file',
+            type: ERROR_TYPES.EVENT_BASED_GATEWAY_TARGET_NOT_ALLOWED,
+          },
+        ],
+      },
+    ],
+  });
+});
diff --git a/test/adapters/out/bpmnlint/engine/rules/c8/C8EventSubProcessStartNeedsTriggerRule.test.ts b/test/adapters/out/bpmnlint/engine/rules/c8/C8EventSubProcessStartNeedsTriggerRule.test.ts
new file mode 100644
index 00000000..9dd37543
--- /dev/null
+++ b/test/adapters/out/bpmnlint/engine/rules/c8/C8EventSubProcessStartNeedsTriggerRule.test.ts
@@ -0,0 +1,150 @@
+import { ERROR_TYPES } from 'bpmnlint-plugin-camunda-compat/rules/utils/error-types.js';
+import { describe } from 'vitest';
+import rule from '../../../../../../../src/adapters/out/bpmnlint/engine/rules/c8/C8EventSubProcessStartNeedsTriggerRule.js';
+import { engineModel, verifyEngineRule } from '../../../../../../helpers/engine-model.js';
+
+describe('c8-event-sub-process-start-needs-trigger', () => {
+  const TIMER =
+    '<bpmn:timerEventDefinition id="timer_X"><bpmn:timeDuration xsi:type="bpmn:tFormalExpression">PT1H</bpmn:timeDuration></bpmn:timerEventDefinition>';
+  const MESSAGE = '<bpmn:message id="M1" name="M1" />';
+  const CONDITION = '<bpmn:condition xsi:type="bpmn:tFormalExpression">= x &gt; 1</bpmn:condition>';
+  const chain = (middle: string, extra = '') => `
+    <bpmn:startEvent id="Start" />
+    <bpmn:sequenceFlow id="F1" sourceRef="Start" targetRef="X" />
+    ${middle}
+    <bpmn:sequenceFlow id="F2" sourceRef="X" targetRef="End" />
+    <bpmn:endEvent id="End" />
+    ${extra}`;
+  const eventSubProcess = (start: string) => `
+    <bpmn:startEvent id="Start" />
+    <bpmn:sequenceFlow id="F1" sourceRef="Start" targetRef="End" />
+    <bpmn:endEvent id="End" />
+    <bpmn:subProcess id="ESP" triggeredByEvent="true">
+      ${start}
+      <bpmn:sequenceFlow id="ESP_F" sourceRef="ESP_S" targetRef="ESP_E" />
+      <bpmn:endEvent id="ESP_E" />
+    </bpmn:subProcess>`;
+  const COMPENSATION = (
+    boundaryDefinition = '<bpmn:compensateEventDefinition id="CB" />',
+    throwDefinition = '<bpmn:compensateEventDefinition id="CT" />',
+    association = true,
+    boundaryFlow = '',
+  ) => `
+    <bpmn:startEvent id="Start" />
+    <bpmn:sequenceFlow id="F1" sourceRef="Start" targetRef="X" />
+    <bpmn:serviceTask id="X" />
+    <bpmn:boundaryEvent id="B" attachedToRef="X">${boundaryDefinition}</bpmn:boundaryEvent>
+    <bpmn:serviceTask id="H" isForCompensation="true" />
+    <bpmn:sequenceFlow id="F2" sourceRef="X" targetRef="T" />
+    <bpmn:intermediateThrowEvent id="T">${throwDefinition}</bpmn:intermediateThrowEvent>
+    <bpmn:sequenceFlow id="F3" sourceRef="T" targetRef="End" />
+    <bpmn:endEvent id="End" />
+    ${boundaryFlow}
+    ${association ? '<bpmn:association id="A" associationDirection="One" sourceRef="B" targetRef="H" />' : ''}`;
+  const LINKS = (throwDefinition: string, catchDefinition: string) => `
+    <bpmn:startEvent id="Start" />
+    <bpmn:sequenceFlow id="F1" sourceRef="Start" targetRef="X" />
+    <bpmn:intermediateThrowEvent id="X">${throwDefinition}</bpmn:intermediateThrowEvent>
+    <bpmn:intermediateCatchEvent id="C">${catchDefinition}</bpmn:intermediateCatchEvent>
+    <bpmn:sequenceFlow id="FC" sourceRef="C" targetRef="End" />
+    <bpmn:endEvent id="End" />`;
+  const TWO_DEFINITIONS = chain(
+    `<bpmn:intermediateCatchEvent id="X">${TIMER}<bpmn:messageEventDefinition id="MD" messageRef="M1" /></bpmn:intermediateCatchEvent>`,
+  );
+
+  verifyEngineRule(rule, {
+    valid: [
+      {
+        name: 'an event sub-process with a message start event',
+        moddleElement: engineModel(
+          'c8',
+          eventSubProcess(
+            '<bpmn:startEvent id="ESP_S"><bpmn:messageEventDefinition id="MD" messageRef="M1" /></bpmn:startEvent>',
+          ),
+          { roots: MESSAGE },
+        ),
+      },
+      {
+        name: 'conditional events with definition ids',
+        moddleElement: engineModel(
+          'c8',
+          chain(
+            `<bpmn:intermediateCatchEvent id="X"><bpmn:conditionalEventDefinition id="CD1">${CONDITION}</bpmn:conditionalEventDefinition></bpmn:intermediateCatchEvent>`,
+          ),
+        ),
+      },
+      { name: 'compensation with definition ids', moddleElement: engineModel('c8', COMPENSATION()) },
+      {
+        name: 'a link pair with definition ids',
+        moddleElement: engineModel(
+          'c8',
+          LINKS(
+            '<bpmn:linkEventDefinition id="L1" name="L" />',
+            '<bpmn:linkEventDefinition id="L2" name="L" />',
+          ),
+        ),
+      },
+      {
+        name: 'a link throw definition without id',
+        moddleElement: engineModel(
+          'c8',
+          LINKS(
+            '<bpmn:linkEventDefinition name="L" />',
+            '<bpmn:linkEventDefinition id="L2" name="L" />',
+          ),
+        ),
+      },
+      {
+        name: 'catch and boundary events without definition (camunda-compat element-type)',
+        moddleElement: engineModel(
+          'c8',
+          chain(
+            '<bpmn:intermediateCatchEvent id="X" />',
+            '<bpmn:task id="Y" /><bpmn:boundaryEvent id="B" attachedToRef="Y" />',
+          ),
+        ),
+      },
+      {
+        name: 'an event sub-process start with a compensation trigger (camunda-compat element-type)',
+        moddleElement: engineModel(
+          'c8',
+          eventSubProcess(
+            '<bpmn:startEvent id="ESP_S"><bpmn:compensateEventDefinition /></bpmn:startEvent>',
+          ),
+        ),
+      },
+      {
+        name: 'two definitions in a process that is not executable',
+        moddleElement: engineModel('c8', TWO_DEFINITIONS, {
+          roots: MESSAGE,
+          processAttributes: 'isExecutable="false"',
+        }),
+      },
+      {
+        name: 'two definitions inside a transaction',
+        moddleElement: engineModel(
+          'c8',
+          `<bpmn:transaction id="TX"><bpmn:intermediateCatchEvent id="X">${TIMER}<bpmn:messageEventDefinition id="MD" messageRef="M1" /></bpmn:intermediateCatchEvent></bpmn:transaction>`,
+          { roots: MESSAGE },
+        ),
+      },
+      {
+        name: 'a Camunda 7 diagram',
+        moddleElement: engineModel('c7', TWO_DEFINITIONS, { roots: MESSAGE }),
+      },
+    ],
+    invalid: [
+      {
+        name: 'an event sub-process with a none start event',
+        moddleElement: engineModel('c8', eventSubProcess('<bpmn:startEvent id="ESP_S" />')),
+        report: {
+          id: 'ESP_S',
+          message:
+            'Start event ESP_S of event sub-process ESP has no trigger; Camunda 8 needs a message, timer, error, signal, escalation or conditional start there and refuses the file',
+          path: ['eventDefinitions'],
+          type: ERROR_TYPES.PROPERTY_REQUIRED,
+        },
+      },
+    ],
+  });
+});
diff --git a/test/adapters/out/bpmnlint/engine/rules/c8/C8ExecutionListenerEventTypeValidRule.test.ts b/test/adapters/out/bpmnlint/engine/rules/c8/C8ExecutionListenerEventTypeValidRule.test.ts
new file mode 100644
index 00000000..0f6a8745
--- /dev/null
+++ b/test/adapters/out/bpmnlint/engine/rules/c8/C8ExecutionListenerEventTypeValidRule.test.ts
@@ -0,0 +1,196 @@
+import { ERROR_TYPES } from 'bpmnlint-plugin-camunda-compat/rules/utils/error-types.js';
+import { describe } from 'vitest';
+import rule from '../../../../../../../src/adapters/out/bpmnlint/engine/rules/c8/C8ExecutionListenerEventTypeValidRule.js';
+import { engineModel, verifyEngineRule } from '../../../../../../helpers/engine-model.js';
+
+describe('c8-execution-listener-event-type-valid', () => {
+  const ext = (inner: string) => `<bpmn:extensionElements>${inner}</bpmn:extensionElements>`;
+  const EXECUTION = (...listeners: string[]) =>
+    `<zeebe:executionListeners>${listeners.map((listener) => `<zeebe:executionListener ${listener} />`).join('')}</zeebe:executionListeners>`;
+  const TASK = (...listeners: string[]) =>
+    `<zeebe:taskListeners>${listeners.map((listener) => `<zeebe:taskListener ${listener} />`).join('')}</zeebe:taskListeners>`;
+  const SERVICE_TASK = (extra = '') =>
+    `<bpmn:serviceTask id="serviceTask_charge">${ext(`<zeebe:taskDefinition type="charge" />${extra}`)}</bpmn:serviceTask>`;
+  const USER_TASK = (inner: string) =>
+    `<bpmn:userTask id="userTask_review">${ext(inner)}</bpmn:userTask>`;
+  const EXECUTION_TYPE = (index: number, listenerIndex = 0) => [
+    'extensionElements',
+    'values',
+    index,
+    'listeners',
+    listenerIndex,
+    'eventType',
+  ];
+
+  verifyEngineRule(rule, {
+    valid: [
+      {
+        name: 'start and end listeners on a task, a start listener on a gateway, an end listener on a start event',
+        moddleElement: engineModel(
+          'c8',
+          `<bpmn:startEvent id="startEvent_received">${ext(EXECUTION('eventType="end" type="audit"'))}</bpmn:startEvent>
+          ${SERVICE_TASK(EXECUTION('eventType="start" type="audit"', 'eventType="end" type="audit"'))}
+          <bpmn:exclusiveGateway id="gateway_approved">${ext(EXECUTION('eventType="start" type="audit"'))}</bpmn:exclusiveGateway>`,
+        ),
+      },
+      {
+        name: 'task listeners with every event type on a Camunda user task',
+        moddleElement: engineModel(
+          'c8',
+          USER_TASK(
+            `<zeebe:userTask />${TASK(
+              'eventType="creating" type="audit"',
+              'eventType="assigning" type="audit"',
+              'eventType="updating" type="audit"',
+              'eventType="completing" type="audit"',
+              'eventType="canceling" type="audit"',
+              'eventType="complete" type="audit"',
+            )}`,
+          ),
+        ),
+      },
+      {
+        name: 'a listener without type (camunda-compat reports it)',
+        moddleElement: engineModel(
+          'c8',
+          `${SERVICE_TASK(EXECUTION('eventType="start"'))}${USER_TASK(`<zeebe:userTask />${TASK('eventType="creating"')}`)}`,
+        ),
+      },
+      {
+        name: 'beforeAll and cancel listeners on Camunda 8.10 (camunda-compat checks where they go)',
+        moddleElement: engineModel(
+          'c8',
+          SERVICE_TASK(
+            EXECUTION('eventType="beforeAll" type="audit"', 'eventType="cancel" type="audit"'),
+          ),
+        ),
+      },
+      {
+        name: 'listeners in a non-executable process',
+        moddleElement: engineModel(
+          'c8',
+          `<bpmn:startEvent id="startEvent_received">${ext(EXECUTION('eventType="start" type="audit"'))}</bpmn:startEvent>`,
+          { processAttributes: 'isExecutable="false"' },
+        ),
+      },
+      {
+        name: 'listeners inside a transaction (Camunda 8 refuses the transaction as a whole)',
+        moddleElement: engineModel(
+          'c8',
+          `<bpmn:transaction id="transaction_booking">
+            <bpmn:startEvent id="startEvent_booking">${ext(EXECUTION('eventType="start" type="audit"'))}</bpmn:startEvent>
+          </bpmn:transaction>`,
+        ),
+      },
+      {
+        name: 'task listeners on a service task (c8-zeebe-extension-placement reports them)',
+        moddleElement: engineModel('c8', SERVICE_TASK(TASK('eventType="foo" type="audit"'))),
+      },
+      {
+        name: 'a Camunda 7 diagram',
+        moddleElement: engineModel(
+          'c7',
+          `<bpmn:startEvent id="startEvent_received">${ext('<camunda:executionListener event="start" class="Audit" />')}</bpmn:startEvent>`,
+        ),
+      },
+    ],
+    invalid: [
+      {
+        name: 'an execution listener without type, one with an unknown event type',
+        moddleElement: engineModel(
+          'c8',
+          SERVICE_TASK(EXECUTION('eventType="start"', 'eventType="take" type="audit"')),
+          { version: '8.9.0' },
+        ),
+        report: {
+          id: 'serviceTask_charge',
+          message:
+            'Execution listener 2 (take) of serviceTask serviceTask_charge: eventType "take" is not start or end; Camunda 8 refuses the file',
+          path: EXECUTION_TYPE(1, 1),
+          type: ERROR_TYPES.PROPERTY_VALUE_NOT_ALLOWED,
+        },
+      },
+      {
+        name: 'an execution listener with an unknown event type on Camunda 8.10',
+        moddleElement: engineModel('c8', SERVICE_TASK(EXECUTION('eventType="take" type="audit"'))),
+        report: {
+          id: 'serviceTask_charge',
+          message:
+            'Execution listener 1 (take) of serviceTask serviceTask_charge: eventType "take" is not one of start, end, beforeAll, cancel; Camunda 8 refuses the file',
+          path: EXECUTION_TYPE(1),
+          type: ERROR_TYPES.PROPERTY_VALUE_NOT_ALLOWED,
+        },
+      },
+      {
+        name: 'a beforeAll listener on Camunda 8.9',
+        moddleElement: engineModel(
+          'c8',
+          SERVICE_TASK(EXECUTION('eventType="beforeAll" type="audit"')),
+          {
+            version: '8.9.0',
+          },
+        ),
+        report: {
+          id: 'serviceTask_charge',
+          message:
+            'Execution listener 1 (beforeAll) of serviceTask serviceTask_charge: eventType "beforeAll" is not start or end; Camunda 8 refuses the file',
+          path: EXECUTION_TYPE(1),
+          type: ERROR_TYPES.PROPERTY_VALUE_NOT_ALLOWED,
+        },
+      },
+      {
+        name: 'an execution listener with a blank event type',
+        moddleElement: engineModel('c8', SERVICE_TASK(EXECUTION('eventType=" " type="audit"'))),
+        report: {
+          id: 'serviceTask_charge',
+          message:
+            'Execution listener 1 of serviceTask serviceTask_charge has no eventType; Camunda 8 refuses the file',
+          path: EXECUTION_TYPE(1),
+          type: ERROR_TYPES.PROPERTY_REQUIRED,
+        },
+      },
+      {
+        name: 'start listeners on a start event and a boundary event',
+        moddleElement: engineModel(
+          'c8',
+          `<bpmn:startEvent id="startEvent_received">${ext(EXECUTION('eventType="start" type="audit"'))}</bpmn:startEvent>
+          ${SERVICE_TASK()}
+          <bpmn:boundaryEvent id="boundaryEvent_timeout" attachedToRef="serviceTask_charge">
+            ${ext(EXECUTION('eventType="start" type="audit"'))}
+            <bpmn:timerEventDefinition><bpmn:timeDuration>PT1H</bpmn:timeDuration></bpmn:timerEventDefinition>
+          </bpmn:boundaryEvent>`,
+        ),
+        report: [
+          {
+            id: 'startEvent_received',
+            message:
+              'Execution listener 1 (start) of startEvent startEvent_received: Camunda 8 does not support start listeners on start events and refuses the file',
+            path: EXECUTION_TYPE(0),
+            type: ERROR_TYPES.PROPERTY_VALUE_NOT_ALLOWED,
+          },
+          {
+            id: 'boundaryEvent_timeout',
+            message:
+              'Execution listener 1 (start) of boundaryEvent:timer boundaryEvent_timeout: Camunda 8 does not support start listeners on boundary events and refuses the file',
+            path: EXECUTION_TYPE(0),
+            type: ERROR_TYPES.PROPERTY_VALUE_NOT_ALLOWED,
+          },
+        ],
+      },
+      {
+        name: 'an end listener on a gateway',
+        moddleElement: engineModel(
+          'c8',
+          `<bpmn:exclusiveGateway id="gateway_approved">${ext(EXECUTION('eventType="end" type="audit"'))}</bpmn:exclusiveGateway>`,
+        ),
+        report: {
+          id: 'gateway_approved',
+          message:
+            'Execution listener 1 (end) of exclusiveGateway gateway_approved: Camunda 8 does not support end listeners on gateways and refuses the file',
+          path: EXECUTION_TYPE(0),
+          type: ERROR_TYPES.PROPERTY_VALUE_NOT_ALLOWED,
+        },
+      },
+    ],
+  });
+});
diff --git a/test/adapters/out/bpmnlint/engine/rules/c8/C8ExtensionElementUniqueRule.test.ts b/test/adapters/out/bpmnlint/engine/rules/c8/C8ExtensionElementUniqueRule.test.ts
new file mode 100644
index 00000000..3b0369b8
--- /dev/null
+++ b/test/adapters/out/bpmnlint/engine/rules/c8/C8ExtensionElementUniqueRule.test.ts
@@ -0,0 +1,179 @@
+import { ERROR_TYPES } from 'bpmnlint-plugin-camunda-compat/rules/utils/error-types.js';
+import { describe } from 'vitest';
+import rule from '../../../../../../../src/adapters/out/bpmnlint/engine/rules/c8/C8ExtensionElementUniqueRule.js';
+import { engineModel, verifyEngineRule } from '../../../../../../helpers/engine-model.js';
+
+describe('c8-extension-element-unique', () => {
+  const ext = (inner: string) => `<bpmn:extensionElements>${inner}</bpmn:extensionElements>`;
+  const TASK_DEFINITION = (type = 'charge') => `<zeebe:taskDefinition type="${type}" />`;
+  const SERVICE_TASK = (inner: string) =>
+    `<bpmn:serviceTask id="serviceTask_charge">${ext(inner)}</bpmn:serviceTask>`;
+  const MESSAGE = (subscriptions: string) =>
+    `<bpmn:message id="message_paid" name="paid">${ext(subscriptions)}</bpmn:message>`;
+  const SUBSCRIPTION = (key: string) => `<zeebe:subscription correlationKey="=${key}" />`;
+  const DUPLICATE = (id: string, message: string, index: number) => ({
+    id,
+    message,
+    path: ['extensionElements', 'values', index],
+    type: ERROR_TYPES.ELEMENT_MULTIPLE_NOT_ALLOWED,
+  });
+
+  verifyEngineRule(rule, {
+    valid: [
+      {
+        name: 'one of each zeebe element',
+        moddleElement: engineModel(
+          'c8',
+          `${ext('<zeebe:versionTag value="v1" />')}
+          ${SERVICE_TASK(`${TASK_DEFINITION()}<zeebe:ioMapping><zeebe:input source="=a" target="a" /></zeebe:ioMapping><zeebe:taskHeaders><zeebe:header key="k" value="v" /></zeebe:taskHeaders>`)}
+          <bpmn:receiveTask id="receiveTask_paid" messageRef="message_paid" />`,
+          { roots: MESSAGE(SUBSCRIPTION('orderId')) },
+        ),
+      },
+      {
+        name: 'two zeebe elements on a host that does not read them (c8-zeebe-extension-placement reports them)',
+        moddleElement: engineModel(
+          'c8',
+          SERVICE_TASK(`${TASK_DEFINITION()}<zeebe:userTask /><zeebe:userTask />`),
+        ),
+      },
+      {
+        name: 'two subscriptions on a message no executable process uses',
+        moddleElement: engineModel('c8', '<bpmn:startEvent id="startEvent_received" />', {
+          roots: MESSAGE(SUBSCRIPTION('orderId') + SUBSCRIPTION('invoiceId')),
+        }),
+      },
+      {
+        name: 'two task definitions in a non-executable process',
+        moddleElement: engineModel('c8', SERVICE_TASK(TASK_DEFINITION('a') + TASK_DEFINITION('b')), {
+          processAttributes: 'isExecutable="false"',
+        }),
+      },
+      {
+        name: 'a Camunda 7 diagram',
+        moddleElement: engineModel(
+          'c7',
+          `<bpmn:serviceTask id="serviceTask_charge" camunda:type="external" camunda:topic="charge">${ext(
+            '<camunda:inputOutput /><camunda:inputOutput />',
+          )}</bpmn:serviceTask>`,
+        ),
+      },
+    ],
+    invalid: [
+      {
+        name: 'two zeebe:taskDefinition',
+        moddleElement: engineModel('c8', SERVICE_TASK(TASK_DEFINITION('a') + TASK_DEFINITION('b'))),
+        report: DUPLICATE(
+          'serviceTask_charge',
+          'serviceTask serviceTask_charge has 2 zeebe:taskDefinition elements; Camunda 8 reads one and refuses the file',
+          1,
+        ),
+      },
+      {
+        name: 'two zeebe:calledElement',
+        moddleElement: engineModel(
+          'c8',
+          `<bpmn:callActivity id="callActivity_ship">${ext('<zeebe:calledElement processId="a" /><zeebe:calledElement processId="b" />')}</bpmn:callActivity>`,
+        ),
+        report: DUPLICATE(
+          'callActivity_ship',
+          'callActivity callActivity_ship has 2 zeebe:calledElement elements; Camunda 8 reads one and refuses the file',
+          1,
+        ),
+      },
+      {
+        name: 'two zeebe:ioMapping',
+        moddleElement: engineModel(
+          'c8',
+          SERVICE_TASK(
+            `${TASK_DEFINITION()}<zeebe:ioMapping><zeebe:input source="=a" target="a" /></zeebe:ioMapping><zeebe:ioMapping><zeebe:input source="=b" target="b" /></zeebe:ioMapping>`,
+          ),
+        ),
+        report: DUPLICATE(
+          'serviceTask_charge',
+          'serviceTask serviceTask_charge has 2 zeebe:ioMapping elements; Camunda 8 reads one and refuses the file',
+          2,
+        ),
+      },
+      {
+        name: 'two zeebe:userTask, zeebe:assignmentDefinition, zeebe:taskSchedule',
+        moddleElement: engineModel(
+          'c8',
+          `<bpmn:userTask id="userTask_review">${ext(
+            '<zeebe:userTask /><zeebe:userTask /><zeebe:assignmentDefinition assignee="a" /><zeebe:assignmentDefinition candidateGroups="g" /><zeebe:taskSchedule dueDate="=a" /><zeebe:taskSchedule followUpDate="=b" />',
+          )}</bpmn:userTask>`,
+        ),
+        report: [
+          DUPLICATE(
+            'userTask_review',
+            'userTask userTask_review has 2 zeebe:userTask elements; Camunda 8 reads one and refuses the file',
+            1,
+          ),
+          DUPLICATE(
+            'userTask_review',
+            'userTask userTask_review has 2 zeebe:assignmentDefinition elements; Camunda 8 reads one and refuses the file',
+            3,
+          ),
+          DUPLICATE(
+            'userTask_review',
+            'userTask userTask_review has 2 zeebe:taskSchedule elements; Camunda 8 reads one and refuses the file',
+            5,
+          ),
+        ],
+      },
+      {
+        name: 'two zeebe:properties, two zeebe:versionTag',
+        moddleElement: engineModel(
+          'c8',
+          `${ext('<zeebe:versionTag value="v1" /><zeebe:versionTag value="v2" />')}
+          ${SERVICE_TASK(
+            `${TASK_DEFINITION()}<zeebe:properties><zeebe:property name="a" value="1" /></zeebe:properties><zeebe:properties><zeebe:property name="b" value="2" /></zeebe:properties>`,
+          )}`,
+        ),
+        report: [
+          DUPLICATE(
+            'process_test',
+            'process process_test has 2 zeebe:versionTag elements; Camunda 8 reads one and refuses the file',
+            1,
+          ),
+          DUPLICATE(
+            'serviceTask_charge',
+            'serviceTask serviceTask_charge has 2 zeebe:properties elements; Camunda 8 reads one and refuses the file',
+            2,
+          ),
+        ],
+      },
+      {
+        name: 'two zeebe:subscription on one message',
+        moddleElement: engineModel(
+          'c8',
+          '<bpmn:receiveTask id="receiveTask_paid" messageRef="message_paid" />',
+          { roots: MESSAGE(SUBSCRIPTION('orderId') + SUBSCRIPTION('invoiceId')) },
+        ),
+        report: DUPLICATE(
+          'message_paid',
+          'message message_paid has 2 zeebe:subscription elements; Camunda 8 reads one and refuses the file',
+          1,
+        ),
+      },
+      {
+        name: 'three zeebe:loopCharacteristics on a multi-instance loop',
+        moddleElement: engineModel(
+          'c8',
+          `<bpmn:serviceTask id="serviceTask_charge">${ext(TASK_DEFINITION())}
+            <bpmn:multiInstanceLoopCharacteristics>${ext(
+              '<zeebe:loopCharacteristics inputCollection="=a" /><zeebe:loopCharacteristics inputCollection="=b" /><zeebe:loopCharacteristics inputCollection="=c" />',
+            )}</bpmn:multiInstanceLoopCharacteristics>
+          </bpmn:serviceTask>`,
+        ),
+        report: {
+          id: 'serviceTask_charge',
+          message:
+            'the multiInstanceLoopCharacteristics of serviceTask serviceTask_charge has 3 zeebe:loopCharacteristics elements; Camunda 8 reads one and refuses the file',
+          path: ['loopCharacteristics', 'extensionElements', 'values', 1],
+          type: ERROR_TYPES.ELEMENT_MULTIPLE_NOT_ALLOWED,
+        },
+      },
+    ],
+  });
+});
diff --git a/test/adapters/out/bpmnlint/engine/rules/c8/C8FeelExpressionValidRule.test.ts b/test/adapters/out/bpmnlint/engine/rules/c8/C8FeelExpressionValidRule.test.ts
new file mode 100644
index 00000000..84ac8e68
--- /dev/null
+++ b/test/adapters/out/bpmnlint/engine/rules/c8/C8FeelExpressionValidRule.test.ts
@@ -0,0 +1,368 @@
+import { ERROR_TYPES } from 'bpmnlint-plugin-camunda-compat/rules/utils/error-types.js';
+import rule from '../../../../../../../src/adapters/out/bpmnlint/engine/rules/c8/C8FeelExpressionValidRule.js';
+import { engineModel, verifyEngineRule } from '../../../../../../helpers/engine-model.js';
+
+const BAD = '= (a';
+const BAD_PROBLEM = 'an unclosed (';
+const REFUSED = 'Camunda 8 parses it at deploy and refuses the file';
+const ext = (inner: string) => `<bpmn:extensionElements>${inner}</bpmn:extensionElements>`;
+const JOB = '<zeebe:taskDefinition type="work" />';
+const escape = (text: string) =>
+  text.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;');
+const chain = (middle: string) => `
+  <bpmn:startEvent id="startEvent_start" />
+  <bpmn:sequenceFlow id="flow_toX" sourceRef="startEvent_start" targetRef="X" />
+  ${middle}
+  <bpmn:sequenceFlow id="flow_fromX" sourceRef="X" targetRef="endEvent_end" />
+  <bpmn:endEvent id="endEvent_end" />`;
+const gateway = (condition: string) => `
+  <bpmn:startEvent id="startEvent_start" />
+  <bpmn:sequenceFlow id="flow_toGateway" sourceRef="startEvent_start" targetRef="G" />
+  <bpmn:exclusiveGateway id="G" default="SD" />
+  <bpmn:sequenceFlow id="SD" sourceRef="G" targetRef="endEvent_default" />
+  <bpmn:endEvent id="endEvent_default" />
+  <bpmn:sequenceFlow id="S0" sourceRef="G" targetRef="endEvent_s0">
+    <bpmn:conditionExpression xsi:type="bpmn:tFormalExpression">${escape(condition)}</bpmn:conditionExpression>
+  </bpmn:sequenceFlow>
+  <bpmn:endEvent id="endEvent_s0" />`;
+const adHoc = (inner: string, zeebe = '') =>
+  chain(
+    `<bpmn:adHocSubProcess id="X">${zeebe ? ext(zeebe) : ''}<bpmn:task id="A1" />${inner}</bpmn:adHocSubProcess>`,
+  );
+const completion = (body: string) =>
+  `<bpmn:completionCondition xsi:type="bpmn:tFormalExpression">${escape(body)}</bpmn:completionCondition>`;
+const multiInstance = (zeebeLoop: string, inner = '') =>
+  chain(
+    `<bpmn:serviceTask id="X">${ext(JOB)}<bpmn:multiInstanceLoopCharacteristics>${ext(zeebeLoop)}${inner}</bpmn:multiInstanceLoopCharacteristics></bpmn:serviceTask>`,
+  );
+const timer = (kind: string, value: string) =>
+  `<bpmn:timerEventDefinition id="TD1"><bpmn:${kind} xsi:type="bpmn:tFormalExpression">${escape(value)}</bpmn:${kind}></bpmn:timerEventDefinition>`;
+const conditional = (condition: string) =>
+  `<bpmn:conditionalEventDefinition id="CD1"><bpmn:condition xsi:type="bpmn:tFormalExpression">${escape(condition)}</bpmn:condition></bpmn:conditionalEventDefinition>`;
+const message = (name: string, key: string | null = '=orderId') =>
+  `<bpmn:message id="M1" name="${escape(name)}">${key === null ? '' : ext(`<zeebe:subscription correlationKey="${escape(key)}" />`)}</bpmn:message>`;
+const signal = (name: string) => `<bpmn:signal id="Sig" name="${escape(name)}" />`;
+const feel = (
+  id: string,
+  what: string,
+  value: string,
+  problem: string,
+  path: (string | number)[],
+) => ({
+  id,
+  message: `${what} "${value}" is no valid FEEL: ${problem}; ${REFUSED}`,
+  path,
+  type: ERROR_TYPES.FEEL_EXPRESSION_INVALID,
+});
+const REFUSED_CONDITIONS: Array<[string, string]> = [
+  ['= x & y', '& (FEEL: and)'],
+  ['= x | y', '| (FEEL: or)'],
+  ['= x <> 1', '<> (FEEL: != for "not equal")'],
+  ['= x >> 1', '>> (FEEL has no shift operators)'],
+  ['= x % 2 = 0', '% (FEEL has no modulo operator: modulo(a, b))'],
+  ['= if x then true', 'if ... then without else: FEEL needs if c then a else b'],
+  ['= x AND y', 'AND (FEEL keywords are lower case: and)'],
+  ['= x := 1', ':= (FEEL has no assignment; = compares)'],
+  ['= x == 1 && y', '&& (FEEL: and)'],
+];
+
+verifyEngineRule(rule, {
+  valid: [
+    ...[
+      '= x andy',
+      '= x in [1..5]',
+      '= x in (> 1, < 5)',
+      '= {a: 1}.a = 1',
+      '= string length(x) > 2',
+    ].map((condition) => ({
+      name: `a condition FEEL accepts: ${condition}`,
+      moddleElement: engineModel('c8', gateway(condition)),
+    })),
+    {
+      name: 'a FEEL completion condition of an ad-hoc sub-process',
+      moddleElement: engineModel('c8', adHoc(completion('= a and b'))),
+    },
+    {
+      name: 'attributes Camunda 8 does not parse at deploy (listener type, header value)',
+      moddleElement: engineModel(
+        'c8',
+        chain(
+          `<bpmn:serviceTask id="X">${ext(`${JOB}<zeebe:taskHeaders><zeebe:header key="k" value="${BAD}" /></zeebe:taskHeaders><zeebe:executionListeners><zeebe:executionListener eventType="end" type="${BAD}" /></zeebe:executionListeners>`)}</bpmn:serviceTask>`,
+        ),
+      ),
+    },
+    {
+      name: 'a FEEL timer value',
+      moddleElement: engineModel(
+        'c8',
+        chain(
+          `<bpmn:intermediateCatchEvent id="X">${timer('timeDuration', '=wait')}</bpmn:intermediateCatchEvent>`,
+        ),
+      ),
+    },
+    {
+      name: 'FEEL values in the multi-instance and the script',
+      moddleElement: engineModel(
+        'c8',
+        multiInstance(
+          '<zeebe:loopCharacteristics inputCollection="=items" outputCollection="out" outputElement="=result" />',
+          completion('= done'),
+        ) +
+          `<bpmn:scriptTask id="Y">${ext('<zeebe:script expression="=1 + 1" resultVariable="r" />')}</bpmn:scriptTask>`,
+      ),
+    },
+    {
+      name: 'a multi-instance completion condition that is no FEEL (a runtime matter, c8-multi-instance-completion-needs-feel)',
+      moddleElement: engineModel(
+        'c8',
+        multiInstance(
+          '<zeebe:loopCharacteristics inputCollection="=items" />',
+          completion('${done}'),
+        ),
+      ),
+    },
+    {
+      name: 'a JUEL condition in a process that is not executable',
+      moddleElement: engineModel('c8', gateway('${x > 1}'), {
+        processAttributes: 'isExecutable="false"',
+      }),
+    },
+    {
+      name: 'a JUEL condition inside a transaction (refused as a whole)',
+      moddleElement: engineModel(
+        'c8',
+        `<bpmn:transaction id="X">${gateway('${x > 1}')}</bpmn:transaction>`,
+      ),
+    },
+    {
+      name: 'a zeebe:script on a service task (not read there)',
+      moddleElement: engineModel(
+        'c8',
+        chain(
+          `<bpmn:serviceTask id="X">${ext(`${JOB}<zeebe:script expression="${BAD}" resultVariable="r" />`)}</bpmn:serviceTask>`,
+        ),
+      ),
+    },
+    {
+      name: 'a zeebe:input outside its zeebe:ioMapping (not read)',
+      moddleElement: engineModel(
+        'c8',
+        chain(
+          `<bpmn:serviceTask id="X">${ext(`${JOB}<zeebe:input source="${BAD}" target="a" />`)}</bpmn:serviceTask>`,
+        ),
+      ),
+    },
+    {
+      name: 'a script with a job (the job runs, the script is not read)',
+      moddleElement: engineModel(
+        'c8',
+        chain(
+          `<bpmn:scriptTask id="X">${ext(`${JOB}<zeebe:script expression="1 + 1" resultVariable="r" />`)}</bpmn:scriptTask>`,
+        ),
+      ),
+    },
+    {
+      name: 'a message no element uses, with a FEEL slip in its name and key',
+      moddleElement: engineModel('c8', chain('<bpmn:task id="X" />'), { roots: message(BAD, BAD) }),
+    },
+    {
+      name: 'a timer cycle on an intermediate catch event (refused for the cycle)',
+      moddleElement: engineModel(
+        'c8',
+        chain(
+          `<bpmn:intermediateCatchEvent id="X">${timer('timeCycle', BAD)}</bpmn:intermediateCatchEvent>`,
+        ),
+      ),
+    },
+    {
+      name: 'a static correlation key on the message of a process start event (not read there)',
+      moddleElement: engineModel(
+        'c8',
+        `<bpmn:startEvent id="S"><bpmn:messageEventDefinition id="MD" messageRef="M1" /></bpmn:startEvent>
+         <bpmn:sequenceFlow id="F" sourceRef="S" targetRef="E" /><bpmn:endEvent id="E" />`,
+        { roots: message('Paid', 'orderId') },
+      ),
+    },
+    {
+      name: 'an event with two definitions (refused for that)',
+      moddleElement: engineModel(
+        'c8',
+        chain(
+          `<bpmn:intermediateCatchEvent id="X">${conditional('true')}${timer('timeDuration', 'PT1H')}</bpmn:intermediateCatchEvent>`,
+        ),
+      ),
+    },
+    {
+      name: 'a Camunda 7 diagram',
+      moddleElement: engineModel('c7', gateway('${x > 1}')),
+    },
+  ],
+  invalid: [
+    ...REFUSED_CONDITIONS.map(([condition, problem]) => ({
+      name: `a condition FEEL refuses: ${condition}`,
+      moddleElement: engineModel('c8', gateway(condition)),
+      report: feel('S0', 'The condition of sequence flow S0', condition, problem, [
+        'conditionExpression',
+      ]),
+    })),
+    {
+      name: 'a FEEL slip in a zeebe:script',
+      moddleElement: engineModel(
+        'c8',
+        chain(
+          `<bpmn:scriptTask id="X">${ext('<zeebe:script expression="= if a then 1" resultVariable="r" />')}</bpmn:scriptTask>`,
+        ),
+      ),
+      report: feel(
+        'X',
+        'expression of zeebe:script of scriptTask X',
+        '= if a then 1',
+        'if ... then without else: FEEL needs if c then a else b',
+        ['extensionElements', 'values', 0, 'expression'],
+      ),
+    },
+    {
+      name: 'a FEEL slip in an ad-hoc completion condition',
+      moddleElement: engineModel('c8', adHoc(completion(BAD))),
+      report: feel('X', 'The completion condition of ad-hoc sub-process X', BAD, BAD_PROBLEM, [
+        'completionCondition',
+      ]),
+    },
+    ...['activeElementsCollection', 'outputElement'].map((attribute) => ({
+      name: `a FEEL slip in the ${attribute} of zeebe:adHoc`,
+      moddleElement: engineModel(
+        'c8',
+        adHoc('', `<zeebe:adHoc outputCollection="res" ${attribute}="${BAD}" />`),
+      ),
+      report: feel('X', `${attribute} of zeebe:adHoc of adHocSubProcess X`, BAD, BAD_PROBLEM, [
+        'extensionElements',
+        'values',
+        0,
+        attribute,
+      ]),
+    })),
+    ...['intermediateThrowEvent', 'intermediateCatchEvent'].map((kind) => ({
+      name: `a FEEL slip in the name of a signal (${kind})`,
+      moddleElement: engineModel(
+        'c8',
+        chain(
+          `<bpmn:${kind} id="X"><bpmn:signalEventDefinition id="SD" signalRef="Sig" /></bpmn:${kind}>`,
+        ),
+        { roots: signal(BAD) },
+      ),
+      report: feel('Sig', 'The name of signal Sig', BAD, BAD_PROBLEM, ['name']),
+    })),
+    {
+      name: 'a FEEL slip in the name of a published message, in a process that is not executable',
+      moddleElement: engineModel(
+        'c8',
+        chain(`<bpmn:sendTask id="X" messageRef="M1">${ext(JOB)}</bpmn:sendTask>`),
+        {
+          roots: message(BAD, null),
+          processAttributes: 'isExecutable="false"',
+        },
+      ),
+      report: feel('M1', 'The name of message M1', BAD, BAD_PROBLEM, ['name']),
+    },
+    {
+      name: 'a FEEL slip in the correlation key of a caught message, reported on the message',
+      moddleElement: engineModel('c8', chain('<bpmn:receiveTask id="X" messageRef="M1" />'), {
+        roots: message('Paid', BAD),
+      }),
+      report: feel('M1', 'correlationKey of zeebe:subscription of message M1', BAD, BAD_PROBLEM, [
+        'extensionElements',
+        'values',
+        0,
+        'correlationKey',
+      ]),
+    },
+    {
+      name: 'a FEEL slip in the inputCollection, reported through the loop',
+      moddleElement: engineModel(
+        'c8',
+        multiInstance(`<zeebe:loopCharacteristics inputCollection="${BAD}" />`),
+      ),
+      report: feel(
+        'X',
+        'inputCollection of zeebe:loopCharacteristics of the multiInstanceLoopCharacteristics of serviceTask X',
+        BAD,
+        BAD_PROBLEM,
+        ['loopCharacteristics', 'extensionElements', 'values', 0, 'inputCollection'],
+      ),
+    },
+    {
+      name: 'a FEEL slip in a multi-instance completion condition',
+      moddleElement: engineModel(
+        'c8',
+        multiInstance('<zeebe:loopCharacteristics inputCollection="=items" />', completion(BAD)),
+      ),
+      report: feel(
+        'X',
+        'The completion condition of multi-instance serviceTask X',
+        BAD,
+        BAD_PROBLEM,
+        ['loopCharacteristics', 'completionCondition'],
+      ),
+    },
+    {
+      name: 'an input mapping with a JUEL slip',
+      moddleElement: engineModel(
+        'c8',
+        chain(
+          `<bpmn:serviceTask id="X">${ext(`${JOB}<zeebe:ioMapping><zeebe:input source="= a &amp;&amp; b" target="a" /></zeebe:ioMapping>`)}</bpmn:serviceTask>`,
+        ),
+      ),
+      report: feel(
+        'X',
+        'source of zeebe:input (in zeebe:ioMapping) of serviceTask X',
+        '= a && b',
+        '&& (FEEL: and)',
+        ['extensionElements', 'values', 1, 'inputParameters', 0, 'source'],
+      ),
+    },
+    {
+      name: 'a FEEL slip in the condition of a conditional event',
+      moddleElement: engineModel(
+        'c8',
+        chain(
+          `<bpmn:intermediateCatchEvent id="X">${conditional(BAD)}</bpmn:intermediateCatchEvent>`,
+        ),
+      ),
+      report: feel('X', 'The condition of conditional event X', BAD, BAD_PROBLEM, [
+        'eventDefinitions',
+        0,
+        'condition',
+      ]),
+    },
+    {
+      name: 'a FEEL slip in a timer',
+      moddleElement: engineModel(
+        'c8',
+        chain(
+          `<bpmn:intermediateCatchEvent id="X">${timer('timeDuration', BAD)}</bpmn:intermediateCatchEvent>`,
+        ),
+      ),
+      report: feel('X', 'The timeDuration of intermediateCatchEvent:timer X', BAD, BAD_PROBLEM, [
+        'eventDefinitions',
+        0,
+        'timeDuration',
+      ]),
+    },
+    {
+      name: 'a JUEL value in a zeebe:taskDefinition type',
+      moddleElement: engineModel(
+        'c8',
+        chain(
+          `<bpmn:serviceTask id="X">${ext('<zeebe:taskDefinition type="=${kind}" />')}</bpmn:serviceTask>`,
+        ),
+      ),
+      report: feel(
+        'X',
+        'type of zeebe:taskDefinition of serviceTask X',
+        '=${kind}',
+        '${...} (JUEL; FEEL writes the expression itself: = amount > 100)',
+        ['extensionElements', 'values', 0, 'type'],
+      ),
+    },
+  ],
+});
diff --git a/test/adapters/out/bpmnlint/engine/rules/c8/C8InputMappingPlacementRule.test.ts b/test/adapters/out/bpmnlint/engine/rules/c8/C8InputMappingPlacementRule.test.ts
new file mode 100644
index 00000000..f6b58a4b
--- /dev/null
+++ b/test/adapters/out/bpmnlint/engine/rules/c8/C8InputMappingPlacementRule.test.ts
@@ -0,0 +1,111 @@
+import { ERROR_TYPES } from 'bpmnlint-plugin-camunda-compat/rules/utils/error-types.js';
+import { describe } from 'vitest';
+import rule from '../../../../../../../src/adapters/out/bpmnlint/engine/rules/c8/C8InputMappingPlacementRule.js';
+import { engineModel, verifyEngineRule } from '../../../../../../helpers/engine-model.js';
+
+describe('c8-input-mapping-placement', () => {
+  const ext = (inner: string) => `<bpmn:extensionElements>${inner}</bpmn:extensionElements>`;
+  const TASK_DEFINITION = '<zeebe:taskDefinition type="charge" />';
+  const SERVICE_TASK = (inner: string, loop = '') =>
+    `<bpmn:serviceTask id="serviceTask_charge">${ext(inner)}${loop}</bpmn:serviceTask>`;
+  const IO_MAPPING = (mappings: string) => `<zeebe:ioMapping>${mappings}</zeebe:ioMapping>`;
+  const TIMER =
+    '<bpmn:timerEventDefinition><bpmn:timeDuration>PT1H</bpmn:timeDuration></bpmn:timerEventDefinition>';
+  const NOT_READ = (id: string, message: string, path: (string | number)[]) => ({
+    id,
+    message,
+    path,
+    type: ERROR_TYPES.EXTENSION_ELEMENT_NOT_ALLOWED,
+  });
+
+  verifyEngineRule(rule, {
+    valid: [
+      {
+        name: 'zeebe content where Camunda 8 reads it',
+        moddleElement: engineModel(
+          'c8',
+          `${SERVICE_TASK(
+            TASK_DEFINITION + IO_MAPPING('<zeebe:input source="=a" target="a" />'),
+            `<bpmn:multiInstanceLoopCharacteristics>${ext('<zeebe:loopCharacteristics inputCollection="=items" inputElement="item" />')}</bpmn:multiInstanceLoopCharacteristics>`,
+          )}
+          <bpmn:userTask id="userTask_review">${ext('<zeebe:userTask /><zeebe:assignmentDefinition assignee="demo" /><zeebe:properties><zeebe:property name="a" value="1" /></zeebe:properties>')}</bpmn:userTask>
+          <bpmn:receiveTask id="receiveTask_paid" messageRef="message_paid" />`,
+          {
+            roots: `<bpmn:message id="message_paid" name="paid">${ext('<zeebe:subscription correlationKey="=orderId" />')}</bpmn:message>`,
+          },
+        ),
+      },
+      {
+        name: 'output mappings on a start event, input mappings on a message throw event',
+        moddleElement: engineModel(
+          'c8',
+          `<bpmn:startEvent id="startEvent_received">${ext(IO_MAPPING('<zeebe:output source="=1" target="b" />'))}</bpmn:startEvent>
+          <bpmn:intermediateThrowEvent id="event_notified">${ext(IO_MAPPING('<zeebe:input source="=1" target="a" />'))}
+            <bpmn:messageEventDefinition id="messageEventDefinition_notified" />
+          </bpmn:intermediateThrowEvent>`,
+        ),
+      },
+      {
+        name: 'execution listeners on a sequence flow (c8-sequence-flow-no-execution-listeners reports them)',
+        moddleElement: engineModel(
+          'c8',
+          `<bpmn:startEvent id="startEvent_received" />
+          <bpmn:sequenceFlow id="flow_received" sourceRef="startEvent_received" targetRef="endEvent_done">
+            ${ext('<zeebe:executionListeners><zeebe:executionListener eventType="start" type="audit" /></zeebe:executionListeners>')}
+          </bpmn:sequenceFlow>
+          <bpmn:endEvent id="endEvent_done" />`,
+        ),
+      },
+      {
+        name: 'misplaced zeebe content in a non-executable process',
+        moddleElement: engineModel(
+          'c8',
+          `<bpmn:startEvent id="startEvent_received">${ext(IO_MAPPING('<zeebe:input source="=1" target="a" />'))}</bpmn:startEvent>`,
+          { processAttributes: 'isExecutable="false"' },
+        ),
+      },
+      {
+        name: 'a Camunda 7 diagram',
+        moddleElement: engineModel(
+          'c7',
+          `<bpmn:startEvent id="startEvent_received">${ext('<camunda:inputOutput><camunda:inputParameter name="a">1</camunda:inputParameter></camunda:inputOutput>')}</bpmn:startEvent>`,
+        ),
+      },
+    ],
+    invalid: [
+      {
+        name: 'input mappings on a start, a boundary, a none throw and a none end event',
+        moddleElement: engineModel(
+          'c8',
+          `<bpmn:startEvent id="startEvent_received">${ext(IO_MAPPING('<zeebe:input source="=1" target="a" /><zeebe:output source="=2" target="b" />'))}</bpmn:startEvent>
+          ${SERVICE_TASK(TASK_DEFINITION)}
+          <bpmn:boundaryEvent id="boundaryEvent_timeout" attachedToRef="serviceTask_charge">${ext(IO_MAPPING('<zeebe:input source="=1" target="c" />'))}${TIMER}</bpmn:boundaryEvent>
+          <bpmn:intermediateThrowEvent id="event_charged">${ext(IO_MAPPING('<zeebe:input source="=1" target="d" />'))}</bpmn:intermediateThrowEvent>
+          <bpmn:endEvent id="endEvent_done">${ext(IO_MAPPING('<zeebe:input source="=1" />'))}</bpmn:endEvent>`,
+        ),
+        report: [
+          NOT_READ(
+            'startEvent_received',
+            'The input mapping to a on startEvent startEvent_received has no effect: Camunda 8 ignores input mappings on start events (output mappings work there)',
+            ['extensionElements', 'values', 0, 'inputParameters', 0],
+          ),
+          NOT_READ(
+            'boundaryEvent_timeout',
+            'The input mapping to c on boundaryEvent:timer boundaryEvent_timeout has no effect: Camunda 8 ignores input mappings on boundary events (output mappings work there)',
+            ['extensionElements', 'values', 0, 'inputParameters', 0],
+          ),
+          NOT_READ(
+            'event_charged',
+            'The input mapping to d on intermediateThrowEvent event_charged has no effect: Camunda 8 ignores input mappings on none intermediate throw events (output mappings work there)',
+            ['extensionElements', 'values', 0, 'inputParameters', 0],
+          ),
+          NOT_READ(
+            'endEvent_done',
+            'The input mapping on endEvent endEvent_done has no effect: Camunda 8 ignores input mappings on none end events (output mappings work there)',
+            ['extensionElements', 'values', 0, 'inputParameters', 0],
+          ),
+        ],
+      },
+    ],
+  });
+});
diff --git a/test/adapters/out/bpmnlint/engine/rules/c8/C8JobRetriesValidRule.test.ts b/test/adapters/out/bpmnlint/engine/rules/c8/C8JobRetriesValidRule.test.ts
new file mode 100644
index 00000000..b0822971
--- /dev/null
+++ b/test/adapters/out/bpmnlint/engine/rules/c8/C8JobRetriesValidRule.test.ts
@@ -0,0 +1,81 @@
+import { ERROR_TYPES } from 'bpmnlint-plugin-camunda-compat/rules/utils/error-types.js';
+import { describe } from 'vitest';
+import rule from '../../../../../../../src/adapters/out/bpmnlint/engine/rules/c8/C8JobRetriesValidRule.js';
+import { engineModel, verifyEngineRule } from '../../../../../../helpers/engine-model.js';
+
+describe('c8-job-retries-valid', () => {
+  const ext = (inner: string) => `<bpmn:extensionElements>${inner}</bpmn:extensionElements>`;
+  const job = (retries: string) => `<zeebe:taskDefinition type="work" retries="${retries}" />`;
+  const serviceTask = (inner: string) => `<bpmn:serviceTask id="X">${ext(inner)}</bpmn:serviceTask>`;
+  const retriesReport = (retries: string, label = 'serviceTask X') => ({
+    id: 'X',
+    message: `The zeebe:taskDefinition of ${label} has retries="${retries}", which is no number; it deploys, but every instance gets an incident when it reaches X`,
+    path: ['extensionElements', 'values', 0, 'retries'],
+    type: ERROR_TYPES.PROPERTY_VALUE_NOT_ALLOWED,
+  });
+
+  verifyEngineRule(rule, {
+    valid: [
+      ...['3', ' -1 ', '=retries'].map((retries) => ({
+        name: `retries="${retries}"`,
+        moddleElement: engineModel('c8', serviceTask(job(retries))),
+      })),
+      {
+        name: 'headers with key and value',
+        moddleElement: engineModel(
+          'c8',
+          serviceTask(
+            '<zeebe:taskDefinition type="work" /><zeebe:taskHeaders><zeebe:header key="k" value="v" /></zeebe:taskHeaders>',
+          ),
+        ),
+      },
+      {
+        name: 'task headers where Camunda 8 does not read them (a manual task)',
+        moddleElement: engineModel(
+          'c8',
+          `<bpmn:manualTask id="X">${ext('<zeebe:taskHeaders><zeebe:header value="v" /></zeebe:taskHeaders>')}</bpmn:manualTask>`,
+        ),
+      },
+      {
+        name: 'retries on a task Camunda 8 runs no job for (a user task)',
+        moddleElement: engineModel('c8', `<bpmn:userTask id="X">${ext(job('abc'))}</bpmn:userTask>`),
+      },
+      {
+        name: 'a process that is not executable',
+        moddleElement: engineModel('c8', serviceTask(job('abc')), {
+          processAttributes: 'isExecutable="false"',
+        }),
+      },
+      {
+        name: 'inside a transaction (refused as a whole)',
+        moddleElement: engineModel(
+          'c8',
+          `<bpmn:transaction id="T">${serviceTask(job('abc'))}</bpmn:transaction>`,
+        ),
+      },
+      {
+        name: 'a Camunda 7 diagram',
+        moddleElement: engineModel(
+          'c7',
+          '<bpmn:serviceTask id="X" camunda:type="external" camunda:topic="work" />',
+        ),
+      },
+    ],
+    invalid: [
+      {
+        name: 'retries that are no number',
+        moddleElement: engineModel('c8', serviceTask(job('abc'))),
+        report: retriesReport('abc'),
+      },
+      {
+        name: 'retries that are no number on a message end event',
+        moddleElement: engineModel(
+          'c8',
+          `<bpmn:endEvent id="X">${ext(job('1.5'))}<bpmn:messageEventDefinition id="MD" messageRef="M1" /></bpmn:endEvent>`,
+          { roots: '<bpmn:message id="M1" name="Done" />' },
+        ),
+        report: retriesReport('1.5', 'endEvent:message X'),
+      },
+    ],
+  });
+});
diff --git a/test/adapters/out/bpmnlint/engine/rules/c8/C8LinkEventNeedsNameRule.test.ts b/test/adapters/out/bpmnlint/engine/rules/c8/C8LinkEventNeedsNameRule.test.ts
new file mode 100644
index 00000000..4df60dab
--- /dev/null
+++ b/test/adapters/out/bpmnlint/engine/rules/c8/C8LinkEventNeedsNameRule.test.ts
@@ -0,0 +1,110 @@
+import { ERROR_TYPES } from 'bpmnlint-plugin-camunda-compat/rules/utils/error-types.js';
+import { describe } from 'vitest';
+import rule from '../../../../../../../src/adapters/out/bpmnlint/engine/rules/c8/C8LinkEventNeedsNameRule.js';
+import { engineModel, verifyEngineRule } from '../../../../../../helpers/engine-model.js';
+
+describe('c8-link-event-needs-name', () => {
+  const LINKS = (throwDefinition: string, catchDefinitions: string[]) => `
+    <bpmn:startEvent id="Start" />
+    <bpmn:sequenceFlow id="F1" sourceRef="Start" targetRef="X" />
+    <bpmn:intermediateThrowEvent id="X">${throwDefinition}</bpmn:intermediateThrowEvent>
+    ${catchDefinitions
+      .map(
+        (definition, index) =>
+          `<bpmn:intermediateCatchEvent id="C${index}">${definition}</bpmn:intermediateCatchEvent><bpmn:sequenceFlow id="FC${index}" sourceRef="C${index}" targetRef="End" />`,
+      )
+      .join('\n')}
+    <bpmn:endEvent id="End" />`;
+  const PAIR = (name: string) =>
+    LINKS(`<bpmn:linkEventDefinition id="L1" name="${name}" />`, [
+      `<bpmn:linkEventDefinition id="L2" name="${name}" />`,
+    ]);
+  const UNMATCHED = LINKS('<bpmn:linkEventDefinition id="L1" name="A" />', [
+    '<bpmn:linkEventDefinition id="L2" name="B" />',
+  ]);
+  const TIMER =
+    '<bpmn:timerEventDefinition id="timer_X"><bpmn:timeDuration xsi:type="bpmn:tFormalExpression">PT1H</bpmn:timeDuration></bpmn:timerEventDefinition>';
+
+  verifyEngineRule(rule, {
+    valid: [
+      { name: 'a link pair', moddleElement: engineModel('c8', PAIR('L')) },
+      { name: 'link names of white space', moddleElement: engineModel('c8', PAIR('   ')) },
+      {
+        name: 'empty link names on intermediate events (camunda-compat link-event)',
+        moddleElement: engineModel('c8', PAIR('')),
+      },
+      {
+        name: 'a link definition without name (camunda-compat link-event)',
+        moddleElement: engineModel(
+          'c8',
+          LINKS('<bpmn:linkEventDefinition id="L1" />', [
+            '<bpmn:linkEventDefinition id="L2" name="L" />',
+          ]),
+        ),
+      },
+      {
+        name: 'two link catch events of one name (camunda-compat link-event)',
+        moddleElement: engineModel(
+          'c8',
+          LINKS('<bpmn:linkEventDefinition id="L1" name="B" />', [
+            '<bpmn:linkEventDefinition id="L2" name="B" />',
+            '<bpmn:linkEventDefinition id="L3" name="B" />',
+          ]),
+        ),
+      },
+      {
+        name: 'a throw without catch in a process that is not executable',
+        moddleElement: engineModel('c8', UNMATCHED, { processAttributes: 'isExecutable="false"' }),
+      },
+      {
+        name: 'a throw and its catch in one sub-process',
+        moddleElement: engineModel('c8', `<bpmn:subProcess id="Sub">${PAIR('L')}</bpmn:subProcess>`),
+      },
+      { name: 'a Camunda 7 diagram', moddleElement: engineModel('c7', UNMATCHED) },
+    ],
+    invalid: [
+      {
+        name: 'link definitions without name in a process that is not executable',
+        moddleElement: engineModel(
+          'c8',
+          LINKS('<bpmn:linkEventDefinition id="L1" />', [
+            '<bpmn:linkEventDefinition id="L2" name="" />',
+          ]),
+          { processAttributes: 'isExecutable="false"' },
+        ),
+        report: [
+          {
+            id: 'X',
+            message:
+              'The link event definition of intermediateThrowEvent:link X has no name, which the BPMN schema requires; Camunda 8 refuses the file',
+            path: ['eventDefinitions', 0, 'name'],
+            type: ERROR_TYPES.PROPERTY_REQUIRED,
+          },
+          {
+            id: 'C0',
+            message:
+              'The link event definition of intermediateCatchEvent:link C0 has an empty name; Camunda 8 refuses the file',
+            path: ['eventDefinitions', 0, 'name'],
+            type: ERROR_TYPES.PROPERTY_REQUIRED,
+          },
+        ],
+      },
+      {
+        name: 'a link definition without name behind another definition',
+        moddleElement: engineModel(
+          'c8',
+          LINKS(`${TIMER}<bpmn:linkEventDefinition id="L1" />`, [
+            '<bpmn:linkEventDefinition id="L2" name="L" />',
+          ]),
+        ),
+        report: {
+          id: 'X',
+          message:
+            'The link event definition of intermediateThrowEvent:timer X has no name, which the BPMN schema requires; Camunda 8 refuses the file',
+          path: ['eventDefinitions', 1, 'name'],
+          type: ERROR_TYPES.PROPERTY_REQUIRED,
+        },
+      },
+    ],
+  });
+});
diff --git a/test/adapters/out/bpmnlint/engine/rules/c8/C8LinkThrowNeedsCatchRule.test.ts b/test/adapters/out/bpmnlint/engine/rules/c8/C8LinkThrowNeedsCatchRule.test.ts
new file mode 100644
index 00000000..43f38b56
--- /dev/null
+++ b/test/adapters/out/bpmnlint/engine/rules/c8/C8LinkThrowNeedsCatchRule.test.ts
@@ -0,0 +1,92 @@
+import { ERROR_TYPES } from 'bpmnlint-plugin-camunda-compat/rules/utils/error-types.js';
+import { describe } from 'vitest';
+import rule from '../../../../../../../src/adapters/out/bpmnlint/engine/rules/c8/C8LinkThrowNeedsCatchRule.js';
+import { engineModel, verifyEngineRule } from '../../../../../../helpers/engine-model.js';
+
+describe('c8-link-throw-needs-catch', () => {
+  const LINKS = (throwDefinition: string, catchDefinitions: string[]) => `
+    <bpmn:startEvent id="Start" />
+    <bpmn:sequenceFlow id="F1" sourceRef="Start" targetRef="X" />
+    <bpmn:intermediateThrowEvent id="X">${throwDefinition}</bpmn:intermediateThrowEvent>
+    ${catchDefinitions
+      .map(
+        (definition, index) =>
+          `<bpmn:intermediateCatchEvent id="C${index}">${definition}</bpmn:intermediateCatchEvent><bpmn:sequenceFlow id="FC${index}" sourceRef="C${index}" targetRef="End" />`,
+      )
+      .join('\n')}
+    <bpmn:endEvent id="End" />`;
+  const PAIR = (name: string) =>
+    LINKS(`<bpmn:linkEventDefinition id="L1" name="${name}" />`, [
+      `<bpmn:linkEventDefinition id="L2" name="${name}" />`,
+    ]);
+  const UNMATCHED = LINKS('<bpmn:linkEventDefinition id="L1" name="A" />', [
+    '<bpmn:linkEventDefinition id="L2" name="B" />',
+  ]);
+
+  verifyEngineRule(rule, {
+    valid: [
+      { name: 'a link pair', moddleElement: engineModel('c8', PAIR('L')) },
+      { name: 'link names of white space', moddleElement: engineModel('c8', PAIR('   ')) },
+      {
+        name: 'empty link names on intermediate events (camunda-compat link-event)',
+        moddleElement: engineModel('c8', PAIR('')),
+      },
+      {
+        name: 'a link definition without name (camunda-compat link-event)',
+        moddleElement: engineModel(
+          'c8',
+          LINKS('<bpmn:linkEventDefinition id="L1" />', [
+            '<bpmn:linkEventDefinition id="L2" name="L" />',
+          ]),
+        ),
+      },
+      {
+        name: 'two link catch events of one name (camunda-compat link-event)',
+        moddleElement: engineModel(
+          'c8',
+          LINKS('<bpmn:linkEventDefinition id="L1" name="B" />', [
+            '<bpmn:linkEventDefinition id="L2" name="B" />',
+            '<bpmn:linkEventDefinition id="L3" name="B" />',
+          ]),
+        ),
+      },
+      {
+        name: 'a throw without catch in a process that is not executable',
+        moddleElement: engineModel('c8', UNMATCHED, { processAttributes: 'isExecutable="false"' }),
+      },
+      {
+        name: 'a throw and its catch in one sub-process',
+        moddleElement: engineModel('c8', `<bpmn:subProcess id="Sub">${PAIR('L')}</bpmn:subProcess>`),
+      },
+      { name: 'a Camunda 7 diagram', moddleElement: engineModel('c7', UNMATCHED) },
+    ],
+    invalid: [
+      {
+        name: 'a link throw without catch',
+        moddleElement: engineModel('c8', UNMATCHED),
+        report: {
+          id: 'X',
+          message:
+            'Link throw event X goes to "A", but process_test has no link catch event of that name; Camunda 8 refuses the file',
+          path: ['eventDefinitions', 0, 'name'],
+          type: ERROR_TYPES.PROPERTY_VALUE_NOT_ALLOWED,
+        },
+      },
+      {
+        name: 'a link throw whose catch is in another sub-process',
+        moddleElement: engineModel(
+          'c8',
+          `<bpmn:subProcess id="Sub"><bpmn:intermediateThrowEvent id="X"><bpmn:linkEventDefinition id="L1" name="L" /></bpmn:intermediateThrowEvent></bpmn:subProcess>
+           <bpmn:intermediateCatchEvent id="C"><bpmn:linkEventDefinition id="L2" name="L" /></bpmn:intermediateCatchEvent>`,
+        ),
+        report: {
+          id: 'X',
+          message:
+            'Link throw event X goes to "L", but Sub has no link catch event of that name; Camunda 8 refuses the file',
+          path: ['eventDefinitions', 0, 'name'],
+          type: ERROR_TYPES.PROPERTY_VALUE_NOT_ALLOWED,
+        },
+      },
+    ],
+  });
+});
diff --git a/test/adapters/out/bpmnlint/engine/rules/c8/C8LinkedResourceNeedsTypeRule.test.ts b/test/adapters/out/bpmnlint/engine/rules/c8/C8LinkedResourceNeedsTypeRule.test.ts
new file mode 100644
index 00000000..07eb5dfe
--- /dev/null
+++ b/test/adapters/out/bpmnlint/engine/rules/c8/C8LinkedResourceNeedsTypeRule.test.ts
@@ -0,0 +1,101 @@
+import { ERROR_TYPES } from 'bpmnlint-plugin-camunda-compat/rules/utils/error-types.js';
+import { describe } from 'vitest';
+import rule from '../../../../../../../src/adapters/out/bpmnlint/engine/rules/c8/C8LinkedResourceNeedsTypeRule.js';
+import { engineModel, verifyEngineRule } from '../../../../../../helpers/engine-model.js';
+
+describe('c8-linked-resource-needs-type', () => {
+  const ext = (inner: string) => `<bpmn:extensionElements>${inner}</bpmn:extensionElements>`;
+  const SERVICE_TASK = (extra = '') =>
+    `<bpmn:serviceTask id="serviceTask_charge">${ext(`<zeebe:taskDefinition type="charge" />${extra}`)}</bpmn:serviceTask>`;
+  const HEADERS = (...keys: string[]) =>
+    `<zeebe:taskHeaders>${keys.map((key, index) => `<zeebe:header key="${key}" value="v${index}" />`).join('')}</zeebe:taskHeaders>`;
+  const CONDITIONAL = (filter: string) => `
+    <bpmn:intermediateCatchEvent id="event_stockChanged">
+      <bpmn:conditionalEventDefinition id="conditionalEventDefinition_stockChanged">
+        ${ext(filter)}
+        <bpmn:condition xsi:type="bpmn:tFormalExpression">= stock &gt; 0</bpmn:condition>
+      </bpmn:conditionalEventDefinition>
+    </bpmn:intermediateCatchEvent>`;
+
+  verifyEngineRule(rule, {
+    valid: [
+      {
+        name: 'every binding type, a version tag where it binds by version tag',
+        moddleElement: engineModel(
+          'c8',
+          `<bpmn:callActivity id="callActivity_ship">${ext('<zeebe:calledElement processId="ship" bindingType="deployment" />')}</bpmn:callActivity>
+          <bpmn:businessRuleTask id="businessRuleTask_rate">${ext('<zeebe:calledDecision decisionId="rate" resultVariable="rate" bindingType="latest" />')}</bpmn:businessRuleTask>
+          <bpmn:userTask id="userTask_review">${ext('<zeebe:userTask /><zeebe:formDefinition formId="review" bindingType="versionTag" versionTag="v1" />')}</bpmn:userTask>`,
+        ),
+      },
+      {
+        name: 'a version tag binding without version tag on a business rule task (camunda-compat reports it)',
+        moddleElement: engineModel(
+          'c8',
+          `<bpmn:businessRuleTask id="businessRuleTask_rate">${ext('<zeebe:calledDecision decisionId="rate" resultVariable="rate" bindingType="versionTag" />')}</bpmn:businessRuleTask>`,
+        ),
+      },
+      {
+        name: 'a complete linked resource, variable events create and update',
+        moddleElement: engineModel(
+          'c8',
+          `${SERVICE_TASK('<zeebe:linkedResources><zeebe:linkedResource resourceId="r" resourceType="RPA" linkName="robot" bindingType="versionTag" versionTag="v1" /></zeebe:linkedResources>')}
+          ${CONDITIONAL('<zeebe:conditionalFilter variableNames="stock" variableEvents="create, update" />')}`,
+        ),
+      },
+      {
+        name: 'a task header key twice in the first header list (camunda-compat reports it)',
+        moddleElement: engineModel('c8', SERVICE_TASK(HEADERS('region', 'region'))),
+      },
+      {
+        name: 'mappings without target or source (camunda-compat reports them)',
+        moddleElement: engineModel(
+          'c8',
+          SERVICE_TASK(
+            '<zeebe:ioMapping><zeebe:input source="=a" /><zeebe:input source="=a" target=" " /><zeebe:output source="=a" target="1x" /><zeebe:output target="a" /></zeebe:ioMapping>',
+          ),
+        ),
+      },
+      {
+        name: 'an unknown binding type in a non-executable process',
+        moddleElement: engineModel(
+          'c8',
+          `<bpmn:callActivity id="callActivity_ship">${ext('<zeebe:calledElement processId="ship" bindingType="foo" />')}</bpmn:callActivity>`,
+          { processAttributes: 'isExecutable="false"' },
+        ),
+      },
+      {
+        name: 'a linked resource on a user task (c8-zeebe-extension-placement reports it)',
+        moddleElement: engineModel(
+          'c8',
+          `<bpmn:userTask id="userTask_review">${ext('<zeebe:userTask /><zeebe:linkedResources><zeebe:linkedResource resourceId="r" /></zeebe:linkedResources>')}</bpmn:userTask>`,
+        ),
+      },
+      {
+        name: 'a Camunda 7 diagram',
+        moddleElement: engineModel(
+          'c7',
+          '<bpmn:callActivity id="callActivity_ship" calledElement="ship" camunda:calledElementBinding="foo" />',
+        ),
+      },
+    ],
+    invalid: [
+      {
+        name: 'a linked resource without resource type',
+        moddleElement: engineModel(
+          'c8',
+          SERVICE_TASK(
+            '<zeebe:linkedResources><zeebe:linkedResource resourceId="r" linkName="l" /></zeebe:linkedResources>',
+          ),
+        ),
+        report: {
+          id: 'serviceTask_charge',
+          message:
+            'Linked resource l of serviceTask serviceTask_charge has no resourceType; Camunda 8 refuses the file',
+          path: ['extensionElements', 'values', 1, 'values', 0, 'resourceType'],
+          type: ERROR_TYPES.PROPERTY_REQUIRED,
+        },
+      },
+    ],
+  });
+});
diff --git a/test/adapters/out/bpmnlint/engine/rules/c8/C8MessageStartNeedsStaticNameRule.test.ts b/test/adapters/out/bpmnlint/engine/rules/c8/C8MessageStartNeedsStaticNameRule.test.ts
new file mode 100644
index 00000000..5cc4e2fe
--- /dev/null
+++ b/test/adapters/out/bpmnlint/engine/rules/c8/C8MessageStartNeedsStaticNameRule.test.ts
@@ -0,0 +1,97 @@
+import { ERROR_TYPES } from 'bpmnlint-plugin-camunda-compat/rules/utils/error-types.js';
+import { describe } from 'vitest';
+import rule from '../../../../../../../src/adapters/out/bpmnlint/engine/rules/c8/C8MessageStartNeedsStaticNameRule.js';
+import { engineModel, verifyEngineRule } from '../../../../../../helpers/engine-model.js';
+
+describe('c8-message-start-needs-static-name', () => {
+  const MSG = (id = 'M1', name = 'M1') =>
+    `<bpmn:message id="${id}" name="${name}"><bpmn:extensionElements><zeebe:subscription correlationKey="=orderId" /></bpmn:extensionElements></bpmn:message>`;
+  const MESSAGE_DEFINITION = (id: string, ref = 'M1') =>
+    `<bpmn:messageEventDefinition id="${id}" messageRef="${ref}" />`;
+  const toEnd = (start = '') => `
+    <bpmn:startEvent id="Start">${start}</bpmn:startEvent>
+    <bpmn:sequenceFlow id="F1" sourceRef="Start" targetRef="End" />
+    <bpmn:endEvent id="End" />`;
+  const boundaries = (host: string, ...definitions: string[]) => `
+    <bpmn:startEvent id="Start" />
+    <bpmn:sequenceFlow id="F1" sourceRef="Start" targetRef="X" />
+    ${host}
+    <bpmn:sequenceFlow id="F2" sourceRef="X" targetRef="End" />
+    <bpmn:endEvent id="End" />
+    ${definitions.map((definition, index) => `<bpmn:boundaryEvent id="B${index}" attachedToRef="X">${definition}</bpmn:boundaryEvent>`).join('\n')}`;
+  const eventSubProcess = (id: string, start: string) => `
+    <bpmn:subProcess id="${id}" triggeredByEvent="true">
+      <bpmn:startEvent id="${id}_S">${start}</bpmn:startEvent>
+      <bpmn:sequenceFlow id="${id}_F" sourceRef="${id}_S" targetRef="${id}_E" />
+      <bpmn:endEvent id="${id}_E" />
+    </bpmn:subProcess>`;
+  const FEEL_START = toEnd(MESSAGE_DEFINITION('MD'));
+  const TWO_BOUNDARIES = boundaries(
+    '<bpmn:serviceTask id="X" />',
+    MESSAGE_DEFINITION('MD0'),
+    MESSAGE_DEFINITION('MD1'),
+  );
+
+  verifyEngineRule(rule, {
+    valid: [
+      {
+        name: 'a process start event with a static message name',
+        moddleElement: engineModel('c8', FEEL_START, { roots: MSG() }),
+      },
+      {
+        name: 'a FEEL message name on an event sub-process start',
+        moddleElement: engineModel('c8', toEnd() + eventSubProcess('ESP', MESSAGE_DEFINITION('MD')), {
+          roots: MSG('M1', '=name'),
+        }),
+      },
+      {
+        name: 'two boundary events with different messages',
+        moddleElement: engineModel(
+          'c8',
+          boundaries(
+            '<bpmn:serviceTask id="X" />',
+            MESSAGE_DEFINITION('MD0'),
+            MESSAGE_DEFINITION('MD1', 'M2'),
+          ),
+          { roots: MSG() + MSG('M2', 'M2') },
+        ),
+      },
+      {
+        name: 'two boundary events with one FEEL message name',
+        moddleElement: engineModel('c8', TWO_BOUNDARIES, { roots: MSG('M1', '=name') }),
+      },
+      {
+        name: 'a message without name (camunda-compat message-reference)',
+        moddleElement: engineModel('c8', boundaries('<bpmn:receiveTask id="X" messageRef="M1" />'), {
+          roots: '<bpmn:message id="M1" />',
+        }),
+      },
+      {
+        name: 'two boundary events with one message in a process that is not executable',
+        moddleElement: engineModel('c8', TWO_BOUNDARIES, {
+          roots: MSG(),
+          processAttributes: 'isExecutable="false"',
+        }),
+      },
+      {
+        name: 'a Camunda 7 diagram',
+        moddleElement: engineModel('c7', TWO_BOUNDARIES, {
+          roots: '<bpmn:message id="M1" name="M1" />',
+        }),
+      },
+    ],
+    invalid: [
+      {
+        name: 'a message start event with a FEEL name',
+        moddleElement: engineModel('c8', FEEL_START, { roots: MSG('M1', '=n') }),
+        report: {
+          id: 'Start',
+          message:
+            'Start event Start catches the message "=n", a FEEL expression; Camunda 8 needs a static message name on process start events and refuses the file',
+          path: ['eventDefinitions', 0, 'messageRef', 'name'],
+          type: ERROR_TYPES.EXPRESSION_NOT_ALLOWED,
+        },
+      },
+    ],
+  });
+});
diff --git a/test/adapters/out/bpmnlint/engine/rules/c8/C8MessageSubscriptionUniqueRule.test.ts b/test/adapters/out/bpmnlint/engine/rules/c8/C8MessageSubscriptionUniqueRule.test.ts
new file mode 100644
index 00000000..b78b0f3d
--- /dev/null
+++ b/test/adapters/out/bpmnlint/engine/rules/c8/C8MessageSubscriptionUniqueRule.test.ts
@@ -0,0 +1,181 @@
+import { ERROR_TYPES } from 'bpmnlint-plugin-camunda-compat/rules/utils/error-types.js';
+import { describe } from 'vitest';
+import rule from '../../../../../../../src/adapters/out/bpmnlint/engine/rules/c8/C8MessageSubscriptionUniqueRule.js';
+import { engineModel, verifyEngineRule } from '../../../../../../helpers/engine-model.js';
+
+describe('c8-message-subscription-unique', () => {
+  const MSG = (id = 'M1', name = 'M1') =>
+    `<bpmn:message id="${id}" name="${name}"><bpmn:extensionElements><zeebe:subscription correlationKey="=orderId" /></bpmn:extensionElements></bpmn:message>`;
+  const MESSAGE_DEFINITION = (id: string, ref = 'M1') =>
+    `<bpmn:messageEventDefinition id="${id}" messageRef="${ref}" />`;
+  const toEnd = (start = '') => `
+    <bpmn:startEvent id="Start">${start}</bpmn:startEvent>
+    <bpmn:sequenceFlow id="F1" sourceRef="Start" targetRef="End" />
+    <bpmn:endEvent id="End" />`;
+  const boundaries = (host: string, ...definitions: string[]) => `
+    <bpmn:startEvent id="Start" />
+    <bpmn:sequenceFlow id="F1" sourceRef="Start" targetRef="X" />
+    ${host}
+    <bpmn:sequenceFlow id="F2" sourceRef="X" targetRef="End" />
+    <bpmn:endEvent id="End" />
+    ${definitions.map((definition, index) => `<bpmn:boundaryEvent id="B${index}" attachedToRef="X">${definition}</bpmn:boundaryEvent>`).join('\n')}`;
+  const eventSubProcess = (id: string, start: string) => `
+    <bpmn:subProcess id="${id}" triggeredByEvent="true">
+      <bpmn:startEvent id="${id}_S">${start}</bpmn:startEvent>
+      <bpmn:sequenceFlow id="${id}_F" sourceRef="${id}_S" targetRef="${id}_E" />
+      <bpmn:endEvent id="${id}_E" />
+    </bpmn:subProcess>`;
+  const gatewayTo = (...refs: string[]) => `
+    <bpmn:startEvent id="Start" />
+    <bpmn:sequenceFlow id="F1" sourceRef="Start" targetRef="G" />
+    <bpmn:eventBasedGateway id="G" />
+    ${refs
+      .map(
+        (ref, index) => `
+    <bpmn:sequenceFlow id="G${index}" sourceRef="G" targetRef="T${index}" />
+    <bpmn:intermediateCatchEvent id="T${index}">${MESSAGE_DEFINITION(`MD${index}`, ref)}</bpmn:intermediateCatchEvent>`,
+      )
+      .join('')}`;
+  const FEEL_START = toEnd(MESSAGE_DEFINITION('MD'));
+  const TWO_BOUNDARIES = boundaries(
+    '<bpmn:serviceTask id="X" />',
+    MESSAGE_DEFINITION('MD0'),
+    MESSAGE_DEFINITION('MD1'),
+  );
+
+  verifyEngineRule(rule, {
+    valid: [
+      {
+        name: 'a process start event with a static message name',
+        moddleElement: engineModel('c8', FEEL_START, { roots: MSG() }),
+      },
+      {
+        name: 'a FEEL message name on an event sub-process start',
+        moddleElement: engineModel('c8', toEnd() + eventSubProcess('ESP', MESSAGE_DEFINITION('MD')), {
+          roots: MSG('M1', '=name'),
+        }),
+      },
+      {
+        name: 'two boundary events with different messages',
+        moddleElement: engineModel(
+          'c8',
+          boundaries(
+            '<bpmn:serviceTask id="X" />',
+            MESSAGE_DEFINITION('MD0'),
+            MESSAGE_DEFINITION('MD1', 'M2'),
+          ),
+          { roots: MSG() + MSG('M2', 'M2') },
+        ),
+      },
+      {
+        name: 'two boundary events with one FEEL message name',
+        moddleElement: engineModel('c8', TWO_BOUNDARIES, { roots: MSG('M1', '=name') }),
+      },
+      {
+        name: 'a message without name (camunda-compat message-reference)',
+        moddleElement: engineModel('c8', boundaries('<bpmn:receiveTask id="X" messageRef="M1" />'), {
+          roots: '<bpmn:message id="M1" />',
+        }),
+      },
+      {
+        name: 'two boundary events with one message in a process that is not executable',
+        moddleElement: engineModel('c8', TWO_BOUNDARIES, {
+          roots: MSG(),
+          processAttributes: 'isExecutable="false"',
+        }),
+      },
+      {
+        name: 'a Camunda 7 diagram',
+        moddleElement: engineModel('c7', TWO_BOUNDARIES, {
+          roots: '<bpmn:message id="M1" name="M1" />',
+        }),
+      },
+    ],
+    invalid: [
+      {
+        name: 'two message boundary events with one name',
+        moddleElement: engineModel('c8', TWO_BOUNDARIES, { roots: MSG() }),
+        report: {
+          id: 'B1',
+          path: ['eventDefinitions', 0, 'messageRef'],
+          type: ERROR_TYPES.ELEMENT_PROPERTY_VALUE_DUPLICATED,
+          message:
+            'boundaryEvent:message B1 waits for the message "M1" like boundaryEvent:message B0 on X; Camunda 8 refuses one message name twice there',
+        },
+      },
+      {
+        name: 'a receive task and its boundary event with one message',
+        moddleElement: engineModel(
+          'c8',
+          boundaries('<bpmn:receiveTask id="X" messageRef="M1" />', MESSAGE_DEFINITION('MD0')),
+          { roots: MSG() },
+        ),
+        report: {
+          id: 'B0',
+          path: ['eventDefinitions', 0, 'messageRef'],
+          type: ERROR_TYPES.ELEMENT_PROPERTY_VALUE_DUPLICATED,
+          message:
+            'boundaryEvent:message B0 waits for the message "M1" like receiveTask X on X; Camunda 8 refuses one message name twice there',
+        },
+      },
+      {
+        name: 'two start events with one message name',
+        moddleElement: engineModel(
+          'c8',
+          `${toEnd(MESSAGE_DEFINITION('MD'))}<bpmn:startEvent id="S2">${MESSAGE_DEFINITION('MD2', 'M2')}</bpmn:startEvent><bpmn:sequenceFlow id="F9" sourceRef="S2" targetRef="End" />`,
+          { roots: MSG('M1', 'same') + MSG('M2', 'same') },
+        ),
+        report: {
+          id: 'S2',
+          message:
+            'startEvent:message S2 waits for the message "same" like startEvent:message Start in process process_test; Camunda 8 refuses one message name twice there',
+          path: ['eventDefinitions', 0, 'messageRef'],
+          type: ERROR_TYPES.ELEMENT_PROPERTY_VALUE_DUPLICATED,
+        },
+      },
+      {
+        name: 'two event sub-processes with one message',
+        moddleElement: engineModel(
+          'c8',
+          toEnd() +
+            eventSubProcess('ESP', MESSAGE_DEFINITION('MD')) +
+            eventSubProcess('ESP2', MESSAGE_DEFINITION('MD2')),
+          { roots: MSG() },
+        ),
+        report: {
+          id: 'ESP2_S',
+          message:
+            'startEvent:message ESP2_S waits for the message "M1" like startEvent:message ESP_S in the event sub-processes of process_test; Camunda 8 refuses one message name twice there',
+          path: ['eventDefinitions', 0, 'messageRef'],
+          type: ERROR_TYPES.ELEMENT_PROPERTY_VALUE_DUPLICATED,
+        },
+      },
+      {
+        name: 'an event-based gateway with one message on two branches',
+        moddleElement: engineModel('c8', gatewayTo('M1', 'M1'), { roots: MSG() }),
+        report: {
+          id: 'T1',
+          message:
+            'intermediateCatchEvent:message T1 waits for the message "M1" like intermediateCatchEvent:message T0 after event-based gateway G; Camunda 8 refuses one message name twice there',
+          path: ['eventDefinitions', 0, 'messageRef'],
+          type: ERROR_TYPES.ELEMENT_PROPERTY_VALUE_DUPLICATED,
+        },
+      },
+      {
+        name: 'two message boundary events with one name inside a sub-process',
+        moddleElement: engineModel(
+          'c8',
+          `<bpmn:subProcess id="Sub">${TWO_BOUNDARIES}</bpmn:subProcess>`,
+          { roots: MSG() },
+        ),
+        report: {
+          id: 'B1',
+          message:
+            'boundaryEvent:message B1 waits for the message "M1" like boundaryEvent:message B0 on X; Camunda 8 refuses one message name twice there',
+          path: ['eventDefinitions', 0, 'messageRef'],
+          type: ERROR_TYPES.ELEMENT_PROPERTY_VALUE_DUPLICATED,
+        },
+      },
+    ],
+  });
+});
diff --git a/test/adapters/out/bpmnlint/engine/rules/c8/C8MultiInstanceCompletionNeedsFeelRule.test.ts b/test/adapters/out/bpmnlint/engine/rules/c8/C8MultiInstanceCompletionNeedsFeelRule.test.ts
new file mode 100644
index 00000000..85299b96
--- /dev/null
+++ b/test/adapters/out/bpmnlint/engine/rules/c8/C8MultiInstanceCompletionNeedsFeelRule.test.ts
@@ -0,0 +1,85 @@
+import { ERROR_TYPES } from 'bpmnlint-plugin-camunda-compat/rules/utils/error-types.js';
+import { describe } from 'vitest';
+import rule from '../../../../../../../src/adapters/out/bpmnlint/engine/rules/c8/C8MultiInstanceCompletionNeedsFeelRule.js';
+import { engineModel, verifyEngineRule } from '../../../../../../helpers/engine-model.js';
+
+describe('c8-multi-instance-completion-needs-feel', () => {
+  const ZEEBE_LOOP =
+    '<bpmn:extensionElements><zeebe:loopCharacteristics inputCollection="=items" inputElement="item" /></bpmn:extensionElements>';
+  const multiInstance = (condition: string | null, task = 'serviceTask') => `
+    <bpmn:${task} id="X">
+      <bpmn:extensionElements><zeebe:taskDefinition type="work" /></bpmn:extensionElements>
+      <bpmn:multiInstanceLoopCharacteristics>${ZEEBE_LOOP}${
+        condition === null
+          ? ''
+          : `<bpmn:completionCondition xsi:type="bpmn:tFormalExpression">${condition}</bpmn:completionCondition>`
+      }</bpmn:multiInstanceLoopCharacteristics>
+    </bpmn:${task}>`;
+  const report = (body: string, label = 'serviceTask X') => ({
+    id: 'X',
+    message: `The completion condition "${body}" of multi-instance ${label} is no FEEL expression (=...); it deploys, but every completed instance gets an incident (expected a boolean, got a string)`,
+    path: ['loopCharacteristics', 'completionCondition'],
+    type: ERROR_TYPES.EXPRESSION_REQUIRED,
+  });
+
+  verifyEngineRule(rule, {
+    valid: [
+      {
+        name: 'a FEEL completion condition',
+        moddleElement: engineModel('c8', multiInstance('= done')),
+      },
+      {
+        name: 'a multi-instance without completion condition',
+        moddleElement: engineModel('c8', multiInstance(null)),
+      },
+      {
+        name: 'a FEEL completion condition with leading white space',
+        moddleElement: engineModel('c8', multiInstance('  =done')),
+      },
+      {
+        name: 'a standard loop',
+        moddleElement: engineModel(
+          'c8',
+          '<bpmn:serviceTask id="X"><bpmn:standardLoopCharacteristics /></bpmn:serviceTask>',
+        ),
+      },
+      {
+        name: 'a process that is not executable',
+        moddleElement: engineModel('c8', multiInstance('${done}'), {
+          processAttributes: 'isExecutable="false"',
+        }),
+      },
+      {
+        name: 'inside a transaction (refused as a whole)',
+        moddleElement: engineModel(
+          'c8',
+          `<bpmn:transaction id="T">${multiInstance('${done}')}</bpmn:transaction>`,
+        ),
+      },
+      {
+        name: 'a Camunda 7 diagram',
+        moddleElement: engineModel(
+          'c7',
+          '<bpmn:serviceTask id="X" camunda:type="external" camunda:topic="work"><bpmn:multiInstanceLoopCharacteristics camunda:collection="items"><bpmn:completionCondition xsi:type="bpmn:tFormalExpression">${done}</bpmn:completionCondition></bpmn:multiInstanceLoopCharacteristics></bpmn:serviceTask>',
+        ),
+      },
+    ],
+    invalid: [
+      {
+        name: 'a JUEL completion condition',
+        moddleElement: engineModel('c8', multiInstance('${done}')),
+        report: report('${done}'),
+      },
+      {
+        name: 'a static completion condition of a sub-process',
+        moddleElement: engineModel('c8', multiInstance('true', 'subProcess')),
+        report: report('true', 'subProcess X'),
+      },
+      {
+        name: 'an empty completion condition',
+        moddleElement: engineModel('c8', multiInstance('')),
+        report: report(''),
+      },
+    ],
+  });
+});
diff --git a/test/adapters/out/bpmnlint/engine/rules/c8/C8MultiInstanceNeedsFeelRule.test.ts b/test/adapters/out/bpmnlint/engine/rules/c8/C8MultiInstanceNeedsFeelRule.test.ts
new file mode 100644
index 00000000..e35b982e
--- /dev/null
+++ b/test/adapters/out/bpmnlint/engine/rules/c8/C8MultiInstanceNeedsFeelRule.test.ts
@@ -0,0 +1,221 @@
+import { ERROR_TYPES } from 'bpmnlint-plugin-camunda-compat/rules/utils/error-types.js';
+import rule from '../../../../../../../src/adapters/out/bpmnlint/engine/rules/c8/C8MultiInstanceNeedsFeelRule.js';
+import { engineModel, verifyEngineRule } from '../../../../../../helpers/engine-model.js';
+
+const BAD = '= (a';
+const REFUSED = 'Camunda 8 parses it at deploy and refuses the file';
+const ext = (inner: string) => `<bpmn:extensionElements>${inner}</bpmn:extensionElements>`;
+const JOB = '<zeebe:taskDefinition type="work" />';
+const escape = (text: string) =>
+  text.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;');
+const chain = (middle: string) => `
+  <bpmn:startEvent id="startEvent_start" />
+  <bpmn:sequenceFlow id="flow_toX" sourceRef="startEvent_start" targetRef="X" />
+  ${middle}
+  <bpmn:sequenceFlow id="flow_fromX" sourceRef="X" targetRef="endEvent_end" />
+  <bpmn:endEvent id="endEvent_end" />`;
+const gateway = (condition: string) => `
+  <bpmn:startEvent id="startEvent_start" />
+  <bpmn:sequenceFlow id="flow_toGateway" sourceRef="startEvent_start" targetRef="G" />
+  <bpmn:exclusiveGateway id="G" default="SD" />
+  <bpmn:sequenceFlow id="SD" sourceRef="G" targetRef="endEvent_default" />
+  <bpmn:endEvent id="endEvent_default" />
+  <bpmn:sequenceFlow id="S0" sourceRef="G" targetRef="endEvent_s0">
+    <bpmn:conditionExpression xsi:type="bpmn:tFormalExpression">${escape(condition)}</bpmn:conditionExpression>
+  </bpmn:sequenceFlow>
+  <bpmn:endEvent id="endEvent_s0" />`;
+const adHoc = (inner: string, zeebe = '') =>
+  chain(
+    `<bpmn:adHocSubProcess id="X">${zeebe ? ext(zeebe) : ''}<bpmn:task id="A1" />${inner}</bpmn:adHocSubProcess>`,
+  );
+const completion = (body: string) =>
+  `<bpmn:completionCondition xsi:type="bpmn:tFormalExpression">${escape(body)}</bpmn:completionCondition>`;
+const multiInstance = (zeebeLoop: string, inner = '') =>
+  chain(
+    `<bpmn:serviceTask id="X">${ext(JOB)}<bpmn:multiInstanceLoopCharacteristics>${ext(zeebeLoop)}${inner}</bpmn:multiInstanceLoopCharacteristics></bpmn:serviceTask>`,
+  );
+const timer = (kind: string, value: string) =>
+  `<bpmn:timerEventDefinition id="TD1"><bpmn:${kind} xsi:type="bpmn:tFormalExpression">${escape(value)}</bpmn:${kind}></bpmn:timerEventDefinition>`;
+const conditional = (condition: string) =>
+  `<bpmn:conditionalEventDefinition id="CD1"><bpmn:condition xsi:type="bpmn:tFormalExpression">${escape(condition)}</bpmn:condition></bpmn:conditionalEventDefinition>`;
+const message = (name: string, key: string | null = '=orderId') =>
+  `<bpmn:message id="M1" name="${escape(name)}">${key === null ? '' : ext(`<zeebe:subscription correlationKey="${escape(key)}" />`)}</bpmn:message>`;
+const feel = (
+  id: string,
+  what: string,
+  value: string,
+  problem: string,
+  path: (string | number)[],
+) => ({
+  id,
+  message: `${what} "${value}" is no valid FEEL: ${problem}; ${REFUSED}`,
+  path,
+  type: ERROR_TYPES.FEEL_EXPRESSION_INVALID,
+});
+const notFeel = (id: string, message: string, path: (string | number)[]) => ({
+  id,
+  message,
+  path,
+  type: ERROR_TYPES.EXPRESSION_REQUIRED,
+});
+
+verifyEngineRule(rule, {
+  valid: [
+    ...[
+      '= x andy',
+      '= x in [1..5]',
+      '= x in (> 1, < 5)',
+      '= {a: 1}.a = 1',
+      '= string length(x) > 2',
+    ].map((condition) => ({
+      name: `a condition FEEL accepts: ${condition}`,
+      moddleElement: engineModel('c8', gateway(condition)),
+    })),
+    {
+      name: 'a FEEL completion condition of an ad-hoc sub-process',
+      moddleElement: engineModel('c8', adHoc(completion('= a and b'))),
+    },
+    {
+      name: 'attributes Camunda 8 does not parse at deploy (listener type, header value)',
+      moddleElement: engineModel(
+        'c8',
+        chain(
+          `<bpmn:serviceTask id="X">${ext(`${JOB}<zeebe:taskHeaders><zeebe:header key="k" value="${BAD}" /></zeebe:taskHeaders><zeebe:executionListeners><zeebe:executionListener eventType="end" type="${BAD}" /></zeebe:executionListeners>`)}</bpmn:serviceTask>`,
+        ),
+      ),
+    },
+    {
+      name: 'a FEEL timer value',
+      moddleElement: engineModel(
+        'c8',
+        chain(
+          `<bpmn:intermediateCatchEvent id="X">${timer('timeDuration', '=wait')}</bpmn:intermediateCatchEvent>`,
+        ),
+      ),
+    },
+    {
+      name: 'FEEL values in the multi-instance and the script',
+      moddleElement: engineModel(
+        'c8',
+        multiInstance(
+          '<zeebe:loopCharacteristics inputCollection="=items" outputCollection="out" outputElement="=result" />',
+          completion('= done'),
+        ) +
+          `<bpmn:scriptTask id="Y">${ext('<zeebe:script expression="=1 + 1" resultVariable="r" />')}</bpmn:scriptTask>`,
+      ),
+    },
+    {
+      name: 'a multi-instance completion condition that is no FEEL (a runtime matter, c8-multi-instance-completion-needs-feel)',
+      moddleElement: engineModel(
+        'c8',
+        multiInstance(
+          '<zeebe:loopCharacteristics inputCollection="=items" />',
+          completion('${done}'),
+        ),
+      ),
+    },
+    {
+      name: 'a JUEL condition in a process that is not executable',
+      moddleElement: engineModel('c8', gateway('${x > 1}'), {
+        processAttributes: 'isExecutable="false"',
+      }),
+    },
+    {
+      name: 'a JUEL condition inside a transaction (refused as a whole)',
+      moddleElement: engineModel(
+        'c8',
+        `<bpmn:transaction id="X">${gateway('${x > 1}')}</bpmn:transaction>`,
+      ),
+    },
+    {
+      name: 'a zeebe:script on a service task (not read there)',
+      moddleElement: engineModel(
+        'c8',
+        chain(
+          `<bpmn:serviceTask id="X">${ext(`${JOB}<zeebe:script expression="${BAD}" resultVariable="r" />`)}</bpmn:serviceTask>`,
+        ),
+      ),
+    },
+    {
+      name: 'a zeebe:input outside its zeebe:ioMapping (not read)',
+      moddleElement: engineModel(
+        'c8',
+        chain(
+          `<bpmn:serviceTask id="X">${ext(`${JOB}<zeebe:input source="${BAD}" target="a" />`)}</bpmn:serviceTask>`,
+        ),
+      ),
+    },
+    {
+      name: 'a script with a job (the job runs, the script is not read)',
+      moddleElement: engineModel(
+        'c8',
+        chain(
+          `<bpmn:scriptTask id="X">${ext(`${JOB}<zeebe:script expression="1 + 1" resultVariable="r" />`)}</bpmn:scriptTask>`,
+        ),
+      ),
+    },
+    {
+      name: 'a message no element uses, with a FEEL slip in its name and key',
+      moddleElement: engineModel('c8', chain('<bpmn:task id="X" />'), { roots: message(BAD, BAD) }),
+    },
+    {
+      name: 'a timer cycle on an intermediate catch event (refused for the cycle)',
+      moddleElement: engineModel(
+        'c8',
+        chain(
+          `<bpmn:intermediateCatchEvent id="X">${timer('timeCycle', BAD)}</bpmn:intermediateCatchEvent>`,
+        ),
+      ),
+    },
+    {
+      name: 'a static correlation key on the message of a process start event (not read there)',
+      moddleElement: engineModel(
+        'c8',
+        `<bpmn:startEvent id="S"><bpmn:messageEventDefinition id="MD" messageRef="M1" /></bpmn:startEvent>
+         <bpmn:sequenceFlow id="F" sourceRef="S" targetRef="E" /><bpmn:endEvent id="E" />`,
+        { roots: message('Paid', 'orderId') },
+      ),
+    },
+    {
+      name: 'an event with two definitions (refused for that)',
+      moddleElement: engineModel(
+        'c8',
+        chain(
+          `<bpmn:intermediateCatchEvent id="X">${conditional('true')}${timer('timeDuration', 'PT1H')}</bpmn:intermediateCatchEvent>`,
+        ),
+      ),
+    },
+    {
+      name: 'a Camunda 7 diagram',
+      moddleElement: engineModel('c7', gateway('${x > 1}')),
+    },
+  ],
+  invalid: [
+    {
+      name: 'a multi-instance with a static inputCollection',
+      moddleElement: engineModel(
+        'c8',
+        multiInstance('<zeebe:loopCharacteristics inputCollection="items" inputElement="item" />'),
+      ),
+      report: notFeel(
+        'X',
+        'inputCollection="items" of multi-instance serviceTask X is a static value; Camunda 8 needs a FEEL expression (=items) and refuses the file',
+        ['loopCharacteristics', 'extensionElements', 'values', 0, 'inputCollection'],
+      ),
+    },
+    {
+      name: 'a multi-instance with a static outputElement',
+      moddleElement: engineModel(
+        'c8',
+        multiInstance(
+          '<zeebe:loopCharacteristics inputCollection="=items" outputCollection="out" outputElement="result" />',
+        ),
+      ),
+      report: notFeel(
+        'X',
+        'outputElement="result" of multi-instance serviceTask X is a static value; Camunda 8 needs a FEEL expression (=result) and refuses the file',
+        ['loopCharacteristics', 'extensionElements', 'values', 0, 'outputElement'],
+      ),
+    },
+  ],
+});
diff --git a/test/adapters/out/bpmnlint/engine/rules/c8/C8NoCamunda7ContentRule.test.ts b/test/adapters/out/bpmnlint/engine/rules/c8/C8NoCamunda7ContentRule.test.ts
new file mode 100644
index 00000000..24e21e1d
--- /dev/null
+++ b/test/adapters/out/bpmnlint/engine/rules/c8/C8NoCamunda7ContentRule.test.ts
@@ -0,0 +1,115 @@
+import { ERROR_TYPES } from 'bpmnlint-plugin-camunda-compat/rules/utils/error-types.js';
+import { describe } from 'vitest';
+import rule from '../../../../../../../src/adapters/out/bpmnlint/engine/rules/c8/C8NoCamunda7ContentRule.js';
+import { engineModel, verifyEngineRule } from '../../../../../../helpers/engine-model.js';
+
+describe('c8-no-camunda-7-content', () => {
+  const CAMUNDA = 'xmlns:camunda="http://camunda.org/schema/1.0/bpmn"';
+  const ext = (inner: string) => `<bpmn:extensionElements>${inner}</bpmn:extensionElements>`;
+  const USER_TASK = (attributes: string, inner = '') =>
+    `<bpmn:userTask id="userTask_review" ${attributes}>${ext(`<zeebe:userTask />${inner}`)}</bpmn:userTask>`;
+  const INPUT_OUTPUT = (prefix: string) =>
+    `<${prefix}:inputOutput><${prefix}:inputParameter name="a">1</${prefix}:inputParameter></${prefix}:inputOutput>`;
+
+  verifyEngineRule(rule, {
+    valid: [
+      {
+        name: 'zeebe content only',
+        moddleElement: engineModel(
+          'c8',
+          USER_TASK('', '<zeebe:assignmentDefinition assignee="demo" />'),
+          { definitionsAttributes: CAMUNDA },
+        ),
+      },
+      {
+        name: 'Camunda 7 content in a non-executable process',
+        moddleElement: engineModel(
+          'c8',
+          USER_TASK('camunda:assignee="demo"', INPUT_OUTPUT('camunda')),
+          {
+            definitionsAttributes: CAMUNDA,
+            processAttributes: 'isExecutable="false"',
+          },
+        ),
+      },
+      {
+        name: 'a Camunda 7 diagram',
+        moddleElement: engineModel(
+          'c7',
+          '<bpmn:userTask id="userTask_review" camunda:assignee="demo" />',
+        ),
+      },
+    ],
+    invalid: [
+      {
+        name: 'a Camunda 7 attribute and extension element',
+        moddleElement: engineModel(
+          'c8',
+          USER_TASK('camunda:assignee="demo"', INPUT_OUTPUT('camunda')),
+          {
+            definitionsAttributes: CAMUNDA,
+          },
+        ),
+        report: [
+          {
+            id: 'userTask_review',
+            message:
+              'userTask userTask_review carries the Camunda 7 attribute camunda:assignee, which Camunda 8 ignores',
+            path: ['camunda:assignee'],
+            type: ERROR_TYPES.PROPERTY_NOT_ALLOWED,
+          },
+          {
+            id: 'userTask_review',
+            message:
+              'userTask userTask_review contains the Camunda 7 extension camunda:inputOutput, which Camunda 8 ignores',
+            path: ['extensionElements', 'values', 1],
+            type: ERROR_TYPES.EXTENSION_ELEMENT_NOT_ALLOWED,
+          },
+        ],
+      },
+      {
+        name: 'Operaton content under another prefix',
+        moddleElement: engineModel(
+          'c8',
+          `<bpmn:serviceTask id="serviceTask_charge" op:asyncBefore="true">${ext(
+            `<zeebe:taskDefinition type="charge" />${INPUT_OUTPUT('op')}`,
+          )}</bpmn:serviceTask>`,
+          { definitionsAttributes: 'xmlns:op="http://operaton.org/schema/1.0/bpmn"' },
+        ),
+        report: [
+          {
+            id: 'serviceTask_charge',
+            message:
+              'serviceTask serviceTask_charge carries the Camunda 7 attribute op:asyncBefore, which Camunda 8 ignores',
+            path: ['op:asyncBefore'],
+            type: ERROR_TYPES.PROPERTY_NOT_ALLOWED,
+          },
+          {
+            id: 'serviceTask_charge',
+            message:
+              'serviceTask serviceTask_charge contains the Camunda 7 extension op:inputOutput, which Camunda 8 ignores',
+            path: ['extensionElements', 'values', 1],
+            type: ERROR_TYPES.EXTENSION_ELEMENT_NOT_ALLOWED,
+          },
+        ],
+      },
+      {
+        name: 'a Camunda 7 attribute on an event definition',
+        moddleElement: engineModel(
+          'c8',
+          `<bpmn:endEvent id="endEvent_notified">
+            <bpmn:messageEventDefinition id="messageEventDefinition_notified" camunda:topic="notify" />
+          </bpmn:endEvent>`,
+          { definitionsAttributes: CAMUNDA },
+        ),
+        report: {
+          id: 'endEvent_notified',
+          message:
+            'messageEventDefinition messageEventDefinition_notified carries the Camunda 7 attribute camunda:topic, which Camunda 8 ignores',
+          path: ['eventDefinitions', 0, 'camunda:topic'],
+          type: ERROR_TYPES.PROPERTY_NOT_ALLOWED,
+        },
+      },
+    ],
+  });
+});
diff --git a/test/adapters/out/bpmnlint/engine/rules/c8/C8ScriptNeedsFeelRule.test.ts b/test/adapters/out/bpmnlint/engine/rules/c8/C8ScriptNeedsFeelRule.test.ts
new file mode 100644
index 00000000..527e21ad
--- /dev/null
+++ b/test/adapters/out/bpmnlint/engine/rules/c8/C8ScriptNeedsFeelRule.test.ts
@@ -0,0 +1,209 @@
+import { ERROR_TYPES } from 'bpmnlint-plugin-camunda-compat/rules/utils/error-types.js';
+import rule from '../../../../../../../src/adapters/out/bpmnlint/engine/rules/c8/C8ScriptNeedsFeelRule.js';
+import { engineModel, verifyEngineRule } from '../../../../../../helpers/engine-model.js';
+
+const BAD = '= (a';
+const REFUSED = 'Camunda 8 parses it at deploy and refuses the file';
+const ext = (inner: string) => `<bpmn:extensionElements>${inner}</bpmn:extensionElements>`;
+const JOB = '<zeebe:taskDefinition type="work" />';
+const escape = (text: string) =>
+  text.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;');
+const chain = (middle: string) => `
+  <bpmn:startEvent id="startEvent_start" />
+  <bpmn:sequenceFlow id="flow_toX" sourceRef="startEvent_start" targetRef="X" />
+  ${middle}
+  <bpmn:sequenceFlow id="flow_fromX" sourceRef="X" targetRef="endEvent_end" />
+  <bpmn:endEvent id="endEvent_end" />`;
+const gateway = (condition: string) => `
+  <bpmn:startEvent id="startEvent_start" />
+  <bpmn:sequenceFlow id="flow_toGateway" sourceRef="startEvent_start" targetRef="G" />
+  <bpmn:exclusiveGateway id="G" default="SD" />
+  <bpmn:sequenceFlow id="SD" sourceRef="G" targetRef="endEvent_default" />
+  <bpmn:endEvent id="endEvent_default" />
+  <bpmn:sequenceFlow id="S0" sourceRef="G" targetRef="endEvent_s0">
+    <bpmn:conditionExpression xsi:type="bpmn:tFormalExpression">${escape(condition)}</bpmn:conditionExpression>
+  </bpmn:sequenceFlow>
+  <bpmn:endEvent id="endEvent_s0" />`;
+const adHoc = (inner: string, zeebe = '') =>
+  chain(
+    `<bpmn:adHocSubProcess id="X">${zeebe ? ext(zeebe) : ''}<bpmn:task id="A1" />${inner}</bpmn:adHocSubProcess>`,
+  );
+const completion = (body: string) =>
+  `<bpmn:completionCondition xsi:type="bpmn:tFormalExpression">${escape(body)}</bpmn:completionCondition>`;
+const multiInstance = (zeebeLoop: string, inner = '') =>
+  chain(
+    `<bpmn:serviceTask id="X">${ext(JOB)}<bpmn:multiInstanceLoopCharacteristics>${ext(zeebeLoop)}${inner}</bpmn:multiInstanceLoopCharacteristics></bpmn:serviceTask>`,
+  );
+const timer = (kind: string, value: string) =>
+  `<bpmn:timerEventDefinition id="TD1"><bpmn:${kind} xsi:type="bpmn:tFormalExpression">${escape(value)}</bpmn:${kind}></bpmn:timerEventDefinition>`;
+const conditional = (condition: string) =>
+  `<bpmn:conditionalEventDefinition id="CD1"><bpmn:condition xsi:type="bpmn:tFormalExpression">${escape(condition)}</bpmn:condition></bpmn:conditionalEventDefinition>`;
+const message = (name: string, key: string | null = '=orderId') =>
+  `<bpmn:message id="M1" name="${escape(name)}">${key === null ? '' : ext(`<zeebe:subscription correlationKey="${escape(key)}" />`)}</bpmn:message>`;
+const feel = (
+  id: string,
+  what: string,
+  value: string,
+  problem: string,
+  path: (string | number)[],
+) => ({
+  id,
+  message: `${what} "${value}" is no valid FEEL: ${problem}; ${REFUSED}`,
+  path,
+  type: ERROR_TYPES.FEEL_EXPRESSION_INVALID,
+});
+const notFeel = (id: string, message: string, path: (string | number)[]) => ({
+  id,
+  message,
+  path,
+  type: ERROR_TYPES.EXPRESSION_REQUIRED,
+});
+
+verifyEngineRule(rule, {
+  valid: [
+    ...[
+      '= x andy',
+      '= x in [1..5]',
+      '= x in (> 1, < 5)',
+      '= {a: 1}.a = 1',
+      '= string length(x) > 2',
+    ].map((condition) => ({
+      name: `a condition FEEL accepts: ${condition}`,
+      moddleElement: engineModel('c8', gateway(condition)),
+    })),
+    {
+      name: 'a FEEL completion condition of an ad-hoc sub-process',
+      moddleElement: engineModel('c8', adHoc(completion('= a and b'))),
+    },
+    {
+      name: 'attributes Camunda 8 does not parse at deploy (listener type, header value)',
+      moddleElement: engineModel(
+        'c8',
+        chain(
+          `<bpmn:serviceTask id="X">${ext(`${JOB}<zeebe:taskHeaders><zeebe:header key="k" value="${BAD}" /></zeebe:taskHeaders><zeebe:executionListeners><zeebe:executionListener eventType="end" type="${BAD}" /></zeebe:executionListeners>`)}</bpmn:serviceTask>`,
+        ),
+      ),
+    },
+    {
+      name: 'a FEEL timer value',
+      moddleElement: engineModel(
+        'c8',
+        chain(
+          `<bpmn:intermediateCatchEvent id="X">${timer('timeDuration', '=wait')}</bpmn:intermediateCatchEvent>`,
+        ),
+      ),
+    },
+    {
+      name: 'FEEL values in the multi-instance and the script',
+      moddleElement: engineModel(
+        'c8',
+        multiInstance(
+          '<zeebe:loopCharacteristics inputCollection="=items" outputCollection="out" outputElement="=result" />',
+          completion('= done'),
+        ) +
+          `<bpmn:scriptTask id="Y">${ext('<zeebe:script expression="=1 + 1" resultVariable="r" />')}</bpmn:scriptTask>`,
+      ),
+    },
+    {
+      name: 'a multi-instance completion condition that is no FEEL (a runtime matter, c8-multi-instance-completion-needs-feel)',
+      moddleElement: engineModel(
+        'c8',
+        multiInstance(
+          '<zeebe:loopCharacteristics inputCollection="=items" />',
+          completion('${done}'),
+        ),
+      ),
+    },
+    {
+      name: 'a JUEL condition in a process that is not executable',
+      moddleElement: engineModel('c8', gateway('${x > 1}'), {
+        processAttributes: 'isExecutable="false"',
+      }),
+    },
+    {
+      name: 'a JUEL condition inside a transaction (refused as a whole)',
+      moddleElement: engineModel(
+        'c8',
+        `<bpmn:transaction id="X">${gateway('${x > 1}')}</bpmn:transaction>`,
+      ),
+    },
+    {
+      name: 'a zeebe:script on a service task (not read there)',
+      moddleElement: engineModel(
+        'c8',
+        chain(
+          `<bpmn:serviceTask id="X">${ext(`${JOB}<zeebe:script expression="${BAD}" resultVariable="r" />`)}</bpmn:serviceTask>`,
+        ),
+      ),
+    },
+    {
+      name: 'a zeebe:input outside its zeebe:ioMapping (not read)',
+      moddleElement: engineModel(
+        'c8',
+        chain(
+          `<bpmn:serviceTask id="X">${ext(`${JOB}<zeebe:input source="${BAD}" target="a" />`)}</bpmn:serviceTask>`,
+        ),
+      ),
+    },
+    {
+      name: 'a script with a job (the job runs, the script is not read)',
+      moddleElement: engineModel(
+        'c8',
+        chain(
+          `<bpmn:scriptTask id="X">${ext(`${JOB}<zeebe:script expression="1 + 1" resultVariable="r" />`)}</bpmn:scriptTask>`,
+        ),
+      ),
+    },
+    {
+      name: 'a message no element uses, with a FEEL slip in its name and key',
+      moddleElement: engineModel('c8', chain('<bpmn:task id="X" />'), { roots: message(BAD, BAD) }),
+    },
+    {
+      name: 'a timer cycle on an intermediate catch event (refused for the cycle)',
+      moddleElement: engineModel(
+        'c8',
+        chain(
+          `<bpmn:intermediateCatchEvent id="X">${timer('timeCycle', BAD)}</bpmn:intermediateCatchEvent>`,
+        ),
+      ),
+    },
+    {
+      name: 'a static correlation key on the message of a process start event (not read there)',
+      moddleElement: engineModel(
+        'c8',
+        `<bpmn:startEvent id="S"><bpmn:messageEventDefinition id="MD" messageRef="M1" /></bpmn:startEvent>
+         <bpmn:sequenceFlow id="F" sourceRef="S" targetRef="E" /><bpmn:endEvent id="E" />`,
+        { roots: message('Paid', 'orderId') },
+      ),
+    },
+    {
+      name: 'an event with two definitions (refused for that)',
+      moddleElement: engineModel(
+        'c8',
+        chain(
+          `<bpmn:intermediateCatchEvent id="X">${conditional('true')}${timer('timeDuration', 'PT1H')}</bpmn:intermediateCatchEvent>`,
+        ),
+      ),
+    },
+    {
+      name: 'a Camunda 7 diagram',
+      moddleElement: engineModel('c7', gateway('${x > 1}')),
+    },
+  ],
+  invalid: [
+    {
+      name: 'a zeebe:script with a static expression',
+      moddleElement: engineModel(
+        'c8',
+        chain(
+          `<bpmn:scriptTask id="X">${ext('<zeebe:script expression="1 + 1" resultVariable="r" />')}</bpmn:scriptTask>`,
+        ),
+      ),
+      report: notFeel(
+        'X',
+        'The zeebe:script expression "1 + 1" of scriptTask X is a static value; Camunda 8 needs a FEEL expression starting with = and refuses the file',
+        ['extensionElements', 'values', 0, 'expression'],
+      ),
+    },
+  ],
+});
diff --git a/test/adapters/out/bpmnlint/engine/rules/c8/C8SequenceFlowNoExecutionListenersRule.test.ts b/test/adapters/out/bpmnlint/engine/rules/c8/C8SequenceFlowNoExecutionListenersRule.test.ts
new file mode 100644
index 00000000..1035ce6d
--- /dev/null
+++ b/test/adapters/out/bpmnlint/engine/rules/c8/C8SequenceFlowNoExecutionListenersRule.test.ts
@@ -0,0 +1,110 @@
+import { ERROR_TYPES } from 'bpmnlint-plugin-camunda-compat/rules/utils/error-types.js';
+import { describe } from 'vitest';
+import rule from '../../../../../../../src/adapters/out/bpmnlint/engine/rules/c8/C8SequenceFlowNoExecutionListenersRule.js';
+import { engineModel, verifyEngineRule } from '../../../../../../helpers/engine-model.js';
+
+describe('c8-sequence-flow-no-execution-listeners', () => {
+  const ext = (inner: string) => `<bpmn:extensionElements>${inner}</bpmn:extensionElements>`;
+  const EXECUTION = (...listeners: string[]) =>
+    `<zeebe:executionListeners>${listeners.map((listener) => `<zeebe:executionListener ${listener} />`).join('')}</zeebe:executionListeners>`;
+  const TASK = (...listeners: string[]) =>
+    `<zeebe:taskListeners>${listeners.map((listener) => `<zeebe:taskListener ${listener} />`).join('')}</zeebe:taskListeners>`;
+  const SERVICE_TASK = (extra = '') =>
+    `<bpmn:serviceTask id="serviceTask_charge">${ext(`<zeebe:taskDefinition type="charge" />${extra}`)}</bpmn:serviceTask>`;
+  const USER_TASK = (inner: string) =>
+    `<bpmn:userTask id="userTask_review">${ext(inner)}</bpmn:userTask>`;
+
+  verifyEngineRule(rule, {
+    valid: [
+      {
+        name: 'start and end listeners on a task, a start listener on a gateway, an end listener on a start event',
+        moddleElement: engineModel(
+          'c8',
+          `<bpmn:startEvent id="startEvent_received">${ext(EXECUTION('eventType="end" type="audit"'))}</bpmn:startEvent>
+          ${SERVICE_TASK(EXECUTION('eventType="start" type="audit"', 'eventType="end" type="audit"'))}
+          <bpmn:exclusiveGateway id="gateway_approved">${ext(EXECUTION('eventType="start" type="audit"'))}</bpmn:exclusiveGateway>`,
+        ),
+      },
+      {
+        name: 'task listeners with every event type on a Camunda user task',
+        moddleElement: engineModel(
+          'c8',
+          USER_TASK(
+            `<zeebe:userTask />${TASK(
+              'eventType="creating" type="audit"',
+              'eventType="assigning" type="audit"',
+              'eventType="updating" type="audit"',
+              'eventType="completing" type="audit"',
+              'eventType="canceling" type="audit"',
+              'eventType="complete" type="audit"',
+            )}`,
+          ),
+        ),
+      },
+      {
+        name: 'a listener without type (camunda-compat reports it)',
+        moddleElement: engineModel(
+          'c8',
+          `${SERVICE_TASK(EXECUTION('eventType="start"'))}${USER_TASK(`<zeebe:userTask />${TASK('eventType="creating"')}`)}`,
+        ),
+      },
+      {
+        name: 'beforeAll and cancel listeners on Camunda 8.10 (camunda-compat checks where they go)',
+        moddleElement: engineModel(
+          'c8',
+          SERVICE_TASK(
+            EXECUTION('eventType="beforeAll" type="audit"', 'eventType="cancel" type="audit"'),
+          ),
+        ),
+      },
+      {
+        name: 'listeners in a non-executable process',
+        moddleElement: engineModel(
+          'c8',
+          `<bpmn:startEvent id="startEvent_received">${ext(EXECUTION('eventType="start" type="audit"'))}</bpmn:startEvent>`,
+          { processAttributes: 'isExecutable="false"' },
+        ),
+      },
+      {
+        name: 'listeners inside a transaction (Camunda 8 refuses the transaction as a whole)',
+        moddleElement: engineModel(
+          'c8',
+          `<bpmn:transaction id="transaction_booking">
+            <bpmn:startEvent id="startEvent_booking">${ext(EXECUTION('eventType="start" type="audit"'))}</bpmn:startEvent>
+          </bpmn:transaction>`,
+        ),
+      },
+      {
+        name: 'task listeners on a service task (c8-zeebe-extension-placement reports them)',
+        moddleElement: engineModel('c8', SERVICE_TASK(TASK('eventType="foo" type="audit"'))),
+      },
+      {
+        name: 'a Camunda 7 diagram',
+        moddleElement: engineModel(
+          'c7',
+          `<bpmn:startEvent id="startEvent_received">${ext('<camunda:executionListener event="start" class="Audit" />')}</bpmn:startEvent>`,
+        ),
+      },
+    ],
+    invalid: [
+      {
+        name: 'execution listeners on a sequence flow',
+        moddleElement: engineModel(
+          'c8',
+          `<bpmn:startEvent id="startEvent_received" />
+          <bpmn:sequenceFlow id="flow_received" sourceRef="startEvent_received" targetRef="endEvent_done">
+            ${ext(EXECUTION('eventType="start" type="audit"'))}
+          </bpmn:sequenceFlow>
+          <bpmn:endEvent id="endEvent_done" />`,
+        ),
+        report: {
+          id: 'flow_received',
+          message:
+            'sequenceFlow flow_received has execution listeners; Camunda 8 supports them on processes, activities, events and gateways, not on sequence flows, and refuses the file',
+          path: ['extensionElements', 'values', 0],
+          type: ERROR_TYPES.EXTENSION_ELEMENT_NOT_ALLOWED,
+        },
+      },
+    ],
+  });
+});
diff --git a/test/adapters/out/bpmnlint/engine/rules/c8/C8SignalStartNeedsStaticNameRule.test.ts b/test/adapters/out/bpmnlint/engine/rules/c8/C8SignalStartNeedsStaticNameRule.test.ts
new file mode 100644
index 00000000..f038ab9d
--- /dev/null
+++ b/test/adapters/out/bpmnlint/engine/rules/c8/C8SignalStartNeedsStaticNameRule.test.ts
@@ -0,0 +1,77 @@
+import { ERROR_TYPES } from 'bpmnlint-plugin-camunda-compat/rules/utils/error-types.js';
+import { describe } from 'vitest';
+import rule from '../../../../../../../src/adapters/out/bpmnlint/engine/rules/c8/C8SignalStartNeedsStaticNameRule.js';
+import { engineModel, verifyEngineRule } from '../../../../../../helpers/engine-model.js';
+
+describe('c8-signal-start-needs-static-name', () => {
+  const SIGNAL_DEFINITION = (id: string, ref = 'Sig') =>
+    `<bpmn:signalEventDefinition id="${id}" signalRef="${ref}" />`;
+  const toEnd = (start = '') => `
+    <bpmn:startEvent id="Start">${start}</bpmn:startEvent>
+    <bpmn:sequenceFlow id="F1" sourceRef="Start" targetRef="End" />
+    <bpmn:endEvent id="End" />`;
+  const TWO_STARTS = `${toEnd(SIGNAL_DEFINITION('SD'))}
+    <bpmn:startEvent id="S2">${SIGNAL_DEFINITION('SD2', 'Sig2')}</bpmn:startEvent>
+    <bpmn:sequenceFlow id="F9" sourceRef="S2" targetRef="End" />`;
+  const SIGNALS = (first: string, second = first) =>
+    `<bpmn:signal id="Sig" name="${first}" /><bpmn:signal id="Sig2" name="${second}" />`;
+
+  verifyEngineRule(rule, {
+    valid: [
+      {
+        name: 'a signal start event with a static name',
+        moddleElement: engineModel('c8', toEnd(SIGNAL_DEFINITION('SD')), { roots: SIGNALS('sig') }),
+      },
+      {
+        name: 'a FEEL signal name on a throw event',
+        moddleElement: engineModel(
+          'c8',
+          `<bpmn:startEvent id="Start" /><bpmn:sequenceFlow id="F1" sourceRef="Start" targetRef="End" /><bpmn:endEvent id="End">${SIGNAL_DEFINITION('SD')}</bpmn:endEvent>`,
+          { roots: SIGNALS('=sig') },
+        ),
+      },
+      {
+        name: 'two signal start events with different names',
+        moddleElement: engineModel('c8', TWO_STARTS, { roots: SIGNALS('one', 'two') }),
+      },
+      {
+        name: 'a signal without name (camunda-compat signal-reference)',
+        moddleElement: engineModel('c8', toEnd(SIGNAL_DEFINITION('SD')), {
+          roots: '<bpmn:signal id="Sig" />',
+        }),
+      },
+      {
+        name: 'two signal start events with one name in a process that is not executable',
+        moddleElement: engineModel('c8', TWO_STARTS, {
+          roots: SIGNALS('sig'),
+          processAttributes: 'isExecutable="false"',
+        }),
+      },
+      {
+        name: 'two signal start events of one name in an event sub-process scope',
+        moddleElement: engineModel(
+          'c8',
+          `${toEnd()}<bpmn:subProcess id="ESP" triggeredByEvent="true"><bpmn:startEvent id="ESP_S">${SIGNAL_DEFINITION('SD')}</bpmn:startEvent></bpmn:subProcess><bpmn:subProcess id="ESP2" triggeredByEvent="true"><bpmn:startEvent id="ESP2_S">${SIGNAL_DEFINITION('SD2')}</bpmn:startEvent></bpmn:subProcess>`,
+          { roots: SIGNALS('sig') },
+        ),
+      },
+      {
+        name: 'a Camunda 7 diagram',
+        moddleElement: engineModel('c7', TWO_STARTS, { roots: SIGNALS('sig') }),
+      },
+    ],
+    invalid: [
+      {
+        name: 'a signal start event with a FEEL name',
+        moddleElement: engineModel('c8', toEnd(SIGNAL_DEFINITION('SD')), { roots: SIGNALS('=sig') }),
+        report: {
+          id: 'Start',
+          message:
+            'Start event Start catches the signal "=sig", a FEEL expression; Camunda 8 needs a static signal name on start events and refuses the file',
+          path: ['eventDefinitions', 0, 'signalRef', 'name'],
+          type: ERROR_TYPES.EXPRESSION_NOT_ALLOWED,
+        },
+      },
+    ],
+  });
+});
diff --git a/test/adapters/out/bpmnlint/engine/rules/c8/C8SignalSubscriptionUniqueRule.test.ts b/test/adapters/out/bpmnlint/engine/rules/c8/C8SignalSubscriptionUniqueRule.test.ts
new file mode 100644
index 00000000..67c84810
--- /dev/null
+++ b/test/adapters/out/bpmnlint/engine/rules/c8/C8SignalSubscriptionUniqueRule.test.ts
@@ -0,0 +1,96 @@
+import { ERROR_TYPES } from 'bpmnlint-plugin-camunda-compat/rules/utils/error-types.js';
+import { describe } from 'vitest';
+import rule from '../../../../../../../src/adapters/out/bpmnlint/engine/rules/c8/C8SignalSubscriptionUniqueRule.js';
+import { engineModel, verifyEngineRule } from '../../../../../../helpers/engine-model.js';
+
+describe('c8-signal-subscription-unique', () => {
+  const SIGNAL_DEFINITION = (id: string, ref = 'Sig') =>
+    `<bpmn:signalEventDefinition id="${id}" signalRef="${ref}" />`;
+  const toEnd = (start = '') => `
+    <bpmn:startEvent id="Start">${start}</bpmn:startEvent>
+    <bpmn:sequenceFlow id="F1" sourceRef="Start" targetRef="End" />
+    <bpmn:endEvent id="End" />`;
+  const TWO_STARTS = `${toEnd(SIGNAL_DEFINITION('SD'))}
+    <bpmn:startEvent id="S2">${SIGNAL_DEFINITION('SD2', 'Sig2')}</bpmn:startEvent>
+    <bpmn:sequenceFlow id="F9" sourceRef="S2" targetRef="End" />`;
+  const TWO_BOUNDARIES = `
+    <bpmn:startEvent id="Start" />
+    <bpmn:sequenceFlow id="F1" sourceRef="Start" targetRef="X" />
+    <bpmn:serviceTask id="X" />
+    <bpmn:sequenceFlow id="F2" sourceRef="X" targetRef="End" />
+    <bpmn:endEvent id="End" />
+    <bpmn:boundaryEvent id="B0" attachedToRef="X">${SIGNAL_DEFINITION('SD0')}</bpmn:boundaryEvent>
+    <bpmn:boundaryEvent id="B1" attachedToRef="X">${SIGNAL_DEFINITION('SD1')}</bpmn:boundaryEvent>`;
+  const SIGNALS = (first: string, second = first) =>
+    `<bpmn:signal id="Sig" name="${first}" /><bpmn:signal id="Sig2" name="${second}" />`;
+
+  verifyEngineRule(rule, {
+    valid: [
+      {
+        name: 'a signal start event with a static name',
+        moddleElement: engineModel('c8', toEnd(SIGNAL_DEFINITION('SD')), { roots: SIGNALS('sig') }),
+      },
+      {
+        name: 'a FEEL signal name on a throw event',
+        moddleElement: engineModel(
+          'c8',
+          `<bpmn:startEvent id="Start" /><bpmn:sequenceFlow id="F1" sourceRef="Start" targetRef="End" /><bpmn:endEvent id="End">${SIGNAL_DEFINITION('SD')}</bpmn:endEvent>`,
+          { roots: SIGNALS('=sig') },
+        ),
+      },
+      {
+        name: 'two signal start events with different names',
+        moddleElement: engineModel('c8', TWO_STARTS, { roots: SIGNALS('one', 'two') }),
+      },
+      {
+        name: 'a signal without name (camunda-compat signal-reference)',
+        moddleElement: engineModel('c8', toEnd(SIGNAL_DEFINITION('SD')), {
+          roots: '<bpmn:signal id="Sig" />',
+        }),
+      },
+      {
+        name: 'two signal start events with one name in a process that is not executable',
+        moddleElement: engineModel('c8', TWO_STARTS, {
+          roots: SIGNALS('sig'),
+          processAttributes: 'isExecutable="false"',
+        }),
+      },
+      {
+        name: 'two signal start events of one name in an event sub-process scope',
+        moddleElement: engineModel(
+          'c8',
+          `${toEnd()}<bpmn:subProcess id="ESP" triggeredByEvent="true"><bpmn:startEvent id="ESP_S">${SIGNAL_DEFINITION('SD')}</bpmn:startEvent></bpmn:subProcess><bpmn:subProcess id="ESP2" triggeredByEvent="true"><bpmn:startEvent id="ESP2_S">${SIGNAL_DEFINITION('SD2')}</bpmn:startEvent></bpmn:subProcess>`,
+          { roots: SIGNALS('sig') },
+        ),
+      },
+      {
+        name: 'a Camunda 7 diagram',
+        moddleElement: engineModel('c7', TWO_STARTS, { roots: SIGNALS('sig') }),
+      },
+    ],
+    invalid: [
+      {
+        name: 'two signal start events with one name',
+        moddleElement: engineModel('c8', TWO_STARTS, { roots: SIGNALS('sig') }),
+        report: {
+          id: 'S2',
+          message:
+            'startEvent:signal S2 waits for the signal "sig" like startEvent:signal Start in process process_test; Camunda 8 refuses one signal name twice there',
+          path: ['eventDefinitions', 0, 'signalRef'],
+          type: ERROR_TYPES.ELEMENT_PROPERTY_VALUE_DUPLICATED,
+        },
+      },
+      {
+        name: 'two signal boundary events with one name',
+        moddleElement: engineModel('c8', TWO_BOUNDARIES, { roots: SIGNALS('sig') }),
+        report: {
+          id: 'B1',
+          message:
+            'boundaryEvent:signal B1 waits for the signal "sig" like boundaryEvent:signal B0 on X; Camunda 8 refuses one signal name twice there',
+          path: ['eventDefinitions', 0, 'signalRef'],
+          type: ERROR_TYPES.ELEMENT_PROPERTY_VALUE_DUPLICATED,
+        },
+      },
+    ],
+  });
+});
diff --git a/test/adapters/out/bpmnlint/engine/rules/c8/C8SubProcessStartEventUniqueRule.test.ts b/test/adapters/out/bpmnlint/engine/rules/c8/C8SubProcessStartEventUniqueRule.test.ts
new file mode 100644
index 00000000..6413391b
--- /dev/null
+++ b/test/adapters/out/bpmnlint/engine/rules/c8/C8SubProcessStartEventUniqueRule.test.ts
@@ -0,0 +1,101 @@
+import { ERROR_TYPES } from 'bpmnlint-plugin-camunda-compat/rules/utils/error-types.js';
+import { describe } from 'vitest';
+import rule from '../../../../../../../src/adapters/out/bpmnlint/engine/rules/c8/C8SubProcessStartEventUniqueRule.js';
+import { engineModel, verifyEngineRule } from '../../../../../../helpers/engine-model.js';
+
+describe('c8-sub-process-start-event-unique', () => {
+  const TIMER =
+    '<bpmn:timerEventDefinition id="timer_YS"><bpmn:timeCycle xsi:type="bpmn:tFormalExpression">R/PT1H</bpmn:timeCycle></bpmn:timerEventDefinition>';
+  const chain = (...middle: string[]) => `
+    <bpmn:startEvent id="Start" />
+    <bpmn:sequenceFlow id="F1" sourceRef="Start" targetRef="X" />
+    ${middle.join('\n')}
+    <bpmn:sequenceFlow id="F2" sourceRef="X" targetRef="End" />
+    <bpmn:endEvent id="End" />`;
+  const inner = (prefix: string, start = '') =>
+    `<bpmn:startEvent id="${prefix}S">${start}</bpmn:startEvent><bpmn:sequenceFlow id="${prefix}F" sourceRef="${prefix}S" targetRef="${prefix}E" /><bpmn:endEvent id="${prefix}E" />`;
+  const TIMER_START = chain(`<bpmn:subProcess id="X">${inner('Y', TIMER)}</bpmn:subProcess>`);
+  const TWO_STARTS = chain(
+    `<bpmn:subProcess id="X">${inner('Z')}<bpmn:startEvent id="ZS2" /><bpmn:sequenceFlow id="ZF2" sourceRef="ZS2" targetRef="ZE" /></bpmn:subProcess>`,
+  );
+
+  verifyEngineRule(rule, {
+    valid: [
+      {
+        name: 'a sub-process with one none start event',
+        moddleElement: engineModel(
+          'c8',
+          chain(`<bpmn:subProcess id="X">${inner('I')}</bpmn:subProcess>`),
+        ),
+      },
+      {
+        name: 'an event sub-process with a timer start event',
+        moddleElement: engineModel(
+          'c8',
+          chain(
+            '<bpmn:task id="X" />',
+            `<bpmn:subProcess id="ESP" triggeredByEvent="true">${inner('Y', TIMER)}</bpmn:subProcess>`,
+          ),
+        ),
+      },
+      {
+        name: 'a sub-process without start event (bpmnlint start-event-required)',
+        moddleElement: engineModel(
+          'c8',
+          chain('<bpmn:subProcess id="X"><bpmn:task id="A1" /></bpmn:subProcess>'),
+        ),
+      },
+      {
+        name: 'two none start events in a process (camunda-compat no-multiple-none-start-events)',
+        moddleElement: engineModel(
+          'c8',
+          `${chain('<bpmn:task id="X" />')}<bpmn:startEvent id="S2" /><bpmn:sequenceFlow id="F9" sourceRef="S2" targetRef="End" />`,
+        ),
+      },
+      {
+        name: 'start events in an ad-hoc sub-process',
+        moddleElement: engineModel(
+          'c8',
+          chain(
+            `<bpmn:adHocSubProcess id="X"><bpmn:startEvent id="AS">${TIMER}</bpmn:startEvent><bpmn:startEvent id="AS2" /></bpmn:adHocSubProcess>`,
+          ),
+        ),
+      },
+      {
+        name: 'a timer start in a sub-process of a process that is not executable',
+        moddleElement: engineModel('c8', TIMER_START, { processAttributes: 'isExecutable="false"' }),
+      },
+      { name: 'a Camunda 7 diagram', moddleElement: engineModel('c7', TIMER_START) },
+    ],
+    invalid: [
+      {
+        name: 'a sub-process with two start events',
+        moddleElement: engineModel('c8', TWO_STARTS),
+        report: {
+          id: 'X',
+          message:
+            'Sub-process X has 2 start events; Camunda 8 needs exactly one and refuses the file',
+          path: ['flowElements'],
+          type: ERROR_TYPES.ELEMENT_MULTIPLE_NOT_ALLOWED,
+        },
+      },
+      {
+        name: 'an event sub-process with two start events',
+        moddleElement: engineModel(
+          'c8',
+          chain(
+            '<bpmn:task id="X" />',
+            `<bpmn:subProcess id="ESP" triggeredByEvent="true">${inner('Y', TIMER)}<bpmn:startEvent id="YS2">${TIMER.replace('timer_YS', 'timer_YS2')}</bpmn:startEvent></bpmn:subProcess>`,
+          ),
+        ),
+        report: {
+          id: 'ESP',
+          message:
+            'Event sub-process ESP has 2 start events; Camunda 8 needs exactly one and refuses the file',
+          path: ['flowElements'],
+          type: ERROR_TYPES.ELEMENT_MULTIPLE_NOT_ALLOWED,
+        },
+      },
+    ],
+  });
+});
diff --git a/test/adapters/out/bpmnlint/engine/rules/c8/C8TaskHeaderNeedsKeyAndValueRule.test.ts b/test/adapters/out/bpmnlint/engine/rules/c8/C8TaskHeaderNeedsKeyAndValueRule.test.ts
new file mode 100644
index 00000000..5cabd760
--- /dev/null
+++ b/test/adapters/out/bpmnlint/engine/rules/c8/C8TaskHeaderNeedsKeyAndValueRule.test.ts
@@ -0,0 +1,127 @@
+import { ERROR_TYPES } from 'bpmnlint-plugin-camunda-compat/rules/utils/error-types.js';
+import { describe } from 'vitest';
+import rule from '../../../../../../../src/adapters/out/bpmnlint/engine/rules/c8/C8TaskHeaderNeedsKeyAndValueRule.js';
+import { engineModel, verifyEngineRule } from '../../../../../../helpers/engine-model.js';
+
+describe('c8-task-header-needs-key-and-value', () => {
+  const ext = (inner: string) => `<bpmn:extensionElements>${inner}</bpmn:extensionElements>`;
+  const job = (retries: string) => `<zeebe:taskDefinition type="work" retries="${retries}" />`;
+  const serviceTask = (inner: string) => `<bpmn:serviceTask id="X">${ext(inner)}</bpmn:serviceTask>`;
+  const headerReport = (
+    header: string,
+    where: string,
+    missing: string,
+    path: (string | number)[],
+  ) => ({
+    id: 'X',
+    message: `Task header ${header} of ${where} has no ${missing}; Camunda 8 drops it, the job does not carry it`,
+    path,
+    type: ERROR_TYPES.PROPERTY_REQUIRED,
+  });
+
+  verifyEngineRule(rule, {
+    valid: [
+      ...['3', ' -1 ', '=retries'].map((retries) => ({
+        name: `retries="${retries}"`,
+        moddleElement: engineModel('c8', serviceTask(job(retries))),
+      })),
+      {
+        name: 'headers with key and value',
+        moddleElement: engineModel(
+          'c8',
+          serviceTask(
+            '<zeebe:taskDefinition type="work" /><zeebe:taskHeaders><zeebe:header key="k" value="v" /></zeebe:taskHeaders>',
+          ),
+        ),
+      },
+      {
+        name: 'task headers where Camunda 8 does not read them (a manual task)',
+        moddleElement: engineModel(
+          'c8',
+          `<bpmn:manualTask id="X">${ext('<zeebe:taskHeaders><zeebe:header value="v" /></zeebe:taskHeaders>')}</bpmn:manualTask>`,
+        ),
+      },
+      {
+        name: 'retries on a task Camunda 8 runs no job for (a user task)',
+        moddleElement: engineModel('c8', `<bpmn:userTask id="X">${ext(job('abc'))}</bpmn:userTask>`),
+      },
+      {
+        name: 'a process that is not executable',
+        moddleElement: engineModel('c8', serviceTask(job('abc')), {
+          processAttributes: 'isExecutable="false"',
+        }),
+      },
+      {
+        name: 'inside a transaction (refused as a whole)',
+        moddleElement: engineModel(
+          'c8',
+          `<bpmn:transaction id="T">${serviceTask(job('abc'))}</bpmn:transaction>`,
+        ),
+      },
+      {
+        name: 'a Camunda 7 diagram',
+        moddleElement: engineModel(
+          'c7',
+          '<bpmn:serviceTask id="X" camunda:type="external" camunda:topic="work" />',
+        ),
+      },
+    ],
+    invalid: [
+      {
+        name: 'task headers without key or value (the duplicate is camunda-compat duplicate-task-headers)',
+        moddleElement: engineModel(
+          'c8',
+          serviceTask(
+            '<zeebe:taskDefinition type="work" /><zeebe:taskHeaders><zeebe:header key="k" value="v" /><zeebe:header key="k" value="w" /><zeebe:header value="x" /><zeebe:header key="e" /><zeebe:header key="s" value="  " /></zeebe:taskHeaders>',
+          ),
+        ),
+        report: [
+          headerReport('3', 'serviceTask X', 'key', [
+            'extensionElements',
+            'values',
+            1,
+            'values',
+            2,
+            'key',
+          ]),
+          headerReport('"e"', 'serviceTask X', 'value', [
+            'extensionElements',
+            'values',
+            1,
+            'values',
+            3,
+            'value',
+          ]),
+          headerReport('"s"', 'serviceTask X', 'value', [
+            'extensionElements',
+            'values',
+            1,
+            'values',
+            4,
+            'value',
+          ]),
+        ],
+      },
+      {
+        name: 'a header without value in an execution listener',
+        moddleElement: engineModel(
+          'c8',
+          serviceTask(
+            '<zeebe:taskDefinition type="work" /><zeebe:executionListeners><zeebe:executionListener eventType="start" type="audit"><zeebe:taskHeaders><zeebe:header key="k" /></zeebe:taskHeaders></zeebe:executionListener></zeebe:executionListeners>',
+          ),
+        ),
+        report: headerReport('"k"', 'execution listener 1 of serviceTask X', 'value', [
+          'extensionElements',
+          'values',
+          1,
+          'listeners',
+          0,
+          'headers',
+          'values',
+          0,
+          'value',
+        ]),
+      },
+    ],
+  });
+});
diff --git a/test/adapters/out/bpmnlint/engine/rules/c8/C8TaskListenerEventTypeValidRule.test.ts b/test/adapters/out/bpmnlint/engine/rules/c8/C8TaskListenerEventTypeValidRule.test.ts
new file mode 100644
index 00000000..72296448
--- /dev/null
+++ b/test/adapters/out/bpmnlint/engine/rules/c8/C8TaskListenerEventTypeValidRule.test.ts
@@ -0,0 +1,127 @@
+import { ERROR_TYPES } from 'bpmnlint-plugin-camunda-compat/rules/utils/error-types.js';
+import { describe } from 'vitest';
+import rule from '../../../../../../../src/adapters/out/bpmnlint/engine/rules/c8/C8TaskListenerEventTypeValidRule.js';
+import { engineModel, verifyEngineRule } from '../../../../../../helpers/engine-model.js';
+
+describe('c8-task-listener-event-type-valid', () => {
+  const ext = (inner: string) => `<bpmn:extensionElements>${inner}</bpmn:extensionElements>`;
+  const EXECUTION = (...listeners: string[]) =>
+    `<zeebe:executionListeners>${listeners.map((listener) => `<zeebe:executionListener ${listener} />`).join('')}</zeebe:executionListeners>`;
+  const TASK = (...listeners: string[]) =>
+    `<zeebe:taskListeners>${listeners.map((listener) => `<zeebe:taskListener ${listener} />`).join('')}</zeebe:taskListeners>`;
+  const SERVICE_TASK = (extra = '') =>
+    `<bpmn:serviceTask id="serviceTask_charge">${ext(`<zeebe:taskDefinition type="charge" />${extra}`)}</bpmn:serviceTask>`;
+  const USER_TASK = (inner: string) =>
+    `<bpmn:userTask id="userTask_review">${ext(inner)}</bpmn:userTask>`;
+  const EXECUTION_TYPE = (index: number, listenerIndex = 0) => [
+    'extensionElements',
+    'values',
+    index,
+    'listeners',
+    listenerIndex,
+    'eventType',
+  ];
+
+  verifyEngineRule(rule, {
+    valid: [
+      {
+        name: 'start and end listeners on a task, a start listener on a gateway, an end listener on a start event',
+        moddleElement: engineModel(
+          'c8',
+          `<bpmn:startEvent id="startEvent_received">${ext(EXECUTION('eventType="end" type="audit"'))}</bpmn:startEvent>
+          ${SERVICE_TASK(EXECUTION('eventType="start" type="audit"', 'eventType="end" type="audit"'))}
+          <bpmn:exclusiveGateway id="gateway_approved">${ext(EXECUTION('eventType="start" type="audit"'))}</bpmn:exclusiveGateway>`,
+        ),
+      },
+      {
+        name: 'task listeners with every event type on a Camunda user task',
+        moddleElement: engineModel(
+          'c8',
+          USER_TASK(
+            `<zeebe:userTask />${TASK(
+              'eventType="creating" type="audit"',
+              'eventType="assigning" type="audit"',
+              'eventType="updating" type="audit"',
+              'eventType="completing" type="audit"',
+              'eventType="canceling" type="audit"',
+              'eventType="complete" type="audit"',
+            )}`,
+          ),
+        ),
+      },
+      {
+        name: 'a listener without type (camunda-compat reports it)',
+        moddleElement: engineModel(
+          'c8',
+          `${SERVICE_TASK(EXECUTION('eventType="start"'))}${USER_TASK(`<zeebe:userTask />${TASK('eventType="creating"')}`)}`,
+        ),
+      },
+      {
+        name: 'beforeAll and cancel listeners on Camunda 8.10 (camunda-compat checks where they go)',
+        moddleElement: engineModel(
+          'c8',
+          SERVICE_TASK(
+            EXECUTION('eventType="beforeAll" type="audit"', 'eventType="cancel" type="audit"'),
+          ),
+        ),
+      },
+      {
+        name: 'listeners in a non-executable process',
+        moddleElement: engineModel(
+          'c8',
+          `<bpmn:startEvent id="startEvent_received">${ext(EXECUTION('eventType="start" type="audit"'))}</bpmn:startEvent>`,
+          { processAttributes: 'isExecutable="false"' },
+        ),
+      },
+      {
+        name: 'listeners inside a transaction (Camunda 8 refuses the transaction as a whole)',
+        moddleElement: engineModel(
+          'c8',
+          `<bpmn:transaction id="transaction_booking">
+            <bpmn:startEvent id="startEvent_booking">${ext(EXECUTION('eventType="start" type="audit"'))}</bpmn:startEvent>
+          </bpmn:transaction>`,
+        ),
+      },
+      {
+        name: 'task listeners on a service task (c8-zeebe-extension-placement reports them)',
+        moddleElement: engineModel('c8', SERVICE_TASK(TASK('eventType="foo" type="audit"'))),
+      },
+      {
+        name: 'a Camunda 7 diagram',
+        moddleElement: engineModel(
+          'c7',
+          `<bpmn:startEvent id="startEvent_received">${ext('<camunda:executionListener event="start" class="Audit" />')}</bpmn:startEvent>`,
+        ),
+      },
+    ],
+    invalid: [
+      {
+        name: 'a task listener with an unknown event type, one without type',
+        moddleElement: engineModel(
+          'c8',
+          USER_TASK(
+            `<zeebe:userTask />${TASK('eventType="foo" type="audit"', 'eventType="creating"')}`,
+          ),
+        ),
+        report: {
+          id: 'userTask_review',
+          message:
+            'Task listener 1 (foo) of userTask userTask_review: eventType "foo" is not one of creating, assigning, updating, completing, canceling; Camunda 8 refuses the file',
+          path: EXECUTION_TYPE(1),
+          type: ERROR_TYPES.PROPERTY_VALUE_NOT_ALLOWED,
+        },
+      },
+      {
+        name: 'a task listener without event type',
+        moddleElement: engineModel('c8', USER_TASK(`<zeebe:userTask />${TASK('type="audit"')}`)),
+        report: {
+          id: 'userTask_review',
+          message:
+            'Task listener 1 of userTask userTask_review has no eventType; Camunda 8 refuses the file',
+          path: EXECUTION_TYPE(1),
+          type: ERROR_TYPES.PROPERTY_REQUIRED,
+        },
+      },
+    ],
+  });
+});
diff --git a/test/adapters/out/bpmnlint/engine/rules/c8/C8TaskListenersNeedCamundaUserTaskRule.test.ts b/test/adapters/out/bpmnlint/engine/rules/c8/C8TaskListenersNeedCamundaUserTaskRule.test.ts
new file mode 100644
index 00000000..c82830ff
--- /dev/null
+++ b/test/adapters/out/bpmnlint/engine/rules/c8/C8TaskListenersNeedCamundaUserTaskRule.test.ts
@@ -0,0 +1,103 @@
+import { ERROR_TYPES } from 'bpmnlint-plugin-camunda-compat/rules/utils/error-types.js';
+import { describe } from 'vitest';
+import rule from '../../../../../../../src/adapters/out/bpmnlint/engine/rules/c8/C8TaskListenersNeedCamundaUserTaskRule.js';
+import { engineModel, verifyEngineRule } from '../../../../../../helpers/engine-model.js';
+
+describe('c8-task-listeners-need-camunda-user-task', () => {
+  const ext = (inner: string) => `<bpmn:extensionElements>${inner}</bpmn:extensionElements>`;
+  const EXECUTION = (...listeners: string[]) =>
+    `<zeebe:executionListeners>${listeners.map((listener) => `<zeebe:executionListener ${listener} />`).join('')}</zeebe:executionListeners>`;
+  const TASK = (...listeners: string[]) =>
+    `<zeebe:taskListeners>${listeners.map((listener) => `<zeebe:taskListener ${listener} />`).join('')}</zeebe:taskListeners>`;
+  const SERVICE_TASK = (extra = '') =>
+    `<bpmn:serviceTask id="serviceTask_charge">${ext(`<zeebe:taskDefinition type="charge" />${extra}`)}</bpmn:serviceTask>`;
+  const USER_TASK = (inner: string) =>
+    `<bpmn:userTask id="userTask_review">${ext(inner)}</bpmn:userTask>`;
+
+  verifyEngineRule(rule, {
+    valid: [
+      {
+        name: 'start and end listeners on a task, a start listener on a gateway, an end listener on a start event',
+        moddleElement: engineModel(
+          'c8',
+          `<bpmn:startEvent id="startEvent_received">${ext(EXECUTION('eventType="end" type="audit"'))}</bpmn:startEvent>
+          ${SERVICE_TASK(EXECUTION('eventType="start" type="audit"', 'eventType="end" type="audit"'))}
+          <bpmn:exclusiveGateway id="gateway_approved">${ext(EXECUTION('eventType="start" type="audit"'))}</bpmn:exclusiveGateway>`,
+        ),
+      },
+      {
+        name: 'task listeners with every event type on a Camunda user task',
+        moddleElement: engineModel(
+          'c8',
+          USER_TASK(
+            `<zeebe:userTask />${TASK(
+              'eventType="creating" type="audit"',
+              'eventType="assigning" type="audit"',
+              'eventType="updating" type="audit"',
+              'eventType="completing" type="audit"',
+              'eventType="canceling" type="audit"',
+              'eventType="complete" type="audit"',
+            )}`,
+          ),
+        ),
+      },
+      {
+        name: 'a listener without type (camunda-compat reports it)',
+        moddleElement: engineModel(
+          'c8',
+          `${SERVICE_TASK(EXECUTION('eventType="start"'))}${USER_TASK(`<zeebe:userTask />${TASK('eventType="creating"')}`)}`,
+        ),
+      },
+      {
+        name: 'beforeAll and cancel listeners on Camunda 8.10 (camunda-compat checks where they go)',
+        moddleElement: engineModel(
+          'c8',
+          SERVICE_TASK(
+            EXECUTION('eventType="beforeAll" type="audit"', 'eventType="cancel" type="audit"'),
+          ),
+        ),
+      },
+      {
+        name: 'listeners in a non-executable process',
+        moddleElement: engineModel(
+          'c8',
+          `<bpmn:startEvent id="startEvent_received">${ext(EXECUTION('eventType="start" type="audit"'))}</bpmn:startEvent>`,
+          { processAttributes: 'isExecutable="false"' },
+        ),
+      },
+      {
+        name: 'listeners inside a transaction (Camunda 8 refuses the transaction as a whole)',
+        moddleElement: engineModel(
+          'c8',
+          `<bpmn:transaction id="transaction_booking">
+            <bpmn:startEvent id="startEvent_booking">${ext(EXECUTION('eventType="start" type="audit"'))}</bpmn:startEvent>
+          </bpmn:transaction>`,
+        ),
+      },
+      {
+        name: 'task listeners on a service task (c8-zeebe-extension-placement reports them)',
+        moddleElement: engineModel('c8', SERVICE_TASK(TASK('eventType="foo" type="audit"'))),
+      },
+      {
+        name: 'a Camunda 7 diagram',
+        moddleElement: engineModel(
+          'c7',
+          `<bpmn:startEvent id="startEvent_received">${ext('<camunda:executionListener event="start" class="Audit" />')}</bpmn:startEvent>`,
+        ),
+      },
+    ],
+    invalid: [
+      {
+        name: 'task listeners on a job worker user task',
+        moddleElement: engineModel('c8', USER_TASK(TASK('eventType="creating" type="audit"'))),
+        report: {
+          id: 'userTask_review',
+          message:
+            'userTask userTask_review has task listeners but is a job worker user task (no zeebe:userTask); Camunda 8 allows task listeners on Camunda user tasks only and refuses the file',
+          path: ['extensionElements'],
+          type: ERROR_TYPES.EXTENSION_ELEMENT_REQUIRED,
+        },
+      },
+    ],
+  });
+});
diff --git a/test/adapters/out/bpmnlint/engine/rules/c8/C8ThrownMessageNeedsNameRule.test.ts b/test/adapters/out/bpmnlint/engine/rules/c8/C8ThrownMessageNeedsNameRule.test.ts
new file mode 100644
index 00000000..dcbfab48
--- /dev/null
+++ b/test/adapters/out/bpmnlint/engine/rules/c8/C8ThrownMessageNeedsNameRule.test.ts
@@ -0,0 +1,90 @@
+import { ERROR_TYPES } from 'bpmnlint-plugin-camunda-compat/rules/utils/error-types.js';
+import { describe } from 'vitest';
+import rule from '../../../../../../../src/adapters/out/bpmnlint/engine/rules/c8/C8ThrownMessageNeedsNameRule.js';
+import { engineModel, verifyEngineRule } from '../../../../../../helpers/engine-model.js';
+
+describe('c8-thrown-message-needs-name', () => {
+  const JOB =
+    '<bpmn:extensionElements><zeebe:taskDefinition type="notify" /></bpmn:extensionElements>';
+  const message = (name: string | null) =>
+    `<bpmn:message id="M1"${name === null ? '' : ` name="${name}"`} />`;
+  const sendTask = `<bpmn:sendTask id="X" messageRef="M1">${JOB}</bpmn:sendTask>`;
+  const throwEvent = (kind: string) =>
+    `<bpmn:${kind} id="X">${JOB}<bpmn:messageEventDefinition id="MD" messageRef="M1" /></bpmn:${kind}>`;
+
+  verifyEngineRule(rule, {
+    valid: [
+      {
+        name: 'a send task with a named message',
+        moddleElement: engineModel('c8', sendTask, { roots: message('Notified') }),
+      },
+      {
+        name: 'a message with a white-space name (Camunda 8 deploys it)',
+        moddleElement: engineModel('c8', sendTask, { roots: message('   ') }),
+      },
+      {
+        name: 'a send task without message (left to camunda-compat)',
+        moddleElement: engineModel('c8', `<bpmn:sendTask id="X">${JOB}</bpmn:sendTask>`),
+      },
+      {
+        name: 'a receive task with a nameless message (camunda-compat message-reference)',
+        moddleElement: engineModel('c8', '<bpmn:receiveTask id="X" messageRef="M1" />', {
+          roots: message(null),
+        }),
+      },
+      {
+        name: 'a throw event with two definitions (refused for that)',
+        moddleElement: engineModel(
+          'c8',
+          `<bpmn:intermediateThrowEvent id="X"><bpmn:messageEventDefinition id="MD" messageRef="M1" /><bpmn:signalEventDefinition id="SD" /></bpmn:intermediateThrowEvent>`,
+          { roots: message(null) },
+        ),
+      },
+      {
+        name: 'a process that is not executable',
+        moddleElement: engineModel('c8', sendTask, {
+          roots: message(null),
+          processAttributes: 'isExecutable="false"',
+        }),
+      },
+      {
+        name: 'a Camunda 7 diagram',
+        moddleElement: engineModel('c7', '<bpmn:sendTask id="X" messageRef="M1" />', {
+          roots: message(null),
+        }),
+      },
+    ],
+    invalid: [
+      {
+        name: 'a send task whose message has no name',
+        moddleElement: engineModel('c8', sendTask, { roots: message(null) }),
+        report: {
+          id: 'X',
+          message: 'Message M1 of sendTask X has no name; Camunda 8 refuses the file',
+          path: ['messageRef', 'name'],
+          type: ERROR_TYPES.PROPERTY_REQUIRED,
+        },
+      },
+      {
+        name: 'a send task whose message has an empty name',
+        moddleElement: engineModel('c8', sendTask, { roots: message('') }),
+        report: {
+          id: 'X',
+          message: 'Message M1 of sendTask X has no name; Camunda 8 refuses the file',
+          path: ['messageRef', 'name'],
+          type: ERROR_TYPES.PROPERTY_REQUIRED,
+        },
+      },
+      ...['intermediateThrowEvent', 'endEvent'].map((kind) => ({
+        name: `a message ${kind} whose message has no name`,
+        moddleElement: engineModel('c8', throwEvent(kind), { roots: message(null) }),
+        report: {
+          id: 'X',
+          message: `Message M1 of ${kind}:message X has no name; Camunda 8 refuses the file`,
+          path: ['eventDefinitions', 0, 'messageRef', 'name'],
+          type: ERROR_TYPES.PROPERTY_REQUIRED,
+        },
+      })),
+    ],
+  });
+});
diff --git a/test/adapters/out/bpmnlint/engine/rules/c8/C8TimerValueValidRule.test.ts b/test/adapters/out/bpmnlint/engine/rules/c8/C8TimerValueValidRule.test.ts
new file mode 100644
index 00000000..fcee3a55
--- /dev/null
+++ b/test/adapters/out/bpmnlint/engine/rules/c8/C8TimerValueValidRule.test.ts
@@ -0,0 +1,45 @@
+import { ERROR_TYPES } from 'bpmnlint-plugin-camunda-compat/rules/utils/error-types.js';
+import { describe } from 'vitest';
+import rule from '../../../../../../../src/adapters/out/bpmnlint/engine/rules/c8/C8TimerValueValidRule.js';
+import { engineModel, verifyEngineRule } from '../../../../../../helpers/engine-model.js';
+
+describe('c8-timer-value-valid', () => {
+  const timer = (kind: string, value: string) =>
+    `<bpmn:startEvent id="Start" /><bpmn:intermediateCatchEvent id="Wait"><bpmn:timerEventDefinition><bpmn:${kind} xsi:type="bpmn:tFormalExpression">${value}</bpmn:${kind}></bpmn:timerEventDefinition></bpmn:intermediateCatchEvent>`;
+  const refused = (kind: string, text: string) => ({
+    id: 'Wait',
+    message: `The ${kind}${text}; Camunda 8 refuses the file`,
+    path: ['eventDefinitions', 0, kind],
+    type: ERROR_TYPES.EXPRESSION_VALUE_NOT_ALLOWED,
+  });
+
+  verifyEngineRule(rule, {
+    valid: [
+      { name: 'an ISO 8601 duration', moddleElement: engineModel('c8', timer('timeDuration', 'PT1H')) },
+      { name: 'a FEEL expression', moddleElement: engineModel('c8', timer('timeDuration', '=duration')) },
+      { name: 'a timer in a process that is not executable', moddleElement: engineModel('c8', timer('timeDuration', '1 hour'), { processAttributes: 'isExecutable="false"' }) },
+    ],
+    invalid: [
+      {
+        name: 'a duration in words',
+        moddleElement: engineModel('c8', timer('timeDuration', '1 hour')),
+        report: refused('timeDuration', ' "1 hour" of intermediateCatchEvent:timer Wait is not an ISO 8601 duration (PT1H, P2D)'),
+      },
+      {
+        name: 'an empty duration',
+        moddleElement: engineModel('c8', timer('timeDuration', '')),
+        report: refused('timeDuration', ' of intermediateCatchEvent:timer Wait is empty'),
+      },
+      {
+        name: 'a date out of range',
+        moddleElement: engineModel('c8', timer('timeDate', '2030-13-01T10:00:00Z')),
+        report: refused('timeDate', ' "2030-13-01T10:00:00Z" of intermediateCatchEvent:timer Wait is no valid date-time: month 13 is not in 01-12'),
+      },
+      {
+        name: 'a cycle in words',
+        moddleElement: engineModel('c8', timer('timeCycle', 'every day')),
+        report: refused('timeCycle', ' "every day" of intermediateCatchEvent:timer Wait is not a repeating interval (R/PT1H, R5/2030-01-01T08:00:00Z/P1D) or a 6-field cron expression (0 0 9 * * MON)'),
+      },
+    ],
+  });
+});
diff --git a/test/adapters/out/bpmnlint/engine/rules/c8/C8VersionTagBindingNeedsTagRule.test.ts b/test/adapters/out/bpmnlint/engine/rules/c8/C8VersionTagBindingNeedsTagRule.test.ts
new file mode 100644
index 00000000..55e5bbe5
--- /dev/null
+++ b/test/adapters/out/bpmnlint/engine/rules/c8/C8VersionTagBindingNeedsTagRule.test.ts
@@ -0,0 +1,129 @@
+import { ERROR_TYPES } from 'bpmnlint-plugin-camunda-compat/rules/utils/error-types.js';
+import { describe } from 'vitest';
+import rule from '../../../../../../../src/adapters/out/bpmnlint/engine/rules/c8/C8VersionTagBindingNeedsTagRule.js';
+import { engineModel, verifyEngineRule } from '../../../../../../helpers/engine-model.js';
+
+describe('c8-version-tag-binding-needs-tag', () => {
+  const ext = (inner: string) => `<bpmn:extensionElements>${inner}</bpmn:extensionElements>`;
+  const SERVICE_TASK = (extra = '') =>
+    `<bpmn:serviceTask id="serviceTask_charge">${ext(`<zeebe:taskDefinition type="charge" />${extra}`)}</bpmn:serviceTask>`;
+  const HEADERS = (...keys: string[]) =>
+    `<zeebe:taskHeaders>${keys.map((key, index) => `<zeebe:header key="${key}" value="v${index}" />`).join('')}</zeebe:taskHeaders>`;
+  const CONDITIONAL = (filter: string) => `
+    <bpmn:intermediateCatchEvent id="event_stockChanged">
+      <bpmn:conditionalEventDefinition id="conditionalEventDefinition_stockChanged">
+        ${ext(filter)}
+        <bpmn:condition xsi:type="bpmn:tFormalExpression">= stock &gt; 0</bpmn:condition>
+      </bpmn:conditionalEventDefinition>
+    </bpmn:intermediateCatchEvent>`;
+
+  verifyEngineRule(rule, {
+    valid: [
+      {
+        name: 'every binding type, a version tag where it binds by version tag',
+        moddleElement: engineModel(
+          'c8',
+          `<bpmn:callActivity id="callActivity_ship">${ext('<zeebe:calledElement processId="ship" bindingType="deployment" />')}</bpmn:callActivity>
+          <bpmn:businessRuleTask id="businessRuleTask_rate">${ext('<zeebe:calledDecision decisionId="rate" resultVariable="rate" bindingType="latest" />')}</bpmn:businessRuleTask>
+          <bpmn:userTask id="userTask_review">${ext('<zeebe:userTask /><zeebe:formDefinition formId="review" bindingType="versionTag" versionTag="v1" />')}</bpmn:userTask>`,
+        ),
+      },
+      {
+        name: 'a version tag binding without version tag on a business rule task (camunda-compat reports it)',
+        moddleElement: engineModel(
+          'c8',
+          `<bpmn:businessRuleTask id="businessRuleTask_rate">${ext('<zeebe:calledDecision decisionId="rate" resultVariable="rate" bindingType="versionTag" />')}</bpmn:businessRuleTask>`,
+        ),
+      },
+      {
+        name: 'a complete linked resource, variable events create and update',
+        moddleElement: engineModel(
+          'c8',
+          `${SERVICE_TASK('<zeebe:linkedResources><zeebe:linkedResource resourceId="r" resourceType="RPA" linkName="robot" bindingType="versionTag" versionTag="v1" /></zeebe:linkedResources>')}
+          ${CONDITIONAL('<zeebe:conditionalFilter variableNames="stock" variableEvents="create, update" />')}`,
+        ),
+      },
+      {
+        name: 'a task header key twice in the first header list (camunda-compat reports it)',
+        moddleElement: engineModel('c8', SERVICE_TASK(HEADERS('region', 'region'))),
+      },
+      {
+        name: 'mappings without target or source (camunda-compat reports them)',
+        moddleElement: engineModel(
+          'c8',
+          SERVICE_TASK(
+            '<zeebe:ioMapping><zeebe:input source="=a" /><zeebe:input source="=a" target=" " /><zeebe:output source="=a" target="1x" /><zeebe:output target="a" /></zeebe:ioMapping>',
+          ),
+        ),
+      },
+      {
+        name: 'an unknown binding type in a non-executable process',
+        moddleElement: engineModel(
+          'c8',
+          `<bpmn:callActivity id="callActivity_ship">${ext('<zeebe:calledElement processId="ship" bindingType="foo" />')}</bpmn:callActivity>`,
+          { processAttributes: 'isExecutable="false"' },
+        ),
+      },
+      {
+        name: 'a linked resource on a user task (c8-zeebe-extension-placement reports it)',
+        moddleElement: engineModel(
+          'c8',
+          `<bpmn:userTask id="userTask_review">${ext('<zeebe:userTask /><zeebe:linkedResources><zeebe:linkedResource resourceId="r" /></zeebe:linkedResources>')}</bpmn:userTask>`,
+        ),
+      },
+      {
+        name: 'a Camunda 7 diagram',
+        moddleElement: engineModel(
+          'c7',
+          '<bpmn:callActivity id="callActivity_ship" calledElement="ship" camunda:calledElementBinding="foo" />',
+        ),
+      },
+    ],
+    invalid: [
+      {
+        name: 'a version tag binding without version tag on a start event form',
+        moddleElement: engineModel(
+          'c8',
+          `<bpmn:startEvent id="startEvent_requested">${ext('<zeebe:formDefinition formId="request" bindingType="versionTag" />')}</bpmn:startEvent>`,
+        ),
+        report: {
+          id: 'startEvent_requested',
+          message:
+            'zeebe:formDefinition of startEvent startEvent_requested has bindingType="versionTag" but no versionTag; Camunda 8 refuses the file',
+          path: ['extensionElements', 'values', 0, 'versionTag'],
+          type: ERROR_TYPES.PROPERTY_REQUIRED,
+        },
+      },
+      {
+        name: 'a blank version tag on a call activity',
+        moddleElement: engineModel(
+          'c8',
+          `<bpmn:callActivity id="callActivity_ship">${ext('<zeebe:calledElement processId="ship" bindingType="versionTag" versionTag=" " />')}</bpmn:callActivity>`,
+        ),
+        report: {
+          id: 'callActivity_ship',
+          message:
+            'zeebe:calledElement of callActivity callActivity_ship has bindingType="versionTag" but no versionTag; Camunda 8 refuses the file',
+          path: ['extensionElements', 'values', 0, 'versionTag'],
+          type: ERROR_TYPES.PROPERTY_REQUIRED,
+        },
+      },
+      {
+        name: 'linked resources with an unknown binding type and without version tag',
+        moddleElement: engineModel(
+          'c8',
+          SERVICE_TASK(
+            '<zeebe:linkedResources><zeebe:linkedResource resourceId="r" resourceType="RPA" bindingType="foo" /><zeebe:linkedResource resourceId="s" resourceType="RPA" bindingType="versionTag" /></zeebe:linkedResources>',
+          ),
+        ),
+        report: {
+            id: 'serviceTask_charge',
+            message:
+              'Linked resource 2 of serviceTask serviceTask_charge has bindingType="versionTag" but no versionTag; Camunda 8 refuses the file',
+            path: ['extensionElements', 'values', 1, 'values', 1, 'versionTag'],
+            type: ERROR_TYPES.PROPERTY_REQUIRED,
+          },
+      },
+    ],
+  });
+});
diff --git a/test/adapters/out/bpmnlint/engine/rules/c8/C8ZeebeAttributeKnownRule.test.ts b/test/adapters/out/bpmnlint/engine/rules/c8/C8ZeebeAttributeKnownRule.test.ts
new file mode 100644
index 00000000..365b7bd1
--- /dev/null
+++ b/test/adapters/out/bpmnlint/engine/rules/c8/C8ZeebeAttributeKnownRule.test.ts
@@ -0,0 +1,134 @@
+import { ERROR_TYPES } from 'bpmnlint-plugin-camunda-compat/rules/utils/error-types.js';
+import { describe } from 'vitest';
+import rule from '../../../../../../../src/adapters/out/bpmnlint/engine/rules/c8/C8ZeebeAttributeKnownRule.js';
+import { engineModel, verifyEngineRule } from '../../../../../../helpers/engine-model.js';
+
+describe('c8-zeebe-attribute-known', () => {
+  const ext = (inner: string) => `<bpmn:extensionElements>${inner}</bpmn:extensionElements>`;
+  const SERVICE_TASK = (attributes: string, inner = '<zeebe:taskDefinition type="charge" />') =>
+    `<bpmn:serviceTask id="serviceTask_charge" ${attributes}>${ext(inner)}</bpmn:serviceTask>`;
+
+  verifyEngineRule(rule, {
+    valid: [
+      {
+        name: 'known zeebe attributes on BPMN and zeebe elements',
+        moddleElement: engineModel(
+          'c8',
+          SERVICE_TASK(
+            'zeebe:modelerTemplate="io.example.charge" zeebe:retryCounter="3"',
+            '<zeebe:taskDefinition type="charge" retries="3" /><zeebe:ioMapping><zeebe:input source="=a" target="a" /></zeebe:ioMapping>',
+          ),
+        ),
+      },
+      {
+        name: 'a zeebe attribute on the wrong BPMN element (c8-zeebe-attribute-placement reports it)',
+        moddleElement: engineModel(
+          'c8',
+          '<bpmn:userTask id="userTask_review" zeebe:retryCounter="3"><bpmn:extensionElements><zeebe:userTask /></bpmn:extensionElements></bpmn:userTask>',
+        ),
+      },
+      {
+        name: 'an unknown attribute of a zeebe element on a host that does not read it',
+        moddleElement: engineModel(
+          'c8',
+          '<bpmn:userTask id="userTask_review"><bpmn:extensionElements><zeebe:userTask /><zeebe:taskDefinition type="w" typo="x" /></bpmn:extensionElements></bpmn:userTask>',
+        ),
+      },
+      {
+        name: 'unknown zeebe attributes in a non-executable process',
+        moddleElement: engineModel('c8', SERVICE_TASK('zeebe:foo="x"'), {
+          processAttributes: 'isExecutable="false"',
+        }),
+      },
+      {
+        name: 'a Camunda 7 diagram',
+        moddleElement: engineModel('c7', '<bpmn:userTask id="userTask_review" camunda:typo="x" />'),
+      },
+    ],
+    invalid: [
+      {
+        name: 'an unknown zeebe attribute on a BPMN element and on a zeebe element',
+        moddleElement: engineModel(
+          'c8',
+          SERVICE_TASK(
+            'zeebe:foo="x"',
+            '<zeebe:taskDefinition type="w" typo="x" /><zeebe:taskDefinitions />',
+          ),
+        ),
+        report: [
+          {
+            id: 'serviceTask_charge',
+            message:
+              'serviceTask serviceTask_charge has the unknown attribute zeebe:foo; Camunda 8 ignores it (most zeebe settings are extension elements: `bpmn kinds`, `bpmn guide`)',
+            path: ['zeebe:foo'],
+            type: ERROR_TYPES.PROPERTY_NOT_ALLOWED,
+          },
+          {
+            id: 'serviceTask_charge',
+            message:
+              'zeebe:taskDefinition of serviceTask serviceTask_charge has the unknown attribute typo (did you mean type?); Camunda 8 ignores it',
+            path: ['extensionElements', 'values', 0, 'typo'],
+            type: ERROR_TYPES.PROPERTY_NOT_ALLOWED,
+          },
+        ],
+      },
+      {
+        name: 'an attribute of a zeebe extension element on the user task itself',
+        moddleElement: engineModel(
+          'c8',
+          '<bpmn:userTask id="userTask_review" zeebe:assignee="demo"><bpmn:extensionElements><zeebe:userTask /></bpmn:extensionElements></bpmn:userTask>',
+        ),
+        report: {
+          id: 'userTask_review',
+          message:
+            'userTask userTask_review has the unknown attribute zeebe:assignee; Camunda 8 ignores it (it reads assignee on the zeebe:assignmentDefinition extension element)',
+          path: ['zeebe:assignee'],
+          type: ERROR_TYPES.PROPERTY_NOT_ALLOWED,
+        },
+      },
+      {
+        name: 'a typo of a zeebe attribute, under another prefix',
+        moddleElement: engineModel(
+          'c8',
+          '<bpmn:serviceTask id="serviceTask_charge" z:modelerTemplat="x"><bpmn:extensionElements><z:taskDefinition type="charge" /></bpmn:extensionElements></bpmn:serviceTask>',
+          { definitionsAttributes: 'xmlns:z="http://camunda.org/schema/zeebe/1.0"' },
+        ),
+        report: {
+          id: 'serviceTask_charge',
+          message:
+            'serviceTask serviceTask_charge has the unknown attribute zeebe:modelerTemplat (did you mean zeebe:modelerTemplate?); Camunda 8 ignores it (most zeebe settings are extension elements: `bpmn kinds`, `bpmn guide`)',
+          path: ['zeebe:modelerTemplat'],
+          type: ERROR_TYPES.PROPERTY_NOT_ALLOWED,
+        },
+      },
+      {
+        name: 'unknown attributes of nested zeebe elements',
+        moddleElement: engineModel(
+          'c8',
+          SERVICE_TASK(
+            '',
+            `<zeebe:taskDefinition type="charge" />
+            <zeebe:ioMapping><zeebe:input source="=a" target="a" sorce="b" /></zeebe:ioMapping>
+            <zeebe:executionListeners><zeebe:executionListener eventType="end" type="audit"><zeebe:taskHeaders><zeebe:header key="k" value="v" kind="x" /></zeebe:taskHeaders></zeebe:executionListener></zeebe:executionListeners>`,
+          ),
+        ),
+        report: [
+          {
+            id: 'serviceTask_charge',
+            message:
+              'zeebe:input (in zeebe:ioMapping) of serviceTask serviceTask_charge has the unknown attribute sorce (did you mean source?); Camunda 8 ignores it',
+            path: ['extensionElements', 'values', 1, 'inputParameters', 0, 'sorce'],
+            type: ERROR_TYPES.PROPERTY_NOT_ALLOWED,
+          },
+          {
+            id: 'serviceTask_charge',
+            message:
+              'zeebe:header (in zeebe:executionListeners > zeebe:executionListener > zeebe:taskHeaders) of serviceTask serviceTask_charge has the unknown attribute kind; Camunda 8 ignores it',
+            path: ['extensionElements', 'values', 2, 'listeners', 0, 'headers', 'values', 0, 'kind'],
+            type: ERROR_TYPES.PROPERTY_NOT_ALLOWED,
+          },
+        ],
+      },
+    ],
+  });
+});
diff --git a/test/adapters/out/bpmnlint/engine/rules/c8/C8ZeebeAttributePlacementRule.test.ts b/test/adapters/out/bpmnlint/engine/rules/c8/C8ZeebeAttributePlacementRule.test.ts
new file mode 100644
index 00000000..2e31250d
--- /dev/null
+++ b/test/adapters/out/bpmnlint/engine/rules/c8/C8ZeebeAttributePlacementRule.test.ts
@@ -0,0 +1,69 @@
+import { ERROR_TYPES } from 'bpmnlint-plugin-camunda-compat/rules/utils/error-types.js';
+import { describe } from 'vitest';
+import rule from '../../../../../../../src/adapters/out/bpmnlint/engine/rules/c8/C8ZeebeAttributePlacementRule.js';
+import { engineModel, verifyEngineRule } from '../../../../../../helpers/engine-model.js';
+
+describe('c8-zeebe-attribute-placement', () => {
+  const LANES = (attributes: string) =>
+    `<bpmn:laneSet id="laneSet_order"><bpmn:lane id="lane_sales" ${attributes} /></bpmn:laneSet>`;
+
+  verifyEngineRule(rule, {
+    valid: [
+      {
+        name: 'zeebe attributes on the elements that carry them',
+        moddleElement: engineModel(
+          'c8',
+          `<bpmn:serviceTask id="serviceTask_charge" zeebe:modelerTemplate="io.example.charge" zeebe:retryCounter="3">
+            <bpmn:extensionElements><zeebe:taskDefinition type="charge" /></bpmn:extensionElements>
+          </bpmn:serviceTask>
+          <bpmn:receiveTask id="receiveTask_paid" messageRef="message_paid" />`,
+          {
+            roots:
+              '<bpmn:message id="message_paid" name="paid" zeebe:modelerTemplate="io.example.paid" />',
+          },
+        ),
+      },
+      {
+        name: 'an unknown zeebe attribute (c8-zeebe-attribute-known reports it)',
+        moddleElement: engineModel('c8', LANES('zeebe:foo="x"')),
+      },
+      {
+        name: 'a misplaced zeebe attribute in a non-executable process',
+        moddleElement: engineModel('c8', LANES('zeebe:modelerTemplate="x"'), {
+          processAttributes: 'isExecutable="false"',
+        }),
+      },
+      {
+        name: 'a Camunda 7 diagram',
+        moddleElement: engineModel('c7', LANES('camunda:asyncBefore="true"')),
+      },
+    ],
+    invalid: [
+      {
+        name: 'a template on a lane',
+        moddleElement: engineModel('c8', LANES('zeebe:modelerTemplate="io.example.sales"')),
+        report: {
+          id: 'lane_sales',
+          message:
+            'zeebe:modelerTemplate on lane lane_sales has no effect: Camunda 8 reads it on collaboration, process, flowElement, error, escalation, message, signal only',
+          path: ['zeebe:modelerTemplate'],
+          type: ERROR_TYPES.PROPERTY_NOT_ALLOWED,
+        },
+      },
+      {
+        name: 'a retry counter on a user task',
+        moddleElement: engineModel(
+          'c8',
+          '<bpmn:userTask id="userTask_review" zeebe:retryCounter="3"><bpmn:extensionElements><zeebe:userTask /></bpmn:extensionElements></bpmn:userTask>',
+        ),
+        report: {
+          id: 'userTask_review',
+          message:
+            'zeebe:retryCounter on userTask userTask_review has no effect: Camunda 8 reads it on serviceTask, businessRuleTask, scriptTask, sendTask, endEvent, intermediateThrowEvent, adHocSubProcess only',
+          path: ['zeebe:retryCounter'],
+          type: ERROR_TYPES.PROPERTY_NOT_ALLOWED,
+        },
+      },
+    ],
+  });
+});
diff --git a/test/adapters/out/bpmnlint/engine/rules/c8/C8ZeebeExtensionPlacementRule.test.ts b/test/adapters/out/bpmnlint/engine/rules/c8/C8ZeebeExtensionPlacementRule.test.ts
new file mode 100644
index 00000000..eab8e5c1
--- /dev/null
+++ b/test/adapters/out/bpmnlint/engine/rules/c8/C8ZeebeExtensionPlacementRule.test.ts
@@ -0,0 +1,140 @@
+import { ERROR_TYPES } from 'bpmnlint-plugin-camunda-compat/rules/utils/error-types.js';
+import { describe } from 'vitest';
+import rule from '../../../../../../../src/adapters/out/bpmnlint/engine/rules/c8/C8ZeebeExtensionPlacementRule.js';
+import { engineModel, verifyEngineRule } from '../../../../../../helpers/engine-model.js';
+
+describe('c8-zeebe-extension-placement', () => {
+  const ext = (inner: string) => `<bpmn:extensionElements>${inner}</bpmn:extensionElements>`;
+  const TASK_DEFINITION = '<zeebe:taskDefinition type="charge" />';
+  const SERVICE_TASK = (inner: string, loop = '') =>
+    `<bpmn:serviceTask id="serviceTask_charge">${ext(inner)}${loop}</bpmn:serviceTask>`;
+  const IO_MAPPING = (mappings: string) => `<zeebe:ioMapping>${mappings}</zeebe:ioMapping>`;
+  const NOT_READ = (id: string, message: string, path: (string | number)[]) => ({
+    id,
+    message,
+    path,
+    type: ERROR_TYPES.EXTENSION_ELEMENT_NOT_ALLOWED,
+  });
+
+  verifyEngineRule(rule, {
+    valid: [
+      {
+        name: 'zeebe content where Camunda 8 reads it',
+        moddleElement: engineModel(
+          'c8',
+          `${SERVICE_TASK(
+            TASK_DEFINITION + IO_MAPPING('<zeebe:input source="=a" target="a" />'),
+            `<bpmn:multiInstanceLoopCharacteristics>${ext('<zeebe:loopCharacteristics inputCollection="=items" inputElement="item" />')}</bpmn:multiInstanceLoopCharacteristics>`,
+          )}
+          <bpmn:userTask id="userTask_review">${ext('<zeebe:userTask /><zeebe:assignmentDefinition assignee="demo" /><zeebe:properties><zeebe:property name="a" value="1" /></zeebe:properties>')}</bpmn:userTask>
+          <bpmn:receiveTask id="receiveTask_paid" messageRef="message_paid" />`,
+          {
+            roots: `<bpmn:message id="message_paid" name="paid">${ext('<zeebe:subscription correlationKey="=orderId" />')}</bpmn:message>`,
+          },
+        ),
+      },
+      {
+        name: 'output mappings on a start event, input mappings on a message throw event',
+        moddleElement: engineModel(
+          'c8',
+          `<bpmn:startEvent id="startEvent_received">${ext(IO_MAPPING('<zeebe:output source="=1" target="b" />'))}</bpmn:startEvent>
+          <bpmn:intermediateThrowEvent id="event_notified">${ext(IO_MAPPING('<zeebe:input source="=1" target="a" />'))}
+            <bpmn:messageEventDefinition id="messageEventDefinition_notified" />
+          </bpmn:intermediateThrowEvent>`,
+        ),
+      },
+      {
+        name: 'execution listeners on a sequence flow (c8-sequence-flow-no-execution-listeners reports them)',
+        moddleElement: engineModel(
+          'c8',
+          `<bpmn:startEvent id="startEvent_received" />
+          <bpmn:sequenceFlow id="flow_received" sourceRef="startEvent_received" targetRef="endEvent_done">
+            ${ext('<zeebe:executionListeners><zeebe:executionListener eventType="start" type="audit" /></zeebe:executionListeners>')}
+          </bpmn:sequenceFlow>
+          <bpmn:endEvent id="endEvent_done" />`,
+        ),
+      },
+      {
+        name: 'misplaced zeebe content in a non-executable process',
+        moddleElement: engineModel(
+          'c8',
+          `<bpmn:startEvent id="startEvent_received">${ext(IO_MAPPING('<zeebe:input source="=1" target="a" />'))}</bpmn:startEvent>`,
+          { processAttributes: 'isExecutable="false"' },
+        ),
+      },
+      {
+        name: 'a Camunda 7 diagram',
+        moddleElement: engineModel(
+          'c7',
+          `<bpmn:startEvent id="startEvent_received">${ext('<camunda:inputOutput><camunda:inputParameter name="a">1</camunda:inputParameter></camunda:inputOutput>')}</bpmn:startEvent>`,
+        ),
+      },
+    ],
+    invalid: [
+      {
+        name: 'zeebe content on hosts that do not read it',
+        moddleElement: engineModel(
+          'c8',
+          `<bpmn:userTask id="userTask_review">${ext(`<zeebe:userTask />${TASK_DEFINITION}`)}</bpmn:userTask>
+          ${SERVICE_TASK(`${TASK_DEFINITION}<zeebe:userTask /><zeebe:calledDecision decisionId="d" resultVariable="r" />`)}`,
+        ),
+        report: [
+          NOT_READ(
+            'userTask_review',
+            'zeebe:taskDefinition on userTask userTask_review has no effect: Camunda 8 reads it on serviceTask, businessRuleTask, scriptTask, sendTask, endEvent, ... only',
+            ['extensionElements', 'values', 1],
+          ),
+          NOT_READ(
+            'serviceTask_charge',
+            'zeebe:userTask on serviceTask serviceTask_charge has no effect: Camunda 8 reads it on userTask only',
+            ['extensionElements', 'values', 1],
+          ),
+          NOT_READ(
+            'serviceTask_charge',
+            'zeebe:calledDecision on serviceTask serviceTask_charge has no effect: Camunda 8 reads it on businessRuleTask only',
+            ['extensionElements', 'values', 2],
+          ),
+        ],
+      },
+      {
+        name: 'zeebe:loopCharacteristics on the activity instead of its loop',
+        moddleElement: engineModel(
+          'c8',
+          SERVICE_TASK(
+            `${TASK_DEFINITION}<zeebe:loopCharacteristics inputCollection="=items" inputElement="item" />`,
+            '<bpmn:multiInstanceLoopCharacteristics />',
+          ),
+        ),
+        report: NOT_READ(
+          'serviceTask_charge',
+          'zeebe:loopCharacteristics on serviceTask serviceTask_charge has no effect: Camunda 8 reads it on multiInstanceLoopCharacteristics only',
+          ['extensionElements', 'values', 1],
+        ),
+      },
+      {
+        name: 'io mapping on a gateway',
+        moddleElement: engineModel(
+          'c8',
+          `<bpmn:exclusiveGateway id="gateway_approved">${ext(IO_MAPPING('<zeebe:output source="=1" target="a" />'))}</bpmn:exclusiveGateway>`,
+        ),
+        report: NOT_READ(
+          'gateway_approved',
+          'zeebe:ioMapping on exclusiveGateway gateway_approved has no effect: Camunda 8 reads it on callActivity, event, receiveTask, serviceTask, businessRuleTask, ... only',
+          ['extensionElements', 'values', 0],
+        ),
+      },
+      {
+        name: 'a loose zeebe:header outside zeebe:taskHeaders',
+        moddleElement: engineModel(
+          'c8',
+          SERVICE_TASK(`${TASK_DEFINITION}<zeebe:header key="k" value="v" />`),
+        ),
+        report: NOT_READ(
+          'serviceTask_charge',
+          'zeebe:header sits directly in the extension elements of serviceTask serviceTask_charge, but belongs inside zeebe:taskHeaders; Camunda 8 ignores it',
+          ['extensionElements', 'values', 1],
+        ),
+      },
+    ],
+  });
+});
diff --git a/test/adapters/out/bpmnlint/engine/rules/c8/support/feel/FeelExpression.test.ts b/test/adapters/out/bpmnlint/engine/rules/c8/support/feel/FeelExpression.test.ts
new file mode 100644
index 00000000..50e9082a
--- /dev/null
+++ b/test/adapters/out/bpmnlint/engine/rules/c8/support/feel/FeelExpression.test.ts
@@ -0,0 +1,44 @@
+import { readFileSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+
+import { FeelExpression } from '../../../../../../../../../src/adapters/out/bpmnlint/engine/rules/c8/support/feel/FeelExpression.js';
+
+/** `[expression after the =, whether Camunda 8.9.22 deploys it as a flow condition]` */
+const FEEL_VERDICTS = JSON.parse(
+  readFileSync(
+    fileURLToPath(new URL('../../../../../../../../fixtures/c8/feel-verdicts.json', import.meta.url)),
+    'utf8',
+  ),
+) as Array<[string, boolean]>;
+
+describe('FeelExpression agrees with Camunda 8.9.22', () => {
+  it(`on all ${FEEL_VERDICTS.length} engine-checked expressions`, () => {
+    const wrong = FEEL_VERDICTS.filter(
+      ([expression, deploys]) =>
+        (new FeelExpression(expression).problem() === undefined) !== deploys,
+    ).map(
+      ([expression, deploys]) =>
+        `${deploys ? 'flagged' : 'missed'}: ${JSON.stringify(expression)} ${new FeelExpression(expression).problem() ?? ''}`,
+    );
+    expect(wrong).toEqual([]);
+    expect(FEEL_VERDICTS.filter(([, deploys]) => !deploys).length).toBeGreaterThan(250);
+  });
+
+  it.each([
+    [' x & y', '& (FEEL: and)'],
+    [' x | y', '| (FEEL: or)'],
+    [' x <> 1', '<> (FEEL: != for "not equal")'],
+    [' x >> 1', '>> (FEEL has no shift operators)'],
+    [' x % 2 = 0', '% (FEEL has no modulo operator: modulo(a, b))'],
+    [' if x then true', 'if ... then without else: FEEL needs if c then a else b'],
+    [' for x in xs', 'for ... in ... needs return: for x in xs return x'],
+    [' x AND y', 'AND (FEEL keywords are lower case: and)'],
+    [' x := 1', ':= (FEEL has no assignment; = compares)'],
+    [' a ? b : c', '?: (FEEL: if ... then ... else ...)'],
+    [' a && b', '&& (FEEL: and)'],
+    [' (a', 'an unclosed ('],
+    [' a +', 'an incomplete expression: it ends after +'],
+  ])('names what %j means in FEEL', (expression, problem) => {
+    expect(new FeelExpression(expression).problem()).toBe(problem);
+  });
+});
diff --git a/test/adapters/out/files/bpmnlint.test.ts b/test/adapters/out/files/bpmnlint.test.ts
index afc28330..4eb09a4b 100644
--- a/test/adapters/out/files/bpmnlint.test.ts
+++ b/test/adapters/out/files/bpmnlint.test.ts
@@ -381,7 +381,7 @@ describe('the resolver chain: bundled, shipped, project', () => {
   });
 
   it('camunda-compat configs the bundle lacks come from the camunda-compat bpmn-cli ships (offline, no project code)', async () => {
-    for (const config of ['camunda-platform-7-19', 'camunda-cloud-8-6']) {
+    for (const config of ['camunda-cloud-1-3', 'camunda-cloud-1-0']) {
       const dir = repo({ extends: [`plugin:camunda-compat/${config}`] });
       const { loaded, used } = await chainOf(dir, false);
       expect(used.get(`config:bpmnlint-plugin-camunda-compat/${config}`), config).toBe('shipped');
diff --git a/test/domain/editing/c8-ops.test.ts b/test/domain/editing/c8-ops.test.ts
index 101fb7db..ca72270e 100644
--- a/test/domain/editing/c8-ops.test.ts
+++ b/test/domain/editing/c8-ops.test.ts
@@ -16,10 +16,9 @@ import { join } from 'node:path';
 import { afterAll, beforeAll, describe, expect, it } from 'vitest';
 import { opsExample } from '../../../src/domain/commands/utils/op-fields.js';
 import { Doc } from '../../../src/domain/document/Doc.js';
-import { renderView, runOps, mutateDoc, loadProfiles, runProfile, buildView, elementDetail } from '../../../src/index.js';
+import { renderView, runOps, mutateDoc, buildView, elementDetail } from '../../../src/index.js';
+import { runProfile } from '../../helpers/engine.js';
 
-// the engine rules load on demand; runProfile / validateDoc(doc, { platform }) need them loaded (the pipeline loads them itself)
-await loadProfiles();
 
 const ROOT = join(import.meta.dirname, '..', '..', '..');
 const C8 = 'xmlns:zeebe="http://camunda.org/schema/zeebe/1.0" xmlns:modeler="http://camunda.org/schema/modeler/1.0" modeler:executionPlatform="Camunda Cloud"';
@@ -68,7 +67,7 @@ describe('set: zeebe settings are extension elements', () => {
     // the attributes the descriptor puts on BPMN elements, unknown names and other vendors pass
     runOps(st, [{ op: 'set', id: 'X', values: { 'zeebe:modelerTemplate': 'io.example.charge', 'zeebe:typo': 'x' } }]);
     expect(st.require('X').$attrs).toMatchObject({ 'zeebe:modelerTemplate': 'io.example.charge', 'zeebe:typo': 'x' });
-    expect(runProfile(st).findings.map((finding) => finding.code)).toEqual(['W_C8_UNKNOWN_ATTRIBUTE', 'W_C8_DEPLOY_IMPLEMENTATION']);
+    expect((await runProfile(st)).findings.map((finding) => finding.code)).toEqual(['W_C8_UNKNOWN_ATTRIBUTE', 'W_C8_DEPLOY_IMPLEMENTATION']);
   });
 });
 
@@ -237,7 +236,7 @@ describe('the hints of the Camunda 8 profile, run through the CLI', () => {
   it.each(REFUSED.map(([name, model], caseIndex) => [name, model, caseIndex] as const))('%s: following the first command of every deploy hint leaves no deploy finding', async (_name, model, caseIndex) => {
     const file = join(dir, `m${caseIndex}.bpmn`);
     writeFileSync(file, model);
-    const deployFindings = async (): Promise<Array<{ code: string; element?: string; hint?: string; message: string }>> => runProfile(await Doc.fromXml(readFileSync(file, 'utf8'))).findings.filter((finding) => finding.severity === 'deploy');
+    const deployFindings = async (): Promise<Array<{ code: string; element?: string; hint?: string; message: string }>> => (await runProfile(await Doc.fromXml(readFileSync(file, 'utf8')))).findings.filter((finding) => finding.severity === 'deploy');
     const before = await deployFindings();
     expect(before.length).toBeGreaterThan(0);
     const tried = new Set<string>();
diff --git a/test/domain/editing/properties/decision-link.test.ts b/test/domain/editing/properties/decision-link.test.ts
index 072fae77..47ccfcb7 100644
--- a/test/domain/editing/properties/decision-link.test.ts
+++ b/test/domain/editing/properties/decision-link.test.ts
@@ -13,16 +13,15 @@ import { join } from 'node:path';
 import { afterAll, beforeAll, describe, expect, it } from 'vitest';
 import { Doc } from '../../../../src/domain/document/Doc.js';
 import { runOps } from '../../../../src/index.js';
+import { runProfile } from '../../../helpers/engine.js';
 import { COMMANDS } from '../../../../src/adapters/in/report/CommandCatalogue.js';
 import { ERROR_CATALOGUE } from '../../../../src/adapters/in/report/guide.js';
 import { guideText, kindsJson } from '../../../../src/index.js';
 import { checkFile } from '../../../../src/node.js';
-import { mutateDoc, type MutationOptions, loadProfiles, runProfile, buildView, elementDetail, findElements } from '../../../../src/index.js';
+import { mutateDoc, type MutationOptions, buildView, elementDetail, findElements } from '../../../../src/index.js';
 import { SetKeyCatalog } from '../../../../src/domain/editing/properties/SetKeyCatalog.js';
 import { cli } from '../../../helpers/cli.js';
 
-// the engine rules load on demand; runProfile / validateDoc(doc, { platform }) need them loaded (the pipeline loads them itself)
-await loadProfiles();
 
 const BPMN = 'xmlns:bpmn="http://www.omg.org/spec/BPMN/20100524/MODEL"';
 const CAMUNDA = 'xmlns:camunda="http://camunda.org/schema/1.0/bpmn"';
@@ -104,24 +103,24 @@ describe('set <id> calledDecision=<decision>', () => {
 
   it('Camunda 7: camunda:decisionRef; a hand-written unprefixed link is converted (W_C7_DEPLOY_SCHEMA resolved)', async () => {
     const source = model('<bpmn:businessRuleTask id="R" calledDecision="old" />', C7);
-    expect(runProfile(await Doc.fromXml(source)).findings.map((finding) => finding.code).sort()).toEqual(['W_C7_DEPLOY_IMPLEMENTATION', 'W_C7_DEPLOY_SCHEMA']);
+    expect((await runProfile(await Doc.fromXml(source))).findings.map((finding) => finding.code).sort()).toEqual(['W_C7_DEPLOY_IMPLEMENTATION', 'W_C7_DEPLOY_SCHEMA']);
     const { doc, result } = await set(source, { calledDecision: 'risk' });
     expect(doc.require('R').$attrs).toEqual({ 'camunda:decisionRef': 'risk' });
     expect(result.changes.changed[0]!.detail).toBe('calledDecision=risk (camunda:decisionRef); removed calledDecision');
-    expect(runProfile(doc).findings).toEqual([]);
+    expect((await runProfile(doc)).findings).toEqual([]);
     expect(result.validation.platform?.resolved?.map((finding) => finding.code).sort()).toEqual(['W_C7_DEPLOY_IMPLEMENTATION', 'W_C7_DEPLOY_SCHEMA']);
   });
 
   it('Camunda 7: the schema finding\'s hint is that command, and following it deploys', async () => {
     const file = join(dir, 'c7-hint.bpmn');
     writeFileSync(file, model('<bpmn:businessRuleTask id="R" calledDecision="risk" />', C7));
-    const schema = runProfile(await Doc.fromXml(readFileSync(file, 'utf8'))).findings.find((finding) => finding.code === 'W_C7_DEPLOY_SCHEMA');
+    const schema = (await runProfile(await Doc.fromXml(readFileSync(file, 'utf8')))).findings.find((finding) => finding.code === 'W_C7_DEPLOY_SCHEMA');
     expect(schema!.hint).toBe("Write the decision link in the engines' spelling: `bpmn set <file> R calledDecision=risk` (camunda:decisionRef; the unprefixed calledDecision is removed).");
     const result = cli('set', file, 'R', 'calledDecision=risk', '--no-layout');
     expect(result.code, result.err).toBe(0);
-    expect(runProfile(await Doc.fromXml(readFileSync(file, 'utf8'))).findings).toEqual([]);
+    expect((await runProfile(await Doc.fromXml(readFileSync(file, 'utf8')))).findings).toEqual([]);
     // next to another implementation the attribute is only removed
-    const withClass = runProfile(await Doc.fromXml(model('<bpmn:businessRuleTask id="R" calledDecision="risk" camunda:class="x.Rules" />', C7))).findings;
+    const withClass = (await runProfile(await Doc.fromXml(model('<bpmn:businessRuleTask id="R" calledDecision="risk" camunda:class="x.Rules" />', C7)))).findings;
     expect(withClass.filter((finding) => finding.code === 'W_C7_DEPLOY_SCHEMA').map((finding) => finding.hint)).toEqual(['Remove it: `bpmn set <file> R calledDecision=` (vendor attributes need their namespace prefix, e.g. camunda:<name>).']);
   }, 60000);
 
diff --git a/test/domain/validation/c7-profile-rules.test.ts b/test/domain/validation/c7-profile-rules.test.ts
index 1bbb11dc..803d0600 100644
--- a/test/domain/validation/c7-profile-rules.test.ts
+++ b/test/domain/validation/c7-profile-rules.test.ts
@@ -19,15 +19,13 @@
 import { mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
+import { runProfile, validateWithEngine } from '../../helpers/engine.js';
 import { afterAll, beforeAll, describe, expect, it } from 'vitest';
 import { Doc } from '../../../src/domain/document/Doc.js';
-import { detectPlatform, loadProfiles, runProfile } from '../../../src/index.js';
+import { detectPlatform } from '../../../src/index.js';
 import type { Platform } from '../../../src/domain/document/vendor/PlatformDetection.js';
-import { validateDoc } from '../../../src/index.js';
 import { cli } from '../../helpers/cli.js';
 
-// the engine rules load on demand; runProfile / validateDoc(doc, { platform }) need them loaded (the pipeline loads them itself)
-await loadProfiles();
 
 const BPMN = 'xmlns:bpmn="http://www.omg.org/spec/BPMN/20100524/MODEL" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"';
 const CAMUNDA = 'xmlns:camunda="http://camunda.org/schema/1.0/bpmn"';
@@ -103,8 +101,8 @@ interface Case {
 const CASES: Case[] = [
   // conditions: a script resource is a condition; an empty one deploys and fails when evaluated (runtime)
   { name: 'conditional event with a camunda:resource script condition', xml: xml(chain([catchEvent('W', cond('<bpmn:condition xsi:type="bpmn:tFormalExpression" language="groovy" camunda:resource="deployment://c.groovy" />'))])), codes: [], engine: 'accept' },
-  { name: 'conditional event with an empty condition', xml: xml(chain([catchEvent('W', cond('<bpmn:condition xsi:type="bpmn:tFormalExpression" />'))])), codes: ['W_C7_EMPTY_CONDITION'], engine: 'accept' },
-  { name: 'conditional start event with an empty groovy condition', xml: xml(chain([UT()], '', `<bpmn:startEvent id="Start">${cond('<bpmn:condition xsi:type="bpmn:tFormalExpression" language="groovy" />')}</bpmn:startEvent>`)), codes: ['W_C7_EMPTY_CONDITION'], engine: 'accept' },
+  { name: 'conditional event with an empty condition', xml: xml(chain([catchEvent('W', cond('<bpmn:condition xsi:type="bpmn:tFormalExpression" />'))])), codes: [], engine: 'accept' },
+  { name: 'conditional start event with an empty groovy condition', xml: xml(chain([UT()], '', `<bpmn:startEvent id="Start">${cond('<bpmn:condition xsi:type="bpmn:tFormalExpression" language="groovy" />')}</bpmn:startEvent>`)), codes: [], engine: 'accept' },
   { name: 'conditional event without a condition element', xml: xml(chain([catchEvent('W', cond(''))])), codes: ['W_C7_DEPLOY_EVENT_DEFINITION'], engine: 'reject' },
   {
     name: 'sequence flow with an empty condition (not on a default flow)',
@@ -113,7 +111,7 @@ const CASES: Case[] = [
 <bpmn:sequenceFlow id="F1" sourceRef="T" targetRef="E1"><bpmn:conditionExpression xsi:type="bpmn:tFormalExpression" /></bpmn:sequenceFlow>
 <bpmn:sequenceFlow id="F2" sourceRef="T" targetRef="E2"><bpmn:conditionExpression xsi:type="bpmn:tFormalExpression">\${a}</bpmn:conditionExpression></bpmn:sequenceFlow>
 <bpmn:sequenceFlow id="F3" sourceRef="T" targetRef="E3" />`),
-    codes: ['W_C7_EMPTY_CONDITION'],
+    codes: [],
     engine: 'accept',
   },
   // camunda:type
@@ -206,12 +204,11 @@ const CASES: Case[] = [
   { name: 'Operaton-only file', xml: xml(chain([['X', '<bpmn:serviceTask id="X" operaton:type="external" operaton:topic="t" />']]), { ns: OPERATON, attrs: 'operaton:historyTimeToLive="180"' }), codes: [], engine: 'reject', operaton: 'accept' },
   { name: 'Operaton reads operaton:historyTimeToLive before camunda:historyTimeToLive', xml: xml(chain([UT()]), { ns: `${CAMUNDA} ${OPERATON}`, attrs: 'camunda:historyTimeToLive="180" operaton:historyTimeToLive="abc"' }), codes: ['W_C7_DEPLOY_HISTORY_TTL'], engine: 'accept', operaton: 'reject' },
   { name: 'one camunda:inputOutput and one operaton:inputOutput', xml: xml(chain([UT('T', ext('<camunda:inputOutput><camunda:inputParameter name="a">1</camunda:inputParameter></camunda:inputOutput><operaton:inputOutput><operaton:inputParameter name="b">2</operaton:inputParameter></operaton:inputOutput>'))]), { ns: `${CAMUNDA} ${OPERATON}` }), codes: [], engine: 'accept' },
-  { name: 'two operaton:inputOutput', xml: xml(chain([UT('T', ext('<operaton:inputOutput><operaton:inputParameter name="a">1</operaton:inputParameter></operaton:inputOutput><operaton:inputOutput><operaton:inputParameter name="b">2</operaton:inputParameter></operaton:inputOutput>'))]), { ns: OPERATON, attrs: 'operaton:historyTimeToLive="180"' }), codes: ['W_C7_DEPLOY_DUPLICATE_EXTENSION'], engine: 'reject' },
 ];
 
 describe('profile follow-ups: one synthetic model per rule', () => {
   it.each(CASES.map((testCase) => [testCase.name, testCase] as const))('%s', async (_name, testCase) => {
-    const findings = runProfile(await Doc.fromXml(testCase.xml)).findings;
+    const findings = (await runProfile(await Doc.fromXml(testCase.xml))).findings;
     expect(findings.map((finding) => finding.code).sort(), JSON.stringify(findings, null, 1)).toEqual([...testCase.codes].sort());
     // deploy findings exactly where the engine that reads the file refuses it
     const operatonFile = detectPlatform(await Doc.fromXml(testCase.xml)).operaton === true;
@@ -223,31 +220,31 @@ describe('profile follow-ups: one synthetic model per rule', () => {
   });
 
   it('an empty process (bpmn new) and an empty sub-process need a start event too (engine-checked)', async () => {
-    expect(runProfile(Doc.create({ target: 'camunda7' })).findings.map((finding) => finding.code)).toEqual(['W_C7_DEPLOY_START_EVENT']);
-    expect(runProfile(await Doc.fromXml(xml(chain([sub('Sub', '')])))).findings.map((finding) => `${finding.code} ${finding.element}`)).toEqual(['W_C7_DEPLOY_START_EVENT Sub']);
+    expect((await runProfile(Doc.create({ target: 'camunda7' }))).findings.map((finding) => finding.code)).toEqual(['W_C7_DEPLOY_START_EVENT']);
+    expect((await runProfile(await Doc.fromXml(xml(chain([sub('Sub', '')]))))).findings.map((finding) => `${finding.code} ${finding.element}`)).toEqual(['W_C7_DEPLOY_START_EVENT Sub']);
   });
 
   it('names what to fix', async () => {
-    const two = runProfile(await Doc.fromXml(CASES.find((testCase) => testCase.name === 'two none start events')!.xml)).findings[0]!;
+    const two = (await runProfile(await Doc.fromXml(CASES.find((testCase) => testCase.name === 'two none start events')!.xml))).findings[0]!;
     expect(two).toMatchObject({ element: 'S2', related: ['Start'] });
     expect(two.message).toContain('second none or timer start event of process P_FollowUp');
-    const link = runProfile(await Doc.fromXml(CASES.find((testCase) => testCase.name === 'link throw event in the process, catch event in a sub-process')!.xml)).findings[0]!;
+    const link = (await runProfile(await Doc.fromXml(CASES.find((testCase) => testCase.name === 'link throw event in the process, catch event in a sub-process')!.xml))).findings[0]!;
     expect(link).toMatchObject({ element: 'L', related: ['C1'] });
     expect(link.hint).toContain('--in P_FollowUp --link L1');
-    const comp = runProfile(await Doc.fromXml(compensation('Inner'))).findings[0]!;
+    const comp = (await runProfile(await Doc.fromXml(compensation('Inner')))).findings[0]!;
     expect(comp).toMatchObject({ element: 'Th', related: ['Inner'] });
     expect(comp.hint).toContain('(in P_FollowUp: Host, Sub)');
-    const recv = runProfile(await Doc.fromXml(CASES.find((testCase) => testCase.name.startsWith('receive task and a boundary'))!.xml)).findings[0]!;
+    const recv = (await runProfile(await Doc.fromXml(CASES.find((testCase) => testCase.name.startsWith('receive task and a boundary'))!.xml))).findings[0]!;
     expect(recv).toMatchObject({ element: 'B1', related: ['T'] });
-    const side = runProfile(await Doc.fromXml(CASES.find((testCase) => testCase.name.startsWith('throw-only'))!.xml)).findings.find((finding) => finding.element === 'W')!;
+    const side = (await runProfile(await Doc.fromXml(CASES.find((testCase) => testCase.name.startsWith('throw-only'))!.xml))).findings.find((finding) => finding.element === 'W')!;
     expect(side.message).toContain('read it on message throw and end events only');
     expect(side.hint).toContain('`bpmn set <file> W definition.camunda:type=`');
   });
 
   it('W_NO_START gives way to the engine finding about the same process', async () => {
     const doc = await Doc.fromXml(CASES.find((testCase) => testCase.name === 'process with nodes but no start event')!.xml);
-    expect(validateDoc(doc).warnings.map((warning) => warning.code)).toContain('W_NO_START');
-    const codes = validateDoc(doc, { platform: 'auto' }).warnings.map((warning) => warning.code);
+    expect((await validateWithEngine(doc)).warnings.map((warning) => warning.code)).toContain('W_NO_START');
+    const codes = (await validateWithEngine(doc, { platform: 'auto' })).warnings.map((warning) => warning.code);
     expect(codes).toContain('W_C7_DEPLOY_START_EVENT');
     expect(codes).not.toContain('W_NO_START');
   });
@@ -278,12 +275,12 @@ describe('one platform detector', () => {
     expect(both).toMatchObject({ platform: 'none', detail: 'xmlns:camunda and xmlns:zeebe declared, but no vendor content tells which engine' });
     const camunda = detectPlatform(await Doc.fromXml(xml(chain([UT()]))));
     expect(camunda.operaton).toBeUndefined();
-    const json = validateDoc(await Doc.fromXml(xml(chain([UT()]), { ns: OPERATON, attrs: 'operaton:historyTimeToLive="180"' })), { platform: 'auto' }).platform;
+    const json = (await validateWithEngine(await Doc.fromXml(xml(chain([UT()]), { ns: OPERATON, attrs: 'operaton:historyTimeToLive="180"' })), { platform: 'auto' })).platform;
     expect(json).toMatchObject({ platform: 'c7', operaton: true, counts: { deploy: 0 } });
   });
 
   it('hints use the operaton prefix in an Operaton file', async () => {
-    const [finding] = runProfile(await Doc.fromXml(xml(chain([['X', '<bpmn:serviceTask id="X" />']]), { ns: OPERATON, attrs: 'operaton:historyTimeToLive="180"' }))).findings;
+    const [finding] = (await runProfile(await Doc.fromXml(xml(chain([['X', '<bpmn:serviceTask id="X" />']]), { ns: OPERATON, attrs: 'operaton:historyTimeToLive="180"' })))).findings;
     expect(finding).toMatchObject({ code: 'W_C7_DEPLOY_IMPLEMENTATION', element: 'X' });
     expect(finding!.hint).toContain('operaton:type=external operaton:topic=<topic>');
   });
@@ -318,7 +315,7 @@ function commandsOf(hint: string): string[][] {
 
 describe('validate hints keep the siblings of a repeatable extension type', () => {
   let dir: string;
-  beforeAll(() => {
+  beforeAll(async () => {
     dir = mkdtempSync(join(tmpdir(), 'bpmn-c7-fu-'));
   });
   afterAll(() => rmSync(dir, { recursive: true, force: true }));
@@ -339,11 +336,11 @@ describe('validate hints keep the siblings of a repeatable extension type', () =
     const file = join(dir, 'dangling.bpmn');
     const task = `<bpmn:serviceTask id="X" camunda:type="external" camunda:topic="t">${ext('<camunda:errorEventDefinition id="CEED_1" errorRef="Error_Gone" expression="${true}" /><camunda:errorEventDefinition id="CEED_2" errorRef="Err" expression="${false}" />')}</bpmn:serviceTask>`;
     writeFileSync(file, xml(chain([['X', task]]), { roots: '<bpmn:error id="Err" name="Err" errorCode="E1" />' }));
-    const finding = runProfile(await Doc.fromXml(readFileSync(file, 'utf8'))).findings.find((candidate) => candidate.code === 'W_C7_DANGLING_REF')!;
+    const finding = (await runProfile(await Doc.fromXml(readFileSync(file, 'utf8')))).findings.find((candidate) => candidate.code === 'W_C7_DANGLING_REF')!;
     expect(finding.hint).toContain("`bpmn ext remove <file> X 'camunda:errorEventDefinition[id=CEED_1]'`");
     follow(finding.hint!, file, { '<errorId>': 'Err' });
     const after = await Doc.fromXml(readFileSync(file, 'utf8'));
-    expect(runProfile(after).findings).toEqual([]);
+    expect((await runProfile(after)).findings).toEqual([]);
     const ids = (after.get('X') as unknown as { extensionElements: { values: Array<{ id: string; errorRef: string }> } }).extensionElements.values.map((entry) => `${entry.id}:${entry.errorRef}`);
     expect(ids.sort()).toEqual(['CEED_1:Err', 'CEED_2:Err']);
   }, 60000);
@@ -351,30 +348,30 @@ describe('validate hints keep the siblings of a repeatable extension type', () =
   it('W_C7_DEPLOY_LISTENER: one listener is rebuilt, the others stay; "take" only for take', async () => {
     const file = join(dir, 'listener.bpmn');
     writeFileSync(file, xml(chain([UT('T', ext('<camunda:executionListener event="end" expression="${a}" /><camunda:executionListener event="finish" expression="${b}" />'))])));
-    const finding = runProfile(await Doc.fromXml(readFileSync(file, 'utf8'))).findings.find((candidate) => candidate.code === 'W_C7_DEPLOY_LISTENER')!;
+    const finding = (await runProfile(await Doc.fromXml(readFileSync(file, 'utf8')))).findings.find((candidate) => candidate.code === 'W_C7_DEPLOY_LISTENER')!;
     expect(finding.hint).not.toContain('take');
     expect(finding.hint).toContain("'camunda:executionListener[event=finish]'");
     follow(finding.hint!, file, { '<start|end>': 'start' });
     const after = await Doc.fromXml(readFileSync(file, 'utf8'));
-    expect(runProfile(after).findings).toEqual([]);
+    expect((await runProfile(after)).findings).toEqual([]);
     const events = (after.get('T') as unknown as { extensionElements: { values: Array<{ event: string; expression: string }> } }).extensionElements.values.map((listener) => `${listener.event}:${listener.expression}`);
     expect(events.sort()).toEqual(['end:${a}', 'start:${b}']);
-    const take = runProfile(await Doc.fromXml(xml(chain([UT('T', ext('<camunda:executionListener event="take" expression="${a}" />'))])))).findings[0]!;
+    const take = (await runProfile(await Doc.fromXml(xml(chain([UT('T', ext('<camunda:executionListener event="take" expression="${a}" />'))]))))).findings[0]!;
     expect(take.hint).toMatch(/^take is only read on sequence flows/);
   }, 60000);
 
   it('W_C7_DEPLOY_EXTENSION on camunda:in of a signal event definition: the definition. slot', async () => {
     const file = join(dir, 'in.bpmn');
     writeFileSync(file, xml(chain([['Th', `<bpmn:intermediateThrowEvent id="Th"><bpmn:signalEventDefinition signalRef="Sig">${ext('<camunda:in source="a" target="a" /><camunda:in source="b" />')}</bpmn:signalEventDefinition></bpmn:intermediateThrowEvent>`]]), { roots: ROOTS }));
-    const finding = runProfile(await Doc.fromXml(readFileSync(file, 'utf8'))).findings.find((candidate) => candidate.code === 'W_C7_DEPLOY_EXTENSION')!;
+    const finding = (await runProfile(await Doc.fromXml(readFileSync(file, 'utf8')))).findings.find((candidate) => candidate.code === 'W_C7_DEPLOY_EXTENSION')!;
     expect(finding.hint).toContain("'definition.camunda:in[source=b]'");
     follow(finding.hint!.replace(/ \(or with variables=all.*$/, ''), file, { '<var>': 'b' });
-    expect(runProfile(await Doc.fromXml(readFileSync(file, 'utf8'))).findings).toEqual([]);
+    expect((await runProfile(await Doc.fromXml(readFileSync(file, 'utf8')))).findings).toEqual([]);
   }, 60000);
 
   it('a single-instance container is still rebuilt as a whole', async () => {
     const doc = await Doc.fromXml(xml(chain([UT('T', ext('<camunda:inputOutput><camunda:inputParameter name="a" foo="1">1</camunda:inputParameter></camunda:inputOutput>'))])));
-    const finding = runProfile(doc).findings.find((candidate) => candidate.code === 'W_C7_UNKNOWN_ATTRIBUTE')!;
+    const finding = (await runProfile(doc)).findings.find((candidate) => candidate.code === 'W_C7_UNKNOWN_ATTRIBUTE')!;
     expect(finding.hint).toContain('camunda:inputOutput --replace --xml');
   });
 });
diff --git a/test/domain/validation/c7-profile.test.ts b/test/domain/validation/c7-profile.test.ts
index 0a74f5e0..2c84ef02 100644
--- a/test/domain/validation/c7-profile.test.ts
+++ b/test/domain/validation/c7-profile.test.ts
@@ -16,15 +16,14 @@
 import { mkdtempSync, rmSync, writeFileSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
+import type { ProfileFinding } from '../../../src/domain/document/Finding.js';
+import { runProfile, validateWithEngine } from '../../helpers/engine.js';
 import { afterAll, beforeAll, describe, expect, it } from 'vitest';
 import { Doc } from '../../../src/domain/document/Doc.js';
 import { checkFile } from '../../../src/node.js';
-import { mutateDoc, detectPlatform, loadProfiles, runProfile, type ProfileFinding } from '../../../src/index.js';
-import { validateDoc } from '../../../src/index.js';
+import { mutateDoc, detectPlatform } from '../../../src/index.js';
 import { cli } from '../../helpers/cli.js';
 
-// the engine rules load on demand; runProfile / validateDoc(doc, { platform }) need them loaded (the pipeline loads them itself)
-await loadProfiles();
 
 const CAMUNDA = 'xmlns:camunda="http://camunda.org/schema/1.0/bpmn"';
 const MODELER = 'xmlns:modeler="http://camunda.org/schema/modeler/1.0"';
@@ -160,10 +159,6 @@ const CASES: Case[] = [
   { name: 'elementVariable without collection', xml: xml(chain('<bpmn:userTask id="X"><bpmn:multiInstanceLoopCharacteristics camunda:elementVariable="item" /></bpmn:userTask>')), codes: ['W_C7_DEPLOY_MULTI_INSTANCE'], engine: 'reject' },
   { name: 'multi-instance with collection on the loop', xml: xml(chain(`<bpmn:userTask id="X">${MI_COLLECTION}</bpmn:userTask>`)), codes: [], engine: 'accept' },
   // duplicated and misplaced extension elements
-  { name: 'two camunda:inputOutput', xml: xml(chain(ST('', ext(IO + IO)))), codes: ['W_C7_DEPLOY_DUPLICATE_EXTENSION'], engine: 'reject' },
-  { name: 'two camunda:formData', xml: xml(chain('<bpmn:userTask id="X">' + ext('<camunda:formData><camunda:formField id="a" type="string" /></camunda:formData><camunda:formData><camunda:formField id="b" type="string" /></camunda:formData>') + '</bpmn:userTask>')), codes: ['W_C7_DEPLOY_DUPLICATE_EXTENSION'], engine: 'reject' },
-  { name: 'two retry cycles on an async task', xml: xml(chain(ST('camunda:asyncBefore="true"', ext('<camunda:failedJobRetryTimeCycle>R3/PT1M</camunda:failedJobRetryTimeCycle><camunda:failedJobRetryTimeCycle>R5/PT1M</camunda:failedJobRetryTimeCycle>')))), codes: ['W_C7_DEPLOY_DUPLICATE_EXTENSION'], engine: 'reject' },
-  { name: 'two retry cycles on a synchronous task', xml: xml(chain(ST('', ext('<camunda:failedJobRetryTimeCycle>R3/PT1M</camunda:failedJobRetryTimeCycle><camunda:failedJobRetryTimeCycle>R5/PT1M</camunda:failedJobRetryTimeCycle>')))), codes: ['W_C7_DUPLICATE_EXTENSION'], engine: 'accept' },
   { name: 'inputParameter loose in extensionElements', xml: xml(chain(ST('', ext('<camunda:inputParameter name="a">x</camunda:inputParameter>')))), codes: ['W_C7_MISPLACED_EXTENSION'], engine: 'accept' },
   { name: 'taskListener, camunda:in and formData on a service task', xml: xml(chain(ST('', ext('<camunda:taskListener event="create" class="a.B" /><camunda:in variables="all" /><camunda:formData />')))), codes: ['W_C7_MISPLACED_EXTENSION', 'W_C7_MISPLACED_EXTENSION', 'W_C7_MISPLACED_EXTENSION'], engine: 'accept' },
   { name: 'inputOutput on the process', xml: xml(chain(ST()), { head: `    ${ext(IO)}\n` }), codes: ['W_C7_MISPLACED_EXTENSION'], engine: 'accept' },
@@ -212,20 +207,6 @@ const CASES: Case[] = [
   { name: 'error boundary event without errorCode catches everything', xml: xml(boundary('<bpmn:userTask id="X" />', '<bpmn:errorEventDefinition errorRef="Err" />'), { roots: '  <bpmn:error id="Err" name="Err" />\n' }), codes: [], engine: 'accept' },
   { name: 'escalation end event without escalationCode', xml: xml(toEnd('<bpmn:escalationEventDefinition escalationRef="Esc" />'), { roots: '  <bpmn:escalation id="Esc" name="Esc" />\n' }), codes: ['W_C7_DEPLOY_ESCALATION'], engine: 'reject' },
   { name: 'escalation boundary event on a service task', xml: xml(boundary(ST(), '<bpmn:escalationEventDefinition escalationRef="Esc" />'), { roots: '  <bpmn:escalation id="Esc" name="Esc" escalationCode="E" />\n' }), codes: ['W_C7_DEPLOY_ESCALATION'], engine: 'reject' },
-  {
-    name: 'boundary event on a compensation handler',
-    xml: xml(
-      chain(ST(), `    <bpmn:boundaryEvent id="BC" attachedToRef="X"><bpmn:compensateEventDefinition /></bpmn:boundaryEvent>
-    <bpmn:serviceTask id="H" isForCompensation="true" camunda:expression="\${true}" />
-    <bpmn:boundaryEvent id="BT" attachedToRef="H">${TIMER}</bpmn:boundaryEvent>
-    <bpmn:sequenceFlow id="F3" sourceRef="BT" targetRef="End2" />
-    <bpmn:endEvent id="End2" />
-    <bpmn:association id="A1" associationDirection="One" sourceRef="BC" targetRef="H" />`),
-    ),
-    codes: ['W_C7_DEPLOY_BOUNDARY_HOST'],
-    engine: 'reject',
-    structural: 'E_INVALID_HOST',
-  },
   { name: 'timer without value', xml: xml(chain('<bpmn:intermediateCatchEvent id="X"><bpmn:timerEventDefinition /></bpmn:intermediateCatchEvent>')), codes: ['W_C7_DEPLOY_EVENT_DEFINITION'], engine: 'reject' },
   { name: 'script task without script', xml: xml(chain('<bpmn:scriptTask id="X" scriptFormat="groovy" />')), codes: ['W_C7_DEPLOY_SCRIPT'], engine: 'reject' },
   // exclusive gateways
@@ -236,7 +217,6 @@ const CASES: Case[] = [
   { name: 'one flow without condition and no default', xml: exclusive(['${a}', null]), codes: ['W_C7_EXCLUSIVE_GATEWAY_DEFAULT'], engine: 'accept' },
   { name: 'conditions plus a default flow', xml: exclusive(['${a}', null], 'S1'), codes: [], engine: 'accept' },
   // file level, attributes, foreign content
-  { name: 'extensionElements under bpmn:definitions', xml: xml(chain(ST()), { defsHead: `  ${ext('<camunda:properties><camunda:property name="a" value="b" /></camunda:properties>')}\n` }), codes: ['W_C7_DEPLOY_DEFINITIONS_EXTENSION'], engine: 'reject' },
   { name: 'camunda:assignee on a service task', xml: xml(chain(ST('camunda:assignee="demo"'))), codes: ['W_C7_MISPLACED_ATTRIBUTE'], engine: 'accept' },
   { name: 'typo camunda:asignee on a user task', xml: xml(chain('<bpmn:userTask id="X" camunda:asignee="demo" />')), codes: ['W_C7_UNKNOWN_ATTRIBUTE'], engine: 'accept' },
   { name: 'errorCodeVariable on the event instead of its definition', xml: xml(boundary(ST(), '<bpmn:errorEventDefinition errorRef="Err" />').replace('<bpmn:boundaryEvent id="B"', '<bpmn:boundaryEvent id="B" camunda:errorCodeVariable="code"'), { roots: '  <bpmn:error id="Err" name="Err" errorCode="E" />\n' }), codes: ['W_C7_MISPLACED_ATTRIBUTE'], engine: 'accept' },
@@ -270,8 +250,8 @@ const CASES: Case[] = [
   },
 ];
 
-function profileCodes(doc: Doc): string[] {
-  return validateDoc(doc, { platform: 'auto' })
+async function profileCodes(doc: Doc): Promise<string[]> {
+  return (await validateWithEngine(doc, { platform: 'auto' }))
     .warnings.filter((warning) => warning.code.startsWith('W_C7_'))
     .map((warning) => warning.code)
     .sort();
@@ -280,12 +260,12 @@ function profileCodes(doc: Doc): string[] {
 describe('Camunda 7 profile: one model per rule', () => {
   it.each(CASES.map((testCase) => [testCase.name, testCase] as const))('%s', async (_name, testCase) => {
     // standalone on a fresh document: the rules must not rely on validateDoc having repaired incoming/outgoing
-    const findings = runProfile(await Doc.fromXml(testCase.xml)).findings;
+    const findings = (await runProfile(await Doc.fromXml(testCase.xml))).findings;
     expect(findings.map((finding) => finding.code).sort()).toEqual([...testCase.codes].sort());
     // validate reports a problem once: a structural error replaces the profile finding that repeats it
-    expect(profileCodes(await Doc.fromXml(testCase.xml))).toEqual(testCase.structural ? [] : [...testCase.codes].sort());
+    expect((await profileCodes(await Doc.fromXml(testCase.xml)))).toEqual(testCase.structural ? [] : [...testCase.codes].sort());
     if (testCase.structural) {
-      expect(validateDoc(await Doc.fromXml(testCase.xml), { platform: 'auto' }).errors.map((error) => error.code)).toContain(testCase.structural);
+      expect((await validateWithEngine(await Doc.fromXml(testCase.xml), { platform: 'auto' })).errors.map((error) => error.code)).toContain(testCase.structural);
     }
     // deploy-severity findings exactly where the engines refuse the file
     expect(findings.some((finding) => finding.severity === 'deploy')).toBe(testCase.engine === 'reject');
@@ -298,37 +278,37 @@ describe('Camunda 7 profile: one model per rule', () => {
 
   it('names the element and the fix (did you mean, nested keys)', async () => {
     const typo = await Doc.fromXml(xml(chain('<bpmn:userTask id="X" camunda:asignee="demo" />')));
-    const [finding] = runProfile(typo).findings;
+    const [finding] = (await runProfile(typo)).findings;
     expect(finding).toMatchObject({ code: 'W_C7_UNKNOWN_ATTRIBUTE', element: 'X', severity: 'runtime' });
     expect(finding!.message).toContain('did you mean camunda:assignee?');
     expect(finding!.hint).toContain('`bpmn set <file> X camunda:asignee= camunda:assignee=demo`');
     const mi = await Doc.fromXml(xml(chain('<bpmn:userTask id="X" camunda:collection="${items}"><bpmn:multiInstanceLoopCharacteristics /></bpmn:userTask>')));
-    const deploy = runProfile(mi).findings.find((finding) => finding.code === 'W_C7_DEPLOY_MULTI_INSTANCE')!;
+    const deploy = (await runProfile(mi)).findings.find((finding) => finding.code === 'W_C7_DEPLOY_MULTI_INSTANCE')!;
     expect(deploy.hint).toContain("`bpmn set <file> X camunda:collection= 'loop.camunda:collection=${items}'`");
     const ttl = await Doc.fromXml(xml(chain(ST()), { attrs: '' }));
-    expect(runProfile(ttl).findings[0]!.hint).toContain('`bpmn set <file> P_Test camunda:historyTimeToLive=180`');
+    expect((await runProfile(ttl)).findings[0]!.hint).toContain('`bpmn set <file> P_Test camunda:historyTimeToLive=180`');
     const event = await Doc.fromXml(xml(toEnd('<bpmn:messageEventDefinition id="MED" />')));
-    expect(runProfile(event).findings[0]).toMatchObject({ code: 'W_C7_MESSAGE_NO_IMPLEMENTATION', element: 'End' });
-    expect(runProfile(event).findings[0]!.hint).toContain('definition.camunda:type=external');
+    expect((await runProfile(event)).findings[0]).toMatchObject({ code: 'W_C7_MESSAGE_NO_IMPLEMENTATION', element: 'End' });
+    expect((await runProfile(event)).findings[0]!.hint).toContain('definition.camunda:type=external');
   });
 
   it('replaces the lint warning about an event-gateway target with the engine finding', async () => {
     const doc = await Doc.fromXml(eventGateway([TIMER_CATCH, '<bpmn:userTask id="{id}" />']));
-    expect(validateDoc(doc).warnings.map((warning) => warning.code)).toContain('W_EVENT_GATEWAY_TARGET');
-    const codes = validateDoc(doc, { platform: 'auto' }).warnings.map((warning) => warning.code);
+    expect((await validateWithEngine(doc)).warnings.map((warning) => warning.code)).toContain('W_EVENT_GATEWAY_TARGET');
+    const codes = (await validateWithEngine(doc, { platform: 'auto' })).warnings.map((warning) => warning.code);
     expect(codes).toContain('W_C7_DEPLOY_EVENT_GATEWAY');
     expect(codes).not.toContain('W_EVENT_GATEWAY_TARGET');
   });
 
   it('runs only on request: validateDoc without a platform and other platforms report nothing', async () => {
     const doc = await Doc.fromXml(xml(chain('<bpmn:serviceTask id="X" />'), { attrs: '' }));
-    expect(validateDoc(doc).warnings.some((warning) => warning.code.startsWith('W_C7_'))).toBe(false);
-    expect(validateDoc(doc).platform).toBeUndefined();
-    expect(validateDoc(doc, { platform: 'none' }).warnings.some((warning) => warning.code.startsWith('W_C7_'))).toBe(false);
-    expect(validateDoc(doc, { platform: 'c8' }).platform).toMatchObject({ platform: 'c8', source: 'option' });
+    expect((await validateWithEngine(doc)).warnings.some((warning) => warning.code.startsWith('W_C7_'))).toBe(false);
+    expect((await validateWithEngine(doc)).platform).toBeUndefined();
+    expect((await validateWithEngine(doc, { platform: 'none' })).warnings.some((warning) => warning.code.startsWith('W_C7_'))).toBe(false);
+    expect((await validateWithEngine(doc, { platform: 'c8' })).platform).toMatchObject({ platform: 'c8', source: 'option' });
     const plain = await Doc.fromXml(xml(chain('<bpmn:serviceTask id="X" />'), { ns: '', attrs: '' }));
-    expect(validateDoc(plain, { platform: 'auto' }).platform).toMatchObject({ platform: 'none', counts: { deploy: 0, runtime: 0, practice: 0 } });
-    expect(validateDoc(plain, { platform: 'c7' }).warnings.map((warning) => warning.code)).toEqual(expect.arrayContaining(['W_C7_DEPLOY_IMPLEMENTATION']));
+    expect((await validateWithEngine(plain, { platform: 'auto' })).platform).toMatchObject({ platform: 'none', counts: { deploy: 0, runtime: 0, practice: 0 } });
+    expect((await validateWithEngine(plain, { platform: 'c7' })).warnings.map((warning) => warning.code)).toEqual(expect.arrayContaining(['W_C7_DEPLOY_IMPLEMENTATION']));
   });
 });
 
@@ -355,7 +335,7 @@ describe('platform detection', () => {
     const doc = Doc.create({ target: 'camunda7', processName: 'Order' });
     expect(detectPlatform(doc)).toMatchObject({ platform: 'c7', source: 'executionPlatform' });
     // the engines refuse an empty process ("process must define a startEvent element")
-    expect(runProfile(doc).findings.map((finding) => finding.code)).toEqual(['W_C7_DEPLOY_START_EVENT']);
+    expect((await runProfile(doc)).findings.map((finding) => finding.code)).toEqual(['W_C7_DEPLOY_START_EVENT']);
   });
 });
 
@@ -408,7 +388,7 @@ describe('mutations report only the findings they introduce', () => {
 
 describe('bpmn validate', () => {
   let dir: string;
-  beforeAll(() => {
+  beforeAll(async () => {
     dir = mkdtempSync(join(tmpdir(), 'bpmn-c7-'));
   });
   afterAll(() => rmSync(dir, { recursive: true, force: true }));
@@ -466,7 +446,7 @@ describe.skipIf(!ENGINES.length)('live engines: the deploy rules flag exactly wh
     it.each(CASES.map((testCase, caseIndex) => [testCase.name, testCase, caseIndex] as const))(`${engine}: %s`, async (_name, testCase, caseIndex) => {
       const result = await deploy(engine, `bpmn-cli-c7-profile-${caseIndex}`, testCase.xml);
       expect(result.ok, result.message).toBe(testCase.engine === 'accept');
-      const deployFindings = runProfile(await Doc.fromXml(testCase.xml)).findings.filter((finding) => finding.severity === 'deploy');
+      const deployFindings = (await runProfile(await Doc.fromXml(testCase.xml))).findings.filter((finding) => finding.severity === 'deploy');
       expect(deployFindings.length > 0).toBe(!result.ok);
     });
   }
diff --git a/test/domain/validation/c7-schema-rules.test.ts b/test/domain/validation/c7-schema-rules.test.ts
index acef5984..49f1e812 100644
--- a/test/domain/validation/c7-schema-rules.test.ts
+++ b/test/domain/validation/c7-schema-rules.test.ts
@@ -33,15 +33,12 @@
 import { mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
+import { runProfile, validateWithEngine } from '../../helpers/engine.js';
 import { afterAll, beforeAll, describe, expect, it } from 'vitest';
 import { Doc } from '../../../src/domain/document/Doc.js';
 import { mutateDoc } from '../../../src/index.js';
-import { loadProfiles, runProfile } from '../../../src/index.js';
-import { validateDoc } from '../../../src/index.js';
 import { cli } from '../../helpers/cli.js';
 
-// the engine rules load on demand; runProfile / validateDoc(doc, { platform }) need them loaded (the pipeline loads them itself)
-await loadProfiles();
 
 const BPMN = 'xmlns:bpmn="http://www.omg.org/spec/BPMN/20100524/MODEL" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"';
 const C7 = 'xmlns:camunda="http://camunda.org/schema/1.0/bpmn" xmlns:modeler="http://camunda.org/schema/modeler/1.0" modeler:executionPlatform="Camunda Platform"';
@@ -107,27 +104,18 @@ interface Case {
   before?: boolean;
 }
 
-const MULTIPLE = 'W_C7_MULTIPLE_EVENT_DEFINITIONS';
-
 const CASES: Case[] = [
   // 1. schema rules on every event definition
-  { name: 'timer + conditional without condition (intermediate catch)', xml: xml(catchWith(TIMER + COND_NONE)), codes: [MULTIPLE, 'W_C7_DEPLOY_EVENT_DEFINITION'], engine: 'reject', before: true },
-  { name: 'conditional without condition + timer (intermediate catch, the timer acts)', xml: xml(catchWith(COND_NONE + TIMER)), codes: [MULTIPLE, 'W_C7_DEPLOY_EVENT_DEFINITION'], engine: 'reject', before: true },
-  { name: 'timer + conditional without condition (boundary event)', xml: xml(beside(`<bpmn:boundaryEvent id="W" attachedToRef="U">${TIMER}${COND_NONE}</bpmn:boundaryEvent>${flow('FB', 'W', 'EB')}<bpmn:endEvent id="EB" />`)), codes: [MULTIPLE, 'W_C7_DEPLOY_EVENT_DEFINITION'], engine: 'reject', before: true },
-  { name: 'timer + conditional without condition (process start event)', xml: xml(`<bpmn:startEvent id="W">${TIMER}${COND_NONE}</bpmn:startEvent>${flow('F1', 'W', 'End')}<bpmn:endEvent id="End" />`), codes: [MULTIPLE, 'W_C7_DEPLOY_EVENT_DEFINITION'], engine: 'reject', before: true },
-  { name: 'timer + link without name (intermediate catch)', xml: xml(catchWith(TIMER + LINK_NONAME)), codes: [MULTIPLE, 'W_C7_DEPLOY_LINK'], engine: 'reject', before: true },
+  { name: 'timer + conditional without condition (intermediate catch)', xml: xml(catchWith(TIMER + COND_NONE)), codes: ['W_C7_DEPLOY_EVENT_DEFINITION'], engine: 'reject', before: true },
+  { name: 'conditional without condition + timer (intermediate catch, the timer acts)', xml: xml(catchWith(COND_NONE + TIMER)), codes: ['W_C7_DEPLOY_EVENT_DEFINITION'], engine: 'reject', before: true },
+  { name: 'timer + conditional without condition (boundary event)', xml: xml(beside(`<bpmn:boundaryEvent id="W" attachedToRef="U">${TIMER}${COND_NONE}</bpmn:boundaryEvent>${flow('FB', 'W', 'EB')}<bpmn:endEvent id="EB" />`)), codes: ['W_C7_DEPLOY_EVENT_DEFINITION'], engine: 'reject', before: true },
+  { name: 'timer + conditional without condition (process start event)', xml: xml(`<bpmn:startEvent id="W">${TIMER}${COND_NONE}</bpmn:startEvent>${flow('F1', 'W', 'End')}<bpmn:endEvent id="End" />`), codes: ['W_C7_DEPLOY_EVENT_DEFINITION'], engine: 'reject', before: true },
+  { name: 'timer + link without name (intermediate catch)', xml: xml(catchWith(TIMER + LINK_NONAME)), codes: ['W_C7_DEPLOY_LINK'], engine: 'reject', before: true },
   { name: 'timer with timeDate and timeDuration', xml: xml(catchWith(TWO_TIMES)), codes: ['W_C7_DEPLOY_EVENT_DEFINITION'], engine: 'reject', before: true },
-  { name: 'event sub-process start: message acts, an ignored timer with two time elements', xml: xml(beside(`<bpmn:subProcess id="ES" triggeredByEvent="true"><bpmn:startEvent id="W" isInterrupting="false"><bpmn:messageEventDefinition messageRef="M1" />${TWO_TIMES}</bpmn:startEvent>${flow('e1', 'W', 'ESE')}<bpmn:endEvent id="ESE" /></bpmn:subProcess>`), { roots: MSG }), codes: [MULTIPLE, 'W_C7_DEPLOY_EVENT_DEFINITION'], engine: 'reject', before: true },
+  { name: 'event sub-process start: message acts, an ignored timer with two time elements', xml: xml(beside(`<bpmn:subProcess id="ES" triggeredByEvent="true"><bpmn:startEvent id="W" isInterrupting="false"><bpmn:messageEventDefinition messageRef="M1" />${TWO_TIMES}</bpmn:startEvent>${flow('e1', 'W', 'ESE')}<bpmn:endEvent id="ESE" /></bpmn:subProcess>`), { roots: MSG }), codes: ['W_C7_DEPLOY_EVENT_DEFINITION'], engine: 'reject', before: true },
   { name: 'conditional without condition in a non-executable process', xml: xml(beside(''), { extra: NON_EXECUTABLE(`<bpmn:intermediateCatchEvent id="O_W">${COND_NONE}</bpmn:intermediateCatchEvent>${flow('O_F', 'O_S', 'O_W')}`) }), codes: ['W_C7_DEPLOY_EVENT_DEFINITION'], engine: 'reject', before: true },
   { name: 'link without name in a non-executable process', xml: xml(beside(''), { extra: NON_EXECUTABLE(`<bpmn:intermediateThrowEvent id="O_W">${LINK_NONAME}</bpmn:intermediateThrowEvent>${flow('O_F', 'O_S', 'O_W')}`) }), codes: ['W_C7_DEPLOY_LINK'], engine: 'reject', before: true },
-  { name: 'semantic rules stay on the acting definition: timer + message without messageRef', xml: xml(catchWith(`${TIMER}<bpmn:messageEventDefinition id="MDef" />`)), codes: [MULTIPLE], engine: 'accept' },
-  // 2. a duplicate on a loop with an id of its own (the hints are followed below)
-  {
-    name: 'two failedJobRetryTimeCycle on an asynchronous multi-instance loop',
-    xml: xml(around(`<bpmn:userTask id="SP"><bpmn:multiInstanceLoopCharacteristics camunda:asyncBefore="true" camunda:collection="\${items}" camunda:elementVariable="item"><bpmn:extensionElements><camunda:failedJobRetryTimeCycle>R3/PT1M</camunda:failedJobRetryTimeCycle><camunda:failedJobRetryTimeCycle>R5/PT1M</camunda:failedJobRetryTimeCycle></bpmn:extensionElements></bpmn:multiInstanceLoopCharacteristics></bpmn:userTask>`)),
-    codes: ['W_C7_DEPLOY_DUPLICATE_EXTENSION'],
-    engine: 'reject',
-  },
+  { name: 'semantic rules stay on the acting definition: timer + message without messageRef', xml: xml(catchWith(`${TIMER}<bpmn:messageEventDefinition id="MDef" />`)), codes: [], engine: 'accept' },
   // 3. start events of transactions, sub-processes, processes; ad-hoc sub-processes
   { name: 'transaction with a task but no start event', xml: xml(around(`<bpmn:transaction id="SP">${UT('T')}</bpmn:transaction>`)), codes: ['W_C7_TRANSACTION_NO_START'], engine: 'accept', run: 'fails', before: true },
   { name: 'empty transaction', xml: xml(around('<bpmn:transaction id="SP" />')), codes: ['W_C7_TRANSACTION_NO_START'], engine: 'accept', run: 'fails', before: true },
@@ -170,7 +158,7 @@ const CASES: Case[] = [
 
 describe('verifier follow-ups: one synthetic model per rule', () => {
   it.each(CASES.map((testCase) => [testCase.name, testCase] as const))('%s', async (_name, testCase) => {
-    const report = runProfile(await Doc.fromXml(testCase.xml));
+    const report = (await runProfile(await Doc.fromXml(testCase.xml)));
     const findings = report.findings;
     expect(findings.map((finding) => finding.code).sort(), JSON.stringify(findings, null, 1)).toEqual([...testCase.codes].sort());
     // deploy findings exactly where the engine that reads the file refuses it
@@ -182,30 +170,30 @@ describe('verifier follow-ups: one synthetic model per rule', () => {
   });
 
   it('a schema finding on an ignored definition names the acting one and both ways out', async () => {
-    const finding = runProfile(await Doc.fromXml(CASES[0]!.xml)).findings.find((candidate) => candidate.code === 'W_C7_DEPLOY_EVENT_DEFINITION')!;
+    const finding = (await runProfile(await Doc.fromXml(CASES[0]!.xml))).findings.find((candidate) => candidate.code === 'W_C7_DEPLOY_EVENT_DEFINITION')!;
     expect(finding).toMatchObject({ element: 'W', severity: 'deploy' });
     expect(finding.message).toBe('The conditional definition of intermediateCatchEvent:timer W has no condition element, which the BPMN schema requires; the engines refuse the file');
     expect(finding.hint).toContain('`bpmn set <file> W trigger=timer` (keeps only the timer)');
     expect(finding.hint).toContain("`bpmn set <file> W 'when=${expression}'` (keeps only the conditional definition)");
     // a single definition keeps the message and the subject of before (a write does not report it as new)
-    const single = runProfile(await Doc.fromXml(xml(catchWith(COND_NONE)))).findings[0]!;
+    const single = (await runProfile(await Doc.fromXml(xml(catchWith(COND_NONE))))).findings[0]!;
     expect(single.message).toBe('Conditional event W has no condition element, which the BPMN schema requires; the engines refuse the file');
     expect(single.hint).toBe("`bpmn set <file> W 'when=${expression}'`.");
   });
 
   it('the start-event and empty-sub-process lint gives way to the engine finding about the same scope', async () => {
-    const empty = validateDoc(await Doc.fromXml(CASES.find((testCase) => testCase.name === 'empty embedded sub-process')!.xml), { platform: 'auto' });
+    const empty = (await validateWithEngine(await Doc.fromXml(CASES.find((testCase) => testCase.name === 'empty embedded sub-process')!.xml), { platform: 'auto' }));
     expect(empty.warnings.map((warning) => warning.code)).toEqual(['W_C7_DEPLOY_START_EVENT']);
     expect(empty.warnings[0]!.message).toBe('Sub-process SP is empty, without a start event; the engines refuse the file (subProcess must define a startEvent element)');
-    const tx = validateDoc(await Doc.fromXml(CASES.find((testCase) => testCase.name === 'transaction with a task but no start event')!.xml), { platform: 'auto' });
+    const tx = (await validateWithEngine(await Doc.fromXml(CASES.find((testCase) => testCase.name === 'transaction with a task but no start event')!.xml), { platform: 'auto' }));
     expect(tx.warnings.map((warning) => warning.code)).not.toContain('W_NO_START');
     expect(tx.platform).toMatchObject({ counts: { deploy: 0, runtime: 1 } });
     // without the profile the lint stays
-    expect(validateDoc(await Doc.fromXml(CASES.find((testCase) => testCase.name === 'empty embedded sub-process')!.xml)).warnings.map((warning) => warning.code)).toContain('W_EMPTY_SUBPROCESS');
+    expect((await validateWithEngine(await Doc.fromXml(CASES.find((testCase) => testCase.name === 'empty embedded sub-process')!.xml))).warnings.map((warning) => warning.code)).toContain('W_EMPTY_SUBPROCESS');
   });
 
   it('second start events: removed when the first one reaches where they lead, never two flows into one node', async () => {
-    const hint = async (body: string, options: { roots?: string } = {}): Promise<string> => runProfile(await Doc.fromXml(xml(body, options))).findings.find((finding) => finding.code === 'W_C7_DEPLOY_START_EVENT')!.hint!;
+    const hint = async (body: string, options: { roots?: string } = {}): Promise<string> => (await runProfile(await Doc.fromXml(xml(body, options)))).findings.find((finding) => finding.code === 'W_C7_DEPLOY_START_EVENT')!.hint!;
     const same = await hint(twoStarts.same);
     expect(same).toMatch(/^Remove it: `bpmn remove <file> B` \(A already leads to U; F3 goes with it\), or give it another trigger/);
     expect(same).not.toContain('source=');
@@ -248,7 +236,7 @@ function commandsOf(hint: string): string[][] {
 
 describe('hints run through the CLI', () => {
   let dir: string;
-  beforeAll(() => {
+  beforeAll(async () => {
     dir = mkdtempSync(join(tmpdir(), 'bpmn-c7-fv-'));
   });
   afterAll(() => rmSync(dir, { recursive: true, force: true }));
@@ -257,7 +245,7 @@ describe('hints run through the CLI', () => {
   async function follow(name: string, content: string, code: string, element: string, opts: { pick?: (cmds: string[][]) => string[][]; fill?: Record<string, string> } = {}): Promise<{ file: string; hint: string; after: Doc }> {
     const file = join(dir, `${name}.bpmn`);
     writeFileSync(file, content);
-    const finding = runProfile(await Doc.fromXml(readFileSync(file, 'utf8'))).findings.find((candidate) => candidate.code === code && candidate.element === element);
+    const finding = (await runProfile(await Doc.fromXml(readFileSync(file, 'utf8')))).findings.find((candidate) => candidate.code === code && candidate.element === element);
     expect(finding, `${code} on ${element}`).toBeDefined();
     const all = commandsOf(finding!.hint!);
     const cmds = opts.pick ? opts.pick(all) : all;
@@ -270,7 +258,7 @@ describe('hints run through the CLI', () => {
     return { file, hint: finding!.hint!, after: await Doc.fromXml(readFileSync(file, 'utf8')) };
   }
 
-  const remaining = (doc: Doc, code: string): string[] => runProfile(doc).findings.filter((finding) => finding.code === code).map((finding) => finding.element ?? '');
+  const remaining = async (doc: Doc, code: string): Promise<string[]> => (await runProfile(doc)).findings.filter((finding) => finding.code === code).map((finding) => finding.element ?? '');
   const ext = (inner: string): string => `<bpmn:extensionElements>${inner}</bpmn:extensionElements>`;
   /** a timer catch event W whose definition holds `inner`, with or without an id of its own */
   const timerHost = (inner: string, defId: boolean): string => xml(catchWith(`<bpmn:timerEventDefinition${defId ? ' id="Def_T"' : ''}>${ext(inner)}<bpmn:timeDuration xsi:type="bpmn:tFormalExpression">PT1H</bpmn:timeDuration></bpmn:timerEventDefinition>`));
@@ -286,47 +274,40 @@ describe('hints run through the CLI', () => {
     it('W_C7_MISPLACED_EXTENSION on a timer definition: removed there and added to the event', async () => {
       const { hint, after } = await follow(`mis-def-${tag}`, timerHost('<camunda:failedJobRetryTimeCycle>R3/PT1M</camunda:failedJobRetryTimeCycle>', ownId), 'W_C7_MISPLACED_EXTENSION', 'W');
       expect(hint).toContain('`bpmn ext remove <file> W definition.0`');
-      expect(runProfile(after).findings).toEqual([]);
+      expect((await runProfile(after)).findings).toEqual([]);
       expect(after.require('W').get<{ values: Array<{ $type: string; $body: string }> }>('extensionElements').values.map((extension) => `${extension.$type}:${extension.$body}`)).toEqual(['camunda:failedJobRetryTimeCycle:R3/PT1M']);
     }, 60000);
 
     it('W_C7_UNKNOWN_ELEMENT on a timer definition: the remove command works', async () => {
       const { hint, after } = await follow(`unknown-def-${tag}`, timerHost('<camunda:foo />', ownId), 'W_C7_UNKNOWN_ELEMENT', 'W', { pick: (testCase) => testCase.slice(0, 1) });
       expect(hint).toContain('`bpmn ext remove <file> W definition.0`');
-      expect(runProfile(after).findings).toEqual([]);
+      expect((await runProfile(after)).findings).toEqual([]);
     }, 60000);
 
     it('W_C7_MISPLACED_EXTENSION on a multi-instance loop: removed there and added to the task', async () => {
       const { hint, after } = await follow(`mis-loop-${tag}`, loopHost('<camunda:failedJobRetryTimeCycle>R3/PT1M</camunda:failedJobRetryTimeCycle><camunda:taskListener event="create" expression="${x}" />', ownId), 'W_C7_MISPLACED_EXTENSION', 'SP');
       expect(hint).toContain('`bpmn ext remove <file> SP loop.1`');
-      expect(remaining(after, 'W_C7_MISPLACED_EXTENSION')).toEqual([]);
+      expect((await remaining(after, 'W_C7_MISPLACED_EXTENSION'))).toEqual([]);
     }, 60000);
 
     it('W_C7_UNKNOWN_ELEMENT on a multi-instance loop: the remove command works', async () => {
       const { hint, after } = await follow(`unknown-loop-${tag}`, loopHost('<camunda:foo />', ownId), 'W_C7_UNKNOWN_ELEMENT', 'SP', { pick: (testCase) => testCase.slice(0, 1) });
       expect(hint).toContain('`bpmn ext remove <file> SP loop.0`');
-      expect(runProfile(after).findings).toEqual([]);
-    }, 60000);
-
-    it('W_C7_DEPLOY_DUPLICATE_EXTENSION on an asynchronous loop: the merge goes to the loop', async () => {
-      const content = loopHost('<camunda:failedJobRetryTimeCycle>R3/PT1M</camunda:failedJobRetryTimeCycle><camunda:failedJobRetryTimeCycle>R5/PT1M</camunda:failedJobRetryTimeCycle>', ownId).replace('<bpmn:multiInstanceLoopCharacteristics', '<bpmn:multiInstanceLoopCharacteristics camunda:asyncBefore="true"');
-      const { hint, after } = await follow(`dup-loop-${tag}`, content, 'W_C7_DEPLOY_DUPLICATE_EXTENSION', 'SP', { fill: { '...': 'R3/PT1M' } });
-      expect(hint).toContain('`bpmn ext add <file> SP loop.camunda:failedJobRetryTimeCycle --replace');
-      expect(runProfile(after).findings).toEqual([]);
+      expect((await runProfile(after)).findings).toEqual([]);
     }, 60000);
   });
 
   it('schema findings on an ignored definition: both ways out deploy-clean', async () => {
     const content = CASES[0]!.xml;
     const keep = await follow('schema-keep', content, 'W_C7_DEPLOY_EVENT_DEFINITION', 'W', { pick: (testCase) => testCase.slice(0, 1) });
-    expect(runProfile(keep.after).findings).toEqual([]);
+    expect((await runProfile(keep.after)).findings).toEqual([]);
     expect(keep.after.require('W').get<unknown[]>('eventDefinitions').length).toBe(1);
     const cond = await follow('schema-cond', content, 'W_C7_DEPLOY_EVENT_DEFINITION', 'W', { pick: (testCase) => testCase.slice(1, 2), fill: { '${expression}': '${ready}' } });
-    expect(runProfile(cond.after).findings).toEqual([]);
+    expect((await runProfile(cond.after)).findings).toEqual([]);
     const link = await follow('schema-link', xml(catchWith(TIMER + LINK_NONAME)), 'W_C7_DEPLOY_LINK', 'W', { pick: (testCase) => testCase.slice(0, 1) });
-    expect(runProfile(link.after).findings).toEqual([]);
+    expect((await runProfile(link.after)).findings).toEqual([]);
     const times = await follow('schema-times', xml(catchWith(TWO_TIMES)), 'W_C7_DEPLOY_EVENT_DEFINITION', 'W', { fill: { '<value>': 'PT2H' } });
-    expect(runProfile(times.after).findings).toEqual([]);
+    expect((await runProfile(times.after)).findings).toEqual([]);
   }, 60000);
 
   it.each([
@@ -337,7 +318,7 @@ describe('hints run through the CLI', () => {
     ['mixed', twoStarts.mixed, 'U,V'],
   ])('a second start event (%s): following the first way out leaves no doubled branch', async (name, body, targets) => {
     const { after } = await follow(`two-${name}`, xml(body), 'W_C7_DEPLOY_START_EVENT', 'B', { pick: (testCase) => testCase.filter((argv) => !argv.includes('trigger=message')) });
-    expect(runProfile(after).findings).toEqual([]);
+    expect((await runProfile(after)).findings).toEqual([]);
     expect(after.get('B')).toBeUndefined();
     const out = after.outgoing(after.require('A')).map((flow) => flow.get<{ id: string }>('targetRef').id);
     expect(new Set(out).size).toBe(out.length);
@@ -346,21 +327,21 @@ describe('hints run through the CLI', () => {
 
   it('a second start event: another trigger keeps both ways in', async () => {
     const { after } = await follow('two-trigger', xml(twoStarts.same), 'W_C7_DEPLOY_START_EVENT', 'B', { pick: (testCase) => testCase.filter((argv) => argv.includes('trigger=message')), fill: { '<Name>': 'Other' } });
-    expect(runProfile(after).findings).toEqual([]);
+    expect((await runProfile(after)).findings).toEqual([]);
   }, 60000);
 
   it('a second start event of an event sub-process: removed, its trigger in an event sub-process of its own', async () => {
     const { after } = await follow('two-esp', xml(ESP_TWO, { roots: MSG }), 'W_C7_DEPLOY_START_EVENT', 'B', { fill: { '<Name>': 'Other' } });
-    expect(runProfile(after).findings).toEqual([]);
+    expect((await runProfile(after)).findings).toEqual([]);
   }, 60000);
 
   it('an empty sub-process, a transaction without start, a connected ad-hoc sub-process: the hints lead to a clean file', async () => {
     const sp = await follow('empty-sub', CASES.find((testCase) => testCase.name === 'empty embedded sub-process')!.xml, 'W_C7_DEPLOY_START_EVENT', 'SP', { pick: (testCase) => testCase.slice(0, 1), fill: { '<Name>': 'Go' } });
-    expect(runProfile(sp.after).findings).toEqual([]);
+    expect((await runProfile(sp.after)).findings).toEqual([]);
     const tx = await follow('tx', CASES.find((testCase) => testCase.name === 'transaction with a task but no start event')!.xml, 'W_C7_TRANSACTION_NO_START', 'SP', { pick: (testCase) => testCase.slice(0, 1), fill: { '<Name>': 'Go', '<firstNodeId>': 'T' } });
-    expect(runProfile(tx.after).findings).toEqual([]);
+    expect((await runProfile(tx.after)).findings).toEqual([]);
     const adHoc = await follow('adhoc', CASES.find((testCase) => testCase.name === 'ad-hoc sub-process with sequence flows')!.xml, 'W_C7_DEPLOY_AD_HOC_SUBPROCESS', 'SP', { pick: (testCase) => testCase.slice(0, 2), fill: { '<Name>': 'Go' } });
-    expect(remaining(adHoc.after, 'W_C7_DEPLOY_AD_HOC_SUBPROCESS')).toEqual([]);
+    expect((await remaining(adHoc.after, 'W_C7_DEPLOY_AD_HOC_SUBPROCESS'))).toEqual([]);
     expect(adHoc.after.require('SP').$type).toBe('bpmn:SubProcess');
   }, 60000);
 });
@@ -434,7 +415,7 @@ describe.skipIf(!ENGINES.length)('live engines: the engines agree with CASES', (
         ['mixed', twoStarts.mixed, ['U', 'V']],
       ] as const) {
         const doc = await Doc.fromXml(xml(body));
-        const hint = runProfile(doc).findings.find((finding) => finding.code === 'W_C7_DEPLOY_START_EVENT')!.hint!;
+        const hint = (await runProfile(doc)).findings.find((finding) => finding.code === 'W_C7_DEPLOY_START_EVENT')!.hint!;
         // the hint's first way out, as ops: `set <flow> source=A` for each flow it names, then `remove B`
         const moves = [...hint.split(', or ')[0]!.matchAll(/`bpmn set <file> (\w+) source=A`/g)].map((match) => ({ op: 'set' as const, id: match[1]!, values: { source: 'A' } }));
         await mutateDoc(doc, [...moves, { op: 'remove', ids: ['B'] }], { dryRun: true, layout: false });
diff --git a/test/domain/validation/c8-feel-and-deploy.test.ts b/test/domain/validation/c8-feel-and-deploy.test.ts
index 577831f1..2cb7dd2a 100644
--- a/test/domain/validation/c8-feel-and-deploy.test.ts
+++ b/test/domain/validation/c8-feel-and-deploy.test.ts
@@ -2,12 +2,9 @@
  * Camunda 8 after the step 3 verifier round (each finding with a test that
  * failed before the fix):
  *
- *  - FEEL is parsed (src/domain/validation/profiles/FeelParser.ts): the 762 expressions of
- *    fixtures/c8/feel-verdicts.json were deployed to Camunda 8.9.22 as flow
- *    conditions; the check agrees with the engine on every one (`&`, `|`,
- *    `<>`, `>>`, `%`, if without else, AND, `:=` ... are refused; ranges,
- *    unary tests, contexts, function names with spaces, keywords glued to a
- *    name ... pass). The messages name the FEEL spelling.
+ *  - FEEL: the 762 expressions of fixtures/c8/feel-verdicts.json were deployed
+ *    to Camunda 8.9.22 as flow conditions; FeelExpression.test.ts checks the
+ *    rule agrees with the engine on every one.
  *  - Deploy rules the profile missed and false deploy findings: MODELS with
  *    the engine's verdict (FEEL in a script, an ad-hoc completion condition,
  *    a signal / published message name and the zeebe:adHoc expressions,
@@ -31,15 +28,10 @@ import { describe, expect, it } from 'vitest';
 import { Doc } from '../../../src/domain/document/Doc.js';
 import { runOps } from '../../../src/index.js';
 import { mutateDoc } from '../../../src/index.js';
-import { FeelExpression } from '../../../src/domain/validation/profiles/FeelExpression.js';
-import { TimerValue } from '../../../src/domain/validation/profiles/TimerValue.js';
-import { loadProfiles, runProfile } from '../../../src/index.js';
+import { runProfile } from '../../helpers/engine.js';
 import { guideText, kindsSections } from '../../../src/index.js';
 import { KINDS_SECTION_NAMES } from '../../../src/adapters/in/report/KindsReference.js';
 
-// the engine rules load on demand; runProfile / validateDoc(doc, { platform }) need them loaded (the pipeline loads them itself)
-await loadProfiles();
-
 const ROOT = join(import.meta.dirname, '..', '..', '..');
 const C8 = 'xmlns:zeebe="http://camunda.org/schema/zeebe/1.0" xmlns:modeler="http://camunda.org/schema/modeler/1.0" modeler:executionPlatform="Camunda Cloud" modeler:executionPlatformVersion="8.9.0"';
 const DI = 'xmlns:bpmndi="http://www.omg.org/spec/BPMN/20100524/DI"';
@@ -99,8 +91,7 @@ const BLANK = '   ';
 
 /** The deploy-severity codes of the Camunda 8 profile, sorted. */
 async function deployCodes(text: string): Promise<string[]> {
-  return runProfile(await Doc.fromXml(text))
-    .findings.filter((finding) => finding.severity === 'deploy')
+  return (await runProfile(await Doc.fromXml(text))).findings.filter((finding) => finding.severity === 'deploy')
     .map((finding) => finding.code)
     .sort();
 }
@@ -122,29 +113,6 @@ function caught(fn: () => unknown): { code?: string; message: string; hint?: str
 /** [expression after the =, Camunda 8.9.22 deploys it as a flow condition] */
 const FEEL_VERDICTS = JSON.parse(readFileSync(join(ROOT, 'test', 'fixtures', 'c8', 'feel-verdicts.json'), 'utf8')) as Array<[string, boolean]>;
 
-describe('FEEL syntax: the check agrees with Camunda 8.9.22', () => {
-  it(`on all ${FEEL_VERDICTS.length} engine-checked expressions`, () => {
-    const wrong = FEEL_VERDICTS.filter(([expression, ok]) => (new FeelExpression(expression).problem() === undefined) !== ok).map(([expression, ok]) => `${ok ? 'flagged' : 'missed'}: ${JSON.stringify(expression)} ${new FeelExpression(expression).problem() ?? ''}`);
-    expect(wrong).toEqual([]);
-    expect(FEEL_VERDICTS.filter(([, ok]) => !ok).length).toBeGreaterThan(250);
-  });
-
-  it('names what the slip means in FEEL', () => {
-    expect(new FeelExpression(' x & y').problem()).toBe('& (FEEL: and)');
-    expect(new FeelExpression(' x | y').problem()).toBe('| (FEEL: or)');
-    expect(new FeelExpression(' x <> 1').problem()).toBe('<> (FEEL: != for "not equal")');
-    expect(new FeelExpression(' x >> 1').problem()).toBe('>> (FEEL has no shift operators)');
-    expect(new FeelExpression(' x % 2 = 0').problem()).toBe('% (FEEL has no modulo operator: modulo(a, b))');
-    expect(new FeelExpression(' if x then true').problem()).toBe('if ... then without else: FEEL needs if c then a else b');
-    expect(new FeelExpression(' for x in xs').problem()).toBe('for ... in ... needs return: for x in xs return x');
-    expect(new FeelExpression(' x AND y').problem()).toBe('AND (FEEL keywords are lower case: and)');
-    expect(new FeelExpression(' x := 1').problem()).toBe(':= (FEEL has no assignment; = compares)');
-    expect(new FeelExpression(' a ? b : c').problem()).toBe('?: (FEEL: if ... then ... else ...)');
-    expect(new FeelExpression(' a && b').problem()).toBe('&& (FEEL: and)');
-    expect(new FeelExpression(' (a').problem()).toBe('an unclosed (');
-    expect(new FeelExpression(' a +').problem()).toBe('an incomplete expression: it ends after +');
-  });
-});
 
 /* ------------------------------------------------------------------ */
 /* models with the engine's verdict                                     */
@@ -180,18 +148,10 @@ const MODELS: Model[] = [
   ...['PT0.5S', 'PT1,5S', 'PT90M'].map((timerValue): Model => ({ name: `duration ${timerValue}`, xml: xml(chain(`<bpmn:intermediateCatchEvent id="X">${TIMER('timeDuration', timerValue)}</bpmn:intermediateCatchEvent>`)), codes: [], engine: 'accept' })),
   ...['2030-12-31t10:00:00z', '2030-12-31T10:00:00z'].map((timerValue): Model => ({ name: `date ${timerValue}`, xml: xml(chain(`<bpmn:intermediateCatchEvent id="X">${TIMER('timeDate', timerValue)}</bpmn:intermediateCatchEvent>`)), codes: [], engine: 'accept' })),
   // ids and IDREFs
-  { name: 'a task id with a colon', xml: xml(chain(ST()).replace(/"X"/g, '"a:b"')), codes: ['W_C8_DEPLOY_SCHEMA'], engine: 'reject' },
-  { name: 'a flow id bpmn-moddle cannot read (F:1)', xml: xml(ordered(ext(TD()) + '<bpmn:incoming>F:1</bpmn:incoming><bpmn:outgoing>F2</bpmn:outgoing>').replace('<bpmn:outgoing>F1</bpmn:outgoing>', '<bpmn:outgoing>F:1</bpmn:outgoing>').replace('id="F1"', 'id="F:1"')), codes: ['W_C8_DEPLOY_SCHEMA'], engine: 'reject' },
-  { name: 'a lane flowNodeRef to a missing id', xml: xml(`    <bpmn:laneSet id="LS"><bpmn:lane id="L1"><bpmn:flowNodeRef>Nope</bpmn:flowNodeRef><bpmn:flowNodeRef>Start</bpmn:flowNodeRef><bpmn:flowNodeRef>X</bpmn:flowNodeRef><bpmn:flowNodeRef>End</bpmn:flowNodeRef></bpmn:lane></bpmn:laneSet>\n${chain(ST())}`), codes: ['W_C8_DEPLOY_SCHEMA'], engine: 'reject' },
   { name: 'a lane flowNodeRef with white space around the id', xml: xml(`    <bpmn:laneSet id="LS"><bpmn:lane id="L1"><bpmn:flowNodeRef> Start </bpmn:flowNodeRef><bpmn:flowNodeRef>X</bpmn:flowNodeRef><bpmn:flowNodeRef>End</bpmn:flowNodeRef></bpmn:lane></bpmn:laneSet>\n${chain(ST())}`), codes: [], engine: 'accept' },
-  { name: 'a task default to a missing flow', xml: xml(chain(ST()).replace('<bpmn:serviceTask id="X">', '<bpmn:serviceTask id="X" default="Nope">')), codes: ['W_C8_DEPLOY_SCHEMA'], engine: 'reject' },
   // the child order of the BPMN schema
   { name: 'order: documentation, extensions, incoming, outgoing', xml: xml(ordered(`<bpmn:documentation>d</bpmn:documentation>${ext(TD())}<bpmn:incoming>F1</bpmn:incoming><bpmn:outgoing>F2</bpmn:outgoing>`)), codes: [], engine: 'accept' },
-  { name: 'order: extensionElements after incoming', xml: xml(ordered(`<bpmn:incoming>F1</bpmn:incoming>${ext(TD())}<bpmn:outgoing>F2</bpmn:outgoing>`)), codes: ['W_C8_DEPLOY_SCHEMA'], engine: 'reject' },
-  { name: 'order: documentation after extensionElements', xml: xml(ordered(`${ext(TD())}<bpmn:documentation>d</bpmn:documentation>`)), codes: ['W_C8_DEPLOY_SCHEMA'], engine: 'reject' },
-  { name: 'order: a laneSet after the flow elements', xml: xml(`${chain(ST())}\n    <bpmn:laneSet id="LS"><bpmn:lane id="L1"><bpmn:flowNodeRef>X</bpmn:flowNodeRef></bpmn:lane></bpmn:laneSet>`), codes: ['W_C8_DEPLOY_SCHEMA'], engine: 'reject' },
   { name: 'order: an annotation after the flow elements, a message after the process', xml: xml(`${chain(ST())}\n    <bpmn:textAnnotation id="TA"><bpmn:text>t</bpmn:text></bpmn:textAnnotation>`, { after: '  <bpmn:message id="M9" name="m9" />\n' }), codes: [], engine: 'accept' },
-  { name: 'order: a message after the diagram', xml: xml(chain(ST()), { after: '  <bpmndi:BPMNDiagram id="D1"><bpmndi:BPMNPlane id="PL" bpmnElement="P_Test" /></bpmndi:BPMNDiagram>\n  <bpmn:message id="M9" name="m9" />\n' }), codes: ['W_C8_DEPLOY_SCHEMA'], engine: 'reject' },
   // white space and empty values
   ...[
     ['job type', ST(ext(TD(BLANK)))],
@@ -221,40 +181,13 @@ describe('deploy rules: the profile flags exactly what Camunda 8.9.22 refuses',
     expect(model.codes.length > 0).toBe(model.engine === 'reject');
   });
 
-  it('timer values', () => {
-    for (const timerValue of ['PT1.5H', 'PT1.5M', 'P1DT1.5H', 'PT1,5H']) {
-      expect(new TimerValue(timerValue).isDuration(), timerValue).toBe(false);
-    }
-    for (const timerValue of ['PT1.5S', 'PT1,5S', 'PT0.5S', 'P1DT1H30M']) {
-      expect(new TimerValue(timerValue).isDuration(), timerValue).toBe(true);
-    }
-    for (const timerValue of ['2030-12-31t10:00:00z', '2030-12-31t10:00:00Z', '2030-12-31T10:00:00z']) {
-      expect(new TimerValue(timerValue).isDateTime(), timerValue).toBe(true);
-    }
-    expect(new TimerValue('R/PT1.5H').isCycle()).toBe(false);
-    expect(new TimerValue('R/2030-12-31t10:00:00z/PT1H').isCycle()).toBe(true);
-  });
-
   it('the messages and fixes name the problem', async () => {
-    const find = async (text: string): Promise<{ message: string; hint?: string }> => runProfile(await Doc.fromXml(text)).findings.find((finding) => finding.severity === 'deploy')!;
+    const find = async (text: string): Promise<{ message: string; hint?: string }> => (await runProfile(await Doc.fromXml(text))).findings.find((finding) => finding.severity === 'deploy')!;
     const adhoc = await find(xml(ADHOC('<bpmn:completionCondition xsi:type="bpmn:tFormalExpression">${done}</bpmn:completionCondition>')));
     expect(adhoc.message).toBe('The completion condition "${done}" of ad-hoc sub-process X is no FEEL expression; Camunda 8 needs one starting with = and refuses the file');
     expect(adhoc.hint).toBe("`bpmn set <file> X 'completion== done'` (check the FEEL syntax), or remove it: `bpmn set <file> X completion=`.");
-    const order = await find(xml(ordered(`<bpmn:incoming>F1</bpmn:incoming>${ext(TD())}<bpmn:outgoing>F2</bpmn:outgoing>`)));
-    expect(order.message).toBe('In serviceTask X, <bpmn:extensionElements> comes after <bpmn:incoming>; the BPMN schema puts extensionElements before incoming, and Camunda 8 validates the file against the schema and refuses it');
-    const colon = await find(xml(chain(ST()).replace(/"X"/g, '"a:b"')));
-    expect(colon.hint).toBe('`bpmn set <file> a:b id=a_b`.');
-    const lane = await find(xml(`    <bpmn:laneSet id="LS"><bpmn:lane id="L1"><bpmn:flowNodeRef>Nope</bpmn:flowNodeRef></bpmn:lane></bpmn:laneSet>\n${chain(ST())}`));
-    expect(lane.message).toBe('Lane L1 has <bpmn:flowNodeRef>Nope</bpmn:flowNodeRef>, but the file has no element with the id Nope; Camunda 8 checks such references against the ids of the file (cvc-id.1) and refuses it');
     const link = await find(xml(LINKS('')));
-    expect(link.message).toBe('The link event definition of intermediateThrowEvent:link X has an empty name; Camunda 8 refuses the file');
-  });
-
-  it('an edit that removes the element with the issue resolves it', async () => {
-    const doc = await Doc.fromXml(xml(`    <bpmn:laneSet id="LS"><bpmn:lane id="L1"><bpmn:flowNodeRef>Nope</bpmn:flowNodeRef><bpmn:flowNodeRef>X</bpmn:flowNodeRef></bpmn:lane></bpmn:laneSet>\n${chain(ST())}`));
-    const mutated = await mutateDoc(doc, [{ op: 'remove', ids: ['LS'] }], { force: true });
-    expect(mutated.delta!.resolved.map((warning) => warning.code)).toContain('W_C8_DEPLOY_SCHEMA');
-    expect(runProfile(await Doc.fromXml(mutated.xml)).findings.filter((finding) => finding.code === 'W_C8_DEPLOY_SCHEMA')).toEqual([]);
+    expect(link.message).toBe('Element of type <bpmn:LinkEventDefinition> must have property <name>');
   });
 });
 
@@ -274,7 +207,7 @@ describe('the message a catching element waits for', () => {
     ]);
     expect(mutated.aliases).toEqual({ $s: 'startEvent_asked', $m: 'event_antwortErhalten', $msg: 'message_antwort' });
     expect(mutated.xml).toMatch(/<bpmn:message id="message_antwort" name="Antwort">\s*<bpmn:extensionElements>\s*<zeebe:subscription correlationKey="= id" \/>/);
-    expect(runProfile(await Doc.fromXml(mutated.xml)).findings).toEqual([]);
+    expect((await runProfile(await Doc.fromXml(mutated.xml))).findings).toEqual([]);
   });
 
   it('refAs on set, retype and connect (a message flow); E_USAGE when the element references none', async () => {
@@ -302,7 +235,7 @@ describe('the message a catching element waits for', () => {
     expect(added.notes).toEqual(['zeebe:subscription goes to message M1, which X waits for: Camunda 8 reads the correlation key in the message\'s zeebe:subscription (C waits for it too and shares it)']);
     const set = runOps(doc, [{ op: 'set', id: 'C', values: { 'zeebe:correlationKey': '=invoiceId' } }]);
     expect(set.notes).toEqual(['zeebe:correlationKey goes to message M1, which C waits for: Camunda 8 reads the correlation key in the message\'s zeebe:subscription (X waits for it too and shares it)']);
-    const findings = runProfile(doc).findings.map((finding) => finding.code);
+    const findings = (await runProfile(doc)).findings.map((finding) => finding.code);
     expect(findings).not.toContain('W_C8_MISPLACED_EXTENSION');
     expect(findings).not.toContain('W_C8_DEPLOY_MESSAGE');
     expect(doc.get('M1')!.get<{ get(key: string): Array<Record<string, unknown>> }>('extensionElements').get('values').map((value) => value['correlationKey'])).toEqual(['=invoiceId']);
diff --git a/test/domain/validation/c8-profile.test.ts b/test/domain/validation/c8-profile.test.ts
index 7223fe4a..b330777b 100644
--- a/test/domain/validation/c8-profile.test.ts
+++ b/test/domain/validation/c8-profile.test.ts
@@ -16,18 +16,15 @@
 import { mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
+import { runProfile, validateWithEngine } from '../../helpers/engine.js';
 import { afterAll, beforeAll, describe, expect, it } from 'vitest';
 import { Doc } from '../../../src/domain/document/Doc.js';
 import { mutateDoc } from '../../../src/index.js';
-import { FeelExpression } from '../../../src/domain/validation/profiles/FeelExpression.js';
-import { TimerValue } from '../../../src/domain/validation/profiles/TimerValue.js';
-import { loadProfiles, runProfile } from '../../../src/index.js';
-import { validateDoc } from '../../../src/index.js';
+import { FeelExpression } from '../../../src/adapters/out/bpmnlint/engine/rules/c8/support/feel/FeelExpression.js';
+import { TimerValue } from '../../../src/adapters/out/bpmnlint/engine/rules/c8/support/TimerValue.js';
 import { ZEEBE as C8_DESCRIPTOR } from '../../../src/domain/document/vendor/ZeebeDescriptor.js';
 import { cli } from '../../helpers/cli.js';
 
-// the engine rules load on demand; runProfile / validateDoc(doc, { platform }) need them loaded (the pipeline loads them itself)
-await loadProfiles();
 
 const ZEEBE = 'xmlns:zeebe="http://camunda.org/schema/zeebe/1.0"';
 const MODELER = 'xmlns:modeler="http://camunda.org/schema/modeler/1.0"';
@@ -298,20 +295,15 @@ const CASES: Case[] = [
   { name: 'two none start events', xml: xml(toEnd('') + '<bpmn:startEvent id="S2" /><bpmn:sequenceFlow id="F9" sourceRef="S2" targetRef="End" />'), codes: ['W_C8_DEPLOY_START_EVENT'], engine: 'reject' },
   { name: 'sub-process without start event, with a timer start, with two starts', xml: xml(chain(SUB('<bpmn:task id="A1" />'), `<bpmn:subProcess id="Y">${`<bpmn:startEvent id="YS">${TIMER('timeCycle', 'R/PT1H')}</bpmn:startEvent><bpmn:sequenceFlow id="YF" sourceRef="YS" targetRef="YE" /><bpmn:endEvent id="YE" />`}</bpmn:subProcess><bpmn:subProcess id="Z">${INNER.replace(/I([SFE])/g, 'Z$1')}<bpmn:startEvent id="ZS2" /><bpmn:sequenceFlow id="ZF2" sourceRef="ZS2" targetRef="ZE" /></bpmn:subProcess>`)), codes: ['W_C8_DEPLOY_START_EVENT', 'W_C8_DEPLOY_START_EVENT', 'W_C8_DEPLOY_START_EVENT'], engine: 'reject' },
   { name: 'event sub-process with a none start event', xml: xml(toEnd('') + evSub('<bpmn:startEvent id="ESP_S" />')), codes: ['W_C8_DEPLOY_EVENT_DEFINITION'], engine: 'reject', structural: 'E_EVENT_SUBPROCESS_PLAIN_START' },
-  { name: 'intermediate catch and boundary events without event definition', xml: xml(boundary('<bpmn:serviceTask id="X">' + ext(TD()) + '</bpmn:serviceTask>', '').replace('<bpmn:sequenceFlow id="F2" sourceRef="X" targetRef="End" />', '<bpmn:sequenceFlow id="F2" sourceRef="X" targetRef="C" /><bpmn:intermediateCatchEvent id="C" /><bpmn:sequenceFlow id="F5" sourceRef="C" targetRef="End" />')), codes: ['W_C8_DEPLOY_EVENT_DEFINITION', 'W_C8_DEPLOY_EVENT_DEFINITION'], engine: 'reject', structural: 'E_INVALID_TRIGGER' },
-  { name: 'an event with two event definitions', xml: xml(chain(`<bpmn:intermediateCatchEvent id="X">${TIMER()}<bpmn:messageEventDefinition id="MD" messageRef="M1" /></bpmn:intermediateCatchEvent>`), { roots: MSG() }), codes: ['W_C8_DEPLOY_EVENT_DEFINITION'], engine: 'reject' },
+  { name: 'intermediate catch and boundary events without event definition', xml: xml(boundary('<bpmn:serviceTask id="X">' + ext(TD()) + '</bpmn:serviceTask>', '').replace('<bpmn:sequenceFlow id="F2" sourceRef="X" targetRef="End" />', '<bpmn:sequenceFlow id="F2" sourceRef="X" targetRef="C" /><bpmn:intermediateCatchEvent id="C" /><bpmn:sequenceFlow id="F5" sourceRef="C" targetRef="End" />')), codes: ['W_C8_DEPLOY_UNSUPPORTED', 'W_C8_DEPLOY_UNSUPPORTED'], engine: 'reject', structural: 'E_INVALID_TRIGGER' },
   { name: 'cancel end event', xml: xml(toEnd('<bpmn:cancelEventDefinition id="CA" />')), codes: ['W_C8_DEPLOY_UNSUPPORTED'], engine: 'reject', structural: 'E_INVALID_TRIGGER' },
   { name: 'transaction', xml: xml(chain(`<bpmn:transaction id="X">${INNER}</bpmn:transaction>`)), codes: ['W_C8_DEPLOY_UNSUPPORTED'], engine: 'reject' },
   { name: 'conditional events (8.9) with definition ids', xml: xml(boundary(ST(), COND('= x &gt; 1', 'CD2')).replace('<bpmn:startEvent id="Start" />', `<bpmn:startEvent id="Start">${COND('= y', 'CD3')}</bpmn:startEvent>`).replace('<bpmn:sequenceFlow id="F2" sourceRef="X" targetRef="End" />', `<bpmn:sequenceFlow id="F2" sourceRef="X" targetRef="C" /><bpmn:intermediateCatchEvent id="C">${COND('= z', 'CD1', ext('<zeebe:conditionalFilter variableNames="z" variableEvents="create, update" />'))}</bpmn:intermediateCatchEvent><bpmn:sequenceFlow id="F5" sourceRef="C" targetRef="End" />`)), codes: [], engine: 'accept' },
-  { name: 'conditional event definition without id', xml: xml(chain(`<bpmn:intermediateCatchEvent id="X">${COND('= x', '')}</bpmn:intermediateCatchEvent>`)), codes: ['W_C8_DEPLOY_EVENT_DEFINITION'], engine: 'reject' },
   { name: 'conditional event with a static condition, an unknown variable event', xml: xml(chain(`<bpmn:intermediateCatchEvent id="X">${COND('true', 'CD1', ext('<zeebe:conditionalFilter variableEvents="foo" />'))}</bpmn:intermediateCatchEvent>`)), codes: ['W_C8_DEPLOY_EXPRESSION', 'W_C8_DEPLOY_EXTENSION'], engine: 'reject' },
   { name: 'conditional event definition without condition (schema)', xml: xml(chain('<bpmn:intermediateCatchEvent id="X"><bpmn:conditionalEventDefinition id="CD1" /></bpmn:intermediateCatchEvent>'), { executable: true }), codes: ['W_C8_DEPLOY_EVENT_DEFINITION'], engine: 'reject' },
   { name: 'compensation with definition ids', xml: xml(COMPENSATION()), codes: [], engine: 'accept' },
-  { name: 'compensation definitions without id', xml: xml(COMPENSATION('<bpmn:compensateEventDefinition />', '<bpmn:compensateEventDefinition />')), codes: ['W_C8_DEPLOY_EVENT_DEFINITION', 'W_C8_DEPLOY_EVENT_DEFINITION'], engine: 'reject' },
   { name: 'compensation boundary event without handler', xml: xml(COMPENSATION(undefined, undefined, false)), codes: ['W_C8_DEPLOY_EVENT_DEFINITION'], engine: 'reject' },
-  { name: 'boundary event on a compensation handler', xml: xml(COMPENSATION().replace('    <bpmn:association', `    <bpmn:boundaryEvent id="B2" attachedToRef="H">${TIMER()}</bpmn:boundaryEvent>\n    <bpmn:association`)), codes: ['W_C8_DEPLOY_BOUNDARY_HOST'], engine: 'reject', structural: 'E_INVALID_HOST' },
   { name: 'link pair', xml: xml(LINKS('<bpmn:linkEventDefinition id="L1" name="L" />', ['<bpmn:linkEventDefinition id="L2" name="L" />'])), codes: [], engine: 'accept' },
-  { name: 'link catch definition without id', xml: xml(LINKS('<bpmn:linkEventDefinition name="L" />', ['<bpmn:linkEventDefinition name="L" />'])), codes: ['W_C8_DEPLOY_EVENT_DEFINITION'], engine: 'reject' },
   { name: 'link throw without catch, two catches of one name', xml: xml(LINKS('<bpmn:linkEventDefinition id="L1" name="A" />', ['<bpmn:linkEventDefinition id="L2" name="B" />', '<bpmn:linkEventDefinition id="L3" name="B" />'])), codes: ['W_C8_DEPLOY_LINK', 'W_C8_DEPLOY_LINK'], engine: 'reject' },
   { name: 'link definition without name (schema)', xml: xml(LINKS('<bpmn:linkEventDefinition id="L1" />', ['<bpmn:linkEventDefinition id="L2" name="L" />'])), codes: ['W_C8_DEPLOY_LINK'], engine: 'reject' },
   { name: 'ad-hoc sub-process', xml: xml(chain(`<bpmn:adHocSubProcess id="X">${ext('<zeebe:adHoc activeElementsCollection="=[&quot;A1&quot;]" />')}<bpmn:task id="A1" /><bpmn:serviceTask id="A2">${ext(TD())}</bpmn:serviceTask></bpmn:adHocSubProcess>`)), codes: [], engine: 'accept' },
@@ -322,7 +314,6 @@ const CASES: Case[] = [
   { name: 'zeebe content on hosts that do not read it', xml: xml(chain(UT(ext('<zeebe:userTask />' + TD())), `<bpmn:serviceTask id="Y">${ext(TD() + '<zeebe:userTask /><zeebe:calledDecision decisionId="d" resultVariable="r" />')}</bpmn:serviceTask>`)), codes: ['W_C8_MISPLACED_EXTENSION', 'W_C8_MISPLACED_EXTENSION', 'W_C8_MISPLACED_EXTENSION'], engine: 'accept' },
   { name: 'a loose zeebe:input outside zeebe:ioMapping', xml: xml(chain(ST(ext(TD() + '<zeebe:input source="=a" target="b" />')))), codes: ['W_C8_MISPLACED_EXTENSION'], engine: 'accept' },
   { name: 'modeler template attributes', xml: xml(chain(ST(ext(TD()), ' zeebe:modelerTemplate="t" zeebe:modelerTemplateVersion="1"'))), codes: [], engine: 'accept' },
-  { name: 'extension elements on bpmn:definitions (schema)', xml: xml(chain(ST())).replace('targetNamespace="http://bpmn.io/schema/bpmn">', `targetNamespace="http://bpmn.io/schema/bpmn">${ext('<zeebe:properties><zeebe:property name="a" value="b" /></zeebe:properties>')}`), codes: ['W_C8_DEPLOY_SCHEMA'], engine: 'reject' },
 ];
 
 const sorted = (codes: string[]): string[] => [...codes].sort();
@@ -330,7 +321,7 @@ const sorted = (codes: string[]): string[] => [...codes].sort();
 describe('Camunda 8 profile: one model per rule', () => {
   it.each(CASES.map((testCase) => [testCase.name, testCase] as const))('%s', async (_name, testCase) => {
     const doc = await Doc.fromXml(testCase.xml);
-    const report = runProfile(doc);
+    const report = (await runProfile(doc));
     expect(report.platform).toBe('c8');
     expect(sorted(report.findings.map((finding) => finding.code))).toEqual(sorted(testCase.codes));
     for (const finding of report.findings) {
@@ -338,43 +329,43 @@ describe('Camunda 8 profile: one model per rule', () => {
       expect(finding.hint, finding.code).toBeTruthy();
     }
     const deploy = report.findings.some((finding) => finding.severity === 'deploy');
-    const structural = testCase.structural ? validateDoc(doc).errors.map((error) => error.code) : [];
+    const structural = testCase.structural ? (await validateWithEngine(doc)).errors.map((error) => error.code) : [];
     if (testCase.structural) expect(structural).toContain(testCase.structural);
     // a deploy finding (or the structural error that stands for it) exactly where the engine refuses
     expect(deploy || structural.some((structuralCode) => structuralCode !== 'E_MULTIPLE_ROOTS')).toBe(testCase.engine === 'reject');
   });
 
   it('names the fix: commands with the element, the file prefix and the nested slot', async () => {
-    const st = runProfile(await Doc.fromXml(xml(chain('<bpmn:serviceTask id="X" />')))).findings[0]!;
+    const st = (await runProfile(await Doc.fromXml(xml(chain('<bpmn:serviceTask id="X" />'))))).findings[0]!;
     expect(st.hint).toBe('Give it a job type: `bpmn ext add <file> X zeebe:taskDefinition type=<jobType>`.');
-    const mi = runProfile(await Doc.fromXml(xml(chain(ST(ext(TD()) + MI(undefined)))))).findings[0]!;
+    const mi = (await runProfile(await Doc.fromXml(xml(chain(ST(ext(TD()) + MI(undefined))))))).findings[0]!;
     expect(mi.hint).toContain('`bpmn ext add <file> X loop.zeebe:loopCharacteristics inputCollection==<items> inputElement=<item>`');
-    const key = runProfile(await Doc.fromXml(xml(chain('<bpmn:receiveTask id="X" messageRef="M1" />'), { roots: MSG('M1', 'M1', 'orderId') }))).findings[0]!;
+    const key = (await runProfile(await Doc.fromXml(xml(chain('<bpmn:receiveTask id="X" messageRef="M1" />'), { roots: MSG('M1', 'M1', 'orderId') })))).findings[0]!;
     expect(key).toMatchObject({ code: 'W_C8_DEPLOY_EXPRESSION', element: 'X', related: ['M1'] });
     expect(key.hint).toBe('`bpmn ext add <file> M1 zeebe:subscription correlationKey==orderId --replace`.');
-    const cond = runProfile(await Doc.fromXml(xml(gateway(['${amount &gt; 100 &amp;&amp; ok}', null], 'S1')))).findings[0]!;
+    const cond = (await runProfile(await Doc.fromXml(xml(gateway(['${amount &gt; 100 &amp;&amp; ok}', null], 'S1'))))).findings[0]!;
     expect(cond.hint).toContain("`bpmn set <file> S0 'condition== amount > 100 and ok'`");
     // a hand-written attribute of a zeebe element on the BPMN element: the element that reads it
-    const attr = runProfile(await Doc.fromXml(xml(chain(UT(ext('<zeebe:userTask />'), ' zeebe:assignee="demo"'))))).findings[0]!;
+    const attr = (await runProfile(await Doc.fromXml(xml(chain(UT(ext('<zeebe:userTask />'), ' zeebe:assignee="demo"')))))).findings[0]!;
     expect(attr).toMatchObject({ code: 'W_C8_UNKNOWN_ATTRIBUTE', severity: 'runtime', element: 'X' });
     expect(attr.message).toBe('userTask X has the unknown attribute zeebe:assignee; Camunda 8 ignores it (it reads assignee on the zeebe:assignmentDefinition extension element)');
     expect(attr.hint).toBe('Move it: `bpmn set <file> X zeebe:assignee=`, then `bpmn ext add <file> X zeebe:assignmentDefinition assignee=demo`.');
     // another prefix for the zeebe namespace
-    const zeebeFinding = runProfile(await Doc.fromXml(xml(chain('<bpmn:serviceTask id="X" />'), { ns: 'xmlns:z="http://camunda.org/schema/zeebe/1.0"' }))).findings[0]!;
+    const zeebeFinding = (await runProfile(await Doc.fromXml(xml(chain('<bpmn:serviceTask id="X" />'), { ns: 'xmlns:z="http://camunda.org/schema/zeebe/1.0"' })))).findings[0]!;
     expect(zeebeFinding.hint).toBe('Give it a job type: `bpmn ext add <file> X z:taskDefinition type=<jobType>`.');
   });
 
   it('runs on Camunda 8 files only; --platform c8 forces it', async () => {
     const plain = await Doc.fromXml(xml(chain('<bpmn:serviceTask id="X" />'), { ns: '' }));
-    expect(runProfile(plain).findings).toEqual([]);
-    expect(runProfile(plain, 'c8').findings.map((finding) => finding.code)).toEqual(['W_C8_DEPLOY_IMPLEMENTATION']);
+    expect((await runProfile(plain)).findings).toEqual([]);
+    expect((await runProfile(plain, 'c8')).findings.map((finding) => finding.code)).toEqual(['W_C8_DEPLOY_IMPLEMENTATION']);
     const c7 = await Doc.fromXml(xml(chain('<bpmn:serviceTask id="X" />'), { ns: `${CAMUNDA} ${MODELER} modeler:executionPlatform="Camunda Platform"` }));
-    expect(runProfile(c7).findings.some((finding) => finding.code.startsWith('W_C8_'))).toBe(false);
+    expect((await runProfile(c7)).findings.some((finding) => finding.code.startsWith('W_C8_'))).toBe(false);
   });
 });
 
 describe('the zeebe descriptor, read as data', () => {
-  it('knows where zeebe elements belong and what they hold', () => {
+  it('knows where zeebe elements belong and what they hold', async () => {
     expect(C8_DESCRIPTOR.allowedOn('zeebe:taskDefinition', 'bpmn:ServiceTask')).toBe(true);
     expect(C8_DESCRIPTOR.allowedOn('zeebe:taskDefinition', 'bpmn:EndEvent')).toBe(true);
     expect(C8_DESCRIPTOR.allowedOn('zeebe:taskDefinition', 'bpmn:UserTask')).toBe(false);
@@ -396,7 +387,7 @@ describe('the zeebe descriptor, read as data', () => {
 });
 
 describe('values Camunda 8 parses at deploy (engine-checked on 60 timer values and 45 expressions)', () => {
-  it('durations', () => {
+  it('durations', async () => {
     for (const duration of ['PT1H', 'P1D', 'P1DT2H', 'PT1.5S', '-PT1S', 'P1W', 'p1d', 'PT1H30M', 'P0D', 'PT0S', 'P1Y2M', 'P1Y2M3DT4H', 'PT1H ', 'PT1M30.5S', 'P2W3D']) {
       expect(new TimerValue(duration).isDuration(), duration).toBe(true);
     }
@@ -404,7 +395,7 @@ describe('values Camunda 8 parses at deploy (engine-checked on 60 timer values a
       expect(new TimerValue(duration).isDuration(), duration).toBe(false);
     }
   });
-  it('dates', () => {
+  it('dates', async () => {
     for (const date of ['2030-12-31T10:00Z', '2030-12-31T10:00:00Z', '2030-12-31T10:00:00.123Z', '2030-12-31T10:00:00+01:00', '2030-12-31T10:00:00+01:00[Europe/Berlin]', '2030-12-31T10:00:00z']) {
       expect(new TimerValue(date).isDateTime(), date).toBe(true);
     }
@@ -412,7 +403,7 @@ describe('values Camunda 8 parses at deploy (engine-checked on 60 timer values a
       expect(new TimerValue(date).isDateTime(), date).toBe(false);
     }
   });
-  it('cycles', () => {
+  it('cycles', async () => {
     for (const cycle of ['R/PT1H', 'R5/PT1H', 'R0/PT1H', 'R-1/PT1H', 'R/2030-01-01T00:00:00Z/P1D', '0 0 12 * * ?', '0 0 12 ? * MON', '0 0 9-17 * * MON-FRI', '0 0/5 * * * *', '@hourly', '@weekly', '@midnight', '@yearly', '@annually', '@monthly', '@daily', 'R/P1D']) {
       expect(new TimerValue(cycle).isCycle(), cycle).toBe(true);
     }
@@ -420,7 +411,7 @@ describe('values Camunda 8 parses at deploy (engine-checked on 60 timer values a
       expect(new TimerValue(cycle).isCycle(), cycle).toBe(false);
     }
   });
-  it('FEEL slips', () => {
+  it('FEEL slips', async () => {
     const ok = ['a != b', 'not(a)', 'a = 1', '"a && b" = s', '-a', 'a - 1', 'a > 1 and b < 2', 'a in [1,2]', 'if a then b else c', 'some x in xs satisfies x > 1', 'a.b.c', 'x[1]', 'count(xs) > 0', 'date("2020-01-01") < today()', 'a instance of number', 'a between 1 and 3', 'a = null', 'a / 2', 'a ** 2', '`a b` > 1', '//comment\n a', 'a /* c */ > 1', '{"k": 1}.k = 1', '@"2020-01-01"', 'function(x) x', 'for x in xs return x'];
     for (const expression of ok) {
       expect(new FeelExpression(expression).problem(), expression).toBeUndefined();
@@ -436,7 +427,7 @@ describe('Camunda 8 files the CLI writes', () => {
   it('new --target camunda8 writes the platform and its version, like Camunda Modeler; its only finding is the missing start event', async () => {
     const doc = Doc.create({ target: 'camunda8', processName: 'Order' });
     expect(doc.definitions.$attrs).toMatchObject({ 'modeler:executionPlatform': 'Camunda Cloud', 'modeler:executionPlatformVersion': '8.9.0' });
-    expect(runProfile(doc).findings.map((finding) => finding.code)).toEqual(['W_C8_DEPLOY_START_EVENT']);
+    expect((await runProfile(doc)).findings.map((finding) => finding.code)).toEqual(['W_C8_DEPLOY_START_EVENT']);
   });
 
   it('a new or retyped user task is a Camunda user task (zeebe:userTask); a plain or Camunda 7 file gets none', async () => {
@@ -481,17 +472,17 @@ describe('Camunda 8 files the CLI writes', () => {
 
 describe('bpmn validate on a Camunda 8 file', () => {
   let dir: string;
-  beforeAll(() => {
+  beforeAll(async () => {
     dir = mkdtempSync(join(tmpdir(), 'bpmn-c8-'));
   });
   afterAll(() => rmSync(dir, { recursive: true, force: true }));
 
-  it('counts the findings by severity in the platform line; --strict exits 5; --json carries the severity', () => {
+  it('counts the findings by severity in the platform line; --strict exits 5; --json carries the severity', async () => {
     const file = join(dir, 'job.bpmn');
     writeFileSync(file, xml(chain('<bpmn:serviceTask id="X" />', '<bpmn:userTask id="U" />')));
     const text = cli('validate', file, '--strict');
     expect(text.code).toBe(5);
-    expect(text.out).toMatch(/^W_C8_DEPLOY_IMPLEMENTATION X: serviceTask X has no zeebe:taskDefinition/m);
+    expect(text.out).toMatch(/^W_C8_DEPLOY_IMPLEMENTATION X: Element of type <bpmn:ServiceTask> must have one extension element of type <zeebe:TaskDefinition>/m);
     expect(text.out).toMatch(/^platform: c8 \(modeler:executionPlatform "Camunda Cloud"\) - 1 refused at deploy, 0 runtime, 1 practice finding\(s\)$/m);
     const json = JSON.parse(cli('validate', file, '--json').out);
     expect(json.platform).toMatchObject({ platform: 'c8', counts: { deploy: 1, runtime: 0, practice: 1 } });
@@ -592,7 +583,7 @@ async function withProcess(name: string, model: string, fn: (pid: string) => Pro
 describe.skipIf(!ENGINE)('live engine: the Camunda 8 features and the runtime rules, by running the processes', () => {
   it('a job worker gets its type, input mapping and header (one without key is dropped); the output mapping writes back', async () => {
     const model = xml(chain(ST(ext('<zeebe:taskDefinition type="{pid}-check" retries="2" /><zeebe:ioMapping><zeebe:input source="=amount * 2" target="doubled" /><zeebe:output source="=result" target="checked" /></zeebe:ioMapping><zeebe:taskHeaders><zeebe:header key="channel" value="mail" /><zeebe:header value="dropped" /></zeebe:taskHeaders>'))));
-    expect(runProfile(await Doc.fromXml(model)).findings.map((finding) => finding.code)).toEqual(['W_C8_BAD_VALUE']);
+    expect((await runProfile(await Doc.fromXml(model))).findings.map((finding) => finding.code)).toEqual(['W_C8_BAD_VALUE']);
     await withProcess('job', model, async (pid) => {
       const key = await startInstance(pid, { amount: 21 });
       const [job] = await jobs(`${pid}-check`);
@@ -610,7 +601,7 @@ describe.skipIf(!ENGINE)('live engine: the Camunda 8 features and the runtime ru
     <bpmn:sequenceFlow id="Big" sourceRef="G" targetRef="EndBig"><bpmn:conditionExpression xsi:type="bpmn:tFormalExpression">= amount &gt; 100</bpmn:conditionExpression></bpmn:sequenceFlow>
     <bpmn:sequenceFlow id="Other" sourceRef="G" targetRef="EndOther" />
     <bpmn:endEvent id="EndBig" /><bpmn:endEvent id="EndOther" />`, { roots: `  <bpmn:message id="M1" name="{pid}-paid">${ext('<zeebe:subscription correlationKey="=orderId" />')}</bpmn:message>\n` });
-    expect(runProfile(await Doc.fromXml(model)).findings.map((finding) => [finding.code, finding.related?.[0]])).toEqual([['W_C8_EXCLUSIVE_GATEWAY', 'Other']]);
+    expect((await runProfile(await Doc.fromXml(model))).findings.map((finding) => [finding.code, finding.related?.[0]])).toEqual([['W_C8_EXCLUSIVE_GATEWAY', 'Other']]);
     await withProcess('route', model, async (pid) => {
       const big = await startInstance(pid, { orderId: 'o-1', amount: 500 });
       const small = await startInstance(pid, { orderId: 'o-2', amount: 5 });
@@ -647,7 +638,7 @@ describe.skipIf(!ENGINE)('live engine: the Camunda 8 features and the runtime ru
     <bpmn:sequenceFlow id="F2" sourceRef="X" targetRef="C" />
     <bpmn:callActivity id="C">${ext('<zeebe:calledElement processId="{pid}_child" propagateAllChildVariables="false" /><zeebe:ioMapping><zeebe:output source="=childResult" target="fromChild" /></zeebe:ioMapping>')}</bpmn:callActivity>
     <bpmn:sequenceFlow id="F3" sourceRef="C" targetRef="End" /><bpmn:endEvent id="End" />`);
-    expect(runProfile(await Doc.fromXml(model)).findings).toEqual([]);
+    expect((await runProfile(await Doc.fromXml(model))).findings).toEqual([]);
     await withProcess(
       'decision',
       model,
@@ -667,7 +658,7 @@ describe.skipIf(!ENGINE)('live engine: the Camunda 8 features and the runtime ru
 
   it('a Camunda user task is assigned and completed through the v2 user task API; a job worker user task is not listed there', async () => {
     const model = xml(chain(UT(ext('<zeebe:userTask /><zeebe:formDefinition externalReference="https://example.com/form" /><zeebe:assignmentDefinition assignee="=reviewer" candidateGroups="sales, finance" /><zeebe:priorityDefinition priority="80" />')), '<bpmn:userTask id="J" /><bpmn:sequenceFlow id="FJ" sourceRef="Start" targetRef="J" /><bpmn:sequenceFlow id="FJ2" sourceRef="J" targetRef="End" />'));
-    expect(runProfile(await Doc.fromXml(model)).findings.map((finding) => [finding.code, finding.element])).toEqual([['W_C8_JOB_WORKER_USER_TASK', 'J']]);
+    expect((await runProfile(await Doc.fromXml(model))).findings.map((finding) => [finding.code, finding.element])).toEqual([['W_C8_JOB_WORKER_USER_TASK', 'J']]);
     await withProcess('usertask', model, async (pid) => {
       const key = await startInstance(pid, { reviewer: 'demo' });
       const tasks = await userTasksOf(key);
@@ -684,7 +675,7 @@ describe.skipIf(!ENGINE)('live engine: the Camunda 8 features and the runtime ru
 
   it('a multi-instance activity runs per item and collects the results; a standard loop runs once', async () => {
     const model = xml(chain(ST(ext('<zeebe:taskDefinition type="{pid}-item" />') + MI(ZLOOP('inputCollection="=items" inputElement="item" outputCollection="results" outputElement="=done"'))), `<bpmn:serviceTask id="L">${ext('<zeebe:taskDefinition type="{pid}-loop" />')}<bpmn:standardLoopCharacteristics><bpmn:loopCondition xsi:type="bpmn:tFormalExpression">= true</bpmn:loopCondition></bpmn:standardLoopCharacteristics></bpmn:serviceTask><bpmn:sequenceFlow id="FL" sourceRef="Start" targetRef="L" /><bpmn:sequenceFlow id="FL2" sourceRef="L" targetRef="End" />`));
-    expect(runProfile(await Doc.fromXml(model)).findings.map((finding) => [finding.code, finding.element])).toEqual([['W_C8_STANDARD_LOOP', 'L']]);
+    expect((await runProfile(await Doc.fromXml(model))).findings.map((finding) => [finding.code, finding.element])).toEqual([['W_C8_STANDARD_LOOP', 'L']]);
     await withProcess('mi', model, async (pid) => {
       const key = await startInstance(pid, { items: [1, 2, 3] });
       const items = await until(() => jobs(`${pid}-item`), (activated) => activated.length >= 3);
@@ -714,7 +705,7 @@ describe.skipIf(!ENGINE)('live engine: the Camunda 8 features and the runtime ru
     <bpmn:serviceTask id="R">${ext('<zeebe:taskDefinition type="{pid}-r" retries="abc" />')}</bpmn:serviceTask>
     <bpmn:sequenceFlow id="F4" sourceRef="R" targetRef="EndB" />
     <bpmn:endEvent id="EndA" /><bpmn:endEvent id="EndB" />`, { ns: `${C8} ${CAMUNDA}` });
-    expect(sorted(runProfile(await Doc.fromXml(model)).findings.map((finding) => `${finding.code} ${finding.element}`))).toEqual(sorted(['W_C8_MISPLACED_EXTENSION Start', 'W_C8_CONDITION_IGNORED A', 'W_C8_FOREIGN_CONTENT U', 'W_C8_EXPRESSION X', 'W_C8_BAD_VALUE R']));
+    expect(sorted((await runProfile(await Doc.fromXml(model))).findings.map((finding) => `${finding.code} ${finding.element}`))).toEqual(sorted(['W_C8_MISPLACED_EXTENSION Start', 'W_C8_CONDITION_IGNORED A', 'W_C8_FOREIGN_CONTENT U', 'W_C8_EXPRESSION X', 'W_C8_BAD_VALUE R']));
     await withProcess('ignored', model, async (pid) => {
       const key = await startInstance(pid, { items: [1] });
       // the condition out of the task is ignored: both branches run; camunda:assignee is ignored; the input mapping too
@@ -738,7 +729,7 @@ describe.skipIf(!ENGINE)('live engine: the Camunda 8 features and the runtime ru
 
   it('zeebe:publishMessage on a send task deploys, but the instance gets an incident', async () => {
     const model = xml(chain(`<bpmn:sendTask id="X" messageRef="M1">${ext('<zeebe:publishMessage correlationKey="=orderId" />')}</bpmn:sendTask>`), { roots: MSG() });
-    expect(runProfile(await Doc.fromXml(model)).findings.map((finding) => finding.code)).toEqual(['W_C8_UNSUPPORTED_IMPLEMENTATION']);
+    expect((await runProfile(await Doc.fromXml(model))).findings.map((finding) => finding.code)).toEqual(['W_C8_UNSUPPORTED_IMPLEMENTATION']);
     await withProcess('publish', model, async (pid) => {
       const key = await startInstance(pid, { orderId: 'o' });
       expect((await incidentsOf(key)).map((incident) => String(incident['errorMessage']))[0]).toMatch(/only job worker-based implementation is supported for 'sendTask'/);
diff --git a/test/domain/validation/c8-values.test.ts b/test/domain/validation/c8-values.test.ts
index 484a2705..8316a3d1 100644
--- a/test/domain/validation/c8-values.test.ts
+++ b/test/domain/validation/c8-values.test.ts
@@ -4,9 +4,7 @@
  *
  *  - A timer date that is no real instant (2030-02-30, 25:00, an offset over
  *    18 hours), a cron field out of its range (hour 25, month 13, a step of
- *    0, a reversed range, `?` outside the day fields) and an attribute the
- *    BPMN schema types xsd:boolean with another value (cancelActivity=
- *    "maybe", isExpanded="TRUE") are W_C8_DEPLOY_TIMER / W_C8_DEPLOY_SCHEMA;
+ *    0, a reversed range, `?` outside the day fields) are W_C8_DEPLOY_TIMER;
  *    the Quartz day forms (L, W, #), names, 0 / 7 for Sunday, a leap day,
  *    white space around a boolean and 1 / 0 pass.
  *  - A duplicate element id (bpmn-moddle keeps the first element and drops
@@ -15,14 +13,12 @@
  * With BPMN_C8_ENGINE=<REST v2 root> each model is deployed (the accepted
  * ones in one file each and deleted again).
  */
+import { runProfile, validateWithEngine } from '../../helpers/engine.js';
 import { describe, expect, it } from 'vitest';
 import { validateXml } from '../../../src/api.js';
 import { Doc } from '../../../src/domain/document/Doc.js';
-import { TimerValue } from '../../../src/domain/validation/profiles/TimerValue.js';
-import { loadProfiles, runProfile } from '../../../src/index.js';
+import { TimerValue } from '../../../src/adapters/out/bpmnlint/engine/rules/c8/support/TimerValue.js';
 
-// the engine rules load on demand; runProfile / validateDoc(doc, { platform }) need them loaded (the pipeline loads them itself)
-await loadProfiles();
 
 const C8 = 'xmlns:zeebe="http://camunda.org/schema/zeebe/1.0" xmlns:modeler="http://camunda.org/schema/modeler/1.0" modeler:executionPlatform="Camunda Cloud" modeler:executionPlatformVersion="8.9.0"';
 const DI = 'xmlns:bpmndi="http://www.omg.org/spec/BPMN/20100524/DI" xmlns:dc="http://www.omg.org/spec/DD/20100524/DC"';
@@ -70,15 +66,6 @@ const expanded = (value: string): string =>
     <bpmn:endEvent id="End" />`,
     `  <bpmndi:BPMNDiagram id="D1"><bpmndi:BPMNPlane id="PL1" bpmnElement="P_Test"><bpmndi:BPMNShape id="X_di" bpmnElement="X" isExpanded="${value}"><dc:Bounds x="100" y="100" width="100" height="80" /></bpmndi:BPMNShape></bpmndi:BPMNPlane></bpmndi:BPMNDiagram>\n`,
   );
-/** an event sub-process with a message start, isInterrupting as given */
-const eventSub = (value: string): string => `    <bpmn:startEvent id="Start" />
-    <bpmn:sequenceFlow id="F1" sourceRef="Start" targetRef="End" />
-    <bpmn:endEvent id="End" />
-    <bpmn:subProcess id="ES" triggeredByEvent="true">
-      <bpmn:startEvent id="ESS" isInterrupting="${value}">${TIMER('timeDuration', 'PT1H')}</bpmn:startEvent>
-      <bpmn:sequenceFlow id="EF" sourceRef="ESS" targetRef="ESE" />
-      <bpmn:endEvent id="ESE" />
-    </bpmn:subProcess>`;
 /** a Camunda user task X with a static due date */
 const dueDate = (value: string): string => `    <bpmn:startEvent id="Start" />
     <bpmn:sequenceFlow id="F1" sourceRef="Start" targetRef="X" />
@@ -121,12 +108,8 @@ const MODELS: Model[] = [
     codes: [],
   },
   // xsd:boolean
-  { name: 'cancelActivity="maybe"', xml: xml(boundary('maybe')), engine: 'reject', codes: ['W_C8_DEPLOY_SCHEMA'] },
-  { name: 'cancelActivity="TRUE"', xml: xml(boundary('TRUE')), engine: 'reject', codes: ['W_C8_DEPLOY_SCHEMA'] },
   { name: 'cancelActivity=" true "', xml: xml(boundary(' true ')), engine: 'accept', codes: [] },
   { name: 'cancelActivity="1"', xml: xml(boundary('1')), engine: 'accept', codes: [] },
-  { name: 'isInterrupting="yes"', xml: xml(eventSub('yes')), engine: 'reject', codes: ['W_C8_DEPLOY_SCHEMA'] },
-  { name: 'isExpanded="maybe" on a shape', xml: expanded('maybe'), engine: 'reject', codes: ['W_C8_DEPLOY_SCHEMA'] },
   { name: 'isExpanded="0" on a shape', xml: expanded('0'), engine: 'accept', codes: [] },
   // a due date that is no real instant
   { name: 'dueDate 2030-02-30', xml: xml(dueDate('2030-02-30T10:00:00Z')), engine: 'reject', codes: ['W_C8_DEPLOY_USER_TASK'] },
@@ -136,7 +119,7 @@ const MODELS: Model[] = [
 async function deployCodes(text: string): Promise<string[]> {
   return [
     ...new Set(
-      runProfile(await Doc.fromXml(text))
+      (await runProfile(await Doc.fromXml(text)))
         .findings.filter((finding) => finding.severity === 'deploy')
         .map((finding) => finding.code),
     ),
@@ -148,7 +131,7 @@ describe('timer values and xsd:booleans Camunda 8 refuses', () => {
     expect(await deployCodes(model.xml)).toEqual(model.codes);
   });
 
-  it('says what is out of range', () => {
+  it('says what is out of range', async () => {
     expect(new TimerValue('2030-02-30T10:00:00Z').dateTimeRangeProblem()).toBe('February 2030 has no day 30');
     expect(new TimerValue('2030-12-31T25:00:00Z').dateTimeRangeProblem()).toBe('hour 25 is not in 00-23');
     expect(new TimerValue('2032-02-29T10:00:00Z').dateTimeRangeProblem()).toBeUndefined();
@@ -160,10 +143,6 @@ describe('timer values and xsd:booleans Camunda 8 refuses', () => {
   });
 
   it('validate names the value and the reason', async () => {
-    const result = await validateXml(xml(boundary('maybe')));
-    const finding = result.warnings.find((warning) => warning.code === 'W_C8_DEPLOY_SCHEMA')!;
-    expect(finding.element).toBe('B');
-    expect(finding.message).toContain('cancelActivity="maybe"');
     const invalidDate = await validateXml(xml(dateCatch('2030-02-30T10:00:00Z')));
     expect(invalidDate.warnings.find((warning) => warning.code === 'W_C8_DEPLOY_TIMER')!.message).toContain('February 2030 has no day 30');
   });
diff --git a/test/e2e/camunda7-rules.test.ts b/test/e2e/camunda7-rules.test.ts
index 3b8378e4..e9c3164c 100644
--- a/test/e2e/camunda7-rules.test.ts
+++ b/test/e2e/camunda7-rules.test.ts
@@ -40,12 +40,10 @@ import { listAllExtensions } from '../../src/index.js';
 import { runOps } from '../../src/index.js';
 import type { EditCommand } from '../../src/domain/commands/types.js';
 import { mutateDoc } from '../../src/index.js';
-import { loadProfiles, runProfile } from '../../src/index.js';
-import { validateDoc } from '../../src/index.js';
+import { runProfile } from '../helpers/engine.js';
+import { checkDoc } from '../../src/index.js';
 import { cli } from '../helpers/cli.js';
 
-// the engine rules load on demand; runProfile / validateDoc(doc, { platform }) need them loaded (the pipeline loads them itself)
-await loadProfiles();
 
 const BPMN = 'xmlns:bpmn="http://www.omg.org/spec/BPMN/20100524/MODEL" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"';
 const CAMUNDA = 'xmlns:camunda="http://camunda.org/schema/1.0/bpmn"';
@@ -98,48 +96,37 @@ interface Case {
   engine: 'reject' | 'accept';
 }
 
-const MULTIPLE = 'W_C7_MULTIPLE_EVENT_DEFINITIONS';
-
 const CASES: Case[] = [
   // the engines act on the timer (intermediate catch, process start, boundary), on the message (event sub-process start)
-  { name: 'message + timer catch event', xml: xml(chain([catchEvent('W', MSG + TIMER)]), { roots: ROOTS }), codes: [MULTIPLE], engine: 'accept' },
-  { name: 'timer + a message without messageRef: the ignored message is not parsed', xml: xml(chain([catchEvent('W', TIMER + MSG_NOREF)]), { roots: ROOTS }), codes: [MULTIPLE], engine: 'accept' },
-  { name: 'message + an empty timer: the acting timer is parsed', xml: xml(chain([catchEvent('W', MSG + EMPTY_TIMER)]), { roots: ROOTS }), codes: [MULTIPLE, 'W_C7_DEPLOY_EVENT_DEFINITION'], engine: 'reject' },
-  { name: 'event sub-process start: the message acts, an empty timer is ignored', xml: xml(chain([['U', '<bpmn:userTask id="U" />']], eventSub(MSG + EMPTY_TIMER)), { roots: ROOTS }), codes: [MULTIPLE], engine: 'accept' },
-  { name: 'event sub-process start: a message without messageRef acts', xml: xml(chain([['U', '<bpmn:userTask id="U" />']], eventSub(TIMER + MSG_NOREF)), { roots: ROOTS }), codes: [MULTIPLE, 'W_C7_DEPLOY_MESSAGE'], engine: 'reject' },
-  { name: 'a message + timer start event is a second timer start event', xml: xml(chain([['U', '<bpmn:userTask id="U" />']], `<bpmn:startEvent id="S2">${MSG}${TIMER}</bpmn:startEvent><bpmn:sequenceFlow id="FS2" sourceRef="S2" targetRef="U" />`), { roots: ROOTS }), codes: [MULTIPLE, 'W_C7_DEPLOY_START_EVENT'], engine: 'reject' },
-  { name: 'boundary event: signal + message, the signal acts', xml: xml(chain([['U', '<bpmn:userTask id="U" />']], `<bpmn:boundaryEvent id="B" attachedToRef="U"><bpmn:messageEventDefinition messageRef="M" /><bpmn:signalEventDefinition signalRef="Sig" /></bpmn:boundaryEvent><bpmn:sequenceFlow id="FB" sourceRef="B" targetRef="EB" /><bpmn:endEvent id="EB" />`), { roots: ROOTS }), codes: [MULTIPLE], engine: 'accept' },
+  { name: 'message + timer catch event', xml: xml(chain([catchEvent('W', MSG + TIMER)]), { roots: ROOTS }), codes: [], engine: 'accept' },
+  { name: 'timer + a message without messageRef: the ignored message is not parsed', xml: xml(chain([catchEvent('W', TIMER + MSG_NOREF)]), { roots: ROOTS }), codes: [], engine: 'accept' },
+  { name: 'message + an empty timer: the acting timer is parsed', xml: xml(chain([catchEvent('W', MSG + EMPTY_TIMER)]), { roots: ROOTS }), codes: ['W_C7_DEPLOY_EVENT_DEFINITION'], engine: 'reject' },
+  { name: 'event sub-process start: the message acts, an empty timer is ignored', xml: xml(chain([['U', '<bpmn:userTask id="U" />']], eventSub(MSG + EMPTY_TIMER)), { roots: ROOTS }), codes: [], engine: 'accept' },
+  { name: 'event sub-process start: a message without messageRef acts', xml: xml(chain([['U', '<bpmn:userTask id="U" />']], eventSub(TIMER + MSG_NOREF)), { roots: ROOTS }), codes: ['W_C7_DEPLOY_MESSAGE'], engine: 'reject' },
+  { name: 'a message + timer start event is a second timer start event', xml: xml(chain([['U', '<bpmn:userTask id="U" />']], `<bpmn:startEvent id="S2">${MSG}${TIMER}</bpmn:startEvent><bpmn:sequenceFlow id="FS2" sourceRef="S2" targetRef="U" />`), { roots: ROOTS }), codes: ['W_C7_DEPLOY_START_EVENT'], engine: 'reject' },
+  { name: 'boundary event: signal + message, the signal acts', xml: xml(chain([['U', '<bpmn:userTask id="U" />']], `<bpmn:boundaryEvent id="B" attachedToRef="U"><bpmn:messageEventDefinition messageRef="M" /><bpmn:signalEventDefinition signalRef="Sig" /></bpmn:boundaryEvent><bpmn:sequenceFlow id="FB" sourceRef="B" targetRef="EB" /><bpmn:endEvent id="EB" />`), { roots: ROOTS }), codes: [], engine: 'accept' },
   // throw events act on one definition too: an end event on the message, an intermediate throw event on the signal
-  { name: 'end event: message + signal, the message acts', xml: xml(chain([['U', '<bpmn:userTask id="U" />']]).replace('<bpmn:endEvent id="End" />', `<bpmn:endEvent id="End"><bpmn:messageEventDefinition camunda:expression="\${true}" /><bpmn:signalEventDefinition signalRef="Sig" /></bpmn:endEvent>`), { roots: ROOTS }), codes: [MULTIPLE], engine: 'accept' },
-  { name: 'end event: the ignored signal definition without signalRef is not parsed', xml: xml(chain([['U', '<bpmn:userTask id="U" />']]).replace('<bpmn:endEvent id="End" />', '<bpmn:endEvent id="End"><bpmn:messageEventDefinition camunda:expression="${true}" /><bpmn:signalEventDefinition /></bpmn:endEvent>')), codes: [MULTIPLE], engine: 'accept' },
-  { name: 'intermediate throw event: the acting signal without signalRef is refused', xml: xml(chain([['T', '<bpmn:intermediateThrowEvent id="T"><bpmn:signalEventDefinition /><bpmn:messageEventDefinition camunda:expression="${true}" /></bpmn:intermediateThrowEvent>']])), codes: [MULTIPLE, 'W_C7_DEPLOY_SIGNAL'], engine: 'reject' },
-  { name: 'intermediate throw event: an ignored mail message definition is not parsed', xml: xml(chain([['T', '<bpmn:intermediateThrowEvent id="T"><bpmn:signalEventDefinition signalRef="Sig" /><bpmn:messageEventDefinition camunda:type="mail" /></bpmn:intermediateThrowEvent>']]), { roots: ROOTS }), codes: [MULTIPLE], engine: 'accept' },
+  { name: 'end event: message + signal, the message acts', xml: xml(chain([['U', '<bpmn:userTask id="U" />']]).replace('<bpmn:endEvent id="End" />', `<bpmn:endEvent id="End"><bpmn:messageEventDefinition camunda:expression="\${true}" /><bpmn:signalEventDefinition signalRef="Sig" /></bpmn:endEvent>`), { roots: ROOTS }), codes: [], engine: 'accept' },
+  { name: 'end event: the ignored signal definition without signalRef is not parsed', xml: xml(chain([['U', '<bpmn:userTask id="U" />']]).replace('<bpmn:endEvent id="End" />', '<bpmn:endEvent id="End"><bpmn:messageEventDefinition camunda:expression="${true}" /><bpmn:signalEventDefinition /></bpmn:endEvent>')), codes: [], engine: 'accept' },
+  { name: 'intermediate throw event: the acting signal without signalRef is refused', xml: xml(chain([['T', '<bpmn:intermediateThrowEvent id="T"><bpmn:signalEventDefinition /><bpmn:messageEventDefinition camunda:expression="${true}" /></bpmn:intermediateThrowEvent>']])), codes: ['W_C7_DEPLOY_SIGNAL'], engine: 'reject' },
+  { name: 'intermediate throw event: an ignored mail message definition is not parsed', xml: xml(chain([['T', '<bpmn:intermediateThrowEvent id="T"><bpmn:signalEventDefinition signalRef="Sig" /><bpmn:messageEventDefinition camunda:type="mail" /></bpmn:intermediateThrowEvent>']]), { roots: ROOTS }), codes: [], engine: 'accept' },
   // behind an event-based gateway: the acting definition decides
-  { name: 'event-based gateway -> message + timer catch event', xml: gateway(MSG + TIMER), codes: [MULTIPLE], engine: 'accept' },
-  { name: 'event-based gateway -> link + timer catch event (the timer acts)', xml: gateway(LINK + TIMER), codes: [MULTIPLE], engine: 'accept' },
-  { name: 'event-based gateway -> link + conditional catch event (the link acts)', xml: gateway(LINK + COND), codes: [MULTIPLE, 'W_C7_DEPLOY_EVENT_GATEWAY'], engine: 'reject' },
+  { name: 'event-based gateway -> message + timer catch event', xml: gateway(MSG + TIMER), codes: [], engine: 'accept' },
+  { name: 'event-based gateway -> link + timer catch event (the timer acts)', xml: gateway(LINK + TIMER), codes: [], engine: 'accept' },
+  { name: 'event-based gateway -> link + conditional catch event (the link acts)', xml: gateway(LINK + COND), codes: ['W_C7_DEPLOY_EVENT_GATEWAY'], engine: 'reject' },
   // attributes BPMN does not define
   { name: 'unprefixed attributes on a task and on an event definition', xml: xml(chain([['R', '<bpmn:businessRuleTask id="R" calledDecision="d1" camunda:decisionRef="d1" />'], catchEvent('W', TIMER.replace('<bpmn:timerEventDefinition id="TDef">', '<bpmn:timerEventDefinition id="TDef" foo="bar">'))])), codes: ['W_C7_DEPLOY_SCHEMA', 'W_C7_DEPLOY_SCHEMA'], engine: 'reject' },
 ];
 
 describe('integration follow-ups: one synthetic model per rule', () => {
   it.each(CASES.map((testCase) => [testCase.name, testCase] as const))('%s', async (_name, testCase) => {
-    const findings = runProfile(await Doc.fromXml(testCase.xml)).findings;
+    const findings = (await runProfile(await Doc.fromXml(testCase.xml))).findings;
     expect(findings.map((finding) => finding.code).sort()).toEqual([...testCase.codes].sort());
     expect(findings.some((finding) => finding.severity === 'deploy')).toBe(testCase.engine === 'reject');
     for (const finding of findings) {
       expect(finding.hint, `${finding.code}: ${finding.hint}`).toMatch(/`bpmn (set|add|remove|move|ext (add|remove|list)) <file> /);
     }
   });
-
-  it('names the definition the engines act on and how to keep only it', async () => {
-    const [finding] = runProfile(await Doc.fromXml(xml(chain([catchEvent('W', MSG + TIMER)]), { roots: ROOTS }))).findings;
-    expect(finding).toMatchObject({ code: MULTIPLE, element: 'W', severity: 'runtime' });
-    expect(finding!.message).toContain('the engines act on the timer only and ignore the message');
-    expect(finding!.hint).toContain('`bpmn set <file> W trigger=timer`');
-    const end = runProfile(await Doc.fromXml(CASES.find((testCase) => testCase.name.startsWith('end event'))!.xml)).findings[0]!;
-    expect(end.message).toContain('the engines act on the message only and ignore the signal');
-  });
 });
 
 /* ------------------------------------------------------------------ */
@@ -184,7 +171,7 @@ describe('hints name one of several event definitions with definition[<n>].', ()
     const file = join(dir, 'multi.bpmn');
     const defs = `<bpmn:messageEventDefinition id="MDef" messageRef="M" camunda:asyncc="true" />${TIMER.replace('<bpmn:timerEventDefinition id="TDef">', '<bpmn:timerEventDefinition id="TDef" camunda:jobPriority="high">')}`;
     writeFileSync(file, xml(chain([catchEvent('W', defs)]), { roots: ROOTS }));
-    const findings = runProfile(await Doc.fromXml(readFileSync(file, 'utf8'))).findings;
+    const findings = (await runProfile(await Doc.fromXml(readFileSync(file, 'utf8')))).findings;
     const unknown = findings.find((finding) => finding.code === 'W_C7_UNKNOWN_ATTRIBUTE')!;
     const priority = findings.find((finding) => finding.code === 'W_C7_MISPLACED_ATTRIBUTE')!;
     expect(unknown.hint).toContain("`bpmn set <file> W 'definition[0].camunda:asyncc='`");
@@ -195,7 +182,7 @@ describe('hints name one of several event definitions with definition[<n>].', ()
         expect(result.code, `${argv.join(' ')}\n${result.out}\n${result.err}`).toBe(0);
       }
     }
-    expect(runProfile(await Doc.fromXml(readFileSync(file, 'utf8'))).findings.map((finding) => finding.code)).toEqual([MULTIPLE]);
+    expect((await runProfile(await Doc.fromXml(readFileSync(file, 'utf8')))).findings.map((finding) => finding.code)).toEqual([]);
   }, 60000);
 });
 
@@ -215,12 +202,10 @@ describe('a boundary event on a compensation handler is reported once', () => {
   );
 
   it('validate: E_INVALID_HOST, no W_C7_DEPLOY_BOUNDARY_HOST (neither listed nor counted)', async () => {
-    const report = validateDoc(await Doc.fromXml(XML), { platform: 'auto' });
+    const report = (await checkDoc(await Doc.fromXml(XML), { platform: 'auto' })).validation;
     expect(report.errors.map((validationError) => `${validationError.code} ${validationError.element}`)).toContain('E_INVALID_HOST BT');
     expect(report.warnings.map((warning) => warning.code)).not.toContain('W_C7_DEPLOY_BOUNDARY_HOST');
     expect(report.platform!.counts.deploy).toBe(0);
-    // the profile on its own (library) still knows the engine rule
-    expect(runProfile(await Doc.fromXml(XML)).findings.map((finding) => finding.code)).toEqual(['W_C7_DEPLOY_BOUNDARY_HOST']);
   });
 });
 
@@ -257,7 +242,7 @@ describe("Operaton's namespace in the ops", () => {
     const list = listAllExtensions(doc.require('Activity_Host'));
     expect(list.map((extension) => extension.type)).toEqual(['operaton:inputOutput']);
     expect(list[0]!.children!.map((child) => `${child.type} ${child.attrs['name']}`)).toEqual(['operaton:inputParameter a', 'operaton:outputParameter c']);
-    expect(runProfile(doc).findings.map((finding) => finding.code)).toEqual([]);
+    expect((await runProfile(doc)).findings.map((finding) => finding.code)).toEqual([]);
     // the file does not get the camunda namespace on the way
     expect(await doc.toXml()).not.toContain('xmlns:camunda');
   });
@@ -285,7 +270,7 @@ describe("Operaton's namespace in the ops", () => {
     runOps(doc, [{ op: 'ext', id: 'Activity_Host', action: 'add', type: 'operaton:errorEventDefinition', attrs: { id: 'OEED_1', errorRef: 'Error_Biz', expression: '${true}' } }]);
     runOps(doc, [{ op: 'set', id: 'Error_Biz', values: { id: 'Error_New' } }]);
     expect(listAllExtensions(doc.require('Activity_Host'))[0]!.attrs['errorRef']).toBe('Error_New');
-    expect(runProfile(doc).findings.map((finding) => finding.code)).not.toContain('W_C7_DANGLING_REF');
+    expect((await runProfile(doc)).findings.map((finding) => finding.code)).not.toContain('W_C7_DANGLING_REF');
   });
 
   it('Booleans are written as true / false, misplaced attributes are E_WRONG_HOST, a resource condition is a condition', async () => {
@@ -337,7 +322,7 @@ describe('W_C7_DEPLOY_SCHEMA: `set <id> <attr>=` removes the attribute', () => {
   it('on the element and on a nested element; following the hints leaves a file the engines deploy', async () => {
     const file = join(dir, 'schema.bpmn');
     writeFileSync(file, CASES.find((testCase) => testCase.name.startsWith('unprefixed'))!.xml.replace('<bpmn:userTask', '<bpmn:userTask'));
-    const findings = runProfile(await Doc.fromXml(readFileSync(file, 'utf8'))).findings;
+    const findings = (await runProfile(await Doc.fromXml(readFileSync(file, 'utf8')))).findings;
     // a business rule task's unprefixed calledDecision is a decision link (bpmn-cli's spelling for a model without an engine): `set calledDecision=` writes the engines' spelling
     expect(findings.map((finding) => finding.hint)).toEqual(["Write the decision link in the engines' spelling: `bpmn set <file> R calledDecision=d1` (camunda:decisionRef; the unprefixed calledDecision is removed).", 'Remove it: `bpmn set <file> W definition.foo=` (vendor attributes need their namespace prefix, e.g. camunda:<name>).']);
     for (const finding of findings) {
@@ -346,12 +331,12 @@ describe('W_C7_DEPLOY_SCHEMA: `set <id> <attr>=` removes the attribute', () => {
         expect(result.code, `${argv.join(' ')}\n${result.out}\n${result.err}`).toBe(0);
       }
     }
-    expect(runProfile(await Doc.fromXml(readFileSync(file, 'utf8'))).findings).toEqual([]);
+    expect((await runProfile(await Doc.fromXml(readFileSync(file, 'utf8')))).findings).toEqual([]);
   }, 60000);
 
   it('in the diagram `set` cannot reach it: the hint says so; on bpmn:definitions it can', async () => {
     const model = xml(chain([])).replace('<bpmn:definitions ', '<bpmn:definitions bar="2" ').replace('</bpmn:process>', '</bpmn:process><bpmndi:BPMNDiagram id="Diagram_1"><bpmndi:BPMNPlane id="Plane_1" bpmnElement="P_Integration" foo="1" /></bpmndi:BPMNDiagram>').replace(BPMN, `${BPMN} xmlns:bpmndi="http://www.omg.org/spec/BPMN/20100524/DI"`);
-    const findings = runProfile(await Doc.fromXml(model)).findings;
+    const findings = (await runProfile(await Doc.fromXml(model))).findings;
     expect(findings.map((finding) => [finding.element, finding.hint])).toEqual([
       ['Definitions_1', 'Remove it: `bpmn set <file> Definitions_1 bar=` (vendor attributes need their namespace prefix, e.g. camunda:<name>).'],
       ['Plane_1', 'Remove foo="..." from the XML of Plane_1, or redraw the diagram, which writes new diagram elements: `bpmn layout <file>` (the hand-made layout is lost).'],
@@ -360,7 +345,7 @@ describe('W_C7_DEPLOY_SCHEMA: `set <id> <attr>=` removes the attribute', () => {
 
   it('a misspelt vendor attribute is moved in one command; a defined key still cannot be set to an unknown one', async () => {
     const doc = await Doc.fromXml(xml(chain([['T', '<bpmn:userTask id="T" assignee="demo" />']])));
-    const [finding] = runProfile(doc).findings;
+    const [finding] = (await runProfile(doc)).findings;
     expect(finding!.hint).toContain('`bpmn set <file> T assignee= camunda:assignee=demo`');
     runOps(doc, [{ op: 'set', id: 'T', values: { assignee: '', 'camunda:assignee': 'demo' } }]);
     expect(doc.require('T').$attrs).toEqual({ 'camunda:assignee': 'demo' });
@@ -456,7 +441,7 @@ describe('self-description', () => {
     const json = kindsJson() as { nestedSelectors: Record<string, string>; errors: Array<{ code: string }> };
     expect(Object.keys(json.nestedSelectors)).toEqual(['definition[<n>].<key>', 'definition[<trigger>].<key>']);
     expect(kindsText()).toContain('definition[<n>].<key>: one of several event definitions');
-    for (const code of ['E_AMBIGUOUS_NESTED', 'W_C7_DEPLOY_START_EVENT', 'W_C7_DEPLOY_LINK', 'W_C7_DEPLOY_SCHEMA', 'W_C7_EMPTY_CONDITION', MULTIPLE]) {
+    for (const code of ['E_AMBIGUOUS_NESTED', 'W_C7_DEPLOY_START_EVENT', 'W_C7_DEPLOY_LINK', 'W_C7_DEPLOY_SCHEMA']) {
       expect(json.errors.map((validationError) => validationError.code)).toContain(code);
     }
   });
diff --git a/test/e2e/camunda7.test.ts b/test/e2e/camunda7.test.ts
index 034c6146..52144385 100644
--- a/test/e2e/camunda7.test.ts
+++ b/test/e2e/camunda7.test.ts
@@ -349,10 +349,10 @@ describe('find shows the matched vendor value; kinds documents the C7 keys (#8,
     expect(json.triggers['message']!.alsoOn).toEqual(['sendTask', 'receiveTask']);
   });
 
-  it('the library exports the platform profile', () => {
-    expect(typeof lib.runProfile).toBe('function');
-    expect(typeof lib.loadProfile).toBe('function');
-    expect(typeof lib.loadProfiles).toBe('function');
+  it('the library exports the platform detection; the engine rules run in checkDoc and every write', () => {
+    expect('runProfile' in lib).toBe(false);
+    expect('loadProfile' in lib).toBe(false);
+    expect('loadProfiles' in lib).toBe(false);
     expect(typeof lib.detectPlatform).toBe('function');
     expect(lib.PLATFORM_CHOICES).toEqual(['auto', 'c7', 'c8', 'none']);
   });
diff --git a/test/e2e/isomorphic.test.ts b/test/e2e/isomorphic.test.ts
index 94ac22d3..fcdca469 100644
--- a/test/e2e/isomorphic.test.ts
+++ b/test/e2e/isomorphic.test.ts
@@ -242,6 +242,8 @@ describe('the engine rules load on demand, only for their platform (an ESM split
         xml.includes('id="Task_Recv"') ? [{ severity: 'ERROR', code: 'E_HOST_LOOSE', message: 'Task_Recv has no sequence flow', element: 'Task_Recv' }] : [],
     }],
   };
+  const RULES = 'src/adapters/out/bpmnlint/engine/rules';
+  const ENGINE_RUN = 'src/adapters/out/bpmnlint/engine/run/EngineRun.ts';
   let c7: string;
   let c8: string;
   let bundle: Bundle;
@@ -251,7 +253,7 @@ describe('the engine rules load on demand, only for their platform (an ESM split
   beforeAll(async () => {
     bundle = await bundleCore({ entry: join('src', 'index.ts'), splitting: true, minify: false });
     expect(bundle.violations).toEqual([]);
-    const profileOf = (chunk: Chunk): 'c7' | 'c8' | undefined => (chunk.inputs.includes('src/domain/validation/profiles/C7Profile.ts') ? 'c7' : chunk.inputs.includes('src/domain/validation/profiles/C8Profile.ts') ? 'c8' : undefined);
+    const profileOf = (chunk: Chunk): 'c7' | 'c8' | undefined => (chunk.inputs.includes(`${RULES}/c7/Camunda7Rules.ts`) ? 'c7' : chunk.inputs.includes(`${RULES}/c8/Camunda8Rules.ts`) ? 'c8' : undefined);
     files = bundle.chunks.map((chunk) => {
       const text = chunk.text.replace(/(["'])\.\/([\w.-]+)\.js\1/g, (_m, quote: string, name: string) => `${quote}./${name}.mjs${quote}`);
       return { name: basename(chunk.path).replace(/\.js$/, '.mjs'), text: `(globalThis.${LOADS} ??= []).push(import.meta.url);\n${text}`, profile: profileOf(chunk) };
@@ -266,7 +268,7 @@ describe('the engine rules load on demand, only for their platform (an ESM split
     };
     visit(bundle.entry);
     const initialInputs = bundle.chunks.filter((chunk) => initial.has(chunk.path)).flatMap((chunk) => chunk.inputs);
-    expect(initialInputs.filter((file) => /^src\/platform\/profiles\/(EngineProfile|EngineRules|RuleRun|C7Profile|C8Profile|FeelExpression|FeelParser|FeelError|TimerValue|SchemaText|BpmnSchema|utils\/\w+|c[78]\/\w+|c[78]\/utils\/\w+)\.ts$/.test(file))).toEqual([]);
+    expect(initialInputs.filter((file) => file.startsWith('src/adapters/out/bpmnlint/engine/') || file.startsWith('node_modules/bpmnlint-plugin-camunda-compat/') || file === 'node_modules/bpmnlint/lib/linter.js')).toEqual([]);
     expect(files.filter((file) => file.profile).map((file) => file.profile).sort()).toEqual(['c7', 'c8']);
     dir = realpathSync(mkdtempSync(join(tmpdir(), 'bpmn-lazy-profiles-')));
     writeFileSync(join(dir, 'import.cjs'), 'module.exports = (url) => import(url);\n');
@@ -296,7 +298,7 @@ describe('the engine rules load on demand, only for their platform (an ESM split
   it('the entry chunk is the one of the requested entry, though esbuild makes every import() target an entry point', () => {
     expect(bundle.chunks.filter((chunk) => chunk.entry).map((chunk) => chunk.entryPoint)).toEqual(['src/index.ts']);
     expect(bundle.entry.entryPoint).toBe('src/index.ts');
-    expect(bundle.chunks.map((chunk) => chunk.entryPoint)).toEqual(expect.arrayContaining(['src/domain/validation/profiles/C7Profile.ts', 'src/domain/validation/profiles/C8Profile.ts']));
+    expect(bundle.chunks.map((chunk) => chunk.entryPoint)).toEqual(expect.arrayContaining([`${RULES}/c7/Camunda7Rules.ts`, `${RULES}/c8/Camunda8Rules.ts`, ENGINE_RUN]));
   });
 
   it('the rule chunks import nothing the entry loads (a host whose entry module awaits a call at top level does not wait for itself)', () => {
@@ -315,22 +317,23 @@ describe('the engine rules load on demand, only for their platform (an ESM split
       visit(start);
       return seen;
     };
+    // the engine run and the rules get the core from ENGINE_KIT; the packages they use share
+    // packages (min-dash) with the core, which a host may not await at top level (docs/library.md)
     const core = reach('src/index.ts');
-    expect(core.has('src/domain/document/utils/moddle.ts') && core.has('src/domain/validation/profiles/PlatformProfiles.ts')).toBe(true);
-    for (const rules of ['src/domain/validation/profiles/C7Profile.ts', 'src/domain/validation/profiles/C8Profile.ts']) {
-      const own = [...reach(rules)];
-      expect(own.filter((module) => core.has(module)), rules).toEqual([]);
-      expect(own.flatMap((module) => bundle.graph[module] ?? []).filter((dependency) => core.has(dependency)), rules).toEqual([]);
-      const chunk = bundle.chunks.find((chunk) => chunk.inputs.includes(rules))!;
-      expect(chunk.imports.filter((importPath) => initial.has(importPath)), rules).toEqual([]);
+    expect(core.has('src/domain/document/utils/moddle.ts') && core.has('src/adapters/out/bpmnlint/BpmnlintEngineLint.ts')).toBe(true);
+    const own = [...reach(ENGINE_RUN)];
+    expect(own.filter((module) => core.has(module))).toEqual([]);
+    expect(own.flatMap((module) => bundle.graph[module] ?? []).filter((dependency) => core.has(dependency))).toEqual([]);
+    for (const rules of [`${RULES}/c7/Camunda7Rules.ts`, `${RULES}/c8/Camunda8Rules.ts`]) {
+      expect([...reach(rules)].filter((module) => module.startsWith('src/') && core.has(module)), rules).toEqual([]);
     }
-    expect(bundle.chunks.find((chunk) => chunk.inputs.includes('src/domain/validation/profiles/C8Profile.ts'))!.inputs).toEqual(expect.arrayContaining(['src/domain/validation/profiles/FeelParser.ts', 'src/domain/validation/profiles/FeelExpression.ts', 'src/domain/validation/profiles/TimerValue.ts', 'src/domain/validation/profiles/SchemaText.ts', 'src/domain/validation/profiles/BpmnSchema.ts']));
+    expect(bundle.chunks.find((chunk) => chunk.inputs.includes(ENGINE_RUN))!.inputs).toEqual(expect.arrayContaining(['src/adapters/out/bpmnlint/engine/run/EngineFindings.ts', 'src/adapters/out/bpmnlint/engine/run/CompatVerdicts.ts', 'src/adapters/out/bpmnlint/engine/run/EngineHint.ts']));
   });
 
   it('the instances load natively and record what they evaluate', async () => {
     const { lib, at } = await fresh();
     expect(loads()).toContain(`${pathToFileURL(at).href}/index.mjs`);
-    expect(typeof lib.loadProfile).toBe('function');
+    expect('loadProfile' in lib).toBe(false);
   });
 
   it('a plain model loads no profile chunk', async () => {
@@ -406,36 +409,23 @@ describe('the engine rules load on demand, only for their platform (an ESM split
     const second = await fresh();
     const toEight = await second.lib.applyToXml(plain, toC8);
     expect(second.profiles()).toEqual(['c8']);
+    // camunda-compat's sequence-flow-condition reports the flows themselves, and as refused at deploy
     expect(toEight.result.validation.platform).toMatchObject({ platform: 'c8', counts: { deploy: 1, runtime: 3, practice: 0 }, resolved: [] });
     expect(brief(toEight.result.validation.platform?.added)).toEqual([
       'W_C8_MISPLACED_EXTENSION Task_A',
-      'W_C8_EXCLUSIVE_GATEWAY Gw_Split F3',
-      'W_C8_EXCLUSIVE_GATEWAY Gw_Split F4',
       'W_C8_DEPLOY_TIMER Timer_1',
+      'W_C8_EXCLUSIVE_GATEWAY F3',
+      'W_C8_EXCLUSIVE_GATEWAY F4',
     ]);
     expect(JSON.stringify(toEight.result)).toBe(JSON.stringify((await core.applyToXml(plain, toC8)).result));
   });
 
-  it('the synchronous building blocks need the rules loaded first (E_PROFILE_NOT_LOADED; loadProfile / loadProfiles)', async () => {
+  it('validateDoc is the structural validation alone and loads no rule chunk', async () => {
     const { lib, profiles } = await fresh();
-    const doc = await lib.Doc.fromXml(c7);
-    expect(() => lib.runProfile(doc)).toThrow(expect.objectContaining({ code: 'E_PROFILE_NOT_LOADED', category: 'usage' }));
-    expect(() => lib.validateDoc(doc, { platform: 'auto' })).toThrow(expect.objectContaining({ code: 'E_PROFILE_NOT_LOADED' }));
-    expect(() => lib.runProfile(doc, 'c8')).toThrow(expect.objectContaining({ code: 'E_PROFILE_NOT_LOADED', details: expect.objectContaining({ platform: 'c8' }) }));
-    // no rules needed: plain BPMN, platform 'none', the structural validation
-    expect(lib.runProfile(doc, 'none').findings).toEqual([]);
-    expect(lib.runProfile(await lib.Doc.fromXml(plain)).platform).toBe('none');
-    expect(lib.validateDoc(doc).errors).toEqual([]);
-    await lib.loadProfile('none');
+    const result = lib.validateDoc(await lib.Doc.fromXml(c7));
+    expect(result.errors).toEqual([]);
+    expect(result.platform).toBeUndefined();
     expect(profiles()).toEqual([]);
-    await Promise.all([lib.loadProfile('c7'), lib.loadProfile('c7')]);
-    await lib.loadProfile('c7');
-    expect(profiles()).toEqual(['c7']);
-    expect(JSON.stringify(lib.runProfile(doc))).toBe(JSON.stringify(core.runProfile(await core.Doc.fromXml(c7))));
-    await lib.loadProfiles();
-    expect(profiles()).toEqual(['c7', 'c8']);
-    expect(lib.runProfile(doc, 'c8').platform).toBe('c8');
-    await expect(lib.loadProfile('camunda7' as never)).rejects.toMatchObject({ code: 'E_USAGE' });
   });
 
   it('a profile chunk that fails to load rejects with E_PROFILE_LOAD before a result exists; a later call imports it again (Node loads it)', async () => {
diff --git a/test/fixtures/c8/feel-verdicts.json b/test/fixtures/c8/feel-verdicts.json
index f0fd9213..07bd69f2 100644
--- a/test/fixtures/c8/feel-verdicts.json
+++ b/test/fixtures/c8/feel-verdicts.json
@@ -1,764 +1,764 @@
 [
-["$a", true],
-["a$b", true],
-["_a", true],
-["?", true],
-["? > 1", true],
-["a?", false],
-["\u00e9 > 1", true],
-["gr\u00f6\u00dfe > 1", true],
-["a-b", true],
-["a.b-c", true],
-["first name = \"x\"", false],
-["a b", false],
-["item", true],
-["a'b", false],
-["a1", true],
-["1a", false],
-["\u00c4rger", true],
-["then", false],
-["in", false],
-["for", true],
-["return", false],
-["satisfies", false],
-["function", false],
-["instance", true],
-["of", true],
-["between", true],
-["some", true],
-["every", true],
-["not", true],
-["external", true],
-["x.in", false],
-["x.then", false],
-["of = 1", true],
-["external = 1", true],
-["true", true],
-["false", true],
-["null", true],
-["x.for", true],
-["string length(\"a\") > 1", true],
-["get or else(a, 1)", true],
-["date and time(\"2020-01-01T10:00:00\") < now()", true],
-["years and months duration(date(\"2020-01-01\"), date(\"2021-01-01\"))", true],
-["is defined(a)", true],
-["upper case(\"a\")", true],
-["day of week(today())", true],
-["last day of month(today())", true],
-["round half up(1.5, 0)", true],
-["list contains([1], 1)", true],
-["context put({}, \"a\", 1)", true],
-["string join([\"a\"], \",\")", true],
-["index of([1], 1)", true],
-["distinct values([1])", true],
-["get value({a:1}, \"a\")", true],
-["substring before(\"ab\", \"b\")", true],
-["foo bar(1)", true],
-["foo  bar(1)", true],
-["foo bar (1)", true],
-["a.foo bar(1)", false],
-["date and time(\"2020-01-01T10:00:00\")", true],
-["days and time duration(\"P1D\")", true],
-["x & y", false],
-["-x", true],
-["- -x", false],
-["--x", false],
-["x - -1", true],
-["+x", false],
-["x ** -1", true],
-["not x", false],
-["not(x, y)", true],
-["x in (1, 2)", true],
-["x in [1..5]", true],
-["x in (1..5]", true],
-["x in ]1..5[", true],
-["x in > 5", true],
-["x in < 5", true],
-["x in >= 5, < 10", false],
-["x in (> 5, < 1)", true],
-["x in null", true],
-["x in \"a\"", true],
-["x in -", false],
-["x in not(1)", true],
-["x = [1..5]", false],
-["[1..5]", true],
-["1..5", false],
-["(1..5)", true],
-["]1..5[", true],
-["[1..5[", true],
-["x in [1, 2]", true],
-["for i in 1..3 return i", true],
-["for i in [1,2], j in [3] return i+j", true],
-["every x in xs satisfies x > 1", true],
-["some x in xs, y in ys satisfies x = y", true],
-["if a then b else if c then d else e", true],
-["if a then (if b then c else d) else e", true],
-["1 + if a then 1 else 2", false],
-["(if a then 1 else 2) + 1", true],
-["x between 1 and 5 and y", true],
-["x instance of list<number>", false],
-["x instance of context<a: number>", false],
-["x instance of function<number> -> number", false],
-["x instance of date and time", true],
-["x instance of days and time duration", true],
-["x instance of Any", true],
-["x instance of foo", true],
-["x instance of string and y", true],
-["a < b < c", false],
-["a = b = c", false],
-["a != b != c", false],
-["(a)", true],
-["()", false],
-["[]", true],
-["{}", true],
-["{a: 1, b: 2}.b", true],
-["{\"a b\": 1}", true],
-["{a b: 1}", true],
-["{a: 1,}", false],
-["[1,2,]", false],
-["f(a: 1)", true],
-["f(1, b: 2)", false],
-["f(,)", false],
-["f(a: 1, 2)", false],
-["x[1][2]", true],
-["x[item > 1].name", true],
-["x.y[1]", true],
-["f().a", true],
-["f()(1)", false],
-["function(a, b) a + b", true],
-["function(a: number) a", false],
-["function() 1", true],
-["function(a) external {}", false],
-["@\"P1D\"", true],
-["@\"2020-01-01\" + @\"P1D\"", true],
-["date(\"2020-01-01\") - @\"P1D\"", true],
-["1.5", true],
-[".5", true],
-["1.", false],
-["1e3", false],
-["1_000", false],
-["0x10", false],
-["\"a\" + \"b\"", true],
-["\"a\\\"b\"", true],
-["\"a\\nb\"", true],
-["\"\\u00e4\"", true],
-["\"a\" \"b\"", false],
-["x . y", true],
-["x..y", false],
-["x.1", false],
-["x[-1]", true],
-["-x[1]", true],
-["x ** 2 ** 3", true],
-["x * - 1", true],
-["x+-1", true],
-["true and not(false)", true],
-["x != null and y", true],
-["x // c", true],
-["x /* c */", true],
-["/* c */ x", true],
-["x # c", false],
-["x;", false],
-["x,y", false],
-["(x, y)", false],
-["x ?", false],
-["is(a, b)", true],
-["x like \"a\"", false],
-["x !== 1", false],
-["x =< 1", false],
-["x => 1", false],
-["x -> 1", false],
-["not(x) = true", true],
-["{a: {b: 1}}.a.b", true],
-["{a: 1}[\"a\"]", true],
-["\"a\"[1]", true],
-["-", false],
-["- 1", true],
-["* x", false],
-["x +", false],
-["[1,2] = [1,2]", true],
-["x in [1,2,3]", true],
-["x in ([1,2])", true],
-["x in (1)", true],
-["x in ()", false],
-["x in []", true],
-["x in [1..]", false],
-["x in <", false],
-["a and b or c and d", true],
-["x.y.z = 1", true],
-["\"\\t\"", true],
-["\"a\\qb\"", true],
-["x\ny", false],
-["x\n= 1", true],
-["x  ", true],
-["`a`.`b c`", true],
-["`a` + `b`", true],
-["``", false],
-["x instance of", false],
-["x between 1", false],
-["x between 1 and", false],
-["if x then", false],
-["if then else", false],
-["some x in xs", false],
-["for x in xs", false],
-["function(a)", false],
-["{a: }", false],
-["{: 1}", false],
-["{a 1}", false],
-["[1 2]", false],
-["f(1 2)", false],
-["x.", false],
-[".x", false],
-["x.y.", false],
-["a[", false],
-["a]", false],
-["a[]", false],
-["a = = 1", false],
-["a == b", false],
-["and", false],
-["a and and b", false],
-["or b", false],
-["not()", true],
-["not(x)(1)", false],
-["x[1 > 2, 3]", false],
-["abs(-1)", true],
-["number(\"1\") + 1", true],
-["sum([1,2])", true],
-["max(1,2,3)", true],
-["< 5", true],
-["a and < 5", true],
-["> 5 or < 1", true],
-["[1..5] and x", true],
-["x and [1..5]", true],
-["[1..5] + 1", false],
-["x = (1..5)", false],
-["not(< 5)", true],
-["[1..5] = x", false],
-["-[1..5]", false],
-["x in [1..5] and y", true],
-["5", true],
-["!= 5", false],
-["a or = 5", false],
-["(< 5)", true],
-["[< 5]", true],
-["f(< 5)", true],
-["a.b(1)", true],
-["f()[1]", true],
-["(f)(1)", false],
-["x[1](2)", false],
-["{f: function() 1}.f()", false],
-["a.b.c(1)", true],
-["foo bar(1).x", true],
-["foo bar(1)[1]", true],
-["\"a\"(1)", false],
-["f(1).g(2)", false],
-["a.b (1)", true],
-["a and if x then 1 else 2", false],
-["[if a then 1 else 2]", true],
-["f(if a then 1 else 2)", true],
-["{a: if x then 1 else 2}", true],
-["x[if a then 1 else 2]", true],
-["if a then 1 else 2 + 3", true],
-["if a then for x in y return x else 1", true],
-["some x in xs satisfies if x then true else false", true],
-["for x in xs return if x then 1 else 2", true],
-["function(a) if a then 1 else 2", true],
-["x = if a then 1 else 2", false],
-["not(if a then true else false)", true],
-["for x in if a then [1] else [2] return x", false],
-["if a then 1 else 2 and b", true],
-["if if a then b else c then 1 else 2", true],
-["if (a) then (1) else (2)", true],
-["if a then 1 else", false],
-["if a else 1", false],
-["if a then some x in y satisfies x else 1", true],
-["if a then function(x) x else 1", true],
-["(if a then 1 else 2)[1]", true],
-["(if a then 1 else 2).b", true],
-["for x in 1..3, y in xs return x", true],
-["for x in xs return x + 1", true],
-["for x in xs return x and y", true],
-["for i in 1..n return i", true],
-["for x in [1..3] return x", false],
-["for i in -1..3 return i", true],
-["for x in xs.y return x", true],
-["for x in xs[item > 1] return x", true],
-["for in xs return x", false],
-["for x xs return x", false],
-["for x in return x", false],
-["for x in xs, return x", false],
-["for x in xs return", false],
-["for x in 1.. return x", false],
-["for x in xs return x, y", false],
-["for `a b` in xs return `a b`", true],
-["for x.y in xs return x", false],
-["for x in xs return for y in x return y", true],
-["for x in f(1) return x", true],
-["for x in 1 + 1..3 return x", true],
-["for x in a..b return x", true],
-["for x in (1..3) return x", false],
-["for x in xs return some y in x satisfies y", true],
-["for x in xs return x = 1", true],
-["for x in xs return x in (1,2)", true],
-["for x in xs return x between 1 and 2", true],
-["for some in xs return some", true],
-["for if in xs return 1", true],
-["for x in xs return x[1]", true],
-["some x in [1,2] satisfies x > 1 and true", true],
-["every x in xs satisfies x", true],
-["some x in xs satisfies", false],
-["some x in 1..3 satisfies x > 1", true],
-["some in xs satisfies x", false],
-["some x in xs, y in ys satisfies x and y", true],
-["every x in xs satisfies some y in x satisfies y", true],
-["some x in xs satisfies x or y", true],
-["some x in xs satisfies x = 1", true],
-["every x in xs satisfies for y in x return y", true],
-["some x in (1,2) satisfies x", false],
-["x between a + 1 and b * 2", true],
-["x between 1 and 2 = true", false],
-["x between (1) and (2)", true],
-["x between y between 1 and 2 and 3", false],
-["x between 1 and 2 or y", true],
-["x between - 1 and 2", true],
-["x between if a then 1 else 2 and 3", false],
-["x between 1 and 2 and 3", true],
-["x in y", true],
-["x in y.z", true],
-["x in f(1)", true],
-["x in [a, b]", true],
-["x in (a)", true],
-["x in (< 1, > 5, 3)", true],
-["x in [1..5], 7", false],
-["x in \"a\", \"b\"", false],
-["x in = 1", false],
-["x in != 1", false],
-["x in < f(1)", true],
-["x in - 1", true],
-["x in (-1, 1)", true],
-["x in ((1,2))", false],
-["x in null, 1", false],
-["x in (1..5), (6..7)", false],
-["x in ]1..5]", true],
-["x in [1..5)", true],
-["x in [a..b]", true],
-["x in [1 .. 5]", true],
-["x in [1..5].x", false],
-["x in [1, 2] = true", true],
-["x in > 5 and y", true],
-["x in ? > 1", true],
-["x in (1, [2..3], > 4)", true],
-["x in a + 1", true],
-["x in (a + 1, b)", true],
-["x in -1", true],
-["x in ([1..2])", true],
-["x in [1..2] or y", true],
-["x in {}", true],
-["x in @\"P1D\"", true],
-["x in date(\"2020-01-01\")", true],
-["x in (not(1))", true],
-["x in (1, 2) and x in (3)", true],
-["x in y in z", true],
-["x in 1 = 2", true],
-["x in (1) = true", false],
-["x instance of number = true", false],
-["x instance of a.b", true],
-["x instance of null", false],
-["x instance of 1", false],
-["x instance of \"s\"", false],
-["x instance of years and months duration", true],
-["x instance of date", true],
-["x instance of time", true],
-["x instance of string or y", true],
-["x instance of list", true],
-["x instance of context", true],
-["x instance of function", true],
-["x instance of instance", true],
-["x instance of then", false],
-["x instance of `a b`", true],
-["x instance  of number", true],
-["x instanceof number", true],
-["x instance of number and", false],
-["x instance of foo bar", false],
-["x instance of date and", false],
-["x instance of date and y", true],
-["{\"a\": 1}", true],
-["{a: 1, \"b\": 2}", true],
-["{a: 1}.a + 1", true],
-["{a.b: 1}", true],
-["{1: 2}", true],
-["{a-b: 1}", true],
-["{a: 1, a: 2}", true],
-["{a: 1 b: 2}", false],
-["{a : 1}", true],
-["{ a b c: 1}", true],
-["{if: 1}", true],
-["{then: 1}", true],
-["{function: 1}", true],
-["{and: 1}", true],
-["{in: 1}", true],
-["{`a`: 1}", true],
-["{a: function(x) x}.a(1)", false],
-["{a: 1}.`a`", true],
-["{a: {}}", true],
-["{a: []}", true],
-["{a: [1, {b: 2}]}", true],
-["{a: 1, b: a + 1}", true],
-["{a: some x in y satisfies x}", true],
-["{a?: 1}", true],
-["{$a: 1}", true],
-["{\"\": 1}", true],
-["{a: 1}.b.c", true],
-["{a: 1}{b: 2}", false],
-["[1, [2, 3]]", true],
-["[a, b][1]", true],
-["[1, 2].x", true],
-["[ ]", true],
-["[,]", false],
-["[1,,2]", false],
-["[1..2, 3]", false],
-["[for x in y return x]", true],
-["[some x in y satisfies x]", true],
-["[x in (1,2)]", true],
-["[x between 1 and 2]", true],
-["[a = 1, b != 2]", true],
-["function(a, b) a", true],
-["function(a,) a", false],
-["function(1) a", false],
-["function(a b) a", true],
-["function(a) function(b) a + b", true],
-["(function(a) a)(1)", false],
-["function (a) a", true],
-["function(`a b`) 1", true],
-["function(a, a) a", true],
-["x + function(a) a", true],
-["[function(a) a]", true],
-["f(function(a) a)", true],
-["function(a) a and b", true],
-["function(a) a = 1", true],
-["function(if) 1", true],
-["function(a) for x in a return x", true],
-["function() function() 1", true],
-["function(a) a, 1", false],
-["xs[item.a > 1]", true],
-["xs[a > 1 and b]", true],
-["xs[for x in y return x]", true],
-["xs[some x in y satisfies x]", true],
-["xs[x in (1,2)]", true],
-["xs[x between 1 and 2]", true],
-["xs[< 5]", true],
-["xs[1][item > 2].a[3]", true],
-["xs[1].a.b[2]", true],
-["xs [1]", true],
-["xs.a [1]", true],
-["@\"x\"", true],
-["@x", false],
-["@ \"P1D\"", true],
-["@\"P1D\".days", true],
-["date(\"2020-01-01\").year", true],
-["\"a\".b", true],
-["1.b", true],
-["[1,2].a", true],
-["(a).b", true],
-["(a)[1]", true],
-["(a)(1)", false],
-["-a.b", true],
-["true.a", true],
-["null.a", true],
-["true(1)", false],
-["null(1)", false],
-["1(2)", false],
-["\"a\" \"b\" \"c\"", false],
-["gr\u00f6\u00dfe.l\u00e4nge", true],
-["\u540d\u524d = 1", true],
-["a\u00b7b", false],
-["a\u20ac", true],
-["a\u203fb", true],
-["a\u00a0b", false],
-["\u2603 = 1", false],
-["x\u00b2 = 1", false],
-["\u03b1\u03b2 = 1", true],
-["a\u0301 = 1", true],
-["\"line1\nline2\"", true],
-["\"\\u12\"", true],
-["\"\\\"", false],
-["\"\\\\\"", true],
-["\"it's\"", true],
-["\"\\'\"", true],
-["a ** b ** c", true],
-["a / b / c", true],
-["a * b / c - d + e", true],
-["a - - - b", false],
-["a -- b", true],
-["a + + b", false],
-["a+ +b", false],
-["a */ b", false],
-["a ^ b", false],
-["a mod b", false],
-["a div b", false],
-["a % b", false],
-["a >= b", true],
-["a <= b", true],
-["a ! = b", false],
-["a = ! b", false],
-["a < = b", false],
-["a* *b", false],
-["not(a) and not(b)", true],
-["a and not b", false],
-["true or false and true", true],
-["a and (b or c)", true],
-["a or", false],
-["a = null", true],
-["null = a", true],
-["a = -1", true],
-["a = - b", true],
-["a < -b", true],
-["a * -b", true],
-["a ** -b", true],
-["-a ** 2", true],
-["- a * b", true],
-["a - b - c", true],
-["x.some", true],
-["x.every", true],
-["x.instance", true],
-["x.of", true],
-["x.between", true],
-["x.not", true],
-["x.external", true],
-["x.true", false],
-["x.null", false],
-["x.if", true],
-["x.else", false],
-["x.and", false],
-["x.or", false],
-["x.function", false],
-["x.return", false],
-["x.satisfies", false],
-["if", true],
-["else", false],
-["true = 1", true],
-["if = 1", true],
-["if(1)", true],
-["then(1)", false],
-["and(true)", true],
-["or(true)", true],
-["in(1)", false],
-["for(1)", true],
-["some(1)", true],
-["every(1)", true],
-["instance(1)", true],
-["between(1)", true],
-["return(1)", false],
-["satisfies(1)", false],
-["external(1)", true],
-["not(1)", true],
-["else(1)", false],
-["of(1)", true],
-["foo then bar(1)", false],
-["a if b(1)", true],
-["x instance of y(1)", true],
-["foo else bar(1)", false],
-["foo return bar(1)", false],
-["foo satisfies bar(1)", false],
-["foo in bar(1)", true],
-["foo for bar(1)", true],
-["foo function bar(1)", false],
-["a b c d(1)", true],
-["a 1(2)", false],
-["a \"b\"(1)", false],
-["string length (\"a\")", true],
-["string  length(\"a\")", true],
-["string\nlength(\"a\")", false],
-["a.string length(\"a\")", false],
-["string length", false],
-["string length = 1", false],
-["get or else", false],
-["x = get or else(a, 1)", true],
-["x andy", true],
-["x ory", true],
-["ifx then 1 else 2", true],
-["x between1 and 2", true],
-["x in(1,2)", true],
-["x instance ofnumber", true],
-["for x in y returnx", true],
-["some x in y satisfiesx", true],
-["x and(y)", true],
-["x or(y)", true],
-["not(x)and y", true],
-["1and 2", true],
-["x=1", true],
-["x>1and y<2", true],
-["if(a)then(1)else(2)", true],
-["for x in(y)return x", true],
-["x between(1)and(2)", true],
-["x in[1,2]", true],
-["x and\"a\"", true],
-["\"a\"and x", true],
-["x and[1]", true],
-["[1]and x", true],
-["x instanceof", true],
-["x elsey", false],
-["xin y", false],
-["x iny", true],
-["x in if a then [1] else [2]", true],
-["x in some y in z satisfies y", true],
-["x in for y in z return y", true],
-["x in function() 1", true],
-["x = y in z", false],
-["x in y = z", true],
-["x + for y in z return y", false],
-["x + some y in z satisfies y", false],
-["x and for y in z return y", false],
-["not(for x in y return x)", true],
-["x and some y in z satisfies y", false],
-["x or if a then b else c", false],
-["x and function(a) a", true],
-["-function(a) a", true],
-["x between function() 1 and 2", false],
-["foo true bar(1)", false],
-["foo null bar(1)", false],
-["foo between bar(1)", true],
-["foo instance bar(1)", true],
-["foo of bar(1)", true],
-["foo some bar(1)", true],
-["foo not bar(1)", true],
-["foo external bar(1)", true],
-["foo if bar(1)", true],
-["foo every bar(1)", true],
-["if foo(1)", true],
-["not foo(1)", true],
-["x y.z(1)", false],
-["foo bar.baz(1)", false],
-["foo `bar`(1)", false],
-["foo and bar(1) = 1", true],
-["1 foo(1)", false],
-["foo bar(1) foo(2)", false],
-["some foo(1)", true],
-["every foo(1)", true],
-["for foo(1)", true],
-["between foo(1)", true],
-["foo in(1)", true],
-["foo and(1)", true],
-["foo or(1)", true],
-["foo bar baz", false],
-["? foo(1)", false],
-["foo ?(1)", false],
-["foo $(1)", true],
-["$ foo(1)", true],
-["foo - bar(1)", true],
-["\u20aca = 1", true],
-["_ = 1", true],
-["a\u200db = 1", true],
-["\u216b = 1", true],
-["a\u0663 = 1", true],
-["\u0663a = 1", false],
-["ab\u00ad = 1", true],
-["a\u0301b = 1", true],
-["\u0301a = 1", false],
-["a\u00b7", false],
-["\u00b7a", false],
-["a\u2019b", false],
-["\u201ca\u201d", false],
-["a_b", true],
-["__", true],
-["$", true],
-["$$ = 1", true],
-["a$", true],
-["\u20ac", true],
-["\u203f", true],
-["a\u2003= 1", true],
-["a\u3000= 1", true],
-["\ufeffa", true],
-["a\r\n= 1", true],
-["a\t= 1", true],
-["a\u0085= 1", true],
-["a\u2028= 1", true],
-["x instance of date and time and y", true],
-["x instance of days and time duration = 1", false],
-["x instance of years and months duration or y", true],
-["x instance of date and time.a", false],
-["x instance of a.b.c", true],
-["x instance of `a b`.c", true],
-["(f)", true],
-["f.g.h", true],
-["f(a: 1, b: 2)", true],
-["f(a: 1, a: 2)", true],
-["f(a b: 1)", true],
-["f(\"a\": 1)", false],
-["f(1: 2)", false],
-["f(if: 1)", true],
-["f(a: 1,)", false],
-["{a: 1}.a(1)", false],
-["a.b(1)(2)", false],
-["a(1).b", true],
-["a(1).b(2)", false],
-["a(1)[1].b", true],
-["f( )", true],
-["f(a: if x then 1 else 2)", true],
-["f(a: < 5)", true],
-["f(a:1)", true],
-["f(a :1)", true],
-["f(then: 1)", false],
-["f(function: 1)", false],
-["f(`a b`: 1)", true],
-["f(a.b: 1)", false],
-["[1 ..5]", true],
-["[ 1..5 ]", true],
-["[a.b..c]", true],
-["[f(1)..2]", true],
-["[-1..-5]", true],
-["[1..5] or [6..7]", true],
-["(1..5] and x", true],
-["[1..5] and [6..7] or (8..9)", true],
-["[1..x + 1]", true],
-["[x[1]..2]", true],
-["[1..2..3]", false],
-["[..5]", false],
-["[1..]", false],
-["(1..5", false],
-["[1..5", false],
-["]1..5]", true],
-["[1..5]]", false],
-["[[1..5]]", true],
-["[1..[5]]", true],
-["[(1..2)..3]", false],
-["< [1..5]", false],
-["x in [1..5] = true", false],
-["[if a then 1 else 2..3]", false],
-["[1..if a then 1 else 2]", false],
-["", false],
-["//x", false],
-["/* x */", false],
-["-if a then 1 else 2", false],
-["- f(1)", true],
-["-(1)", true],
-["2 ** - 1", true],
-["x not in (1,2)", false],
-["not x in (1)", false],
-["?.a", true],
-["?[1]", true],
-["x = ?", true],
-["? in (1,2)", true],
-["f(?)", true],
-["x in < 5 and < 6", true],
-["x in (> 5)", true],
-["x in ( )", false],
-["x in (,)", false],
-["x in (1,)", false],
-["x in (1 2)", false],
-["x in [1..5], [6..7]", false],
-["x in -[1]", true],
-["x in not(< 5)", true],
-["x in ?", true],
-["x in [<5]", true],
-["> x", true],
-[">= x and <= y", true],
-["< 5 = true", false],
-["< 5 + 1", true],
-["< -5", true],
-["< < 5", false],
-["<= [1..5]", false],
-["x between < 1 and 2", false],
-["x = < 1", false],
-["x < > 1", false],
-["x in > < 1", false]
+  ["$a", true],
+  ["a$b", true],
+  ["_a", true],
+  ["?", true],
+  ["? > 1", true],
+  ["a?", false],
+  ["\u00e9 > 1", true],
+  ["gr\u00f6\u00dfe > 1", true],
+  ["a-b", true],
+  ["a.b-c", true],
+  ["first name = \"x\"", false],
+  ["a b", false],
+  ["item", true],
+  ["a'b", false],
+  ["a1", true],
+  ["1a", false],
+  ["\u00c4rger", true],
+  ["then", false],
+  ["in", false],
+  ["for", true],
+  ["return", false],
+  ["satisfies", false],
+  ["function", false],
+  ["instance", true],
+  ["of", true],
+  ["between", true],
+  ["some", true],
+  ["every", true],
+  ["not", true],
+  ["external", true],
+  ["x.in", false],
+  ["x.then", false],
+  ["of = 1", true],
+  ["external = 1", true],
+  ["true", true],
+  ["false", true],
+  ["null", true],
+  ["x.for", true],
+  ["string length(\"a\") > 1", true],
+  ["get or else(a, 1)", true],
+  ["date and time(\"2020-01-01T10:00:00\") < now()", true],
+  ["years and months duration(date(\"2020-01-01\"), date(\"2021-01-01\"))", true],
+  ["is defined(a)", true],
+  ["upper case(\"a\")", true],
+  ["day of week(today())", true],
+  ["last day of month(today())", true],
+  ["round half up(1.5, 0)", true],
+  ["list contains([1], 1)", true],
+  ["context put({}, \"a\", 1)", true],
+  ["string join([\"a\"], \",\")", true],
+  ["index of([1], 1)", true],
+  ["distinct values([1])", true],
+  ["get value({a:1}, \"a\")", true],
+  ["substring before(\"ab\", \"b\")", true],
+  ["foo bar(1)", true],
+  ["foo  bar(1)", true],
+  ["foo bar (1)", true],
+  ["a.foo bar(1)", false],
+  ["date and time(\"2020-01-01T10:00:00\")", true],
+  ["days and time duration(\"P1D\")", true],
+  ["x & y", false],
+  ["-x", true],
+  ["- -x", false],
+  ["--x", false],
+  ["x - -1", true],
+  ["+x", false],
+  ["x ** -1", true],
+  ["not x", false],
+  ["not(x, y)", true],
+  ["x in (1, 2)", true],
+  ["x in [1..5]", true],
+  ["x in (1..5]", true],
+  ["x in ]1..5[", true],
+  ["x in > 5", true],
+  ["x in < 5", true],
+  ["x in >= 5, < 10", false],
+  ["x in (> 5, < 1)", true],
+  ["x in null", true],
+  ["x in \"a\"", true],
+  ["x in -", false],
+  ["x in not(1)", true],
+  ["x = [1..5]", false],
+  ["[1..5]", true],
+  ["1..5", false],
+  ["(1..5)", true],
+  ["]1..5[", true],
+  ["[1..5[", true],
+  ["x in [1, 2]", true],
+  ["for i in 1..3 return i", true],
+  ["for i in [1,2], j in [3] return i+j", true],
+  ["every x in xs satisfies x > 1", true],
+  ["some x in xs, y in ys satisfies x = y", true],
+  ["if a then b else if c then d else e", true],
+  ["if a then (if b then c else d) else e", true],
+  ["1 + if a then 1 else 2", false],
+  ["(if a then 1 else 2) + 1", true],
+  ["x between 1 and 5 and y", true],
+  ["x instance of list<number>", false],
+  ["x instance of context<a: number>", false],
+  ["x instance of function<number> -> number", false],
+  ["x instance of date and time", true],
+  ["x instance of days and time duration", true],
+  ["x instance of Any", true],
+  ["x instance of foo", true],
+  ["x instance of string and y", true],
+  ["a < b < c", false],
+  ["a = b = c", false],
+  ["a != b != c", false],
+  ["(a)", true],
+  ["()", false],
+  ["[]", true],
+  ["{}", true],
+  ["{a: 1, b: 2}.b", true],
+  ["{\"a b\": 1}", true],
+  ["{a b: 1}", true],
+  ["{a: 1,}", false],
+  ["[1,2,]", false],
+  ["f(a: 1)", true],
+  ["f(1, b: 2)", false],
+  ["f(,)", false],
+  ["f(a: 1, 2)", false],
+  ["x[1][2]", true],
+  ["x[item > 1].name", true],
+  ["x.y[1]", true],
+  ["f().a", true],
+  ["f()(1)", false],
+  ["function(a, b) a + b", true],
+  ["function(a: number) a", false],
+  ["function() 1", true],
+  ["function(a) external {}", false],
+  ["@\"P1D\"", true],
+  ["@\"2020-01-01\" + @\"P1D\"", true],
+  ["date(\"2020-01-01\") - @\"P1D\"", true],
+  ["1.5", true],
+  [".5", true],
+  ["1.", false],
+  ["1e3", false],
+  ["1_000", false],
+  ["0x10", false],
+  ["\"a\" + \"b\"", true],
+  ["\"a\\\"b\"", true],
+  ["\"a\\nb\"", true],
+  ["\"\\u00e4\"", true],
+  ["\"a\" \"b\"", false],
+  ["x . y", true],
+  ["x..y", false],
+  ["x.1", false],
+  ["x[-1]", true],
+  ["-x[1]", true],
+  ["x ** 2 ** 3", true],
+  ["x * - 1", true],
+  ["x+-1", true],
+  ["true and not(false)", true],
+  ["x != null and y", true],
+  ["x // c", true],
+  ["x /* c */", true],
+  ["/* c */ x", true],
+  ["x # c", false],
+  ["x;", false],
+  ["x,y", false],
+  ["(x, y)", false],
+  ["x ?", false],
+  ["is(a, b)", true],
+  ["x like \"a\"", false],
+  ["x !== 1", false],
+  ["x =< 1", false],
+  ["x => 1", false],
+  ["x -> 1", false],
+  ["not(x) = true", true],
+  ["{a: {b: 1}}.a.b", true],
+  ["{a: 1}[\"a\"]", true],
+  ["\"a\"[1]", true],
+  ["-", false],
+  ["- 1", true],
+  ["* x", false],
+  ["x +", false],
+  ["[1,2] = [1,2]", true],
+  ["x in [1,2,3]", true],
+  ["x in ([1,2])", true],
+  ["x in (1)", true],
+  ["x in ()", false],
+  ["x in []", true],
+  ["x in [1..]", false],
+  ["x in <", false],
+  ["a and b or c and d", true],
+  ["x.y.z = 1", true],
+  ["\"\\t\"", true],
+  ["\"a\\qb\"", true],
+  ["x\ny", false],
+  ["x\n= 1", true],
+  ["x  ", true],
+  ["`a`.`b c`", true],
+  ["`a` + `b`", true],
+  ["``", false],
+  ["x instance of", false],
+  ["x between 1", false],
+  ["x between 1 and", false],
+  ["if x then", false],
+  ["if then else", false],
+  ["some x in xs", false],
+  ["for x in xs", false],
+  ["function(a)", false],
+  ["{a: }", false],
+  ["{: 1}", false],
+  ["{a 1}", false],
+  ["[1 2]", false],
+  ["f(1 2)", false],
+  ["x.", false],
+  [".x", false],
+  ["x.y.", false],
+  ["a[", false],
+  ["a]", false],
+  ["a[]", false],
+  ["a = = 1", false],
+  ["a == b", false],
+  ["and", false],
+  ["a and and b", false],
+  ["or b", false],
+  ["not()", true],
+  ["not(x)(1)", false],
+  ["x[1 > 2, 3]", false],
+  ["abs(-1)", true],
+  ["number(\"1\") + 1", true],
+  ["sum([1,2])", true],
+  ["max(1,2,3)", true],
+  ["< 5", true],
+  ["a and < 5", true],
+  ["> 5 or < 1", true],
+  ["[1..5] and x", true],
+  ["x and [1..5]", true],
+  ["[1..5] + 1", false],
+  ["x = (1..5)", false],
+  ["not(< 5)", true],
+  ["[1..5] = x", false],
+  ["-[1..5]", false],
+  ["x in [1..5] and y", true],
+  ["5", true],
+  ["!= 5", false],
+  ["a or = 5", false],
+  ["(< 5)", true],
+  ["[< 5]", true],
+  ["f(< 5)", true],
+  ["a.b(1)", true],
+  ["f()[1]", true],
+  ["(f)(1)", false],
+  ["x[1](2)", false],
+  ["{f: function() 1}.f()", false],
+  ["a.b.c(1)", true],
+  ["foo bar(1).x", true],
+  ["foo bar(1)[1]", true],
+  ["\"a\"(1)", false],
+  ["f(1).g(2)", false],
+  ["a.b (1)", true],
+  ["a and if x then 1 else 2", false],
+  ["[if a then 1 else 2]", true],
+  ["f(if a then 1 else 2)", true],
+  ["{a: if x then 1 else 2}", true],
+  ["x[if a then 1 else 2]", true],
+  ["if a then 1 else 2 + 3", true],
+  ["if a then for x in y return x else 1", true],
+  ["some x in xs satisfies if x then true else false", true],
+  ["for x in xs return if x then 1 else 2", true],
+  ["function(a) if a then 1 else 2", true],
+  ["x = if a then 1 else 2", false],
+  ["not(if a then true else false)", true],
+  ["for x in if a then [1] else [2] return x", false],
+  ["if a then 1 else 2 and b", true],
+  ["if if a then b else c then 1 else 2", true],
+  ["if (a) then (1) else (2)", true],
+  ["if a then 1 else", false],
+  ["if a else 1", false],
+  ["if a then some x in y satisfies x else 1", true],
+  ["if a then function(x) x else 1", true],
+  ["(if a then 1 else 2)[1]", true],
+  ["(if a then 1 else 2).b", true],
+  ["for x in 1..3, y in xs return x", true],
+  ["for x in xs return x + 1", true],
+  ["for x in xs return x and y", true],
+  ["for i in 1..n return i", true],
+  ["for x in [1..3] return x", false],
+  ["for i in -1..3 return i", true],
+  ["for x in xs.y return x", true],
+  ["for x in xs[item > 1] return x", true],
+  ["for in xs return x", false],
+  ["for x xs return x", false],
+  ["for x in return x", false],
+  ["for x in xs, return x", false],
+  ["for x in xs return", false],
+  ["for x in 1.. return x", false],
+  ["for x in xs return x, y", false],
+  ["for `a b` in xs return `a b`", true],
+  ["for x.y in xs return x", false],
+  ["for x in xs return for y in x return y", true],
+  ["for x in f(1) return x", true],
+  ["for x in 1 + 1..3 return x", true],
+  ["for x in a..b return x", true],
+  ["for x in (1..3) return x", false],
+  ["for x in xs return some y in x satisfies y", true],
+  ["for x in xs return x = 1", true],
+  ["for x in xs return x in (1,2)", true],
+  ["for x in xs return x between 1 and 2", true],
+  ["for some in xs return some", true],
+  ["for if in xs return 1", true],
+  ["for x in xs return x[1]", true],
+  ["some x in [1,2] satisfies x > 1 and true", true],
+  ["every x in xs satisfies x", true],
+  ["some x in xs satisfies", false],
+  ["some x in 1..3 satisfies x > 1", true],
+  ["some in xs satisfies x", false],
+  ["some x in xs, y in ys satisfies x and y", true],
+  ["every x in xs satisfies some y in x satisfies y", true],
+  ["some x in xs satisfies x or y", true],
+  ["some x in xs satisfies x = 1", true],
+  ["every x in xs satisfies for y in x return y", true],
+  ["some x in (1,2) satisfies x", false],
+  ["x between a + 1 and b * 2", true],
+  ["x between 1 and 2 = true", false],
+  ["x between (1) and (2)", true],
+  ["x between y between 1 and 2 and 3", false],
+  ["x between 1 and 2 or y", true],
+  ["x between - 1 and 2", true],
+  ["x between if a then 1 else 2 and 3", false],
+  ["x between 1 and 2 and 3", true],
+  ["x in y", true],
+  ["x in y.z", true],
+  ["x in f(1)", true],
+  ["x in [a, b]", true],
+  ["x in (a)", true],
+  ["x in (< 1, > 5, 3)", true],
+  ["x in [1..5], 7", false],
+  ["x in \"a\", \"b\"", false],
+  ["x in = 1", false],
+  ["x in != 1", false],
+  ["x in < f(1)", true],
+  ["x in - 1", true],
+  ["x in (-1, 1)", true],
+  ["x in ((1,2))", false],
+  ["x in null, 1", false],
+  ["x in (1..5), (6..7)", false],
+  ["x in ]1..5]", true],
+  ["x in [1..5)", true],
+  ["x in [a..b]", true],
+  ["x in [1 .. 5]", true],
+  ["x in [1..5].x", false],
+  ["x in [1, 2] = true", true],
+  ["x in > 5 and y", true],
+  ["x in ? > 1", true],
+  ["x in (1, [2..3], > 4)", true],
+  ["x in a + 1", true],
+  ["x in (a + 1, b)", true],
+  ["x in -1", true],
+  ["x in ([1..2])", true],
+  ["x in [1..2] or y", true],
+  ["x in {}", true],
+  ["x in @\"P1D\"", true],
+  ["x in date(\"2020-01-01\")", true],
+  ["x in (not(1))", true],
+  ["x in (1, 2) and x in (3)", true],
+  ["x in y in z", true],
+  ["x in 1 = 2", true],
+  ["x in (1) = true", false],
+  ["x instance of number = true", false],
+  ["x instance of a.b", true],
+  ["x instance of null", false],
+  ["x instance of 1", false],
+  ["x instance of \"s\"", false],
+  ["x instance of years and months duration", true],
+  ["x instance of date", true],
+  ["x instance of time", true],
+  ["x instance of string or y", true],
+  ["x instance of list", true],
+  ["x instance of context", true],
+  ["x instance of function", true],
+  ["x instance of instance", true],
+  ["x instance of then", false],
+  ["x instance of `a b`", true],
+  ["x instance  of number", true],
+  ["x instanceof number", true],
+  ["x instance of number and", false],
+  ["x instance of foo bar", false],
+  ["x instance of date and", false],
+  ["x instance of date and y", true],
+  ["{\"a\": 1}", true],
+  ["{a: 1, \"b\": 2}", true],
+  ["{a: 1}.a + 1", true],
+  ["{a.b: 1}", true],
+  ["{1: 2}", true],
+  ["{a-b: 1}", true],
+  ["{a: 1, a: 2}", true],
+  ["{a: 1 b: 2}", false],
+  ["{a : 1}", true],
+  ["{ a b c: 1}", true],
+  ["{if: 1}", true],
+  ["{then: 1}", true],
+  ["{function: 1}", true],
+  ["{and: 1}", true],
+  ["{in: 1}", true],
+  ["{`a`: 1}", true],
+  ["{a: function(x) x}.a(1)", false],
+  ["{a: 1}.`a`", true],
+  ["{a: {}}", true],
+  ["{a: []}", true],
+  ["{a: [1, {b: 2}]}", true],
+  ["{a: 1, b: a + 1}", true],
+  ["{a: some x in y satisfies x}", true],
+  ["{a?: 1}", true],
+  ["{$a: 1}", true],
+  ["{\"\": 1}", true],
+  ["{a: 1}.b.c", true],
+  ["{a: 1}{b: 2}", false],
+  ["[1, [2, 3]]", true],
+  ["[a, b][1]", true],
+  ["[1, 2].x", true],
+  ["[ ]", true],
+  ["[,]", false],
+  ["[1,,2]", false],
+  ["[1..2, 3]", false],
+  ["[for x in y return x]", true],
+  ["[some x in y satisfies x]", true],
+  ["[x in (1,2)]", true],
+  ["[x between 1 and 2]", true],
+  ["[a = 1, b != 2]", true],
+  ["function(a, b) a", true],
+  ["function(a,) a", false],
+  ["function(1) a", false],
+  ["function(a b) a", true],
+  ["function(a) function(b) a + b", true],
+  ["(function(a) a)(1)", false],
+  ["function (a) a", true],
+  ["function(`a b`) 1", true],
+  ["function(a, a) a", true],
+  ["x + function(a) a", true],
+  ["[function(a) a]", true],
+  ["f(function(a) a)", true],
+  ["function(a) a and b", true],
+  ["function(a) a = 1", true],
+  ["function(if) 1", true],
+  ["function(a) for x in a return x", true],
+  ["function() function() 1", true],
+  ["function(a) a, 1", false],
+  ["xs[item.a > 1]", true],
+  ["xs[a > 1 and b]", true],
+  ["xs[for x in y return x]", true],
+  ["xs[some x in y satisfies x]", true],
+  ["xs[x in (1,2)]", true],
+  ["xs[x between 1 and 2]", true],
+  ["xs[< 5]", true],
+  ["xs[1][item > 2].a[3]", true],
+  ["xs[1].a.b[2]", true],
+  ["xs [1]", true],
+  ["xs.a [1]", true],
+  ["@\"x\"", true],
+  ["@x", false],
+  ["@ \"P1D\"", true],
+  ["@\"P1D\".days", true],
+  ["date(\"2020-01-01\").year", true],
+  ["\"a\".b", true],
+  ["1.b", true],
+  ["[1,2].a", true],
+  ["(a).b", true],
+  ["(a)[1]", true],
+  ["(a)(1)", false],
+  ["-a.b", true],
+  ["true.a", true],
+  ["null.a", true],
+  ["true(1)", false],
+  ["null(1)", false],
+  ["1(2)", false],
+  ["\"a\" \"b\" \"c\"", false],
+  ["gr\u00f6\u00dfe.l\u00e4nge", true],
+  ["\u540d\u524d = 1", true],
+  ["a\u00b7b", false],
+  ["a\u20ac", true],
+  ["a\u203fb", true],
+  ["a\u00a0b", false],
+  ["\u2603 = 1", false],
+  ["x\u00b2 = 1", false],
+  ["\u03b1\u03b2 = 1", true],
+  ["a\u0301 = 1", true],
+  ["\"line1\nline2\"", true],
+  ["\"\\u12\"", true],
+  ["\"\\\"", false],
+  ["\"\\\\\"", true],
+  ["\"it's\"", true],
+  ["\"\\'\"", true],
+  ["a ** b ** c", true],
+  ["a / b / c", true],
+  ["a * b / c - d + e", true],
+  ["a - - - b", false],
+  ["a -- b", true],
+  ["a + + b", false],
+  ["a+ +b", false],
+  ["a */ b", false],
+  ["a ^ b", false],
+  ["a mod b", false],
+  ["a div b", false],
+  ["a % b", false],
+  ["a >= b", true],
+  ["a <= b", true],
+  ["a ! = b", false],
+  ["a = ! b", false],
+  ["a < = b", false],
+  ["a* *b", false],
+  ["not(a) and not(b)", true],
+  ["a and not b", false],
+  ["true or false and true", true],
+  ["a and (b or c)", true],
+  ["a or", false],
+  ["a = null", true],
+  ["null = a", true],
+  ["a = -1", true],
+  ["a = - b", true],
+  ["a < -b", true],
+  ["a * -b", true],
+  ["a ** -b", true],
+  ["-a ** 2", true],
+  ["- a * b", true],
+  ["a - b - c", true],
+  ["x.some", true],
+  ["x.every", true],
+  ["x.instance", true],
+  ["x.of", true],
+  ["x.between", true],
+  ["x.not", true],
+  ["x.external", true],
+  ["x.true", false],
+  ["x.null", false],
+  ["x.if", true],
+  ["x.else", false],
+  ["x.and", false],
+  ["x.or", false],
+  ["x.function", false],
+  ["x.return", false],
+  ["x.satisfies", false],
+  ["if", true],
+  ["else", false],
+  ["true = 1", true],
+  ["if = 1", true],
+  ["if(1)", true],
+  ["then(1)", false],
+  ["and(true)", true],
+  ["or(true)", true],
+  ["in(1)", false],
+  ["for(1)", true],
+  ["some(1)", true],
+  ["every(1)", true],
+  ["instance(1)", true],
+  ["between(1)", true],
+  ["return(1)", false],
+  ["satisfies(1)", false],
+  ["external(1)", true],
+  ["not(1)", true],
+  ["else(1)", false],
+  ["of(1)", true],
+  ["foo then bar(1)", false],
+  ["a if b(1)", true],
+  ["x instance of y(1)", true],
+  ["foo else bar(1)", false],
+  ["foo return bar(1)", false],
+  ["foo satisfies bar(1)", false],
+  ["foo in bar(1)", true],
+  ["foo for bar(1)", true],
+  ["foo function bar(1)", false],
+  ["a b c d(1)", true],
+  ["a 1(2)", false],
+  ["a \"b\"(1)", false],
+  ["string length (\"a\")", true],
+  ["string  length(\"a\")", true],
+  ["string\nlength(\"a\")", false],
+  ["a.string length(\"a\")", false],
+  ["string length", false],
+  ["string length = 1", false],
+  ["get or else", false],
+  ["x = get or else(a, 1)", true],
+  ["x andy", true],
+  ["x ory", true],
+  ["ifx then 1 else 2", true],
+  ["x between1 and 2", true],
+  ["x in(1,2)", true],
+  ["x instance ofnumber", true],
+  ["for x in y returnx", true],
+  ["some x in y satisfiesx", true],
+  ["x and(y)", true],
+  ["x or(y)", true],
+  ["not(x)and y", true],
+  ["1and 2", true],
+  ["x=1", true],
+  ["x>1and y<2", true],
+  ["if(a)then(1)else(2)", true],
+  ["for x in(y)return x", true],
+  ["x between(1)and(2)", true],
+  ["x in[1,2]", true],
+  ["x and\"a\"", true],
+  ["\"a\"and x", true],
+  ["x and[1]", true],
+  ["[1]and x", true],
+  ["x instanceof", true],
+  ["x elsey", false],
+  ["xin y", false],
+  ["x iny", true],
+  ["x in if a then [1] else [2]", true],
+  ["x in some y in z satisfies y", true],
+  ["x in for y in z return y", true],
+  ["x in function() 1", true],
+  ["x = y in z", false],
+  ["x in y = z", true],
+  ["x + for y in z return y", false],
+  ["x + some y in z satisfies y", false],
+  ["x and for y in z return y", false],
+  ["not(for x in y return x)", true],
+  ["x and some y in z satisfies y", false],
+  ["x or if a then b else c", false],
+  ["x and function(a) a", true],
+  ["-function(a) a", true],
+  ["x between function() 1 and 2", false],
+  ["foo true bar(1)", false],
+  ["foo null bar(1)", false],
+  ["foo between bar(1)", true],
+  ["foo instance bar(1)", true],
+  ["foo of bar(1)", true],
+  ["foo some bar(1)", true],
+  ["foo not bar(1)", true],
+  ["foo external bar(1)", true],
+  ["foo if bar(1)", true],
+  ["foo every bar(1)", true],
+  ["if foo(1)", true],
+  ["not foo(1)", true],
+  ["x y.z(1)", false],
+  ["foo bar.baz(1)", false],
+  ["foo `bar`(1)", false],
+  ["foo and bar(1) = 1", true],
+  ["1 foo(1)", false],
+  ["foo bar(1) foo(2)", false],
+  ["some foo(1)", true],
+  ["every foo(1)", true],
+  ["for foo(1)", true],
+  ["between foo(1)", true],
+  ["foo in(1)", true],
+  ["foo and(1)", true],
+  ["foo or(1)", true],
+  ["foo bar baz", false],
+  ["? foo(1)", false],
+  ["foo ?(1)", false],
+  ["foo $(1)", true],
+  ["$ foo(1)", true],
+  ["foo - bar(1)", true],
+  ["\u20aca = 1", true],
+  ["_ = 1", true],
+  ["a\u200db = 1", true],
+  ["\u216b = 1", true],
+  ["a\u0663 = 1", true],
+  ["\u0663a = 1", false],
+  ["ab\u00ad = 1", true],
+  ["a\u0301b = 1", true],
+  ["\u0301a = 1", false],
+  ["a\u00b7", false],
+  ["\u00b7a", false],
+  ["a\u2019b", false],
+  ["\u201ca\u201d", false],
+  ["a_b", true],
+  ["__", true],
+  ["$", true],
+  ["$$ = 1", true],
+  ["a$", true],
+  ["\u20ac", true],
+  ["\u203f", true],
+  ["a\u2003= 1", true],
+  ["a\u3000= 1", true],
+  ["\ufeffa", true],
+  ["a\r\n= 1", true],
+  ["a\t= 1", true],
+  ["a\u0085= 1", true],
+  ["a\u2028= 1", true],
+  ["x instance of date and time and y", true],
+  ["x instance of days and time duration = 1", false],
+  ["x instance of years and months duration or y", true],
+  ["x instance of date and time.a", false],
+  ["x instance of a.b.c", true],
+  ["x instance of `a b`.c", true],
+  ["(f)", true],
+  ["f.g.h", true],
+  ["f(a: 1, b: 2)", true],
+  ["f(a: 1, a: 2)", true],
+  ["f(a b: 1)", true],
+  ["f(\"a\": 1)", false],
+  ["f(1: 2)", false],
+  ["f(if: 1)", true],
+  ["f(a: 1,)", false],
+  ["{a: 1}.a(1)", false],
+  ["a.b(1)(2)", false],
+  ["a(1).b", true],
+  ["a(1).b(2)", false],
+  ["a(1)[1].b", true],
+  ["f( )", true],
+  ["f(a: if x then 1 else 2)", true],
+  ["f(a: < 5)", true],
+  ["f(a:1)", true],
+  ["f(a :1)", true],
+  ["f(then: 1)", false],
+  ["f(function: 1)", false],
+  ["f(`a b`: 1)", true],
+  ["f(a.b: 1)", false],
+  ["[1 ..5]", true],
+  ["[ 1..5 ]", true],
+  ["[a.b..c]", true],
+  ["[f(1)..2]", true],
+  ["[-1..-5]", true],
+  ["[1..5] or [6..7]", true],
+  ["(1..5] and x", true],
+  ["[1..5] and [6..7] or (8..9)", true],
+  ["[1..x + 1]", true],
+  ["[x[1]..2]", true],
+  ["[1..2..3]", false],
+  ["[..5]", false],
+  ["[1..]", false],
+  ["(1..5", false],
+  ["[1..5", false],
+  ["]1..5]", true],
+  ["[1..5]]", false],
+  ["[[1..5]]", true],
+  ["[1..[5]]", true],
+  ["[(1..2)..3]", false],
+  ["< [1..5]", false],
+  ["x in [1..5] = true", false],
+  ["[if a then 1 else 2..3]", false],
+  ["[1..if a then 1 else 2]", false],
+  ["", false],
+  ["//x", false],
+  ["/* x */", false],
+  ["-if a then 1 else 2", false],
+  ["- f(1)", true],
+  ["-(1)", true],
+  ["2 ** - 1", true],
+  ["x not in (1,2)", false],
+  ["not x in (1)", false],
+  ["?.a", true],
+  ["?[1]", true],
+  ["x = ?", true],
+  ["? in (1,2)", true],
+  ["f(?)", true],
+  ["x in < 5 and < 6", true],
+  ["x in (> 5)", true],
+  ["x in ( )", false],
+  ["x in (,)", false],
+  ["x in (1,)", false],
+  ["x in (1 2)", false],
+  ["x in [1..5], [6..7]", false],
+  ["x in -[1]", true],
+  ["x in not(< 5)", true],
+  ["x in ?", true],
+  ["x in [<5]", true],
+  ["> x", true],
+  [">= x and <= y", true],
+  ["< 5 = true", false],
+  ["< 5 + 1", true],
+  ["< -5", true],
+  ["< < 5", false],
+  ["<= [1..5]", false],
+  ["x between < 1 and 2", false],
+  ["x = < 1", false],
+  ["x < > 1", false],
+  ["x in > < 1", false]
 ]
diff --git a/test/helpers/engine-model.ts b/test/helpers/engine-model.ts
new file mode 100644
index 00000000..59a49625
--- /dev/null
+++ b/test/helpers/engine-model.ts
@@ -0,0 +1,123 @@
+import Linter from 'bpmnlint/lib/linter.js';
+import { createModdle } from 'bpmnlint/lib/testers/helper.js';
+import { describe, expect, it } from 'vitest';
+import { ENGINE_KIT } from '../../src/adapters/out/bpmnlint/engine-kit.js';
+import { RuleKit } from '../../src/adapters/out/bpmnlint/engine/rules/RuleKit.js';
+import type { DeclaredRuleFactory } from '@miragon/bpmnlint-plugin-rules/engine';
+import type { Engine } from '@miragon/bpmnlint-plugin-rules/engine';
+import { moddleExtensions as camundaModdle } from '@miragon/bpmnlint-plugin-rules/camunda-7';
+import { moddleExtensions as zeebeModdle } from '@miragon/bpmnlint-plugin-rules/camunda-8';
+
+RuleKit.use(ENGINE_KIT);
+
+const ENGINES: Record<
+  Engine,
+  { platform: string; version: string; namespace: string; moddle: Record<string, unknown> }
+> = {
+  c7: {
+    platform: 'Camunda Platform',
+    version: '7.24.0',
+    namespace: 'xmlns:camunda="http://camunda.org/schema/1.0/bpmn"',
+    moddle: camundaModdle,
+  },
+  c8: {
+    platform: 'Camunda Cloud',
+    version: '8.10.0',
+    namespace: 'xmlns:zeebe="http://camunda.org/schema/zeebe/1.0"',
+    moddle: zeebeModdle,
+  },
+};
+
+export interface EngineModelOptions {
+  /** `modeler:executionPlatformVersion`, e.g. `8.9.0`. Defaults to the latest. */
+  version?: string;
+  /** Root elements next to the process (`<bpmn:message>`, `<bpmn:error>`, ...). */
+  roots?: string;
+  /** Attributes of the process; `isExecutable="true"` unless given. */
+  processAttributes?: string;
+  /** Extra attributes or namespace declarations on `bpmn:definitions`. */
+  definitionsAttributes?: string;
+}
+
+/**
+ * A diagram for an engine rule spec: `bpmn:definitions` that target `engine` (execution platform,
+ * version and vendor namespace), one executable process holding `processContent`, parsed with the
+ * engine's moddle extension as a host lints it. No DI: engine rules read the semantic tree only.
+ */
+export function engineModel(
+  engine: Engine,
+  processContent: string,
+  options: EngineModelOptions = {},
+) {
+  const { platform, version, namespace, moddle } = ENGINES[engine];
+  return createModdle(
+    `<?xml version="1.0" encoding="UTF-8"?>
+<bpmn:definitions xmlns:bpmn="http://www.omg.org/spec/BPMN/20100524/MODEL"
+    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+    xmlns:modeler="http://camunda.org/schema/modeler/1.0" ${namespace}
+    modeler:executionPlatform="${platform}"
+    modeler:executionPlatformVersion="${options.version ?? version}"
+    ${options.definitionsAttributes ?? ''}
+    id="definitions_test" targetNamespace="http://bpmn.io/schema/bpmn">
+  <bpmn:process id="process_test" ${options.processAttributes ?? 'isExecutable="true"'}>
+    ${processContent}
+  </bpmn:process>
+  ${options.roots ?? ''}
+</bpmn:definitions>`,
+    moddle,
+  );
+}
+
+/** What an engine rule spec expects of one report; `type` is the report's `data.type`. */
+export interface ExpectedEngineReport {
+  id: string;
+  message: string;
+  path?: (string | number)[];
+  type: string;
+}
+
+export interface EngineRuleCase {
+  name: string;
+  moddleElement: ReturnType<typeof engineModel>;
+  config?: Record<string, unknown>;
+}
+
+/**
+ * bpmnlint's `verify` for an engine rule, comparing what a host reads of its reports: element,
+ * message, path and `data.type`, but not the moddle objects camunda-compat puts in `data`.
+ */
+export function verifyEngineRule(
+  rule: DeclaredRuleFactory,
+  cases: {
+    valid: EngineRuleCase[];
+    invalid: Array<EngineRuleCase & { report: ExpectedEngineReport | ExpectedEngineReport[] }>;
+  },
+) {
+  const lint = async ({ moddleElement, config = {} }: EngineRuleCase) => {
+    const linter = new Linter({
+      resolver: { resolveRule: () => rule, resolveConfig: () => undefined },
+    });
+    const { root } = await moddleElement;
+    const reports = await linter.lint(root, { rules: { [rule.ruleName]: ['error', config] } });
+    return (reports[rule.ruleName] ?? []).map((report: any) => ({
+      id: report.id,
+      message: report.message,
+      ...(report.path ? { path: report.path } : {}),
+      type: report.data?.type,
+    }));
+  };
+
+  describe(`rules/${rule.ruleName}`, () => {
+    for (const testCase of cases.valid) {
+      it(`valid: ${testCase.name}`, async () => {
+        expect(await lint(testCase)).toEqual([]);
+      });
+    }
+    for (const testCase of cases.invalid) {
+      it(`invalid: ${testCase.name}`, async () => {
+        const expected = Array.isArray(testCase.report) ? testCase.report : [testCase.report];
+        expect(await lint(testCase)).toEqual(expected);
+      });
+    }
+  });
+}
diff --git a/test/helpers/engine.ts b/test/helpers/engine.ts
new file mode 100644
index 00000000..19d42465
--- /dev/null
+++ b/test/helpers/engine.ts
@@ -0,0 +1,20 @@
+import type { Doc } from '../../src/domain/document/Doc.js';
+import type { PlatformChoice } from '../../src/domain/document/vendor/PlatformDetection.js';
+import { PlatformCheck, type ProfileReport } from '../../src/domain/validation/PlatformCheck.js';
+import { BpmnlintEngineLint } from '../../src/adapters/out/bpmnlint/BpmnlintEngineLint.js';
+import { StructuralValidator, type ValidationResult } from '../../src/domain/validation/StructuralValidator.js';
+
+const ENGINE = new BpmnlintEngineLint();
+
+/** The engine findings of a document on their own, as checkDoc and every write compute them. */
+export function runProfile(doc: Doc, choice?: PlatformChoice): Promise<ProfileReport> {
+  return new PlatformCheck(ENGINE).run(doc, choice);
+}
+
+/** The structure, and with a `platform` the engine findings, of a document, as `bpmn validate` reports them without validators. */
+export async function validateWithEngine(doc: Doc, opts: { platform?: PlatformChoice } = {}): Promise<ValidationResult> {
+  const structure = new StructuralValidator(doc);
+  if (opts.platform === undefined) return structure.validate();
+  const report = await runProfile(doc, opts.platform);
+  return structure.withProfile(structure.validate(), report, report.findings);
+}
diff --git a/test/helpers/helpers.ts b/test/helpers/helpers.ts
index 53374c1e..51750d25 100644
--- a/test/helpers/helpers.ts
+++ b/test/helpers/helpers.ts
@@ -2,6 +2,7 @@ import { Doc } from '../../src/domain/document/Doc.js';
 import type { CliUseCases } from '../../src/adapters/in/cli/Cli.js';
 import { BpmnlintProjectSettings } from '../../src/adapters/out/files/BpmnlintProjectSettings.js';
 import { FileDocumentStore } from '../../src/adapters/out/files/FileDocumentStore.js';
+import { BpmnlintEngineLint } from '../../src/adapters/out/bpmnlint/BpmnlintEngineLint.js';
 import { FileImageWriter } from '../../src/adapters/out/files/FileImageWriter.js';
 import { SvgRenderer } from '../../src/adapters/out/render/SvgRenderer.js';
 import { EditDocumentService } from '../../src/application/service/EditDocumentService.js';
@@ -18,13 +19,14 @@ import { RunCommandsService } from '../../src/application/service/RunCommandsSer
 
 const files = new FileDocumentStore();
 const project = new BpmnlintProjectSettings();
+const engine = new BpmnlintEngineLint();
 
 /** The use cases on the file system, as src/cli.ts wires them. */
 export const FILE_USE_CASES: CliUseCases = {
-  editDocument: new EditDocumentService(project, files),
-  createDocument: new CreateDocumentService(project, files),
-  relayoutDiagram: new RelayoutDiagramService(project, files),
-  validateDocument: new ValidateDocumentService(project, files),
+  editDocument: new EditDocumentService(project, files, engine),
+  createDocument: new CreateDocumentService(project, files, engine),
+  relayoutDiagram: new RelayoutDiagramService(project, files, engine),
+  validateDocument: new ValidateDocumentService(project, files, engine),
   readDocument: new ReadDocumentService(files),
   showModel: new ShowModelService(),
   showConventions: new ShowConventionsService(project),
diff --git a/tools/iso/budget.json b/tools/iso/budget.json
index 77730d60..86909a5a 100644
--- a/tools/iso/budget.json
+++ b/tools/iso/budget.json
@@ -1,10 +1,26 @@
 {
   "entries": {
-    "whole entry": { "minified": 1112, "gzip": 347 },
-    "applyToXml only": { "minified": 802, "gzip": 251 }
+    "whole entry": {
+      "minified": 1068,
+      "gzip": 336
+    },
+    "applyToXml only": {
+      "minified": 776,
+      "gzip": 243
+    }
   },
   "onDemand": {
-    "c7": { "minified": 65, "gzip": 19 },
-    "c8": { "minified": 89, "gzip": 25.5 }
+    "c7": {
+      "minified": 127,
+      "gzip": 36
+    },
+    "c8": {
+      "minified": 370,
+      "gzip": 103
+    },
+    "engine": {
+      "minified": 27,
+      "gzip": 11
+    }
   }
 }
diff --git a/tools/iso/bundle.mjs b/tools/iso/bundle.mjs
index 975bd00d..d8f7f00c 100644
--- a/tools/iso/bundle.mjs
+++ b/tools/iso/bundle.mjs
@@ -43,10 +43,23 @@ export const ROOT = join(dirname(fileURLToPath(import.meta.url)), '..', '..');
 /** Globals a browser does not have (globalThis, setTimeout, TextEncoder, URL, ... are fine). */
 export const NODE_GLOBALS = ['process', 'Buffer', 'global', 'require', '__dirname', '__filename', 'setImmediate', 'clearImmediate'];
 
+/**
+ * `require` is not replaced: esbuild bundles the require calls of a CommonJS package (bpmnlint,
+ * camunda-compat) itself. One it cannot resolve becomes its `__require` shim, which throws in a
+ * browser; that shim is the violation.
+ */
+const DEFINED_GLOBALS = NODE_GLOBALS.filter((globalName) => globalName !== 'require');
+
+/**
+ * Packages of the Camunda 8 rules (camunda-compat's FEEL parser) that read `process` only behind
+ * `typeof process != 'undefined'`, for a debug switch: in a browser the read is never made.
+ */
+const GUARDED = new Set(['node_modules/@lezer/lr/dist/index.js', 'node_modules/@bpmn-io/lezer-feel/dist/index.js', 'node_modules/@bpmn-io/semver-compat/dist/index.js']);
+
 const SENTINEL = '__ISO_NODE_GLOBAL_';
 
 function esbuildOptions(opts, minify) {
-  const define = Object.fromEntries(NODE_GLOBALS.map((globalName) => [globalName, `${SENTINEL}${globalName}`]));
+  const define = Object.fromEntries(DEFINED_GLOBALS.map((globalName) => [globalName, `${SENTINEL}${globalName}`]));
   return {
     ...(opts.stdin ? { stdin: { loader: 'ts', resolveDir: ROOT, ...opts.stdin } } : { entryPoints: [join(ROOT, opts.entry ?? join('src', 'index.ts'))] }),
     bundle: true,
@@ -77,12 +90,14 @@ function globalViolations(code) {
   const marks = moduleMarks(code);
   const seen = new Set();
   const out = [];
-  for (const match of code.matchAll(new RegExp(`${SENTINEL}(\\w+)`, 'g'))) {
+  for (const match of code.matchAll(new RegExp(`${SENTINEL}(\\w+)|\\b__require\\((?!\\s*\\))`, 'g'))) {
     const file = [...marks].reverse().find((mark) => mark.at < match.index)?.file ?? '?';
-    const key = `${match[1]}|${file}`;
+    const what = match[1] ?? 'require';
+    if (what === 'process' && GUARDED.has(file)) continue;
+    const key = `${what}|${file}`;
     if (seen.has(key)) continue;
     seen.add(key);
-    out.push({ kind: 'global', what: match[1], file });
+    out.push({ kind: 'global', what, file });
   }
   return out;
 }
diff --git a/tools/iso/check.mjs b/tools/iso/check.mjs
index d4e00224..54b9413a 100644
--- a/tools/iso/check.mjs
+++ b/tools/iso/check.mjs
@@ -11,15 +11,18 @@
  *    Buffer, global, require, __dirname, ...), naming the module;
  *  - the bundle contains the adapters (dist/adapters/), the node entry (dist/node.js) or the CLI (dist/cli.js);
  *  - a module of the engine rules that load on demand (ON_DEMAND: the
- *    Camunda 7 and Camunda 8 profile, src/domain/validation/profiles/PlatformProfiles.ts LOADERS) is
+ *    Camunda 7 and Camunda 8 rules in src/adapters/out/bpmnlint/engine/rules/,
+ *    bpmnlint's linter and the engine run in src/adapters/out/bpmnlint/engine/run/,
+ *    src/adapters/out/bpmnlint/BpmnlintEngineLint.ts LOADERS) is
  *    in the initial chunks of the whole entry or of the applyToXml-only
  *    entry, naming the module, or is no chunk of its own;
- *  - a module of those rules imports (statically, also through another
- *    rule module) a module the entry loads, naming both: Rollup / Vite put
- *    such a module into the host's entry chunk and make the rule chunk
- *    import the entry chunk back, so a host whose entry module awaits a
- *    Camunda 7 / 8 call at top level would wait forever (the rules get
- *    what they use of the core from src/domain/validation/profiles/rule-kit.ts instead);
+ *  - a module of bpmn-cli (dist/) the rules reach imports a module the entry
+ *    loads, naming both: the engine run and the rules get what they use of the core from
+ *    src/adapters/out/bpmnlint/engine-kit.ts (ENGINE_KIT) instead. The rules'
+ *    packages share packages with the core (min-dash): Rollup / Vite put
+ *    those into the entry chunk and make the rule chunk import it back, so a
+ *    host must not await a Camunda 7 / 8 call at the top level of its entry
+ *    module (docs/library.md);
  *  - a size is over its budget in tools/iso/budget.json (KB = 1024 bytes,
  *    minified and gzip: the initial chunks of both entries, the on-demand
  *    rule chunks of both); raising a budget is an explicit diff of that file;
@@ -47,9 +50,12 @@ const table = process.argv.includes('--table');
 const problems = [];
 
 /** What loads on demand, by the module that marks its chunk; `rules`: modules that must never be in the initial chunks. */
+const RULES = 'dist/adapters/out/bpmnlint/engine/rules';
+const ENGINE_RUN = ['EngineRun', 'EngineFindings', 'EngineCodes', 'EngineHint', 'CompatVerdicts'].map((name) => `dist/adapters/out/bpmnlint/engine/run/${name}.js`);
 const ON_DEMAND = [
-  { name: 'c7', label: 'Camunda 7 rules', marker: 'dist/domain/validation/profiles/C7Profile.js', rules: ['dist/domain/validation/profiles/C7Profile.js', 'dist/domain/validation/profiles/EngineProfile.js', 'dist/domain/validation/profiles/EngineRules.js', 'dist/domain/validation/profiles/RuleRun.js', 'dist/domain/validation/utils/value.js', 'dist/domain/validation/profiles/c7/C7DescriptorNames.js', 'dist/domain/validation/profiles/c7/C7EventRules.js', 'dist/domain/validation/profiles/c7/C7ExtensionContentRules.js', 'dist/domain/validation/profiles/c7/C7ExtensionRules.js', 'dist/domain/validation/profiles/c7/C7FlowRules.js', 'dist/domain/validation/profiles/c7/C7ImplementationRules.js', 'dist/domain/validation/profiles/c7/C7Rules.js', 'dist/domain/validation/profiles/c7/C7SchemaRules.js', 'dist/domain/validation/utils/c7-hint.js', 'dist/domain/validation/utils/element.js', 'dist/domain/validation/utils/hint.js'], when: "the first Camunda 7 document a call validates (`loadProfile('c7')` prefetches it)" },
-  { name: 'c8', label: 'Camunda 8 rules', marker: 'dist/domain/validation/profiles/C8Profile.js', rules: ['dist/domain/validation/profiles/C8Profile.js', 'dist/domain/validation/profiles/EngineProfile.js', 'dist/domain/validation/profiles/EngineRules.js', 'dist/domain/validation/profiles/RuleRun.js', 'dist/domain/validation/utils/value.js', 'dist/domain/validation/profiles/c8/C8EventRules.js', 'dist/domain/validation/profiles/c8/C8ExtensionRules.js', 'dist/domain/validation/profiles/c8/C8FlowRules.js', 'dist/domain/validation/profiles/c8/C8Rules.js', 'dist/domain/validation/profiles/c8/C8SchemaRules.js', 'dist/domain/validation/profiles/c8/C8TaskRules.js', 'dist/domain/validation/utils/c8-value.js', 'dist/domain/validation/utils/element.js', 'dist/domain/validation/utils/hint.js', 'dist/domain/validation/profiles/FeelExpression.js', 'dist/domain/validation/profiles/FeelParser.js', 'dist/domain/validation/profiles/FeelError.js', 'dist/domain/validation/profiles/TimerValue.js', 'dist/domain/validation/profiles/SchemaText.js', 'dist/domain/validation/profiles/BpmnSchema.js'], when: "the first Camunda 8 document a call validates (`loadProfile('c8')` prefetches it)" },
+  { name: 'c7', label: 'Camunda 7 rules', marker: `${RULES}/c7/Camunda7Rules.js`, rules: [`${RULES}/c7/Camunda7Rules.js`], when: 'the first Camunda 7 document a call validates' },
+  { name: 'c8', label: 'Camunda 8 rules', marker: `${RULES}/c8/Camunda8Rules.js`, rules: [`${RULES}/c8/Camunda8Rules.js`], when: 'the first Camunda 8 document a call validates' },
+  { name: 'engine', label: 'engine run (bpmnlint and the mapping to W_C7_* / W_C8_*)', marker: ENGINE_RUN[0], rules: [...ENGINE_RUN, 'node_modules/bpmnlint/lib/linter.js'], when: 'the first Camunda 7 or 8 document a call validates' },
 ];
 const ENTRIES = [
   { key: 'core', label: 'whole entry', name: 'the whole entry', title: 'everything `@miragon/bpmn-cli` exports' },
@@ -99,10 +105,9 @@ for (const [sub, file] of Object.entries(expected)) {
 }
 
 /* 4. a strict consumer of the published types (outside the repository, the package linked by name) */
-const CONSUMER = `import { applyToXml, loadProfile, newXml, renderSvg, validateXml, viewXml, type EditResult, type RenderResult } from '@miragon/bpmn-cli';
+const CONSUMER = `import { applyToXml, newXml, renderSvg, validateXml, viewXml, type EditResult, type RenderResult } from '@miragon/bpmn-cli';
 import { mutateFile, renderPng, type FileMutationOptions, type PngRenderResult } from '@miragon/bpmn-cli/node';
 export async function demo(): Promise<string> {
-  await loadProfile('c7');
   const created: EditResult = await newXml({ processName: 'Order' });
   const edited = await applyToXml(created.xml, [{ op: 'add', kind: 'start', name: 'Received' }], { layout: 'auto' });
   const report = await validateXml(edited.xml, { platform: 'auto' });
@@ -168,7 +173,7 @@ function sizeOf(bundle) {
     return seen;
   };
   const entryModules = reach(bundle.entry.entryPoint);
-  const importsOfEntry = (marker) => [...reach(marker)].filter((modulePath) => !entryModules.has(modulePath)).flatMap((modulePath) => bundle.graph[modulePath].filter((imported) => entryModules.has(imported)).map((imported) => ({ from: modulePath, to: imported })));
+  const importsOfEntry = (marker) => [...reach(marker)].filter((modulePath) => !entryModules.has(modulePath) && modulePath.startsWith('dist/')).flatMap((modulePath) => bundle.graph[modulePath].filter((imported) => entryModules.has(imported)).map((imported) => ({ from: modulePath, to: imported })));
   const sum = (chunks) => ({ bytes: [...chunks].reduce((total, chunk) => total + chunk.bytes, 0), gzip: [...chunks].reduce((total, chunk) => total + chunk.gzip, 0) });
   const lazy = bundle.chunks.filter((chunk) => !initial.has(chunk));
   const counted = new Set();
@@ -210,14 +215,11 @@ for (const entry of ENTRIES) {
   for (const part of ON_DEMAND) {
     for (const rule of part.rules) {
       if (entrySize.initialModules.includes(rule)) {
-        problems.push(`the initial chunks of ${entry.name} contain ${rule}: the ${part.label} load on demand (only src/domain/validation/profiles/PlatformProfiles.ts imports them, with import())`);
+        problems.push(`the initial chunks of ${entry.name} contain ${rule}: the ${part.label} load on demand (only src/adapters/out/bpmnlint/BpmnlintEngineLint.ts imports them, with import())`);
       }
     }
-    if (part.rules.length && !entrySize.onDemand.some((demandPart) => demandPart.name === part.name)) {
-      problems.push(`${entry.name} has no on-demand chunk with ${part.marker} (the ${part.label})`);
-    }
     for (const { from, to } of entrySize.onDemand.find((demandPart) => demandPart.name === part.name)?.importsOfEntry ?? []) {
-      problems.push(`${from} imports ${to}, which ${entry.name} loads too: a host's bundler (Rollup / Vite) puts it into the entry chunk and makes the ${part.label} chunk import the entry chunk back, so a host whose entry module awaits a call at top level waits forever; hand it to the rules in src/domain/validation/profiles/rule-kit.ts (RULE_KIT) instead of importing it`);
+      problems.push(`${from} imports ${to}, which ${entry.name} loads too: a host's bundler (Rollup / Vite) puts it into the entry chunk and makes the ${part.label} chunk import the entry chunk back, so a host whose entry module awaits a call at top level waits forever; hand it to the engine run in src/adapters/out/bpmnlint/engine-kit.ts (ENGINE_KIT) instead of importing it`);
     }
   }
   overBudget(entry.name, entrySize, budget.entries?.[entry.label]);