bpmn-elements 8.2.3 → 9.0.0

package/src/process/Process.js

@@ -1,9 +1,9 @@
-import ProcessExecution from './ProcessExecution';
-import {getUniqueId} from '../shared';
-import {ProcessApi} from '../Api';
-import {ProcessBroker} from '../EventBroker';
-import {cloneMessage, cloneContent, cloneParent} from '../messageHelper';
-import {makeErrorFromMessage} from '../error/Errors';
+import ProcessExecution from './ProcessExecution.js';
+import {getUniqueId} from '../shared.js';
+import {ProcessApi} from '../Api.js';
+import {ProcessBroker} from '../EventBroker.js';
+import {cloneMessage, cloneContent, cloneParent} from '../messageHelper.js';
+import {makeErrorFromMessage} from '../error/Errors.js';
 
 const kConsuming = Symbol.for('consuming');
 const kCounters = Symbol.for('counters');
@@ -56,30 +56,28 @@ export function Process(processDef, context) {
   this[kExtensions] = context.loadExtensions(this);
 }
 
-const proto = Process.prototype;
-
-Object.defineProperty(proto, 'counters', {
+Object.defineProperty(Process.prototype, 'counters', {
   enumerable: true,
   get() {
     return {...this[kCounters]};
   },
 });
 
-Object.defineProperty(proto, 'extensions', {
+Object.defineProperty(Process.prototype, 'extensions', {
   enumerable: true,
   get() {
     return this[kExtensions];
   },
 });
 
-Object.defineProperty(proto, 'stopped', {
+Object.defineProperty(Process.prototype, 'stopped', {
   enumerable: true,
   get() {
     return this[kStopped];
   },
 });
 
-Object.defineProperty(proto, 'isRunning', {
+Object.defineProperty(Process.prototype, 'isRunning', {
   enumerable: true,
   get() {
     if (!this[kConsuming]) return false;
@@ -87,7 +85,7 @@ Object.defineProperty(proto, 'isRunning', {
   },
 });
 
-Object.defineProperty(proto, 'executionId', {
+Object.defineProperty(Process.prototype, 'executionId', {
   enumerable: true,
   get() {
     const {executionId, initExecutionId} = this[kExec];
@@ -95,28 +93,28 @@ Object.defineProperty(proto, 'executionId', {
   },
 });
 
-Object.defineProperty(proto, 'execution', {
+Object.defineProperty(Process.prototype, 'execution', {
   enumerable: true,
   get() {
     return this[kExec].execution;
   },
 });
 
-Object.defineProperty(proto, 'status', {
+Object.defineProperty(Process.prototype, 'status', {
   enumerable: true,
   get() {
     return this[kStatus];
   },
 });
 
-proto.init = function init(useAsExecutionId) {
+Process.prototype.init = function init(useAsExecutionId) {
   const exec = this[kExec];
   const initExecutionId = exec.initExecutionId = useAsExecutionId || getUniqueId(this.id);
   this._debug(`initialized with executionId <${initExecutionId}>`);
   this._publishEvent('init', this._createMessage({executionId: initExecutionId}));
 };
 
-proto.run = function run(runContent) {
+Process.prototype.run = function run(runContent) {
   if (this.isRunning) throw new Error(`process <${this.id}> is already running`);
 
   const exec = this[kExec];
@@ -133,7 +131,7 @@ proto.run = function run(runContent) {
   this._activateRunConsumers();
 };
 
-proto.resume = function resume() {
+Process.prototype.resume = function resume() {
   if (this.isRunning) throw new Error(`cannot resume running process <${this.id}>`);
   if (!this.status) return this;
 
@@ -145,7 +143,7 @@ proto.resume = function resume() {
   return this;
 };
 
-proto.recover = function recover(state) {
+Process.prototype.recover = function recover(state) {
   if (this.isRunning) throw new Error(`cannot recover running process <${this.id}>`);
   if (!state) return this;
 
@@ -165,27 +163,27 @@ proto.recover = function recover(state) {
   return this;
 };
 
-proto.shake = function shake(startId) {
+Process.prototype.shake = function shake(startId) {
   if (this.isRunning) return this.execution.shake(startId);
   return new ProcessExecution(this, this.context).shake(startId);
 };
 
-proto.stop = function stop() {
+Process.prototype.stop = function stop() {
   if (!this.isRunning) return;
   this.getApi().stop();
 };
 
-proto.getApi = function getApi(message) {
+Process.prototype.getApi = function getApi(message) {
   const execution = this.execution;
   if (execution) return execution.getApi(message);
   return ProcessApi(this.broker, message || this[kStateMessage]);
 };
 
-proto.signal = function signal(message) {
+Process.prototype.signal = function signal(message) {
   return this.getApi().signal(message, {delegate: true});
 };
 
-proto.getState = function getState() {
+Process.prototype.getState = function getState() {
   return this._createMessage({
     environment: this.environment.getState(),
     status: this.status,
@@ -196,11 +194,11 @@ proto.getState = function getState() {
   });
 };
 
-proto.cancelActivity = function cancelActivity(message) {
+Process.prototype.cancelActivity = function cancelActivity(message) {
   return this.getApi().cancel(message, {delegate: true});
 };
 
-proto._activateRunConsumers = function activateRunConsumers() {
+Process.prototype._activateRunConsumers = function activateRunConsumers() {
   this[kConsuming] = true;
   const broker = this.broker;
   const {onApiMessage, onRunMessage} = this[kMessageHandlers];
@@ -208,7 +206,7 @@ proto._activateRunConsumers = function activateRunConsumers() {
   broker.getQueue('run-q').assertConsumer(onRunMessage, {exclusive: true, consumerTag: '_process-run'});
 };
 
-proto._deactivateRunConsumers = function deactivateRunConsumers() {
+Process.prototype._deactivateRunConsumers = function deactivateRunConsumers() {
   const broker = this.broker;
   broker.cancel('_process-api');
   broker.cancel('_process-run');
@@ -216,7 +214,7 @@ proto._deactivateRunConsumers = function deactivateRunConsumers() {
   this[kConsuming] = false;
 };
 
-proto._onRunMessage = function onRunMessage(routingKey, message) {
+Process.prototype._onRunMessage = function onRunMessage(routingKey, message) {
   const {content, fields} = message;
 
   if (routingKey === 'run.resume') {
@@ -303,7 +301,7 @@ proto._onRunMessage = function onRunMessage(routingKey, message) {
   message.ack();
 };
 
-proto._onResumeMessage = function onResumeMessage(message) {
+Process.prototype._onResumeMessage = function onResumeMessage(message) {
   message.ack();
 
   const stateMessage = this[kStateMessage];
@@ -325,7 +323,7 @@ proto._onResumeMessage = function onResumeMessage(message) {
   return this.broker.publish('run', stateMessage.fields.routingKey, cloneContent(stateMessage.content), stateMessage.properties);
 };
 
-proto._onExecutionMessage = function onExecutionMessage(routingKey, message) {
+Process.prototype._onExecutionMessage = function onExecutionMessage(routingKey, message) {
   const content = message.content;
   const messageType = message.properties.type;
   message.ack();
@@ -352,12 +350,12 @@ proto._onExecutionMessage = function onExecutionMessage(routingKey, message) {
   executeMessage.ack();
 };
 
-proto._publishEvent = function publishEvent(state, content) {
+Process.prototype._publishEvent = function publishEvent(state, content) {
   const eventContent = this._createMessage({...content, state});
   this.broker.publish('event', `process.${state}`, eventContent, {type: state, mandatory: state === 'error'});
 };
 
-proto.sendMessage = function sendMessage(message) {
+Process.prototype.sendMessage = function sendMessage(message) {
   const messageContent = message && message.content;
   if (!messageContent) return;
 
@@ -373,35 +371,35 @@ proto.sendMessage = function sendMessage(message) {
   this.getApi().sendApiMessage(message.properties.type || 'message', cloneContent(messageContent), {delegate: true});
 };
 
-proto.getActivityById = function getActivityById(childId) {
+Process.prototype.getActivityById = function getActivityById(childId) {
   const execution = this.execution;
   if (execution) return execution.getActivityById(childId);
   return this.context.getActivityById(childId);
 };
 
-proto.getActivities = function getActivities() {
+Process.prototype.getActivities = function getActivities() {
   const execution = this.execution;
   if (execution) return execution.getActivities();
   return this.context.getActivities(this.id);
 };
 
-proto.getStartActivities = function getStartActivities(filterOptions) {
+Process.prototype.getStartActivities = function getStartActivities(filterOptions) {
   return this.context.getStartActivities(filterOptions, this.id);
 };
 
-proto.getSequenceFlows = function getSequenceFlows() {
+Process.prototype.getSequenceFlows = function getSequenceFlows() {
   const execution = this.execution;
   if (execution) return execution.getSequenceFlows();
   return this.context.getSequenceFlows();
 };
 
-proto.getPostponed = function getPostponed(...args) {
+Process.prototype.getPostponed = function getPostponed(...args) {
   const execution = this.execution;
   if (!execution) return [];
   return execution.getPostponed(...args);
 };
 
-proto._onApiMessage = function onApiMessage(routingKey, message) {
+Process.prototype._onApiMessage = function onApiMessage(routingKey, message) {
   const messageType = message.properties.type;
 
   switch (messageType) {
@@ -413,13 +411,13 @@ proto._onApiMessage = function onApiMessage(routingKey, message) {
   }
 };
 
-proto._onStop = function onStop() {
+Process.prototype._onStop = function onStop() {
   this[kStopped] = true;
   this._deactivateRunConsumers();
   return this._publishEvent('stop');
 };
 
-proto._createMessage = function createMessage(override) {
+Process.prototype._createMessage = function createMessage(override) {
   return {
     id: this.id,
     type: this.type,
@@ -430,6 +428,6 @@ proto._createMessage = function createMessage(override) {
   };
 };
 
-proto._debug = function debug(msg) {
+Process.prototype._debug = function debug(msg) {
   this.logger.debug(`<${this.id}> ${msg}`);
 };

package/src/process/ProcessExecution.js

@@ -1,6 +1,6 @@
-import {ProcessApi} from '../Api';
-import {cloneContent, cloneMessage, pushParent} from '../messageHelper';
-import {getUniqueId} from '../shared';
+import {ProcessApi} from '../Api.js';
+import {cloneContent, cloneMessage, pushParent} from '../messageHelper.js';
+import {getUniqueId} from '../shared.js';
 
 export default ProcessExecution;
 
@@ -54,42 +54,40 @@ function ProcessExecution(parentActivity, context) {
   };
 }
 
-const proto = ProcessExecution.prototype;
-
-Object.defineProperty(proto, 'stopped', {
+Object.defineProperty(ProcessExecution.prototype, 'stopped', {
   enumerable: true,
   get() {
     return this[kStopped];
   },
 });
 
-Object.defineProperty(proto, 'completed', {
+Object.defineProperty(ProcessExecution.prototype, 'completed', {
   enumerable: true,
   get() {
     return this[kCompleted];
   },
 });
 
-Object.defineProperty(proto, 'status', {
+Object.defineProperty(ProcessExecution.prototype, 'status', {
   enumerable: true,
   get() {
     return this[kStatus];
   },
 });
 
-Object.defineProperty(proto, 'postponedCount', {
+Object.defineProperty(ProcessExecution.prototype, 'postponedCount', {
   get() {
     return this[kElements].postponed.length;
   },
 });
 
-Object.defineProperty(proto, 'isRunning', {
+Object.defineProperty(ProcessExecution.prototype, 'isRunning', {
   get() {
     return this[kActivated];
   },
 });
 
-proto.execute = function execute(executeMessage) {
+ProcessExecution.prototype.execute = function execute(executeMessage) {
   if (!executeMessage) throw new Error('Process execution requires message');
   if (!executeMessage.content || !executeMessage.content.executionId) throw new Error('Process execution requires execution id');
 
@@ -115,7 +113,7 @@ proto.execute = function execute(executeMessage) {
   return true;
 };
 
-proto.resume = function resume() {
+ProcessExecution.prototype.resume = function resume() {
   this._debug(`resume process execution at ${this.status}`);
 
   if (this[kCompleted]) return this._complete('completed');
@@ -158,7 +156,7 @@ proto.resume = function resume() {
   if (!postponed.length && status === 'executing') return this._complete('completed');
 };
 
-proto.recover = function recover(state) {
+ProcessExecution.prototype.recover = function recover(state) {
   if (!state) return this;
   this.executionId = state.executionId;
 
@@ -204,7 +202,7 @@ proto.recover = function recover(state) {
   return this;
 };
 
-proto.shake = function shake(fromId) {
+ProcessExecution.prototype.shake = function shake(fromId) {
   let executing = true;
   const id = this.id;
   if (!this.isRunning) {
@@ -239,11 +237,11 @@ proto.shake = function shake(fromId) {
   return result;
 };
 
-proto.stop = function stop() {
+ProcessExecution.prototype.stop = function stop() {
   this.getApi().stop();
 };
 
-proto.getPostponed = function getPostponed(filterFn) {
+ProcessExecution.prototype.getPostponed = function getPostponed(filterFn) {
   const result = [];
   for (const msg of this[kElements].postponed.slice()) {
     const api = this._getChildApi(msg);
@@ -254,7 +252,7 @@ proto.getPostponed = function getPostponed(filterFn) {
   return result;
 };
 
-proto.discard = function discard() {
+ProcessExecution.prototype.discard = function discard() {
   this[kStatus] = 'discard';
   return this[kActivityQ].queueMessage({routingKey: 'execution.discard'}, {
     id: this.id,
@@ -263,7 +261,7 @@ proto.discard = function discard() {
   }, {type: 'discard'});
 };
 
-proto.getState = function getState() {
+ProcessExecution.prototype.getState = function getState() {
   const {children, flows, outboundMessageFlows, associations} = this[kElements];
   return {
     executionId: this.executionId,
@@ -281,19 +279,19 @@ proto.getState = function getState() {
   };
 };
 
-proto.getActivities = function getActivities() {
+ProcessExecution.prototype.getActivities = function getActivities() {
   return this[kElements].children.slice();
 };
 
-proto.getActivityById = function getActivityById(activityId) {
+ProcessExecution.prototype.getActivityById = function getActivityById(activityId) {
   return this[kElements].children.find((child) => child.id === activityId);
 };
 
-proto.getSequenceFlows = function getSequenceFlows() {
+ProcessExecution.prototype.getSequenceFlows = function getSequenceFlows() {
   return this[kElements].flows.slice();
 };
 
-proto.getApi = function getApi(message) {
+ProcessExecution.prototype.getApi = function getApi(message) {
   if (!message) return ProcessApi(this.broker, this[kExecuteMessage]);
 
   const content = message.content;
@@ -317,7 +315,7 @@ proto.getApi = function getApi(message) {
   return api;
 };
 
-proto._start = function start() {
+ProcessExecution.prototype._start = function start() {
   if (this[kElements].children.length === 0) {
     return this._complete('completed');
   }
@@ -344,14 +342,22 @@ proto._start = function start() {
   });
 };
 
-proto._activate = function activate() {
+ProcessExecution.prototype._activate = function activate() {
   const {onApiMessage, onMessageFlowEvent, onActivityEvent} = this[kMessageHandlers];
 
-  this.broker.subscribeTmp('api', '#', onApiMessage, {
-    noAck: true,
-    consumerTag: `_process-api-consumer-${this.executionId}`,
-    priority: 200,
-  });
+  if (!this.isSubProcess) {
+    this.broker.consume('api-q', onApiMessage, {
+      noAck: true,
+      consumerTag: `_process-api-consumer-${this.executionId}`,
+      priority: 200,
+    });
+  } else {
+    this.broker.subscribeTmp('api', '#', onApiMessage, {
+      noAck: true,
+      consumerTag: `_process-api-consumer-${this.executionId}`,
+      priority: 200,
+    });
+  }
 
   const {outboundMessageFlows, flows, associations, startActivities, triggeredByEvent, children} = this[kElements];
 
@@ -398,7 +404,7 @@ proto._activate = function activate() {
   this[kActivated] = true;
 };
 
-proto._deactivate = function deactivate() {
+ProcessExecution.prototype._deactivate = function deactivate() {
   const broker = this.broker;
   const executionId = this.executionId;
   broker.cancel(`_process-api-consumer-${executionId}`);
@@ -428,7 +434,7 @@ proto._deactivate = function deactivate() {
   this[kActivated] = false;
 };
 
-proto._onDelegateEvent = function onDelegateEvent(message) {
+ProcessExecution.prototype._onDelegateEvent = function onDelegateEvent(message) {
   const eventType = message.properties.type;
   let delegate = true;
 
@@ -451,11 +457,11 @@ proto._onDelegateEvent = function onDelegateEvent(message) {
   return delegate;
 };
 
-proto._onMessageFlowEvent = function onMessageFlowEvent(routingKey, message) {
+ProcessExecution.prototype._onMessageFlowEvent = function onMessageFlowEvent(routingKey, message) {
   this.broker.publish('message', routingKey, cloneContent(message.content), message.properties);
 };
 
-proto._onActivityEvent = function onActivityEvent(routingKey, message) {
+ProcessExecution.prototype._onActivityEvent = function onActivityEvent(routingKey, message) {
   if (message.fields.redelivered && message.properties.persistent === false) return;
 
   const content = message.content;
@@ -487,7 +493,7 @@ proto._onActivityEvent = function onActivityEvent(routingKey, message) {
   this[kActivityQ].queueMessage(message.fields, cloneContent(content), {persistent: true, ...message.properties});
 };
 
-proto._onChildMessage = function onChildMessage(routingKey, message) {
+ProcessExecution.prototype._onChildMessage = function onChildMessage(routingKey, message) {
   if (message.fields.redelivered && message.properties.persistent === false) return message.ack();
 
   const content = message.content;
@@ -550,13 +556,13 @@ proto._onChildMessage = function onChildMessage(routingKey, message) {
   }
 };
 
-proto._stateChangeMessage = function stateChangeMessage(message, postponeMessage) {
+ProcessExecution.prototype._stateChangeMessage = function stateChangeMessage(message, postponeMessage) {
   const previousMsg = this._popPostponed(message.content);
   if (previousMsg) previousMsg.ack();
   if (postponeMessage) this[kElements].postponed.push(message);
 };
 
-proto._popPostponed = function popPostponed(byContent) {
+ProcessExecution.prototype._popPostponed = function popPostponed(byContent) {
   const {postponed, detachedActivities} = this[kElements];
 
   const postponedIdx = postponed.findIndex((msg) => {
@@ -575,7 +581,7 @@ proto._popPostponed = function popPostponed(byContent) {
   return postponedMsg;
 };
 
-proto._onChildCompleted = function onChildCompleted(message) {
+ProcessExecution.prototype._onChildCompleted = function onChildCompleted(message) {
   this._stateChangeMessage(message, false);
   if (message.fields.redelivered) return message.ack();
 
@@ -611,7 +617,7 @@ proto._onChildCompleted = function onChildCompleted(message) {
   }
 };
 
-proto._stopExecution = function stopExecution(message) {
+ProcessExecution.prototype._stopExecution = function stopExecution(message) {
   const postponedCount = this.postponedCount;
   this._debug(`stop process execution (stop child executions ${postponedCount})`);
   if (postponedCount) {
@@ -625,7 +631,7 @@ proto._stopExecution = function stopExecution(message) {
   }, {type: 'stopped', persistent: false});
 };
 
-proto._onDiscard = function onDiscard() {
+ProcessExecution.prototype._onDiscard = function onDiscard() {
   this._deactivate();
   const running = this[kElements].postponed.splice(0);
   this._debug(`discard process execution (discard child executions ${running.length})`);
@@ -637,7 +643,7 @@ proto._onDiscard = function onDiscard() {
   return this._complete('discard');
 };
 
-proto._onApiMessage = function onApiMessage(routingKey, message) {
+ProcessExecution.prototype._onApiMessage = function onApiMessage(routingKey, message) {
   const executionId = this.executionId;
   const broker = this.broker;
   if (message.properties.delegate) {
@@ -678,7 +684,7 @@ proto._onApiMessage = function onApiMessage(routingKey, message) {
   }
 };
 
-proto._complete = function complete(completionType, content) {
+ProcessExecution.prototype._complete = function complete(completionType, content) {
   this._deactivate();
   this._debug(`process execution ${completionType}`);
   this[kCompleted] = true;
@@ -693,7 +699,7 @@ proto._complete = function complete(completionType, content) {
   }), {type: completionType, mandatory: completionType === 'error'});
 };
 
-proto._terminate = function terminate(message) {
+ProcessExecution.prototype._terminate = function terminate(message) {
   this[kStatus] = 'terminated';
   this._debug('terminating process execution');
 
@@ -711,23 +717,23 @@ proto._terminate = function terminate(message) {
   this[kActivityQ].purge();
 };
 
-proto._getFlowById = function getFlowById(flowId) {
+ProcessExecution.prototype._getFlowById = function getFlowById(flowId) {
   return this[kElements].flows.find((f) => f.id === flowId);
 };
 
-proto._getAssociationById = function getAssociationById(associationId) {
+ProcessExecution.prototype._getAssociationById = function getAssociationById(associationId) {
   return this[kElements].associations.find((a) => a.id === associationId);
 };
 
-proto._getMessageFlowById = function getMessageFlowById(flowId) {
+ProcessExecution.prototype._getMessageFlowById = function getMessageFlowById(flowId) {
   return this[kElements].outboundMessageFlows.find((f) => f.id === flowId);
 };
 
-proto._getChildById = function getChildById(childId) {
+ProcessExecution.prototype._getChildById = function getChildById(childId) {
   return this.getActivityById(childId) || this._getFlowById(childId);
 };
 
-proto._getChildApi = function getChildApi(message) {
+ProcessExecution.prototype._getChildApi = function getChildApi(message) {
   const content = message.content;
 
   let child = this._getChildById(content.id);
@@ -746,12 +752,12 @@ proto._getChildApi = function getChildApi(message) {
   }
 };
 
-proto._onShookEnd = function onShookEnd(message) {
+ProcessExecution.prototype._onShookEnd = function onShookEnd(message) {
   const routingKey = message.fields.routingKey;
   if (routingKey !== 'activity.shake.end') return;
   this[kElements].startSequences[message.content.id] = cloneMessage(message);
 };
 
-proto._debug = function debugMessage(logMessage) {
+ProcessExecution.prototype._debug = function debugMessage(logMessage) {
   this[kParent].logger.debug(`<${this.executionId} (${this.id})> ${logMessage}`);
 };

package/src/tasks/CallActivity.js

@@ -1,6 +1,6 @@
-import Activity from '../activity/Activity';
-import {ActivityError} from '../error/Errors';
-import {cloneContent} from '../messageHelper';
+import Activity from '../activity/Activity.js';
+import {ActivityError} from '../error/Errors.js';
+import {cloneContent} from '../messageHelper.js';
 
 export default function CallActivity(activityDef, context) {
   return new Activity(CallActivityBehaviour, activityDef, context);
@@ -18,9 +18,7 @@ export function CallActivityBehaviour(activity) {
   this.environment = activity.environment;
 }
 
-const proto = CallActivityBehaviour.prototype;
-
-proto.execute = function execute(executeMessage) {
+CallActivityBehaviour.prototype.execute = function execute(executeMessage) {
   const executeContent = executeMessage.content;
   const loopCharacteristics = this.loopCharacteristics;
   if (loopCharacteristics && executeContent.isRootScope) {
@@ -59,7 +57,7 @@ proto.execute = function execute(executeMessage) {
   });
 };
 
-proto._onDelegatedApiMessage = function onDelegatedApiMessage(calledElement, executeMessage, routingKey, message) {
+CallActivityBehaviour.prototype._onDelegatedApiMessage = function onDelegatedApiMessage(calledElement, executeMessage, routingKey, message) {
   if (!message.properties.delegate) return;
   const {content: delegateContent} = message;
   if (!delegateContent || !delegateContent.message) return;
@@ -82,7 +80,7 @@ proto._onDelegatedApiMessage = function onDelegatedApiMessage(calledElement, exe
   return this._onApiMessage(calledElement, executeMessage, routingKey, message);
 };
 
-proto._onApiMessage = function onApiMessage(calledElement, executeMessage, routingKey, message) {
+CallActivityBehaviour.prototype._onApiMessage = function onApiMessage(calledElement, executeMessage, routingKey, message) {
   const {type: messageType, correlationId} = message.properties;
   const executeContent = executeMessage.content;
 
@@ -123,7 +121,7 @@ proto._onApiMessage = function onApiMessage(calledElement, executeMessage, routi
   }
 };
 
-proto._stop = function stop(executionId) {
+CallActivityBehaviour.prototype._stop = function stop(executionId) {
   const broker = this.broker;
   broker.cancel(`_api-${executionId}`);
   broker.cancel(`_api-delegated-${executionId}`);

package/src/tasks/LoopCharacteristics.js

@@ -1,5 +1,5 @@
-import {RunError} from '../error/Errors';
-import {cloneContent, cloneMessage, unshiftParent, cloneParent} from '../messageHelper';
+import {RunError} from '../error/Errors.js';
+import {cloneContent, cloneMessage, unshiftParent, cloneParent} from '../messageHelper.js';
 
 export default function LoopCharacteristics(activity, loopCharacteristics) {
   this.activity = activity;