remove intermediate skipDiscard flag

Author: paed01

CHANGELOG.md

@@ -1,19 +1,19 @@
 # Changelog
 
-## v18.0.0 - 2026-05-31
+## v18.0.0 - 2026-06-11
 
-Refactor parallel converging and forking gateways, and treat multiple start events as mutually exclusive entry points.
+Refactor parallel converging and forking gateways, and treat multiple start events as mutually exclusive entry points. As a result of the parallel gateway keeping track of peers there is no need for discarding a sequence flows.
 
 ### Breaking
 
+- `Definition` must be called with `new`
 - parallel gateways now enter execution as soon as the first inbound sequence flow is touched
-- shake sequence has changed
+- removed discarding of outbound sequence flows altogether — activities no longer publish flow discards, so sequence flow and downstream activity `discarded` counters stay at `0`
 - IntermediateCatchEvent cannot be used as a starting element, or it can but will not be started by default
-- `Definition` must be called with `new`
-- non-gateway activities discard their outbound when all conditional flows are falsy instead of throwing; only exclusive and inclusive gateways still require a taken or default flow
+- non-gateway activities end the branch when all conditional outbound flows are falsy instead of throwing; only exclusive and inclusive gateways still require a taken or default flow
 - multiple start events are mutually exclusive entry points — the first start event to fire discards the others still waiting to be triggered, so two start events can no longer both run (e.g. into a parallel join, or a joining task taken twice)
 - start activities that are not start events (e.g. a starting receive task, or an activity without an inbound flow) are no longer auto-discarded; they are genuine tokens that must be signalled or completed
-- multiple start events no longer trigger a graph shake on run/resume; only converging parallel gateways do, and the shake remains available on demand via `shake()`
+- shake sequence has changed
 
 ### Additions
 
@@ -28,7 +28,7 @@ Refactor parallel converging and forking gateways, and treat multiple start even
 
 ### Types
 
-- runtime types are now generated from JSDoc and bundled with [dts-buddy](https://github.com/Rich-Harris/dts-buddy); status enums (`ActivityStatus`, `DefinitionStatus`, `ProcessStatus`) and `TimerType` accept both enum members and their string literals.
+- runtime types are now generated from JSDoc and bundled with [dts-buddy](https://github.com/Rich-Harris/dts-buddy)
 - expose `isStartEvent` and `isParallelGateway` on the `Activity` interface
 
 ## v17.3.0 - 2025-12-03

dist/Environment.js

@@ -29,7 +29,6 @@ function Environment(options = {}) {
   this.timers = options.timers || new _Timers.Timers();
   /** @type {import('#types').EnvironmentSettings} */
   this.settings = {
-    skipDiscard: true,
     ...options.settings
   };
   /** @type {import('#types').LoggerFactory} */

dist/activity/Activity.js

@@ -793,7 +793,6 @@ Activity.prototype._pauseRunQ = function pauseRunQ() {
 Activity.prototype._onRunMessage = function onRunMessage(routingKey, message, messageProperties) {
   switch (routingKey) {
     case 'run.execute.passthrough':
-    case 'run.outbound.discard':
     case 'run.outbound.take':
     case 'run.next':
       return this._continueRunMessage(routingKey, message, messageProperties);
@@ -932,12 +931,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;
@@ -1065,10 +1058,6 @@ Activity.prototype._doOutbound = function doOutbound(fromMessage, isDiscarded, c
   const outboundSequenceFlows = this[K_FLOWS].outboundSequenceFlows;
   if (!outboundSequenceFlows.length) return callback(null, []);
   const fromContent = fromMessage.content;
-  let discardSequence = fromContent.discardSequence;
-  if (isDiscarded && !discardSequence && this[K_FLAGS].attachedTo && fromContent.inbound?.[0]) {
-    discardSequence = [fromContent.inbound[0].id];
-  }
   let outboundFlows;
   if (isDiscarded) {
     outboundFlows = outboundSequenceFlows.map(flow => (0, _outboundEvaluator.formatFlowAction)(flow, {
@@ -1078,20 +1067,20 @@ Activity.prototype._doOutbound = function doOutbound(fromMessage, isDiscarded, c
     outboundFlows = outboundSequenceFlows.map(flow => (0, _outboundEvaluator.formatFlowAction)(flow, fromContent.outbound.filter(f => f.id === flow.id).pop()));
   }
   if (outboundFlows) {
-    this._doRunOutbound(outboundFlows, fromContent, discardSequence);
+    this._doRunOutbound(outboundFlows, fromContent);
     return callback(null, outboundFlows);
   }
   return this.evaluateOutbound(fromMessage, fromContent.outboundTakeOne, (err, evaluatedOutbound) => {
     if (err) return callback(new _Errors.ActivityError(err.message, fromMessage, err));
-    const outbound = this._doRunOutbound(evaluatedOutbound, fromContent, discardSequence);
+    const outbound = this._doRunOutbound(evaluatedOutbound, fromContent);
     return callback(null, outbound);
   });
 };
 
 /** @internal */
-Activity.prototype._doRunOutbound = function doRunOutbound(outboundList, content, discardSequence) {
+Activity.prototype._doRunOutbound = function doRunOutbound(outboundList, content) {
   if (outboundList.length === 1) {
-    this._publishRunOutbound(outboundList[0], content, discardSequence);
+    this._publishRunOutbound(outboundList[0], content);
   } else {
     const targets = new Map();
     for (const outboundFlow of outboundList) {
@@ -1103,30 +1092,27 @@ Activity.prototype._doRunOutbound = function doRunOutbound(outboundList, content
       }
     }
     for (const outboundFlow of targets.values()) {
-      this._publishRunOutbound(outboundFlow, content, discardSequence);
+      this._publishRunOutbound(outboundFlow, content);
     }
   }
   return outboundList;
 };
 
 /** @internal */
-Activity.prototype._publishRunOutbound = function publishRunOutbound(outboundFlow, content, discardSequence) {
+Activity.prototype._publishRunOutbound = function publishRunOutbound(outboundFlow, content) {
   const {
     id: flowId,
     action,
     result
   } = outboundFlow;
-  if (action === 'discard' && this.environment.settings.skipDiscard) {
+  if (action === 'discard') {
     return;
   }
   this.broker.publish('run', 'run.outbound.' + action, (0, _messageHelper.cloneContent)(content, {
     flow: {
       ...(result && typeof result === 'object' && result),
       ...outboundFlow,
-      sequenceId: (0, _shared.getUniqueId)(`${flowId}_${action}`),
-      ...(discardSequence && {
-        discardSequence: discardSequence.slice()
-      })
+      sequenceId: (0, _shared.getUniqueId)(`${flowId}_${action}`)
     }
   }));
 };

docs/Environment.md

@@ -16,7 +16,6 @@ Arguments:
     - `strict`: boolean, [strict mode](#strict-mode) defaults to false
     - `batchSize`: optional positive integer to control parallel loop batch size, defaults to 50
     - `disableTrackState`: optional boolean to disable tracking of element counters between recover and resume. State of idle elements are not returned when getting state. Recommended if running and recovering really large flows
-    - `skipDiscard`: boolean, when true the runtime omits unnecessary discard messages for flows that no converging join is waiting on, defaults to true. Set to false for behaviour parity with older versions that always published discards
   - `scripts`: [Scripts instance](/docs/Scripts.md)
   - `timers`: [Timers instance](/docs/Timers.md)
   - `expressions`: expressions handler, defaults to [Expressions instance](/docs/Expression.md)

docs/SequenceFlow.md

@@ -66,6 +66,6 @@ An expression condition can resolve to a service function instead of a plain val
 If every conditional outbound flow evaluates to falsy, the behaviour depends on the element:
 
 - a diverging **exclusive or inclusive gateway** takes its `default` flow when declared, otherwise it raises an `<id> no conditional flow taken` error — these gateways require exactly one (exclusive) or at least one (inclusive) outbound to be taken;
-- any **other activity** (task, event, …) simply discards its outbound — the branch ends, no error is raised.
+- any **other activity** (task, event, …) simply ends the branch, no error is raised.
 
-> With the default `skipDiscard` setting the discards are not published, so the outbound flow `discard` counters stay at `0`. Set `skipDiscard` to `false` to observe the discards.
+> The runtime no longer publishes outbound flow discards, so outbound flow `discard` counters stay at `0`.

src/Environment.js

@@ -24,7 +24,7 @@ export function Environment(options = {}) {
   /** @type {import('#types').ITimers} */
   this.timers = options.timers || new Timers();
   /** @type {import('#types').EnvironmentSettings} */
-  this.settings = { skipDiscard: true, ...options.settings };
+  this.settings = { ...options.settings };
   /** @type {import('#types').LoggerFactory} */
   this.Logger = options.Logger || DummyLogger;
   this[K_SERVICES] = options.services || {};

src/activity/Activity.js

@@ -744,7 +744,6 @@ Activity.prototype._pauseRunQ = function pauseRunQ() {
 Activity.prototype._onRunMessage = function onRunMessage(routingKey, message, messageProperties) {
   switch (routingKey) {
     case 'run.execute.passthrough':
-    case 'run.outbound.discard':
     case 'run.outbound.take':
     case 'run.next':
       return this._continueRunMessage(routingKey, message, messageProperties);
@@ -881,11 +880,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;
 
@@ -994,11 +988,6 @@ Activity.prototype._doOutbound = function doOutbound(fromMessage, isDiscarded, c
 
   const fromContent = fromMessage.content;
 
-  let discardSequence = fromContent.discardSequence;
-  if (isDiscarded && !discardSequence && this[K_FLAGS].attachedTo && fromContent.inbound?.[0]) {
-    discardSequence = [fromContent.inbound[0].id];
-  }
-
   let outboundFlows;
   if (isDiscarded) {
     outboundFlows = outboundSequenceFlows.map((flow) => formatFlowAction(flow, { action: 'discard' }));
@@ -1007,21 +996,21 @@ Activity.prototype._doOutbound = function doOutbound(fromMessage, isDiscarded, c
   }
 
   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);
   });
 };
 
 /** @internal */
-Activity.prototype._doRunOutbound = function doRunOutbound(outboundList, content, discardSequence) {
+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();
 
@@ -1035,18 +1024,18 @@ Activity.prototype._doRunOutbound = function doRunOutbound(outboundList, content
     }
 
     for (const outboundFlow of targets.values()) {
-      this._publishRunOutbound(outboundFlow, content, discardSequence);
+      this._publishRunOutbound(outboundFlow, content);
     }
   }
 
   return outboundList;
 };
 
 /** @internal */
-Activity.prototype._publishRunOutbound = function publishRunOutbound(outboundFlow, content, discardSequence) {
+Activity.prototype._publishRunOutbound = function publishRunOutbound(outboundFlow, content) {
   const { id: flowId, action, result } = outboundFlow;
 
-  if (action === 'discard' && this.environment.settings.skipDiscard) {
+  if (action === 'discard') {
     return;
   }
 
@@ -1058,7 +1047,6 @@ Activity.prototype._publishRunOutbound = function publishRunOutbound(outboundFlo
         ...(result && typeof result === 'object' && result),
         ...outboundFlow,
         sequenceId: getUniqueId(`${flowId}_${action}`),
-        ...(discardSequence && { discardSequence: discardSequence.slice() }),
       },
     })
   );

test/Environment-test.js

@@ -2,8 +2,8 @@ import { Environment, Timers } from 'bpmn-elements';
 
 describe('Environment', () => {
   describe('ctor', () => {
-    it('sets settings with skipDiscard default', () => {
-      expect(new Environment()).to.have.property('settings').that.deep.equal({ skipDiscard: true });
+    it('defaults settings to an empty object', () => {
+      expect(new Environment()).to.have.property('settings').that.deep.equal({});
       expect(
         new Environment({
           settings: {
@@ -13,12 +13,11 @@ describe('Environment', () => {
       )
         .to.have.property('settings')
         .that.eql({
-          skipDiscard: true,
           test: 1,
         });
     });
 
-    it('shallow clones settings while preserving skipDiscard default', () => {
+    it('shallow clones settings', () => {
       const settings = {
         test: 1,
       };
@@ -28,7 +27,6 @@ describe('Environment', () => {
       settings.test = 2;
 
       expect(environment).to.have.property('settings').that.eql({
-        skipDiscard: true,
         test: 1,
       });
     });
@@ -268,13 +266,13 @@ describe('Environment', () => {
     it('ignored if non-object is passed', () => {
       const environment = new Environment({ settings: { before: true } });
       environment.assignSettings();
-      expect(environment.settings).to.eql({ skipDiscard: true, before: true });
+      expect(environment.settings).to.eql({ before: true });
       environment.assignSettings(null);
-      expect(environment.settings).to.eql({ skipDiscard: true, before: true });
+      expect(environment.settings).to.eql({ before: true });
       environment.assignSettings('null');
-      expect(environment.settings).to.eql({ skipDiscard: true, before: true });
+      expect(environment.settings).to.eql({ before: true });
       environment.assignSettings(1);
-      expect(environment.settings).to.eql({ skipDiscard: true, before: true });
+      expect(environment.settings).to.eql({ before: true });
     });
   });
 

test/feature/BoundaryEvent-feature.js

@@ -280,8 +280,8 @@ Feature('BoundaryEvent', () => {
       expect(initTask.counters).to.have.property('taken', 2);
     });
 
-    And('end was discarded', () => {
-      expect(bp.getActivityById('end').counters).to.have.property('discarded', bp.environment.settings.skipDiscard ? 0 : 1);
+    And('end was not discarded', () => {
+      expect(bp.getActivityById('end').counters).to.have.property('discarded', 0);
       expect(bp.getActivityById('end').counters).to.have.property('taken', 0);
     });
 
@@ -302,8 +302,8 @@ Feature('BoundaryEvent', () => {
       expect(bound.owner.counters).to.have.property('discarded', 1);
     });
 
-    And('init task is discarded', () => {
-      expect(initTask.counters).to.have.property('discarded', bp.environment.settings.skipDiscard ? 0 : 1);
+    And('init task is not discarded', () => {
+      expect(initTask.counters).to.have.property('discarded', 0);
       expect(initTask.counters).to.have.property('taken', 2);
     });
 
@@ -314,7 +314,7 @@ Feature('BoundaryEvent', () => {
 
     And('end was taken', () => {
       expect(bp.getActivityById('end').counters).to.have.property('taken', 1);
-      expect(bp.getActivityById('end').counters).to.have.property('discarded', bp.environment.settings.skipDiscard ? 0 : 1);
+      expect(bp.getActivityById('end').counters).to.have.property('discarded', 0);
     });
 
     And('process completes', () => {