Fix cancel heartbeat delay timer on abort

.pubnub.yml

@@ -1,5 +1,14 @@
 ---
 changelog:
+  - date: 2026-10-14
+    version: v13.1.2
+    changes:
+      - type: bug
+        text: "Clear pending heartbeat delay timer when presence effect is aborted, so destroy no longer waits for the full heartbeat interval."
+      - type: improvement
+        text: "Drop `delay` from event engine dependencies and client setup, as heartbeat delay now uses `heartbeatDelay`."
+      - type: improvement
+        text: "Add tests for timer cancel on destroy, no heartbeats after destroy and heartbeat loop stop on zero interval."
   - date: 2026-10-13
     version: v13.1.1
     changes:
@@ -1513,7 +1522,7 @@ supported-platforms:
       - 'Ubuntu 14.04 and up'
       - 'Windows 7 and up'
     version: 'Pubnub Javascript for Node'
-version: '13.1.1'
+version: '13.1.2'
 sdks:
   - full-name: PubNub Javascript SDK
     short-name: Javascript
@@ -1529,7 +1538,7 @@ sdks:
           - distribution-type: source
             distribution-repository: GitHub release
             package-name: pubnub.js
-            location: https://github.com/pubnub/javascript/archive/refs/tags/v13.1.1.zip
+            location: https://github.com/pubnub/javascript/archive/refs/tags/v13.1.2.zip
             requires:
               - name: 'agentkeepalive'
                 min-version: '3.5.2'
@@ -2200,7 +2209,7 @@ sdks:
           - distribution-type: library
             distribution-repository: GitHub release
             package-name: pubnub.js
-            location: https://github.com/pubnub/javascript/releases/download/v13.1.1/pubnub.13.1.1.js
+            location: https://github.com/pubnub/javascript/releases/download/v13.1.2/pubnub.13.1.2.js
             requires:
               - name: 'agentkeepalive'
                 min-version: '3.5.2'

CHANGELOG.md

@@ -1,3 +1,13 @@
+## v13.1.2
+October 14 2026
+
+#### Fixed
+- Clear pending heartbeat delay timer when presence effect is aborted, so destroy no longer waits for the full heartbeat interval.
+
+#### Modified
+- Drop `delay` from event engine dependencies and client setup, as heartbeat delay now uses `heartbeatDelay`.
+- Add tests for timer cancel on destroy, no heartbeats after destroy and heartbeat loop stop on zero interval.
+
 ## v13.1.1
 October 13 2026
 

README.md

@@ -29,8 +29,8 @@ Watch [Getting Started with PubNub JS SDK](https://app.dashcam.io/replay/64ee0d2
      npm install pubnub
      ```
    * or download one of our builds from our CDN: 
-     * https://cdn.pubnub.com/sdk/javascript/pubnub.13.1.1.js
-     * https://cdn.pubnub.com/sdk/javascript/pubnub.13.1.1.min.js
+     * https://cdn.pubnub.com/sdk/javascript/pubnub.13.1.2.js
+     * https://cdn.pubnub.com/sdk/javascript/pubnub.13.1.2.min.js
 
    > **React Native:** the SDK relies on a global `URL` implementation, which React Native does not
    > provide, so it depends on [`react-native-url-polyfill`](https://www.npmjs.com/package/react-native-url-polyfill).

dist/web/pubnub.js

@@ -5613,7 +5613,7 @@
 	            return base.PubNubFile;
 	        },
 	        get version() {
-	            return '13.1.1';
+	            return '13.1.2';
 	        },
 	        getVersion() {
 	            return this.version;
@@ -9203,8 +9203,11 @@
 	            }
 	        })));
 	        this.on(wait.type, asyncHandler((_1, abortSignal_1, _a) => __awaiter(this, [_1, abortSignal_1, _a], void 0, function* (_, abortSignal, { heartbeatDelay }) {
+	            const { cancelDelay, promise } = heartbeatDelay();
 	            abortSignal.throwIfAborted();
-	            yield heartbeatDelay();
+	            const unsubscribeAbortListener = abortSignal.subscribe(() => cancelDelay());
+	            yield promise;
+	            unsubscribeAbortListener();
 	            abortSignal.throwIfAborted();
 	            return engine.transition(timesUp());
 	        })));
@@ -18607,13 +18610,24 @@
 	                                    }));
 	                                    this.makeUnsubscribe(parameters, () => { });
 	                                },
-	                                heartbeatDelay: () => new Promise((resolve, reject) => {
-	                                    heartbeatInterval = this._configuration.getHeartbeatInterval();
-	                                    if (!heartbeatInterval)
-	                                        reject(new PubNubError('Heartbeat interval has been reset.'));
-	                                    else
-	                                        setTimeout(resolve, heartbeatInterval * 1000);
-	                                }),
+	                                heartbeatDelay: () => {
+	                                    let cancelDelay = () => { };
+	                                    const promise = new Promise((resolve, reject) => {
+	                                        heartbeatInterval = this._configuration.getHeartbeatInterval();
+	                                        if (!heartbeatInterval)
+	                                            reject(new PubNubError('Heartbeat interval has been reset.'));
+	                                        else {
+	                                            const timeoutId = setTimeout(() => {
+	                                                resolve();
+	                                            }, heartbeatInterval * 1000);
+	                                            cancelDelay = () => {
+	                                                clearTimeout(timeoutId);
+	                                                reject(new PubNubError('Heartbeat interval has been cancelled.'));
+	                                            };
+	                                        }
+	                                    });
+	                                    return { cancelDelay, promise };
+	                                },
 	                                emitStatus: (status) => this.emitStatus(status),
 	                                config: this._configuration,
 	                                presenceState: this.presenceState,
@@ -18639,7 +18653,6 @@
 	                            }));
 	                            return this.subscribeReceiveMessages(parameters);
 	                        },
-	                        delay: (amount) => new Promise((resolve) => setTimeout(resolve, amount)),
 	                        join: (parameters) => {
 	                            var _a, _b;
 	                            this.logger.trace('EventEngine', () => ({

lib/core/components/configuration.js

@@ -174,7 +174,7 @@ const makeConfiguration = (base, setupCryptoModule) => {
             return base.PubNubFile;
         },
         get version() {
-            return '13.1.1';
+            return '13.1.2';
         },
         getVersion() {
             return this.version;

lib/core/pubnub-common.js

@@ -244,13 +244,24 @@ class PubNubCore {
                                     }));
                                     this.makeUnsubscribe(parameters, () => { });
                                 },
-                                heartbeatDelay: () => new Promise((resolve, reject) => {
-                                    heartbeatInterval = this._configuration.getHeartbeatInterval();
-                                    if (!heartbeatInterval)
-                                        reject(new pubnub_error_1.PubNubError('Heartbeat interval has been reset.'));
-                                    else
-                                        setTimeout(resolve, heartbeatInterval * 1000);
-                                }),
+                                heartbeatDelay: () => {
+                                    let cancelDelay = () => { };
+                                    const promise = new Promise((resolve, reject) => {
+                                        heartbeatInterval = this._configuration.getHeartbeatInterval();
+                                        if (!heartbeatInterval)
+                                            reject(new pubnub_error_1.PubNubError('Heartbeat interval has been reset.'));
+                                        else {
+                                            const timeoutId = setTimeout(() => {
+                                                resolve();
+                                            }, heartbeatInterval * 1000);
+                                            cancelDelay = () => {
+                                                clearTimeout(timeoutId);
+                                                reject(new pubnub_error_1.PubNubError('Heartbeat interval has been cancelled.'));
+                                            };
+                                        }
+                                    });
+                                    return { cancelDelay, promise };
+                                },
                                 emitStatus: (status) => this.emitStatus(status),
                                 config: this._configuration,
                                 presenceState: this.presenceState,
@@ -276,7 +287,6 @@ class PubNubCore {
                             }));
                             return this.subscribeReceiveMessages(parameters);
                         },
-                        delay: (amount) => new Promise((resolve) => setTimeout(resolve, amount)),
                         join: (parameters) => {
                             var _a, _b;
                             this.logger.trace('EventEngine', () => ({

lib/event-engine/presence/dispatcher.js

@@ -93,8 +93,11 @@ class PresenceEventEngineDispatcher extends core_1.Dispatcher {
             }
         })));
         this.on(effects.wait.type, (0, core_1.asyncHandler)((_1, abortSignal_1, _a) => __awaiter(this, [_1, abortSignal_1, _a], void 0, function* (_, abortSignal, { heartbeatDelay }) {
+            const { cancelDelay, promise } = heartbeatDelay();
             abortSignal.throwIfAborted();
-            yield heartbeatDelay();
+            const unsubscribeAbortListener = abortSignal.subscribe(() => cancelDelay());
+            yield promise;
+            unsubscribeAbortListener();
             abortSignal.throwIfAborted();
             return engine.transition(events.timesUp());
         })));

package.json

@@ -1,6 +1,6 @@
 {
   "name": "pubnub",
-  "version": "13.1.1",
+  "version": "13.1.2",
   "author": "PubNub <support@pubnub.com>",
   "description": "PubNub SDK for JavaScript. Publish/subscribe messaging over HTTP long-poll with server-assigned message ordering, channel occupancy via Here Now, and message history through Message Persistence.",
   "scripts": {

src/core/components/configuration.ts

@@ -245,7 +245,7 @@ export const makeConfiguration = (
       return base.PubNubFile;
     },
     get version(): string {
-      return '13.1.1';
+      return '13.1.2';
     },
     getVersion(): string {
       return this.version;

src/core/pubnub-common.ts

@@ -495,12 +495,24 @@ export class PubNubCore<
 
                   this.makeUnsubscribe(parameters, () => {});
                 },
-                heartbeatDelay: () =>
-                  new Promise((resolve, reject) => {
+                heartbeatDelay: () => {
+                  let cancelDelay = () => {};
+                  const promise = new Promise<void>((resolve, reject) => {
                     heartbeatInterval = this._configuration.getHeartbeatInterval();
                     if (!heartbeatInterval) reject(new PubNubError('Heartbeat interval has been reset.'));
-                    else setTimeout(resolve, heartbeatInterval * 1000);
-                  }),
+                    else {
+                      const timeoutId = setTimeout(() => {
+                        resolve();
+                      }, heartbeatInterval * 1000);
+
+                      cancelDelay = () => {
+                        clearTimeout(timeoutId);
+                        reject(new PubNubError('Heartbeat interval has been cancelled.'));
+                      };
+                    }
+                  });
+                  return { cancelDelay, promise };
+                },
                 emitStatus: (status) => this.emitStatus(status),
                 config: this._configuration,
                 presenceState: this.presenceState,
@@ -529,7 +541,6 @@ export class PubNubCore<
 
               return this.subscribeReceiveMessages(parameters);
             },
-            delay: (amount) => new Promise((resolve) => setTimeout(resolve, amount)),
             join: (parameters) => {
               this.logger.trace('EventEngine', () => ({
                 messageType: 'object',

src/event-engine/dispatcher.ts

@@ -31,8 +31,6 @@ export type Dependencies = {
   presenceState: Record<string, Payload>;
   config: PrivateClientConfiguration;
 
-  delay: (milliseconds: number) => Promise<void>;
-
   emitMessages: (
     cursor: Subscription.SubscriptionCursor,
     events: Subscription.SubscriptionResponse['messages'],

src/event-engine/presence/dispatcher.ts

@@ -25,7 +25,7 @@ export type Dependencies = {
     callback?: ResultCallback<Presence.PresenceHeartbeatResponse>,
   ) => Promise<Presence.PresenceHeartbeatResponse | void>;
   leave: (parameters: Presence.PresenceLeaveParameters) => void;
-  heartbeatDelay: () => Promise<void>;
+  heartbeatDelay: () => { cancelDelay: () => void; promise: Promise<void> };
 
   config: PrivateClientConfiguration;
   presenceState: Record<string, Payload>;
@@ -85,9 +85,13 @@ export class PresenceEventEngineDispatcher extends Dispatcher<effects.Effects, D
     this.on(
       effects.wait.type,
       asyncHandler(async (_, abortSignal, { heartbeatDelay }) => {
+        const { cancelDelay, promise } = heartbeatDelay();
         abortSignal.throwIfAborted();
-        await heartbeatDelay();
+        const unsubscribeAbortListener = abortSignal.subscribe(() => cancelDelay());
 
+        await promise;
+
+        unsubscribeAbortListener();
         abortSignal.throwIfAborted();
 
         return engine.transition(events.timesUp());

test/unit/event_engine_presence.test.ts

@@ -514,4 +514,100 @@ describe('EventEngine', () => {
     expect(presenceEngine?.channels).to.deep.equal([]);
     expect(presenceEngine?.groups).to.deep.equal([]);
   });
+
+  describe('heartbeat delay timer', () => {
+    const sleep = (ms: number) => new Promise<void>((resolve) => setTimeout(resolve, ms));
+
+    it('should cancel the pending heartbeat delay timer when destroyed', async () => {
+      utils
+        .createNock()
+        .get('/v2/presence/sub-key/demo/channel/test/heartbeat')
+        .query(true)
+        .reply(200, '{"message":"OK", "service":"Presence"}', { 'content-type': 'text/javascript' })
+        .persist();
+
+      // Unique delay identifies the heartbeat delay timer among other timers.
+      const heartbeatDelay = 7000;
+      pubnub.setHeartbeatInterval(heartbeatDelay / 1000);
+
+      const { setTimeout: scheduleTimeout, clearTimeout: cancelTimeout } = global;
+      const delayTimers: unknown[] = [];
+      const cancelledTimers = new Set<unknown>();
+      global.setTimeout = ((callback: () => void, delay?: number, ...args: unknown[]) => {
+        const timer = scheduleTimeout(callback, delay, ...args);
+        if (delay === heartbeatDelay) delayTimers.push(timer);
+        return timer;
+      }) as typeof setTimeout;
+      global.clearTimeout = ((timer: unknown) => {
+        cancelledTimers.add(timer);
+        cancelTimeout(timer as NodeJS.Timeout);
+      }) as typeof clearTimeout;
+
+      try {
+        // @ts-expect-error Intentional access to the private interface.
+        pubnub.join({ channels: ['test'] });
+
+        await forState('HEARTBEAT_COOLDOWN', 1000);
+        expect(delayTimers).to.have.lengthOf(1);
+
+        pubnub.destroy(true);
+        // Cancellation is dispatched asynchronously (`AbortSignal` notifies listeners on the next tick).
+        await sleep(50);
+
+        expect(cancelledTimers.has(delayTimers[0])).to.equal(true);
+      } finally {
+        global.setTimeout = scheduleTimeout;
+        global.clearTimeout = cancelTimeout;
+      }
+    });
+
+    it('should not send heartbeats after destroy', async () => {
+      let heartbeats = 0;
+      utils
+        .createNock()
+        .get('/v2/presence/sub-key/demo/channel/test/heartbeat')
+        .query(true)
+        .reply(() => {
+          heartbeats++;
+          return [200, '{"message":"OK", "service":"Presence"}', { 'content-type': 'text/javascript' }];
+        })
+        .persist();
+
+      // @ts-expect-error Intentional access to the private interface.
+      pubnub.join({ channels: ['test'] });
+
+      await forState('HEARTBEAT_COOLDOWN', 1000);
+      pubnub.destroy(true);
+      const heartbeatsAtDestroy = heartbeats;
+
+      await sleep(1500);
+
+      expect(heartbeats).to.equal(heartbeatsAtDestroy);
+    });
+
+    it('should stop the heartbeat loop when heartbeat interval is reset to zero', async () => {
+      let heartbeats = 0;
+      utils
+        .createNock()
+        .get('/v2/presence/sub-key/demo/channel/test/heartbeat')
+        .query(true)
+        .reply(() => {
+          heartbeats++;
+          return [200, '{"message":"OK", "service":"Presence"}', { 'content-type': 'text/javascript' }];
+        })
+        .persist();
+
+      // @ts-expect-error Intentional access to the private interface.
+      pubnub.join({ channels: ['test'] });
+
+      await forState('HEARTBEAT_COOLDOWN', 1000);
+      pubnub.setHeartbeatInterval(0);
+      const heartbeatsAtReset = heartbeats;
+
+      // At most one heartbeat already scheduled with the previous interval is expected after the reset.
+      await sleep(2500);
+
+      expect(heartbeats - heartbeatsAtReset).to.be.at.most(1);
+    });
+  });
 });