node-firebird 2.17.0 → 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;
@@ -1404,16 +1418,26 @@ Firebird.attach(options, function (err, db) {
   db.attachEvent(function (err, evtmgr) {
     if (err) throw err;
 
+    // Auxiliary socket/protocol failures after attachment are reported here.
+    // Install this listener before registering events.
+    evtmgr.on('error', function (err) {
+      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
@@ -1479,9 +1503,20 @@ db.attachEvent(function (err, evtmgr) {
 });
 ```
 
-Errors on the aux socket *after* it connects are not delivered to this callback. Poll
-`evtmgr.getState().isEventConnectionOpen` if you need to detect an aux connection that dies
-mid-subscription.
+Errors on the aux socket *after* it connects are delivered through the manager's `error`
+event. Install the listener before calling `registerEvent()`:
+
+```js
+evtmgr.on('error', function (err) {
+  // The manager is now CLOSED. Reattach explicitly if the application wants
+  // to resume event delivery; the driver does not reconnect automatically.
+  console.error('event connection failed:', err);
+});
+```
+
+When no manager error listener is installed, the driver forwards the failure to guarded
+database `error` listeners when present. It never emits an unhandled EventEmitter `error`.
+The primary database attachment remains available for ordinary queries.
 
 ### Escaping Query values
 

package/lib/types.d.ts

@@ -1,4 +1,5 @@
 import type { Readable, Writable } from 'stream';
+import type { EventEmitter } from 'events';
 import type { SqlTag } from './sql-template';
 export type { SqlTag, SqlQuery, SqlIdentifier, CompiledQuery } from './sql-template';
 export type DatabaseCallback = (err: any, db: Database) => void;
@@ -6,6 +7,29 @@ export type TransactionCallback = (err: any, transaction: Transaction) => void;
 export type QueryCallback = (err: any, result: any[]) => void;
 export type SimpleCallback = (err: any) => void;
 export type SequentialCallback = (row: any, index: number, next?: (err?: any) => void) => void | Promise<void>;
+export interface FbEventState {
+    state: 'IDLE' | 'SUBSCRIBED' | 'CLOSED';
+    hasActiveSubscription: boolean;
+    registeredEvents: Record<string, number>;
+    eventId: number;
+    isEventConnectionOpen: boolean;
+    isDatabaseConnectionClosed: boolean;
+}
+export interface FbEventManager extends EventEmitter {
+    readonly eventid: number;
+    readonly events: Record<string, number>;
+    registerEvent(events: string[], callback: SimpleCallback): void;
+    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;
+}
+export type FbEventManagerCallback = (err: any, manager?: FbEventManager) => void;
 /**
  * Describes a single column in a prepared statement's result set or
  * parameter list.  The properties here are populated by the
@@ -250,7 +274,7 @@ export interface Database {
     batchStream(query: string, options?: BatchStreamOptions): BatchStream;
     drop(callback: SimpleCallback): void;
     escape(value: any): string;
-    attachEvent(callback: any): this;
+    attachEvent(callback: FbEventManagerCallback): this;
     createTablespace(name: string, filePath: string, callback?: QueryCallback): Database;
     alterTablespace(name: string, filePath: string, callback?: QueryCallback): Database;
     dropTablespace(name: string, callback?: QueryCallback): Database;
@@ -271,7 +295,7 @@ export interface Database {
     newStatementAsync(query: string): Promise<Statement>;
     detachAsync(force?: boolean): Promise<void>;
     dropAsync(): Promise<void>;
-    attachEventAsync(): Promise<any>;
+    attachEventAsync(): Promise<FbEventManager>;
     /** Starts a transaction, commits when `work` resolves, rolls back when it rejects. */
     withTransaction<T>(work: (transaction: Transaction) => Promise<T> | T, options?: TransactionOptions | Isolation): Promise<T>;
     /**
@@ -354,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/database.js

@@ -390,6 +390,13 @@ class Database extends events_1.default.EventEmitter {
     attachEvent(callback) {
         var self = this;
         const eventid = self.eventid++;
+        let completed = false;
+        const complete = function (err, manager) {
+            if (completed)
+                return;
+            completed = true;
+            callback(err, manager);
+        };
         if (process.env.FIREBIRD_DEBUG) {
             console.log('[fb-debug] Database.attachEvent: calling auxConnection, eventid=%d queue=%d', eventid, self.connection._queue.length);
         }
@@ -398,7 +405,7 @@ class Database extends events_1.default.EventEmitter {
                 if (process.env.FIREBIRD_DEBUG) {
                     console.log('[fb-debug] Database.attachEvent: auxConnection error:', err.message);
                 }
-                (0, callback_1.doError)(err, callback);
+                (0, callback_1.doError)(err, complete);
                 return;
             }
             if (process.env.FIREBIRD_DEBUG) {
@@ -410,7 +417,7 @@ class Database extends events_1.default.EventEmitter {
                     if (process.env.FIREBIRD_DEBUG) {
                         console.log('[fb-debug] Database.attachEvent: EventConnection error:', err.message);
                     }
-                    (0, callback_1.doError)(err, callback);
+                    (0, callback_1.doError)(err, complete);
                     return;
                 }
                 if (process.env.FIREBIRD_DEBUG) {
@@ -418,13 +425,13 @@ class Database extends events_1.default.EventEmitter {
                 }
                 const evt = new fbEventManager_1.default(self, eventConnection, eventid, function (err) {
                     if (err) {
-                        (0, callback_1.doError)(err, callback);
+                        (0, callback_1.doError)(err, complete);
                         return;
                     }
                     if (process.env.FIREBIRD_DEBUG) {
                         console.log('[fb-debug] Database.attachEvent: FbEventManager ready, eventid=%d', evt.eventid);
                     }
-                    callback(err, evt);
+                    complete(err, evt);
                 });
             }, self);
         });

package/lib/wire/eventConnection.d.ts

@@ -10,6 +10,8 @@ declare class EventConnection {
     error: any;
     eventcallback: ((err: any, ret?: any) => void) | null;
     _connectSettled: boolean;
+    _terminalErrorReported: boolean;
+    _intentionalClose: boolean;
     constructor(host: string, port: number, callback: ((err?: Error) => void) | undefined, db: any);
     _bind_events(host: string, port: number, callback?: (err?: Error) => void): void;
     throwClosed(callback?: (err: any) => void): this;

package/lib/wire/eventConnection.js

@@ -14,6 +14,8 @@ class EventConnection {
         this._isClosed = false;
         this._isOpened = false;
         this._connectSettled = false;
+        this._terminalErrorReported = false;
+        this._intentionalClose = false;
         this._socket = net_1.default.createConnection(port, host);
         this._bind_events(host, port, callback);
         this.error = null;
@@ -28,19 +30,41 @@ class EventConnection {
             if (callback)
                 callback(err);
         }
+        function reportTerminalError(err) {
+            if (self._terminalErrorReported)
+                return;
+            self._terminalErrorReported = true;
+            const wasOpened = self._isOpened;
+            self.error = err;
+            self._isClosed = true;
+            self._isOpened = false;
+            // An error during a caller-initiated shutdown is part of tearing
+            // down the auxiliary socket, not a database error.
+            if (!self._intentionalClose && !wasOpened) {
+                finishConnect(err);
+            }
+            else if (!self._intentionalClose && self.eventcallback) {
+                self.eventcallback(err);
+            }
+            else if (!self._intentionalClose && self.db && self.db.connection &&
+                typeof self.db.connection._emitError === 'function') {
+                self.db.connection._emitError(err);
+            }
+            if (!self._socket.destroyed)
+                self._socket.destroy();
+        }
         self._socket.on('close', function () {
             self._isClosed = true;
             if (!self._isOpened) {
                 finishConnect(self.error || new Error(`Event connection to ${host}:${port} closed before connecting.`));
             }
+            else if (!self._intentionalClose && self.eventcallback && !self._terminalErrorReported) {
+                reportTerminalError(new Error(`Event connection to ${host}:${port} closed unexpectedly.`));
+            }
+            self._isOpened = false;
         });
         self._socket.on('error', function (e) {
-            self.error = e;
-            if (!self._isOpened) {
-                if (!self._socket.destroyed)
-                    self._socket.destroy();
-                finishConnect(e);
-            }
+            reportTerminalError(e);
         });
         self._socket.on('connect', function () {
             self._isClosed = false;
@@ -64,6 +88,7 @@ class EventConnection {
             try {
                 var tmp_event;
                 while (xdr.pos < xdr.buffer.length) {
+                    op_pos = xdr.pos;
                     do {
                         var r = xdr.readInt();
                     } while (r === const_1.default.op_dummy);
@@ -80,7 +105,9 @@ class EventConnection {
                             var eventcount = 0;
                             var pos = 1;
                             while (pos < buf.length) {
-                                var len = buf.readInt8(pos++);
+                                var len = buf.readUInt8(pos++);
+                                if (pos + len + 4 > buf.length)
+                                    throw new RangeError('Incomplete event payload');
                                 eventname = buf.toString(DEFAULT_ENCODING, pos, pos + len);
                                 var prevcount = self.emgr.events[eventname] || 0;
                                 pos += len;
@@ -92,20 +119,22 @@ 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:
-                            // Unknown opcode on the event connection – stop processing.
+                            reportTerminalError(new Error('Unexpected event connection opcode: ' + r));
                             return;
                     }
                 }
@@ -117,14 +146,13 @@ class EventConnection {
                     self._xdr = xdr;
                 }
                 else {
-                    throw err;
+                    reportTerminalError(err instanceof Error ? err : new Error(String(err)));
                 }
             }
         });
     }
     throwClosed(callback) {
         var err = new Error('Event Connection is closed.');
-        this.db.emit('error', err);
         if (callback)
             callback(err);
         return this;

package/lib/wire/fbEventManager.d.ts

@@ -5,8 +5,28 @@ 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;
+    _handleAsyncError(err: any): void;
     /**
      * Returns a snapshot of the current state for debugging.
      * Useful for tracing the state machine during development.
@@ -36,8 +56,10 @@ declare class FbEventManager extends Events.EventEmitter {
         isEventConnectionOpen: boolean;
         isDatabaseConnectionClosed: boolean;
     };
-    _createEventLoop(callback: (err: any, ret?: any) => void): void;
+    _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)
@@ -64,6 +65,7 @@
 // Asynchronous notifications on the AUX (EventConnection) socket
 // ───────────────────────────────────────────────────────────────
 //   Server → Client : op_event  (fired by Firebird POST_EVENT trigger)
+//   Error / unexpected close → CLOSED; emit manager 'error' once
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -79,11 +81,68 @@ 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._createEventLoop(callback);
+        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;
+        this._createEventLoop();
+        process.nextTick(() => this._finishReady());
+    }
+    on(event, listener) {
+        return super.on(event, listener);
+    }
+    once(event, listener) {
+        return super.once(event, listener);
+    }
+    _finishReady(err) {
+        if (this._readySettled)
+            return;
+        this._readySettled = true;
+        if (err)
+            (0, callback_1.doError)(err, this._readyCallback);
+        else
+            this._readyCallback(null);
+    }
+    _handleAsyncError(err) {
+        if (this._terminalErrorReported)
+            return;
+        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;
+        this.eventconnection.eventcallback = null;
+        if (this.eventconnection._socket && !this.eventconnection._socket.destroyed &&
+            typeof this.eventconnection._socket.destroy === 'function') {
+            this.eventconnection._socket.destroy();
+        }
+        if (!this._readySettled) {
+            this._finishReady(error);
+        }
+        else if (this.listenerCount('error') > 0) {
+            this.emit('error', error);
+        }
+        else if (this.db.connection && typeof this.db.connection._emitError === 'function') {
+            this.db.connection._emitError(error);
+        }
     }
     /**
      * Returns a snapshot of the current state for debugging.
@@ -136,7 +195,7 @@ class FbEventManager extends events_1.default.EventEmitter {
             isDatabaseConnectionClosed: dbConnClosed,
         };
     }
-    _createEventLoop(callback) {
+    _createEventLoop() {
         var self = this;
         var cnx = this.db.connection;
         this.eventconnection.emgr = this;
@@ -152,34 +211,62 @@ 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) {
-                    (0, callback_1.doError)(err, callback);
+            const eventId = self.eventid;
+            cnx.queEvents(self.events, eventId, function (err) {
+                if (err && (!self._eventBaseline || !self._isRetiredEventId(eventId))) {
+                    self._handleAsyncError(err);
                     return;
                 }
                 // subscription renewed, nothing else to do
             });
         }
         this.eventconnection.eventcallback = function (err, ret) {
-            if (err || (self.eventid !== ret.eventid)) {
-                (0, callback_1.doError)(err || new Error('Bad eventid'), callback);
+            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();
         };
-        // Resolve attachEvent on the next tick – no subscription is needed
-        // until the caller registers at least one event name via registerEvent().
-        // process.nextTick ensures the outer `const evt = new FbEventManager(...)`
-        // assignment in database.js completes before this callback fires.
-        process.nextTick(function () { callback(null); });
     }
     _changeEvent(callback) {
+        if (this._eventBaseline) {
+            this._changeEventWithBaseline(callback);
+            return;
+        }
         var self = this;
         const changeVersion = ++self._subscriptionVersion;
         function subscribe() {
@@ -189,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;
             }
@@ -201,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;
@@ -225,28 +314,121 @@ 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);
         }
         // Prevent the event loop from re-queuing on stale op_event notifications
         // 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.0",
+    "version": "2.18.0",
     "description": "Pure JavaScript and Asynchronous Firebird client for Node.js.",
     "keywords": [
         "firebird",

package/src/types.ts

@@ -6,6 +6,7 @@
 // published declaration files.
 
 import type { Readable, Writable } from 'stream';
+import type { EventEmitter } from 'events';
 import type { SqlTag } from './sql-template';
 
 export type { SqlTag, SqlQuery, SqlIdentifier, CompiledQuery } from './sql-template';
@@ -16,6 +17,32 @@ export type QueryCallback = (err: any, result: any[]) => void;
 export type SimpleCallback = (err: any) => void;
 export type SequentialCallback = (row: any, index: number, next?: (err?: any) => void) => void | Promise<void>;
 
+export interface FbEventState {
+    state: 'IDLE' | 'SUBSCRIBED' | 'CLOSED';
+    hasActiveSubscription: boolean;
+    registeredEvents: Record<string, number>;
+    eventId: number;
+    isEventConnectionOpen: boolean;
+    isDatabaseConnectionClosed: boolean;
+}
+
+export interface FbEventManager extends EventEmitter {
+    readonly eventid: number;
+    readonly events: Record<string, number>;
+    registerEvent(events: string[], callback: SimpleCallback): void;
+    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;
+}
+
+export type FbEventManagerCallback = (err: any, manager?: FbEventManager) => void;
+
 /**
  * Describes a single column in a prepared statement's result set or
  * parameter list.  The properties here are populated by the
@@ -272,7 +299,7 @@ export interface Database {
     batchStream(query: string, options?: BatchStreamOptions): BatchStream;
     drop(callback: SimpleCallback): void;
     escape(value: any): string;
-    attachEvent(callback: any): this;
+    attachEvent(callback: FbEventManagerCallback): this;
     createTablespace(name: string, filePath: string, callback?: QueryCallback): Database;
     alterTablespace(name: string, filePath: string, callback?: QueryCallback): Database;
     dropTablespace(name: string, callback?: QueryCallback): Database;
@@ -293,7 +320,7 @@ export interface Database {
     newStatementAsync(query: string): Promise<Statement>;
     detachAsync(force?: boolean): Promise<void>;
     dropAsync(): Promise<void>;
-    attachEventAsync(): Promise<any>;
+    attachEventAsync(): Promise<FbEventManager>;
     /** Starts a transaction, commits when `work` resolves, rolls back when it rejects. */
     withTransaction<T>(work: (transaction: Transaction) => Promise<T> | T, options?: TransactionOptions | Isolation): Promise<T>;
     /**
@@ -415,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/database.ts

@@ -464,6 +464,12 @@ class Database extends Events.EventEmitter {
     attachEvent(callback: Callback<FbEventManager>): this {
         var self = this;
         const eventid = self.eventid++;
+        let completed = false;
+        const complete: Callback<FbEventManager> = function(err?: any, manager?: FbEventManager) {
+            if (completed) return;
+            completed = true;
+            callback(err, manager);
+        };
         if (process.env.FIREBIRD_DEBUG) {
             console.log('[fb-debug] Database.attachEvent: calling auxConnection, eventid=%d queue=%d', eventid, self.connection._queue.length);
         }
@@ -473,7 +479,7 @@ class Database extends Events.EventEmitter {
                 if (process.env.FIREBIRD_DEBUG) {
                     console.log('[fb-debug] Database.attachEvent: auxConnection error:', err.message);
                 }
-                doError(err, callback);
+                doError(err, complete);
                 return;
             }
 
@@ -489,7 +495,7 @@ class Database extends Events.EventEmitter {
                     if (process.env.FIREBIRD_DEBUG) {
                         console.log('[fb-debug] Database.attachEvent: EventConnection error:', err.message);
                     }
-                    doError(err, callback);
+                    doError(err, complete);
                     return;
                 }
 
@@ -499,14 +505,14 @@ class Database extends Events.EventEmitter {
 
                 const evt = new FbEventManager(self, eventConnection, eventid, function (err: any) {
                     if (err) {
-                        doError(err, callback);
+                        doError(err, complete);
                         return;
                     }
 
                     if (process.env.FIREBIRD_DEBUG) {
                         console.log('[fb-debug] Database.attachEvent: FbEventManager ready, eventid=%d', evt.eventid);
                     }
-                callback(err, evt);
+                complete(err, evt);
                 });
             }, self);
         });

package/src/wire/eventConnection.ts

@@ -14,6 +14,8 @@ class EventConnection {
     error: any;
     eventcallback: ((err: any, ret?: any) => void) | null;
     _connectSettled: boolean;
+    _terminalErrorReported: boolean;
+    _intentionalClose: boolean;
 
     constructor(host: string, port: number, callback: ((err?: Error) => void) | undefined, db: any) {
         var self = this;
@@ -22,6 +24,8 @@ class EventConnection {
         this._isClosed = false;
         this._isOpened = false;
         this._connectSettled = false;
+        this._terminalErrorReported = false;
+        this._intentionalClose = false;
         this._socket = net.createConnection(port, host);
         this._bind_events(host, port, callback);
         this.error = null;
@@ -37,19 +41,40 @@ class EventConnection {
             if (callback) callback(err);
         }
 
+        function reportTerminalError(err: Error) {
+            if (self._terminalErrorReported) return;
+            self._terminalErrorReported = true;
+            const wasOpened = self._isOpened;
+            self.error = err;
+            self._isClosed = true;
+            self._isOpened = false;
+
+            // An error during a caller-initiated shutdown is part of tearing
+            // down the auxiliary socket, not a database error.
+            if (!self._intentionalClose && !wasOpened) {
+                finishConnect(err);
+            } else if (!self._intentionalClose && self.eventcallback) {
+                self.eventcallback(err);
+            } else if (!self._intentionalClose && self.db && self.db.connection &&
+                typeof self.db.connection._emitError === 'function') {
+                self.db.connection._emitError(err);
+            }
+
+            if (!self._socket.destroyed) self._socket.destroy();
+        }
+
         self._socket.on('close', function () {
             self._isClosed = true;
             if (!self._isOpened) {
                 finishConnect(self.error || new Error(`Event connection to ${host}:${port} closed before connecting.`));
+            } else if (!self._intentionalClose && self.eventcallback && !self._terminalErrorReported) {
+                reportTerminalError(new Error(`Event connection to ${host}:${port} closed unexpectedly.`));
             }
+            self._isOpened = false;
         })
 
         self._socket.on('error', function (e) {
-            self.error = e;
-            if (!self._isOpened) {
-                if (!self._socket.destroyed) self._socket.destroy();
-                finishConnect(e);
-            }
+            reportTerminalError(e);
         })
 
         self._socket.on('connect', function () {
@@ -78,6 +103,7 @@ class EventConnection {
 
                 var tmp_event: Record<string, number>;
                 while (xdr.pos < xdr.buffer.length) {
+                    op_pos = xdr.pos;
                     do {
                         var r = xdr.readInt();
                     } while (r === Const.op_dummy);
@@ -95,7 +121,8 @@ class EventConnection {
                             var eventcount = 0;
                             var pos = 1;
                             while (pos < buf.length) {
-                                var len = buf.readInt8(pos++);
+                                var len = buf.readUInt8(pos++);
+                                if (pos + len + 4 > buf.length) throw new RangeError('Incomplete event payload');
                                 eventname = buf.toString(DEFAULT_ENCODING, pos, pos + len);
                                 var prevcount = self.emgr.events[eventname] || 0;
                                 pos += len;
@@ -107,20 +134,22 @@ 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:
-                            // Unknown opcode on the event connection – stop processing.
+                            reportTerminalError(new Error('Unexpected event connection opcode: ' + r));
                             return;
                     }
                 }
@@ -130,7 +159,7 @@ class EventConnection {
                     xdr.pos = 0;
                     self._xdr = xdr;
                 } else {
-                    throw err;
+                    reportTerminalError(err instanceof Error ? err : new Error(String(err)));
                 }
             }
         })
@@ -138,7 +167,6 @@ class EventConnection {
 
     throwClosed(callback?: (err: any) => void): this {
         var err = new Error('Event Connection is closed.');
-        this.db.emit('error', err);
         if (callback)
             callback(err);
         return this;

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)
@@ -63,6 +64,7 @@
 // Asynchronous notifications on the AUX (EventConnection) socket
 // ───────────────────────────────────────────────────────────────
 //   Server → Client : op_event  (fired by Firebird POST_EVENT trigger)
+//   Error / unexpected close → CLOSED; emit manager 'error' once
 
 import Events from 'events';
 import { doError } from '../callback';
@@ -73,7 +75,19 @@ 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) {
         super();
@@ -84,11 +98,73 @@ 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._createEventLoop(callback);
+        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;
+        this._createEventLoop();
+        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 {
+        return super.once(event, listener);
+    }
+
+    _finishReady(err?: Error): void {
+        if (this._readySettled) return;
+        this._readySettled = true;
+        if (err) doError(err, this._readyCallback);
+        else this._readyCallback(null);
+    }
+
+    _handleAsyncError(err: any): void {
+        if (this._terminalErrorReported) return;
+        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;
+        this.eventconnection.eventcallback = null;
+        if (this.eventconnection._socket && !this.eventconnection._socket.destroyed &&
+            typeof this.eventconnection._socket.destroy === 'function') {
+            this.eventconnection._socket.destroy();
+        }
+
+        if (!this._readySettled) {
+            this._finishReady(error);
+        } else if (this.listenerCount('error') > 0) {
+            this.emit('error', error);
+        } else if (this.db.connection && typeof this.db.connection._emitError === 'function') {
+            this.db.connection._emitError(error);
+        }
     }
 
     /**
@@ -143,7 +219,7 @@ class FbEventManager extends Events.EventEmitter {
         };
     }
 
-    _createEventLoop(callback: (err: any, ret?: any) => void): void {
+    _createEventLoop(): void {
         var self = this;
         var cnx = this.db.connection;
         this.eventconnection.emgr = this;
@@ -161,12 +237,14 @@ 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) {
-                    doError(err, callback);
+            const eventId = self.eventid;
+            cnx.queEvents(self.events, eventId, function (err: any) {
+                if (err && (!self._eventBaseline || !self._isRetiredEventId(eventId))) {
+                    self._handleAsyncError(err);
                     return;
                 }
                 // subscription renewed, nothing else to do
@@ -174,26 +252,53 @@ class FbEventManager extends Events.EventEmitter {
         }
 
         this.eventconnection.eventcallback = function (err: any, ret?: any) {
-            if (err || (self.eventid !== ret.eventid)) {
-                doError(err || new Error('Bad eventid'), callback);
+            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();
         };
 
-        // Resolve attachEvent on the next tick – no subscription is needed
-        // until the caller registers at least one event name via registerEvent().
-        // process.nextTick ensures the outer `const evt = new FbEventManager(...)`
-        // assignment in database.js completes before this callback fires.
-        process.nextTick(function() { callback(null); });
     }
 
     _changeEvent(callback: (err: any, ret?: any) => void): void {
+        if (this._eventBaseline) {
+            this._changeEventWithBaseline(callback);
+            return;
+        }
         var self = this;
         const changeVersion = ++self._subscriptionVersion;
 
@@ -204,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;
             }
@@ -217,6 +323,7 @@ class FbEventManager extends Events.EventEmitter {
                 if (err) {
                     if (self._subscriptionVersion === changeVersion) {
                         self._hasActiveSubscription = false;
+                        self._baselinePending = false;
                     }
                     doError(err, callback);
                     return;
@@ -242,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);
@@ -255,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] });
@@ -265,13 +453,21 @@ 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);
         }
 
         // Prevent the event loop from re-queuing on stale op_event notifications
         // 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