bpmn-elements 17.3.0 → 18.0.1

package/src/activity/Activity.js

@@ -1,4 +1,4 @@
-import ActivityExecution from './ActivityExecution.js';
+import { ActivityExecution } from './ActivityExecution.js';
 import { getUniqueId } from '../shared.js';
 import { ActivityApi } from '../Api.js';
 import { ActivityBroker } from '../EventBroker.js';
@@ -6,39 +6,55 @@ import { Formatter } from '../MessageFormatter.js';
 import { cloneContent, cloneParent, cloneMessage } from '../messageHelper.js';
 import { makeErrorFromMessage, ActivityError } from '../error/Errors.js';
 import { OutboundEvaluator, formatFlowAction } from './outbound-evaluator.js';
-
-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');
-
-export default Activity;
-
-function Activity(Behaviour, activityDef, context) {
+import {
+  K_ACTIVATED,
+  K_CONSUMING,
+  K_COUNTERS,
+  K_EXECUTE_MESSAGE,
+  K_EXTENSIONS,
+  K_MESSAGE_HANDLERS,
+  K_STATE_MESSAGE,
+} from '../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
+ */
+export function Activity(Behaviour, activityDef, context) {
   const { id, type = 'activity', name, behaviour = {} } = activityDef;
   const { attachedTo: attachedToRef, eventDefinitions } = behaviour;
 
-  this[kActivityDef] = activityDef;
+  this[K_ACTIVITY_DEF] = activityDef;
   this.id = id;
   this.type = type;
   this.name = name;
-  this.behaviour = { ...behaviour, eventDefinitions };
+  /** @type {import('moddle-context-serializer').ActivityBehaviour} */
+  this.behaviour = {
+    ...behaviour,
+    eventDefinitions,
+    ...(activityDef.linkNames && { linkNames: activityDef.linkNames, linkBehaviour: activityDef.linkBehaviour }),
+  };
   this.Behaviour = Behaviour;
+  /** @type {import('moddle-context-serializer').Parent} */
   this.parent = activityDef.parent ? 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[K_COUNTERS] = {
     taken: 0,
     discarded: 0,
   };
@@ -60,159 +76,175 @@ function Activity(Behaviour, activityDef, context) {
 
   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 inboundSourceIds = new Set(inboundSequenceFlows.map(({ sourceId }) => sourceId));
+  const isParallelJoin = activityDef.isParallelGateway && inboundSourceIds.size > 1;
 
-  this[kFlows] = {
+  this[K_FLOWS] = {
     inboundSequenceFlows,
     inboundAssociations,
-    inboundTriggers,
+    inboundTriggers: undefined,
     outboundSequenceFlows,
     outboundEvaluator: new OutboundEvaluator(this, outboundSequenceFlows),
-    ...(isParallelJoin && {
-      inboundJoinFlows: new Set(),
-      inboundSourceIds: new Set(inboundSequenceFlows.map(({ sourceId }) => sourceId)),
-    }),
   };
 
-  this[kFlags] = {
+  this[K_FLAGS] = {
     isEnd: !outboundSequenceFlows.length,
-    isStart: !inboundTriggers.length && !behaviour.triggeredByEvent,
+    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[K_EXEC] = new Map();
 
-  this[kMessageHandlers] = {
-    onInbound: isParallelJoin ? this._onJoinInbound.bind(this) : this._onInbound.bind(this),
+  this[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[K_EXTENSIONS] = context.loadExtensions(this);
+  this[K_CONSUMING] = false;
+  this[K_CONSUMING_RUN_Q] = undefined;
 }
 
 Object.defineProperties(Activity.prototype, {
   counters: {
     get() {
-      return { ...this[kCounters] };
+      return { ...this[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[K_EXTENSIONS];
     },
   },
   bpmnIo: {
     get() {
-      const extensions = this[kExtensions];
+      const extensions = this[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 Formatter(this);
+      formatter = this[K_FORMATTER] = new Formatter(this);
       return formatter;
     },
   },
   isRunning: {
     get() {
-      if (!this[kConsuming]) return false;
+      if (!this[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);
@@ -220,7 +252,7 @@ Object.defineProperties(Activity.prototype, {
   },
   eventDefinitions: {
     get() {
-      return this[kEventDefinitions];
+      return this[K_EVENT_DEFINITIONS];
     },
   },
   parentElement: {
@@ -228,36 +260,85 @@ Object.defineProperties(Activity.prototype, {
       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;
+  if (this[K_ACTIVATED]) return;
+  this[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[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') : getUniqueId(id);
   exec.set('initExecutionId', executionId);
   this.logger.debug(`<${id}> initialized with executionId <${executionId}>`);
   this._publishEvent('init', this._createMessage({ ...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') || getUniqueId(id);
   exec.set('executionId', executionId);
   exec.delete('initExecutionId');
@@ -270,13 +351,18 @@ Activity.prototype.run = function run(runContent) {
   broker.publish('run', 'run.enter', content);
   broker.publish('run', 'run.start', cloneContent(content));
 
-  this[kConsuming] = true;
+  this[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);
@@ -294,16 +380,22 @@ 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], ...state.counters };
+  this[K_COUNTERS] = { ...this[K_COUNTERS], ...state.counters };
 
   if (state.execution) {
     exec.set('execution', new ActivityExecution(this, this.context).recover(state.execution));
@@ -314,8 +406,12 @@ Activity.prototype.recover = function recover(state) {
   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[K_CONSUMING]) {
     throw new Error(`cannot resume running activity <${this.id}>`);
   }
   if (!this.status) return this.activate();
@@ -327,25 +423,34 @@ Activity.prototype.resume = function resume() {
   const content = this._createMessage();
   this.broker.publish('run', 'run.resume', content, { persistent: false });
 
-  this[kConsuming] = true;
+  this[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', cloneContent(this[kStateMessage].content));
-  this[kConsuming] = true;
+  broker.publish('run', 'run.discard', cloneContent(this[K_STATE_MESSAGE].content));
+  this[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 triggers = this[kFlows].inboundTriggers;
+  const triggers = this._getInboundTriggers();
   if (triggers.length) {
     const onInboundEvent = this._onInboundEvent.bind(this);
     const triggerConsumerTag = `_inbound-${this.id}`;
@@ -362,21 +467,33 @@ Activity.prototype.addInboundListeners = function addInboundListeners() {
   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[K_CONSUMING]) return this.broker.cancel('_run-on-inbound');
+  return this.getApi(this[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[K_STATE_MESSAGE];
   if (!stateMessage) return;
   if (this.status === 'executing') return false;
   if (this.status === 'formatting') return false;
@@ -385,26 +502,46 @@ Activity.prototype.next = function next() {
   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 ActivityApi(this.broker, message || this[kStateMessage]);
+  return ActivityApi(this.broker, message || this[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') || getUniqueId(this.id);
   exec.set('executionId', executionId);
   exec.delete('initExecutionId');
@@ -414,15 +551,16 @@ Activity.prototype._runDiscard = function runDiscard(discardContent) {
   const content = this._createMessage({ ...discardContent, executionId });
   this.broker.publish('run', 'run.discard', content);
 
-  this[kConsuming] = true;
+  this[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';
@@ -440,47 +578,82 @@ Activity.prototype._discardRun = function discardRun() {
 
   this._deactivateRunConsumers();
 
-  const stateMessage = this[kStateMessage];
+  const stateMessage = this[K_STATE_MESSAGE];
   if (this.extensions) this.extensions.deactivate(cloneMessage(stateMessage));
 
   const broker = this.broker;
   broker.getQueue('run-q').purge();
 
   broker.publish('run', discardRoutingKey, cloneContent(stateMessage.content), { correlationId: stateMessage.properties.correlationId });
-  this[kConsuming] = true;
+  this[K_CONSUMING] = true;
   this._consumeRunQ();
 };
 
+/** @internal */
+Activity.prototype._onShakeMessage = function _onShakeMessage(sourceMessage) {
+  if (this[K_FLAGS].isParallelGateway) {
+    const message = 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 = cloneMessage(sourceMessage);
-  message.content.sequence = message.content.sequence || [];
-  message.content.sequence.push({ id: this.id, type: this.type });
+  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, 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, { persistent: false, type: 'shake' });
+  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 = 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: cloneContent(linkedContent) });
+    }
+  }
+
+  if (this[K_FLAGS].isEnd) {
+    return this.broker.publish('event', 'activity.shake.end', cloneContent(message.content), { persistent: false, type: 'shake' });
+  }
+
+  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 flow of this[kFlows].outboundSequenceFlows) flow.shake(message);
+  for (const t of targets.values()) t.shake(message);
 };
 
+/** @internal */
 Activity.prototype._consumeInbound = function consumeInbound() {
-  if (!this[kActivated]) return;
+  if (!this[K_ACTIVATED]) return;
 
-  if (this.status || !this[kFlows].inboundTriggers.length) 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.assertConsumer(onInbound, { consumerTag: '_run-on-inbound', prefetch: 1000 });
-  }
+  const onInbound = this[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;
@@ -490,6 +663,12 @@ Activity.prototype._onInbound = function onInbound(routingKey, message) {
   const inbound = [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':
@@ -498,64 +677,13 @@ 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 });
-    }
-  }
-};
-
-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(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);
-      }
+      return this._runDiscard({ inbound });
     }
   }
-
-  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, content, properties } = message;
   const inboundQ = this.broker.getQueue('inbound-q');
@@ -563,36 +691,54 @@ Activity.prototype._onInboundEvent = function onInboundEvent(routingKey, message
   switch (routingKey) {
     case 'activity.enter':
     case 'activity.discard': {
-      if (content.id === this[kFlags].attachedTo) {
+      if (content.id === this[K_FLAGS].attachedTo) {
         inboundQ.queueMessage(fields, cloneContent(content), properties);
       }
       break;
     }
-    case 'flow.shake': {
-      return this._shakeOutbound(message);
+    case 'flow.shake':
+    case 'activity.shake.start':
+      return this._onShakeMessage(message);
+    case 'activity.link': {
+      const linkName = content.message?.linkName;
+      if (!this[K_FLAGS].linkNames?.includes(linkName)) break;
+      const executionId = getUniqueId(this.id);
+      this.broker.publish(
+        'event',
+        'activity.enter',
+        cloneContent(content, { id: this.id, type: this.type, executionId, state: 'enter', message: { ...content.message } })
+      );
+      inboundQ.queueMessage(
+        { routingKey: 'activity.relink' },
+        cloneContent(content, { id: this.id, executionId, message: { ...content.message } }),
+        properties
+      );
+      return;
     }
     case 'association.take':
     case 'flow.take':
-    case 'flow.discard':
       return inboundQ.queueMessage(fields, cloneContent(content), properties);
   }
 };
 
+/** @internal */
 Activity.prototype._consumeRunQ = function consumeRunQ() {
-  this[kConsumingRunQ] = true;
-  this.broker.getQueue('run-q').assertConsumer(this[kMessageHandlers].onRunMessage, { exclusive: true, consumerTag: '_activity-run' });
+  this[K_CONSUMING_RUN_Q] = true;
+  this.broker.getQueue('run-q').assertConsumer(this[K_MESSAGE_HANDLERS].onRunMessage, { exclusive: true, consumerTag: '_activity-run' });
 };
 
+/** @internal */
 Activity.prototype._pauseRunQ = function pauseRunQ() {
-  if (!this[kConsumingRunQ]) return;
+  if (!this[K_CONSUMING_RUN_Q]) return;
 
-  this[kConsumingRunQ] = false;
+  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);
@@ -614,6 +760,7 @@ Activity.prototype._onRunMessage = function onRunMessage(routingKey, message, me
   });
 };
 
+/** @internal */
 Activity.prototype._continueRunMessage = function continueRunMessage(routingKey, message) {
   const isRedelivered = message.fields.redelivered;
   const content = cloneContent(message.content);
@@ -621,7 +768,7 @@ Activity.prototype._continueRunMessage = function continueRunMessage(routingKey,
 
   const id = this.id;
   const step = this.environment.settings.step;
-  this[kStateMessage] = message;
+  this[K_STATE_MESSAGE] = message;
 
   switch (routingKey) {
     case 'run.enter': {
@@ -629,7 +776,7 @@ Activity.prototype._continueRunMessage = function continueRunMessage(routingKey,
 
       this.status = 'entered';
       if (!isRedelivered) {
-        this[kExec].delete('execution');
+        this[K_EXEC].delete('execution');
         if (this.extensions) this.extensions.activate(cloneMessage(message));
         this._publishEvent('enter', content, { correlationId });
       }
@@ -639,7 +786,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(cloneMessage(message));
 
@@ -659,20 +806,20 @@ Activity.prototype._continueRunMessage = function continueRunMessage(routingKey,
       break;
     }
     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[K_EXECUTE_MESSAGE] = message;
         return execution.passthrough(message);
       }
     }
     case 'run.execute': {
       this.status = 'executing';
-      this[kExecuteMessage] = message;
+      this[K_EXECUTE_MESSAGE] = message;
 
       if (isRedelivered && this.extensions) this.extensions.activate(cloneMessage(message));
 
-      const exec = this[kExec];
+      const exec = this[K_EXEC];
       let execution = exec.get('execution');
       if (!execution) {
         execution = new ActivityExecution(this, this.context);
@@ -681,14 +828,14 @@ Activity.prototype._continueRunMessage = function continueRunMessage(routingKey,
 
       this.broker
         .getQueue('execution-q')
-        .assertConsumer(this[kMessageHandlers].onExecutionMessage, { exclusive: true, consumerTag: '_activity-execution' });
+        .assertConsumer(this[K_MESSAGE_HANDLERS].onExecutionMessage, { exclusive: true, consumerTag: '_activity-execution' });
       return execution.execute(message);
     }
     case 'run.end': {
       this.logger.debug(`<${id}> end`, isRedelivered ? 'redelivered' : '');
       if (isRedelivered) break;
 
-      this[kCounters].taken++;
+      this[K_COUNTERS].taken++;
 
       this.status = 'end';
 
@@ -710,7 +857,7 @@ Activity.prototype._continueRunMessage = function continueRunMessage(routingKey,
     }
     case 'run.discarded': {
       this.logger.debug(`<${content.executionId} (${id})> discarded`);
-      this[kCounters].discarded++;
+      this[K_COUNTERS].discarded++;
 
       this.status = 'discarded';
       content.outbound = undefined;
@@ -728,11 +875,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;
 
@@ -754,8 +896,9 @@ 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[K_EXECUTE_MESSAGE];
   const content = cloneContent({
     ...executeMessage.content,
     ...message.content,
@@ -770,7 +913,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', cloneContent(content, { outbound }));
@@ -784,10 +927,11 @@ Activity.prototype._onExecutionMessage = function onExecutionMessage(routingKey,
       break;
     }
     case 'execution.cancel':
-    case 'execution.discard':
+    case 'execution.discard': {
       this.status = 'discarded';
       broker.publish('run', 'run.discarded', content, { correlationId });
       break;
+    }
     default: {
       this.status = 'executed';
       broker.publish('run', 'run.end', content, { correlationId });
@@ -798,21 +942,23 @@ Activity.prototype._onExecutionMessage = function onExecutionMessage(routingKey,
   this._ackRunExecuteMessage();
 };
 
+/** @internal */
 Activity.prototype._ackRunExecuteMessage = function ackRunExecuteMessage() {
   if (this.environment.settings.step) return;
-  const executeMessage = this[kExecuteMessage];
+  const executeMessage = this[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', cloneContent(content), { correlationId });
     return onOutbound();
   }
 
-  return this._doOutbound(cloneMessage(message), isDiscarded, (err, outbound) => {
+  return this._doOutbound(cloneMessage(message), (err, outbound) => {
     if (err) {
       return this._publishEvent('error', { ...content, error: err }, { correlationId });
     }
@@ -830,39 +976,34 @@ Activity.prototype._doRunLeave = function doRunLeave(message, isDiscarded, onOut
   });
 };
 
-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) => formatFlowAction(flow, { action: 'discard' }));
-  } else if (fromContent.outbound?.length) {
+  if (fromContent.outbound?.length) {
     outboundFlows = outboundSequenceFlows.map((flow) => 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 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();
 
@@ -876,15 +1017,21 @@ 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,
@@ -893,16 +1040,16 @@ Activity.prototype._publishRunOutbound = function publishRunOutbound(outboundFlo
         ...(result && typeof result === 'object' && result),
         ...outboundFlow,
         sequenceId: getUniqueId(`${flowId}_${action}`),
-        ...(discardSequence && { discardSequence: discardSequence.slice() }),
       },
     })
   );
 };
 
+/** @internal */
 Activity.prototype._onResumeMessage = function onResumeMessage(message) {
   message.ack();
 
-  const stateMessage = this[kStateMessage];
+  const stateMessage = this[K_STATE_MESSAGE];
   const fields = stateMessage.fields;
   if (!fields.redelivered) return;
 
@@ -924,6 +1071,7 @@ Activity.prototype._onResumeMessage = function onResumeMessage(message) {
   return this.broker.publish('run', fields.routingKey, cloneContent(stateMessage.content), stateMessage.properties);
 };
 
+/** @internal */
 Activity.prototype._publishEvent = function publishEvent(state, content, properties) {
   this.broker.publish('event', `activity.${state}`, cloneContent(content, { state }), {
     ...properties,
@@ -932,12 +1080,13 @@ Activity.prototype._publishEvent = function publishEvent(state, content, propert
   });
 };
 
+/** @internal */
 Activity.prototype._onStop = function onStop(message) {
-  const running = this[kConsuming];
+  const running = this[K_CONSUMING];
 
   this.stopped = true;
 
-  this[kConsuming] = false;
+  this[K_CONSUMING] = false;
   const broker = this.broker;
   this._pauseRunQ();
   broker.cancel('_activity-api');
@@ -952,18 +1101,20 @@ 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[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': {
@@ -978,6 +1129,7 @@ Activity.prototype._onApiMessage = function onApiMessage(routingKey, message) {
   }
 };
 
+/** @internal */
 Activity.prototype._createMessage = function createMessage(override) {
   const { name, status, parent } = this;
 
@@ -990,21 +1142,23 @@ Activity.prototype._createMessage = function createMessage(override) {
     ...(parent && { parent: 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[K_CONSUMING] = false;
 };