bpmn-elements 17.3.0 → 18.0.1

package/dist/definition/DefinitionExecution.js

@@ -3,31 +3,33 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.default = DefinitionExecution;
-var _getPropertyValue = _interopRequireDefault(require("../getPropertyValue.js"));
+exports.DefinitionExecution = DefinitionExecution;
 var _Api = require("../Api.js");
 var _shared = require("../shared.js");
 var _messageHelper = require("../messageHelper.js");
-function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
-const kActivated = Symbol.for('activated');
-const kProcessesQ = Symbol.for('processesQ');
-const kCompleted = Symbol.for('completed');
-const kExecuteMessage = Symbol.for('executeMessage');
-const kMessageHandlers = Symbol.for('messageHandlers');
-const kParent = Symbol.for('definition');
-const kProcesses = Symbol.for('processes');
-const kStatus = Symbol.for('status');
-const kStopped = Symbol.for('stopped');
+var _constants = require("../constants.js");
+const K_PROCESSES_Q = Symbol.for('processesQ');
+const K_PARENT = Symbol.for('definition');
+const K_PROCESSES = Symbol.for('processes');
+
+/**
+ * Drives the execution of a Definition. Activates executable processes, routes inter-process
+ * delegate messages and call activity hand-offs, and rolls completion up to the Definition.
+ * @param {import('./Definition.js').Definition} definition
+ * @param {import('../Context.js').ContextInstance} context
+ */
 function DefinitionExecution(definition, context) {
   const broker = definition.broker;
-  this[kParent] = definition;
+  this[K_PARENT] = definition;
   this.id = definition.id;
   this.type = definition.type;
   this.broker = broker;
   const environment = this.environment = definition.environment;
   this.context = context;
   const processes = context.getProcesses();
+  /** @type {Set<string>} */
   const ids = new Set();
+  /** @type {Set<import('../process/Process.js').Process>} */
   const executable = new Set();
   for (const bp of processes) {
     bp.environment.assignVariables(environment.variables);
@@ -35,7 +37,7 @@ function DefinitionExecution(definition, context) {
     ids.add(bp.id);
     if (bp.isExecutable) executable.add(bp);
   }
-  this[kProcesses] = {
+  this[K_PROCESSES] = {
     processes,
     ids,
     executable,
@@ -47,12 +49,12 @@ function DefinitionExecution(definition, context) {
     durable: true
   });
   this.executionId = undefined;
-  this[kCompleted] = false;
-  this[kStopped] = false;
-  this[kActivated] = false;
-  this[kStatus] = 'init';
-  this[kProcessesQ] = undefined;
-  this[kMessageHandlers] = {
+  this[_constants.K_COMPLETED] = false;
+  this[_constants.K_STOPPED] = false;
+  this[_constants.K_ACTIVATED] = false;
+  this[_constants.K_STATUS] = 'init';
+  this[K_PROCESSES_Q] = undefined;
+  this[_constants.K_MESSAGE_HANDLERS] = {
     onApiMessage: this._onApiMessage.bind(this),
     onCallActivity: this._onCallActivity.bind(this),
     onCancelCallActivity: this._onCancelCallActivity.bind(this),
@@ -65,38 +67,38 @@ function DefinitionExecution(definition, context) {
 Object.defineProperties(DefinitionExecution.prototype, {
   stopped: {
     get() {
-      return this[kStopped];
+      return this[_constants.K_STOPPED];
     }
   },
   completed: {
     get() {
-      return this[kCompleted];
+      return this[_constants.K_COMPLETED];
     }
   },
   status: {
     get() {
-      return this[kStatus];
+      return this[_constants.K_STATUS];
     }
   },
   processes: {
     get() {
-      return [...this[kProcesses].running];
+      return [...this[K_PROCESSES].running];
     }
   },
   postponedCount: {
     get() {
-      return this[kProcesses].postponed.size;
+      return this[K_PROCESSES].postponed.size;
     }
   },
   isRunning: {
     get() {
-      return this[kActivated];
+      return this[_constants.K_ACTIVATED];
     }
   },
   activityStatus: {
     get() {
       let status = 'idle';
-      const running = this[kProcesses].running;
+      const running = this[K_PROCESSES].running;
       if (!running.size) return status;
       for (const bp of running) {
         const bpStatus = bp.activityStatus;
@@ -117,17 +119,24 @@ Object.defineProperties(DefinitionExecution.prototype, {
     }
   }
 });
+
+/**
+ * Activate executable processes and start the definition execution. Resumes if the message
+ * is redelivered. When `content.processId` is set, only that process is started.
+ * @param {import('#types').ElementBrokerMessage} executeMessage
+ * @throws {Error} when message or executionId is missing
+ */
 DefinitionExecution.prototype.execute = function execute(executeMessage) {
   if (!executeMessage) throw new Error('Definition execution requires message');
   const content = executeMessage.content;
   const executionId = this.executionId = content.executionId;
   if (!executionId) throw new Error('Definition execution requires execution id');
-  this[kExecuteMessage] = (0, _messageHelper.cloneMessage)(executeMessage, {
+  this[_constants.K_EXECUTE_MESSAGE] = (0, _messageHelper.cloneMessage)(executeMessage, {
     executionId,
     state: 'start'
   });
-  this[kStopped] = false;
-  this[kProcessesQ] = this.broker.assertQueue(`execute-${executionId}-q`, {
+  this[_constants.K_STOPPED] = false;
+  this[K_PROCESSES_Q] = this.broker.assertQueue(`execute-${executionId}-q`, {
     durable: true,
     autoDelete: false
   });
@@ -137,7 +146,7 @@ DefinitionExecution.prototype.execute = function execute(executeMessage) {
   const {
     running,
     executable
-  } = this[kProcesses];
+  } = this[K_PROCESSES];
   if (content.processId) {
     const startWithProcess = this.getProcessById(content.processId);
     if (startWithProcess) {
@@ -153,30 +162,41 @@ DefinitionExecution.prototype.execute = function execute(executeMessage) {
   this._start();
   return true;
 };
+
+/**
+ * Resume after recover by reactivating running processes.
+ */
 DefinitionExecution.prototype.resume = function resume() {
-  this._debug(`resume ${this[kStatus]} definition execution`);
-  if (this[kCompleted]) return this._complete('completed');
+  this._debug(`resume ${this[_constants.K_STATUS]} definition execution`);
+  if (this[_constants.K_COMPLETED]) return this._complete('completed');
   const {
     running,
     postponed
-  } = this[kProcesses];
+  } = this[K_PROCESSES];
   this._activate(running);
   postponed.clear();
-  this[kProcessesQ].consume(this[kMessageHandlers].onProcessMessage, {
+  this[K_PROCESSES_Q].consume(this[_constants.K_MESSAGE_HANDLERS].onProcessMessage, {
     prefetch: 1000,
     consumerTag: `_definition-activity-${this.executionId}`
   });
-  if (this[kCompleted]) return;
+  if (this[_constants.K_COMPLETED]) return;
   for (const bp of running) bp.resume();
 };
-DefinitionExecution.prototype.recover = function recover(state) {
+
+/**
+ * Restore execution state captured by getState. Reinstates running processes from the snapshot.
+ * @param {import('#types').DefinitionExecutionState} [state]
+ * @param {number} [recoveredVersion] State version
+ * @returns {this}
+ */
+DefinitionExecution.prototype.recover = function recover(state, recoveredVersion) {
   if (!state) return this;
   this.executionId = state.executionId;
-  this[kStopped] = state.stopped;
-  this[kCompleted] = state.completed;
-  this[kStatus] = state.status;
-  this._debug(`recover ${this[kStatus]} definition execution`);
-  const running = this[kProcesses].running;
+  this[_constants.K_STOPPED] = state.stopped;
+  this[_constants.K_COMPLETED] = state.completed;
+  this[_constants.K_STATUS] = state.status;
+  this._debug(`recover ${this[_constants.K_STATUS]} definition execution`);
+  const running = this[K_PROCESSES].running;
   running.clear();
   const ids = new Set();
   for (const bpState of state.processes) {
@@ -189,57 +209,101 @@ DefinitionExecution.prototype.recover = function recover(state) {
     }
     if (!bp) continue;
     ids.add(bpid);
-    bp.recover(bpState);
+    bp.recover(bpState, recoveredVersion);
     running.add(bp);
   }
   return this;
 };
+
+/**
+ * Stop the running execution via the api.
+ */
 DefinitionExecution.prototype.stop = function stop() {
   this.getApi().stop();
 };
+
+/**
+ * Get every process in the definition (running first, then any non-running by id).
+ * @returns {import('../process/Process.js').Process[]}
+ */
 DefinitionExecution.prototype.getProcesses = function getProcesses() {
   const {
     running,
     processes
-  } = this[kProcesses];
+  } = this[K_PROCESSES];
   const result = [...running];
   for (const bp of processes) {
     if (!result.find(runningBp => bp.id === runningBp.id)) result.push(bp);
   }
   return result;
 };
+
+/**
+ * @param {string} processId
+ */
 DefinitionExecution.prototype.getProcessById = function getProcessById(processId) {
   return this.getProcesses().find(bp => bp.id === processId);
 };
+
+/**
+ * Get every process matching the given id (call activities can spawn duplicates).
+ * @param {string} processId
+ */
 DefinitionExecution.prototype.getProcessesById = function getProcessesById(processId) {
   return this.getProcesses().filter(bp => bp.id === processId);
 };
+
+/**
+ * @param {string} processExecutionId
+ * @returns {import('../process/Process.js').Process | undefined}
+ */
 DefinitionExecution.prototype.getProcessByExecutionId = function getProcessByExecutionId(processExecutionId) {
-  for (const bp of this[kProcesses].running) {
+  for (const bp of this[K_PROCESSES].running) {
     if (bp.executionId === processExecutionId) return bp;
   }
 };
+
+/**
+ * Get processes that have an executionId, i.e. are currently running.
+ * @returns {import('../process/Process.js').Process[]}
+ */
 DefinitionExecution.prototype.getRunningProcesses = function getRunningProcesses() {
-  return [...this[kProcesses].running].filter(bp => bp.executionId);
+  return [...this[K_PROCESSES].running].filter(bp => bp.executionId);
 };
+
+/**
+ * Get processes flagged executable in the definition.
+ * @returns {import('../process/Process.js').Process[]}
+ */
 DefinitionExecution.prototype.getExecutableProcesses = function getExecutableProcesses() {
-  return [...this[kProcesses].executable];
+  return [...this[K_PROCESSES].executable];
 };
+
+/**
+ * Snapshot execution state for recover.
+ * @returns {import('#types').DefinitionExecutionState}
+ */
 DefinitionExecution.prototype.getState = function getState() {
   const processes = [];
-  for (const bp of this[kProcesses].running) {
+  for (const bp of this[K_PROCESSES].running) {
     processes.push(bp.getState());
   }
   return {
     executionId: this.executionId,
-    stopped: this[kStopped],
-    completed: this[kCompleted],
-    status: this[kStatus],
+    stopped: this[_constants.K_STOPPED],
+    completed: this[_constants.K_COMPLETED],
+    status: this[_constants.K_STATUS],
     processes
   };
 };
+
+/**
+ * Resolve a Definition Api or, when the message belongs to a child process, its process Api.
+ * @param {import('#types').ElementBrokerMessage} [apiMessage]
+ * @returns {import('#types').IApi<import('./Definition.js').Definition>}
+ */
 DefinitionExecution.prototype.getApi = function getApi(apiMessage) {
-  if (!apiMessage) apiMessage = this[kExecuteMessage] || {
+  if (!apiMessage) apiMessage = this[_constants.K_EXECUTE_MESSAGE] || {
     content: this._createMessage()
   };
   const content = apiMessage.content;
@@ -247,7 +311,7 @@ DefinitionExecution.prototype.getApi = function getApi(apiMessage) {
     return this._getProcessApi(apiMessage);
   }
   const api = (0, _Api.DefinitionApi)(this.broker, apiMessage);
-  const postponed = this[kProcesses].postponed;
+  const postponed = this[K_PROCESSES].postponed;
   const self = this;
   api.getExecuting = function getExecuting() {
     const apis = [];
@@ -259,19 +323,27 @@ DefinitionExecution.prototype.getApi = function getApi(apiMessage) {
   };
   return api;
 };
+
+/**
+ * List currently postponed activities across every running process.
+ * @param {import('#types').filterPostponed} [filterFn]
+ * @returns {import('#types').IApi<import('#types').Activity>}
+ */
 DefinitionExecution.prototype.getPostponed = function getPostponed(...args) {
   let result = [];
-  for (const bp of this[kProcesses].running) {
+  for (const bp of this[K_PROCESSES].running) {
     result = result.concat(bp.getPostponed(...args));
   }
   return result;
 };
+
+/** @internal */
 DefinitionExecution.prototype._start = function start() {
   const {
     ids,
     executable,
     postponed
-  } = this[kProcesses];
+  } = this[K_PROCESSES];
   if (!ids.size) {
     return this._complete('completed');
   }
@@ -280,25 +352,29 @@ DefinitionExecution.prototype._start = function start() {
       error: new Error('No executable process')
     });
   }
-  this[kStatus] = 'start';
+  this[_constants.K_STATUS] = 'start';
   for (const bp of executable) bp.init();
   for (const bp of executable) bp.run();
   postponed.clear();
-  this[kProcessesQ].assertConsumer(this[kMessageHandlers].onProcessMessage, {
+  this[K_PROCESSES_Q].assertConsumer(this[_constants.K_MESSAGE_HANDLERS].onProcessMessage, {
     prefetch: 1000,
     consumerTag: `_definition-activity-${this.executionId}`
   });
 };
+
+/** @internal */
 DefinitionExecution.prototype._activate = function activate(processList) {
-  this.broker.subscribeTmp('api', '#', this[kMessageHandlers].onApiMessage, {
+  this.broker.subscribeTmp('api', '#', this[_constants.K_MESSAGE_HANDLERS].onApiMessage, {
     noAck: true,
     consumerTag: '_definition-api-consumer'
   });
   for (const bp of processList) this._activateProcess(bp);
-  this[kActivated] = true;
+  this[_constants.K_ACTIVATED] = true;
 };
+
+/** @internal */
 DefinitionExecution.prototype._activateProcess = function activateProcess(bp) {
-  const handlers = this[kMessageHandlers];
+  const handlers = this[_constants.K_MESSAGE_HANDLERS];
   const broker = bp.broker;
   broker.subscribeTmp('message', 'message.outbound', handlers.onMessageOutbound, {
     noAck: true,
@@ -334,11 +410,13 @@ DefinitionExecution.prototype._activateProcess = function activateProcess(bp) {
     priority: 100
   });
 };
+
+/** @internal */
 DefinitionExecution.prototype._onChildEvent = function onChildEvent(routingKey, originalMessage) {
   const message = (0, _messageHelper.cloneMessage)(originalMessage);
   const content = message.content;
   const parent = content.parent = content.parent || {};
-  const isDirectChild = this[kProcesses].ids.has(content.id);
+  const isDirectChild = this[K_PROCESSES].ids.has(content.id);
   if (isDirectChild) {
     parent.executionId = this.executionId;
   } else {
@@ -349,14 +427,18 @@ DefinitionExecution.prototype._onChildEvent = function onChildEvent(routingKey,
     mandatory: false
   });
   if (!isDirectChild) return;
-  this[kProcessesQ].queueMessage(message.fields, (0, _messageHelper.cloneContent)(content), message.properties);
+  this[K_PROCESSES_Q].queueMessage(message.fields, (0, _messageHelper.cloneContent)(content), message.properties);
 };
+
+/** @internal */
 DefinitionExecution.prototype._deactivate = function deactivate() {
   this.broker.cancel('_definition-api-consumer');
   this.broker.cancel(`_definition-activity-${this.executionId}`);
-  for (const bp of this[kProcesses].running) this._deactivateProcess(bp);
-  this[kActivated] = false;
+  for (const bp of this[K_PROCESSES].running) this._deactivateProcess(bp);
+  this[_constants.K_ACTIVATED] = false;
 };
+
+/** @internal */
 DefinitionExecution.prototype._deactivateProcess = function deactivateProcess(bp) {
   bp.broker.cancel('_definition-outbound-message-consumer');
   bp.broker.cancel('_definition-activity-consumer');
@@ -364,6 +446,8 @@ DefinitionExecution.prototype._deactivateProcess = function deactivateProcess(bp
   bp.broker.cancel('_definition-call-consumer');
   bp.broker.cancel('_definition-call-cancel-consumer');
 };
+
+/** @internal */
 DefinitionExecution.prototype._onProcessMessage = function onProcessMessage(routingKey, message) {
   const content = message.content;
   const isRedelivered = message.fields.redelivered;
@@ -386,7 +470,7 @@ DefinitionExecution.prototype._onProcessMessage = function onProcessMessage(rout
   this._stateChangeMessage(message, true);
   switch (routingKey) {
     case 'process.enter':
-      this[kStatus] = 'executing';
+      this[_constants.K_STATUS] = 'executing';
       break;
     case 'process.discarded':
       {
@@ -431,7 +515,7 @@ DefinitionExecution.prototype._onProcessMessage = function onProcessMessage(rout
             type: 'error'
           });
         } else {
-          for (const bp of new Set(this[kProcesses].running)) {
+          for (const bp of new Set(this[K_PROCESSES].running)) {
             if (bp.id !== childId) bp.stop();
           }
           Object.assign(this.environment.output, content.output);
@@ -443,9 +527,11 @@ DefinitionExecution.prototype._onProcessMessage = function onProcessMessage(rout
       }
   }
 };
+
+/** @internal */
 DefinitionExecution.prototype._stateChangeMessage = function stateChangeMessage(message, postponeMessage) {
   let previousMsg;
-  const postponed = this[kProcesses].postponed;
+  const postponed = this[K_PROCESSES].postponed;
   for (const msg of postponed) {
     if (msg.content.executionId === message.content.executionId) {
       previousMsg = msg;
@@ -456,6 +542,8 @@ DefinitionExecution.prototype._stateChangeMessage = function stateChangeMessage(
   if (previousMsg) previousMsg.ack();
   if (postponeMessage) postponed.add(message);
 };
+
+/** @internal */
 DefinitionExecution.prototype._onProcessCompleted = function onProcessCompleted(message) {
   this._stateChangeMessage(message, false);
   if (message.fields.redelivered) return message.ack();
@@ -475,49 +563,55 @@ DefinitionExecution.prototype._onProcessCompleted = function onProcessCompleted(
     this._complete('completed');
   }
 };
+
+/** @internal */
 DefinitionExecution.prototype._onStopped = function onStopped(message) {
-  const running = this[kProcesses].running;
+  const running = this[K_PROCESSES].running;
   this._debug(`stop definition execution (stop process executions ${running.size})`);
-  this[kProcessesQ].close();
+  this[K_PROCESSES_Q].close();
   for (const bp of new Set(running)) bp.stop();
   this._deactivate();
-  this[kStopped] = true;
-  return this.broker.publish('execution', `execution.stopped.${this.executionId}`, (0, _messageHelper.cloneContent)(this[kExecuteMessage].content, {
+  this[_constants.K_STOPPED] = true;
+  return this.broker.publish('execution', `execution.stopped.${this.executionId}`, (0, _messageHelper.cloneContent)(this[_constants.K_EXECUTE_MESSAGE].content, {
     ...message.content
   }), {
     type: 'stopped',
     persistent: false
   });
 };
+
+/** @internal */
 DefinitionExecution.prototype._onApiMessage = function onApiMessage(routingKey, message) {
   const messageType = message.properties.type;
   const delegate = message.properties.delegate;
   if (delegate && this.id === message.content.id) {
-    const referenceId = (0, _getPropertyValue.default)(message, 'content.message.id');
+    const referenceId = message.content.message?.id;
     this._startProcessesByMessage({
       referenceId,
       referenceType: messageType
     });
   }
   if (delegate) {
-    for (const bp of new Set(this[kProcesses].running)) {
+    for (const bp of new Set(this[K_PROCESSES].running)) {
       bp.broker.publish('api', routingKey, (0, _messageHelper.cloneContent)(message.content), message.properties);
     }
   }
   if (this.executionId !== message.content.executionId) return;
   if (messageType === 'stop') {
-    this[kProcessesQ].queueMessage({
+    this[K_PROCESSES_Q].queueMessage({
       routingKey: 'execution.stop'
     }, (0, _messageHelper.cloneContent)(message.content), {
       persistent: false
     });
   }
 };
+
+/** @internal */
 DefinitionExecution.prototype._startProcessesByMessage = function startProcessesByMessage(reference) {
   const {
     processes: bps,
     running
-  } = this[kProcesses];
+  } = this[K_PROCESSES];
   if (bps.length < 2) return;
   for (const bp of bps) {
     if (bp.isExecutable) continue;
@@ -540,6 +634,8 @@ DefinitionExecution.prototype._startProcessesByMessage = function startProcesses
     if (reference.referenceType === 'message') return;
   }
 };
+
+/** @internal */
 DefinitionExecution.prototype._onMessageOutbound = function onMessageOutbound(routingKey, message) {
   const content = message.content;
   const {
@@ -561,11 +657,13 @@ DefinitionExecution.prototype._onMessageOutbound = function onMessageOutbound(ro
   if (found) return;
   targetProcess = targetProcess || this.context.getNewProcessById(target.processId);
   this._activateProcess(targetProcess);
-  this[kProcesses].running.add(targetProcess);
+  this[K_PROCESSES].running.add(targetProcess);
   targetProcess.init();
   targetProcess.run();
   targetProcess.sendMessage(message);
 };
+
+/** @internal */
 DefinitionExecution.prototype._onCallActivity = function onCallActivity(routingKey, message) {
   const content = message.content;
   const {
@@ -593,12 +691,14 @@ DefinitionExecution.prototype._onCallActivity = function onCallActivity(routingK
   if (!targetProcess) return;
   this._debug(`call from <${fromParent.id}.${fromId}> to <${calledElement}>`);
   this._activateProcess(targetProcess);
-  this[kProcesses].running.add(targetProcess);
+  this[K_PROCESSES].running.add(targetProcess);
   targetProcess.init(bpExecutionId);
   targetProcess.run({
     inbound: [(0, _messageHelper.cloneContent)(content)]
   });
 };
+
+/** @internal */
 DefinitionExecution.prototype._onCancelCallActivity = function onCancelCallActivity(routingKey, message) {
   const {
     calledElement,
@@ -622,6 +722,8 @@ DefinitionExecution.prototype._onCancelCallActivity = function onCancelCallActiv
     targetProcess.getApi().discard();
   }
 };
+
+/** @internal */
 DefinitionExecution.prototype._onDelegateMessage = function onDelegateMessage(routingKey, executeMessage) {
   const content = executeMessage.content;
   const messageType = executeMessage.properties.type;
@@ -648,19 +750,23 @@ DefinitionExecution.prototype._onDelegateMessage = function onDelegateMessage(ro
     type: messageType
   });
 };
+
+/** @internal */
 DefinitionExecution.prototype._removeProcessByExecutionId = function removeProcessByExecutionId(processExecutionId) {
   const bp = this.getProcessByExecutionId(processExecutionId);
-  if (bp) this[kProcesses].running.delete(bp);
+  if (bp) this[K_PROCESSES].running.delete(bp);
   return bp;
 };
+
+/** @internal */
 DefinitionExecution.prototype._complete = function complete(completionType, content, options) {
   this._deactivate();
-  const stateMessage = this[kExecuteMessage];
+  const stateMessage = this[_constants.K_EXECUTE_MESSAGE];
   this._debug(`definition execution ${completionType} in ${Date.now() - stateMessage.properties.timestamp}ms`);
   if (!content) content = this._createMessage();
-  this[kCompleted] = true;
-  this[kStatus] = completionType;
-  this.broker.deleteQueue(this[kProcessesQ].name);
+  this[_constants.K_COMPLETED] = true;
+  this[_constants.K_STATUS] = completionType;
+  this.broker.deleteQueue(this[K_PROCESSES_Q].name);
   return this.broker.publish('execution', `execution.${completionType}.${this.executionId}`, {
     ...stateMessage.content,
     output: {
@@ -674,15 +780,19 @@ DefinitionExecution.prototype._complete = function complete(completionType, cont
     ...options
   });
 };
+
+/** @internal */
 DefinitionExecution.prototype._createMessage = function createMessage(content) {
   return {
     id: this.id,
     type: this.type,
     executionId: this.executionId,
-    status: this[kStatus],
+    status: this[_constants.K_STATUS],
     ...content
   };
 };
+
+/** @internal */
 DefinitionExecution.prototype._getProcessApi = function getProcessApi(message) {
   const content = message.content;
   let api = this._getProcessApiByExecutionId(content.executionId, message);
@@ -696,11 +806,15 @@ DefinitionExecution.prototype._getProcessApi = function getProcessApi(message) {
     if (api) return api;
   }
 };
+
+/** @internal */
 DefinitionExecution.prototype._getProcessApiByExecutionId = function getProcessApiByExecutionId(parentExecutionId, message) {
   const processInstance = this.getProcessByExecutionId(parentExecutionId);
   if (!processInstance) return;
   return processInstance.getApi(message);
 };
+
+/** @internal */
 DefinitionExecution.prototype._debug = function debug(logMessage) {
-  this[kParent].logger.debug(`<${this.executionId} (${this.id})> ${logMessage}`);
+  this[K_PARENT].logger.debug(`<${this.executionId} (${this.id})> ${logMessage}`);
 };

package/dist/error/BpmnError.js

@@ -3,7 +3,12 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.default = BpmnErrorActivity;
+exports.BpmnErrorActivity = BpmnErrorActivity;
+/**
+ * BPMN error.
+ * @param {import('moddle-context-serializer').SerializableElement} errorDef
+ * @param {import('#types').ContextInstance} context
+ */
 function BpmnErrorActivity(errorDef, context) {
   const {
     id,
@@ -21,11 +26,17 @@ function BpmnErrorActivity(errorDef, context) {
     errorCode: behaviour.errorCode,
     resolve
   };
+
+  /**
+   * @param {import('#types').ElementBrokerMessage} executionMessage
+   * @param {Error} [error]
+   */
   function resolve(executionMessage, error) {
     const resolveCtx = {
       ...executionMessage,
       error
     };
+    /** @type {{ id?: string; type?: string; messageType: string; name: string; code: string | undefined; inner?: Error }} */
     const result = {
       id,
       type,