bpmn-elements 17.3.0 → 18.0.1

package/src/process/ProcessExecution.js

@@ -2,24 +2,25 @@ import { ProcessApi } from '../Api.js';
 import { cloneContent, cloneMessage, pushParent } from '../messageHelper.js';
 import { getUniqueId } from '../shared.js';
 import { ActivityTracker } from '../Tracker.js';
-
-export default ProcessExecution;
-
-const kActivated = Symbol.for('activated');
-const kActivityQ = Symbol.for('activityQ');
-const kCompleted = Symbol.for('completed');
-const kElements = Symbol.for('elements');
-const kExecuteMessage = Symbol.for('executeMessage');
-const kMessageHandlers = Symbol.for('messageHandlers');
-const kParent = Symbol.for('parent');
-const kStatus = Symbol.for('status');
-const kStopped = Symbol.for('stopped');
-const kTracker = Symbol.for('activity tracker');
-
-function ProcessExecution(parentActivity, context) {
+import { K_ACTIVATED, K_COMPLETED, K_EXECUTE_MESSAGE, K_MESSAGE_HANDLERS, K_STATUS, K_STOPPED, STATE_VERSION } from '../constants.js';
+
+const K_ACTIVITY_Q = Symbol.for('activityQ');
+const K_ELEMENTS = Symbol.for('elements');
+const K_PARENT = Symbol.for('parent');
+const K_TRACKER = Symbol.for('activity tracker');
+const K_PEERS_DISCOVERED = Symbol.for('peers discovered');
+const K_RECOVERED_VERSION = Symbol.for('recovered version');
+
+/**
+ * Drives the execution of a single process or sub-process: activates children, routes activity
+ * events, and rolls completion up to the owning Process or sub-process Activity.
+ * @param {import('#types').Process | import('#types').Activity} parentActivity
+ * @param {import('#types').ContextInstance} context
+ */
+export function ProcessExecution(parentActivity, context) {
   const { id, type, broker, isSubProcess, isTransaction } = parentActivity;
 
-  this[kParent] = parentActivity;
+  this[K_PARENT] = parentActivity;
   this.id = id;
   this.type = type;
   this.isSubProcess = isSubProcess;
@@ -28,29 +29,30 @@ function ProcessExecution(parentActivity, context) {
   this.environment = context.environment;
   this.context = context;
 
-  this[kElements] = {
+  this[K_ELEMENTS] = {
     postponed: new Set(),
     children: context.getActivities(id),
     associations: context.getAssociations(id),
     flows: context.getSequenceFlows(id),
     outboundMessageFlows: context.getMessageFlows(id),
     startActivities: new Set(),
+    startEventCount: 0,
     triggeredByEvent: new Set(),
     detachedActivities: new Set(),
-    startSequences: {},
+    convergingGateways: new Set(),
   };
 
   const exchangeName = (this._exchangeName = isSubProcess ? 'subprocess-execution' : 'execution');
   broker.assertExchange(exchangeName, 'topic', { autoDelete: false, durable: true });
 
-  this[kCompleted] = false;
-  this[kStopped] = false;
-  this[kActivated] = false;
-  this[kStatus] = 'init';
-  this[kTracker] = new ActivityTracker(id);
+  this[K_COMPLETED] = false;
+  this[K_STOPPED] = false;
+  this[K_ACTIVATED] = false;
+  this[K_STATUS] = 'init';
+  this[K_TRACKER] = new ActivityTracker(id);
   this.executionId = undefined;
 
-  this[kMessageHandlers] = {
+  this[K_MESSAGE_HANDLERS] = {
     onActivityEvent: this._onActivityEvent.bind(this),
     onApiMessage: this._onApiMessage.bind(this),
     onChildMessage: this._onChildMessage.bind(this),
@@ -61,51 +63,56 @@ function ProcessExecution(parentActivity, context) {
 Object.defineProperties(ProcessExecution.prototype, {
   stopped: {
     get() {
-      return this[kStopped];
+      return this[K_STOPPED];
     },
   },
   completed: {
     get() {
-      return this[kCompleted];
+      return this[K_COMPLETED];
     },
   },
   status: {
     get() {
-      return this[kStatus];
+      return this[K_STATUS];
     },
   },
   postponedCount: {
     get() {
-      return this[kElements].postponed.size;
+      return this[K_ELEMENTS].postponed.size;
     },
   },
   isRunning: {
     get() {
-      return this[kActivated];
+      return this[K_ACTIVATED];
     },
   },
   activityStatus: {
     get() {
-      return this[kTracker].activityStatus;
+      return this[K_TRACKER].activityStatus;
     },
   },
 });
 
+/**
+ * Activate children and start the process execution. Resumes if the message is redelivered.
+ * @param {import('#types').ElementBrokerMessage} executeMessage
+ * @throws {Error} when message or executionId is missing
+ */
 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');
 
   const executionId = (this.executionId = executeMessage.content.executionId);
 
-  this[kExecuteMessage] = cloneMessage(executeMessage, {
+  this[K_EXECUTE_MESSAGE] = cloneMessage(executeMessage, {
     executionId,
     state: 'start',
   });
 
-  this[kStopped] = false;
+  this[K_STOPPED] = false;
 
   this.environment.assignVariables(executeMessage);
-  this[kActivityQ] = this.broker.assertQueue(`execute-${executionId}-q`, { durable: true, autoDelete: false });
+  this[K_ACTIVITY_Q] = this.broker.assertQueue(`execute-${executionId}-q`, { durable: true, autoDelete: false });
 
   if (executeMessage.fields.redelivered) {
     return this.resume();
@@ -117,33 +124,33 @@ ProcessExecution.prototype.execute = function execute(executeMessage) {
   return true;
 };
 
+/**
+ * Resume after recover, resuming any postponed children.
+ */
 ProcessExecution.prototype.resume = function resume() {
   this._debug(`resume process execution at ${this.status}`);
 
-  if (this[kCompleted]) return this._complete('completed');
+  if (this[K_COMPLETED]) return this._complete('completed');
 
   this._activate();
 
-  const { startActivities, detachedActivities, postponed } = this[kElements];
-
-  if (startActivities.size > 1) {
-    for (const a of startActivities) a.shake();
-  }
+  const { postponed, detachedActivities } = this[K_ELEMENTS];
+  this._shakeOnStart();
 
   postponed.clear();
   detachedActivities.clear();
 
-  this[kActivityQ].consume(this[kMessageHandlers].onChildMessage, {
+  this[K_ACTIVITY_Q].consume(this[K_MESSAGE_HANDLERS].onChildMessage, {
     prefetch: 1000,
     consumerTag: `_process-activity-${this.executionId}`,
   });
 
-  if (this[kCompleted]) return;
+  if (this[K_COMPLETED]) return;
 
   const status = this.status;
   if (status === 'init') return this._start();
 
-  const tracker = this[kTracker];
+  const tracker = this[K_TRACKER];
   for (const msg of new Set(postponed)) {
     const activity = this.getActivityById(msg.content.id);
     if (!activity) continue;
@@ -158,13 +165,21 @@ ProcessExecution.prototype.resume = function resume() {
     activity.resume();
   }
 
-  if (this[kCompleted]) return;
+  if (this[K_COMPLETED]) return;
+
+  this._reconcileStartEvents();
+
+  if (this[K_COMPLETED]) return;
 
   if (!postponed.size && status === 'executing') return this._complete('completed');
 };
 
+/**
+ * Snapshot execution state including children, flows, message flows, and associations.
+ * @returns {import('#types').ProcessExecutionState}
+ */
 ProcessExecution.prototype.getState = function getState() {
-  const { children, flows, outboundMessageFlows, associations } = this[kElements];
+  const { children, flows, outboundMessageFlows, associations } = this[K_ELEMENTS];
 
   const flowStates = flows.reduce((result, flow) => {
     const elmState = flow.getState();
@@ -174,8 +189,8 @@ ProcessExecution.prototype.getState = function getState() {
 
   return {
     executionId: this.executionId,
-    stopped: this[kStopped],
-    completed: this[kCompleted],
+    stopped: this[K_STOPPED],
+    completed: this[K_COMPLETED],
     status: this.status,
     children: children.reduce((result, activity) => {
       if (activity.placeholder) return result;
@@ -191,13 +206,20 @@ ProcessExecution.prototype.getState = function getState() {
   };
 };
 
-ProcessExecution.prototype.recover = function recover(state) {
+/**
+ * Restore execution state captured by getState.
+ * @param {import('#types').ProcessExecutionState} [state]
+ * @param {number} [recoveredVersion] State version
+ * @returns {this}
+ */
+ProcessExecution.prototype.recover = function recover(state, recoveredVersion) {
   if (!state) return this;
   this.executionId = state.executionId;
+  this[K_RECOVERED_VERSION] = recoveredVersion;
 
-  this[kStopped] = state.stopped;
-  this[kCompleted] = state.completed;
-  this[kStatus] = state.status;
+  this[K_STOPPED] = state.stopped;
+  this[K_COMPLETED] = state.completed;
+  this[K_STATUS] = state.status;
 
   this._debug(`recover process execution at ${this.status}`);
 
@@ -237,53 +259,29 @@ ProcessExecution.prototype.recover = function recover(state) {
   return this;
 };
 
+/**
+ * Walk activity graph from the given start id, or every start activity when omitted.
+ * @param {string} [fromId]
+ * @returns {import('#types').ShakeResult}
+ */
 ProcessExecution.prototype.shake = function shake(fromId) {
-  let executing = true;
-  const id = this.id;
-  if (!this.isRunning) {
-    executing = false;
-    this.executionId = getUniqueId(id);
-    this._activate();
-  }
-  const toShake = fromId ? [this.getActivityById(fromId)].filter(Boolean) : this[kElements].startActivities;
-
-  const result = {};
-  this.broker.subscribeTmp(
-    'event',
-    '*.shake.*',
-    (routingKey, { content }) => {
-      let isLooped = false;
-      switch (routingKey) {
-        case 'flow.shake.loop':
-          isLooped = true;
-        case 'activity.shake.end': {
-          const { id: shakeId, parent: shakeParent } = content;
-          if (shakeParent.id !== id) return;
-
-          result[shakeId] = result[shakeId] || [];
-          result[shakeId].push({ ...content, isLooped });
-          break;
-        }
-      }
-    },
-    { noAck: true, consumerTag: `_shaker-${this.executionId}` }
-  );
-
-  for (const a of toShake) a.shake();
-
-  if (!executing) this._deactivate();
-  this.broker.cancel(`_shaker-${this.executionId}`);
-
-  return result;
+  return Object.fromEntries(this._shakeElements(fromId).sequences);
 };
 
+/**
+ * Stop the running process execution via the api.
+ */
 ProcessExecution.prototype.stop = function stop() {
   this.getApi().stop();
 };
 
+/**
+ * List currently postponed children as Api wrappers.
+ * @param {import('#types').filterPostponed} [filterFn]
+ */
 ProcessExecution.prototype.getPostponed = function getPostponed(filterFn) {
   const result = [];
-  for (const msg of this[kElements].postponed) {
+  for (const msg of this[K_ELEMENTS].postponed) {
     const api = this._getChildApi(msg);
     if (!api) continue;
     if (filterFn && !filterFn(api)) continue;
@@ -292,9 +290,12 @@ ProcessExecution.prototype.getPostponed = function getPostponed(filterFn) {
   return result;
 };
 
+/**
+ * Queue a discard message that propagates to all running children.
+ */
 ProcessExecution.prototype.discard = function discard() {
-  this[kStatus] = 'discard';
-  return this[kActivityQ].queueMessage(
+  this[K_STATUS] = 'discard';
+  this[K_ACTIVITY_Q].queueMessage(
     { routingKey: 'execution.discard' },
     {
       id: this.id,
@@ -305,8 +306,11 @@ ProcessExecution.prototype.discard = function discard() {
   );
 };
 
+/**
+ * Queue a cancel message that propagates to all running children.
+ */
 ProcessExecution.prototype.cancel = function discard() {
-  return this[kActivityQ].queueMessage(
+  this[K_ACTIVITY_Q].queueMessage(
     { routingKey: 'execution.cancel' },
     {
       id: this.id,
@@ -317,24 +321,45 @@ ProcessExecution.prototype.cancel = function discard() {
   );
 };
 
+/**
+ * Get child activities in the process scope.
+ * @returns {import('#types').Activity[]}
+ */
 ProcessExecution.prototype.getActivities = function getActivities() {
-  return this[kElements].children.slice();
+  return this[K_ELEMENTS].children.slice();
 };
 
+/**
+ * @param {string} activityId
+ * @returns {import('#types').Activity}
+ */
 ProcessExecution.prototype.getActivityById = function getActivityById(activityId) {
-  return this[kElements].children.find((child) => child.id === activityId);
+  return this[K_ELEMENTS].children.find((child) => child.id === activityId);
 };
 
+/**
+ * Get sequence flows in the process scope.
+ * @returns {import('#types').SequenceFlow}
+ */
 ProcessExecution.prototype.getSequenceFlows = function getSequenceFlows() {
-  return this[kElements].flows.slice();
+  return this[K_ELEMENTS].flows.slice();
 };
 
+/**
+ * Get associations in the process scope.
+ * @returns {import('../flows/Association.js').Association}
+ */
 ProcessExecution.prototype.getAssociations = function getAssociations() {
-  return this[kElements].associations.slice();
+  return this[K_ELEMENTS].associations.slice();
 };
 
+/**
+ * Resolve a process or child Api for the given message.
+ * @param {import('#types').ElementBrokerMessage} [message]
+ * @returns {import('#types').IApi<import('#types').Process>}
+ */
 ProcessExecution.prototype.getApi = function getApi(message) {
-  if (!message) return ProcessApi(this.broker, this[kExecuteMessage]);
+  if (!message) return ProcessApi(this.broker, this[K_EXECUTE_MESSAGE]);
 
   const content = message.content;
 
@@ -343,7 +368,7 @@ ProcessExecution.prototype.getApi = function getApi(message) {
   }
 
   const api = ProcessApi(this.broker, message);
-  const postponed = this[kElements].postponed;
+  const postponed = this[K_ELEMENTS].postponed;
   const self = this;
 
   api.getExecuting = function getExecuting() {
@@ -358,36 +383,42 @@ ProcessExecution.prototype.getApi = function getApi(message) {
   return api;
 };
 
+/** @internal */
 ProcessExecution.prototype._start = function start() {
-  if (!this[kElements].children.length) {
+  if (!this[K_ELEMENTS].children.length) {
     return this._complete('completed');
   }
 
-  this[kStatus] = 'start';
+  this[K_STATUS] = 'start';
 
-  const executeContent = { ...this[kExecuteMessage].content, state: this.status };
+  const executeContent = { ...this[K_EXECUTE_MESSAGE].content, state: this.status };
 
   this.broker.publish(this._exchangeName, 'execute.start', cloneContent(executeContent));
 
-  const { startActivities, postponed, detachedActivities } = this[kElements];
-  if (startActivities.size > 1) {
-    for (const a of startActivities) a.shake();
-  }
+  const { startActivities, postponed, detachedActivities } = this[K_ELEMENTS];
+  this._shakeOnStart();
 
   for (const a of startActivities) a.init();
-  this[kStatus] = 'executing';
+  this[K_STATUS] = 'executing';
   for (const a of startActivities) a.run();
 
+  if (!startActivities.size) {
+    for (const a of this[K_ELEMENTS].triggeredByEvent) {
+      if (a.isCatching && !a.isRunning) a.run();
+    }
+  }
+
   postponed.clear();
   detachedActivities.clear();
-  this[kActivityQ].assertConsumer(this[kMessageHandlers].onChildMessage, {
+  this[K_ACTIVITY_Q].assertConsumer(this[K_MESSAGE_HANDLERS].onChildMessage, {
     prefetch: 1000,
     consumerTag: `_process-activity-${this.executionId}`,
   });
 };
 
+/** @internal */
 ProcessExecution.prototype._activate = function activate() {
-  const { onApiMessage, onMessageFlowEvent, onActivityEvent } = this[kMessageHandlers];
+  const { onApiMessage, onMessageFlowEvent, onActivityEvent } = this[K_MESSAGE_HANDLERS];
 
   if (!this.isSubProcess) {
     this.broker.consume('api-q', onApiMessage, {
@@ -403,7 +434,7 @@ ProcessExecution.prototype._activate = function activate() {
     });
   }
 
-  const { outboundMessageFlows, flows, associations, startActivities, triggeredByEvent, children } = this[kElements];
+  const { outboundMessageFlows, flows, associations, startActivities, triggeredByEvent, convergingGateways, children } = this[K_ELEMENTS];
 
   for (const flow of outboundMessageFlows) {
     flow.activate();
@@ -433,6 +464,7 @@ ProcessExecution.prototype._activate = function activate() {
   startActivities.clear();
   triggeredByEvent.clear();
 
+  let startEventCount = 0;
   for (const activity of children) {
     if (activity.placeholder) continue;
     activity.activate(this);
@@ -441,20 +473,26 @@ ProcessExecution.prototype._activate = function activate() {
       consumerTag: '_process-activity-consumer',
       priority: 200,
     });
-    if (activity.isStart) startActivities.add(activity);
-    if (activity.triggeredByEvent) triggeredByEvent.add(activity);
+    if (activity.isStart) {
+      startActivities.add(activity);
+      if (activity.isStartEvent) startEventCount++;
+    }
+    if (activity.triggeredByEvent || activity.isCatching) triggeredByEvent.add(activity);
+    if (activity.isParallelGateway) convergingGateways.add(activity);
   }
 
-  this[kActivated] = true;
+  this[K_ELEMENTS].startEventCount = startEventCount;
+  this[K_ACTIVATED] = true;
 };
 
+/** @internal */
 ProcessExecution.prototype._deactivate = function deactivate() {
   const broker = this.broker;
   const executionId = this.executionId;
   broker.cancel(`_process-api-consumer-${executionId}`);
   broker.cancel(`_process-activity-${executionId}`);
 
-  const { children, flows, associations, outboundMessageFlows } = this[kElements];
+  const { children, flows, associations, outboundMessageFlows } = this[K_ELEMENTS];
 
   for (const activity of children) {
     if (activity.placeholder) continue;
@@ -475,9 +513,108 @@ ProcessExecution.prototype._deactivate = function deactivate() {
     flow.broker.cancel('_process-message-consumer');
   }
 
-  this[kActivated] = false;
+  this[K_ACTIVATED] = false;
+};
+
+/**
+ * Discover converging parallel gateway peers for the peer monitor, reusing already discovered ones.
+ * @internal
+ */
+ProcessExecution.prototype._shakeOnStart = function shakeOnStart() {
+  const convergingGateways = this[K_ELEMENTS].convergingGateways;
+  if (!convergingGateways.size) return;
+
+  if (this._peersDiscovered()) {
+    this._debug(`reuse discovered parallel gateway peers (${convergingGateways.size})`);
+    return;
+  }
+
+  this._shakeElements();
+  this._debug(`forced shake to discover converging gateway peers (${convergingGateways.size})`);
+};
+
+/**
+ * Whether every converging parallel gateway has discovered its peers in this runtime instance.
+ * Peers are a runtime cache and absent after recover, so a changed source is reshaken.
+ * @internal
+ */
+ProcessExecution.prototype._peersDiscovered = function peersDiscovered() {
+  const convergingGateways = this[K_ELEMENTS].convergingGateways;
+  for (const gateway of convergingGateways) {
+    if (!gateway[K_PEERS_DISCOVERED]) return false;
+  }
+  return true;
+};
+
+/** @internal */
+ProcessExecution.prototype._shakeElements = function shakeElements(fromId) {
+  let executing = true;
+  const id = this.id;
+  if (!this.isRunning) {
+    executing = false;
+    this.executionId = getUniqueId(id);
+    this._activate();
+  }
+  const toShake = fromId ? [this.getActivityById(fromId)].filter(Boolean) : this[K_ELEMENTS].startActivities;
+
+  const result = {
+    sequences: new Map(),
+  };
+
+  const convergingGateways = new Map();
+  const consumerTag = `_shaker-${this.executionId}`;
+
+  this.broker.subscribeTmp(
+    'event',
+    '*.shake.*',
+    (routingKey, { content }) => {
+      if (content.parent.id !== this.id) return;
+
+      switch (routingKey) {
+        case 'activity.shake.join': {
+          const join = convergingGateways.get(content.join);
+          if (!join) {
+            convergingGateways.set(content.join, content);
+          } else {
+            join.sequence = join.sequence.concat(content.sequence);
+          }
+          break;
+        }
+        case 'flow.shake.loop':
+        case 'activity.shake.linked':
+        case 'activity.shake.end': {
+          const { id: shakeId, parent: shakeParent } = content;
+          if (shakeParent.id !== id) return;
+
+          let seqnce;
+          if (!(seqnce = result.sequences.get(shakeId))) {
+            seqnce = [];
+            result.sequences.set(shakeId, seqnce);
+          }
+          seqnce.push({ ...content, isLooped: routingKey === 'flow.shake.loop' });
+
+          break;
+        }
+      }
+    },
+    { noAck: true, consumerTag }
+  );
+
+  for (const a of toShake) a.shake();
+
+  for (const [aid, c] of convergingGateways.entries()) {
+    this._debug(`manual shake of converging gateway <${aid}>`);
+    this.getActivityById(aid).broker.publish('api', 'activity.shake.continue', c, { type: 'shake' });
+  }
+
+  if (!executing) this._deactivate();
+
+  this.broker.cancel(consumerTag);
+
+  return result;
 };
 
+/** @internal */
 ProcessExecution.prototype._onDelegateEvent = function onDelegateEvent(message) {
   const eventType = message.properties.type;
   let delegate = true;
@@ -489,8 +626,8 @@ ProcessExecution.prototype._onDelegateEvent = function onDelegateEvent(message)
     this._debug(`delegate ${eventType} anonymous event`);
   }
 
-  for (const activity of this[kElements].triggeredByEvent) {
-    if (activity.getStartActivities({ referenceId: content.message?.id, referenceType: eventType }).length) {
+  for (const activity of this[K_ELEMENTS].triggeredByEvent) {
+    if (activity.isSubProcess && activity.getStartActivities({ referenceId: content.message?.id, referenceType: eventType }).length) {
       delegate = false;
       activity.run(content.message);
     }
@@ -501,17 +638,20 @@ ProcessExecution.prototype._onDelegateEvent = function onDelegateEvent(message)
   return delegate;
 };
 
+/** @internal */
 ProcessExecution.prototype._onMessageFlowEvent = function onMessageFlowEvent(routingKey, message) {
   this.broker.publish('message', routingKey, cloneContent(message.content), message.properties);
 };
 
+/** @internal */
 ProcessExecution.prototype._onActivityEvent = function onActivityEvent(routingKey, message) {
-  if (message.fields.redelivered && message.properties.persistent === false) return;
+  const { fields, content, properties } = message;
+
+  if (fields.redelivered && properties.persistent === false) return;
 
-  const content = message.content;
   const parent = (content.parent = content.parent || {});
-  let delegate = message.properties.delegate;
-  const shaking = message.properties.type === 'shake';
+  let delegate = properties.delegate;
+  const shaking = properties.type === 'shake';
 
   const isDirectChild = content.parent.id === this.id;
   if (isDirectChild) {
@@ -522,14 +662,14 @@ ProcessExecution.prototype._onActivityEvent = function onActivityEvent(routingKe
 
   if (delegate) delegate = this._onDelegateEvent(message);
 
-  this[kTracker].track(routingKey, message);
-  this.broker.publish('event', routingKey, content, { ...message.properties, delegate, mandatory: false });
-  if (shaking) return this._onShookEnd(message);
+  this[K_TRACKER].track(routingKey, message);
+  this.broker.publish('event', routingKey, content, { ...properties, delegate, mandatory: false });
+  if (shaking) return;
   if (!isDirectChild) return;
 
   switch (routingKey) {
     case 'process.terminate':
-      return this[kActivityQ].queueMessage({ routingKey: 'execution.terminate' }, cloneContent(content), {
+      return this[K_ACTIVITY_Q].queueMessage({ routingKey: 'execution.terminate' }, cloneContent(content), {
         type: 'terminate',
         persistent: true,
       });
@@ -537,9 +677,10 @@ ProcessExecution.prototype._onActivityEvent = function onActivityEvent(routingKe
       return;
   }
 
-  this[kActivityQ].queueMessage(message.fields, cloneContent(content), { persistent: true, ...message.properties });
+  this[K_ACTIVITY_Q].queueMessage(message.fields, cloneContent(content), { persistent: true, ...message.properties });
 };
 
+/** @internal */
 ProcessExecution.prototype._onChildMessage = function onChildMessage(routingKey, message) {
   if (message.fields.redelivered && message.properties.persistent === false) return message.ack();
 
@@ -557,7 +698,7 @@ ProcessExecution.prototype._onChildMessage = function onChildMessage(routingKey,
       return this._onDiscard(message);
     case 'execution.discard.detached': {
       message.ack();
-      for (const detached of this[kElements].detachedActivities) {
+      for (const detached of this[K_ELEMENTS].detachedActivities) {
         this._getChildApi(detached).discard();
       }
       return;
@@ -567,7 +708,7 @@ ProcessExecution.prototype._onChildMessage = function onChildMessage(routingKey,
       return this._onCancel(message);
     case 'activity.error.caught': {
       let prevMsg;
-      for (const msg of this[kElements].postponed) {
+      for (const msg of this[K_ELEMENTS].postponed) {
         if (msg.content.executionId === content.executionId) {
           prevMsg = msg;
           break;
@@ -576,7 +717,6 @@ ProcessExecution.prototype._onChildMessage = function onChildMessage(routingKey,
       if (!prevMsg) return message.ack();
       break;
     }
-    case 'flow.looped':
     case 'activity.leave':
       return this._onChildCompleted(message);
   }
@@ -585,7 +725,7 @@ ProcessExecution.prototype._onChildMessage = function onChildMessage(routingKey,
 
   switch (routingKey) {
     case 'activity.detach': {
-      this[kElements].detachedActivities.add(cloneMessage(message));
+      this[K_ELEMENTS].detachedActivities.add(cloneMessage(message));
       break;
     }
     case 'activity.cancel': {
@@ -604,16 +744,22 @@ ProcessExecution.prototype._onChildMessage = function onChildMessage(routingKey,
 
       break;
     }
+    case 'activity.end': {
+      if (!(content.isStartEvent || this.getActivityById(content.id)?.isStartEvent)) break;
+      if (this[K_ELEMENTS].startEventCount <= 1) break;
+      this._discardArmedStartEvents(content.id);
+      break;
+    }
     case 'activity.error': {
       let eventCaughtBy;
-      for (const msg of this[kElements].postponed) {
+      for (const msg of this[K_ELEMENTS].postponed) {
         if (msg.fields.routingKey === 'activity.catch' && msg.content.source?.executionId === content.executionId) {
           eventCaughtBy = msg;
           break;
         }
       }
       if (eventCaughtBy) {
-        this[kActivityQ].queueMessage({ routingKey: 'activity.error.caught' }, cloneContent(content), {
+        this[K_ACTIVITY_Q].queueMessage({ routingKey: 'activity.error.caught' }, cloneContent(content), {
           persistent: true,
           ...message.properties,
         });
@@ -624,14 +770,16 @@ ProcessExecution.prototype._onChildMessage = function onChildMessage(routingKey,
   }
 };
 
+/** @internal */
 ProcessExecution.prototype._stateChangeMessage = function stateChangeMessage(message, postponeMessage) {
   const previousMsg = this._popPostponed(message.content);
   if (previousMsg) previousMsg.ack();
-  if (postponeMessage) this[kElements].postponed.add(message);
+  if (postponeMessage) this[K_ELEMENTS].postponed.add(message);
 };
 
+/** @internal */
 ProcessExecution.prototype._popPostponed = function popPostponed(byContent) {
-  const { postponed, detachedActivities } = this[kElements];
+  const { postponed, detachedActivities } = this[K_ELEMENTS];
 
   let postponedMsg;
   if (byContent.sequenceId) {
@@ -663,13 +811,20 @@ ProcessExecution.prototype._popPostponed = function popPostponed(byContent) {
   return postponedMsg;
 };
 
+/** @internal */
 ProcessExecution.prototype._onChildCompleted = function onChildCompleted(message) {
   this._stateChangeMessage(message, false);
   if (message.fields.redelivered) return message.ack();
 
-  const { id, type, isEnd } = message.content;
+  const { id, type, isParallelGateway } = message.content;
+
+  if (isParallelGateway) {
+    for (const inb of message.content.inbound) {
+      this._popPostponed(inb)?.ack();
+    }
+  }
 
-  const { postponed, detachedActivities, startActivities } = this[kElements];
+  const { postponed, detachedActivities } = this[K_ELEMENTS];
   const postponedCount = postponed.size;
 
   if (!postponedCount) {
@@ -679,10 +834,10 @@ ProcessExecution.prototype._onChildCompleted = function onChildCompleted(message
   }
 
   message.ack();
-  this._debug(`left <${id}> (${type}), pending activities ${postponedCount}`);
+  this._debug(`left <${id}> (${type}), pending activities ${postponedCount} ${[...postponed].map((m) => m.content.id)}`);
 
   if (postponedCount && postponedCount === detachedActivities.size) {
-    return this[kActivityQ].queueMessage(
+    return this[K_ACTIVITY_Q].queueMessage(
       { routingKey: 'execution.discard.detached' },
       {
         id: this.id,
@@ -692,21 +847,9 @@ ProcessExecution.prototype._onChildCompleted = function onChildCompleted(message
       { type: 'cancel' }
     );
   }
-
-  if (isEnd && startActivities.size) {
-    const startSequences = this[kElements].startSequences;
-    for (const msg of postponed) {
-      const postponedId = msg.content.id;
-      const startSequence = startSequences[postponedId];
-      if (startSequence) {
-        if (startSequence.content.sequence.some(({ id: sid }) => sid === id)) {
-          this._getChildApi(msg).discard();
-        }
-      }
-    }
-  }
 };
 
+/** @internal */
 ProcessExecution.prototype._stopExecution = function stopExecution(message) {
   const postponedCount = this.postponedCount;
   this._debug(`stop process execution (stop child executions ${postponedCount})`);
@@ -714,21 +857,22 @@ ProcessExecution.prototype._stopExecution = function stopExecution(message) {
     for (const api of this.getPostponed()) api.stop();
   }
   this._deactivate();
-  this[kStopped] = true;
+  this[K_STOPPED] = true;
   return this.broker.publish(
     this._exchangeName,
     `execution.stopped.${this.executionId}`,
     {
-      ...this[kExecuteMessage].content,
+      ...this[K_EXECUTE_MESSAGE].content,
       ...(message && message.content),
     },
     { type: 'stopped', persistent: false }
   );
 };
 
+/** @internal */
 ProcessExecution.prototype._onDiscard = function onDiscard() {
   this._deactivate();
-  const postponed = this[kElements].postponed;
+  const postponed = this[K_ELEMENTS].postponed;
   const running = new Set(postponed);
   postponed.clear();
 
@@ -742,23 +886,24 @@ ProcessExecution.prototype._onDiscard = function onDiscard() {
     for (const msg of running) this._getChildApi(msg).discard();
   }
 
-  this[kActivityQ].purge();
+  this[K_ACTIVITY_Q].purge();
   return this._complete('discard');
 };
 
+/** @internal */
 ProcessExecution.prototype._onCancel = function onCancel() {
-  const postponed = this[kElements].postponed;
+  const postponed = this[K_ELEMENTS].postponed;
   const running = new Set(postponed);
 
   const isTransaction = this.isTransaction;
 
   if (isTransaction) {
     this._debug(`cancel transaction execution (cancel child executions ${running.size})`);
-    this[kStatus] = 'cancel';
+    this[K_STATUS] = 'cancel';
     this.broker.publish(
       'event',
       'transaction.cancel',
-      cloneMessage(this[kExecuteMessage], {
+      cloneMessage(this[K_EXECUTE_MESSAGE], {
         state: 'cancel',
       })
     );
@@ -778,6 +923,7 @@ ProcessExecution.prototype._onCancel = function onCancel() {
   }
 };
 
+/** @internal */
 ProcessExecution.prototype._onApiMessage = function onApiMessage(routingKey, message) {
   if (message.properties.delegate) {
     return this._delegateApiMessage(routingKey, message);
@@ -797,11 +943,12 @@ ProcessExecution.prototype._onApiMessage = function onApiMessage(routingKey, mes
     case 'discard':
       return this.discard(message);
     case 'stop':
-      this[kActivityQ].queueMessage({ routingKey: 'execution.stop' }, cloneContent(message.content), { persistent: false });
+      this[K_ACTIVITY_Q].queueMessage({ routingKey: 'execution.stop' }, cloneContent(message.content), { persistent: false });
       break;
   }
 };
 
+/** @internal */
 ProcessExecution.prototype._delegateApiMessage = function delegateApiMessage(routingKey, message, continueOnConsumed) {
   const correlationId = message.properties.correlationId || getUniqueId(this.executionId);
   this._debug(`delegate api ${routingKey} message to children, with correlationId <${correlationId}>`);
@@ -820,8 +967,9 @@ ProcessExecution.prototype._delegateApiMessage = function delegateApiMessage(rou
     { consumerTag: `_ct-delegate-${correlationId}`, noAck: true }
   );
 
-  for (const child of this[kElements].children) {
+  for (const child of this[K_ELEMENTS].children) {
     if (child.placeholder) continue;
+
     child.broker.publish('api', routingKey, cloneContent(message.content), message.properties);
     if (consumed && !continueOnConsumed) break;
   }
@@ -829,9 +977,10 @@ ProcessExecution.prototype._delegateApiMessage = function delegateApiMessage(rou
   return broker.cancel(`_ct-delegate-${correlationId}`);
 };
 
+/** @internal */
 ProcessExecution.prototype._complete = function complete(completionType, content) {
   this._deactivate();
-  this[kCompleted] = true;
+  this[K_COMPLETED] = true;
 
   const status = this.status;
   switch (this.status) {
@@ -844,16 +993,16 @@ ProcessExecution.prototype._complete = function complete(completionType, content
       break;
     default:
       this._debug(`process execution ${completionType}`);
-      this[kStatus] = completionType;
+      this[K_STATUS] = completionType;
   }
 
   const broker = this.broker;
-  this[kActivityQ].delete();
+  this[K_ACTIVITY_Q].delete();
 
-  return broker.publish(
+  broker.publish(
     this._exchangeName,
     `execution.${completionType}.${this.executionId}`,
-    cloneContent(this[kExecuteMessage].content, {
+    cloneContent(this[K_EXECUTE_MESSAGE].content, {
       output: { ...this.environment.output },
       ...content,
       state: completionType,
@@ -862,11 +1011,12 @@ ProcessExecution.prototype._complete = function complete(completionType, content
   );
 };
 
+/** @internal */
 ProcessExecution.prototype._terminate = function terminate(message) {
-  this[kStatus] = 'terminated';
+  this[K_STATUS] = 'terminated';
   this._debug('terminating process execution');
 
-  const postponed = this[kElements].postponed;
+  const postponed = this[K_ELEMENTS].postponed;
   const running = new Set(postponed);
   postponed.clear();
 
@@ -881,25 +1031,67 @@ ProcessExecution.prototype._terminate = function terminate(message) {
     msg.ack();
   }
 
-  this[kActivityQ].purge();
+  this[K_ACTIVITY_Q].purge();
 };
 
+/** @internal */
 ProcessExecution.prototype._getFlowById = function getFlowById(flowId) {
-  return this[kElements].flows.find((f) => f.id === flowId);
+  return this[K_ELEMENTS].flows.find((f) => f.id === flowId);
 };
 
+/** @internal */
 ProcessExecution.prototype._getAssociationById = function getAssociationById(associationId) {
-  return this[kElements].associations.find((a) => a.id === associationId);
+  return this[K_ELEMENTS].associations.find((a) => a.id === associationId);
 };
 
+/** @internal */
 ProcessExecution.prototype._getMessageFlowById = function getMessageFlowById(flowId) {
-  return this[kElements].outboundMessageFlows.find((f) => f.id === flowId);
+  return this[K_ELEMENTS].outboundMessageFlows.find((f) => f.id === flowId);
 };
 
+/** @internal */
 ProcessExecution.prototype._getChildById = function getChildById(childId) {
   return this.getActivityById(childId) || this._getFlowById(childId);
 };
 
+/**
+ * Discard the other armed start events once one mutually exclusive entry point wins.
+ * Resolves the start-event flag from the live activity so recovered pre-flag state is handled.
+ * @internal
+ */
+ProcessExecution.prototype._discardArmedStartEvents = function discardArmedStartEvents(winnerId) {
+  const elements = this[K_ELEMENTS];
+  const startPeers = [];
+  for (const msg of elements.postponed) {
+    const peerId = msg.content.id;
+    if (peerId === winnerId) continue;
+    if (this.getActivityById(peerId)?.isStartEvent) startPeers.push(msg);
+  }
+  if (!startPeers.length) return;
+  elements.startEventCount = 0;
+  for (const msg of startPeers) this._getChildApi(msg).discard();
+};
+
+/**
+ * On resume of a state from an older major, discard start events left armed when another entry
+ * point already won before recovery. The winning start event's `activity.end` cannot replay, so
+ * the live discard trigger never fires.
+ * @internal
+ */
+ProcessExecution.prototype._reconcileStartEvents = function reconcileStartEvents() {
+  const elements = this[K_ELEMENTS];
+  if (elements.startEventCount <= 1) return;
+  if (!(this[K_RECOVERED_VERSION] < STATE_VERSION)) return;
+
+  for (const child of elements.children) {
+    if (child.isStartEvent && child.counters.taken) {
+      this._discardArmedStartEvents();
+      return;
+    }
+  }
+};
+
+/** @internal */
 ProcessExecution.prototype._getChildApi = function getChildApi(message) {
   const content = message.content;
 
@@ -919,12 +1111,7 @@ ProcessExecution.prototype._getChildApi = function getChildApi(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);
-};
-
+/** @internal */
 ProcessExecution.prototype._debug = function debugMessage(logMessage) {
-  this[kParent].logger.debug(`<${this.executionId} (${this.id})> ${logMessage}`);
+  this[K_PARENT].logger.debug(`<${this.executionId} (${this.id})> ${logMessage}`);
 };