bpmn-elements 14.0.1 → 15.0.0

package/src/definition/DefinitionExecution.js

@@ -24,21 +24,21 @@ export default function DefinitionExecution(definition, context) {
   this.context = context;
 
   const processes = context.getProcesses();
-  const ids = [];
-  const executable = [];
+  const ids = new Set();
+  const executable = new Set();
   for (const bp of processes) {
     bp.environment.assignVariables(environment.variables);
     bp.environment.assignSettings(environment.settings);
-    ids.push(bp.id);
-    if (bp.isExecutable) executable.push(bp);
+    ids.add(bp.id);
+    if (bp.isExecutable) executable.add(bp);
   }
 
   this[kProcesses] = {
     processes,
-    running: [],
     ids,
     executable,
-    postponed: [],
+    running: new Set(),
+    postponed: new Set(),
   };
 
   broker.assertExchange('execution', 'topic', { autoDelete: false, durable: true });
@@ -79,12 +79,12 @@ Object.defineProperties(DefinitionExecution.prototype, {
   },
   processes: {
     get() {
-      return this[kProcesses].running;
+      return [...this[kProcesses].running];
     },
   },
   postponedCount: {
     get() {
-      return this[kProcesses].postponed.length;
+      return this[kProcesses].postponed.size;
     },
   },
   isRunning: {
@@ -96,7 +96,7 @@ Object.defineProperties(DefinitionExecution.prototype, {
     get() {
       let status = 'idle';
       const running = this[kProcesses].running;
-      if (!running || !running.length) return status;
+      if (!running.size) return status;
 
       for (const bp of running) {
         const bpStatus = bp.activityStatus;
@@ -143,13 +143,15 @@ DefinitionExecution.prototype.execute = function execute(executeMessage) {
   if (content.processId) {
     const startWithProcess = this.getProcessById(content.processId);
     if (startWithProcess) {
-      executable.splice(0);
-      executable.push(startWithProcess);
+      executable.clear();
+      executable.add(startWithProcess);
     }
   }
 
   this._debug('execute definition');
-  running.push(...executable);
+  for (const bp of executable) {
+    running.add(bp);
+  }
   this._activate(executable);
   this._start();
   return true;
@@ -162,7 +164,7 @@ DefinitionExecution.prototype.resume = function resume() {
 
   const { running, postponed } = this[kProcesses];
   this._activate(running);
-  postponed.splice(0);
+  postponed.clear();
   this[kProcessesQ].consume(this[kMessageHandlers].onProcessMessage, {
     prefetch: 1000,
     consumerTag: `_definition-activity-${this.executionId}`,
@@ -184,22 +186,22 @@ DefinitionExecution.prototype.recover = function recover(state) {
   this._debug(`recover ${this[kStatus]} definition execution`);
 
   const running = this[kProcesses].running;
-  running.splice(0);
+  running.clear();
 
-  const ids = [];
+  const ids = new Set();
   for (const bpState of state.processes) {
     const bpid = bpState.id;
     let bp;
-    if (ids.indexOf(bpid) > -1) {
+    if (ids.has(bpid)) {
       bp = this.context.getNewProcessById(bpid);
     } else {
       bp = this.getProcessById(bpid);
     }
     if (!bp) continue;
 
-    ids.push(bpid);
+    ids.add(bpid);
     bp.recover(bpState);
-    running.push(bp);
+    running.add(bp);
   }
 
   return this;
@@ -211,7 +213,7 @@ DefinitionExecution.prototype.stop = function stop() {
 
 DefinitionExecution.prototype.getProcesses = function getProcesses() {
   const { running, processes } = this[kProcesses];
-  const result = running.slice();
+  const result = [...running];
   for (const bp of processes) {
     if (!result.find((runningBp) => bp.id === runningBp.id)) result.push(bp);
   }
@@ -227,26 +229,31 @@ DefinitionExecution.prototype.getProcessesById = function getProcessesById(proce
 };
 
 DefinitionExecution.prototype.getProcessByExecutionId = function getProcessByExecutionId(processExecutionId) {
-  const running = this[kProcesses].running;
-  return running.find((bp) => bp.executionId === processExecutionId);
+  for (const bp of this[kProcesses].running) {
+    if (bp.executionId === processExecutionId) return bp;
+  }
 };
 
 DefinitionExecution.prototype.getRunningProcesses = function getRunningProcesses() {
-  const running = this[kProcesses].running;
-  return running.filter((bp) => bp.executionId);
+  return [...this[kProcesses].running].filter((bp) => bp.executionId);
 };
 
 DefinitionExecution.prototype.getExecutableProcesses = function getExecutableProcesses() {
-  return this[kProcesses].executable.slice();
+  return [...this[kProcesses].executable];
 };
 
 DefinitionExecution.prototype.getState = function getState() {
+  const processes = [];
+  for (const bp of this[kProcesses].running) {
+    processes.push(bp.getState());
+  }
+
   return {
     executionId: this.executionId,
     stopped: this[kStopped],
     completed: this[kCompleted],
     status: this[kStatus],
-    processes: this[kProcesses].running.map((bp) => bp.getState()),
+    processes,
   };
 };
 
@@ -263,31 +270,32 @@ DefinitionExecution.prototype.getApi = function getApi(apiMessage) {
   const self = this;
 
   api.getExecuting = function getExecuting() {
-    return postponed.reduce((result, msg) => {
+    const apis = [];
+    for (const msg of postponed) {
       const bpApi = self._getProcessApi(msg);
-      if (bpApi) result.push(bpApi);
-      return result;
-    }, []);
+      if (bpApi) apis.push(bpApi);
+    }
+    return apis;
   };
 
   return api;
 };
 
 DefinitionExecution.prototype.getPostponed = function getPostponed(...args) {
-  const running = this[kProcesses].running;
-  return running.reduce((result, p) => {
-    result = result.concat(p.getPostponed(...args));
-    return result;
-  }, []);
+  let result = [];
+  for (const bp of this[kProcesses].running) {
+    result = result.concat(bp.getPostponed(...args));
+  }
+  return result;
 };
 
 DefinitionExecution.prototype._start = function start() {
   const { ids, executable, postponed } = this[kProcesses];
-  if (!ids.length) {
+  if (!ids.size) {
     return this._complete('completed');
   }
 
-  if (!executable.length) {
+  if (!executable.size) {
     return this._complete('error', { error: new Error('No executable process') });
   }
 
@@ -296,7 +304,7 @@ DefinitionExecution.prototype._start = function start() {
   for (const bp of executable) bp.init();
   for (const bp of executable) bp.run();
 
-  postponed.splice(0);
+  postponed.clear();
   this[kProcessesQ].assertConsumer(this[kMessageHandlers].onProcessMessage, {
     prefetch: 1000,
     consumerTag: `_definition-activity-${this.executionId}`,
@@ -348,7 +356,7 @@ DefinitionExecution.prototype._onChildEvent = function onChildEvent(routingKey,
   const content = message.content;
   const parent = (content.parent = content.parent || {});
 
-  const isDirectChild = this[kProcesses].ids.indexOf(content.id) > -1;
+  const isDirectChild = this[kProcesses].ids.has(content.id);
   if (isDirectChild) {
     parent.executionId = this.executionId;
   } else {
@@ -434,7 +442,7 @@ DefinitionExecution.prototype._onProcessMessage = function onProcessMessage(rout
           { mandatory: true, type: 'error' },
         );
       } else {
-        for (const bp of this[kProcesses].running.slice()) {
+        for (const bp of new Set(this[kProcesses].running)) {
           if (bp.id !== childId) bp.stop();
         }
 
@@ -450,13 +458,16 @@ DefinitionExecution.prototype._onProcessMessage = function onProcessMessage(rout
 DefinitionExecution.prototype._stateChangeMessage = function stateChangeMessage(message, postponeMessage) {
   let previousMsg;
   const postponed = this[kProcesses].postponed;
-  const idx = postponed.findIndex((msg) => msg.content.executionId === message.content.executionId);
-  if (idx > -1) {
-    previousMsg = postponed.splice(idx, 1)[0];
+  for (const msg of postponed) {
+    if (msg.content.executionId === message.content.executionId) {
+      previousMsg = msg;
+      postponed.delete(msg);
+      break;
+    }
   }
 
   if (previousMsg) previousMsg.ack();
-  if (postponeMessage) postponed.push(message);
+  if (postponeMessage) postponed.add(message);
 };
 
 DefinitionExecution.prototype._onProcessCompleted = function onProcessCompleted(message) {
@@ -479,9 +490,9 @@ DefinitionExecution.prototype._onProcessCompleted = function onProcessCompleted(
 
 DefinitionExecution.prototype._onStopped = function onStopped(message) {
   const running = this[kProcesses].running;
-  this._debug(`stop definition execution (stop process executions ${running.length})`);
+  this._debug(`stop definition execution (stop process executions ${running.size})`);
   this[kProcessesQ].close();
-  for (const bp of running.slice()) bp.stop();
+  for (const bp of new Set(running)) bp.stop();
   this._deactivate();
 
   this[kStopped] = true;
@@ -505,7 +516,7 @@ DefinitionExecution.prototype._onApiMessage = function onApiMessage(routingKey,
   }
 
   if (delegate) {
-    for (const bp of this[kProcesses].running.slice()) {
+    for (const bp of new Set(this[kProcesses].running)) {
       bp.broker.publish('api', routingKey, cloneContent(message.content), message.properties);
     }
   }
@@ -528,7 +539,7 @@ DefinitionExecution.prototype._startProcessesByMessage = function startProcesses
     if (!bp.executionId) {
       this._debug(`start <${bp.id}> by <${reference.referenceId}> (${reference.referenceType})`);
       this._activateProcess(bp);
-      running.push(bp);
+      running.add(bp);
       bp.init();
       bp.run();
       if (reference.referenceType === 'message') return;
@@ -539,7 +550,7 @@ DefinitionExecution.prototype._startProcessesByMessage = function startProcesses
 
     const targetProcess = this.context.getNewProcessById(bp.id);
     this._activateProcess(targetProcess);
-    running.push(targetProcess);
+    running.add(targetProcess);
     targetProcess.init();
     targetProcess.run();
     if (reference.referenceType === 'message') return;
@@ -573,7 +584,7 @@ DefinitionExecution.prototype._onMessageOutbound = function onMessageOutbound(ro
   targetProcess = targetProcess || this.context.getNewProcessById(target.processId);
 
   this._activateProcess(targetProcess);
-  this[kProcesses].running.push(targetProcess);
+  this[kProcesses].running.add(targetProcess);
   targetProcess.init();
   targetProcess.run();
   targetProcess.sendMessage(message);
@@ -605,7 +616,7 @@ DefinitionExecution.prototype._onCallActivity = function onCallActivity(routingK
   this._debug(`call from <${fromParent.id}.${fromId}> to <${calledElement}>`);
 
   this._activateProcess(targetProcess);
-  this[kProcesses].running.push(targetProcess);
+  this[kProcesses].running.add(targetProcess);
   targetProcess.init(bpExecutionId);
   targetProcess.run({ inbound: [cloneContent(content)] });
 };
@@ -672,10 +683,9 @@ DefinitionExecution.prototype._onDelegateMessage = function onDelegateMessage(ro
 };
 
 DefinitionExecution.prototype._removeProcessByExecutionId = function removeProcessByExecutionId(processExecutionId) {
-  const running = this[kProcesses].running;
-  const idx = running.findIndex((p) => p.executionId === processExecutionId);
-  if (idx === -1) return;
-  return running.splice(idx, 1)[0];
+  const bp = this.getProcessByExecutionId(processExecutionId);
+  if (bp) this[kProcesses].running.delete(bp);
+  return bp;
 };
 
 DefinitionExecution.prototype._complete = function complete(completionType, content, options) {

package/src/eventDefinitions/SignalEventDefinition.js

@@ -108,7 +108,7 @@ SignalEventDefinition.prototype.executeThrow = function executeThrow(executeMess
   throwContent.parent = shiftParent(parent);
 
   const broker = this.broker;
-  broker.publish('event', 'activity.signal', throwContent, { type: 'signal' });
+  broker.publish('event', 'activity.signal', throwContent, { type: 'signal', delegate: true });
 
   return broker.publish('execution', 'execute.completed', cloneContent(executeContent));
 };

package/src/events/BoundaryEvent.js

@@ -22,8 +22,8 @@ export function BoundaryEventBehaviour(activity) {
   this.broker = activity.broker;
   this[kExecution] =
     activity.eventDefinitions && new EventDefinitionExecution(activity, activity.eventDefinitions, 'execute.bound.completed');
-  this[kShovels] = [];
-  this[kAttachedTags] = [];
+  this[kShovels] = new Set();
+  this[kAttachedTags] = new Set();
 }
 
 Object.defineProperties(BoundaryEventBehaviour.prototype, {
@@ -60,7 +60,7 @@ BoundaryEventBehaviour.prototype.execute = function execute(executeMessage) {
       consumerTag,
       priority: 300,
     });
-    this[kAttachedTags].push(consumerTag);
+    this[kAttachedTags].add(consumerTag);
 
     broker.subscribeOnce('api', `activity.#.${executionId}`, this._onApiMessage.bind(this), {
       consumerTag: `_api-${executionId}`,
@@ -118,7 +118,7 @@ BoundaryEventBehaviour.prototype._onCompleted = function onCompleted(_, { conten
 
   if (content.isRecovered && !attachedTo.isRunning) {
     const attachedExecuteTag = `_on-attached-execute-${executionId}`;
-    this[kAttachedTags].push(attachedExecuteTag);
+    this[kAttachedTags].add(attachedExecuteTag);
     attachedTo.broker.subscribeOnce(
       'execution',
       '#',
@@ -146,7 +146,7 @@ BoundaryEventBehaviour.prototype._onExpectMessage = function onExpectMessage(_,
   const attachedTo = this.attachedTo;
 
   const errorConsumerTag = `_bound-error-listener-${executionId}`;
-  this[kAttachedTags].push(errorConsumerTag);
+  this[kAttachedTags].add(errorConsumerTag);
 
   attachedTo.broker.subscribeTmp(
     'event',
@@ -177,7 +177,7 @@ BoundaryEventBehaviour.prototype._onDetachMessage = function onDetachMessage(_,
   const { executionId: detachId, bindExchange, sourceExchange, sourcePattern } = content;
 
   const shovelName = `_detached-${brokerSafeId(id)}_${detachId}`;
-  this[kShovels].push(shovelName);
+  this[kShovels].add(shovelName);
 
   const broker = this.broker;
   attachedTo.broker.createShovel(
@@ -238,8 +238,10 @@ BoundaryEventBehaviour.prototype._stop = function stop(detach) {
   const attachedTo = this.attachedTo,
     broker = this.broker,
     executionId = this.executionId;
-  for (const tag of this[kAttachedTags].splice(0)) attachedTo.broker.cancel(tag);
-  for (const shovelName of this[kShovels].splice(0)) attachedTo.broker.closeShovel(shovelName);
+  for (const tag of this[kAttachedTags]) attachedTo.broker.cancel(tag);
+  this[kAttachedTags].clear();
+  for (const shovelName of this[kShovels]) attachedTo.broker.closeShovel(shovelName);
+  this[kShovels].clear();
 
   broker.cancel('_execution-tag');
   broker.cancel(`_execution-completed-${executionId}`);

package/src/process/ProcessExecution.js

@@ -29,15 +29,15 @@ function ProcessExecution(parentActivity, context) {
   this.context = context;
 
   this[kElements] = {
+    postponed: new Set(),
     children: context.getActivities(id),
     associations: context.getAssociations(id),
     flows: context.getSequenceFlows(id),
     outboundMessageFlows: context.getMessageFlows(id),
     startActivities: [],
     triggeredByEvent: [],
-    detachedActivities: [],
+    detachedActivities: new Set(),
     startSequences: {},
-    postponed: [],
   };
 
   const exchangeName = (this._exchangeName = isSubProcess ? 'subprocess-execution' : 'execution');
@@ -76,7 +76,7 @@ Object.defineProperties(ProcessExecution.prototype, {
   },
   postponedCount: {
     get() {
-      return this[kElements].postponed.length;
+      return this[kElements].postponed.size;
     },
   },
   isRunning: {
@@ -130,8 +130,8 @@ ProcessExecution.prototype.resume = function resume() {
     for (const a of startActivities) a.shake();
   }
 
-  postponed.splice(0);
-  detachedActivities.splice(0);
+  postponed.clear();
+  detachedActivities.clear();
 
   this[kActivityQ].consume(this[kMessageHandlers].onChildMessage, {
     prefetch: 1000,
@@ -144,7 +144,7 @@ ProcessExecution.prototype.resume = function resume() {
   if (status === 'init') return this._start();
 
   const tracker = this[kTracker];
-  for (const msg of postponed.slice()) {
+  for (const msg of new Set(postponed)) {
     const activity = this.getActivityById(msg.content.id);
     if (!activity) continue;
     if (msg.content.placeholder) continue;
@@ -160,7 +160,7 @@ ProcessExecution.prototype.resume = function resume() {
 
   if (this[kCompleted]) return;
 
-  if (!postponed.length && status === 'executing') return this._complete('completed');
+  if (!postponed.size && status === 'executing') return this._complete('completed');
 };
 
 ProcessExecution.prototype.getState = function getState() {
@@ -283,7 +283,7 @@ ProcessExecution.prototype.stop = function stop() {
 
 ProcessExecution.prototype.getPostponed = function getPostponed(filterFn) {
   const result = [];
-  for (const msg of this[kElements].postponed.slice()) {
+  for (const msg of this[kElements].postponed) {
     const api = this._getChildApi(msg);
     if (!api) continue;
     if (filterFn && !filterFn(api)) continue;
@@ -347,11 +347,12 @@ ProcessExecution.prototype.getApi = function getApi(message) {
   const self = this;
 
   api.getExecuting = function getExecuting() {
-    return postponed.reduce((result, msg) => {
+    const result = [];
+    for (const msg of postponed) {
       const childApi = self._getChildApi(msg);
       if (childApi) result.push(childApi);
-      return result;
-    }, []);
+    }
+    return result;
   };
 
   return api;
@@ -377,8 +378,8 @@ ProcessExecution.prototype._start = function start() {
   this[kStatus] = 'executing';
   for (const a of startActivities) a.run();
 
-  postponed.splice(0);
-  detachedActivities.splice(0);
+  postponed.clear();
+  detachedActivities.clear();
   this[kActivityQ].assertConsumer(this[kMessageHandlers].onChildMessage, {
     prefetch: 1000,
     consumerTag: `_process-activity-${this.executionId}`,
@@ -565,9 +566,13 @@ ProcessExecution.prototype._onChildMessage = function onChildMessage(routingKey,
       message.ack();
       return this._onCancel(message);
     case 'activity.error.caught': {
-      const prevMsg = this[kElements].postponed.find((msg) => {
-        return msg.content.executionId === content.executionId;
-      });
+      let prevMsg;
+      for (const msg of this[kElements].postponed) {
+        if (msg.content.executionId === content.executionId) {
+          prevMsg = msg;
+          break;
+        }
+      }
       if (!prevMsg) return message.ack();
       break;
     }
@@ -580,7 +585,7 @@ ProcessExecution.prototype._onChildMessage = function onChildMessage(routingKey,
 
   switch (routingKey) {
     case 'activity.detach': {
-      this[kElements].detachedActivities.push(cloneMessage(message));
+      this[kElements].detachedActivities.add(cloneMessage(message));
       break;
     }
     case 'activity.cancel': {
@@ -600,10 +605,13 @@ ProcessExecution.prototype._onChildMessage = function onChildMessage(routingKey,
       break;
     }
     case 'activity.error': {
-      const eventCaughtBy = this[kElements].postponed.find((msg) => {
-        if (msg.fields.routingKey !== 'activity.catch') return;
-        return msg.content.source && msg.content.source.executionId === content.executionId;
-      });
+      let eventCaughtBy;
+      for (const msg of this[kElements].postponed) {
+        if (msg.fields.routingKey === 'activity.catch' && msg.content.source && msg.content.source.executionId === content.executionId) {
+          eventCaughtBy = msg;
+          break;
+        }
+      }
       if (eventCaughtBy) {
         this[kActivityQ].queueMessage({ routingKey: 'activity.error.caught' }, cloneContent(content), {
           persistent: true,
@@ -619,24 +627,38 @@ ProcessExecution.prototype._onChildMessage = function onChildMessage(routingKey,
 ProcessExecution.prototype._stateChangeMessage = function stateChangeMessage(message, postponeMessage) {
   const previousMsg = this._popPostponed(message.content);
   if (previousMsg) previousMsg.ack();
-  if (postponeMessage) this[kElements].postponed.push(message);
+  if (postponeMessage) this[kElements].postponed.add(message);
 };
 
 ProcessExecution.prototype._popPostponed = function popPostponed(byContent) {
   const { postponed, detachedActivities } = this[kElements];
 
-  const postponedIdx = postponed.findIndex((msg) => {
-    if (msg.content.isSequenceFlow || msg.content.isAssociation) return msg.content.sequenceId === byContent.sequenceId;
-    return msg.content.executionId === byContent.executionId;
-  });
-
   let postponedMsg;
-  if (postponedIdx > -1) {
-    postponedMsg = postponed.splice(postponedIdx, 1)[0];
+  if (byContent.sequenceId) {
+    for (const msg of postponed) {
+      if (!msg.content.isSequenceFlow && !msg.content.isAssociation) continue;
+      if (msg.content.sequenceId === byContent.sequenceId) {
+        postponedMsg = msg;
+        break;
+      }
+    }
+  } else {
+    for (const msg of postponed) {
+      if (msg.content.executionId === byContent.executionId) {
+        postponedMsg = msg;
+        break;
+      }
+    }
   }
 
-  const detachedIdx = detachedActivities.findIndex((msg) => msg.content.executionId === byContent.executionId);
-  if (detachedIdx > -1) detachedActivities.splice(detachedIdx, 1);
+  if (postponedMsg) postponed.delete(postponedMsg);
+
+  for (const msg of detachedActivities) {
+    if (msg.content.executionId === byContent.executionId) {
+      detachedActivities.delete(msg);
+      break;
+    }
+  }
 
   return postponedMsg;
 };
@@ -648,7 +670,7 @@ ProcessExecution.prototype._onChildCompleted = function onChildCompleted(message
   const { id, type, isEnd } = message.content;
 
   const { postponed, detachedActivities, startActivities } = this[kElements];
-  const postponedCount = postponed.length;
+  const postponedCount = postponed.size;
 
   if (!postponedCount) {
     this._debug(`left <${id}> (${type}), pending runs ${postponedCount}`);
@@ -657,9 +679,9 @@ ProcessExecution.prototype._onChildCompleted = function onChildCompleted(message
   }
 
   message.ack();
-  this._debug(`left <${id}> (${type}), pending runs ${postponedCount}, ${postponed.map((a) => a.content.id).join(',')}`);
+  this._debug(`left <${id}> (${type}), pending activities ${postponedCount}`);
 
-  if (postponedCount && postponedCount === detachedActivities.length) {
+  if (postponedCount && postponedCount === detachedActivities.size) {
     return this[kActivityQ].queueMessage(
       { routingKey: 'execution.discard.detached' },
       {
@@ -706,8 +728,11 @@ ProcessExecution.prototype._stopExecution = function stopExecution(message) {
 
 ProcessExecution.prototype._onDiscard = function onDiscard() {
   this._deactivate();
-  const running = this[kElements].postponed.splice(0);
-  this._debug(`discard process execution (discard child executions ${running.length})`);
+  const postponed = this[kElements].postponed;
+  const running = new Set(postponed);
+  postponed.clear();
+
+  this._debug(`discard process execution (discard child executions ${running.size})`);
 
   if (this.isSubProcess) {
     this.stop();
@@ -722,11 +747,13 @@ ProcessExecution.prototype._onDiscard = function onDiscard() {
 };
 
 ProcessExecution.prototype._onCancel = function onCancel() {
-  const running = this[kElements].postponed.slice(0);
+  const postponed = this[kElements].postponed;
+  const running = new Set(postponed);
+
   const isTransaction = this.isTransaction;
 
   if (isTransaction) {
-    this._debug(`cancel transaction execution (cancel child executions ${running.length})`);
+    this._debug(`cancel transaction execution (cancel child executions ${running.size})`);
     this[kStatus] = 'cancel';
     this.broker.publish(
       'event',
@@ -744,7 +771,7 @@ ProcessExecution.prototype._onCancel = function onCancel() {
       }
     }
   } else {
-    this._debug(`cancel process execution (cancel child executions ${running.length})`);
+    this._debug(`cancel process execution (cancel child executions ${running.size})`);
     for (const msg of running) {
       this._getChildApi(msg).discard();
     }
@@ -839,7 +866,10 @@ ProcessExecution.prototype._terminate = function terminate(message) {
   this[kStatus] = 'terminated';
   this._debug('terminating process execution');
 
-  const running = this[kElements].postponed.splice(0);
+  const postponed = this[kElements].postponed;
+  const running = new Set(postponed);
+  postponed.clear();
+
   for (const flow of this.getSequenceFlows()) flow.stop();
   for (const flow of this.getAssociations()) flow.stop();
 

package/src/tasks/LoopCharacteristics.js

@@ -146,12 +146,12 @@ ParallelLoopCharacteristics.prototype.execute = function execute(executeMessage)
 ParallelLoopCharacteristics.prototype._startBatch = function startBatch() {
   const chr = this.characteristics;
   const cardinality = chr.cardinality;
-  const batch = [];
+  const batch = new Set();
 
   let startContent = chr.next(this.index);
   do {
     chr.debug(`start parallel iteration index ${this.index}`);
-    batch.push(startContent);
+    batch.add(startContent);
     this.running++;
     this.index++;