bpmn-elements 17.2.2 → 18.0.0

package/dist/activity/Activity.js

@@ -3,8 +3,8 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.default = void 0;
-var _ActivityExecution = _interopRequireDefault(require("./ActivityExecution.js"));
+exports.Activity = Activity;
+var _ActivityExecution = require("./ActivityExecution.js");
 var _shared = require("../shared.js");
 var _Api = require("../Api.js");
 var _EventBroker = require("../EventBroker.js");
@@ -12,22 +12,21 @@ var _MessageFormatter = require("../MessageFormatter.js");
 var _messageHelper = require("../messageHelper.js");
 var _Errors = require("../error/Errors.js");
 var _outboundEvaluator = require("./outbound-evaluator.js");
-function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
-const kActivityDef = Symbol.for('activityDefinition');
-const kConsuming = Symbol.for('consuming');
-const kConsumingRunQ = Symbol.for('run queue consumer');
-const kCounters = Symbol.for('counters');
-const kEventDefinitions = Symbol.for('eventDefinitions');
-const kExec = Symbol.for('exec');
-const kExecuteMessage = Symbol.for('executeMessage');
-const kExtensions = Symbol.for('extensions');
-const kFlags = Symbol.for('flags');
-const kFlows = Symbol.for('flows');
-const kFormatter = Symbol.for('formatter');
-const kMessageHandlers = Symbol.for('messageHandlers');
-const kStateMessage = Symbol.for('stateMessage');
-const kActivated = Symbol.for('activated');
-var _default = exports.default = Activity;
+var _constants = require("../constants.js");
+const K_ACTIVITY_DEF = Symbol.for('activityDefinition');
+const K_CONSUMING_RUN_Q = Symbol.for('run queue consumer');
+const K_EVENT_DEFINITIONS = Symbol.for('eventDefinitions');
+const K_EXEC = Symbol.for('exec');
+const K_FLAGS = Symbol.for('flags');
+const K_FLOWS = Symbol.for('flows');
+const K_FORMATTER = Symbol.for('formatter');
+
+/**
+ * Activity wraps any element (task, event, gateway) and orchestrates its lifecycle through the broker.
+ * @param {import('#types').IActivityBehaviour} Behaviour Element-specific behaviour constructor invoked per execution
+ * @param {import('moddle-context-serializer').Activity} activityDef Parsed BPMN element definition
+ * @param {import('#types').ContextInstance} context Per-execution registry and factory
+ */
 function Activity(Behaviour, activityDef, context) {
   const {
     id,
@@ -39,20 +38,29 @@ function Activity(Behaviour, activityDef, context) {
     attachedTo: attachedToRef,
     eventDefinitions
   } = behaviour;
-  this[kActivityDef] = activityDef;
+  this[K_ACTIVITY_DEF] = activityDef;
   this.id = id;
   this.type = type;
   this.name = name;
+  /** @type {import('moddle-context-serializer').ActivityBehaviour} */
   this.behaviour = {
     ...behaviour,
-    eventDefinitions
+    eventDefinitions,
+    ...(activityDef.linkNames && {
+      linkNames: activityDef.linkNames,
+      linkBehaviour: activityDef.linkBehaviour
+    })
   };
   this.Behaviour = Behaviour;
+  /** @type {import('moddle-context-serializer').Parent} */
   this.parent = activityDef.parent ? (0, _messageHelper.cloneParent)(activityDef.parent) : {};
+  /** @type {import('#types').ILogger} */
   this.logger = context.environment.Logger(type.toLowerCase());
   this.environment = context.environment;
   this.context = context;
-  this[kCounters] = {
+  /** @type {import('#types').ActivityStatus | undefined} */
+  this.status = undefined;
+  this[_constants.K_COUNTERS] = {
     taken: 0,
     discarded: 0
   };
@@ -76,156 +84,173 @@ function Activity(Behaviour, activityDef, context) {
   this.emitFatal = emitFatal;
   const inboundSequenceFlows = context.getInboundSequenceFlows(id);
   const inboundAssociations = context.getInboundAssociations(id);
-  let inboundTriggers;
-  if (attachedToActivity) {
-    inboundTriggers = [attachedToActivity];
-  } else if (isForCompensation) {
-    inboundTriggers = inboundAssociations.slice();
-  } else {
-    inboundTriggers = inboundSequenceFlows.slice();
-  }
+  const hasInboundTrigger = attachedToActivity ? true : isForCompensation ? !!inboundAssociations.length : !!inboundSequenceFlows.length;
   const outboundSequenceFlows = context.getOutboundSequenceFlows(id);
-  const isParallelJoin = activityDef.isParallelGateway && inboundSequenceFlows.length > 1;
-  const flows = this[kFlows] = {
+  const inboundSourceIds = new Set(inboundSequenceFlows.map(({
+    sourceId
+  }) => sourceId));
+  const isParallelJoin = activityDef.isParallelGateway && inboundSourceIds.size > 1;
+  this[K_FLOWS] = {
     inboundSequenceFlows,
     inboundAssociations,
-    inboundTriggers,
+    inboundTriggers: undefined,
     outboundSequenceFlows,
-    outboundEvaluator: new _outboundEvaluator.OutboundEvaluator(this, outboundSequenceFlows),
-    ...(isParallelJoin && {
-      inboundJoinFlows: new Set(),
-      inboundSourceIds: new Set(inboundSequenceFlows.map(({
-        sourceId
-      }) => sourceId))
-    })
+    outboundEvaluator: new _outboundEvaluator.OutboundEvaluator(this, outboundSequenceFlows)
   };
-  this[kFlags] = {
-    isEnd: flows.outboundSequenceFlows.length === 0,
-    isStart: flows.inboundSequenceFlows.length === 0 && !attachedTo && !behaviour.triggeredByEvent && !isForCompensation,
+  this[K_FLAGS] = {
+    isEnd: !outboundSequenceFlows.length,
+    isStart: !hasInboundTrigger && !behaviour.triggeredByEvent && !activityDef.isCatching,
     isSubProcess: activityDef.isSubProcess,
     isMultiInstance: !!behaviour.loopCharacteristics,
     isForCompensation,
     attachedTo,
     isTransaction: activityDef.isTransaction,
     isParallelJoin,
+    isParallelGateway: activityDef.isParallelGateway,
+    isStartEvent: !!activityDef.isStartEvent,
     isThrowing: activityDef.isThrowing,
+    linkNames: activityDef.linkNames,
+    linkBehaviour: activityDef.linkBehaviour,
+    isCatching: activityDef.isCatching,
     lane: activityDef.lane?.id
   };
-  this[kExec] = new Map();
-  this[kMessageHandlers] = {
-    onInbound: isParallelJoin ? this._onJoinInbound.bind(this) : this._onInbound.bind(this),
+  this[K_EXEC] = new Map();
+  this[_constants.K_MESSAGE_HANDLERS] = {
+    onInbound: this._onInbound.bind(this),
     onRunMessage: this._onRunMessage.bind(this),
     onApiMessage: this._onApiMessage.bind(this),
     onExecutionMessage: this._onExecutionMessage.bind(this)
   };
-  this[kEventDefinitions] = eventDefinitions?.map((ed, idx) => new ed.Behaviour(this, ed, context, idx));
-  this[kExtensions] = context.loadExtensions(this);
-  this[kConsuming] = false;
-  this[kConsumingRunQ] = undefined;
+
+  /** @type {import('#types').EventDefinition[] | undefined} */
+  this[K_EVENT_DEFINITIONS] = eventDefinitions?.map((ed, idx) => new ed.Behaviour(this, ed, context, idx));
+  this[_constants.K_EXTENSIONS] = context.loadExtensions(this);
+  this[_constants.K_CONSUMING] = false;
+  this[K_CONSUMING_RUN_Q] = undefined;
 }
 Object.defineProperties(Activity.prototype, {
   counters: {
     get() {
       return {
-        ...this[kCounters]
+        ...this[_constants.K_COUNTERS]
       };
     }
   },
   execution: {
     get() {
-      return this[kExec].get('execution');
+      return this[K_EXEC].get('execution');
     }
   },
   executionId: {
     get() {
-      return this[kExec].get('executionId');
+      return this[K_EXEC].get('executionId');
     }
   },
   extensions: {
     get() {
-      return this[kExtensions];
+      return this[_constants.K_EXTENSIONS];
     }
   },
   bpmnIo: {
     get() {
-      const extensions = this[kExtensions];
+      const extensions = this[_constants.K_EXTENSIONS];
       return extensions?.extensions.find(e => e.type === 'bpmnio');
     }
   },
   formatter: {
     get() {
-      let formatter = this[kFormatter];
+      let formatter = this[K_FORMATTER];
       if (formatter) return formatter;
-      formatter = this[kFormatter] = new _MessageFormatter.Formatter(this);
+      formatter = this[K_FORMATTER] = new _MessageFormatter.Formatter(this);
       return formatter;
     }
   },
   isRunning: {
     get() {
-      if (!this[kConsuming]) return false;
+      if (!this[_constants.K_CONSUMING]) return false;
       return !!this.status;
     }
   },
   outbound: {
     get() {
-      return this[kFlows].outboundSequenceFlows;
+      return this[K_FLOWS].outboundSequenceFlows;
     }
   },
   inbound: {
     get() {
-      return this[kFlows].inboundSequenceFlows;
+      return this[K_FLOWS].inboundSequenceFlows;
     }
   },
   isEnd: {
     get() {
-      return this[kFlags].isEnd;
+      return this[K_FLAGS].isEnd;
     }
   },
   isStart: {
     get() {
-      return this[kFlags].isStart;
+      return this[K_FLAGS].isStart;
     }
   },
   isSubProcess: {
     get() {
-      return this[kFlags].isSubProcess;
+      return this[K_FLAGS].isSubProcess;
     }
   },
   isTransaction: {
     get() {
-      return this[kFlags].isTransaction;
+      return this[K_FLAGS].isTransaction;
     }
   },
   isMultiInstance: {
     get() {
-      return this[kFlags].isMultiInstance;
+      return this[K_FLAGS].isMultiInstance;
     }
   },
   isThrowing: {
     get() {
-      return this[kFlags].isThrowing;
+      return this[K_FLAGS].isThrowing;
+    }
+  },
+  isCatching: {
+    get() {
+      return this[K_FLAGS].isCatching;
     }
   },
   isForCompensation: {
     get() {
-      return this[kFlags].isForCompensation;
+      return this[K_FLAGS].isForCompensation;
+    }
+  },
+  isParallelJoin: {
+    get() {
+      return this[K_FLAGS].isParallelJoin;
+    }
+  },
+  isParallelGateway: {
+    get() {
+      return this[K_FLAGS].isParallelGateway;
+    }
+  },
+  isStartEvent: {
+    get() {
+      return this[K_FLAGS].isStartEvent;
     }
   },
   triggeredByEvent: {
     get() {
-      return this[kActivityDef].triggeredByEvent;
+      return this[K_ACTIVITY_DEF].triggeredByEvent;
     }
   },
   attachedTo: {
     get() {
-      const attachedToId = this[kFlags].attachedTo;
+      const attachedToId = this[K_FLAGS].attachedTo;
       if (!attachedToId) return null;
       return this.getActivityById(attachedToId);
     }
   },
   lane: {
     get() {
-      const laneId = this[kFlags].lane;
+      const laneId = this[K_FLAGS].lane;
       if (!laneId) return undefined;
       const parent = this.parentElement;
       return parent.getLaneById && parent.getLaneById(laneId);
@@ -233,31 +258,78 @@ Object.defineProperties(Activity.prototype, {
   },
   eventDefinitions: {
     get() {
-      return this[kEventDefinitions];
+      return this[K_EVENT_DEFINITIONS];
     }
   },
   parentElement: {
     get() {
       return this.context.getActivityParentById(this.id);
     }
+  },
+  initialized: {
+    get() {
+      return !!this[K_EXEC]?.get('initExecutionId');
+    }
   }
 });
+
+/**
+ * Subscribe to inbound flows and start consuming the inbound queue.
+ * @returns {void}
+ */
 Activity.prototype.activate = function activate() {
-  if (this[kActivated]) return;
-  this[kActivated] = true;
-  this.addInboundListeners();
-  return this._consumeInbound();
+  if (this[_constants.K_ACTIVATED]) return;
+  this[_constants.K_ACTIVATED] = true;
+  return this.addInboundListeners() && this._consumeInbound();
 };
+
+/** @internal */
+Activity.prototype._getInboundTriggers = function _getInboundTriggers() {
+  const flows = this[K_FLOWS];
+  if (flows.inboundTriggers) return flows.inboundTriggers;
+  const flags = this[K_FLAGS];
+  let triggers;
+  if (flags.attachedTo) {
+    triggers = [this.context.getActivityById(flags.attachedTo)];
+  } else if (flags.isForCompensation) {
+    triggers = flows.inboundAssociations.slice();
+  } else {
+    triggers = flows.inboundSequenceFlows.slice();
+  }
+  const {
+    isCatching,
+    linkNames,
+    linkBehaviour
+  } = flags;
+  if (isCatching && linkNames?.length) {
+    const known = new Set(triggers.map(t => t.id));
+    for (const source of this.context.getActivitiesByEventDefinitionBehaviour(linkBehaviour, linkNames)) {
+      if (source.id === this.id || !source.isThrowing || known.has(source.id)) continue;
+      triggers.push(source);
+      known.add(source.id);
+    }
+  }
+  return flows.inboundTriggers = triggers;
+};
+
+/**
+ * Cancel inbound subscriptions and any pending run/format consumers.
+ */
 Activity.prototype.deactivate = function deactivate() {
-  this[kActivated] = false;
+  this[_constants.K_ACTIVATED] = false;
   const broker = this.broker;
   this.removeInboundListeners();
   broker.cancel('_run-on-inbound');
   broker.cancel('_format-consumer');
 };
+
+/**
+ * Initialise activity executionId and emit init event without starting the run.
+ * @param {Record<string, any>} [initContent] Optional content merged into the init message
+ */
 Activity.prototype.init = function init(initContent) {
   const id = this.id;
-  const exec = this[kExec];
+  const exec = this[K_EXEC];
   const executionId = exec.has('initExecutionId') ? exec.get('initExecutionId') : (0, _shared.getUniqueId)(id);
   exec.set('initExecutionId', executionId);
   this.logger.debug(`<${id}> initialized with executionId <${executionId}>`);
@@ -266,10 +338,16 @@ Activity.prototype.init = function init(initContent) {
     executionId
   }));
 };
+
+/**
+ * Start running the activity by publishing run.enter and run.start.
+ * @param {Record<string, any>} [runContent] Optional content merged into the run message
+ * @throws {Error} if the activity is already running
+ */
 Activity.prototype.run = function run(runContent) {
   const id = this.id;
   if (this.isRunning) throw new Error(`activity <${id}> is already running`);
-  const exec = this[kExec];
+  const exec = this[K_EXEC];
   const executionId = exec.get('initExecutionId') || (0, _shared.getUniqueId)(id);
   exec.set('executionId', executionId);
   exec.delete('initExecutionId');
@@ -281,12 +359,18 @@ Activity.prototype.run = function run(runContent) {
   const broker = this.broker;
   broker.publish('run', 'run.enter', content);
   broker.publish('run', 'run.start', (0, _messageHelper.cloneContent)(content));
-  this[kConsuming] = true;
+  this[_constants.K_CONSUMING] = true;
   this._consumeRunQ();
 };
+
+/**
+ * Snapshot activity state for recover.
+ * Returns undefined when nothing is running and `disableTrackState` is set.
+ * @returns {import('#types').ActivityState}
+ */
 Activity.prototype.getState = function getState() {
   const status = this.status;
-  const exec = this[kExec];
+  const exec = this[K_EXEC];
   const execution = exec.get('execution');
   const executionId = exec.get('executionId');
   const brokerState = this.broker.getState(true);
@@ -306,25 +390,37 @@ Activity.prototype.getState = function getState() {
     })
   };
 };
+
+/**
+ * Restore activity state captured by getState. Cannot be called while running.
+ * @param {import('#types').ActivityState} [state]
+ * @returns {this} this when state was applied
+ * @throws {Error} when activity is currently running
+ */
 Activity.prototype.recover = function recover(state) {
   if (this.isRunning) throw new Error(`cannot recover running activity <${this.id}>`);
-  if (!state) return;
+  if (!state) return this;
   this.stopped = state.stopped;
   this.status = state.status;
-  const exec = this[kExec];
+  const exec = this[K_EXEC];
   exec.set('executionId', state.executionId);
-  this[kCounters] = {
-    ...this[kCounters],
+  this[_constants.K_COUNTERS] = {
+    ...this[_constants.K_COUNTERS],
     ...state.counters
   };
   if (state.execution) {
-    exec.set('execution', new _ActivityExecution.default(this, this.context).recover(state.execution));
+    exec.set('execution', new _ActivityExecution.ActivityExecution(this, this.context).recover(state.execution));
   }
   this.broker.recover(state.broker);
   return this;
 };
+
+/**
+ * Resume after recover. If no run has been started, falls back to activate.
+ * @throws {Error} when called on a running activity
+ */
 Activity.prototype.resume = function resume() {
-  if (this[kConsuming]) {
+  if (this[_constants.K_CONSUMING]) {
     throw new Error(`cannot resume running activity <${this.id}>`);
   }
   if (!this.status) return this.activate();
@@ -334,55 +430,85 @@ Activity.prototype.resume = function resume() {
   this.broker.publish('run', 'run.resume', content, {
     persistent: false
   });
-  this[kConsuming] = true;
+  this[_constants.K_CONSUMING] = true;
   this._consumeRunQ();
 };
+
+/**
+ * Discard the activity. Stops execution if running; the activity leaves without taking any outbound flow.
+ * @param {Record<string, any>} [discardContent] Optional content propagated with the discard
+ * @returns {void}
+ */
 Activity.prototype.discard = function discard(discardContent) {
   if (!this.status) return this._runDiscard(discardContent);
-  const execution = this[kExec].get('execution');
+  const execution = this[K_EXEC].get('execution');
   if (execution && !execution.completed) return execution.discard();
   this._deactivateRunConsumers();
   const broker = this.broker;
   broker.getQueue('run-q').purge();
-  broker.publish('run', 'run.discard', (0, _messageHelper.cloneContent)(this[kStateMessage].content));
-  this[kConsuming] = true;
+  broker.publish('run', 'run.discard', (0, _messageHelper.cloneContent)(this[_constants.K_STATE_MESSAGE].content));
+  this[_constants.K_CONSUMING] = true;
   this._consumeRunQ();
 };
+
+/**
+ * Subscribe to inbound triggers (sequence flows, attached activity, or compensation associations).
+ * @returns {number} count of subscribed triggers
+ */
 Activity.prototype.addInboundListeners = function addInboundListeners() {
-  const onInboundEvent = this._onInboundEvent.bind(this);
-  const triggerConsumerTag = `_inbound-${this.id}`;
-  for (const trigger of this[kFlows].inboundTriggers) {
-    if (trigger.isSequenceFlow) {
-      trigger.broker.subscribeTmp('event', 'flow.#', onInboundEvent, {
-        noAck: true,
-        consumerTag: triggerConsumerTag
-      });
-    } else if (this.isForCompensation) {
-      trigger.broker.subscribeTmp('event', 'association.#', onInboundEvent, {
-        noAck: true,
-        consumerTag: triggerConsumerTag
-      });
-    } else {
-      trigger.broker.subscribeTmp('event', 'activity.#', onInboundEvent, {
-        noAck: true,
-        consumerTag: triggerConsumerTag
-      });
+  const triggers = this._getInboundTriggers();
+  if (triggers.length) {
+    const onInboundEvent = this._onInboundEvent.bind(this);
+    const triggerConsumerTag = `_inbound-${this.id}`;
+    for (const trigger of triggers) {
+      if (trigger.isSequenceFlow) {
+        trigger.broker.subscribeTmp('event', 'flow.#', onInboundEvent, {
+          noAck: true,
+          consumerTag: triggerConsumerTag
+        });
+      } else if (this.isForCompensation) {
+        trigger.broker.subscribeTmp('event', 'association.#', onInboundEvent, {
+          noAck: true,
+          consumerTag: triggerConsumerTag
+        });
+      } else {
+        trigger.broker.subscribeTmp('event', 'activity.#', onInboundEvent, {
+          noAck: true,
+          consumerTag: triggerConsumerTag
+        });
+      }
     }
   }
+  return triggers.length;
 };
+
+/**
+ * Cancel inbound trigger subscriptions added by addInboundListeners.
+ */
 Activity.prototype.removeInboundListeners = function removeInboundListeners() {
+  const triggers = this[K_FLOWS].inboundTriggers;
+  if (!triggers) return;
   const triggerConsumerTag = `_inbound-${this.id}`;
-  for (const trigger of this[kFlows].inboundTriggers) {
+  for (const trigger of triggers) {
     trigger.broker.cancel(triggerConsumerTag);
   }
 };
+
+/**
+ * Stop the activity. If not currently running, just cancels the inbound consumer.
+ */
 Activity.prototype.stop = function stop() {
-  if (!this[kConsuming]) return this.broker.cancel('_run-on-inbound');
-  return this.getApi(this[kStateMessage]).stop();
+  if (!this[_constants.K_CONSUMING]) return this.broker.cancel('_run-on-inbound');
+  return this.getApi(this[_constants.K_STATE_MESSAGE]).stop();
 };
+
+/**
+ * Advance one run-step when the environment runs in step mode. No-op otherwise.
+ */
 Activity.prototype.next = function next() {
   if (!this.environment.settings.step) return;
-  const stateMessage = this[kStateMessage];
+  /** @type {import('#types').ElementBrokerMessage} */
+  const stateMessage = this[_constants.K_STATE_MESSAGE];
   if (!stateMessage) return;
   if (this.status === 'executing') return false;
   if (this.status === 'formatting') return false;
@@ -390,24 +516,49 @@ Activity.prototype.next = function next() {
   stateMessage.ack();
   return current;
 };
+
+/**
+ * Walk outbound flows to discover the activity graph from this point.
+ */
 Activity.prototype.shake = function shake() {
   this._shakeOutbound({
     content: this._createMessage()
   });
 };
+
+/**
+ * Evaluate outbound sequence flows for the given source message.
+ * @param {import('#types').ElementBrokerMessage} fromMessage Source run message
+ * @param {boolean} discardRestAtTake When true, take only the first matching flow and discard the rest
+ * @param {(err: Error, evaluationResult: any) => void} callback
+ * @returns {void}
+ */
 Activity.prototype.evaluateOutbound = function evaluateOutbound(fromMessage, discardRestAtTake, callback) {
-  return this[kFlows].outboundEvaluator.evaluate(fromMessage, discardRestAtTake, callback);
+  return this[K_FLOWS].outboundEvaluator.evaluate(fromMessage, discardRestAtTake, callback);
 };
+
+/**
+ * Resolve an Api wrapper for the activity, preferring the running execution if any.
+ * @param {import('#types').ElementBrokerMessage} [message]
+ * @returns {import('#types').IApi<import('./Activity.js').Activity>}
+ */
 Activity.prototype.getApi = function getApi(message) {
-  const execution = this[kExec].get('execution');
+  const execution = this[K_EXEC].get('execution');
   if (execution && !execution.completed) return execution.getApi(message);
-  return (0, _Api.ActivityApi)(this.broker, message || this[kStateMessage]);
+  return (0, _Api.ActivityApi)(this.broker, message || this[_constants.K_STATE_MESSAGE]);
 };
+
+/**
+ * Look up another activity in the same context.
+ * @param {string} elementId
+ */
 Activity.prototype.getActivityById = function getActivityById(elementId) {
   return this.context.getActivityById(elementId);
 };
+
+/** @internal */
 Activity.prototype._runDiscard = function runDiscard(discardContent) {
-  const exec = this[kExec];
+  const exec = this[K_EXEC];
   const executionId = exec.get('initExecutionId') || (0, _shared.getUniqueId)(this.id);
   exec.set('executionId', executionId);
   exec.delete('initExecutionId');
@@ -417,13 +568,15 @@ Activity.prototype._runDiscard = function runDiscard(discardContent) {
     executionId
   });
   this.broker.publish('run', 'run.discard', content);
-  this[kConsuming] = true;
+  this[_constants.K_CONSUMING] = true;
   this._consumeRunQ();
 };
+
+/** @internal */
 Activity.prototype._discardRun = function discardRun() {
   const status = this.status;
   if (!status) return;
-  const execution = this[kExec].get('execution');
+  const execution = this[K_EXEC].get('execution');
   if (execution && !execution.completed) return;
   let discardRoutingKey = 'run.discard';
   switch (status) {
@@ -439,51 +592,100 @@ Activity.prototype._discardRun = function discardRun() {
       return;
   }
   this._deactivateRunConsumers();
-  const stateMessage = this[kStateMessage];
+  const stateMessage = this[_constants.K_STATE_MESSAGE];
   if (this.extensions) this.extensions.deactivate((0, _messageHelper.cloneMessage)(stateMessage));
   const broker = this.broker;
   broker.getQueue('run-q').purge();
   broker.publish('run', discardRoutingKey, (0, _messageHelper.cloneContent)(stateMessage.content), {
     correlationId: stateMessage.properties.correlationId
   });
-  this[kConsuming] = true;
+  this[_constants.K_CONSUMING] = true;
   this._consumeRunQ();
 };
+
+/** @internal */
+Activity.prototype._onShakeMessage = function _onShakeMessage(sourceMessage) {
+  if (this[K_FLAGS].isParallelGateway) {
+    const message = (0, _messageHelper.cloneMessage)(sourceMessage, {
+      join: this.id
+    });
+    message.content.sequence.push({
+      id: this.id,
+      type: this.type
+    });
+    return this.broker.publish('event', 'activity.shake.join', message.content, {
+      persistent: false,
+      type: 'shake'
+    });
+  }
+  this._shakeOutbound(sourceMessage);
+};
+
+/** @internal */
 Activity.prototype._shakeOutbound = function shakeOutbound(sourceMessage) {
   const message = (0, _messageHelper.cloneMessage)(sourceMessage);
-  message.content.sequence = message.content.sequence || [];
-  message.content.sequence.push({
+  const sequence = message.content.sequence = message.content.sequence || [];
+  const count = 1;
+  const looped = sequence?.find(f => f.id === this.id);
+  sequence.push({
     id: this.id,
-    type: this.type
+    type: this.type,
+    count: looped ? looped.count + 1 : count
   });
-  const broker = this.broker;
   this.broker.publish('api', 'activity.shake.start', message.content, {
     persistent: false,
     type: 'shake'
   });
-  if (this[kFlags].isEnd) {
-    return broker.publish('event', 'activity.shake.end', message.content, {
+  const flags = this[K_FLAGS];
+  if (flags.isThrowing && flags.linkNames?.length) {
+    for (const target of this.context.getActivitiesByEventDefinitionBehaviour(flags.linkBehaviour, flags.linkNames)) {
+      if (target.id === this.id || !target.isCatching) continue;
+      const linkedContent = (0, _messageHelper.cloneContent)(message.content, {
+        sourceId: this.id,
+        targetId: target.id,
+        isLinked: true
+      });
+      linkedContent.sequence = linkedContent.sequence.concat({
+        id: target.id,
+        type: target.type
+      });
+      target.broker.publish('event', 'activity.shake.linked', linkedContent, {
+        persistent: false,
+        type: 'shake'
+      });
+      for (const flow of target.outbound) flow.shake({
+        content: (0, _messageHelper.cloneContent)(linkedContent)
+      });
+    }
+  }
+  if (this[K_FLAGS].isEnd) {
+    return this.broker.publish('event', 'activity.shake.end', (0, _messageHelper.cloneContent)(message.content), {
       persistent: false,
       type: 'shake'
     });
   }
-  for (const flow of this[kFlows].outboundSequenceFlows) flow.shake(message);
+  const targets = new Map();
+  for (const outboundFlow of this[K_FLOWS].outboundSequenceFlows) {
+    const prevTarget = targets.get(outboundFlow.targetId);
+    if (!prevTarget) {
+      targets.set(outboundFlow.targetId, outboundFlow);
+    }
+  }
+  for (const t of targets.values()) t.shake(message);
 };
+
+/** @internal */
 Activity.prototype._consumeInbound = function consumeInbound() {
-  if (!this[kActivated]) return;
-  if (this.status) return;
+  if (!this[_constants.K_ACTIVATED]) return;
+  if (this.status || !this._getInboundTriggers().length) return;
   const inboundQ = this.broker.getQueue('inbound-q');
-  const onInbound = this[kMessageHandlers].onInbound;
-  if (this[kFlags].isParallelJoin) {
-    return inboundQ.consume(onInbound, {
-      consumerTag: '_run-on-inbound',
-      prefetch: 1000
-    });
-  }
-  return inboundQ.consume(onInbound, {
+  const onInbound = this[_constants.K_MESSAGE_HANDLERS].onInbound;
+  return inboundQ.assertConsumer(onInbound, {
     consumerTag: '_run-on-inbound'
   });
 };
+
+/** @internal */
 Activity.prototype._onInbound = function onInbound(routingKey, message) {
   message.ack();
   const broker = this.broker;
@@ -491,6 +693,12 @@ Activity.prototype._onInbound = function onInbound(routingKey, message) {
   const content = message.content;
   const inbound = [(0, _messageHelper.cloneContent)(content)];
   switch (routingKey) {
+    case 'activity.relink':
+      if (content.executionId) this[K_EXEC].set('initExecutionId', content.executionId);
+      return this.run({
+        message: content.message,
+        inbound
+      });
     case 'association.take':
     case 'flow.take':
     case 'activity.restart':
@@ -499,67 +707,16 @@ Activity.prototype._onInbound = function onInbound(routingKey, message) {
         message: content.message,
         inbound
       });
-    case 'flow.discard':
     case 'activity.discard':
       {
-        let discardSequence;
-        if (content.discardSequence) discardSequence = content.discardSequence.slice();
         return this._runDiscard({
-          inbound,
-          discardSequence
+          inbound
         });
       }
   }
 };
-Activity.prototype._onJoinInbound = function onJoinInbound(routingKey, message) {
-  const {
-    content
-  } = message;
-  const {
-    inboundJoinFlows,
-    inboundSourceIds
-  } = this[kFlows];
-  let alreadyTouched = false;
-  const touched = new Set();
-  let taken;
-  for (const msg of inboundJoinFlows) {
-    const sourceId = msg.content.sourceId;
-    touched.add(sourceId);
-    if (sourceId === content.sourceId) {
-      alreadyTouched = true;
-    }
-  }
-  inboundJoinFlows.add(message);
-  if (alreadyTouched) return;
-  const remaining = inboundSourceIds.size - touched.size - 1;
-  if (remaining) {
-    return this.logger.debug(`<${this.id}> inbound ${message.content.action} from <${message.content.id}>, ${remaining} remaining`);
-  }
-  const inbound = [];
-  for (const im of inboundJoinFlows) {
-    if (im.fields.routingKey === 'flow.take') taken = true;
-    im.ack();
-    inbound.push((0, _messageHelper.cloneContent)(im.content));
-  }
-  const discardSequence = new Set();
-  if (!taken) {
-    for (const im of inboundJoinFlows) {
-      if (!im.content.discardSequence) continue;
-      for (const sourceId of im.content.discardSequence) {
-        discardSequence.add(sourceId);
-      }
-    }
-  }
-  inboundJoinFlows.clear();
-  this.broker.cancel('_run-on-inbound');
-  if (!taken) return this._runDiscard({
-    inbound,
-    discardSequence: [...discardSequence]
-  });
-  return this.run({
-    inbound
-  });
-};
+
+/** @internal */
 Activity.prototype._onInboundEvent = function onInboundEvent(routingKey, message) {
   const {
     fields,
@@ -571,36 +728,65 @@ Activity.prototype._onInboundEvent = function onInboundEvent(routingKey, message
     case 'activity.enter':
     case 'activity.discard':
       {
-        if (content.id === this[kFlags].attachedTo) {
+        if (content.id === this[K_FLAGS].attachedTo) {
           inboundQ.queueMessage(fields, (0, _messageHelper.cloneContent)(content), properties);
         }
         break;
       }
     case 'flow.shake':
+    case 'activity.shake.start':
+      return this._onShakeMessage(message);
+    case 'activity.link':
       {
-        return this._shakeOutbound(message);
+        const linkName = content.message?.linkName;
+        if (!this[K_FLAGS].linkNames?.includes(linkName)) break;
+        const executionId = (0, _shared.getUniqueId)(this.id);
+        this.broker.publish('event', 'activity.enter', (0, _messageHelper.cloneContent)(content, {
+          id: this.id,
+          type: this.type,
+          executionId,
+          state: 'enter',
+          message: {
+            ...content.message
+          }
+        }));
+        inboundQ.queueMessage({
+          routingKey: 'activity.relink'
+        }, (0, _messageHelper.cloneContent)(content, {
+          id: this.id,
+          executionId,
+          message: {
+            ...content.message
+          }
+        }), properties);
+        return;
       }
     case 'association.take':
     case 'flow.take':
-    case 'flow.discard':
       return inboundQ.queueMessage(fields, (0, _messageHelper.cloneContent)(content), properties);
   }
 };
+
+/** @internal */
 Activity.prototype._consumeRunQ = function consumeRunQ() {
-  this[kConsumingRunQ] = true;
-  this.broker.getQueue('run-q').assertConsumer(this[kMessageHandlers].onRunMessage, {
+  this[K_CONSUMING_RUN_Q] = true;
+  this.broker.getQueue('run-q').assertConsumer(this[_constants.K_MESSAGE_HANDLERS].onRunMessage, {
     exclusive: true,
     consumerTag: '_activity-run'
   });
 };
+
+/** @internal */
 Activity.prototype._pauseRunQ = function pauseRunQ() {
-  if (!this[kConsumingRunQ]) return;
-  this[kConsumingRunQ] = false;
+  if (!this[K_CONSUMING_RUN_Q]) return;
+  this[K_CONSUMING_RUN_Q] = false;
   this.broker.cancel('_activity-run');
 };
+
+/** @internal */
 Activity.prototype._onRunMessage = function onRunMessage(routingKey, message, messageProperties) {
   switch (routingKey) {
-    case 'run.outbound.discard':
+    case 'run.execute.passthrough':
     case 'run.outbound.take':
     case 'run.next':
       return this._continueRunMessage(routingKey, message, messageProperties);
@@ -620,20 +806,22 @@ Activity.prototype._onRunMessage = function onRunMessage(routingKey, message, me
     this._continueRunMessage(routingKey, message, messageProperties);
   });
 };
+
+/** @internal */
 Activity.prototype._continueRunMessage = function continueRunMessage(routingKey, message) {
   const isRedelivered = message.fields.redelivered;
   const content = (0, _messageHelper.cloneContent)(message.content);
   const correlationId = message.properties.correlationId;
   const id = this.id;
   const step = this.environment.settings.step;
-  this[kStateMessage] = message;
+  this[_constants.K_STATE_MESSAGE] = message;
   switch (routingKey) {
     case 'run.enter':
       {
         this.logger.debug(`<${id}> enter`, isRedelivered ? 'redelivered' : '');
         this.status = 'entered';
         if (!isRedelivered) {
-          this[kExec].delete('execution');
+          this[K_EXEC].delete('execution');
           if (this.extensions) this.extensions.activate((0, _messageHelper.cloneMessage)(message));
           this._publishEvent('enter', content, {
             correlationId
@@ -645,7 +833,7 @@ Activity.prototype._continueRunMessage = function continueRunMessage(routingKey,
       {
         this.logger.debug(`<${id}> discard`, isRedelivered ? 'redelivered' : '');
         this.status = 'discard';
-        this[kExec].delete('execution');
+        this[K_EXEC].delete('execution');
         if (this.extensions) this.extensions.activate((0, _messageHelper.cloneMessage)(message));
         if (!isRedelivered) {
           this.broker.publish('run', 'run.discarded', content, {
@@ -671,25 +859,25 @@ Activity.prototype._continueRunMessage = function continueRunMessage(routingKey,
       }
     case 'run.execute.passthrough':
       {
-        const execution = this[kExec].get('execution');
+        const execution = this[K_EXEC].get('execution');
         if (!isRedelivered && execution) {
           if (execution.completed) return message.ack();
-          this[kExecuteMessage] = message;
+          this[_constants.K_EXECUTE_MESSAGE] = message;
           return execution.passthrough(message);
         }
       }
     case 'run.execute':
       {
         this.status = 'executing';
-        this[kExecuteMessage] = message;
+        this[_constants.K_EXECUTE_MESSAGE] = message;
         if (isRedelivered && this.extensions) this.extensions.activate((0, _messageHelper.cloneMessage)(message));
-        const exec = this[kExec];
+        const exec = this[K_EXEC];
         let execution = exec.get('execution');
         if (!execution) {
-          execution = new _ActivityExecution.default(this, this.context);
+          execution = new _ActivityExecution.ActivityExecution(this, this.context);
           exec.set('execution', execution);
         }
-        this.broker.getQueue('execution-q').assertConsumer(this[kMessageHandlers].onExecutionMessage, {
+        this.broker.getQueue('execution-q').assertConsumer(this[_constants.K_MESSAGE_HANDLERS].onExecutionMessage, {
           exclusive: true,
           consumerTag: '_activity-execution'
         });
@@ -699,7 +887,7 @@ Activity.prototype._continueRunMessage = function continueRunMessage(routingKey,
       {
         this.logger.debug(`<${id}> end`, isRedelivered ? 'redelivered' : '');
         if (isRedelivered) break;
-        this[kCounters].taken++;
+        this[_constants.K_COUNTERS].taken++;
         this.status = 'end';
         return this._doRunLeave(message, false, () => {
           this._publishEvent('end', content, {
@@ -721,7 +909,7 @@ Activity.prototype._continueRunMessage = function continueRunMessage(routingKey,
     case 'run.discarded':
       {
         this.logger.debug(`<${content.executionId} (${id})> discarded`);
-        this[kCounters].discarded++;
+        this[_constants.K_COUNTERS].discarded++;
         this.status = 'discarded';
         content.outbound = undefined;
         if (!isRedelivered) {
@@ -737,12 +925,6 @@ Activity.prototype._continueRunMessage = function continueRunMessage(routingKey,
         message.ack();
         return flow.take(content.flow);
       }
-    case 'run.outbound.discard':
-      {
-        const flow = this._getOutboundSequenceFlowById(content.flow.id);
-        message.ack();
-        return flow.discard(content.flow);
-      }
     case 'run.leave':
       {
         this.status = undefined;
@@ -764,8 +946,10 @@ Activity.prototype._continueRunMessage = function continueRunMessage(routingKey,
   }
   if (!step) message.ack();
 };
+
+/** @internal */
 Activity.prototype._onExecutionMessage = function onExecutionMessage(routingKey, message) {
-  const executeMessage = this[kExecuteMessage];
+  const executeMessage = this[_constants.K_EXECUTE_MESSAGE];
   const content = (0, _messageHelper.cloneContent)({
     ...executeMessage.content,
     ...message.content,
@@ -782,7 +966,7 @@ Activity.prototype._onExecutionMessage = function onExecutionMessage(routingKey,
   switch (routingKey) {
     case 'execution.outbound.take':
       {
-        return this._doOutbound(message, false, (err, outbound) => {
+        return this._doOutbound(message, (err, outbound) => {
           message.ack();
           if (err) return this.emitFatal(err, content);
           broker.publish('run', 'run.execute.passthrough', (0, _messageHelper.cloneContent)(content, {
@@ -804,11 +988,13 @@ Activity.prototype._onExecutionMessage = function onExecutionMessage(routingKey,
       }
     case 'execution.cancel':
     case 'execution.discard':
-      this.status = 'discarded';
-      broker.publish('run', 'run.discarded', content, {
-        correlationId
-      });
-      break;
+      {
+        this.status = 'discarded';
+        broker.publish('run', 'run.discarded', content, {
+          correlationId
+        });
+        break;
+      }
     default:
       {
         this.status = 'executed';
@@ -820,24 +1006,28 @@ Activity.prototype._onExecutionMessage = function onExecutionMessage(routingKey,
   message.ack();
   this._ackRunExecuteMessage();
 };
+
+/** @internal */
 Activity.prototype._ackRunExecuteMessage = function ackRunExecuteMessage() {
   if (this.environment.settings.step) return;
-  const executeMessage = this[kExecuteMessage];
+  const executeMessage = this[_constants.K_EXECUTE_MESSAGE];
   executeMessage.ack();
 };
+
+/** @internal */
 Activity.prototype._doRunLeave = function doRunLeave(message, isDiscarded, onOutbound) {
   const {
     content,
     properties
   } = message;
   const correlationId = properties.correlationId;
-  if (content.ignoreOutbound) {
+  if (isDiscarded || content.ignoreOutbound) {
     this.broker.publish('run', 'run.leave', (0, _messageHelper.cloneContent)(content), {
       correlationId
     });
     return onOutbound();
   }
-  return this._doOutbound((0, _messageHelper.cloneMessage)(message), isDiscarded, (err, outbound) => {
+  return this._doOutbound((0, _messageHelper.cloneMessage)(message), (err, outbound) => {
     if (err) {
       return this._publishEvent('error', {
         ...content,
@@ -856,35 +1046,31 @@ Activity.prototype._doRunLeave = function doRunLeave(message, isDiscarded, onOut
     onOutbound();
   });
 };
-Activity.prototype._doOutbound = function doOutbound(fromMessage, isDiscarded, callback) {
-  const outboundSequenceFlows = this[kFlows].outboundSequenceFlows;
+
+/** @internal */
+Activity.prototype._doOutbound = function doOutbound(fromMessage, callback) {
+  const outboundSequenceFlows = this[K_FLOWS].outboundSequenceFlows;
   if (!outboundSequenceFlows.length) return callback(null, []);
   const fromContent = fromMessage.content;
-  let discardSequence = fromContent.discardSequence;
-  if (isDiscarded && !discardSequence && this[kFlags].attachedTo && fromContent.inbound?.[0]) {
-    discardSequence = [fromContent.inbound[0].id];
-  }
   let outboundFlows;
-  if (isDiscarded) {
-    outboundFlows = outboundSequenceFlows.map(flow => (0, _outboundEvaluator.formatFlowAction)(flow, {
-      action: 'discard'
-    }));
-  } else if (fromContent.outbound?.length) {
+  if (fromContent.outbound?.length) {
     outboundFlows = outboundSequenceFlows.map(flow => (0, _outboundEvaluator.formatFlowAction)(flow, fromContent.outbound.filter(f => f.id === flow.id).pop()));
   }
   if (outboundFlows) {
-    this._doRunOutbound(outboundFlows, fromContent, discardSequence);
+    this._doRunOutbound(outboundFlows, fromContent);
     return callback(null, outboundFlows);
   }
   return this.evaluateOutbound(fromMessage, fromContent.outboundTakeOne, (err, evaluatedOutbound) => {
     if (err) return callback(new _Errors.ActivityError(err.message, fromMessage, err));
-    const outbound = this._doRunOutbound(evaluatedOutbound, fromContent, discardSequence);
+    const outbound = this._doRunOutbound(evaluatedOutbound, fromContent);
     return callback(null, outbound);
   });
 };
-Activity.prototype._doRunOutbound = function doRunOutbound(outboundList, content, discardSequence) {
+
+/** @internal */
+Activity.prototype._doRunOutbound = function doRunOutbound(outboundList, content) {
   if (outboundList.length === 1) {
-    this._publishRunOutbound(outboundList[0], content, discardSequence);
+    this._publishRunOutbound(outboundList[0], content);
   } else {
     const targets = new Map();
     for (const outboundFlow of outboundList) {
@@ -896,31 +1082,35 @@ Activity.prototype._doRunOutbound = function doRunOutbound(outboundList, content
       }
     }
     for (const outboundFlow of targets.values()) {
-      this._publishRunOutbound(outboundFlow, content, discardSequence);
+      this._publishRunOutbound(outboundFlow, content);
     }
   }
   return outboundList;
 };
-Activity.prototype._publishRunOutbound = function publishRunOutbound(outboundFlow, content, discardSequence) {
+
+/** @internal */
+Activity.prototype._publishRunOutbound = function publishRunOutbound(outboundFlow, content) {
   const {
     id: flowId,
     action,
     result
   } = outboundFlow;
+  if (action === 'discard') {
+    return;
+  }
   this.broker.publish('run', 'run.outbound.' + action, (0, _messageHelper.cloneContent)(content, {
     flow: {
       ...(result && typeof result === 'object' && result),
       ...outboundFlow,
-      sequenceId: (0, _shared.getUniqueId)(`${flowId}_${action}`),
-      ...(discardSequence && {
-        discardSequence: discardSequence.slice()
-      })
+      sequenceId: (0, _shared.getUniqueId)(`${flowId}_${action}`)
     }
   }));
 };
+
+/** @internal */
 Activity.prototype._onResumeMessage = function onResumeMessage(message) {
   message.ack();
-  const stateMessage = this[kStateMessage];
+  const stateMessage = this[_constants.K_STATE_MESSAGE];
   const fields = stateMessage.fields;
   if (!fields.redelivered) return;
   switch (fields.routingKey) {
@@ -937,6 +1127,8 @@ Activity.prototype._onResumeMessage = function onResumeMessage(message) {
   this.logger.debug(`<${this.id}> resume from ${message.content.status}`);
   return this.broker.publish('run', fields.routingKey, (0, _messageHelper.cloneContent)(stateMessage.content), stateMessage.properties);
 };
+
+/** @internal */
 Activity.prototype._publishEvent = function publishEvent(state, content, properties) {
   this.broker.publish('event', `activity.${state}`, (0, _messageHelper.cloneContent)(content, {
     state
@@ -946,10 +1138,12 @@ Activity.prototype._publishEvent = function publishEvent(state, content, propert
     mandatory: state === 'error'
   });
 };
+
+/** @internal */
 Activity.prototype._onStop = function onStop(message) {
-  const running = this[kConsuming];
+  const running = this[_constants.K_CONSUMING];
   this.stopped = true;
-  this[kConsuming] = false;
+  this[_constants.K_CONSUMING] = false;
   const broker = this.broker;
   this._pauseRunQ();
   broker.cancel('_activity-api');
@@ -963,17 +1157,21 @@ Activity.prototype._onStop = function onStop(message) {
     });
   }
 };
+
+/** @internal */
 Activity.prototype._consumeApi = function consumeApi() {
-  const executionId = this[kExec].get('executionId');
+  const executionId = this[K_EXEC].get('executionId');
   if (!executionId) return;
   const broker = this.broker;
   broker.cancel('_activity-api');
-  broker.subscribeTmp('api', `activity.*.${executionId}`, this[kMessageHandlers].onApiMessage, {
+  broker.subscribeTmp('api', `activity.*.${executionId}`, this[_constants.K_MESSAGE_HANDLERS].onApiMessage, {
     noAck: true,
     consumerTag: '_activity-api',
     priority: 100
   });
 };
+
+/** @internal */
 Activity.prototype._onApiMessage = function onApiMessage(routingKey, message) {
   switch (message.properties.type) {
     case 'discard':
@@ -990,6 +1188,8 @@ Activity.prototype._onApiMessage = function onApiMessage(routingKey, message) {
       }
   }
 };
+
+/** @internal */
 Activity.prototype._createMessage = function createMessage(override) {
   const {
     name,
@@ -1010,18 +1210,22 @@ Activity.prototype._createMessage = function createMessage(override) {
       parent: (0, _messageHelper.cloneParent)(parent)
     })
   };
-  for (const [flag, value] of Object.entries(this[kFlags])) {
+  for (const [flag, value] of Object.entries(this[K_FLAGS])) {
     if (value) result[flag] = value;
   }
   return result;
 };
+
+/** @internal */
 Activity.prototype._getOutboundSequenceFlowById = function getOutboundSequenceFlowById(flowId) {
-  return this[kFlows].outboundSequenceFlows.find(flow => flow.id === flowId);
+  return this[K_FLOWS].outboundSequenceFlows.find(flow => flow.id === flowId);
 };
+
+/** @internal */
 Activity.prototype._deactivateRunConsumers = function _deactivateRunConsumers() {
   const broker = this.broker;
   broker.cancel('_activity-api');
   this._pauseRunQ();
   broker.cancel('_activity-execution');
-  this[kConsuming] = false;
+  this[_constants.K_CONSUMING] = false;
 };