bpmn-elements 17.2.2 → 18.0.0

package/src/events/IntermediateCatchEvent.js

@@ -1,22 +1,38 @@
-import Activity from '../activity/Activity.js';
-import EventDefinitionExecution from '../eventDefinitions/EventDefinitionExecution.js';
+import { Activity } from '../activity/Activity.js';
+import { EventDefinitionExecution } from '../eventDefinitions/EventDefinitionExecution.js';
 import { cloneContent } from '../messageHelper.js';
+import { K_EXECUTION } from '../constants.js';
 
-const kExecution = Symbol.for('execution');
-
-export default function IntermediateCatchEvent(activityDef, context) {
-  return new Activity(IntermediateCatchEventBehaviour, activityDef, context);
+/**
+ * Intermediate catch event
+ * @param {import('moddle-context-serializer').Activity} activityDef
+ * @param {import('#types').ContextInstance} context
+ */
+export function IntermediateCatchEvent(activityDef, context) {
+  return new Activity(
+    IntermediateCatchEventBehaviour,
+    { ...activityDef, isCatching: true, ...context.getLinkEventDefinitionInfo(activityDef) },
+    context
+  );
 }
 
+/**
+ * Intermediate catch event behaviour
+ * @param {import('#types').Activity} activity
+ */
 export function IntermediateCatchEventBehaviour(activity) {
   this.id = activity.id;
   this.type = activity.type;
   this.broker = activity.broker;
-  this[kExecution] = activity.eventDefinitions && new EventDefinitionExecution(activity, activity.eventDefinitions);
+  this[K_EXECUTION] = activity.eventDefinitions && new EventDefinitionExecution(activity, activity.eventDefinitions);
 }
 
+/**
+ * @param {import('#types').ElementBrokerMessage} executeMessage
+ * @returns {void}
+ */
 IntermediateCatchEventBehaviour.prototype.execute = function execute(executeMessage) {
-  const execution = this[kExecution];
+  const execution = this[K_EXECUTION];
   if (execution) {
     return execution.execute(executeMessage);
   }

package/src/events/IntermediateThrowEvent.js

@@ -1,22 +1,38 @@
-import Activity from '../activity/Activity.js';
-import EventDefinitionExecution from '../eventDefinitions/EventDefinitionExecution.js';
+import { Activity } from '../activity/Activity.js';
+import { EventDefinitionExecution } from '../eventDefinitions/EventDefinitionExecution.js';
 import { cloneContent } from '../messageHelper.js';
+import { K_EXECUTION } from '../constants.js';
 
-const kExecution = Symbol.for('execution');
-
-export default function IntermediateThrowEvent(activityDef, context) {
-  return new Activity(IntermediateThrowEventBehaviour, { ...activityDef, isThrowing: true }, context);
+/**
+ * Intermediate throw event
+ * @param {import('moddle-context-serializer').Activity} activityDef
+ * @param {import('#types').ContextInstance} context
+ */
+export function IntermediateThrowEvent(activityDef, context) {
+  return new Activity(
+    IntermediateThrowEventBehaviour,
+    { ...activityDef, isThrowing: true, ...context.getLinkEventDefinitionInfo(activityDef) },
+    context
+  );
 }
 
+/**
+ * Intermediate throw event behaviour
+ * @param {import('#types').Activity} activity
+ */
 export function IntermediateThrowEventBehaviour(activity) {
   this.id = activity.id;
   this.type = activity.type;
   this.broker = activity.broker;
-  this[kExecution] = activity.eventDefinitions && new EventDefinitionExecution(activity, activity.eventDefinitions);
+  this[K_EXECUTION] = activity.eventDefinitions && new EventDefinitionExecution(activity, activity.eventDefinitions);
 }
 
+/**
+ * @param {import('#types').ElementBrokerMessage} executeMessage
+ * @returns {void}
+ */
 IntermediateThrowEventBehaviour.prototype.execute = function execute(executeMessage) {
-  const execution = this[kExecution];
+  const execution = this[K_EXECUTION];
   if (execution) {
     return execution.execute(executeMessage);
   }

package/src/events/StartEvent.js

@@ -1,30 +1,41 @@
-import Activity from '../activity/Activity.js';
-import EventDefinitionExecution from '../eventDefinitions/EventDefinitionExecution.js';
+import { Activity } from '../activity/Activity.js';
+import { EventDefinitionExecution } from '../eventDefinitions/EventDefinitionExecution.js';
 import { cloneContent } from '../messageHelper.js';
+import { K_EXECUTE_MESSAGE, K_EXECUTION } from '../constants.js';
 
-const kExecuteMessage = Symbol.for('executeMessage');
-const kExecution = Symbol.for('execution');
-
-export default function StartEvent(activityDef, context) {
-  return new Activity(StartEventBehaviour, activityDef, context);
+/**
+ * Start event
+ * @param {import('moddle-context-serializer').Activity} activityDef
+ * @param {import('#types').ContextInstance} context
+ */
+export function StartEvent(activityDef, context) {
+  return new Activity(StartEventBehaviour, { ...activityDef, isStartEvent: true }, context);
 }
 
+/**
+ * Start event behaviour
+ * @param {import('#types').Activity} activity
+ */
 export function StartEventBehaviour(activity) {
   this.id = activity.id;
   this.type = activity.type;
   this.activity = activity;
   this.broker = activity.broker;
-  this[kExecution] = activity.eventDefinitions && new EventDefinitionExecution(activity, activity.eventDefinitions);
+  this[K_EXECUTION] = activity.eventDefinitions && new EventDefinitionExecution(activity, activity.eventDefinitions);
 }
 
 Object.defineProperty(StartEventBehaviour.prototype, 'executionId', {
   get() {
-    return this[kExecuteMessage]?.content.executionId;
+    return this[K_EXECUTE_MESSAGE]?.content.executionId;
   },
 });
 
+/**
+ * @param {import('#types').ElementBrokerMessage} executeMessage
+ * @returns {void}
+ */
 StartEventBehaviour.prototype.execute = function execute(executeMessage) {
-  const execution = this[kExecution];
+  const execution = this[K_EXECUTION];
   if (execution) {
     return execution.execute(executeMessage);
   }
@@ -36,7 +47,7 @@ StartEventBehaviour.prototype.execute = function execute(executeMessage) {
   }
 
   const executionId = content.executionId;
-  this[kExecuteMessage] = executeMessage;
+  this[K_EXECUTE_MESSAGE] = executeMessage;
   broker.subscribeTmp('api', `activity.#.${executionId}`, (...args) => this._onApiMessage(...args), {
     noAck: true,
     consumerTag: `_api-${executionId}`,
@@ -56,7 +67,7 @@ StartEventBehaviour.prototype._onApiMessage = function onApiMessage(routingKey,
       return this._stop();
     case 'signal': {
       this._stop();
-      const content = this[kExecuteMessage].content;
+      const content = this[K_EXECUTE_MESSAGE].content;
       return this.broker.publish(
         'execution',
         'execute.completed',
@@ -69,7 +80,7 @@ StartEventBehaviour.prototype._onApiMessage = function onApiMessage(routingKey,
     }
     case 'discard': {
       this._stop();
-      const content = this[kExecuteMessage].content;
+      const content = this[K_EXECUTE_MESSAGE].content;
       return this.broker.publish('execution', 'execute.discard', cloneContent(content), { correlationId });
     }
   }
@@ -85,7 +96,7 @@ StartEventBehaviour.prototype._onDelegatedApiMessage = function onDelegatedApiMe
   if (signalId !== this.id && signalExecutionId !== this.executionId) return;
 
   const { type, correlationId } = message.properties;
-  const executeContent = this[kExecuteMessage].content;
+  const executeContent = this[K_EXECUTE_MESSAGE].content;
   this.broker.publish(
     'event',
     'activity.consumed',

package/src/events/index.js

@@ -1,18 +1,5 @@
-import BoundaryEvent, { BoundaryEventBehaviour } from './BoundaryEvent.js';
-import EndEvent, { EndEventBehaviour } from './EndEvent.js';
-import IntermediateCatchEvent, { IntermediateCatchEventBehaviour } from './IntermediateCatchEvent.js';
-import IntermediateThrowEvent, { IntermediateThrowEventBehaviour } from './IntermediateThrowEvent.js';
-import StartEvent, { StartEventBehaviour } from './StartEvent.js';
-
-export {
-  BoundaryEvent,
-  BoundaryEventBehaviour,
-  EndEvent,
-  EndEventBehaviour,
-  IntermediateCatchEvent,
-  IntermediateCatchEventBehaviour,
-  IntermediateThrowEvent,
-  IntermediateThrowEventBehaviour,
-  StartEvent,
-  StartEventBehaviour,
-};
+export { BoundaryEvent, BoundaryEventBehaviour } from './BoundaryEvent.js';
+export { EndEvent, EndEventBehaviour } from './EndEvent.js';
+export { IntermediateCatchEvent, IntermediateCatchEventBehaviour } from './IntermediateCatchEvent.js';
+export { IntermediateThrowEvent, IntermediateThrowEventBehaviour } from './IntermediateThrowEvent.js';
+export { StartEvent, StartEventBehaviour } from './StartEvent.js';

package/src/flows/Association.js

@@ -2,16 +2,22 @@ import { cloneParent } from '../messageHelper.js';
 import { EventBroker } from '../EventBroker.js';
 import { Api } from '../Api.js';
 import { getUniqueId } from '../shared.js';
-
-const kCounters = Symbol.for('counters');
-
-export default function Association(associationDef, { environment }) {
+import { K_COUNTERS } from '../constants.js';
+
+/**
+ * Association connecting a source and target activity. Used to drive compensation —
+ * activities marked `isForCompensation` subscribe to inbound association events.
+ * @param {import('moddle-context-serializer').Association} associationDef
+ * @param {import('#types').ContextInstance} context
+ */
+export function Association(associationDef, { environment }) {
   const { id, type = 'association', name, parent, targetId, sourceId, behaviour = {} } = associationDef;
 
   this.id = id;
   this.type = type;
   this.name = name;
   this.parent = cloneParent(parent);
+  /** @type {Record<string, any>} */
   this.behaviour = behaviour;
   this.sourceId = sourceId;
   this.targetId = targetId;
@@ -19,7 +25,7 @@ export default function Association(associationDef, { environment }) {
   this.environment = environment;
   const logger = (this.logger = environment.Logger(type.toLowerCase()));
 
-  this[kCounters] = {
+  this[K_COUNTERS] = {
     take: 0,
     discard: 0,
   };
@@ -34,29 +40,43 @@ export default function Association(associationDef, { environment }) {
 }
 
 Object.defineProperty(Association.prototype, 'counters', {
+  /** @returns {{ take: number, discard: number }} */
   get() {
-    return { ...this[kCounters] };
+    return { ...this[K_COUNTERS] };
   },
 });
 
+/**
+ * Take the association and publish association.take.
+ * @param {Record<string, any>} [content]
+ */
 Association.prototype.take = function take(content) {
   this.logger.debug(`<${this.id}> take target <${this.targetId}>`);
-  ++this[kCounters].take;
+  ++this[K_COUNTERS].take;
 
   this._publishEvent('take', content);
 
   return true;
 };
 
+/**
+ * Discard the association and publish association.discard.
+ * @param {Record<string, any>} [content]
+ */
 Association.prototype.discard = function discard(content) {
   this.logger.debug(`<${this.id}> discard target <${this.targetId}>`);
-  ++this[kCounters].discard;
+  ++this[K_COUNTERS].discard;
 
   this._publishEvent('discard', content);
 
   return true;
 };
 
+/**
+ * Snapshot association state. Returns undefined when broker has no state and
+ * `disableTrackState` is set.
+ * @returns {import('#types').AssociationState | undefined}
+ */
 Association.prototype.getState = function getState() {
   const brokerState = this.broker.getState(true);
   if (!brokerState && this.environment.settings.disableTrackState) return;
@@ -69,19 +89,32 @@ Association.prototype.getState = function getState() {
   };
 };
 
+/**
+ * Restore association state captured by getState.
+ * @param {import('#types').AssociationState} state
+ */
 Association.prototype.recover = function recover(state) {
-  Object.assign(this[kCounters], state.counters);
+  Object.assign(this[K_COUNTERS], state.counters);
   this.broker.recover(state.broker);
 };
 
+/**
+ * Resolve an association-scoped Api wrapper.
+ * @param {import('#types').ElementBrokerMessage} [message]
+ * @returns {import('#types').IApi<this>}
+ */
 Association.prototype.getApi = function getApi(message) {
   return new Api('association', this.broker, message || { content: this._createMessageContent() });
 };
 
+/**
+ * Stop the association's broker.
+ */
 Association.prototype.stop = function stop() {
   this.broker.stop();
 };
 
+/** @internal */
 Association.prototype._publishEvent = function publishEvent(action, content) {
   const eventContent = this._createMessageContent({
     action,
@@ -92,6 +125,7 @@ Association.prototype._publishEvent = function publishEvent(action, content) {
   this.broker.publish('event', `association.${action}`, eventContent, { type: action });
 };
 
+/** @internal */
 Association.prototype._createMessageContent = function createMessageContent(override) {
   return {
     ...override,

package/src/flows/MessageFlow.js

@@ -2,11 +2,18 @@ import { brokerSafeId } from '../shared.js';
 import { cloneParent } from '../messageHelper.js';
 import { MessageFlowBroker } from '../EventBroker.js';
 import { Api } from '../Api.js';
+import { K_COUNTERS } from '../constants.js';
 
-const kCounters = Symbol.for('counters');
-const kSourceElement = Symbol.for('sourceElement');
+const K_SOURCE_ELEMENT = Symbol.for('sourceElement');
 
-export default function MessageFlow(flowDef, context) {
+/**
+ * Message flow connecting a source activity (or process) to a target. Subscribes to the
+ * source's `end` event and publishes `message.outbound` whenever the source completes,
+ * carrying any message payload through to the target.
+ * @param {import('moddle-context-serializer').MessageFlow} flowDef
+ * @param {import('#types').ContextInstance} context
+ */
+export function MessageFlow(flowDef, context) {
   const { id, type = 'messageflow', name, target, source, behaviour, parent } = flowDef;
 
   this.id = id;
@@ -15,11 +22,12 @@ export default function MessageFlow(flowDef, context) {
   this.parent = cloneParent(parent);
   this.source = source;
   this.target = target;
+  /** @type {Record<string, any>} */
   this.behaviour = behaviour;
   this.environment = context.environment;
   this.context = context;
 
-  this[kCounters] = {
+  this[K_COUNTERS] = {
     messages: 0,
   };
 
@@ -30,16 +38,22 @@ export default function MessageFlow(flowDef, context) {
   this.emit = emit;
   this.waitFor = waitFor;
 
-  this[kSourceElement] = context.getActivityById(source.id) || context.getProcessById(source.processId);
+  this[K_SOURCE_ELEMENT] = context.getActivityById(source.id) || context.getProcessById(source.processId);
   this.logger = context.environment.Logger(type.toLowerCase());
 }
 
 Object.defineProperty(MessageFlow.prototype, 'counters', {
+  /** @returns {{ messages: number }} */
   get() {
-    return { ...this[kCounters] };
+    return { ...this[K_COUNTERS] };
   },
 });
 
+/**
+ * Snapshot message-flow state. Returns undefined when broker has no state and
+ * `disableTrackState` is set.
+ * @returns {import('#types').MessageFlowState | undefined}
+ */
 MessageFlow.prototype.getState = function getState() {
   const brokerState = this.broker.getState(true);
   if (!brokerState && this.environment.settings.disableTrackState) return;
@@ -52,31 +66,47 @@ MessageFlow.prototype.getState = function getState() {
   };
 };
 
+/**
+ * Restore message-flow state captured by getState.
+ * @param {import('#types').MessageFlowState} state
+ */
 MessageFlow.prototype.recover = function recover(state) {
-  Object.assign(this[kCounters], state.counters);
+  Object.assign(this[K_COUNTERS], state.counters);
   this.broker.recover(state.broker);
 };
 
+/**
+ * Resolve a message-scoped Api wrapper.
+ * @param {import('#types').ElementBrokerMessage} [message]
+ * @returns {import('#types').IApi<this>}
+ */
 MessageFlow.prototype.getApi = function getApi(message) {
   return new Api('message', this.broker, message || { content: this._createMessageContent() });
 };
 
+/**
+ * Subscribe to the source element's message and end events to bridge the message across.
+ */
 MessageFlow.prototype.activate = function activate() {
-  const sourceElement = this[kSourceElement];
+  const sourceElement = this[K_SOURCE_ELEMENT];
   const safeId = brokerSafeId(this.id);
   sourceElement.on('message', this.deactivate.bind(this), { consumerTag: `_message-on-message-${safeId}` });
   sourceElement.on('end', this._onSourceEnd.bind(this), { consumerTag: `_message-on-end-${safeId}` });
 };
 
+/**
+ * Cancel the source element subscriptions added by activate.
+ */
 MessageFlow.prototype.deactivate = function deactivate() {
-  const sourceElement = this[kSourceElement];
+  const sourceElement = this[K_SOURCE_ELEMENT];
   const safeId = brokerSafeId(this.id);
   sourceElement.broker.cancel(`_message-on-end-${safeId}`);
   sourceElement.broker.cancel(`_message-on-message-${safeId}`);
 };
 
+/** @internal */
 MessageFlow.prototype._onSourceEnd = function onSourceEnd({ content }) {
-  ++this[kCounters].messages;
+  ++this[K_COUNTERS].messages;
   const source = this.source;
   const target = this.target;
   this.logger.debug(
@@ -85,6 +115,7 @@ MessageFlow.prototype._onSourceEnd = function onSourceEnd({ content }) {
   this.broker.publish('event', 'message.outbound', this._createMessageContent(content.message));
 };
 
+/** @internal */
 MessageFlow.prototype._createMessageContent = function createMessage(message) {
   return {
     id: this.id,

package/src/flows/SequenceFlow.js

@@ -3,18 +3,22 @@ import { getUniqueId } from '../shared.js';
 import { EventBroker } from '../EventBroker.js';
 import { FlowApi } from '../Api.js';
 import { ScriptCondition, ExpressionCondition } from '../condition.js';
-
-const kCounters = Symbol.for('counters');
-
-export default SequenceFlow;
-
-function SequenceFlow(flowDef, { environment }) {
+import { K_COUNTERS } from '../constants.js';
+
+/**
+ * Sequence flow connecting two activities. Owns its broker and publishes take/discard/looped
+ * events; activities subscribe to drive their inbound queue.
+ * @param {import('moddle-context-serializer').SequenceFlow} flowDef
+ * @param {import('#types').ContextInstance} context
+ */
+export function SequenceFlow(flowDef, { environment }) {
   const { id, type = 'sequenceflow', name, parent, targetId, sourceId, isDefault, behaviour = {} } = flowDef;
 
   this.id = id;
   this.type = type;
   this.name = name;
   this.parent = cloneParent(parent);
+  /** @type {Record<string, any>} */
   this.behaviour = behaviour;
   this.sourceId = sourceId;
   this.targetId = targetId;
@@ -23,7 +27,7 @@ function SequenceFlow(flowDef, { environment }) {
   this.environment = environment;
   const logger = (this.logger = environment.Logger(type.toLowerCase()));
 
-  this[kCounters] = {
+  this[K_COUNTERS] = {
     looped: 0,
     take: 0,
     discard: 0,
@@ -42,27 +46,38 @@ function SequenceFlow(flowDef, { environment }) {
 }
 
 Object.defineProperty(SequenceFlow.prototype, 'counters', {
+  /** @returns {{ take: number, discard: number, looped: number }} */
   get() {
-    return { ...this[kCounters] };
+    return { ...this[K_COUNTERS] };
   },
 });
 
+/**
+ * Take the flow and publish flow.take.
+ * @param {Record<string, any>} [content]
+ */
 SequenceFlow.prototype.take = function take(content) {
   const sequenceId = content?.sequenceId;
 
   this.logger.debug(`<${sequenceId} (${this.id})> take, target <${this.targetId}>`);
-  ++this[kCounters].take;
+  ++this[K_COUNTERS].take;
 
   this._publishEvent('take', content);
 
   return true;
 };
 
+/**
+ * Discard the flow and publish flow.discard.
+ *
+ * @deprecated The execution runtime no longer discards sequence flows, so this is a no-op during a run. It will be removed in a future version.
+ * @param {Record<string, any>} [content]
+ */
 SequenceFlow.prototype.discard = function discard(content = {}) {
   const sequenceId = content?.sequenceId ?? getUniqueId(this.id);
-  const discardSequence = (content.discardSequence = (content.discardSequence || []).slice());
+  const discardSequence = (content.discardSequence = content.discardSequence?.slice() || []);
   if (discardSequence.indexOf(this.targetId) > -1) {
-    ++this[kCounters].looped;
+    ++this[K_COUNTERS].looped;
     this.logger.debug(`<${this.id}> discard loop detected <${this.sourceId}> -> <${this.targetId}>. Stop.`);
     return this._publishEvent('looped', content);
   }
@@ -70,10 +85,15 @@ SequenceFlow.prototype.discard = function discard(content = {}) {
   discardSequence.push(this.sourceId);
 
   this.logger.debug(`<${sequenceId} (${this.id})> discard, target <${this.targetId}>`);
-  ++this[kCounters].discard;
+  ++this[K_COUNTERS].discard;
   this._publishEvent('discard', content);
 };
 
+/**
+ * Snapshot flow state. Returns undefined when the broker has no state and `disableTrackState`
+ * is set.
+ * @returns {import('#types').SequenceFlowState | undefined}
+ */
 SequenceFlow.prototype.getState = function getState() {
   const brokerState = this.broker.getState(true);
   if (!brokerState && this.environment.settings.disableTrackState) return;
@@ -86,33 +106,65 @@ SequenceFlow.prototype.getState = function getState() {
   };
 };
 
+/**
+ * Restore flow state captured by getState.
+ * @param {import('#types').SequenceFlowState} state
+ */
 SequenceFlow.prototype.recover = function recover(state) {
-  Object.assign(this[kCounters], state.counters);
+  Object.assign(this[K_COUNTERS], state.counters);
   this.broker.recover(state.broker);
 };
 
+/**
+ * Resolve a Flow Api wrapper.
+ * @param {import('#types').ElementBrokerMessage} [message]
+ * @returns {import('#types').IApi<this>}
+ */
 SequenceFlow.prototype.getApi = function getApi(message) {
   return FlowApi(this.broker, message || { content: this.createMessage() });
 };
 
+/**
+ * Stop the flow's broker.
+ */
 SequenceFlow.prototype.stop = function stop() {
   this.broker.stop();
 };
 
+/**
+ * Walk the flow as part of a process shake. Detects loops and publishes flow.shake.loop
+ * when the target was already visited, otherwise flow.shake.
+ * @param {import('#types').ElementBrokerMessage} message
+ */
 SequenceFlow.prototype.shake = function shake(message) {
   const content = cloneContent(message.content);
+
   content.sequence = content.sequence || [];
-  content.sequence.push({ id: this.id, type: this.type, isSequenceFlow: true, targetId: this.targetId });
 
-  if (content.id === this.targetId) return this.broker.publish('event', 'flow.shake.loop', content, { persistent: false, type: 'shake' });
+  const info = {
+    id: this.id,
+    type: this.type,
+    isSequenceFlow: true,
+    sourceId: this.sourceId,
+    targetId: this.targetId,
+  };
 
-  for (const s of message.content.sequence || []) {
-    if (s.id === this.id) return this.broker.publish('event', 'flow.shake.loop', content, { persistent: false, type: 'shake' });
+  if (content.id === this.targetId) {
+    content.sequence.push(info);
+    return this.broker.publish('event', 'flow.shake.loop', content, { persistent: false, type: 'shake' });
+  } else if (content.sequence?.find((f) => f.id === this.id)) {
+    return this.broker.publish('event', 'flow.shake.loop', content, { persistent: false, type: 'shake' });
+  } else {
+    content.sequence.push(info);
+    this.broker.publish('event', 'flow.shake', content, { persistent: false, type: 'shake' });
   }
-
-  this.broker.publish('event', 'flow.shake', content, { persistent: false, type: 'shake' });
 };
 
+/**
+ * Resolve the flow's condition (script or expression). Returns null when no condition is set.
+ * Emits a fatal error when the script language is missing or unsupported.
+ * @returns {import('#types').ICondition | null}
+ */
 SequenceFlow.prototype.getCondition = function getCondition() {
   const conditionExpression = this.behaviour.conditionExpression;
   if (!conditionExpression) return null;
@@ -133,6 +185,11 @@ SequenceFlow.prototype.getCondition = function getCondition() {
   return new ExpressionCondition(this, conditionExpression.body);
 };
 
+/**
+ * Build a flow event message body, optionally merging override content.
+ * @param {Record<string, any>} [override]
+ * @returns {import('#types').ElementMessageContent}
+ */
 SequenceFlow.prototype.createMessage = function createMessage(override) {
   return {
     ...override,
@@ -147,6 +204,11 @@ SequenceFlow.prototype.createMessage = function createMessage(override) {
   };
 };
 
+/**
+ * Evaluate the flow's condition for the source activity message. Default flows are always taken.
+ * @param {import('#types').ElementBrokerMessage} fromMessage Source activity message
+ * @param {(err: Error | null, result?: boolean | unknown) => void} callback Callback with truthy result if flow should be taken
+ */
 SequenceFlow.prototype.evaluate = function evaluate(fromMessage, callback) {
   if (this.isDefault) {
     return callback(null, true);
@@ -160,6 +222,7 @@ SequenceFlow.prototype.evaluate = function evaluate(fromMessage, callback) {
   flowCondition.execute(fromMessage, callback);
 };
 
+/** @internal */
 SequenceFlow.prototype._publishEvent = function publishEvent(action, content) {
   const eventContent = this.createMessage({
     action,

package/src/flows/index.js

@@ -1,5 +1,4 @@
-import Association from './Association.js';
-import MessageFlow from './MessageFlow.js';
-import SequenceFlow from './SequenceFlow.js';
-
+import { Association } from './Association.js';
+import { MessageFlow } from './MessageFlow.js';
+import { SequenceFlow } from './SequenceFlow.js';
 export { Association, MessageFlow, SequenceFlow };