bpmn-elements 17.2.2 → 18.0.0

package/dist/error/Errors.js

@@ -7,23 +7,41 @@ exports.RunError = exports.BpmnError = exports.ActivityError = void 0;
 exports.makeErrorFromMessage = makeErrorFromMessage;
 var _messageHelper = require("../messageHelper.js");
 class ActivityError extends Error {
+  /**
+   * @param {string} description
+   * @param {import('#types').ElementBrokerMessage} [sourceMessage]
+   * @param {Error | { name?: string; code?: string | number }} [inner]
+   */
   constructor(description, sourceMessage, inner) {
     super(description);
+    /** @type {string} */
     this.type = 'ActivityError';
+    /** @type {string} */
     this.name = this.constructor.name;
+    /** @type {string} */
     this.description = description;
-    if (sourceMessage) this.source = (0, _messageHelper.cloneMessage)(sourceMessage, sourceMessage.content?.error && {
-      error: undefined
-    });
+    if (sourceMessage) {
+      /** @type {Pick<import('#types').ElementBrokerMessage, 'fields' | 'content' | 'properties'> | undefined} */
+      this.source = (0, _messageHelper.cloneMessage)(sourceMessage, sourceMessage.content?.error && {
+        error: undefined
+      });
+    }
     if (inner) {
+      /** @type {Error | { name?: string; code?: string | number } | undefined} */
       this.inner = inner;
       if (inner.name) this.name = inner.name;
-      if (inner.code) this.code = inner.code;
+      if ('code' in inner && inner.code) {
+        /** @type {string | number | undefined} */
+        this.code = inner.code;
+      }
     }
   }
 }
 exports.ActivityError = ActivityError;
 class RunError extends ActivityError {
+  /**
+   * @param {ConstructorParameters<typeof ActivityError>} args
+   */
   constructor(...args) {
     super(...args);
     this.type = 'RunError';
@@ -31,19 +49,37 @@ class RunError extends ActivityError {
 }
 exports.RunError = RunError;
 class BpmnError extends Error {
-  constructor(description, behaviour, sourceMessage, inner) {
+  /**
+   * @param {string} description
+   * @param {{ id?: string; name?: string; errorCode?: string | number; code?: string }} [behaviour]
+   * @param {import('#types').ElementBrokerMessage} [sourceMessage]
+   */
+  constructor(description, behaviour, sourceMessage) {
     super(description);
+    /** @type {string} */
     this.type = 'BpmnError';
+    /** @type {string} */
     this.name = behaviour?.name ?? this.constructor.name;
+    /** @type {string} */
     this.description = description;
+    /** @type {string | undefined} */
     this.code = behaviour?.errorCode?.toString() ?? behaviour?.code;
+    /** @type {string | undefined} */
     this.id = behaviour?.id;
-    if (sourceMessage) this.source = (0, _messageHelper.cloneMessage)(sourceMessage, sourceMessage.content?.error && {
-      error: undefined
-    });
-    if (inner) this.inner = inner;
+    if (sourceMessage) {
+      /** @type {Pick<import('#types').ElementBrokerMessage, 'fields' | 'content' | 'properties'> | undefined} */
+      this.source = (0, _messageHelper.cloneMessage)(sourceMessage, sourceMessage.content?.error && {
+        error: undefined
+      });
+    }
   }
 }
+
+/**
+ * Get an Error from an error message.
+ * @param {import('#types').ElementBrokerMessage} errorMessage
+ * @returns {Error | ActivityError | RunError | BpmnError}
+ */
 exports.BpmnError = BpmnError;
 function makeErrorFromMessage(errorMessage) {
   const {
@@ -71,6 +107,11 @@ function makeErrorFromMessage(errorMessage) {
   }
   return error;
 }
+
+/**
+ * @param {any} test
+ * @returns {Error | undefined}
+ */
 function isKnownError(test) {
   if (test instanceof ActivityError) return test;
   if (test instanceof BpmnError) return test;

package/dist/eventDefinitions/CancelEventDefinition.js

@@ -3,10 +3,14 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.default = CancelEventDefinition;
+exports.CancelEventDefinition = CancelEventDefinition;
 var _messageHelper = require("../messageHelper.js");
-const kCompleted = Symbol.for('completed');
-const kExecuteMessage = Symbol.for('executeMessage');
+var _constants = require("../constants.js");
+/**
+ * Cancel event definition
+ * @param {import('#types').Activity} activity
+ * @param {import('moddle-context-serializer').EventDefinition} eventDefinition
+ */
 function CancelEventDefinition(activity, eventDefinition) {
   const {
     id,
@@ -17,6 +21,7 @@ function CancelEventDefinition(activity, eventDefinition) {
   const type = eventDefinition.type;
   this.id = id;
   this.type = type;
+  /** @type {import('#types').EventReference} */
   this.reference = {
     referenceType: 'cancel'
   };
@@ -27,16 +32,25 @@ function CancelEventDefinition(activity, eventDefinition) {
   this.logger = environment.Logger(type.toLowerCase());
 }
 Object.defineProperty(CancelEventDefinition.prototype, 'executionId', {
+  /** @returns {string} */
   get() {
-    return this[kExecuteMessage]?.content.executionId;
+    return this[_constants.K_EXECUTE_MESSAGE]?.content.executionId;
   }
 });
+
+/**
+ * @param {import('#types').ElementBrokerMessage} executeMessage
+ */
 CancelEventDefinition.prototype.execute = function execute(executeMessage) {
   return this.isThrowing ? this.executeThrow(executeMessage) : this.executeCatch(executeMessage);
 };
+
+/**
+ * @param {import('#types').ElementBrokerMessage} executeMessage
+ */
 CancelEventDefinition.prototype.executeCatch = function executeCatch(executeMessage) {
-  this[kExecuteMessage] = executeMessage;
-  this[kCompleted] = false;
+  this[_constants.K_EXECUTE_MESSAGE] = executeMessage;
+  this[_constants.K_COMPLETED] = false;
   const executeContent = executeMessage.content;
   const {
     executionId,
@@ -66,6 +80,10 @@ CancelEventDefinition.prototype.executeCatch = function executeCatch(executeMess
   waitContent.parent = (0, _messageHelper.shiftParent)(parent);
   broker.publish('event', 'activity.wait', waitContent);
 };
+
+/**
+ * @param {import('#types').ElementBrokerMessage} executeMessage
+ */
 CancelEventDefinition.prototype.executeThrow = function executeThrow(executeMessage) {
   const executeContent = executeMessage.content;
   const {
@@ -82,7 +100,7 @@ CancelEventDefinition.prototype.executeThrow = function executeThrow(executeMess
   broker.publish('event', 'activity.cancel', cancelContent, {
     type: 'cancel'
   });
-  return broker.publish('execution', 'execute.completed', (0, _messageHelper.cloneContent)(executeContent));
+  broker.publish('execution', 'execute.completed', (0, _messageHelper.cloneContent)(executeContent));
 };
 CancelEventDefinition.prototype._onCatchMessage = function onCatchMessage(_, message) {
   const content = message.content;
@@ -90,10 +108,10 @@ CancelEventDefinition.prototype._onCatchMessage = function onCatchMessage(_, mes
   return this._complete(content.message);
 };
 CancelEventDefinition.prototype._complete = function complete(output) {
-  this[kCompleted] = true;
+  this[_constants.K_COMPLETED] = true;
   this._stop();
   this._debug('completed');
-  const content = (0, _messageHelper.cloneContent)(this[kExecuteMessage].content, {
+  const content = (0, _messageHelper.cloneContent)(this[_constants.K_EXECUTE_MESSAGE].content, {
     output,
     state: 'cancel'
   });
@@ -103,9 +121,9 @@ CancelEventDefinition.prototype._onApiMessage = function onApiMessage(routingKey
   switch (message.properties.type) {
     case 'discard':
       {
-        this[kCompleted] = true;
+        this[_constants.K_COMPLETED] = true;
         this._stop();
-        const content = (0, _messageHelper.cloneContent)(this[kExecuteMessage].content);
+        const content = (0, _messageHelper.cloneContent)(this[_constants.K_EXECUTE_MESSAGE].content);
         return this.broker.publish('execution', 'execute.discard', content);
       }
     case 'stop':

package/dist/eventDefinitions/CompensateEventDefinition.js

@@ -3,14 +3,19 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.default = CompensateEventDefinition;
+exports.CompensateEventDefinition = CompensateEventDefinition;
 var _shared = require("../shared.js");
 var _messageHelper = require("../messageHelper.js");
-const kCompleted = Symbol.for('completed');
-const kExecuteMessage = Symbol.for('executeMessage');
-const kMessageQ = Symbol.for('messageQ');
-const kCompensateQ = Symbol.for('compensateQ');
-const kAssociations = Symbol.for('associations');
+var _constants = require("../constants.js");
+const K_COMPENSATE_Q = Symbol.for('compensateQ');
+const K_ASSOCIATIONS = Symbol.for('associations');
+
+/**
+ * Compensate event definition
+ * @param {import('#types').Activity} activity
+ * @param {import('moddle-context-serializer').EventDefinition} eventDefinition
+ * @param {import('#types').ContextInstance} context
+ */
 function CompensateEventDefinition(activity, eventDefinition, context) {
   const {
     id,
@@ -20,45 +25,56 @@ function CompensateEventDefinition(activity, eventDefinition, context) {
   } = activity;
   this.id = id;
   const type = this.type = eventDefinition.type;
-  const reference = this.reference = {
-    referenceType: 'compensate'
+  const referenceType = 'compensate';
+  /** @type {import('#types').EventReference} */
+  this.reference = {
+    referenceType
   };
   this.isThrowing = isThrowing;
   this.activity = activity;
   this.broker = broker;
   this.logger = environment.Logger(type.toLowerCase());
   if (!isThrowing) {
-    this[kCompleted] = false;
-    this[kAssociations] = context.getOutboundAssociations(id);
-    const messageQueueName = `${reference.referenceType}-${(0, _shared.brokerSafeId)(id)}-q`;
-    this[kMessageQ] = broker.assertQueue(messageQueueName, {
+    this[_constants.K_COMPLETED] = false;
+    this[K_ASSOCIATIONS] = context.getOutboundAssociations(id);
+    const messageQueueName = `${referenceType}-${(0, _shared.brokerSafeId)(id)}-q`;
+    this[_constants.K_MESSAGE_Q] = broker.assertQueue(messageQueueName, {
       autoDelete: false,
       durable: true
     });
-    this[kCompensateQ] = broker.assertQueue('compensate-q', {
+    this[K_COMPENSATE_Q] = broker.assertQueue('compensate-q', {
       autoDelete: false,
       durable: true
     });
-    broker.bindQueue(messageQueueName, 'api', `*.${reference.referenceType}.#`, {
+    broker.bindQueue(messageQueueName, 'api', `*.${referenceType}.#`, {
       durable: true,
       priority: 400
     });
   }
 }
 Object.defineProperty(CompensateEventDefinition.prototype, 'executionId', {
+  /** @returns {string} */
   get() {
-    return this[kExecuteMessage]?.content.executionId;
+    return this[_constants.K_EXECUTE_MESSAGE]?.content.executionId;
   }
 });
+
+/**
+ * @param {import('#types').ElementBrokerMessage} executeMessage
+ */
 CompensateEventDefinition.prototype.execute = function execute(executeMessage) {
   return this.isThrowing ? this.executeThrow(executeMessage) : this.executeCatch(executeMessage);
 };
+
+/**
+ * @param {import('#types').ElementBrokerMessage} executeMessage
+ */
 CompensateEventDefinition.prototype.executeCatch = function executeCatch(executeMessage) {
-  this[kExecuteMessage] = executeMessage;
-  this[kCompleted] = false;
+  this[_constants.K_EXECUTE_MESSAGE] = executeMessage;
+  this[_constants.K_COMPLETED] = false;
   if (executeMessage.fields.routingKey === 'execute.compensating') {
     this._debug('resumed at compensating');
-    this[kCompleted] = true;
+    this[_constants.K_COMPLETED] = true;
     return this._compensate();
   }
   const executeContent = executeMessage.content;
@@ -74,11 +90,11 @@ CompensateEventDefinition.prototype.executeCatch = function executeCatch(execute
     noAck: true,
     consumerTag: '_oncollect-messages'
   });
-  this[kMessageQ].consume(this._onCompensateApiMessage.bind(this), {
+  this[_constants.K_MESSAGE_Q].consume(this._onCompensateApiMessage.bind(this), {
     noAck: true,
     consumerTag: `_oncompensate-${executionId}`
   });
-  if (this[kCompleted]) return;
+  if (this[_constants.K_COMPLETED]) return;
   broker.subscribeTmp('api', `activity.#.${parent.executionId}#`, this._onApiMessage.bind(this), {
     noAck: true,
     consumerTag: `_api-${executionId}`
@@ -89,6 +105,10 @@ CompensateEventDefinition.prototype.executeCatch = function executeCatch(execute
     expect: 'compensate'
   }));
 };
+
+/**
+ * @param {import('#types').ElementBrokerMessage} executeMessage
+ */
 CompensateEventDefinition.prototype.executeThrow = function executeThrow(executeMessage) {
   const executeContent = executeMessage.content;
   const {
@@ -113,15 +133,15 @@ CompensateEventDefinition.prototype._onCollect = function onCollect(routingKey,
     case 'execute.error':
     case 'execute.completed':
       {
-        return this[kCompensateQ].queueMessage(message.fields, (0, _messageHelper.cloneContent)(message.content), message.properties);
+        return this[K_COMPENSATE_Q].queueMessage(message.fields, (0, _messageHelper.cloneContent)(message.content), message.properties);
       }
   }
 };
 CompensateEventDefinition.prototype._onCompensateApiMessage = function onCompensateApiMessage(routingKey, message) {
-  this[kCompleted] = true;
+  this[_constants.K_COMPLETED] = true;
   const output = message.content.message;
   const broker = this.broker;
-  const executeContent = this[kExecuteMessage].content;
+  const executeContent = this[_constants.K_EXECUTE_MESSAGE].content;
   this._stopCollect();
   this._debug('caught compensate event');
   const catchContent = (0, _messageHelper.cloneContent)(executeContent, {
@@ -131,7 +151,7 @@ CompensateEventDefinition.prototype._onCompensateApiMessage = function onCompens
     executionId: executeContent.parent.executionId
   });
   catchContent.parent = (0, _messageHelper.shiftParent)(catchContent.parent);
-  this[kCompensateQ].queueMessage({
+  this[K_COMPENSATE_Q].queueMessage({
     routingKey: 'execute.compensated'
   }, (0, _messageHelper.cloneContent)(executeContent));
   broker.publish('execution', 'execute.compensating', (0, _messageHelper.cloneContent)(executeContent, {
@@ -145,7 +165,7 @@ CompensateEventDefinition.prototype._onCompensateApiMessage = function onCompens
   return this._compensate();
 };
 CompensateEventDefinition.prototype._compensate = function compensate() {
-  return this[kCompensateQ].consume(this._onCollected.bind(this), {
+  return this[K_COMPENSATE_Q].consume(this._onCollected.bind(this), {
     noAck: true,
     consumerTag: '_convey-messages'
   });
@@ -158,14 +178,14 @@ CompensateEventDefinition.prototype._onCollected = function onCollected(routingK
       cancelActivity: false
     }));
   }
-  for (const association of this[kAssociations]) association.take((0, _messageHelper.cloneMessage)(message));
+  for (const association of this[K_ASSOCIATIONS]) association.take((0, _messageHelper.cloneMessage)(message));
 };
 CompensateEventDefinition.prototype._onDiscardApiMessage = function onDiscardApiMessage(routingKey, message) {
-  this[kCompleted] = true;
+  this[_constants.K_COMPLETED] = true;
   this._stop();
-  this[kCompensateQ].purge();
-  for (const association of this[kAssociations]) association.discard((0, _messageHelper.cloneMessage)(message));
-  return this.broker.publish('execution', 'execute.discard', (0, _messageHelper.cloneContent)(this[kExecuteMessage].content));
+  this[K_COMPENSATE_Q].purge();
+  for (const association of this[K_ASSOCIATIONS]) association.discard((0, _messageHelper.cloneMessage)(message));
+  return this.broker.publish('execution', 'execute.discard', (0, _messageHelper.cloneContent)(this[_constants.K_EXECUTE_MESSAGE].content));
 };
 CompensateEventDefinition.prototype._onApiMessage = function onApiMessage(routingKey, message) {
   const messageType = message.properties.type;
@@ -190,7 +210,7 @@ CompensateEventDefinition.prototype._stopCollect = function stopCollect() {
   broker.cancel(`_api-${executionId}`);
   broker.cancel(`_oncompensate-${executionId}`);
   broker.cancel('_oncollect-messages');
-  this[kMessageQ].purge();
+  this[_constants.K_MESSAGE_Q].purge();
 };
 CompensateEventDefinition.prototype._stop = function stop() {
   this._stopCollect();

package/dist/eventDefinitions/ConditionalEventDefinition.js

@@ -3,11 +3,18 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.default = ConditionalEventDefinition;
+exports.ConditionalEventDefinition = ConditionalEventDefinition;
 var _messageHelper = require("../messageHelper.js");
 var _Errors = require("../error/Errors.js");
 var _condition = require("../condition.js");
-const kExecuteMessage = Symbol.for('executeMessage');
+var _constants = require("../constants.js");
+/**
+ * Conditional event definition
+ * @param {import('#types').Activity} activity
+ * @param {import('moddle-context-serializer').EventDefinition} eventDefinition
+ * @param {import('#types').ContextInstance} _context
+ * @param {number} index event definition index
+ */
 function ConditionalEventDefinition(activity, eventDefinition, _context, index) {
   const {
     id,
@@ -28,12 +35,17 @@ function ConditionalEventDefinition(activity, eventDefinition, _context, index)
   this.condition = this.getCondition(index);
 }
 Object.defineProperty(ConditionalEventDefinition.prototype, 'executionId', {
+  /** @returns {string} */
   get() {
-    return this[kExecuteMessage]?.content.executionId;
+    return this[_constants.K_EXECUTE_MESSAGE]?.content.executionId;
   }
 });
+
+/**
+ * @param {import('#types').ElementBrokerMessage} executeMessage
+ */
 ConditionalEventDefinition.prototype.execute = function execute(executeMessage) {
-  this[kExecuteMessage] = executeMessage;
+  this[_constants.K_EXECUTE_MESSAGE] = executeMessage;
   if (!this.condition) return this._setup(executeMessage);
   this.evaluate(executeMessage, (err, result) => {
     this.evaluateCallback(err, result);
@@ -75,7 +87,7 @@ ConditionalEventDefinition.prototype._setup = function setup(executeMessage) {
 
 /**
  * Evaluate condition
- * @param {import('types').ElementBrokerMessage} message
+ * @param {import('#types').ElementBrokerMessage} message
  * @param {CallableFunction} callback
  */
 ConditionalEventDefinition.prototype.evaluate = function evaluate(message, callback) {
@@ -94,7 +106,7 @@ ConditionalEventDefinition.prototype.evaluate = function evaluate(message, callb
  */
 ConditionalEventDefinition.prototype.evaluateCallback = function evaluateCallback(err, result) {
   const broker = this.broker;
-  const executeMessage = this[kExecuteMessage];
+  const executeMessage = this[_constants.K_EXECUTE_MESSAGE];
   const executeContent = executeMessage.content;
   if (err) {
     return broker.publish('execution', 'execute.error', (0, _messageHelper.cloneContent)(executeContent, {
@@ -104,7 +116,7 @@ ConditionalEventDefinition.prototype.evaluateCallback = function evaluateCallbac
     }));
   }
   this._debug(`condition evaluated to ${!!result}`);
-  this.broker.publish('event', 'activity.condition', (0, _messageHelper.cloneContent)(this[kExecuteMessage].content, {
+  this.broker.publish('event', 'activity.condition', (0, _messageHelper.cloneContent)(this[_constants.K_EXECUTE_MESSAGE].content, {
     conditionResult: result
   }));
   if (!result) return;
@@ -117,7 +129,7 @@ ConditionalEventDefinition.prototype.evaluateCallback = function evaluateCallbac
 /**
  * Get condition
  * @param {number} index Eventdefinition sequence number, used to name registered script
- * @returns {ExpressionCondition|ScriptCondition|null}
+ * @returns {import('#types').ICondition | null}
  */
 ConditionalEventDefinition.prototype.getCondition = function getCondition(index) {
   const behaviour = this.behaviour;
@@ -166,7 +178,7 @@ ConditionalEventDefinition.prototype._onApiMessage = function onApiMessage(routi
       {
         this._stop();
         this._debug('discarded');
-        return this.broker.publish('execution', 'execute.discard', (0, _messageHelper.cloneContent)(this[kExecuteMessage].content, {
+        return this.broker.publish('execution', 'execute.discard', (0, _messageHelper.cloneContent)(this[_constants.K_EXECUTE_MESSAGE].content, {
           state: 'discard'
         }));
       }

package/dist/eventDefinitions/ErrorEventDefinition.js

@@ -3,14 +3,15 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.default = ErrorEventDefinition;
+exports.ErrorEventDefinition = ErrorEventDefinition;
 var _shared = require("../shared.js");
 var _messageHelper = require("../messageHelper.js");
-const kCompleted = Symbol.for('completed');
-const kMessageQ = Symbol.for('messageQ');
-const kExecuteMessage = Symbol.for('executeMessage');
-const kReferenceElement = Symbol.for('referenceElement');
-const kReferenceInfo = Symbol.for('referenceInfo');
+var _constants = require("../constants.js");
+/**
+ * Error event definition
+ * @param {import('#types').Activity} activity
+ * @param {import('moddle-context-serializer').EventDefinition} eventDefinition
+ */
 function ErrorEventDefinition(activity, eventDefinition) {
   const {
     id,
@@ -24,7 +25,9 @@ function ErrorEventDefinition(activity, eventDefinition) {
   } = eventDefinition;
   this.id = id;
   this.type = type;
-  const reference = this.reference = {
+
+  /** @type {import('#types').EventReference} */
+  this.reference = {
     name: 'anonymous',
     ...behaviour.errorRef,
     referenceType: 'throw'
@@ -34,44 +37,53 @@ function ErrorEventDefinition(activity, eventDefinition) {
   this.environment = environment;
   this.broker = broker;
   this.logger = environment.Logger(type.toLowerCase());
-  const referenceElement = this[kReferenceElement] = reference.id && activity.getActivityById(reference.id);
+  const referenceElement = this[_constants.K_REFERENCE_ELEMENT] = this.reference.id && activity.getActivityById(this.reference.id);
   if (!isThrowing) {
-    this[kCompleted] = false;
+    this[_constants.K_COMPLETED] = false;
     const referenceId = referenceElement ? referenceElement.id : 'anonymous';
-    const messageQueueName = `${reference.referenceType}-${(0, _shared.brokerSafeId)(id)}-${(0, _shared.brokerSafeId)(referenceId)}-q`;
-    this[kMessageQ] = broker.assertQueue(messageQueueName, {
+    const messageQueueName = `${this.reference.referenceType}-${(0, _shared.brokerSafeId)(id)}-${(0, _shared.brokerSafeId)(referenceId)}-q`;
+    this[_constants.K_MESSAGE_Q] = broker.assertQueue(messageQueueName, {
       autoDelete: false,
       durable: true
     });
-    broker.bindQueue(messageQueueName, 'api', `*.${reference.referenceType}.#`, {
+    broker.bindQueue(messageQueueName, 'api', `*.${this.reference.referenceType}.#`, {
       durable: true,
       priority: 300
     });
   }
 }
 Object.defineProperty(ErrorEventDefinition.prototype, 'executionId', {
+  /** @returns {string} */
   get() {
-    return this[kExecuteMessage]?.content.executionId;
+    return this[_constants.K_EXECUTE_MESSAGE]?.content.executionId;
   }
 });
+
+/**
+ * @param {import('#types').ElementBrokerMessage} executeMessage
+ */
 ErrorEventDefinition.prototype.execute = function execute(executeMessage) {
   return this.isThrowing ? this.executeThrow(executeMessage) : this.executeCatch(executeMessage);
 };
+
+/**
+ * @param {import('#types').ElementBrokerMessage} executeMessage
+ */
 ErrorEventDefinition.prototype.executeCatch = function executeCatch(executeMessage) {
-  this[kExecuteMessage] = executeMessage;
-  this[kCompleted] = false;
+  this[_constants.K_EXECUTE_MESSAGE] = executeMessage;
+  this[_constants.K_COMPLETED] = false;
   const executeContent = executeMessage.content;
   const {
     executionId,
     parent
   } = executeContent;
   const parentExecutionId = parent?.executionId;
-  const info = this[kReferenceInfo] = this._getReferenceInfo(executeMessage);
-  this[kMessageQ].consume(this._onThrowApiMessage.bind(this), {
+  const info = this[_constants.K_REFERENCE_INFO] = this._getReferenceInfo(executeMessage);
+  this[_constants.K_MESSAGE_Q].consume(this._onThrowApiMessage.bind(this), {
     noAck: true,
     consumerTag: `_onthrow-${executionId}`
   });
-  if (this[kCompleted]) return;
+  if (this[_constants.K_COMPLETED]) return;
   this._debug(`expect ${info.description}`);
   const broker = this.broker;
   broker.subscribeTmp('api', `activity.#.${executionId}`, this._onApiMessage.bind(this), {
@@ -92,7 +104,7 @@ ErrorEventDefinition.prototype.executeCatch = function executeCatch(executeMessa
         ...info.message
       }
     }));
-    if (this[kCompleted]) return this._stop();
+    if (this[_constants.K_COMPLETED]) return this._stop();
   }
   const waitContent = (0, _messageHelper.cloneContent)(executeContent, {
     executionId: parentExecutionId,
@@ -103,6 +115,10 @@ ErrorEventDefinition.prototype.executeCatch = function executeCatch(executeMessa
   waitContent.parent = (0, _messageHelper.shiftParent)(parent);
   broker.publish('event', 'activity.wait', waitContent);
 };
+
+/**
+ * @param {import('#types').ElementBrokerMessage} executeMessage
+ */
 ErrorEventDefinition.prototype.executeThrow = function executeThrow(executeMessage) {
   const executeContent = executeMessage.content;
   const {
@@ -132,24 +148,24 @@ ErrorEventDefinition.prototype.executeThrow = function executeThrow(executeMessa
 };
 ErrorEventDefinition.prototype._onErrorMessage = function onErrorMessage(routingKey, message) {
   const error = message.content.error;
-  if (!this[kReferenceElement]) return this._catchError(routingKey, message, error);
+  if (!this[_constants.K_REFERENCE_ELEMENT]) return this._catchError(routingKey, message, error);
   if (!error) return;
-  const info = this[kReferenceInfo];
+  const info = this[_constants.K_REFERENCE_INFO];
   if ('' + error.code !== '' + info.message.code) return;
   return this._catchError(routingKey, message, error);
 };
 ErrorEventDefinition.prototype._onThrowApiMessage = function onThrowApiMessage(routingKey, message) {
   const error = message.content.message;
-  if (!this[kReferenceElement]) return this._catchError(routingKey, message, error);
-  const info = this[kReferenceInfo];
+  if (!this[_constants.K_REFERENCE_ELEMENT]) return this._catchError(routingKey, message, error);
+  const info = this[_constants.K_REFERENCE_INFO];
   if (info.message.id !== error?.id) return;
   return this._catchError(routingKey, message, error);
 };
 ErrorEventDefinition.prototype._catchError = function catchError(routingKey, message, error) {
-  this[kCompleted] = true;
+  this[_constants.K_COMPLETED] = true;
   this._stop();
-  this._debug(`caught ${this[kReferenceInfo].description}`);
-  const executeContent = this[kExecuteMessage].content;
+  this._debug(`caught ${this[_constants.K_REFERENCE_INFO].description}`);
+  const executeContent = this[_constants.K_EXECUTE_MESSAGE].content;
   const parent = executeContent.parent;
   const catchContent = (0, _messageHelper.cloneContent)(executeContent, {
     source: {
@@ -176,9 +192,9 @@ ErrorEventDefinition.prototype._onApiMessage = function onApiMessage(routingKey,
   switch (messageType) {
     case 'discard':
       {
-        this[kCompleted] = true;
+        this[_constants.K_COMPLETED] = true;
         this._stop();
-        return this.broker.publish('execution', 'execute.discard', (0, _messageHelper.cloneContent)(this[kExecuteMessage].content));
+        return this.broker.publish('execution', 'execute.discard', (0, _messageHelper.cloneContent)(this[_constants.K_EXECUTE_MESSAGE].content));
       }
     case 'stop':
       {
@@ -193,10 +209,10 @@ ErrorEventDefinition.prototype._stop = function stop() {
   broker.cancel(`_onthrow-${executionId}`);
   broker.cancel(`_onerror-${executionId}`);
   broker.cancel(`_api-${executionId}`);
-  this[kMessageQ].purge();
+  this[_constants.K_MESSAGE_Q].purge();
 };
 ErrorEventDefinition.prototype._getReferenceInfo = function getReferenceInfo(message) {
-  const referenceElement = this[kReferenceElement];
+  const referenceElement = this[_constants.K_REFERENCE_ELEMENT];
   if (!referenceElement) {
     return {
       message: {