node-firebird 2.17.1 → 2.18.0

package/README.md

@@ -182,6 +182,7 @@ var options = {};
 
 options.host = '127.0.0.1';
 options.eventHost = undefined; // optional; override the server-advertised host for the auxiliary event connection
+options.eventBaseline = false; // optional; emit the first event counter snapshot as 'baseline' instead of 'post_event'
 options.port = 3050;
 options.database = 'database.fdb';
 options.user = 'SYSDBA';
@@ -1396,6 +1397,19 @@ Firebird database events are **asynchronous** notifications triggered by `POST_E
 triggers or stored procedures. They travel over a separate "aux" connection (opened via
 `db.attachEvent()`) and are managed through a `FbEventManager` instance.
 
+By default, the first event notification after registration follows the existing
+`post_event` behavior. Set `options.eventBaseline = true` to emit that initial
+counter snapshot as `baseline` instead, without a `post_event` for that packet.
+Each register/unregister reconfiguration starts a new baseline. A `baseline`
+listener receives a snapshot of the currently registered event counters; install
+it, and any `post_event` listener, **before** calling `registerEvent()` because
+the auxiliary packet can arrive before the registration callback. A real event
+committed during registration can be included in that first snapshot, so an
+application using this option should query its current database state on
+`baseline` rather than assume every individual change will generate a later
+`post_event`. The default remains unchanged for applications that use the first
+`post_event` as a startup refresh signal.
+
 ```js
 Firebird.attach(options, function (err, db) {
   if (err) throw err;
@@ -1410,16 +1424,20 @@ Firebird.attach(options, function (err, db) {
       console.error('event connection failed:', err);
     });
 
+    // With options.eventBaseline = true, initialize from the current DB state.
+    // evtmgr.on('baseline', function (counts) { refreshFromDatabase(); });
+
+    evtmgr.on('post_event', function (name, count) {
+      // name  === event name string (e.g. 'MY_EVENT')
+      // count === cumulative trigger count since last notification
+    });
+
     // 2. Subscribe to one or more named events (names must match POST_EVENT('name') in your
     //    PSQL triggers/procedures). Resolves once op_que_events is acknowledged by the server.
     evtmgr.registerEvent(['MY_EVENT'], function (err) {
       if (err) throw err;
 
-      // 3. Listen for POST_EVENT notifications
-      evtmgr.on('post_event', function (name, count) {
-        // name  === event name string (e.g. 'MY_EVENT')
-        // count === cumulative trigger count since last notification
-      });
+      // 3. Subscription acknowledged. Notifications may already have arrived.
     });
 
     // 4. Unsubscribe from one or more events. Passing all currently registered names cancels

package/lib/types.d.ts

@@ -22,8 +22,10 @@ export interface FbEventManager extends EventEmitter {
     unregisterEvent(events: string[], callback: SimpleCallback): void;
     close(callback?: SimpleCallback): void;
     getState(): FbEventState;
+    on(event: 'baseline', listener: (counts: Readonly<Record<string, number>>) => void): this;
     on(event: 'post_event', listener: (name: string, count: number) => void): this;
     on(event: 'error', listener: (error: Error) => void): this;
+    once(event: 'baseline', listener: (counts: Readonly<Record<string, number>>) => void): this;
     once(event: 'post_event', listener: (name: string, count: number) => void): this;
     once(event: 'error', listener: (error: Error) => void): this;
 }
@@ -376,6 +378,8 @@ export interface Options {
     host?: string;
     /** Override the server-advertised auxiliary event host (for NAT, tunnels and load balancers). */
     eventHost?: string;
+    /** Emit the first counter snapshot of each event subscription as 'baseline' instead of 'post_event'. Off by default. */
+    eventBaseline?: boolean;
     port?: number;
     database?: string;
     user?: string;

package/lib/uri.js

@@ -15,7 +15,7 @@ exports.normalizeOptions = normalizeOptions;
  */
 const BOOLEAN_KEYS = new Set([
     'lowercase_keys', 'blobAsText', 'wireCompression', 'manager',
-    'namedPlaceholders', 'enableKeepAlive',
+    'namedPlaceholders', 'enableKeepAlive', 'eventBaseline',
 ]);
 /** Option keys coerced to number when they arrive as URI query parameters. */
 const NUMBER_KEYS = new Set([

package/lib/wire/eventConnection.js

@@ -119,17 +119,19 @@ class EventConnection {
                             }
                             xdr.readInt64(); // ignore AST INFO
                             var event_id = xdr.readInt();
-                            // set the new count in global event hash
-                            // Only update events that are still registered; do not
-                            // re-add events that unregisterEvent() has deleted, since
-                            // that would cause subscribe() to re-subscribe for them.
-                            for (var evt in tmp_event) {
-                                if (Object.prototype.hasOwnProperty.call(self.emgr.events, evt)) {
-                                    self.emgr.events[evt] = tmp_event[evt];
+                            // In the default mode, retain the existing parser-side
+                            // counter update. Baseline mode lets the manager apply
+                            // counts only after rejecting cancelled subscriptions.
+                            // Never re-add an event removed by unregisterEvent().
+                            if (!self.emgr._eventBaseline) {
+                                for (var evt in tmp_event) {
+                                    if (Object.prototype.hasOwnProperty.call(self.emgr.events, evt)) {
+                                        self.emgr.events[evt] = tmp_event[evt];
+                                    }
                                 }
                             }
                             if (self.eventcallback)
-                                self.eventcallback(null, { eventid: event_id, events: lst_event });
+                                self.eventcallback(null, { eventid: event_id, events: lst_event, counts: tmp_event });
                             break;
                         default:
                             reportTerminalError(new Error('Unexpected event connection opcode: ' + r));

package/lib/wire/fbEventManager.d.ts

@@ -5,13 +5,24 @@ declare class FbEventManager extends Events.EventEmitter {
     events: Record<string, number>;
     eventid: number;
     _subscriptionVersion: number;
+    _activeSubscriptionVersion: number;
     _hasActiveSubscription: boolean;
+    _baselinePending: boolean;
+    _eventBaseline: boolean;
+    _baselineChangeInProgress: boolean;
+    _baselineCallbacks: Array<(err: any, ret?: any) => void>;
+    _hasQueuedBaseline: boolean;
+    _retiredEventIdLimit: number;
+    _baselineCloseRequested: boolean;
+    _baselineCloseCallbacks: Array<(err?: any) => void>;
     _readySettled: boolean;
     _terminalErrorReported: boolean;
     _readyCallback: (err: any, ret?: any) => void;
     constructor(db: any, eventconnection: any, eventid: number, callback: (err: any, ret?: any) => void);
+    on(event: 'baseline', listener: (counts: Readonly<Record<string, number>>) => void): this;
     on(event: 'post_event', listener: (name: string, count: number) => void): this;
     on(event: 'error', listener: (error: Error) => void): this;
+    once(event: 'baseline', listener: (counts: Readonly<Record<string, number>>) => void): this;
     once(event: 'post_event', listener: (name: string, count: number) => void): this;
     once(event: 'error', listener: (error: Error) => void): this;
     _finishReady(err?: Error): void;
@@ -47,6 +58,8 @@ declare class FbEventManager extends Events.EventEmitter {
     };
     _createEventLoop(): void;
     _changeEvent(callback: (err: any, ret?: any) => void): void;
+    _isRetiredEventId(eventId: number): boolean;
+    _changeEventWithBaseline(callback: (err: any, ret?: any) => void): void;
     registerEvent(events: string[], callback: (err: any, ret?: any) => void): any;
     unregisterEvent(events: string[], callback: (err: any, ret?: any) => void): any;
     close(callback?: (err?: any) => void): void;

package/lib/wire/fbEventManager.js

@@ -47,7 +47,8 @@
 //       │  │ IDLE  (or CLOSING if called from close())        │
 //       │  └──────────────────────────────────────────────────┘
 //       │
-//       │ emit('post_event', name, count)
+//       │ eventBaseline: first op_event → emit('baseline', counts)
+//       │ otherwise → emit('post_event', name, count)
 //       └──────────────────────┐
 //                              ▼
 //                  loop() → SUBSCRIBING (re-subscribe)
@@ -80,10 +81,23 @@ class FbEventManager extends events_1.default.EventEmitter {
         // Guards _hasActiveSubscription against late callbacks from an older
         // register/unregister cycle after a newer subscription change started.
         this._subscriptionVersion = 0;
+        this._activeSubscriptionVersion = 0;
         // True when an op_que_events subscription is currently active on the
         // main connection (so close() and _changeEvent know whether to send
         // op_cancel_events before tearing down or re-subscribing).
         this._hasActiveSubscription = false;
+        this._baselinePending = false;
+        this._eventBaseline = db.connection.options?.eventBaseline === true;
+        this._baselineChangeInProgress = false;
+        this._baselineCallbacks = [];
+        this._hasQueuedBaseline = false;
+        // Highest event ID retired by a baseline reconfiguration. IDs come
+        // from db.eventid++ and the current one is always retired before a
+        // new one is allocated, so every ID <= this value is stale. A single
+        // watermark avoids keeping one entry per reconfiguration forever.
+        this._retiredEventIdLimit = 0;
+        this._baselineCloseRequested = false;
+        this._baselineCloseCallbacks = [];
         this._readySettled = false;
         this._terminalErrorReported = false;
         this._readyCallback = callback;
@@ -111,6 +125,7 @@ class FbEventManager extends events_1.default.EventEmitter {
         this._terminalErrorReported = true;
         const error = err instanceof Error ? err : new Error(String(err));
         this._hasActiveSubscription = false;
+        this._baselinePending = false;
         this._subscriptionVersion++;
         this.eventconnection._isClosed = true;
         this.eventconnection._isOpened = false;
@@ -196,11 +211,13 @@ class FbEventManager extends events_1.default.EventEmitter {
             // op_event arriving on the event connection after closeEvents can
             // trigger queEvents({}) which Firebird never acknowledges,
             // permanently blocking the main connection queue.
-            if (!self._hasActiveSubscription || Object.keys(self.events).length === 0) {
+            if (!self._hasActiveSubscription || Object.keys(self.events).length === 0 ||
+                (self._eventBaseline && self._activeSubscriptionVersion !== self._subscriptionVersion)) {
                 return;
             }
-            cnx.queEvents(self.events, self.eventid, function (err) {
-                if (err) {
+            const eventId = self.eventid;
+            cnx.queEvents(self.events, eventId, function (err) {
+                if (err && (!self._eventBaseline || !self._isRetiredEventId(eventId))) {
                     self._handleAsyncError(err);
                     return;
                 }
@@ -208,17 +225,48 @@ class FbEventManager extends events_1.default.EventEmitter {
             });
         }
         this.eventconnection.eventcallback = function (err, ret) {
-            if (err || !ret || (self.eventid !== ret.eventid)) {
-                self._handleAsyncError(err || new Error('Bad eventid'));
+            if (err || !ret) {
+                self._handleAsyncError(err || new Error('Missing event packet'));
                 return;
             }
-            ret.events.forEach(function (event) {
-                self.emit('post_event', event.name, event.count);
-            });
+            if (self.eventid !== ret.eventid) {
+                if (self._eventBaseline && self._isRetiredEventId(ret.eventid))
+                    return;
+                self._handleAsyncError(new Error('Bad eventid'));
+                return;
+            }
+            if (self._eventBaseline &&
+                (self._baselineCloseRequested || !self._hasActiveSubscription ||
+                    self._activeSubscriptionVersion !== self._subscriptionVersion ||
+                    Object.keys(ret.counts).some(name => !Object.prototype.hasOwnProperty.call(self.events, name)))) {
+                // Ignore a packet from a cancelled subscription (including
+                // one carrying an event that has since been unregistered).
+                return;
+            }
+            if (self._eventBaseline) {
+                for (const [name, count] of Object.entries(ret.counts)) {
+                    self.events[name] = count;
+                }
+            }
+            if (self._eventBaseline && self._baselinePending && self._hasActiveSubscription) {
+                self._baselinePending = false;
+                // Give callers their own snapshot, never the mutable
+                // subscription object.
+                self.emit('baseline', Object.freeze({ ...self.events }));
+            }
+            else {
+                ret.events.forEach(function (event) {
+                    self.emit('post_event', event.name, event.count);
+                });
+            }
             loop();
         };
     }
     _changeEvent(callback) {
+        if (this._eventBaseline) {
+            this._changeEventWithBaseline(callback);
+            return;
+        }
         var self = this;
         const changeVersion = ++self._subscriptionVersion;
         function subscribe() {
@@ -228,6 +276,7 @@ class FbEventManager extends events_1.default.EventEmitter {
             // permanently block the main connection queue.
             if (Object.keys(self.events).length === 0) {
                 self._hasActiveSubscription = false;
+                self._baselinePending = false;
                 callback(null);
                 return;
             }
@@ -240,6 +289,7 @@ class FbEventManager extends events_1.default.EventEmitter {
                 if (err) {
                     if (self._subscriptionVersion === changeVersion) {
                         self._hasActiveSubscription = false;
+                        self._baselinePending = false;
                     }
                     (0, callback_1.doError)(err, callback);
                     return;
@@ -264,22 +314,113 @@ class FbEventManager extends events_1.default.EventEmitter {
             subscribe();
         }
     }
+    _isRetiredEventId(eventId) {
+        return eventId <= this._retiredEventIdLimit;
+    }
+    _changeEventWithBaseline(callback) {
+        const cnx = this.db.connection;
+        this._subscriptionVersion++;
+        this._baselineCallbacks.push(callback);
+        if (this._baselineChangeInProgress)
+            return;
+        this._baselineChangeInProgress = true;
+        const finish = (err, ret) => {
+            this._baselineChangeInProgress = false;
+            if (this._baselineCloseRequested && !err)
+                err = new Error('Event Connection is closed.');
+            const callbacks = this._baselineCallbacks.splice(0);
+            for (const done of callbacks) {
+                if (err)
+                    (0, callback_1.doError)(err, done);
+                else
+                    done(null, ret);
+            }
+            if (this._baselineCloseRequested) {
+                this._baselineCloseRequested = false;
+                const closeCallbacks = this._baselineCloseCallbacks.splice(0);
+                this.close(closeError => {
+                    for (const done of closeCallbacks)
+                        done(closeError);
+                });
+            }
+        };
+        const subscribe = () => {
+            if (this._baselineCloseRequested) {
+                finish(new Error('Event Connection is closed.'));
+                return;
+            }
+            if (Object.keys(this.events).length === 0) {
+                this._hasActiveSubscription = false;
+                this._baselinePending = false;
+                finish(null);
+                return;
+            }
+            // p_event_rid is client-generated. A fresh ID makes a delayed
+            // notification from an older generation distinguishable even
+            // when both generations contain the same event name.
+            if (this._hasQueuedBaseline)
+                this.eventid = this.db.eventid++;
+            this._hasQueuedBaseline = true;
+            const version = this._subscriptionVersion;
+            this._activeSubscriptionVersion = version;
+            for (const name of Object.keys(this.events))
+                this.events[name] = 0;
+            this._baselinePending = true;
+            this._hasActiveSubscription = true;
+            cnx.queEvents(this.events, this.eventid, (err, ret) => {
+                if (err) {
+                    this._hasActiveSubscription = false;
+                    this._baselinePending = false;
+                    finish(err);
+                }
+                else if (version !== this._subscriptionVersion) {
+                    cycle();
+                }
+                else {
+                    finish(null, ret);
+                }
+            });
+        };
+        const cycle = () => {
+            if (!this._hasActiveSubscription) {
+                subscribe();
+                return;
+            }
+            const oldId = this.eventid;
+            this._hasActiveSubscription = false;
+            this._baselinePending = false;
+            this._retiredEventIdLimit = Math.max(this._retiredEventIdLimit, oldId);
+            cnx.closeEvents(oldId, (err) => {
+                if (err)
+                    finish(err);
+                else
+                    subscribe();
+            });
+        };
+        cycle();
+    }
     registerEvent(events, callback) {
         var self = this;
-        if (self.db.connection._isClosed || self.eventconnection._isClosed)
+        if (self.db.connection._isClosed || self.eventconnection._isClosed || self._baselineCloseRequested)
             return self.eventconnection.throwClosed(callback);
         events.forEach((event) => self.events[event] = self.events[event] || 0);
         self._changeEvent(callback);
     }
     unregisterEvent(events, callback) {
         var self = this;
-        if (self.db.connection._isClosed || self.eventconnection._isClosed)
+        if (self.db.connection._isClosed || self.eventconnection._isClosed || self._baselineCloseRequested)
             return self.eventconnection.throwClosed(callback);
         events.forEach(function (event) { delete self.events[event]; });
         self._changeEvent(callback);
     }
     close(callback) {
         var self = this;
+        if (self._eventBaseline && self._baselineChangeInProgress) {
+            self._baselineCloseRequested = true;
+            if (callback)
+                self._baselineCloseCallbacks.push(callback);
+            return;
+        }
         if (process.env.FIREBIRD_DEBUG) {
             console.log('[fb-debug] FbEventManager.close() called, _hasActiveSubscription=%s eventid=%d', self._hasActiveSubscription, self.eventid);
         }
@@ -287,6 +428,7 @@ class FbEventManager extends events_1.default.EventEmitter {
         // that may arrive between closeEvents and socket.end()
         self.eventconnection._intentionalClose = true;
         self.eventconnection.eventcallback = null;
+        self._baselinePending = false;
         // Gracefully close the event socket using a FIN (end()) rather than a RST
         // (destroy()), then wait for the 'close' event which confirms both sides have
         // exchanged FINs.  This gives Firebird (all versions 3/4/5) time to fully

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "node-firebird",
-    "version": "2.17.1",
+    "version": "2.18.0",
     "description": "Pure JavaScript and Asynchronous Firebird client for Node.js.",
     "keywords": [
         "firebird",

package/src/types.ts

@@ -33,8 +33,10 @@ export interface FbEventManager extends EventEmitter {
     unregisterEvent(events: string[], callback: SimpleCallback): void;
     close(callback?: SimpleCallback): void;
     getState(): FbEventState;
+    on(event: 'baseline', listener: (counts: Readonly<Record<string, number>>) => void): this;
     on(event: 'post_event', listener: (name: string, count: number) => void): this;
     on(event: 'error', listener: (error: Error) => void): this;
+    once(event: 'baseline', listener: (counts: Readonly<Record<string, number>>) => void): this;
     once(event: 'post_event', listener: (name: string, count: number) => void): this;
     once(event: 'error', listener: (error: Error) => void): this;
 }
@@ -440,6 +442,8 @@ export interface Options {
     host?: string;
     /** Override the server-advertised auxiliary event host (for NAT, tunnels and load balancers). */
     eventHost?: string;
+    /** Emit the first counter snapshot of each event subscription as 'baseline' instead of 'post_event'. Off by default. */
+    eventBaseline?: boolean;
     port?: number;
     database?: string;
     user?: string;

package/src/uri.ts

@@ -12,7 +12,7 @@ import type { Options } from './types';
  */
 const BOOLEAN_KEYS = new Set([
     'lowercase_keys', 'blobAsText', 'wireCompression', 'manager',
-    'namedPlaceholders', 'enableKeepAlive',
+    'namedPlaceholders', 'enableKeepAlive', 'eventBaseline',
 ]);
 
 /** Option keys coerced to number when they arrive as URI query parameters. */

package/src/wire/eventConnection.ts

@@ -134,17 +134,19 @@ class EventConnection {
                             }
                             xdr.readInt64(); // ignore AST INFO
                             var event_id = xdr.readInt();
-                            // set the new count in global event hash
-                            // Only update events that are still registered; do not
-                            // re-add events that unregisterEvent() has deleted, since
-                            // that would cause subscribe() to re-subscribe for them.
-                            for (var evt in tmp_event) {
-                                if (Object.prototype.hasOwnProperty.call(self.emgr.events, evt)) {
-                                    self.emgr.events[evt] = tmp_event[evt];
+                            // In the default mode, retain the existing parser-side
+                            // counter update. Baseline mode lets the manager apply
+                            // counts only after rejecting cancelled subscriptions.
+                            // Never re-add an event removed by unregisterEvent().
+                            if (!self.emgr._eventBaseline) {
+                                for (var evt in tmp_event) {
+                                    if (Object.prototype.hasOwnProperty.call(self.emgr.events, evt)) {
+                                        self.emgr.events[evt] = tmp_event[evt];
+                                    }
                                 }
                             }
                             if (self.eventcallback)
-                                self.eventcallback(null, { eventid: event_id, events: lst_event });
+                                self.eventcallback(null, { eventid: event_id, events: lst_event, counts: tmp_event });
                             break;
                         default:
                             reportTerminalError(new Error('Unexpected event connection opcode: ' + r));

package/src/wire/fbEventManager.ts

@@ -46,7 +46,8 @@
 //       │  │ IDLE  (or CLOSING if called from close())        │
 //       │  └──────────────────────────────────────────────────┘
 //       │
-//       │ emit('post_event', name, count)
+//       │ eventBaseline: first op_event → emit('baseline', counts)
+//       │ otherwise → emit('post_event', name, count)
 //       └──────────────────────┐
 //                              ▼
 //                  loop() → SUBSCRIBING (re-subscribe)
@@ -74,7 +75,16 @@ class FbEventManager extends Events.EventEmitter {
     events: Record<string, number>;
     eventid: number;
     _subscriptionVersion: number;
+    _activeSubscriptionVersion: number;
     _hasActiveSubscription: boolean;
+    _baselinePending: boolean;
+    _eventBaseline: boolean;
+    _baselineChangeInProgress: boolean;
+    _baselineCallbacks: Array<(err: any, ret?: any) => void>;
+    _hasQueuedBaseline: boolean;
+    _retiredEventIdLimit: number;
+    _baselineCloseRequested: boolean;
+    _baselineCloseCallbacks: Array<(err?: any) => void>;
     _readySettled: boolean;
     _terminalErrorReported: boolean;
     _readyCallback: (err: any, ret?: any) => void;
@@ -88,10 +98,23 @@ class FbEventManager extends Events.EventEmitter {
         // Guards _hasActiveSubscription against late callbacks from an older
         // register/unregister cycle after a newer subscription change started.
         this._subscriptionVersion = 0;
+        this._activeSubscriptionVersion = 0;
         // True when an op_que_events subscription is currently active on the
         // main connection (so close() and _changeEvent know whether to send
         // op_cancel_events before tearing down or re-subscribing).
         this._hasActiveSubscription = false;
+        this._baselinePending = false;
+        this._eventBaseline = db.connection.options?.eventBaseline === true;
+        this._baselineChangeInProgress = false;
+        this._baselineCallbacks = [];
+        this._hasQueuedBaseline = false;
+        // Highest event ID retired by a baseline reconfiguration. IDs come
+        // from db.eventid++ and the current one is always retired before a
+        // new one is allocated, so every ID <= this value is stale. A single
+        // watermark avoids keeping one entry per reconfiguration forever.
+        this._retiredEventIdLimit = 0;
+        this._baselineCloseRequested = false;
+        this._baselineCloseCallbacks = [];
         this._readySettled = false;
         this._terminalErrorReported = false;
         this._readyCallback = callback;
@@ -99,12 +122,14 @@ class FbEventManager extends Events.EventEmitter {
         process.nextTick(() => this._finishReady());
     }
 
+    on(event: 'baseline', listener: (counts: Readonly<Record<string, number>>) => void): this;
     on(event: 'post_event', listener: (name: string, count: number) => void): this;
     on(event: 'error', listener: (error: Error) => void): this;
     on(event: string | symbol, listener: (...args: any[]) => void): this {
         return super.on(event, listener);
     }
 
+    once(event: 'baseline', listener: (counts: Readonly<Record<string, number>>) => void): this;
     once(event: 'post_event', listener: (name: string, count: number) => void): this;
     once(event: 'error', listener: (error: Error) => void): this;
     once(event: string | symbol, listener: (...args: any[]) => void): this {
@@ -123,6 +148,7 @@ class FbEventManager extends Events.EventEmitter {
         this._terminalErrorReported = true;
         const error = err instanceof Error ? err : new Error(String(err));
         this._hasActiveSubscription = false;
+        this._baselinePending = false;
         this._subscriptionVersion++;
         this.eventconnection._isClosed = true;
         this.eventconnection._isOpened = false;
@@ -211,11 +237,13 @@ class FbEventManager extends Events.EventEmitter {
             // op_event arriving on the event connection after closeEvents can
             // trigger queEvents({}) which Firebird never acknowledges,
             // permanently blocking the main connection queue.
-            if (!self._hasActiveSubscription || Object.keys(self.events).length === 0) {
+            if (!self._hasActiveSubscription || Object.keys(self.events).length === 0 ||
+                (self._eventBaseline && self._activeSubscriptionVersion !== self._subscriptionVersion)) {
                 return;
             }
-            cnx.queEvents(self.events, self.eventid, function (err: any) {
-                if (err) {
+            const eventId = self.eventid;
+            cnx.queEvents(self.events, eventId, function (err: any) {
+                if (err && (!self._eventBaseline || !self._isRetiredEventId(eventId))) {
                     self._handleAsyncError(err);
                     return;
                 }
@@ -224,14 +252,42 @@ class FbEventManager extends Events.EventEmitter {
         }
 
         this.eventconnection.eventcallback = function (err: any, ret?: any) {
-            if (err || !ret || (self.eventid !== ret.eventid)) {
-                self._handleAsyncError(err || new Error('Bad eventid'));
+            if (err || !ret) {
+                self._handleAsyncError(err || new Error('Missing event packet'));
+                return;
+            }
+            if (self.eventid !== ret.eventid) {
+                if (self._eventBaseline && self._isRetiredEventId(ret.eventid)) return;
+                self._handleAsyncError(new Error('Bad eventid'));
                 return;
             }
 
-            ret.events.forEach(function (event: { name: string; count: number }) {
-                self.emit('post_event', event.name, event.count);
-            });
+            if (self._eventBaseline &&
+                (self._baselineCloseRequested || !self._hasActiveSubscription ||
+                self._activeSubscriptionVersion !== self._subscriptionVersion ||
+                Object.keys(ret.counts).some(name =>
+                    !Object.prototype.hasOwnProperty.call(self.events, name)))) {
+                // Ignore a packet from a cancelled subscription (including
+                // one carrying an event that has since been unregistered).
+                return;
+            }
+
+            if (self._eventBaseline) {
+                for (const [name, count] of Object.entries(ret.counts as Record<string, number>)) {
+                    self.events[name] = count;
+                }
+            }
+
+            if (self._eventBaseline && self._baselinePending && self._hasActiveSubscription) {
+                self._baselinePending = false;
+                // Give callers their own snapshot, never the mutable
+                // subscription object.
+                self.emit('baseline', Object.freeze({ ...self.events }));
+            } else {
+                ret.events.forEach(function (event: { name: string; count: number }) {
+                    self.emit('post_event', event.name, event.count);
+                });
+            }
 
             loop();
         };
@@ -239,6 +295,10 @@ class FbEventManager extends Events.EventEmitter {
     }
 
     _changeEvent(callback: (err: any, ret?: any) => void): void {
+        if (this._eventBaseline) {
+            this._changeEventWithBaseline(callback);
+            return;
+        }
         var self = this;
         const changeVersion = ++self._subscriptionVersion;
 
@@ -249,6 +309,7 @@ class FbEventManager extends Events.EventEmitter {
             // permanently block the main connection queue.
             if (Object.keys(self.events).length === 0) {
                 self._hasActiveSubscription = false;
+                self._baselinePending = false;
                 callback(null);
                 return;
             }
@@ -262,6 +323,7 @@ class FbEventManager extends Events.EventEmitter {
                 if (err) {
                     if (self._subscriptionVersion === changeVersion) {
                         self._hasActiveSubscription = false;
+                        self._baselinePending = false;
                     }
                     doError(err, callback);
                     return;
@@ -287,10 +349,91 @@ class FbEventManager extends Events.EventEmitter {
         }
     }
 
+    _isRetiredEventId(eventId: number): boolean {
+        return eventId <= this._retiredEventIdLimit;
+    }
+
+    _changeEventWithBaseline(callback: (err: any, ret?: any) => void): void {
+        const cnx = this.db.connection;
+        this._subscriptionVersion++;
+        this._baselineCallbacks.push(callback);
+        if (this._baselineChangeInProgress) return;
+        this._baselineChangeInProgress = true;
+
+        const finish = (err: any, ret?: any) => {
+            this._baselineChangeInProgress = false;
+            if (this._baselineCloseRequested && !err) err = new Error('Event Connection is closed.');
+            const callbacks = this._baselineCallbacks.splice(0);
+            for (const done of callbacks) {
+                if (err) doError(err, done);
+                else done(null, ret);
+            }
+            if (this._baselineCloseRequested) {
+                this._baselineCloseRequested = false;
+                const closeCallbacks = this._baselineCloseCallbacks.splice(0);
+                this.close(closeError => {
+                    for (const done of closeCallbacks) done(closeError);
+                });
+            }
+        };
+
+        const subscribe = () => {
+            if (this._baselineCloseRequested) {
+                finish(new Error('Event Connection is closed.'));
+                return;
+            }
+            if (Object.keys(this.events).length === 0) {
+                this._hasActiveSubscription = false;
+                this._baselinePending = false;
+                finish(null);
+                return;
+            }
+
+            // p_event_rid is client-generated. A fresh ID makes a delayed
+            // notification from an older generation distinguishable even
+            // when both generations contain the same event name.
+            if (this._hasQueuedBaseline) this.eventid = this.db.eventid++;
+            this._hasQueuedBaseline = true;
+            const version = this._subscriptionVersion;
+            this._activeSubscriptionVersion = version;
+            for (const name of Object.keys(this.events)) this.events[name] = 0;
+            this._baselinePending = true;
+            this._hasActiveSubscription = true;
+            cnx.queEvents(this.events, this.eventid, (err: any, ret?: any) => {
+                if (err) {
+                    this._hasActiveSubscription = false;
+                    this._baselinePending = false;
+                    finish(err);
+                } else if (version !== this._subscriptionVersion) {
+                    cycle();
+                } else {
+                    finish(null, ret);
+                }
+            });
+        };
+
+        const cycle = () => {
+            if (!this._hasActiveSubscription) {
+                subscribe();
+                return;
+            }
+            const oldId = this.eventid;
+            this._hasActiveSubscription = false;
+            this._baselinePending = false;
+            this._retiredEventIdLimit = Math.max(this._retiredEventIdLimit, oldId);
+            cnx.closeEvents(oldId, (err: any) => {
+                if (err) finish(err);
+                else subscribe();
+            });
+        };
+
+        cycle();
+    }
+
     registerEvent(events: string[], callback: (err: any, ret?: any) => void): any {
         var self = this;
 
-        if (self.db.connection._isClosed || self.eventconnection._isClosed)
+        if (self.db.connection._isClosed || self.eventconnection._isClosed || self._baselineCloseRequested)
             return self.eventconnection.throwClosed(callback);
 
         events.forEach((event) => self.events[event] = self.events[event] || 0);
@@ -300,7 +443,7 @@ class FbEventManager extends Events.EventEmitter {
     unregisterEvent(events: string[], callback: (err: any, ret?: any) => void): any {
         var self = this;
 
-        if (self.db.connection._isClosed || self.eventconnection._isClosed)
+        if (self.db.connection._isClosed || self.eventconnection._isClosed || self._baselineCloseRequested)
             return self.eventconnection.throwClosed(callback);
 
         events.forEach(function (event) { delete self.events[event] });
@@ -310,6 +453,12 @@ class FbEventManager extends Events.EventEmitter {
     close(callback?: (err?: any) => void): void {
         var self = this;
 
+        if (self._eventBaseline && self._baselineChangeInProgress) {
+            self._baselineCloseRequested = true;
+            if (callback) self._baselineCloseCallbacks.push(callback);
+            return;
+        }
+
         if (process.env.FIREBIRD_DEBUG) {
             console.log('[fb-debug] FbEventManager.close() called, _hasActiveSubscription=%s eventid=%d', self._hasActiveSubscription, self.eventid);
         }
@@ -318,6 +467,7 @@ class FbEventManager extends Events.EventEmitter {
         // that may arrive between closeEvents and socket.end()
         self.eventconnection._intentionalClose = true;
         self.eventconnection.eventcallback = null;
+        self._baselinePending = false;
 
         // Gracefully close the event socket using a FIN (end()) rather than a RST
         // (destroy()), then wait for the 'close' event which confirms both sides have