bpmn-elements 6.0.1 → 8.0.1

package/src/activity/Activity.js

@@ -7,943 +7,1081 @@ import {Formatter} from '../MessageFormatter';
 import {cloneContent, cloneParent, cloneMessage} from '../messageHelper';
 import {makeErrorFromMessage, ActivityError} from '../error/Errors';
 
-export default function Activity(Behaviour, activityDef, context) {
-  const {id, type = 'activity', name, parent: originalParent = {}, behaviour = {}, isParallelGateway, isSubProcess, triggeredByEvent, isThrowing, isTransaction} = activityDef;
-  const isForCompensation = behaviour.isForCompensation;
-
-  const parent = cloneParent(originalParent);
-  const {environment, getInboundSequenceFlows, getOutboundSequenceFlows, getInboundAssociations} = context;
+const kActivityDef = Symbol.for('activityDefinition');
+const kBpmnIo = Symbol.for('bpmnIo');
+const kConsuming = Symbol.for('consuming');
+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');
+
+export default Activity;
+
+function Activity(Behaviour, activityDef, context) {
+  const {id, type = 'activity', name, behaviour = {}} = activityDef;
+  const {attachedTo: attachedToRef, eventDefinitions} = behaviour;
 
-  const logger = environment.Logger(type.toLowerCase());
-  const {step} = environment.settings;
+  this[kActivityDef] = activityDef;
+  this.id = id;
+  this.type = type;
+  this.name = name;
+  this.behaviour = {...behaviour, eventDefinitions};
+  this.Behaviour = Behaviour;
+  this.parent = activityDef.parent ? cloneParent(activityDef.parent) : {};
+  this.logger = context.environment.Logger(type.toLowerCase());
+  this.environment = context.environment;
+  this.context = context;
+  this[kCounters] = {
+    taken: 0,
+    discarded: 0,
+  };
 
-  const {attachedTo: attachedToRef, eventDefinitions} = behaviour;
   let attachedToActivity, attachedTo;
-
   if (attachedToRef) {
     attachedTo = attachedToRef.id;
     attachedToActivity = context.getActivityById(attachedToRef.id);
   }
 
-  const inboundSequenceFlows = getInboundSequenceFlows(id) || [];
-  const outboundSequenceFlows = getOutboundSequenceFlows(id) || [];
-  const inboundAssociations = getInboundAssociations(id) || [];
+  const {broker, on, once, waitFor, emitFatal} = ActivityBroker(this);
 
-  const isStart = inboundSequenceFlows.length === 0 && !attachedTo && !triggeredByEvent && !isForCompensation;
-  const isEnd = outboundSequenceFlows.length === 0;
-  const isParallelJoin = inboundSequenceFlows.length > 1 && isParallelGateway;
-  const isMultiInstance = !!behaviour.loopCharacteristics;
-
-  let execution, initExecutionId, executionId, stateMessage, status, stopped = false, executeMessage, consumingRunQ;
+  this.broker = broker;
+  this.on = on;
+  this.once = once;
+  this.waitFor = waitFor;
+  this.emitFatal = emitFatal;
 
+  const inboundSequenceFlows = context.getInboundSequenceFlows(id);
+  const inboundAssociations = context.getInboundAssociations(id);
   const inboundTriggers = attachedToActivity ? [attachedToActivity] : inboundSequenceFlows.slice();
-  const inboundJoinFlows = [];
-
-  let counters = {
-    taken: 0,
-    discarded: 0,
+  const outboundSequenceFlows = context.getOutboundSequenceFlows(id);
+  const flows = this[kFlows] = {
+    inboundSequenceFlows,
+    inboundAssociations,
+    inboundJoinFlows: [],
+    inboundTriggers,
+    outboundSequenceFlows,
+    outboundEvaluator: new OutboundEvaluator(this, outboundSequenceFlows),
   };
 
-  const activityApi = {
-    id,
-    type,
-    name,
-    isEnd,
-    isStart,
-    isSubProcess,
-    isThrowing,
+  const isForCompensation = !!behaviour.isForCompensation;
+  const isParallelJoin = activityDef.isParallelGateway && flows.inboundSequenceFlows.length > 1;
+  this[kFlags] = {
+    isEnd: flows.outboundSequenceFlows.length === 0,
+    isStart: flows.inboundSequenceFlows.length === 0 && !attachedTo && !behaviour.triggeredByEvent && !isForCompensation,
+    isSubProcess: activityDef.isSubProcess,
+    isMultiInstance: !!behaviour.loopCharacteristics,
     isForCompensation,
-    triggeredByEvent,
-    parent: cloneParent(parent),
-    behaviour: {...behaviour, eventDefinitions},
-    attachedTo: attachedToActivity,
-    environment,
-    inbound: inboundSequenceFlows,
-    outbound: outboundSequenceFlows,
-    get counters() {
-      return {...counters};
-    },
-    get executionId() {
-      return executionId;
-    },
-    get status() {
-      return status;
-    },
-    get stopped() {
-      return stopped;
-    },
-    get isRunning() {
-      if (!consumingRunQ) return false;
-      return !!status;
-    },
-    Behaviour,
-    activate,
-    deactivate,
-    evaluateOutbound,
-    logger,
-    discard,
-    getApi,
-    getActivityById,
-    getState,
-    init,
-    recover,
-    resume,
-    run,
-    shake,
-    stop,
-    next: step && next,
+    attachedTo,
+    isTransaction: activityDef.isTransaction,
+    isParallelJoin,
+    isThrowing: activityDef.isThrowing,
   };
+  this[kExec] = {};
 
-  const {broker, on, once, waitFor, emitFatal} = ActivityBroker(activityApi);
-
-  activityApi.on = on;
-  activityApi.once = once;
-  activityApi.waitFor = waitFor;
-  activityApi.emitFatal = emitFatal;
-
-  const runQ = broker.getQueue('run-q');
-  const executionQ = broker.getQueue('execution-q');
-  const inboundQ = broker.assertQueue('inbound-q', {durable: true, autoDelete: false});
-
-  const formatRunQ = broker.getQueue('format-run-q');
-  const formatter = Formatter({id, broker, logger}, formatRunQ);
+  this[kMessageHandlers] = {
+    onInbound: isParallelJoin ? this._onJoinInbound.bind(this) : this._onInbound.bind(this),
+    onRunMessage: this._onRunMessage.bind(this),
+    onApiMessage: this._onApiMessage.bind(this),
+    onExecutionMessage: this._onExecutionMessage.bind(this),
+  };
 
+  const onInboundEvent = this._onInboundEvent.bind(this);
+  broker.assertQueue('inbound-q', {durable: true, autoDelete: false});
   if (isForCompensation) {
-    inboundAssociations.forEach((trigger) => {
+    for (const trigger of inboundAssociations) {
       trigger.broker.subscribeTmp('event', '#', onInboundEvent, {noAck: true, consumerTag: `_inbound-${id}`});
-    });
+    }
   } else {
-    inboundTriggers.forEach((trigger) => {
+    for (const trigger of inboundTriggers) {
       if (trigger.isSequenceFlow) trigger.broker.subscribeTmp('event', 'flow.#', onInboundEvent, {noAck: true, consumerTag: `_inbound-${id}`});
       else trigger.broker.subscribeTmp('event', 'activity.#', onInboundEvent, {noAck: true, consumerTag: `_inbound-${id}`});
-    });
+    }
   }
 
-  Object.defineProperty(activityApi, 'broker', {
-    enumerable: true,
-    get: () => broker,
-  });
-
-  Object.defineProperty(activityApi, 'execution', {
-    enumerable: true,
-    get: () => execution,
-  });
-
-  const bpmnIo = BpmnIO(activityApi, context);
-
-  const loaedEventDefinitions = eventDefinitions && eventDefinitions.map((ed) => ed.Behaviour(activityApi, ed, context));
-  Object.defineProperty(activityApi, 'eventDefinitions', {
-    enumerable: true,
-    get: () => loaedEventDefinitions,
-  });
-
-  const extensions = context.loadExtensions(activityApi);
-  Object.defineProperty(activityApi, 'extensions', {
-    enumerable: true,
-    get: () => extensions,
-  });
-
-  return activityApi;
+  this[kEventDefinitions] = eventDefinitions && eventDefinitions.map((ed) => new ed.Behaviour(this, ed, this.context));
+}
 
-  function init(initContent) {
-    initExecutionId = initExecutionId || getUniqueId(id);
-    logger.debug(`<${id}> initialized with executionId <${initExecutionId}>`);
-    publishEvent('init', createMessage({...initContent, executionId: initExecutionId}));
+const proto = Activity.prototype;
+
+Object.defineProperty(proto, 'counters', {
+  enumerable: true,
+  get() {
+    return {...this[kCounters]};
+  },
+});
+
+Object.defineProperty(proto, 'execution', {
+  enumerable: true,
+  get() {
+    return this[kExec].execution;
+  },
+});
+
+Object.defineProperty(proto, 'executionId', {
+  enumerable: true,
+  get() {
+    return this[kExec].executionId;
+  },
+});
+
+Object.defineProperty(proto, 'bpmnIo', {
+  enumerable: true,
+  get() {
+    if (kBpmnIo in this) return this[kBpmnIo];
+    const bpmnIo = this[kBpmnIo] = new BpmnIO(this, this.context);
+    return bpmnIo;
+  },
+});
+
+Object.defineProperty(proto, 'extensions', {
+  enumerable: true,
+  get() {
+    if (kExtensions in this) return this[kExtensions];
+    const extensions = this[kExtensions] = this.context.loadExtensions(this);
+    return extensions;
+  },
+});
+
+Object.defineProperty(proto, 'formatter', {
+  enumerable: true,
+  get() {
+    let formatter = this[kFormatter];
+    if (formatter) return formatter;
+
+    const broker = this.broker;
+    formatter = this[kFormatter] = new Formatter({
+      id: this.id,
+      broker,
+      logger: this.logger,
+    }, broker.getQueue('format-run-q'));
+    return formatter;
+  },
+});
+
+Object.defineProperty(proto, 'isRunning', {
+  enumerable: true,
+  get() {
+    if (!this[kConsuming]) return false;
+    return !!this.status;
+  },
+});
+
+Object.defineProperty(proto, 'outbound', {
+  enumerable: true,
+  get() {
+    return this[kFlows].outboundSequenceFlows;
+  },
+});
+
+Object.defineProperty(proto, 'inbound', {
+  enumerable: true,
+  get() {
+    return this[kFlows].inboundSequenceFlows;
+  },
+});
+
+Object.defineProperty(proto, 'isEnd', {
+  enumerable: true,
+  get() {
+    return this[kFlags].isEnd;
+  },
+});
+Object.defineProperty(proto, 'isStart', {
+  enumerable: true,
+  get() {
+    return this[kFlags].isStart;
+  },
+});
+Object.defineProperty(proto, 'isSubProcess', {
+  enumerable: true,
+  get() {
+    return this[kFlags].isSubProcess;
+  },
+});
+
+Object.defineProperty(proto, 'isMultiInstance', {
+  enumerable: true,
+  get() {
+    return this[kFlags].isMultiInstance;
+  },
+});
+
+Object.defineProperty(proto, 'isThrowing', {
+  enumerable: true,
+  get() {
+    return this[kFlags].isThrowing;
+  },
+});
+Object.defineProperty(proto, 'isForCompensation', {
+  enumerable: true,
+  get() {
+    return this[kFlags].isForCompensation;
+  },
+});
+Object.defineProperty(proto, 'triggeredByEvent', {
+  enumerable: true,
+  get() {
+    return this[kActivityDef].triggeredByEvent;
+  },
+});
+
+Object.defineProperty(proto, 'attachedTo', {
+  enumerable: true,
+  get() {
+    const attachedToId = this[kFlags].attachedTo;
+    if (!attachedToId) return null;
+    return this.getActivityById(attachedToId);
+  },
+});
+
+Object.defineProperty(proto, 'eventDefinitions', {
+  enumerable: true,
+  get() {
+    return this[kEventDefinitions];
+  },
+});
+
+proto.activate = function activate() {
+  if (this[kFlags].isForCompensation) return;
+  return this._consumeInbound();
+};
+
+proto.deactivate = function deactivate() {
+  const broker = this.broker;
+  broker.cancel('_run-on-inbound');
+  broker.cancel('_format-consumer');
+};
+
+proto.init = function init(initContent) {
+  const id = this.id;
+  const exec = this[kExec];
+  const executionId = exec.initExecutionId = exec.initExecutionId || getUniqueId(id);
+  this.logger.debug(`<${id}> initialized with executionId <${executionId}>`);
+  this._publishEvent('init', this._createMessage({...initContent, executionId}));
+};
+
+proto.run = function run(runContent) {
+  const id = this.id;
+  if (this.isRunning) throw new Error(`activity <${id}> is already running`);
+
+  const exec = this[kExec];
+  const executionId = exec.executionId = exec.initExecutionId || getUniqueId(id);
+  exec.initExecutionId = null;
+
+  this._consumeApi();
+
+  const content = this._createMessage({...runContent, executionId});
+  const broker = this.broker;
+
+  broker.publish('run', 'run.enter', content);
+  broker.publish('run', 'run.start', cloneContent(content));
+
+  this._consumeRunQ();
+};
+
+proto.recover = function recover(state) {
+  if (this.isRunning) throw new Error(`cannot recover running activity <${this.id}>`);
+  if (!state) return;
+
+  this.stopped = state.stopped;
+  this.status = state.status;
+  const exec = this[kExec];
+  exec.executionId = state.executionId;
+
+  this[kCounters] = {...this[kCounters], ...state.counters};
+
+  if (state.execution) {
+    exec.execution = new ActivityExecution(this, this.context).recover(state.execution);
   }
 
-  function run(runContent) {
-    if (activityApi.isRunning) throw new Error(`activity <${id}> is already running`);
-
-    executionId = initExecutionId || getUniqueId(id);
-    initExecutionId = undefined;
-
-    consumeApi();
-
-    const content = createMessage({...runContent, executionId});
+  this.broker.recover(state.broker);
 
-    broker.publish('run', 'run.enter', content);
-    broker.publish('run', 'run.start', cloneContent(content));
+  return this;
+};
 
-    consumeRunQ();
+proto.resume = function resume() {
+  if (this[kConsuming]) {
+    throw new Error(`cannot resume running activity <${this.id}>`);
   }
-
-  function createMessage(override = {}) {
-    const result = {
-      ...override,
-      id,
-      type,
-      ...(name ? {name} : undefined),
-      ...(status ? {status} : undefined),
-      parent: cloneParent(parent),
-    };
-
-    const flags = {isEnd, isStart, isSubProcess, isMultiInstance, isForCompensation, attachedTo, isTransaction};
-    for (const flag in flags) {
-      if (flags[flag]) result[flag] = flags[flag];
-    }
-
-    return result;
-  }
-
-  function recover(state) {
-    if (activityApi.isRunning) throw new Error(`cannot recover running activity <${id}>`);
-    if (!state) return;
-
-    stopped = state.stopped;
-    status = state.status;
-    executionId = state.executionId;
-
-    counters = {...counters, ...state.counters};
-
-    if (state.execution) {
-      execution = ActivityExecution(activityApi, context).recover(state.execution);
-    }
-
-    broker.recover(state.broker);
-
-    return activityApi;
+  if (!this.status) return this.activate();
+
+  this.stopped = false;
+
+  this._consumeApi();
+
+  const content = this._createMessage();
+  this.broker.publish('run', 'run.resume', content, {persistent: false});
+  this._consumeRunQ();
+};
+
+proto.discard = function discard(discardContent) {
+  if (!this.status) return this._runDiscard(discardContent);
+  const execution = this[kExec].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._consumeRunQ();
+};
+
+proto.stop = function stop() {
+  if (!this[kConsuming]) return;
+  return this.getApi().stop();
+};
+
+proto.next = function next() {
+  if (!this.environment.settings.step) return;
+  const stateMessage = this[kStateMessage];
+  if (!stateMessage) return;
+  if (this.status === 'executing') return false;
+  if (this.status === 'formatting') return false;
+  const current = stateMessage;
+  stateMessage.ack();
+  return current;
+};
+
+proto.shake = function shake() {
+  this._shakeOutbound({content: this._createMessage()});
+};
+
+proto.evaluateOutbound = function evaluateOutbound(fromMessage, discardRestAtTake, callback) {
+  return this[kFlows].outboundEvaluator.evaluate(fromMessage, discardRestAtTake, callback);
+};
+
+proto.getState = function getState() {
+  const msg = this._createMessage();
+
+  const exec = this[kExec];
+  return {
+    ...msg,
+    executionId: exec.executionId,
+    stopped: this.stopped,
+    behaviour: {...this.behaviour},
+    counters: this.counters,
+    broker: this.broker.getState(true),
+    execution: exec.execution && exec.execution.getState(),
+  };
+};
+
+proto.getApi = function getApi(message) {
+  const execution = this[kExec].execution;
+  if (execution && !execution.completed) return execution.getApi(message);
+  return ActivityApi(this.broker, message || this[kStateMessage]);
+};
+
+proto.getActivityById = function getActivityById(elementId) {
+  return this.context.getActivityById(elementId);
+};
+
+proto._runDiscard = function runDiscard(discardContent) {
+  const exec = this[kExec];
+  const executionId = exec.executionId = exec.initExecutionId || getUniqueId(this.id);
+  exec.initExecutionId = null;
+
+  this._consumeApi();
+
+  const content = this._createMessage({...discardContent, executionId});
+  this.broker.publish('run', 'run.discard', content);
+
+  this._consumeRunQ();
+};
+
+proto._discardRun = function discardRun() {
+  const status = this.status;
+  if (!status) return;
+
+  const execution = this[kExec].execution;
+  if (execution && !execution.completed) return;
+  switch (status) {
+    case 'executing':
+    case 'error':
+    case 'discarded':
+      return;
   }
 
-  function resume() {
-    if (consumingRunQ) {
-      throw new Error(`cannot resume running activity <${id}>`);
-    }
-    if (!status) return activate();
+  this._deactivateRunConsumers();
+  if (this.extensions) this.extensions.deactivate();
+  const broker = this.broker;
+  broker.getQueue('run-q').purge();
+  broker.publish('run', 'run.discard', cloneContent(this[kStateMessage].content));
+  this._consumeRunQ();
+};
 
-    stopped = false;
+proto._shakeOutbound = function shakeOutbound(sourceMessage) {
+  const message = cloneMessage(sourceMessage);
+  message.content.sequence = message.content.sequence || [];
+  message.content.sequence.push({id: this.id, type: this.type});
 
-    consumeApi();
+  const broker = this.broker;
+  this.broker.publish('api', 'activity.shake.start', message.content, {persistent: false, type: 'shake'});
 
-    const content = createMessage({executionId});
-    broker.publish('run', 'run.resume', content, {persistent: false});
-    consumeRunQ();
+  if (this[kFlags].isEnd) {
+    return broker.publish('event', 'activity.shake.end', message.content, {persistent: false, type: 'shake'});
   }
 
-  function discard(discardContent) {
-    if (!status) return runDiscard(discardContent);
-    if (execution && !execution.completed) return execution.discard();
+  for (const flow of this[kFlows].outboundSequenceFlows) flow.shake(message);
+};
 
-    deactivateRunConsumers();
-    runQ.purge();
-    broker.publish('run', 'run.discard', cloneContent(stateMessage.content));
-    consumeRunQ();
+proto._consumeInbound = function consumeInbound() {
+  if (this.status) return;
+  const inboundQ = this.broker.getQueue('inbound-q');
+  if (this[kFlags].isParallelJoin) {
+    return inboundQ.consume(this[kMessageHandlers].onInbound, {consumerTag: '_run-on-inbound', prefetch: 1000});
   }
 
-  function discardRun() {
-    if (!status) return;
-
-    if (execution && !execution.completed) return;
-    switch (status) {
-      case 'executing':
-      case 'error':
-      case 'discarded':
-        return;
+  return inboundQ.consume(this[kMessageHandlers].onInbound, {consumerTag: '_run-on-inbound'});
+};
+
+proto._onInbound = function onInbound(routingKey, message) {
+  message.ack();
+  const id = this.id;
+  const broker = this.broker;
+  broker.cancel('_run-on-inbound');
+
+  const content = message.content;
+  const inbound = [cloneContent(content)];
+
+  switch (routingKey) {
+    case 'association.take':
+    case 'flow.take':
+    case 'activity.enter':
+      return this.run({
+        message: content.message,
+        inbound,
+      });
+    case 'flow.discard':
+    case 'activity.discard': {
+      let discardSequence;
+      if (content.discardSequence) discardSequence = content.discardSequence.slice();
+      return this._runDiscard({inbound, discardSequence});
     }
+    case 'association.complete': {
+      broker.cancel('_run-on-inbound');
 
-    deactivateRunConsumers();
-    if (extensions) extensions.deactivate();
-    runQ.purge();
-    broker.publish('run', 'run.discard', cloneContent(stateMessage.content));
-    consumeRunQ();
-  }
-
-  function runDiscard(discardContent = {}) {
-    executionId = initExecutionId || getUniqueId(id);
+      const compensationId = `${brokerSafeId(id)}_${brokerSafeId(content.sequenceId)}`;
+      this.logger.debug(`<${id}> completed compensation with id <${compensationId}>`);
 
-    consumeApi();
-
-    initExecutionId = undefined;
-
-    const content = createMessage({...discardContent, executionId});
-    broker.publish('run', 'run.discard', content);
-
-    consumeRunQ();
-  }
-
-  function stop() {
-    if (!consumingRunQ) return;
-    return getApi().stop();
-  }
-
-  function onStop(message) {
-    const running = consumingRunQ;
-
-    stopped = true;
-
-    consumingRunQ = false;
-    broker.cancel('_activity-run');
-    broker.cancel('_activity-api');
-    broker.cancel('_activity-execution');
-    broker.cancel('_run-on-inbound');
-    broker.cancel('_format-consumer');
-
-    if (running) {
-      if (extensions) extensions.deactivate(message || createMessage());
-      publishEvent('stop');
+      return this._publishEvent('compensation.end', this._createMessage({
+        executionId: compensationId,
+      }));
     }
   }
+};
 
-  function activate() {
-    if (isForCompensation) return;
-    return consumeInbound();
-  }
+proto._onJoinInbound = function onJoinInbound(routingKey, message) {
+  const {content} = message;
+  const {inboundSequenceFlows, inboundJoinFlows, inboundTriggers} = this[kFlows];
+  const idx = inboundJoinFlows.findIndex((msg) => msg.content.id === content.id);
 
-  function deactivate() {
-    broker.cancel('_run-on-inbound');
-    broker.cancel('_format-consumer');
-  }
+  inboundJoinFlows.push(message);
 
-  function consumeRunQ() {
-    if (consumingRunQ) return;
+  if (idx > -1) return;
 
-    consumingRunQ = true;
-    runQ.assertConsumer(onRunMessage, {exclusive: true, consumerTag: '_activity-run'});
+  const allTouched = inboundJoinFlows.length >= inboundTriggers.length;
+  if (!allTouched) {
+    const remaining = inboundSequenceFlows.filter((inb, i, list) => list.indexOf(inb) === i).length - inboundJoinFlows.length;
+    return this.logger.debug(`<${this.id}> inbound ${message.content.action} from <${message.content.id}>, ${remaining} remaining`);
   }
 
-  function consumeApi() {
-    if (!executionId) return;
+  const evaluatedInbound = inboundJoinFlows.splice(0);
 
-    broker.cancel('_activity-api');
-    broker.subscribeTmp('api', `activity.*.${executionId}`, onApiMessage, {noAck: true, consumerTag: '_activity-api', priority: 100});
-  }
+  let taken;
+  const inbound = evaluatedInbound.map((im) => {
+    if (im.fields.routingKey === 'flow.take') taken = true;
+    im.ack();
+    return cloneContent(im.content);
+  });
 
-  function consumeInbound() {
-    if (status) return;
-    if (isParallelJoin) {
-      return inboundQ.consume(onJoinInbound, {consumerTag: '_run-on-inbound', prefetch: 1000});
+  const discardSequence = !taken && evaluatedInbound.reduce((result, im) => {
+    if (!im.content.discardSequence) return result;
+    for (const sourceId of im.content.discardSequence) {
+      if (result.indexOf(sourceId) === -1) result.push(sourceId);
     }
+    return result;
+  }, []);
 
-    return inboundQ.consume(onInbound, {consumerTag: '_run-on-inbound'});
-  }
+  this.broker.cancel('_run-on-inbound');
 
-  function deactivateRunConsumers() {
-    broker.cancel('_activity-api');
-    broker.cancel('_activity-run');
-    broker.cancel('_activity-execution');
-    consumingRunQ = false;
-  }
+  if (!taken) return this._runDiscard({inbound, discardSequence});
+  return this.run({inbound});
+};
 
-  function onInboundEvent(routingKey, message) {
-    const {fields, content, properties} = message;
+proto._onInboundEvent = function onInboundEvent(routingKey, message) {
+  const {fields, content, properties} = message;
+  const id = this.id;
+  const inboundQ = this.broker.getQueue('inbound-q');
 
-    switch (routingKey) {
-      case 'activity.enter':
-      case 'activity.discard': {
-        if (content.id === attachedToActivity.id) {
-          inboundQ.queueMessage(fields, cloneContent(content), properties);
-        }
-        break;
-      }
-      case 'flow.shake': {
-        shakeOutbound(message);
-        break;
-      }
-      case 'association.take':
-      case 'flow.take':
-      case 'flow.discard':
+  switch (routingKey) {
+    case 'activity.enter':
+    case 'activity.discard': {
+      if (content.id === this[kFlags].attachedTo) {
         inboundQ.queueMessage(fields, cloneContent(content), properties);
-        break;
-      case 'association.discard': {
-        logger.debug(`<${id}> compensation discarded`);
-        inboundQ.purge();
-        break;
       }
-      case 'association.complete': {
-        if (!isForCompensation) break;
+      break;
+    }
+    case 'flow.shake': {
+      return this._shakeOutbound(message);
+    }
+    case 'association.take':
+    case 'flow.take':
+    case 'flow.discard':
+      return inboundQ.queueMessage(fields, cloneContent(content), properties);
+    case 'association.discard': {
+      this.logger.debug(`<${id}> compensation discarded`);
+      return inboundQ.purge();
+    }
+    case 'association.complete': {
+      if (!this[kFlags].isForCompensation) break;
 
-        inboundQ.queueMessage(fields, cloneContent(content), properties);
+      inboundQ.queueMessage(fields, cloneContent(content), properties);
 
-        const compensationId = `${brokerSafeId(id)}_${brokerSafeId(content.sequenceId)}`;
-        publishEvent('compensation.start', createMessage({
-          executionId: compensationId,
-          placeholder: true,
-        }));
+      const compensationId = `${brokerSafeId(id)}_${brokerSafeId(content.sequenceId)}`;
+      this._publishEvent('compensation.start', this._createMessage({
+        executionId: compensationId,
+        placeholder: true,
+      }));
 
-        logger.debug(`<${id}> start compensation with id <${compensationId}>`);
+      this.logger.debug(`<${id}> start compensation with id <${compensationId}>`);
 
-        consumeInbound();
-        break;
-      }
+      return this._consumeInbound();
     }
   }
-
-  function onInbound(routingKey, message) {
-    message.ack();
-    broker.cancel('_run-on-inbound');
-
-    const content = message.content;
-    const inbound = [cloneContent(content)];
-
-    switch (routingKey) {
-      case 'association.take':
-      case 'flow.take':
-      case 'activity.enter':
-        run({
-          message: content.message,
-          inbound,
-        });
-        break;
-      case 'flow.discard':
-      case 'activity.discard': {
-        let discardSequence;
-        if (content.discardSequence) discardSequence = content.discardSequence.slice();
-        runDiscard({inbound, discardSequence});
-        break;
-      }
-      case 'association.complete': {
-        broker.cancel('_run-on-inbound');
-
-        const compensationId = `${brokerSafeId(id)}_${brokerSafeId(content.sequenceId)}`;
-        logger.debug(`<${id}> completed compensation with id <${compensationId}>`);
-
-        publishEvent('compensation.end', createMessage({
-          executionId: compensationId,
-        }));
-        break;
-      }
+};
+
+proto._consumeRunQ = function consumeRunQ() {
+  if (this[kConsuming]) return;
+
+  this[kConsuming] = true;
+  this.broker.getQueue('run-q').assertConsumer(this[kMessageHandlers].onRunMessage, {exclusive: true, consumerTag: '_activity-run'});
+};
+
+proto._onRunMessage = function onRunMessage(routingKey, message, messageProperties) {
+  switch (routingKey) {
+    case 'run.outbound.discard':
+    case 'run.outbound.take':
+    case 'run.next':
+      return this._continueRunMessage(routingKey, message, messageProperties);
+    case 'run.resume': {
+      return this._onResumeMessage(message);
     }
   }
 
-  function onJoinInbound(routingKey, message) {
-    const {content} = message;
-    const idx = inboundJoinFlows.findIndex((msg) => msg.content.id === content.id);
+  const preStatus = this.status;
+  this.status = 'formatting';
+  return this.formatter.format(message, (err, formattedContent, formatted) => {
+    if (err) return this.emitFatal(err, message.content);
+    if (formatted) message.content = formattedContent;
+    this.status = preStatus;
+    this._continueRunMessage(routingKey, message, messageProperties);
+  });
+};
 
-    inboundJoinFlows.push(message);
+proto._continueRunMessage = function continueRunMessage(routingKey, message) {
+  const isRedelivered = message.fields.redelivered;
+  const content = cloneContent(message.content);
+  const correlationId = message.properties.correlationId;
 
-    if (idx > -1) return;
+  const id = this.id;
+  const step = this.environment.settings.step;
+  this[kStateMessage] = message;
 
-    const allTouched = inboundJoinFlows.length >= inboundTriggers.length;
-    if (!allTouched) {
-      const remaining = inboundSequenceFlows.filter((inb, i, list) => list.indexOf(inb) === i).length - inboundJoinFlows.length;
-      return logger.debug(`<${id}> inbound ${message.content.action} from <${message.content.id}>, ${remaining} remaining`);
-    }
+  switch (routingKey) {
+    case 'run.enter': {
+      this.logger.debug(`<${id}> enter`, isRedelivered ? 'redelivered' : '');
 
-    const evaluatedInbound = inboundJoinFlows.splice(0);
+      this.status = 'entered';
+      if (!isRedelivered) {
+        this[kExec].execution = null;
+      }
 
-    let taken;
-    const inbound = evaluatedInbound.map((im) => {
-      if (im.fields.routingKey === 'flow.take') taken = true;
-      im.ack();
-      return cloneContent(im.content);
-    });
+      if (this.extensions) this.extensions.activate(cloneMessage(message), this);
+      if (this.bpmnIo) this.bpmnIo.activate(message);
 
-    const discardSequence = !taken && evaluatedInbound.reduce((result, im) => {
-      if (!im.content.discardSequence) return result;
-      im.content.discardSequence.forEach((sourceId) => {
-        if (result.indexOf(sourceId) === -1) result.push(sourceId);
-      });
-      return result;
-    }, []);
+      if (!isRedelivered) this._publishEvent('enter', content, {correlationId});
+      break;
+    }
+    case 'run.discard': {
+      this.logger.debug(`<${id}> discard`, isRedelivered ? 'redelivered' : '');
 
-    broker.cancel('_run-on-inbound');
+      this.status = 'discard';
+      this[kExec].execution = null;
 
-    if (!taken) return runDiscard({inbound, discardSequence});
-    return run({inbound});
-  }
+      if (this.extensions) this.extensions.activate(cloneMessage(message), this);
+      if (this.bpmnIo) this.bpmnIo.activate(message);
 
-  function onRunMessage(routingKey, message, messageProperties) {
-    switch (routingKey) {
-      case 'run.outbound.discard':
-      case 'run.outbound.take':
-      case 'run.next':
-        return continueRunMessage(routingKey, message, messageProperties);
-      case 'run.resume': {
-        return onResumeMessage();
+      if (!isRedelivered) {
+        this.broker.publish('run', 'run.discarded', content, {correlationId});
+        this._publishEvent('discard', content);
       }
+      break;
     }
-
-    const preStatus = status;
-    status = 'formatting';
-    return formatter(message, (err, formattedContent, formatted) => {
-      if (err) return emitFatal(err, message.content);
-      if (formatted) message.content = formattedContent;
-      status = preStatus;
-      continueRunMessage(routingKey, message, messageProperties);
-    });
-
-    function onResumeMessage() {
-      message.ack();
-
-      const {fields} = stateMessage;
-
-      switch (fields.routingKey) {
-        case 'run.enter':
-        case 'run.start':
-        case 'run.discarded':
-        case 'run.end':
-        case 'run.leave':
-          break;
-        default:
-          return;
+    case 'run.start': {
+      this.logger.debug(`<${id}> start`, isRedelivered ? 'redelivered' : '');
+      this.status = 'started';
+      if (!isRedelivered) {
+        this.broker.publish('run', 'run.execute', content, {correlationId});
+        this._publishEvent('start', content, {correlationId});
       }
 
-      if (!fields.redelivered) return;
-
-      logger.debug(`<${id}> resume from ${message.content.status}`);
-
-      return broker.publish('run', fields.routingKey, cloneContent(stateMessage.content), stateMessage.properties);
+      break;
     }
-  }
-
-  function continueRunMessage(routingKey, message) {
-    const {fields, content: originalContent, ack} = message;
-    const isRedelivered = fields.redelivered;
-    const content = cloneContent(originalContent);
-    const {correlationId} = message.properties;
-
-    stateMessage = message;
-
-    switch (routingKey) {
-      case 'run.enter': {
-        logger.debug(`<${id}> enter`, isRedelivered ? 'redelivered' : '');
-
-        status = 'entered';
-        if (!isRedelivered) {
-          execution = undefined;
-        }
-
-        if (extensions) extensions.activate(cloneMessage(message), activityApi);
-        if (bpmnIo) bpmnIo.activate(message);
-
-        if (!isRedelivered) publishEvent('enter', content, {correlationId});
-        break;
+    case 'run.execute.passthrough': {
+      const execution = this.execution;
+      if (!isRedelivered && execution) {
+        this[kExecuteMessage] = message;
+        return execution.passthrough(message);
+      }
+    }
+    case 'run.execute': {
+      this.status = 'executing';
+      this[kExecuteMessage] = message;
+
+      this.broker.getQueue('execution-q').assertConsumer(this[kMessageHandlers].onExecutionMessage, {exclusive: true, consumerTag: '_activity-execution'});
+      const exec = this[kExec];
+      if (!exec.execution) exec.execution = new ActivityExecution(this, this.context);
+
+      if (isRedelivered) {
+        return this._resumeExtensions(message, (err, formattedContent) => {
+          if (err) return this.emitFatal(err, message.content);
+          if (formattedContent) message.content = formattedContent;
+          this.status = 'executing';
+          return exec.execution.execute(message);
+        });
       }
-      case 'run.discard': {
-        logger.debug(`<${id}> discard`, isRedelivered ? 'redelivered' : '');
-
-        status = 'discard';
-        execution = undefined;
 
-        if (extensions) extensions.activate(cloneMessage(message), activityApi);
-        if (bpmnIo) bpmnIo.activate(message);
+      return exec.execution.execute(message);
+    }
+    case 'run.end': {
+      if (this.status === 'end') break;
 
-        if (!isRedelivered) {
-          broker.publish('run', 'run.discarded', content, {correlationId});
-          publishEvent('discard', content);
-        }
-        break;
-      }
-      case 'run.start': {
-        logger.debug(`<${id}> start`, isRedelivered ? 'redelivered' : '');
-        status = 'started';
-        if (!isRedelivered) {
-          broker.publish('run', 'run.execute', content, {correlationId});
-          publishEvent('start', content, {correlationId});
-        }
-
-        break;
-      }
-      case 'run.execute.passthrough': {
-        if (!isRedelivered && execution) {
-          executeMessage = message;
-          return execution.passthrough(message);
-        }
-      }
-      case 'run.execute': {
-        status = 'executing';
-        executeMessage = message;
-
-        executionQ.assertConsumer(onExecutionMessage, {exclusive: true, consumerTag: '_activity-execution'});
-        execution = execution || ActivityExecution(activityApi, context);
-
-        if (isRedelivered) {
-          return resumeExtensions(message, (err, formattedContent) => {
-            if (err) return emitFatal(err, message.content);
-            if (formattedContent) message.content = formattedContent;
-            status = 'executing';
-            return execution.execute(message);
-          });
-        }
-
-        return execution.execute(message);
-      }
-      case 'run.end': {
-        if (status === 'end') break;
+      this[kCounters].taken++;
 
-        counters.taken++;
+      this.status = 'end';
 
-        status = 'end';
+      return this._doRunLeave(message, false, () => {
+        this._publishEvent('end', content, {correlationId});
+        if (!step) message.ack();
+      });
+    }
+    case 'run.error': {
+      this._publishEvent('error', {
+        ...content,
+        error: isRedelivered ? makeErrorFromMessage(message) : content.error,
+      }, {correlationId});
+      break;
+    }
+    case 'run.discarded': {
+      this.logger.debug(`<${content.executionId} (${id})> discarded`);
+      this[kCounters].discarded++;
 
-        if (isRedelivered) break;
+      this.status = 'discarded';
+      content.outbound = undefined;
 
-        return doRunLeave(false, () => {
-          publishEvent('end', content, {correlationId});
-          if (!step) ack();
+      if (!isRedelivered) {
+        return this._doRunLeave(message, true, () => {
+          if (!step) message.ack();
         });
       }
-      case 'run.error': {
-        publishEvent('error', cloneContent(content, {
-          error: fields.redelivered ? makeErrorFromMessage(message) : content.error,
-        }), {correlationId});
-        break;
-      }
-      case 'run.discarded': {
-        logger.debug(`<${executionId} (${id})> discarded`);
-        counters.discarded++;
 
-        status = 'discarded';
-        content.outbound = undefined;
+      break;
+    }
+    case 'run.outbound.take': {
+      const flow = this._getOutboundSequenceFlowById(content.flow.id);
+      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;
 
-        if (!isRedelivered) {
-          return doRunLeave(true, () => {
-            if (!step) ack();
-          });
-        }
+      if (this.bpmnIo) this.bpmnIo.deactivate(message);
+      if (this.extensions) this.extensions.deactivate(message);
 
-        break;
-      }
-      case 'run.outbound.take': {
-        const flow = getOutboundSequenceFlowById(content.flow.id);
-        ack();
-        return flow.take(content.flow);
+      if (!isRedelivered) {
+        this.broker.publish('run', 'run.next', content, {persistent: false});
+        this._publishEvent('leave', content, {correlationId});
       }
-      case 'run.outbound.discard': {
-        const flow = getOutboundSequenceFlowById(content.flow.id);
-        ack();
-        return flow.discard(content.flow);
-      }
-      case 'run.leave': {
-        status = undefined;
-
-        if (bpmnIo) bpmnIo.deactivate(message);
-        if (extensions) extensions.deactivate(message);
-
-        if (!isRedelivered) {
-          broker.publish('run', 'run.next', cloneContent(content), {persistent: false});
-          publishEvent('leave', content, {correlationId});
-        }
 
-        break;
-      }
-      case 'run.next':
-        consumeInbound();
-        break;
+      break;
     }
+    case 'run.next':
+      this._consumeInbound();
+      break;
+  }
 
-    if (!step) ack();
+  if (!step) message.ack();
+};
 
-    function doRunLeave(isDiscarded, onOutbound) {
-      if (content.ignoreOutbound) {
-        broker.publish('run', 'run.leave', cloneContent(content), {correlationId});
-        if (onOutbound) onOutbound();
-        return;
-      }
+proto._onExecutionMessage = function onExecutionMessage(routingKey, message) {
+  const executeMessage = this[kExecuteMessage];
+  const content = cloneContent({
+    ...executeMessage.content,
+    ...message.content,
+    executionId: executeMessage.content.executionId,
+    parent: {...this.parent},
+  });
 
-      return doOutbound(cloneMessage(message), isDiscarded, (err, outbound) => {
-        if (err) {
-          return publishEvent('error', cloneContent(content, {error: err}), {correlationId});
-        }
+  const {correlationId} = message.properties;
 
-        broker.publish('run', 'run.leave', cloneContent(content, {
-          ...(outbound.length ? {outbound} : undefined),
-        }), {correlationId});
+  this._publishEvent(routingKey, content, message.properties);
+  const broker = this.broker;
 
-        if (onOutbound) onOutbound();
+  switch (routingKey) {
+    case 'execution.outbound.take': {
+      return this._doOutbound(message, false, (err, outbound) => {
+        message.ack();
+        if (err) return this.emitFatal(err, content);
+        broker.publish('run', 'run.execute.passthrough', cloneContent(content, {outbound}));
+        return this._ackRunExecuteMessage();
       });
     }
+    case 'execution.error': {
+      this.status = 'error';
+      broker.publish('run', 'run.error', content, {correlationId});
+      broker.publish('run', 'run.discarded', content, {correlationId});
+      break;
+    }
+    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});
+    }
   }
 
-  function resumeExtensions(message, callback) {
-    if (!extensions && !bpmnIo) return callback();
-
-    if (extensions) extensions.activate(cloneMessage(message), activityApi);
-    if (bpmnIo) bpmnIo.activate(cloneMessage(message));
-
-    status = 'formatting';
-    return formatter(message, (err, formattedContent, formatted) => {
-      if (err) return callback(err);
-      return callback(null, formatted && formattedContent);
-    });
-  }
-
-  function getOutboundSequenceFlowById(flowId) {
-    return outboundSequenceFlows.find((flow) => flow.id === flowId);
+  message.ack();
+  this._ackRunExecuteMessage();
+};
+
+proto._ackRunExecuteMessage = function ackRunExecuteMessage() {
+  if (this.environment.settings.step) return;
+  const executeMessage = this[kExecuteMessage];
+  this[kExecuteMessage] = null;
+  executeMessage.ack();
+};
+
+proto._doRunLeave = function doRunLeave(message, isDiscarded, onOutbound) {
+  const {content, properties} = message;
+  const correlationId = properties.correlationId;
+  if (content.ignoreOutbound) {
+    this.broker.publish('run', 'run.leave', cloneContent(content), {correlationId});
+    return onOutbound();
   }
 
-  function onExecutionMessage(routingKey, message) {
-    const content = cloneContent({
-      ...executeMessage.content,
-      ...message.content,
-      executionId: executeMessage.content.executionId,
-      parent: {...parent},
-    });
+  return this._doOutbound(cloneMessage(message), isDiscarded, (err, outbound) => {
+    if (err) {
+      return this._publishEvent('error', {...content, error: err}, {correlationId});
+    }
 
-    const {correlationId} = message.properties;
+    this.broker.publish('run', 'run.leave', cloneContent(content, {
+      ...(outbound.length ? {outbound} : undefined),
+    }), {correlationId});
 
-    publishEvent(routingKey, content, message.properties);
+    onOutbound();
+  });
+};
 
-    switch (routingKey) {
-      case 'execution.outbound.take': {
-        return doOutbound(cloneMessage(message), false, (err, outbound) => {
-          message.ack();
-          if (err) return emitFatal(err, content);
-          broker.publish('run', 'run.execute.passthrough', cloneContent(content, {outbound}));
-          return ackRunExecuteMessage();
-        });
-      }
-      case 'execution.error': {
-        status = 'error';
-        broker.publish('run', 'run.error', content, {correlationId});
-        broker.publish('run', 'run.discarded', content, {correlationId});
-        break;
-      }
-      case 'execution.discard':
-        status = 'discarded';
-        broker.publish('run', 'run.discarded', content, {correlationId});
-        break;
-      default: {
-        status = 'executed';
-        broker.publish('run', 'run.end', content, {correlationId});
-      }
-    }
+proto._doOutbound = function doOutbound(fromMessage, isDiscarded, callback) {
+  const outboundSequenceFlows = this[kFlows].outboundSequenceFlows;
+  if (!outboundSequenceFlows.length) return callback(null, []);
 
-    message.ack();
-    ackRunExecuteMessage();
+  const fromContent = fromMessage.content;
 
-    function ackRunExecuteMessage() {
-      if (step) return;
-      if (!executeMessage) return;
+  let discardSequence = fromContent.discardSequence;
+  if (isDiscarded && !discardSequence && this[kFlags].attachedTo && fromContent.inbound && fromContent.inbound[0]) {
+    discardSequence = [fromContent.inbound[0].id];
+  }
 
-      const ackMessage = executeMessage;
-      executeMessage = null;
-      ackMessage.ack();
-    }
+  let outboundFlows;
+  if (isDiscarded) {
+    outboundFlows = outboundSequenceFlows.map((flow) => formatFlowAction(flow, {action: 'discard'}));
+  } else if (fromContent.outbound && fromContent.outbound.length) {
+    outboundFlows = outboundSequenceFlows.map((flow) => formatFlowAction(flow, fromContent.outbound.filter((f) => f.id === flow.id).pop()));
   }
 
-  function onApiMessage(routingKey, message) {
-    const messageType = message.properties.type;
-    switch (messageType) {
-      case 'discard': {
-        discardRun(message);
-        break;
-      }
-      case 'stop': {
-        onStop(message);
-        break;
-      }
-      case 'shake': {
-        shakeOutbound(message);
-        break;
-      }
-    }
+  if (outboundFlows) {
+    this._doRunOutbound(outboundFlows, fromContent, discardSequence);
+    return callback(null, outboundFlows);
   }
 
-  function shake() {
-    shakeOutbound({content: createMessage()});
+  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);
+    return callback(null, outbound);
+  });
+};
+
+proto._doRunOutbound = function doRunOutbound(outboundList, content, discardSequence) {
+  for (const outboundFlow of outboundList) {
+    const {id: flowId, action} = outboundFlow;
+    this.broker.publish('run', 'run.outbound.' + action, cloneContent(content, {
+      flow: {
+        ...outboundFlow,
+        sequenceId: getUniqueId(`${flowId}_${action}`),
+        ...(discardSequence ? {discardSequence: discardSequence.slice()} : undefined),
+      },
+    }));
+  }
+  return outboundList;
+};
+
+proto._onResumeMessage = function onResumeMessage(message) {
+  message.ack();
+
+  const stateMessage = this[kStateMessage];
+  const {fields} = stateMessage;
+
+  switch (fields.routingKey) {
+    case 'run.enter':
+    case 'run.start':
+    case 'run.discarded':
+    case 'run.end':
+    case 'run.leave':
+      break;
+    default:
+      return;
   }
 
-  function shakeOutbound(sourceMessage) {
-    const message = cloneMessage(sourceMessage);
-    message.content.sequence = message.content.sequence || [];
-    message.content.sequence.push({id, type});
+  if (!fields.redelivered) return;
 
-    broker.publish('api', 'activity.shake.start', message.content, {persistent: false, type: 'shake'});
+  this.logger.debug(`<${this.id}> resume from ${message.content.status}`);
 
-    if (isEnd) {
-      return broker.publish('event', 'activity.shake.end', message.content, {persistent: false, type: 'shake'});
-    }
+  return this.broker.publish('run', fields.routingKey, cloneContent(stateMessage.content), stateMessage.properties);
+};
 
-    outboundSequenceFlows.forEach((f) => f.shake(message));
-  }
+proto._publishEvent = function publishEvent(state, content, properties = {}) {
+  this.broker.publish('event', `activity.${state}`, cloneContent(content, {state}), {
+    ...properties,
+    type: state,
+    mandatory: state === 'error',
+    persistent: 'persistent' in properties ? properties.persistent : state !== 'stop',
+  });
+};
 
-  function publishEvent(state, content, messageProperties = {}) {
-    if (!state) return;
-    if (!content) content = createMessage();
-    broker.publish('event', `activity.${state}`, {...content, state}, {
-      ...messageProperties,
-      type: state,
-      mandatory: state === 'error',
-      persistent: 'persistent' in messageProperties ? messageProperties.persistent : state !== 'stop',
-    });
-  }
+proto._onStop = function onStop(message) {
+  const running = this[kConsuming];
 
-  function doOutbound(fromMessage, isDiscarded, callback) {
-    if (!outboundSequenceFlows.length) return callback(null, []);
+  this.stopped = true;
 
-    const fromContent = fromMessage.content;
+  this[kConsuming] = false;
+  const broker = this.broker;
+  broker.cancel('_activity-run');
+  broker.cancel('_activity-api');
+  broker.cancel('_activity-execution');
+  broker.cancel('_run-on-inbound');
+  broker.cancel('_format-consumer');
 
-    let discardSequence = fromContent.discardSequence;
-    if (isDiscarded && !discardSequence && attachedTo && fromContent.inbound && fromContent.inbound[0]) {
-      discardSequence = [fromContent.inbound[0].id];
+  if (running) {
+    if (this.extensions) this.extensions.deactivate(message || this._createMessage());
+    this._publishEvent('stop', this._createMessage());
+  }
+};
+
+proto._consumeApi = function consumeApi() {
+  const executionId = this[kExec].executionId;
+  if (!executionId) return;
+  const broker = this.broker;
+  broker.cancel('_activity-api');
+  broker.subscribeTmp('api', `activity.*.${executionId}`, this[kMessageHandlers].onApiMessage, {noAck: true, consumerTag: '_activity-api', priority: 100});
+};
+
+proto._onApiMessage = function onApiMessage(routingKey, message) {
+  switch (message.properties.type) {
+    case 'discard': {
+      return this._discardRun(message);
     }
-
-    let outboundFlows;
-    if (isDiscarded) {
-      outboundFlows = outboundSequenceFlows.map((flow) => formatFlowAction(flow, {action: 'discard'}));
-    } else if (fromContent.outbound && fromContent.outbound.length) {
-      outboundFlows = outboundSequenceFlows.map((flow) => formatFlowAction(flow, fromContent.outbound.filter((f) => f.id === flow.id).pop()));
+    case 'stop': {
+      return this._onStop(message);
     }
-
-    if (outboundFlows) {
-      doRunOutbound(outboundFlows);
-      return callback(null, outboundFlows);
+    case 'shake': {
+      return this._shakeOutbound(message);
     }
+  }
+};
+
+proto._createMessage = function createMessage(override) {
+  const name = this.name, status = this.status, parent = this.parent;
+  const result = {
+    ...override,
+    id: this.id,
+    type: this.type,
+    ...(name ? {name} : undefined),
+    ...(status ? {status} : undefined),
+    ...(parent ? {parent: cloneParent(parent)} : undefined),
+  };
 
-    return evaluateOutbound(fromMessage, fromContent.outboundTakeOne, (err, evaluatedOutbound) => {
-      if (err) return callback(new ActivityError(err.message, fromMessage, err));
+  for (const [flag, value] of Object.entries(this[kFlags])) {
+    if (value) result[flag] = value;
+  }
 
-      const outbound = doRunOutbound(evaluatedOutbound);
-      return callback(null, outbound);
-    });
+  return result;
+};
 
-    function doRunOutbound(outboundList) {
-      return outboundList.map((outboundFlow) => {
-        const {id: flowId, action} = outboundFlow;
-        broker.publish('run', 'run.outbound.' + action, cloneContent(fromContent, {
-          flow: {
-            ...outboundFlow,
-            sequenceId: getUniqueId(`${flowId}_${action}`),
-            ...(discardSequence ? {discardSequence: discardSequence.slice()} : undefined),
-          },
-        }));
-
-        return outboundFlow;
-      });
-    }
-  }
+proto._getOutboundSequenceFlowById = function getOutboundSequenceFlowById(flowId) {
+  return this[kFlows].outboundSequenceFlows.find((flow) => flow.id === flowId);
+};
 
-  function formatFlowAction(flow, options) {
-    if (!options) options = {action: 'discard'};
+proto._resumeExtensions = function resumeExtensions(message, callback) {
+  const extensions = this.extensions, bpmnIo = this.bpmnIo;
+  if (!extensions && !bpmnIo) return callback();
 
-    const action = options.action;
-    const message = options.message;
+  if (extensions) extensions.activate(cloneMessage(message), this);
+  if (bpmnIo) bpmnIo.activate(cloneMessage(message), this);
 
-    return {
-      ...options,
-      id: flow.id,
-      action,
-      ...(flow.isDefault ? {isDefault: true} : undefined),
-      ...(message !== undefined ? {message} : undefined),
-    };
+  this.status = 'formatting';
+  return this.formatter.format(message, (err, formattedContent, formatted) => {
+    if (err) return callback(err);
+    return callback(null, formatted && formattedContent);
+  });
+};
+
+proto._deactivateRunConsumers = function _deactivateRunConsumers() {
+  const broker = this.broker;
+  broker.cancel('_activity-api');
+  broker.cancel('_activity-run');
+  broker.cancel('_activity-execution');
+  this[kConsuming] = false;
+};
+
+function OutboundEvaluator(activity, outboundFlows) {
+  this.activity = activity;
+  this.broker = activity.broker;
+  const flows = this.outboundFlows = outboundFlows.slice();
+  const defaultFlowIdx = flows.findIndex(({isDefault}) => isDefault);
+  if (defaultFlowIdx > -1) {
+    const [defaultFlow] = flows.splice(defaultFlowIdx, 1);
+    flows.push(defaultFlow);
   }
 
-  function evaluateOutbound(fromMessage, discardRestAtTake, callback) {
-    let conditionMet;
-    const outbound = {};
-
-    if (!outboundSequenceFlows.length) return completed();
+  this.defaultFlowIdx = outboundFlows.findIndex(({isDefault}) => isDefault);
+  this._onEvaluated = this.onEvaluated.bind(this);
+  this.evaluateArgs = {};
+}
 
-    const content = fromMessage.content;
-    const message = content.message;
-    const evaluateFlows = outboundSequenceFlows.slice();
-    const defaultFlowIdx = outboundSequenceFlows.findIndex(({isDefault}) => isDefault);
-    if (defaultFlowIdx > -1) {
-      evaluateFlows.splice(defaultFlowIdx, 1);
-      evaluateFlows.push(outboundSequenceFlows[defaultFlowIdx]);
-    }
-    let takenCount = 0;
+OutboundEvaluator.prototype.evaluate = function evaluate(fromMessage, discardRestAtTake, callback) {
+  const outboundFlows = this.outboundFlows;
+
+  const args = this.evaluateArgs = {
+    fromMessage,
+    evaluationId: fromMessage.content.executionId,
+    discardRestAtTake,
+    callback,
+    conditionMet: false,
+    result: {},
+    takenCount: 0,
+  };
 
-    broker.subscribeTmp('execution', 'evaluate.flow.#', (routingKey, {content: evalContent, ack}) => {
-      const {id: flowId, action} = evalContent;
+  if (!outboundFlows.length) return this.completed();
 
-      if (action === 'take') {
-        takenCount++;
-        conditionMet = true;
-      }
+  const flows = args.flows = outboundFlows.slice();
 
-      outbound[flowId] = evalContent;
+  this.broker.subscribeTmp('execution', 'evaluate.flow.#', this._onEvaluated, {
+    consumerTag: `_flow-evaluation-${args.evaluationId}`,
+  });
 
-      if ('result' in evalContent) {
-        logger.debug(`<${content.executionId} (${id})> flow <${flowId}> evaluated to: ${evalContent.result}`);
-      }
+  return this.evaluateFlow(flows.shift());
+};
 
-      let nextFlow = evaluateFlows.shift();
-      if (!nextFlow) return completed();
+OutboundEvaluator.prototype.onEvaluated = function onEvaluated(routingKey, message) {
+  const content = message.content;
+  const {id: flowId, action, evaluationId} = message.content;
+  const args = this.evaluateArgs;
 
-      if (discardRestAtTake && conditionMet) {
-        do {
-          outbound[nextFlow.id] = formatFlowAction(nextFlow, {action: 'discard'});
-        } while ((nextFlow = evaluateFlows.shift()));
-        return completed();
-      }
+  if (action === 'take') {
+    args.takenCount++;
+    args.conditionMet = true;
+  }
 
-      if (conditionMet && nextFlow.isDefault) {
-        outbound[nextFlow.id] = formatFlowAction(nextFlow, {action: 'discard'});
-        return completed();
-      }
+  args.result[flowId] = content;
 
-      ack();
-      evaluateSequenceFlows(nextFlow);
-    }, {consumerTag: `_flow-evaluation-${executionId}`});
+  if ('result' in content) {
+    this.activity.logger.debug(`<${evaluationId} (${this.activity.id})> flow <${flowId}> evaluated to: ${!!content.result}`);
+  }
 
-    return evaluateSequenceFlows(evaluateFlows.shift());
+  let nextFlow = args.flows.shift();
+  if (!nextFlow) return this.completed();
 
-    function completed(err) {
-      broker.cancel(`_flow-evaluation-${executionId}`);
-      if (err) return callback(err);
+  if (args.discardRestAtTake && args.conditionMet) {
+    do {
+      args.result[nextFlow.id] = formatFlowAction(nextFlow, {action: 'discard'});
+    } while ((nextFlow = args.flows.shift()));
+    return this.completed();
+  }
 
-      if (!takenCount) {
-        const nonTakenError = new ActivityError(`<${id}> no conditional flow taken`, fromMessage);
-        logger.error(`<${id}>`, nonTakenError);
-        return callback(nonTakenError);
-      }
+  if (args.conditionMet && nextFlow.isDefault) {
+    args.result[nextFlow.id] = formatFlowAction(nextFlow, {action: 'discard'});
+    return this.completed();
+  }
 
-      const outboundList = Object.keys(outbound).reduce((result, flowId) => {
-        const flow = outbound[flowId];
-        result.push({
-          ...flow,
-          ...(message !== undefined ? {message} : undefined),
-        });
-        return result;
-      }, []);
+  message.ack();
+  this.evaluateFlow(nextFlow);
+};
 
-      return callback(null, outboundList);
-    }
+OutboundEvaluator.prototype.evaluateFlow = function evaluateFlow(flow) {
+  const broker = this.broker;
+  if (flow.isDefault) {
+    return broker.publish('execution', 'evaluate.flow.take', formatFlowAction(flow, {action: 'take'}), {persistent: false});
+  }
 
-    function evaluateSequenceFlows(flow) {
-      if (!flow) return completed();
+  const flowCondition = flow.getCondition();
+  if (!flowCondition) {
+    return broker.publish('execution', 'evaluate.flow.take', formatFlowAction(flow, {action: 'take'}), {persistent: false});
+  }
 
-      if (flow.isDefault) {
-        return broker.publish('execution', 'evaluate.flow.take', formatFlowAction(flow, {action: 'take'}), {persistent: false});
-      }
+  const {fromMessage, evaluationId} = this.evaluateArgs;
+  flowCondition.execute(cloneMessage(fromMessage), (err, result) => {
+    if (err) return this.completed(err);
+    const action = result ? 'take' : 'discard';
+    return broker.publish('execution', 'evaluate.flow.' + action, formatFlowAction(flow, {
+      action,
+      result,
+      evaluationId,
+    }), {persistent: false});
+  });
+};
 
-      const flowCondition = flow.getCondition();
-      if (!flowCondition) {
-        return broker.publish('execution', 'evaluate.flow.take', formatFlowAction(flow, {action: 'take'}), {persistent: false});
-      }
+OutboundEvaluator.prototype.completed = function completed(err) {
+  const {callback, evaluationId, fromMessage, result, takenCount} = this.evaluateArgs;
+  this.broker.cancel(`_flow-evaluation-${evaluationId}`);
 
-      flowCondition.execute(cloneMessage(fromMessage), (err, result) => {
-        if (err) return completed(err);
-        const action = result ? 'take' : 'discard';
-        return broker.publish('execution', 'evaluate.flow.' + action, formatFlowAction(flow, {
-          action,
-          result,
-        }), {persistent: false});
-      });
-    }
-  }
+  if (err) return callback(err);
 
-  function getActivityById(elementId) {
-    return context.getActivityById(elementId);
+  if (!takenCount && this.outboundFlows.length) {
+    const nonTakenError = new ActivityError(`<${this.activity.id}> no conditional flow taken`, fromMessage);
+    return callback(nonTakenError);
   }
 
-  function getState() {
-    const msg = createMessage();
-
-    return {
-      ...msg,
-      status,
-      executionId,
-      stopped,
-      behaviour: {...behaviour},
-      counters: {...counters},
-      broker: broker.getState(true),
-      execution: execution && execution.getState(),
-    };
+  const message = fromMessage.content.message;
+  const evaluationResult = [];
+  for (const flow of Object.values(result)) {
+    evaluationResult.push({
+      ...flow,
+      ...(message !== undefined ? {message} : undefined),
+    });
   }
 
-  function next() {
-    if (!step) return;
-    if (!stateMessage) return;
-    if (status === 'executing') return false;
-    if (status === 'formatting') return false;
-    const current = stateMessage;
-    stateMessage.ack();
-    return current;
-  }
+  return callback(null, evaluationResult);
+};
 
-  function getApi(message) {
-    if (execution && !execution.completed) return execution.getApi(message);
-    return ActivityApi(broker, message || stateMessage);
-  }
+function formatFlowAction(flow, options) {
+  return {
+    ...options,
+    id: flow.id,
+    action: options.action,
+    ...(flow.isDefault ? {isDefault: true} : undefined),
+  };
 }