node-firebird 2.3.4 → 2.4.1

package/lib/wire/connection.js

@@ -1,165 +1,193 @@
-const Events = require('events');
-const os = require('os');
-const path = require('path');
-
-const {XdrWriter, BlrWriter, XdrReader, BitSet, BlrReader} = require('./serialize');
-const {doCallback, doError} = require('../callback');
-const srp = require('../srp');
-const crypt = require('../unix-crypt');
-const Const = require('./const');
-const Xsql = require('./xsqlvar');
-const ServiceManager = require('./service');
-const Database = require('./database');
-const Statement = require('./statement');
-const Transaction = require('./transaction');
-const {lookupMessages, noop, parseDate} = require('../utils');
-const Socket = require("./socket");
-
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+const events_1 = __importDefault(require("events"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const serialize_1 = require("./serialize");
+const callback_1 = require("../callback");
+const srp = __importStar(require("../srp"));
+const crypt = __importStar(require("../unix-crypt"));
+const const_1 = __importDefault(require("./const"));
+const Xsql = __importStar(require("./xsqlvar"));
+const service_1 = __importDefault(require("./service"));
+const database_1 = __importDefault(require("./database"));
+const statement_1 = __importDefault(require("./statement"));
+const transaction_1 = __importDefault(require("./transaction"));
+const utils_1 = require("../utils");
+const socket_1 = __importDefault(require("./socket"));
+function parseValueIfJson(value, options) {
+    if (options && options.jsonAsObject && typeof value === 'string' && (value.startsWith('{') || value.startsWith('['))) {
+        try {
+            return JSON.parse(value);
+        }
+        catch (e) {
+            // Ignore parse error and keep as string
+        }
+    }
+    return value;
+}
 /***************************************
  *
  *   Connection
  *
  ***************************************/
-
 class Connection {
     constructor(host, port, callback, options, db, svc) {
         var self = this;
         this.db = db;
-        this.svc = svc
-        this._msg = new XdrWriter(32);
-        this._blr = new BlrWriter(32);
+        this.svc = svc;
+        this._msg = new serialize_1.XdrWriter(32);
+        this._blr = new serialize_1.BlrWriter(32);
         this._queue = [];
         this._detachTimeout;
         this._detachCallback;
         this._detachAuto;
-        this._socket = new Socket(port, host);
+        this._socket = new socket_1.default(port, host);
         this._pending = [];
         this._isOpened = false;
         this._isClosed = false;
         this._isDetach = false;
         this._isUsed = false;
-        this._pooled = options.isPool||false;
-        if (options && options.blobChunkSize > 65535) options.blobChunkSize = 65535;
-        if (options && options.blobReadChunkSize > 65535) options.blobReadChunkSize = 65535;
+        this._pooled = options.isPool || false;
+        if (options && options.blobChunkSize > 65535)
+            options.blobChunkSize = 65535;
+        if (options && options.blobReadChunkSize > 65535)
+            options.blobReadChunkSize = 65535;
         this.options = options;
         this._bind_events(host, port, callback);
         this.error;
         this._retry_connection_id;
         this._retry_connection_interval = options.retryConnectionInterval || 1000;
         this._max_cached_query = options.maxCachedQuery || -1;
-        this._cache_query = options.cacheQuery?{}:null;
-        this._messageFile = options.messageFile || path.join(__dirname, 'firebird.msg');
+        this._cache_query = options.cacheQuery ? {} : null;
+        this._messageFile = options.messageFile || path_1.default.join(__dirname, 'firebird.msg');
     }
-
-
     _setcachedquery(query, statement) {
-        if (this._cache_query){
-            if (this._max_cached_query === -1 || this._max_cached_query > Object.keys(this._cache_query).length){
+        if (this._cache_query) {
+            if (this._max_cached_query === -1 || this._max_cached_query > Object.keys(this._cache_query).length) {
                 this._cache_query[query] = statement;
             }
         }
-    
-    
     }
-
-
     getCachedQuery(query) {
         return this._cache_query ? this._cache_query[query] : null;
     }
-
-
+    // Reject every request that is still awaiting a server response (e.g. a
+    // transaction.commit() sent right before the server went away) instead of
+    // leaving its callback to hang forever. Requests already in flight cannot
+    // be transparently resumed on a reconnect: a fresh attach() hands out new
+    // transaction/statement handles, so nothing the server sends back could
+    // ever match a callback queued against the old connection.
+    _rejectPending(err) {
+        var queue = this._queue;
+        this._queue = [];
+        this._pending = [];
+        for (var i = 0; i < queue.length; i++) {
+            (0, callback_1.doError)(err, queue[i]);
+        }
+    }
     _bind_events(host, port, callback) {
-    
         var self = this;
-    
-        self._socket.on('close', function() {
-    
+        self._socket.on('close', function () {
             if (!self._isOpened || self._isDetach) {
                 return;
             }
-    
             self._isOpened = false;
-    
+            self._isClosed = true;
+            var lostError = self.error || new Error('Connection to Firebird server was lost.');
             if (!self.db) {
+                self._rejectPending(lostError);
                 if (callback)
                     callback(self.error);
                 return;
             }
-    
-            self._retry_connection_id = setTimeout(function() {
+            self._rejectPending(lostError);
+            self._retry_connection_id = setTimeout(function () {
                 self._socket.removeAllListeners();
                 self._socket = null;
-    
-                var ctx = new Connection(host, port, function(err) {
-                    ctx.connect(self.options, function(err) {
-    
+                var ctx = new Connection(host, port, function (err) {
+                    ctx.connect(self.options, function (err) {
                         if (err) {
                             self.db.emit('error', err);
                             return;
                         }
-    
-                        ctx.attach(self.options, function(err) {
-    
+                        ctx.attach(self.options, function (err) {
                             if (err) {
                                 self.db.emit('error', err);
                                 return;
                             }
-    
-                            ctx._queue = ctx._queue.concat(self._queue);
-                            ctx._pending = ctx._pending.concat(self._pending);
                             self.db.emit('reconnect');
-    
                         }, self.db);
                     });
-    
                     Object.assign(self, ctx);
-    
                 }, self.options, self.db);
             }, self._retry_connection_interval);
-    
         });
-    
-        self._socket.on('error', function(e) {
-    
+        self._socket.on('error', function (e) {
             self.error = e;
-    
             if (self.db)
-                self.db.emit('error', e)
-    
+                self.db.emit('error', e);
             if (callback)
                 callback(e);
-    
         });
-    
-        self._socket.on('connect', function() {
+        self._socket.on('connect', function () {
             self._isClosed = false;
             self._isOpened = true;
             if (callback)
                 callback();
         });
-    
         self._socket.on('data', function (data) {
             var xdr;
             var hadSavedBuffer = Boolean(self._xdr);
-    
             if (!self._xdr) {
-                xdr = new XdrReader(data);
-            } else {
-                xdr = new XdrReader(Buffer.concat([self._xdr.buffer, data], self._xdr.buffer.length + data.length));
+                xdr = new serialize_1.XdrReader(data);
+            }
+            else {
+                xdr = new serialize_1.XdrReader(Buffer.concat([self._xdr.buffer, data], self._xdr.buffer.length + data.length));
                 delete (self._xdr);
             }
-
             if (process.env.FIREBIRD_DEBUG) {
-                console.log('[fb-debug] data event: bytes=%d queue=%d pending=%d xdr.pos=%d savedBuf=%s',
-                    xdr.buffer.length, self._queue.length, self._pending.length, xdr.pos, hadSavedBuffer);
+                console.log('[fb-debug] data event: bytes=%d queue=%d pending=%d xdr.pos=%d savedBuf=%s', xdr.buffer.length, self._queue.length, self._pending.length, xdr.pos, hadSavedBuffer);
             }
-    
             while (xdr.pos < xdr.buffer.length) {
                 var cb = self._queue[0], pos = xdr.pos;
                 var lazySnapshot = cb ? cb.lazy_count : undefined;
-    
                 decodeResponse(xdr, cb, self, self._lowercase_keys, function (err, obj) {
-    
                     if (err) {
                         if (err instanceof RangeError) {
                             // Genuinely incomplete packet – buffer the remaining bytes
@@ -167,12 +195,9 @@ class Connection {
                             xdr.buffer = xdr.buffer.slice(pos);
                             xdr.pos = 0;
                             self._xdr = xdr;
-
                             if (process.env.FIREBIRD_DEBUG) {
-                                console.log('[fb-debug] incomplete packet: saved %d bytes at pos=%d queue=%d',
-                                    xdr.buffer.length, pos, self._queue.length);
+                                console.log('[fb-debug] incomplete packet: saved %d bytes at pos=%d queue=%d', xdr.buffer.length, pos, self._queue.length);
                             }
-
                             // Restore lazy_count to its value before this (failed)
                             // decode attempt. Forcing lazy_count = 2 here made the
                             // decoder expect a second op_response that never arrives
@@ -181,11 +206,13 @@ class Connection {
                             if (cb) {
                                 if (lazySnapshot === undefined) {
                                     delete cb.lazy_count;
-                                } else {
+                                }
+                                else {
                                     cb.lazy_count = lazySnapshot;
                                 }
                             }
-                        } else {
+                        }
+                        else {
                             // Any other error (truly unknown opcode not handled above).
                             // Save the buffer so it can be retried, but log a warning.
                             if (process.env.FIREBIRD_DEBUG) {
@@ -197,437 +224,429 @@ class Connection {
                         }
                         return;
                     }
-    
                     // remove the op flag, needed for partial packet
                     if (xdr.r) {
                         delete (xdr.r);
                     }
-
                     // op_event / op_response_piggyback received on the main connection:
                     // data has been consumed by decodeResponse but it does not belong to
                     // any queued request – do NOT shift the queue or invoke any pending
                     // callback.
                     if (obj && obj._isOpEvent) {
                         if (process.env.FIREBIRD_DEBUG) {
-                            console.log('[fb-debug] async opcode consumed (ignored): queue=%d xdr.pos=%d remaining=%d',
-                                self._queue.length, xdr.pos, xdr.buffer.length - xdr.pos);
+                            console.log('[fb-debug] async opcode consumed (ignored): queue=%d xdr.pos=%d remaining=%d', self._queue.length, xdr.pos, xdr.buffer.length - xdr.pos);
                         }
                         return;
                     }
-    
                     self._queue.shift();
                     self._pending.shift();
-    
                     if (process.env.FIREBIRD_DEBUG) {
-                        console.log('[fb-debug] response dispatched: queue remaining=%d pending remaining=%d xdr.pos=%d',
-                            self._queue.length, self._pending.length, xdr.pos);
+                        console.log('[fb-debug] response dispatched: queue remaining=%d pending remaining=%d xdr.pos=%d', self._queue.length, self._pending.length, xdr.pos);
                     }
-
                     if (obj && obj.status) {
-                        obj.message = lookupMessages(obj.status);
-                        doCallback(obj, cb);
-                    } else {
-                        doCallback(obj, cb);
+                        obj.message = (0, utils_1.lookupMessages)(obj.status);
+                        (0, callback_1.doCallback)(obj, cb);
+                    }
+                    else {
+                        (0, callback_1.doCallback)(obj, cb);
                     }
-    
                 });
-    
                 if (xdr.pos === 0) {
                     break;
                 }
             }
-    
             if (!self._detachAuto || self._pending.length !== 0) {
                 return;
             }
-    
             clearTimeout(self._detachTimeout);
             self._detachTimeout = setTimeout(function () {
                 self.db.detach(self._detachCallback);
                 self._detachAuto = false;
             }, 100);
-    
         });
     }
-
-
     disconnect() {
         this._socket.end();
     }
-
-
-
-
-
     sendOpContAuth(authData, authDataEnc, pluginName) {
         var msg = this._msg;
         msg.pos = 0;
-    
-        msg.addInt(Const.op_cont_auth);
+        msg.addInt(const_1.default.op_cont_auth);
         msg.addString(authData, authDataEnc);
-        msg.addString(pluginName, Const.DEFAULT_ENCODING)
-        msg.addString(Const.AUTH_PLUGIN_LIST.join(','), Const.DEFAULT_ENCODING);
+        msg.addString(pluginName, const_1.default.DEFAULT_ENCODING);
+        msg.addString(const_1.default.AUTH_PLUGIN_LIST.join(','), const_1.default.DEFAULT_ENCODING);
         // msg.addInt(0); // p_list
         msg.addInt(0); // keys
-    
         this._socket.write(msg.getData());
     }
-
-
     sendOpCrypt(encryptPlugin) {
         var msg = this._msg;
         msg.pos = 0;
-
-        msg.addInt(Const.op_crypt);
-        msg.addString(encryptPlugin || 'Arc4', Const.DEFAULT_ENCODING);
-        msg.addString('Symmetric', Const.DEFAULT_ENCODING);
-
+        msg.addInt(const_1.default.op_crypt);
+        msg.addString(encryptPlugin || 'Arc4', const_1.default.DEFAULT_ENCODING);
+        msg.addString('Symmetric', const_1.default.DEFAULT_ENCODING);
         this._socket.write(msg.getData());
     }
-
-
     sendOpCryptKeyCallback(pluginData) {
         var msg = this._msg;
         msg.pos = 0;
-
-        msg.addInt(Const.op_crypt_key_callback);
+        msg.addInt(const_1.default.op_crypt_key_callback);
         msg.addBlr(pluginData); // Send the callback response data as a buffer
-
         this._socket.write(msg.getData());
     }
-
-
     _queueEvent(callback, defer = false) {
         var self = this;
-    
         if (self._isClosed) {
             if (callback)
                 callback(new Error('Connection is closed.'));
             return;
         }
-    
-        const canDefer = defer && this.accept.protocolVersion >= Const.PROTOCOL_VERSION11;
-    
+        const canDefer = defer && this.accept.protocolVersion >= const_1.default.PROTOCOL_VERSION11;
         self._socket.write(self._msg.getData(), canDefer);
         if (canDefer && callback) {
             callback();
-        } else {
+        }
+        else {
             self._queue.push(callback);
         }
     }
-
-
     connect(options, callback) {
-        var pluginName = options.manager ? Const.AUTH_PLUGIN_LEGACY : options.pluginName || Const.AUTH_PLUGIN_LIST[0]; // TODO Srp for service
+        var pluginName = options.pluginName || const_1.default.AUTH_PLUGIN_LIST[0];
         var msg = this._msg;
         var blr = this._blr;
-    
         this._pending.push('connect');
         this._authStartTime = Date.now();
-    
         msg.pos = 0;
         blr.pos = 0;
-    
-        blr.addString(Const.CNCT_login, options.user, Const.DEFAULT_ENCODING);
-        blr.addString(Const.CNCT_plugin_name, pluginName, Const.DEFAULT_ENCODING);
-        blr.addString(Const.CNCT_plugin_list, Const.AUTH_PLUGIN_LIST.join(','), Const.DEFAULT_ENCODING);
-    
+        blr.addString(const_1.default.CNCT_login, options.user, const_1.default.DEFAULT_ENCODING);
+        blr.addString(const_1.default.CNCT_plugin_name, pluginName, const_1.default.DEFAULT_ENCODING);
+        blr.addString(const_1.default.CNCT_plugin_list, const_1.default.AUTH_PLUGIN_LIST.join(','), const_1.default.DEFAULT_ENCODING);
         var specificData = '';
-        if (Const.AUTH_PLUGIN_SRP_LIST.indexOf(pluginName) > -1) {
+        if (const_1.default.AUTH_PLUGIN_SRP_LIST.indexOf(pluginName) > -1) {
             const _t0 = Date.now();
             this.clientKeys = srp.clientSeed();
             if (process.env.FIREBIRD_DEBUG) {
                 console.log('[fb-debug] srp.clientSeed: %dms', Date.now() - _t0);
             }
             specificData = this.clientKeys.public.toString(16);
-            blr.addMultiblockPart(Const.CNCT_specific_data, specificData, Const.DEFAULT_ENCODING);
-        } else if (pluginName === Const.AUTH_PLUGIN_LEGACY) {
-            specificData = crypt.crypt(options.password, Const.LEGACY_AUTH_SALT).substring(2);
-            blr.addMultiblockPart(Const.CNCT_specific_data, specificData, Const.DEFAULT_ENCODING);
-        } else {
-            doError(new Error('Invalide auth plugin \'' + pluginName + '\''), callback);
+            blr.addMultiblockPart(const_1.default.CNCT_specific_data, specificData, const_1.default.DEFAULT_ENCODING);
+        }
+        else if (pluginName === const_1.default.AUTH_PLUGIN_LEGACY) {
+            specificData = crypt.crypt(options.password, const_1.default.LEGACY_AUTH_SALT).substring(2);
+            blr.addMultiblockPart(const_1.default.CNCT_specific_data, specificData, const_1.default.DEFAULT_ENCODING);
+        }
+        else {
+            (0, callback_1.doError)(new Error('Invalide auth plugin \'' + pluginName + '\''), callback);
             return;
         }
-        blr.addBytes([Const.CNCT_client_crypt, 4, options.wireCrypt !== undefined ? options.wireCrypt : Const.WIRE_CRYPT_ENABLE, 0, 0, 0]);
-        blr.addString(Const.CNCT_user, os.userInfo().username || 'Unknown', Const.DEFAULT_ENCODING);
-        blr.addString(Const.CNCT_host, os.hostname(), Const.DEFAULT_ENCODING);
-        blr.addBytes([Const.CNCT_user_verification, 0]);
-    
-        msg.addInt(Const.op_connect);
-        msg.addInt(Const.op_attach);
-        msg.addInt(Const.CONNECT_VERSION3);
-        msg.addInt(Const.ARCHITECTURE_GENERIC);
-        msg.addString(options.database || options.filename, Const.DEFAULT_ENCODING);
-        msg.addInt(Const.SUPPORTED_PROTOCOL.length);  // Count of Protocol version understood count.
+        blr.addBytes([const_1.default.CNCT_client_crypt, 4, options.wireCrypt !== undefined ? options.wireCrypt : const_1.default.WIRE_CRYPT_ENABLE, 0, 0, 0]);
+        blr.addString(const_1.default.CNCT_user, os_1.default.userInfo().username || 'Unknown', const_1.default.DEFAULT_ENCODING);
+        blr.addString(const_1.default.CNCT_host, os_1.default.hostname(), const_1.default.DEFAULT_ENCODING);
+        blr.addBytes([const_1.default.CNCT_user_verification, 0]);
+        msg.addInt(const_1.default.op_connect);
+        msg.addInt(const_1.default.op_attach);
+        msg.addInt(const_1.default.CONNECT_VERSION3);
+        msg.addInt(const_1.default.ARCHITECTURE_GENERIC);
+        msg.addString(options.database || options.filename, const_1.default.DEFAULT_ENCODING);
+        var maxProtocols = options.maxNegotiatedProtocols !== undefined ? options.maxNegotiatedProtocols : 10;
+        var protocolsToSend = const_1.default.SUPPORTED_PROTOCOL;
+        if (protocolsToSend.length > maxProtocols) {
+            protocolsToSend = protocolsToSend.slice(-maxProtocols);
+        }
+        msg.addInt(protocolsToSend.length); // Count of Protocol version understood count.
         msg.addBlr(this._blr);
-    
-        for (var protocol of Const.SUPPORTED_PROTOCOL) {
+        for (var protocol of protocolsToSend) {
             msg.addInt(protocol[0]); // Version
             msg.addInt(protocol[1]); // Architecture
             msg.addInt(protocol[2]); // Min type
-            if (protocol[0] >= Const.PROTOCOL_VERSION13 && options.wireCompression) {
-                msg.addInt(protocol[3] | Const.pflag_compress); // Max type with compress flag
-            } else {
+            if (protocol[0] >= const_1.default.PROTOCOL_VERSION13 && options.wireCompression) {
+                msg.addInt(protocol[3] | const_1.default.pflag_compress); // Max type with compress flag
+            }
+            else {
                 msg.addInt(protocol[3]); // Max type
             }
             msg.addInt(protocol[4]); // Preference weight
         }
-    
         var self = this;
         function cb(err, ret) {
             if (err) {
-                doError(err, callback);
+                (0, callback_1.doError)(err, callback);
                 return;
             }
-
             // Check for pending accept from op_cond_accept flow
             if (self._pendingAccept) {
                 ret = self._pendingAccept;
                 delete self._pendingAccept;
             }
-
             self.accept = ret;
-
             // Wire encryption: send op_crypt if SRP session key is available
-            if (ret.sessionKey && ret.protocolVersion >= Const.PROTOCOL_VERSION13 &&
-                options.wireCrypt !== Const.WIRE_CRYPT_DISABLE) {
-                var keyBuf = Buffer.from(ret.sessionKey.toString(16).padStart(40, '0'), 'hex');
-                self.sendOpCrypt('Arc4');
-                self._socket.enableEncryption(keyBuf);
+            if (ret.sessionKey && ret.protocolVersion >= const_1.default.PROTOCOL_VERSION13 &&
+                options.wireCrypt !== const_1.default.WIRE_CRYPT_DISABLE) {
+                var padLen = 40;
+                var keyBuf = Buffer.from(ret.sessionKey.toString(16).padStart(padLen, '0'), 'hex');
+                var selectedPlugin = 'Arc4';
+                if (ret.keys) {
+                    var serverPlugins = ret.keys.split(',').map(function (s) { return s.trim().toLowerCase(); });
+                    var preferred = ['chacha64', 'chacha', 'arc4'];
+                    for (var i = 0; i < preferred.length; i++) {
+                        if (serverPlugins.indexOf(preferred[i]) !== -1) {
+                            var mapping = {
+                                chacha64: 'ChaCha64',
+                                chacha: 'ChaCha',
+                                arc4: 'Arc4'
+                            };
+                            selectedPlugin = mapping[preferred[i]];
+                            break;
+                        }
+                    }
+                }
+                // Send op_crypt BEFORE enabling encryption (op_crypt is sent plaintext)
+                // The server then enables encryption from its side.
+                // After the op_response to op_crypt, both sides are encrypted.
+                self.sendOpCrypt(selectedPlugin);
+                if (selectedPlugin === 'Arc4') {
+                    self._socket.enableEncryption(keyBuf, 'Arc4');
+                }
                 self._pending.push('crypt');
-                self._queue.push(function(cryptErr) {
+                self._queue.push(function (cryptErr, response) {
                     if (cryptErr) {
-                        doError(cryptErr, callback);
+                        (0, callback_1.doError)(cryptErr, callback);
                         return;
                     }
+                    if (selectedPlugin !== 'Arc4') {
+                        var iv = response && response.buffer;
+                        if (!iv || (selectedPlugin === 'ChaCha64' && iv.length < 8) || (selectedPlugin === 'ChaCha' && iv.length < 12)) {
+                            var errIv = new Error('Invalid or missing IV for ' + selectedPlugin + ' encryption');
+                            (0, callback_1.doError)(errIv, callback);
+                            return;
+                        }
+                        self._socket.enableEncryption(keyBuf, selectedPlugin, iv);
+                    }
                     if (callback)
                         callback(undefined, ret);
                 });
                 return;
             }
-
             if (callback)
                 callback(undefined, ret);
         }
-    
         if (process.env.FIREBIRD_DEBUG) {
             console.log('[fb-debug] auth: op_connect sent plugin=%s t=%dms', pluginName, Date.now() - this._authStartTime);
         }
         this._queueEvent(cb);
     }
-
-
     attach(options, callback, db) {
-        this._lowercase_keys = options.lowercase_keys || Const.DEFAULT_LOWERCASE_KEYS;
-    
+        this._lowercase_keys = options.lowercase_keys || const_1.default.DEFAULT_LOWERCASE_KEYS;
         var database = options.database || options.filename;
         if (database == null || database.length === 0) {
-            doError(new Error('No database specified'), callback);
+            (0, callback_1.doError)(new Error('No database specified'), callback);
             return;
         }
-    
-        var user = options.user || Const.DEFAULT_USER;
-        var password = options.password || Const.DEFAULT_PASSWORD;
+        var user = options.user || const_1.default.DEFAULT_USER;
+        var password = options.password || const_1.default.DEFAULT_PASSWORD;
         var role = options.role;
         var self = this;
         var msg = this._msg;
         var blr = this._blr;
         msg.pos = 0;
         blr.pos = 0;
-    
-        blr.addByte(Const.isc_dpb_version1);
-        blr.addString(Const.isc_dpb_lc_ctype, options.encoding || 'UTF8', Const.DEFAULT_ENCODING);
-        
+        blr.addByte(const_1.default.isc_dpb_version1);
+        blr.addString(const_1.default.isc_dpb_lc_ctype, options.encoding || 'UTF8', const_1.default.DEFAULT_ENCODING);
         // For Firebird 3+ (protocol 13+), add UTF-8 filename flag to ensure all DPB strings are handled with UTF-8
-        if (this.accept.protocolVersion >= Const.PROTOCOL_VERSION13) {
-            blr.addByte(Const.isc_dpb_utf8_filename);
+        if (this.accept.protocolVersion >= const_1.default.PROTOCOL_VERSION13) {
+            blr.addByte(const_1.default.isc_dpb_utf8_filename);
             blr.addByte(0);
         }
-        
-        blr.addString(Const.isc_dpb_user_name, user, Const.DEFAULT_ENCODING);
+        blr.addString(const_1.default.isc_dpb_user_name, user, const_1.default.DEFAULT_ENCODING);
         if (options.password && !this.accept.authData) {
-            if (this.accept.protocolVersion < Const.PROTOCOL_VERSION13) {
-                if (this.accept.protocolVersion === Const.PROTOCOL_VERSION10) {
-                    blr.addString(Const.isc_dpb_password, password, Const.DEFAULT_ENCODING);
-                } else {
-                    blr.addString(Const.isc_dpb_password_enc, crypt.crypt(password, Const.LEGACY_AUTH_SALT).substring(2), Const.DEFAULT_ENCODING);
+            if (this.accept.protocolVersion < const_1.default.PROTOCOL_VERSION13) {
+                if (this.accept.protocolVersion === const_1.default.PROTOCOL_VERSION10) {
+                    blr.addString(const_1.default.isc_dpb_password, password, const_1.default.DEFAULT_ENCODING);
+                }
+                else {
+                    blr.addString(const_1.default.isc_dpb_password_enc, crypt.crypt(password, const_1.default.LEGACY_AUTH_SALT).substring(2), const_1.default.DEFAULT_ENCODING);
                 }
             }
         }
-    
         if (role)
-            blr.addString(Const.isc_dpb_sql_role_name, role, Const.DEFAULT_ENCODING);
-    
-        blr.addBytes([Const.isc_dpb_process_id, 4]);
+            blr.addString(const_1.default.isc_dpb_sql_role_name, role, const_1.default.DEFAULT_ENCODING);
+        blr.addBytes([const_1.default.isc_dpb_process_id, 4]);
         blr.addInt32(process.pid);
-    
-        let processName  = process.title || "";
-        blr.addString(Const.isc_dpb_process_name, processName.length > 255 ? processName.substring(processName.length - 255,  processName.length) : processName, Const.DEFAULT_ENCODING);
-    
+        let processName = process.title || "";
+        blr.addString(const_1.default.isc_dpb_process_name, processName.length > 255 ? processName.substring(processName.length - 255, processName.length) : processName, const_1.default.DEFAULT_ENCODING);
         if (this.accept.authData) {
-            blr.addString(Const.isc_dpb_specific_auth_data, this.accept.authData, Const.DEFAULT_ENCODING);
+            blr.addString(const_1.default.isc_dpb_specific_auth_data, this.accept.authData, const_1.default.DEFAULT_ENCODING);
         }
-
         if (options.sessionTimeZone) {
-            blr.addString(Const.isc_dpb_session_time_zone, options.sessionTimeZone, Const.DEFAULT_ENCODING);
+            blr.addString(const_1.default.isc_dpb_session_time_zone, options.sessionTimeZone, const_1.default.DEFAULT_ENCODING);
         }
-    
-        msg.addInt(Const.op_attach);
-        msg.addInt(0);  // Database Object ID
-        msg.addString(database, Const.DEFAULT_ENCODING);
+        if (options.parallelWorkers !== undefined) {
+            blr.addNumeric(const_1.default.isc_dpb_parallel_workers, options.parallelWorkers);
+        }
+        if (options.maxInlineBlobSize !== undefined) {
+            blr.addNumeric(const_1.default.isc_dpb_max_inline_blob_size, options.maxInlineBlobSize);
+        }
+        // Firebird 6.0 SQL Schema parameters (Protocol 20+).
+        // These DPB tags configure the session's current schema and the
+        // schema search path for unqualified object name resolution.
+        if (this.accept.protocolVersion >= const_1.default.PROTOCOL_VERSION20) {
+            if (options.defaultSchema) {
+                // Sets CURRENT_SCHEMA for the session.  Equivalent to issuing
+                // SET SCHEMA <name> immediately after connecting.
+                blr.addString(const_1.default.isc_dpb_default_schema, options.defaultSchema, const_1.default.DEFAULT_ENCODING);
+            }
+            if (options.searchPath) {
+                // Comma-separated ordered schema name list, like PostgreSQL's
+                // search_path.  Unqualified object references are resolved by
+                // scanning schemas in this order.
+                const sp = Array.isArray(options.searchPath)
+                    ? options.searchPath.join(',')
+                    : String(options.searchPath);
+                blr.addString(const_1.default.isc_dpb_search_path, sp, const_1.default.DEFAULT_ENCODING);
+            }
+        }
+        msg.addInt(const_1.default.op_attach);
+        msg.addInt(0); // Database Object ID
+        msg.addString(database, const_1.default.DEFAULT_ENCODING);
         msg.addBlr(this._blr);
-    
         function cb(err, ret) {
             if (err) {
-                doError(err, callback);
+                (0, callback_1.doError)(err, callback);
                 return;
             }
-    
             self.dbhandle = ret.handle;
             if (callback)
                 callback(undefined, ret);
             if (!db)
                 ret.emit('attach', ret);
         }
-    
         // For reconnect
         if (db) {
             db.connection = this;
             cb.response = db;
-        } else {
-            cb.response = new Database(this);
+        }
+        else {
+            cb.response = new database_1.default(this);
             cb.response.removeAllListeners('error');
-            cb.response.on('error', noop);
+            cb.response.on('error', utils_1.noop);
         }
-    
         this._queueEvent(cb);
     }
-
-
     detach(callback) {
-    
         var self = this;
-    
         if (self._isClosed)
-            return;
-    
+            return this.throwClosed(callback);
         self._isUsed = false;
         self._isDetach = true;
-    
         var msg = self._msg;
-    
         msg.pos = 0;
-        msg.addInt(Const.op_detach);
+        msg.addInt(const_1.default.op_detach);
         msg.addInt(0); // Database Object ID
-    
-        self._queueEvent(function(err, ret) {
+        self._queueEvent(function (err, ret) {
             clearTimeout(self._retry_connection_id);
-            delete(self.dbhandle);
+            delete (self.dbhandle);
             if (callback)
                 callback(err, ret);
         });
     }
-
-
     createDatabase(options, callback) {
+        // Mirror attach(): honour the lowercase_keys option so that db.query()
+        // called on a freshly-created database returns the expected column case.
+        this._lowercase_keys = options.lowercase_keys || const_1.default.DEFAULT_LOWERCASE_KEYS;
         var database = options.database || options.filename;
         if (database == null || database.length === 0) {
-            doError(new Error('No database specified'), callback);
+            (0, callback_1.doError)(new Error('No database specified'), callback);
             return;
         }
-    
-        var user = options.user || Const.DEFAULT_USER;
-        var password = options.password || Const.DEFAULT_PASSWORD;
-        var pageSize = options.pageSize || Const.DEFAULT_PAGE_SIZE;
+        var user = options.user || const_1.default.DEFAULT_USER;
+        var password = options.password || const_1.default.DEFAULT_PASSWORD;
+        var pageSize = options.pageSize || const_1.default.DEFAULT_PAGE_SIZE;
         var role = options.role;
         var blr = this._blr;
-    
         blr.pos = 0;
-        blr.addByte(Const.isc_dpb_version1);
-        blr.addString(Const.isc_dpb_set_db_charset, 'UTF8', Const.DEFAULT_ENCODING);
-        blr.addString(Const.isc_dpb_lc_ctype, 'UTF8', Const.DEFAULT_ENCODING);
-        
+        blr.addByte(const_1.default.isc_dpb_version1);
+        blr.addString(const_1.default.isc_dpb_set_db_charset, 'UTF8', const_1.default.DEFAULT_ENCODING);
+        blr.addString(const_1.default.isc_dpb_lc_ctype, 'UTF8', const_1.default.DEFAULT_ENCODING);
         // For Firebird 3+ (protocol 13+), add UTF-8 filename flag to ensure all DPB strings are handled with UTF-8
-        if (this.accept.protocolVersion >= Const.PROTOCOL_VERSION13) {
-            blr.addByte(Const.isc_dpb_utf8_filename);
+        if (this.accept.protocolVersion >= const_1.default.PROTOCOL_VERSION13) {
+            blr.addByte(const_1.default.isc_dpb_utf8_filename);
             blr.addByte(0);
         }
-        
-        blr.addString(Const.isc_dpb_user_name, user, Const.DEFAULT_ENCODING);
-        if (this.accept.protocolVersion < Const.PROTOCOL_VERSION13) {
-            if (this.accept.protocolVersion === Const.PROTOCOL_VERSION10) {
-                blr.addString(Const.isc_dpb_password, password, Const.DEFAULT_ENCODING);
-            } else {
-                blr.addString(Const.isc_dpb_password_enc, crypt.crypt(password, Const.LEGACY_AUTH_SALT).substring(2), Const.DEFAULT_ENCODING);
+        blr.addString(const_1.default.isc_dpb_user_name, user, const_1.default.DEFAULT_ENCODING);
+        if (this.accept.protocolVersion < const_1.default.PROTOCOL_VERSION13) {
+            if (this.accept.protocolVersion === const_1.default.PROTOCOL_VERSION10) {
+                blr.addString(const_1.default.isc_dpb_password, password, const_1.default.DEFAULT_ENCODING);
+            }
+            else {
+                blr.addString(const_1.default.isc_dpb_password_enc, crypt.crypt(password, const_1.default.LEGACY_AUTH_SALT).substring(2), const_1.default.DEFAULT_ENCODING);
             }
         }
         if (role)
-            blr.addString(Const.isc_dpb_sql_role_name, role, Const.DEFAULT_ENCODING);
-    
-        blr.addBytes([Const.isc_dpb_process_id, 4]);
+            blr.addString(const_1.default.isc_dpb_sql_role_name, role, const_1.default.DEFAULT_ENCODING);
+        blr.addBytes([const_1.default.isc_dpb_process_id, 4]);
         blr.addInt32(process.pid);
-    
-        let processName  = process.title || "";
-        blr.addString(Const.isc_dpb_process_name, processName.length > 255 ? processName.substring(processName.length - 255,  processName.length) : processName, Const.DEFAULT_ENCODING);
-    
+        let processName = process.title || "";
+        blr.addString(const_1.default.isc_dpb_process_name, processName.length > 255 ? processName.substring(processName.length - 255, processName.length) : processName, const_1.default.DEFAULT_ENCODING);
         if (this.accept.authData) {
-            blr.addString(Const.isc_dpb_specific_auth_data, this.accept.authData, Const.DEFAULT_ENCODING);
+            blr.addString(const_1.default.isc_dpb_specific_auth_data, this.accept.authData, const_1.default.DEFAULT_ENCODING);
         }
-
         if (options.sessionTimeZone) {
-            blr.addString(Const.isc_dpb_session_time_zone, options.sessionTimeZone, Const.DEFAULT_ENCODING);
+            blr.addString(const_1.default.isc_dpb_session_time_zone, options.sessionTimeZone, const_1.default.DEFAULT_ENCODING);
         }
-    
-        blr.addNumeric(Const.isc_dpb_sql_dialect, 3);
-        blr.addNumeric(Const.isc_dpb_force_write, 1);
-        blr.addNumeric(Const.isc_dpb_overwrite, 1);
-        blr.addNumeric(Const.isc_dpb_page_size, pageSize);
-    
+        if (options.parallelWorkers !== undefined) {
+            blr.addNumeric(const_1.default.isc_dpb_parallel_workers, options.parallelWorkers);
+        }
+        if (options.maxInlineBlobSize !== undefined) {
+            blr.addNumeric(const_1.default.isc_dpb_max_inline_blob_size, options.maxInlineBlobSize);
+        }
+        // Firebird 6.0 SQL Schema parameters (Protocol 20+).
+        if (this.accept.protocolVersion >= const_1.default.PROTOCOL_VERSION20) {
+            if (options.defaultSchema) {
+                blr.addString(const_1.default.isc_dpb_default_schema, options.defaultSchema, const_1.default.DEFAULT_ENCODING);
+            }
+            if (options.searchPath) {
+                const sp = Array.isArray(options.searchPath)
+                    ? options.searchPath.join(',')
+                    : String(options.searchPath);
+                blr.addString(const_1.default.isc_dpb_search_path, sp, const_1.default.DEFAULT_ENCODING);
+            }
+        }
+        blr.addNumeric(const_1.default.isc_dpb_sql_dialect, 3);
+        blr.addNumeric(const_1.default.isc_dpb_force_write, 1);
+        blr.addNumeric(const_1.default.isc_dpb_overwrite, 1);
+        blr.addNumeric(const_1.default.isc_dpb_page_size, pageSize);
         var msg = this._msg;
         msg.pos = 0;
-        msg.addInt(Const.op_create);  // op_create
-        msg.addInt(0);          // Database Object ID
-        msg.addString(database, Const.DEFAULT_ENCODING);
+        msg.addInt(const_1.default.op_create); // op_create
+        msg.addInt(0); // Database Object ID
+        msg.addString(database, const_1.default.DEFAULT_ENCODING);
         msg.addBlr(blr);
-    
         var self = this;
-    
         function cb(err, ret) {
-    
             if (ret)
                 self.dbhandle = ret.handle;
-
             if (callback)
                 callback(err, ret);
-
             if (!err && ret)
                 ret.emit('attach', ret);
         }
-    
-        cb.response = new Database(this);
+        cb.response = new database_1.default(this);
         this._queueEvent(cb);
     }
-
-
     dropDatabase(callback) {
         var msg = this._msg;
         msg.pos = 0;
-    
-        msg.addInt(Const.op_drop_database);
+        msg.addInt(const_1.default.op_drop_database);
         msg.addInt(this.dbhandle);
-    
         var self = this;
-        this._queueEvent(function(err) {
-            self.detach(function() {
+        this._queueEvent(function (err) {
+            self.detach(function () {
                 self.disconnect();
-    
                 if (callback)
                     callback(err);
             });
         });
     }
-
-
     throwClosed(callback) {
         var err = new Error('Connection is closed.');
         this.db.emit('error', err);
@@ -635,68 +654,58 @@ class Connection {
             callback(err);
         return this;
     }
-
-
     startTransaction(options, callback) {
-    
-        if (typeof(options) === 'function') {
+        if (typeof (options) === 'function') {
             var tmp = options;
             options = callback;
             callback = tmp;
         }
-    
         // Compatibility
         if (Array.isArray(options)) {
             options = {
                 isolation: options,
-                readOnly: (options === Const.ISOLATION_READ_COMMITTED_READ_ONLY),
+                readOnly: (options === const_1.default.ISOLATION_READ_COMMITTED_READ_ONLY),
             };
         }
-    
         // Default options
         options = Object.assign({
             autoCommit: false,
             autoUndo: true,
-            isolation: Const.ISOLATION_READ_COMMITTED,
+            isolation: const_1.default.ISOLATION_READ_COMMITTED,
             ignoreLimbo: false,
             //lock: [],
             readOnly: false,
             wait: true,
             waitTimeout: 0,
         }, options);
-    
         if (this._isClosed)
             return this.throwClosed(callback);
-    
         // for auto detach
         this._pending.push('startTransaction');
-    
         var blr = this._blr;
         var msg = this._msg;
-    
         blr.pos = 0;
         msg.pos = 0;
-    
-        blr.addByte(Const.isc_tpb_version3);
+        blr.addByte(const_1.default.isc_tpb_version3);
         blr.addBytes(options.isolation);
-        blr.addByte(options.readOnly ? Const.isc_tpb_read : Const.isc_tpb_write);
+        blr.addByte(options.readOnly ? const_1.default.isc_tpb_read : const_1.default.isc_tpb_write);
         if (options.wait) {
-            blr.addByte(Const.isc_tpb_wait);
-    
+            blr.addByte(const_1.default.isc_tpb_wait);
             if (options.waitTimeout) {
-                blr.addNumeric(Const.isc_tpb_lock_timeout, options.waitTimeout);
+                blr.addNumeric(const_1.default.isc_tpb_lock_timeout, options.waitTimeout);
             }
-        } else {
-            blr.addByte(Const.isc_tpb_nowait);
+        }
+        else {
+            blr.addByte(const_1.default.isc_tpb_nowait);
         }
         if (!options.autoUndo) {
-            blr.addByte(Const.isc_tpb_no_auto_undo);
+            blr.addByte(const_1.default.isc_tpb_no_auto_undo);
         }
         if (options.autoCommit) {
-            blr.addByte(Const.isc_tpb_autocommit);
+            blr.addByte(const_1.default.isc_tpb_autocommit);
         }
         if (options.ignoreLimbo) {
-            blr.addByte(Const.isc_tpb_ignore_limbo);
+            blr.addByte(const_1.default.isc_tpb_ignore_limbo);
         }
         // TODO
         /*if (options.lock.length) {
@@ -708,139 +717,98 @@ class Connection {
                 blr.addByte(lockType);
             }
         }*/
-    
-        msg.addInt(Const.op_transaction);
+        msg.addInt(const_1.default.op_transaction);
         msg.addInt(this.dbhandle);
         msg.addBlr(blr);
-        callback.response = new Transaction(this);
-    
+        callback.response = new transaction_1.default(this);
         this.db.emit('transaction', options);
         this._queueEvent(callback);
     }
-
-
     commit(transaction, callback) {
-    
         if (this._isClosed)
             return this.throwClosed(callback);
-    
         // for auto detach
         this._pending.push('commit');
-    
         var msg = this._msg;
         msg.pos = 0;
-        msg.addInt(Const.op_commit);
+        msg.addInt(const_1.default.op_commit);
         msg.addInt(transaction.handle);
         this.db.emit('commit');
         this._queueEvent(callback);
     }
-
-
     rollback(transaction, callback) {
-    
         if (this._isClosed)
             return this.throwClosed(callback);
-    
         // for auto detach
         this._pending.push('rollback');
-    
         var msg = this._msg;
         msg.pos = 0;
-        msg.addInt(Const.op_rollback);
+        msg.addInt(const_1.default.op_rollback);
         msg.addInt(transaction.handle);
         this.db.emit('rollback');
         this._queueEvent(callback);
     }
-
-
     commitRetaining(transaction, callback) {
-    
         if (this._isClosed)
-            throw new Error('Connection is closed.');
-    
+            return this.throwClosed(callback);
         // for auto detach
         this._pending.push('commitRetaining');
-    
         var msg = this._msg;
         msg.pos = 0;
-        msg.addInt(Const.op_commit_retaining);
+        msg.addInt(const_1.default.op_commit_retaining);
         msg.addInt(transaction.handle);
         this._queueEvent(callback);
     }
-
-
     rollbackRetaining(transaction, callback) {
-    
         if (this._isClosed)
             return this.throwClosed(callback);
-    
         // for auto detach
         this._pending.push('rollbackRetaining');
-    
         var msg = this._msg;
         msg.pos = 0;
-        msg.addInt(Const.op_rollback_retaining);
+        msg.addInt(const_1.default.op_rollback_retaining);
         msg.addInt(transaction.handle);
         this._queueEvent(callback);
     }
-
-
     allocateStatement(callback) {
-    
         if (this._isClosed)
             return this.throwClosed(callback);
-    
         // for auto detach
         this._pending.push('allocateStatement');
-    
         var msg = this._msg;
         msg.pos = 0;
-        msg.addInt(Const.op_allocate_statement);
+        msg.addInt(const_1.default.op_allocate_statement);
         msg.addInt(this.dbhandle);
-        callback.response = new Statement(this);
+        callback.response = new statement_1.default(this);
         this._queueEvent(callback);
     }
-
-
     dropStatement(statement, callback) {
-    
         if (this._isClosed)
             return this.throwClosed(callback);
-    
         // for auto detach
         this._pending.push('dropStatement');
-    
         var msg = this._msg;
         msg.pos = 0;
-        msg.addInt(Const.op_free_statement);
+        msg.addInt(const_1.default.op_free_statement);
         msg.addInt(statement.handle);
-        msg.addInt(Const.DSQL_drop);
-    
+        msg.addInt(const_1.default.DSQL_drop);
         this._queueEvent(callback, true);
     }
-
-
     closeStatement(statement, callback) {
-    
         if (this._isClosed)
             return this.throwClosed(callback);
-    
         // for auto detach
         this._pending.push('closeStatement');
-    
         var msg = this._msg;
         msg.pos = 0;
-        msg.addInt(Const.op_free_statement);
+        msg.addInt(const_1.default.op_free_statement);
         msg.addInt(statement.handle);
-        msg.addInt(Const.DSQL_close);
-    
+        msg.addInt(const_1.default.DSQL_close);
         this._queueEvent(callback, true);
     }
-
-
     allocateAndPrepareStatement(transaction, query, plan, callback) {
         var self = this;
-        var mainCallback = function(err, ret) {
+        var mainCallback = function (err, ret) {
             if (!err) {
                 mainCallback.response.handle = ret.handle;
                 describe(ret.buffer, mainCallback.response);
@@ -849,93 +817,75 @@ class Connection {
                 ret = mainCallback.response;
                 self._setcachedquery(query, ret);
             }
-    
             if (callback)
                 callback(err, ret);
         };
-    
         // for auto detach
         this._pending.push('allocateAndPrepareStatement');
-    
         var msg = this._msg;
         var blr = this._blr;
-    
         msg.pos = 0;
         blr.pos = 0;
-    
-        msg.addInt(Const.op_allocate_statement);
+        msg.addInt(const_1.default.op_allocate_statement);
         msg.addInt(this.dbhandle);
         mainCallback.lazy_count = 1;
-    
-        blr.addBytes(Const.DESCRIBE);
+        const describeBytes = this.accept.protocolVersion >= const_1.default.PROTOCOL_VERSION20 ? const_1.default.DESCRIBE_WITH_SCHEMA : const_1.default.DESCRIBE;
+        if (process.env.FIREBIRD_DEBUG) {
+            console.log('[fb-debug] describeBytes:', describeBytes);
+        }
+        blr.addBytes(describeBytes);
         if (plan)
-            blr.addByte(Const.isc_info_sql_get_plan);
-    
-        msg.addInt(Const.op_prepare_statement);
+            blr.addByte(const_1.default.isc_info_sql_get_plan);
+        msg.addInt(const_1.default.op_prepare_statement);
         msg.addInt(transaction.handle);
         msg.addInt(0xFFFF);
         msg.addInt(3); // dialect = 3
-        msg.addString(query, Const.DEFAULT_ENCODING);
+        msg.addString(query, const_1.default.DEFAULT_ENCODING);
         msg.addBlr(blr);
         msg.addInt(65535); // buffer_length
         mainCallback.lazy_count += 1;
-    
-        mainCallback.response = new Statement(this);
+        mainCallback.response = new statement_1.default(this);
         this._queueEvent(mainCallback);
     }
-
-
     prepare(transaction, query, plan, callback) {
         var self = this;
-    
-        if (this.accept.protocolMinimumType === Const.ptype_lazy_send) { // V11 Statement or higher
+        if (this.accept.protocolMinimumType === const_1.default.ptype_lazy_send) { // V11 Statement or higher
             self.allocateAndPrepareStatement(transaction, query, plan, callback);
-        } else { // V10 Statement
+        }
+        else { // V10 Statement
             self.allocateStatement(function (err, statement) {
                 if (err) {
-                    doError(err, callback);
+                    (0, callback_1.doError)(err, callback);
                     return;
                 }
-    
                 self.prepareStatement(transaction, statement, query, plan, callback);
             });
         }
     }
-
-
-
     prepareStatement(transaction, statement, query, plan, callback) {
-    
         if (this._isClosed)
             return this.throwClosed(callback);
-    
         var msg = this._msg;
         var blr = this._blr;
-    
         msg.pos = 0;
         blr.pos = 0;
-    
         if (plan instanceof Function) {
             callback = plan;
             plan = false;
         }
-    
-        blr.addBytes(Const.DESCRIBE);
-    
+        const describeBytes = this.accept.protocolVersion >= const_1.default.PROTOCOL_VERSION20 ? const_1.default.DESCRIBE_WITH_SCHEMA : const_1.default.DESCRIBE;
+        blr.addBytes(describeBytes);
         if (plan)
-            blr.addByte(Const.isc_info_sql_get_plan);
-    
-        msg.addInt(Const.op_prepare_statement);
+            blr.addByte(const_1.default.isc_info_sql_get_plan);
+        msg.addInt(const_1.default.op_prepare_statement);
         msg.addInt(transaction.handle);
         msg.addInt(statement.handle);
         msg.addInt(3); // dialect = 3
-        msg.addString(query, Const.DEFAULT_ENCODING);
+        msg.addString(query, const_1.default.DEFAULT_ENCODING);
         msg.addBlr(blr);
         msg.addInt(65535); // buffer_length
-    
         var self = this;
-        this._queueEvent(function(err, ret) {
-    
+        this._queueEvent(function (err, ret) {
             if (!err) {
                 describe(ret.buffer, statement);
                 statement.query = query;
@@ -943,75 +893,53 @@ class Connection {
                 ret = statement;
                 self._setcachedquery(query, ret);
             }
-    
             if (callback)
                 callback(err, ret);
         });
-    
     }
-
-
-
     executeStatement(transaction, statement, params, callback, custom) {
-    
         if (this._isClosed)
             return this.throwClosed(callback);
-    
         // for auto detach
         this._pending.push('executeStatement');
-    
         if (params instanceof Function) {
             callback = params;
             params = undefined;
         }
-    
         var self = this;
-    
-        var op = Const.op_execute;
-        if (
-            this.accept.protocolVersion >= Const.PROTOCOL_VERSION13 &&
-            statement.type === Const.isc_info_sql_stmt_exec_procedure &&
-            statement.output.length
-        ) {
-            op = Const.op_execute2;
+        var op = const_1.default.op_execute;
+        if (this.accept.protocolVersion >= const_1.default.PROTOCOL_VERSION13 &&
+            statement.type === const_1.default.isc_info_sql_stmt_exec_procedure &&
+            statement.output.length) {
+            op = const_1.default.op_execute2;
         }
-    
         function PrepareParams(params, input, callback) {
-
             var value, meta;
             var ret = new Array(params.length);
-
             function putBlobData(index, value, callback) {
-    
-                self.createBlob2(transaction, function(err, blob) {
-    
+                self.createBlob2(transaction, function (err, blob) {
                     var b;
                     var isStream = value.readable;
-    
                     if (Buffer.isBuffer(value))
                         b = value;
-                    else if (typeof(value) === 'string')
-                        b = Buffer.from(value, Const.DEFAULT_ENCODING);
+                    else if (typeof (value) === 'string')
+                        b = Buffer.from(value, const_1.default.DEFAULT_ENCODING);
                     else if (!isStream)
-                        b = Buffer.from(JSON.stringify(value), Const.DEFAULT_ENCODING);
-    
+                        b = Buffer.from(JSON.stringify(value), const_1.default.DEFAULT_ENCODING);
                     // Use configured transfer size or default to 1024
                     var chunkSize = self.options.blobChunkSize || 1024;
-    
                     if (Buffer.isBuffer(b)) {
                         bufferReader(b, chunkSize, function (b, next) {
                             self.batchSegments(blob, b, next);
-                        }, function() {
+                        }, function () {
                             ret[index] = new Xsql.SQLParamQuad(blob.oid);
                             self.closeBlob(blob, callback, false);
                         });
                         return;
                     }
-
                     var isReading = false;
                     var isEnd = false;
-
-                    value.on('data', function(chunk) {
+                    value.on('data', function (chunk) {
                         // Optimization: If chunk is smaller than transfer size, send directly
                         if (chunk.length <= chunkSize) {
                             self.batchSegments(blob, chunk, function () {
@@ -1022,23 +950,21 @@ class Connection {
                             });
                             return;
                         }
-
                         value.pause();
                         isReading = true;
                         bufferReader(chunk, chunkSize, function (b, next) {
                             self.batchSegments(blob, b, next);
-                        }, function() {
+                        }, function () {
                             isReading = false;
-
                             if (isEnd) {
                                 ret[index] = new Xsql.SQLParamQuad(blob.oid);
                                 self.closeBlob(blob, callback, false);
-                            } else
+                            }
+                            else
                                 value.resume();
                         });
                     });
-
-                    value.on('end', function() {
+                    value.on('end', function () {
                         isEnd = true;
                         if (isReading)
                             return;
@@ -1051,164 +977,186 @@ class Connection {
                     });
                 });
             }
-    
             function step(i) {
                 if (i === params.length) {
                     callback(ret);
                     return;
                 }
-
                 value = params[i];
                 meta = input[i];
-
+                if (statement.connection.options && statement.connection.options.jsonAsObject && value !== null && value !== undefined && typeof value === 'object' && !(value instanceof Date) && !(value instanceof Buffer)) {
+                    if (typeof value.pipe !== 'function') {
+                        value = JSON.stringify(value);
+                    }
+                }
                 if (value === null || value === undefined) {
                     switch (meta.type) {
-                        case Const.SQL_VARYING:
-                        case Const.SQL_NULL:
-                        case Const.SQL_TEXT:
+                        case const_1.default.SQL_VARYING:
+                        case const_1.default.SQL_NULL:
+                        case const_1.default.SQL_TEXT:
                             ret[i] = new Xsql.SQLParamString(null);
                             break;
-                        case Const.SQL_DOUBLE:
-                        case Const.SQL_FLOAT:
-                        case Const.SQL_D_FLOAT:
+                        case const_1.default.SQL_DOUBLE:
+                        case const_1.default.SQL_FLOAT:
+                        case const_1.default.SQL_D_FLOAT:
                             ret[i] = new Xsql.SQLParamDouble(null);
                             break;
-                        case Const.SQL_TYPE_DATE:
-                        case Const.SQL_TYPE_TIME:
-                        case Const.SQL_TIMESTAMP:
-                        case Const.SQL_TIME_TZ:
-                        case Const.SQL_TIME_TZ_EX:
-                        case Const.SQL_TIMESTAMP_TZ:
-                        case Const.SQL_TIMESTAMP_TZ_EX:
+                        case const_1.default.SQL_TYPE_DATE:
+                        case const_1.default.SQL_TYPE_TIME:
+                        case const_1.default.SQL_TIMESTAMP:
+                        case const_1.default.SQL_TIME_TZ:
+                        case const_1.default.SQL_TIME_TZ_EX:
+                        case const_1.default.SQL_TIMESTAMP_TZ:
+                        case const_1.default.SQL_TIMESTAMP_TZ_EX:
                             ret[i] = new Xsql.SQLParamDate(null);
                             break;
-                        case Const.SQL_BLOB:
-                        case Const.SQL_ARRAY:
-                        case Const.SQL_QUAD:
+                        case const_1.default.SQL_BLOB:
+                        case const_1.default.SQL_ARRAY:
+                        case const_1.default.SQL_QUAD:
                             ret[i] = new Xsql.SQLParamQuad(null);
                             break;
-                        case Const.SQL_LONG:
-                        case Const.SQL_SHORT:
-                        case Const.SQL_INT64:
-                        case Const.SQL_BOOLEAN:
+                        case const_1.default.SQL_LONG:
+                        case const_1.default.SQL_SHORT:
+                        case const_1.default.SQL_INT64:
+                        case const_1.default.SQL_BOOLEAN:
                             ret[i] = new Xsql.SQLParamInt(null);
                             break;
                         default:
                             ret[i] = null;
                     }
                     step(i + 1);
-                } else {
+                }
+                else {
                     switch (meta.type) {
-                        case Const.SQL_BLOB:
-                            putBlobData(i, value, function() { step(i + 1); });
+                        case const_1.default.SQL_BLOB:
+                            putBlobData(i, value, function () { step(i + 1); });
                             break;
-
-                        case Const.SQL_TIMESTAMP:
-                        case Const.SQL_TYPE_DATE:
-                        case Const.SQL_TYPE_TIME:
-                        case Const.SQL_TIME_TZ:
-                        case Const.SQL_TIME_TZ_EX:
-                        case Const.SQL_TIMESTAMP_TZ:
-                        case Const.SQL_TIMESTAMP_TZ_EX:
+                        case const_1.default.SQL_TIMESTAMP:
+                        case const_1.default.SQL_TYPE_DATE:
+                        case const_1.default.SQL_TYPE_TIME:
+                        case const_1.default.SQL_TIME_TZ:
+                        case const_1.default.SQL_TIME_TZ_EX:
+                        case const_1.default.SQL_TIMESTAMP_TZ:
+                        case const_1.default.SQL_TIMESTAMP_TZ_EX:
                             if (value instanceof Date)
                                 ret[i] = new Xsql.SQLParamDate(value);
-                            else if (typeof(value) === 'string')
-                                ret[i] = new Xsql.SQLParamDate(parseDate(value));
+                            else if (typeof (value) === 'string')
+                                ret[i] = new Xsql.SQLParamDate((0, utils_1.parseDate)(value));
                             else
                                 ret[i] = new Xsql.SQLParamDate(new Date(value));
-
                             step(i + 1);
                             break;
-
                         default:
-                            switch (typeof value) {
-                                case 'bigint':
-                                    ret[i] = new Xsql.SQLParamInt128(value);
-                                    break;
-                                case 'number':
-                                    if (value % 1 === 0) {
-                                        if (value >= Const.MIN_INT && value <= Const.MAX_INT)
-                                            ret[i] = new Xsql.SQLParamInt(value);
+                            if (Buffer.isBuffer(value)) {
+                                ret[i] = new Xsql.SQLParamBuffer(value);
+                            }
+                            else {
+                                switch (typeof value) {
+                                    case 'bigint':
+                                        ret[i] = new Xsql.SQLParamInt128(value);
+                                        break;
+                                    case 'number':
+                                        if (value % 1 === 0) {
+                                            if (value >= const_1.default.MIN_INT && value <= const_1.default.MAX_INT)
+                                                ret[i] = new Xsql.SQLParamInt(value);
+                                            else
+                                                ret[i] = new Xsql.SQLParamInt64(value);
+                                        }
                                         else
-                                            ret[i] = new Xsql.SQLParamInt64(value);
-                                    } else
-                                        ret[i] = new Xsql.SQLParamDouble(value);
-                                    break;
-                                case 'string':
-                                    ret[i] = new Xsql.SQLParamString(value);
-                                    break;
-                                case 'boolean':
-                                    ret[i] = new Xsql.SQLParamBool(value);
-                                    break;
-                                default:
-                                    //throw new Error('Unexpected parametter: ' + JSON.stringify(params) + ' - ' + JSON.stringify(input));
-                                    ret[i] = new Xsql.SQLParamString(value.toString());
-                                    break;
+                                            ret[i] = new Xsql.SQLParamDouble(value);
+                                        break;
+                                    case 'string':
+                                        ret[i] = new Xsql.SQLParamString(value);
+                                        break;
+                                    case 'boolean':
+                                        ret[i] = new Xsql.SQLParamBool(value);
+                                        break;
+                                    default:
+                                        //throw new Error('Unexpected parametter: ' + JSON.stringify(params) + ' - ' + JSON.stringify(input));
+                                        ret[i] = new Xsql.SQLParamString(value.toString());
+                                        break;
+                                }
                             }
                             step(i + 1);
                     }
                 }
             }
-
             step(0);
         }
-    
         var input = statement.input;
-    
         if (input.length) {
-    
             if (!(params instanceof Array)) {
-                if (params !== undefined)
+                if (params !== undefined && typeof params === 'object' && params !== null) {
+                    var mappedParams = [];
+                    for (var i = 0; i < input.length; i++) {
+                        mappedParams.push(undefined);
+                    }
+                    var matchedCount = 0;
+                    var nameMap = {};
+                    for (var i = 0; i < input.length; i++) {
+                        var name = input[i].alias || input[i].field;
+                        if (name) {
+                            nameMap[name.toUpperCase()] = i;
+                        }
+                    }
+                    for (var key in params) {
+                        if (Object.prototype.hasOwnProperty.call(params, key)) {
+                            var cleanKey = key.startsWith(':') ? key.substring(1) : key;
+                            var index = nameMap[cleanKey.toUpperCase()];
+                            if (index !== undefined) {
+                                mappedParams[index] = params[key];
+                                matchedCount++;
+                            }
+                        }
+                    }
+                    if (matchedCount > 0) {
+                        params = mappedParams;
+                    }
+                    else {
+                        params = [params];
+                    }
+                }
+                else if (params !== undefined) {
                     params = [params];
-                else
+                }
+                else {
                     params = [];
+                }
             }
-    
             if (params.length !== input.length) {
                 self._pending.pop();
                 callback(new Error('Expected parameters: (params=' + params.length + ' vs. expected=' + input.length + ') - ' + statement.query));
                 return;
             }
-    
-            PrepareParams(params, input, function(prms) {
+            PrepareParams(params, input, function (prms) {
                 self.sendExecute(op, statement, transaction, callback, prms);
             });
-    
             return;
         }
-    
         this.sendExecute(op, statement, transaction, callback);
     }
-
-
     sendExecute(op, statement, transaction, callback, parameters) {
         var msg = this._msg;
         var blr = this._blr;
         msg.pos = 0;
         blr.pos = 0;
-    
         msg.addInt(op);
         msg.addInt(statement.handle);
         msg.addInt(transaction.handle);
-    
         if (parameters && parameters.length) {
             CalcBlr(blr, parameters);
-            msg.addBlr(blr);    // params blr
+            msg.addBlr(blr); // params blr
             msg.addInt(0); // message number
             msg.addInt(1); // param count
-    
-            if (this.accept.protocolVersion >= Const.PROTOCOL_VERSION13) {
+            if (this.accept.protocolVersion >= const_1.default.PROTOCOL_VERSION13) {
                 // start with null indicator bitmap
-                var nullBits = new BitSet();
-    
+                var nullBits = new serialize_1.BitSet();
                 for (var i = 0; i < parameters.length; i++) {
-                    nullBits.set(i, (parameters[i].value === null) & 1);
+                    nullBits.set(i, parameters[i].value === null ? 1 : 0);
                 }
-    
                 var nullBuffer = nullBits.toBuffer();
                 var requireBytes = Math.floor((parameters.length + 7) / 8);
                 var remainingBytes = requireBytes - nullBuffer.length;
-    
                 if (nullBuffer.length) {
                     msg.addBuffer(nullBuffer);
                 }
@@ -1216,75 +1164,124 @@ class Connection {
                     msg.addBuffer(Buffer.alloc(remainingBytes));
                 }
                 msg.addAlignment(requireBytes);
-    
-                for(var i = 0; i < parameters.length; i++) {
+                for (var i = 0; i < parameters.length; i++) {
                     if (parameters[i].value !== null) {
                         parameters[i].encode(msg);
                     }
                 }
-            } else {
-                for(var i = 0; i < parameters.length; i++) {
+            }
+            else {
+                for (var i = 0; i < parameters.length; i++) {
                     parameters[i].encode(msg);
                     if (parameters[i].value !== null) {
                         msg.addInt(0);
                     }
                 }
             }
-        } else {
-            msg.addBlr(blr);    // empty
+        }
+        else {
+            msg.addBlr(blr); // empty
             msg.addInt(0); // message number
             msg.addInt(0); // param count
         }
-    
-        if (op === Const.op_execute2) {
-            var outputBlr = new BlrWriter(32);
-    
+        if (op === const_1.default.op_execute2) {
+            var outputBlr = new serialize_1.BlrWriter(32);
             if (statement.output && statement.output.length) {
                 CalcBlr(outputBlr, statement.output);
                 msg.addBlr(outputBlr);
-            } else {
+            }
+            else {
                 msg.addBlr(outputBlr); // empty
             }
             msg.addInt(0); // out_message_number = out_message_type
         }
-
-        if (this.accept.protocolVersion >= Const.PROTOCOL_VERSION16) {
+        if (this.accept.protocolVersion >= const_1.default.PROTOCOL_VERSION16) {
             // TODO impl statement timout
             msg.addInt(statement.options?.timeout || 0); // p_sqldata_timeout
         }
-    
+        if (this.accept.protocolVersion >= const_1.default.PROTOCOL_VERSION18) {
+            msg.addInt(statement.options?.scrollable ? 1 : 0); // p_sqldata_cursor_flags (1 = CURSOR_TYPE_SCROLLABLE)
+        }
+        if (this.accept.protocolVersion >= const_1.default.PROTOCOL_VERSION19) {
+            msg.addInt(statement.options?.maxInlineBlobSize !== undefined ? statement.options.maxInlineBlobSize : (this.options?.maxInlineBlobSize || 0)); // p_sqldata_inline_blob_size
+        }
         callback.statement = statement;
         this._queueEvent(callback);
     }
-
-
-
-
     fetch(statement, transaction, count, callback) {
-    
         var msg = this._msg;
         var blr = this._blr;
-    
         msg.pos = 0;
         blr.pos = 0;
-    
         if (count instanceof Function) {
             callback = count;
-            count = Const.DEFAULT_FETCHSIZE;
+            count = const_1.default.DEFAULT_FETCHSIZE;
         }
-    
-        msg.addInt(Const.op_fetch);
+        msg.addInt(const_1.default.op_fetch);
         msg.addInt(statement.handle);
         CalcBlr(blr, statement.output);
         msg.addBlr(blr);
         msg.addInt(0); // message number
-        msg.addInt(count || Const.DEFAULT_FETCHSIZE); // fetch count
-    
+        msg.addInt(count || const_1.default.DEFAULT_FETCHSIZE); // fetch count
+        callback.statement = statement;
+        this._queueEvent(callback);
+    }
+    fetchScroll(statement, transaction, direction, offset, count, callback) {
+        if (typeof count === 'function') {
+            callback = count;
+            count = undefined;
+        }
+        if (typeof offset === 'function') {
+            callback = offset;
+            offset = undefined;
+            count = undefined;
+        }
+        var msg = this._msg;
+        var blr = this._blr;
+        msg.pos = 0;
+        blr.pos = 0;
+        let dirInt = 0;
+        if (typeof direction === 'number') {
+            dirInt = direction;
+        }
+        else if (typeof direction === 'string') {
+            const dirUpper = direction.toUpperCase();
+            switch (dirUpper) {
+                case 'NEXT':
+                    dirInt = 0;
+                    break;
+                case 'PRIOR':
+                    dirInt = 1;
+                    break;
+                case 'FIRST':
+                    dirInt = 2;
+                    break;
+                case 'LAST':
+                    dirInt = 3;
+                    break;
+                case 'ABSOLUTE':
+                    dirInt = 4;
+                    break;
+                case 'RELATIVE':
+                    dirInt = 5;
+                    break;
+                default:
+                    throw new Error('Invalid fetch direction: ' + direction);
+            }
+        }
+        const offsetVal = offset || 0;
+        const fetchCount = count || 1;
+        msg.addInt(const_1.default.op_fetch_scroll);
+        msg.addInt(statement.handle);
+        CalcBlr(blr, statement.output);
+        msg.addBlr(blr);
+        msg.addInt(0); // message number
+        msg.addInt(fetchCount); // fetch count
+        msg.addInt(dirInt); // fetch operation
+        msg.addInt(offsetVal); // fetch position (offset)
         callback.statement = statement;
         this._queueEvent(callback);
     }
-
-
     fetchAll(statement, transaction, callback) {
         const self = this;
         const custom = statement.options || {};
@@ -1296,7 +1293,6 @@ class Connection {
                 callback(err);
                 return;
             }
-
             if (ret && ret.data && ret.data.length) {
                 // Read blobs sequentially instead of in parallel to avoid
                 // exceeding Firebird's per-connection open-blob-handle limit,
@@ -1312,18 +1308,17 @@ class Connection {
                         return readBlobsSequentially(index + 1, results);
                     });
                 };
-
                 readBlobsSequentially(0, []).then((arrBlob) => {
                     for (let i = 0; i < arrBlob.length; i++) {
                         const blob = arrBlob[i];
-                        ret.data[blob.row][blob.column] = blob.value;
+                        ret.data[blob.row][blob.column] = parseValueIfJson(blob.value, statement.connection.options);
                     }
-
                     doSynchronousLoop(ret.data, (row, _i, next) => {
                         const pos = asStream ? streamIndex++ : (data.push(row) - 1);
                         if (asStream) {
                             executeStreamRow(custom, row, pos, statement.output, next);
-                        } else {
+                        }
+                        else {
                             next();
                         }
                     }, (streamErr) => {
@@ -1331,247 +1326,209 @@ class Connection {
                             callback(streamErr);
                             return;
                         }
-
                         if (ret.fetched) {
                             callback(undefined, data || []);
-                        } else {
-                            self.fetch(statement, transaction, Const.DEFAULT_FETCHSIZE, loop);
+                        }
+                        else {
+                            self.fetch(statement, transaction, const_1.default.DEFAULT_FETCHSIZE, loop);
                         }
                     });
                 }).catch(callback);
                 return;
             }
-
             if (ret && ret.fetched) {
                 callback(undefined, data || []);
-            } else {
-                self.fetch(statement, transaction, Const.DEFAULT_FETCHSIZE, loop);
+            }
+            else {
+                self.fetch(statement, transaction, const_1.default.DEFAULT_FETCHSIZE, loop);
             }
         };
-
-        this.fetch(statement, transaction, Const.DEFAULT_FETCHSIZE, loop);
+        this.fetch(statement, transaction, const_1.default.DEFAULT_FETCHSIZE, loop);
     }
-
-
-
     openBlob(blob, transaction, callback) {
         var msg = this._msg;
         msg.pos = 0;
-        msg.addInt(Const.op_open_blob);
+        msg.addInt(const_1.default.op_open_blob);
         msg.addInt(transaction.handle);
         msg.addQuad(blob);
         this._queueEvent(callback);
     }
-
-
     closeBlob(blob, callback, defer = true) {
         var msg = this._msg;
         msg.pos = 0;
-        msg.addInt(Const.op_close_blob);
+        msg.addInt(const_1.default.op_close_blob);
         msg.addInt(blob.handle);
         this._queueEvent(callback, defer);
     }
-
-
     getSegment(blob, callback) {
         var msg = this._msg;
         msg.pos = 0;
-        msg.addInt(Const.op_get_segment);
+        msg.addInt(const_1.default.op_get_segment);
         msg.addInt(blob.handle);
         msg.addInt(this.options.blobReadChunkSize || 1024); // buffer length (max 65535)
         msg.addInt(0); // ???
         this._queueEvent(callback);
     }
-
-
     createBlob2(transaction, callback) {
         var msg = this._msg;
         msg.pos = 0;
-        msg.addInt(Const.op_create_blob2);
+        msg.addInt(const_1.default.op_create_blob2);
         msg.addInt(0);
         msg.addInt(transaction.handle);
         msg.addInt(0);
         msg.addInt(0);
         this._queueEvent(callback);
     }
-
-
     batchSegments(blob, buffer, callback) {
         var msg = this._msg;
         var blr = this._blr;
         msg.pos = 0;
         blr.pos = 0;
-        msg.addInt(Const.op_batch_segments);
+        msg.addInt(const_1.default.op_batch_segments);
         msg.addInt(blob.handle);
         msg.addInt(buffer.length + 2);
         blr.addBuffer(buffer);
         msg.addBlr(blr);
         this._queueEvent(callback);
     }
-
-
     svcattach(options, callback, svc) {
-        this._lowercase_keys = options.lowercase_keys || Const.DEFAULT_LOWERCASE_KEYS;
+        this._lowercase_keys = options.lowercase_keys || const_1.default.DEFAULT_LOWERCASE_KEYS;
         var database = options.database || options.filename;
-        var user = options.user || Const.DEFAULT_USER;
-        var password = options.password || Const.DEFAULT_PASSWORD;
+        var user = options.user || const_1.default.DEFAULT_USER;
+        var password = options.password || const_1.default.DEFAULT_PASSWORD;
         var role = options.role;
         var msg = this._msg;
         var blr = this._blr;
         msg.pos = 0;
         blr.pos = 0;
-    
-        blr.addBytes([Const.isc_dpb_version2, Const.isc_dpb_version2]);
-        blr.addString(Const.isc_dpb_lc_ctype, 'UTF8', Const.DEFAULT_ENCODING);
-        
+        blr.addBytes([const_1.default.isc_dpb_version2, const_1.default.isc_dpb_version2]);
+        blr.addString(const_1.default.isc_dpb_lc_ctype, 'UTF8', const_1.default.DEFAULT_ENCODING);
         // For Firebird 3+ (protocol 13+), add UTF-8 filename flag to ensure all DPB strings are handled with UTF-8
-        if (this.accept.protocolVersion >= Const.PROTOCOL_VERSION13) {
-            blr.addByte(Const.isc_dpb_utf8_filename);
+        if (this.accept.protocolVersion >= const_1.default.PROTOCOL_VERSION13) {
+            blr.addByte(const_1.default.isc_dpb_utf8_filename);
             blr.addByte(0);
         }
-        
-        blr.addString(Const.isc_dpb_user_name, user, Const.DEFAULT_ENCODING);
-        blr.addString(Const.isc_dpb_password, password, Const.DEFAULT_ENCODING);
-        blr.addByte(Const.isc_dpb_dummy_packet_interval);
+        blr.addString(const_1.default.isc_dpb_user_name, user, const_1.default.DEFAULT_ENCODING);
+        blr.addString(const_1.default.isc_dpb_password, password, const_1.default.DEFAULT_ENCODING);
+        blr.addByte(const_1.default.isc_dpb_dummy_packet_interval);
         blr.addByte(4);
         blr.addBytes([120, 10, 0, 0]); // FROM DOT NET PROVIDER
         if (role)
-            blr.addString(Const.isc_dpb_sql_role_name, role, Const.DEFAULT_ENCODING);
-    
-        msg.addInt(Const.op_service_attach);
+            blr.addString(const_1.default.isc_dpb_sql_role_name, role, const_1.default.DEFAULT_ENCODING);
+        msg.addInt(const_1.default.op_service_attach);
         msg.addInt(0);
-        msg.addString(Const.DEFAULT_SVC_NAME, Const.DEFAULT_ENCODING); // only local for moment
+        msg.addString(const_1.default.DEFAULT_SVC_NAME, const_1.default.DEFAULT_ENCODING); // only local for moment
         msg.addBlr(this._blr);
-    
         var self = this;
-    
         function cb(err, ret) {
-    
             if (err) {
-                doError(err, callback);
+                (0, callback_1.doError)(err, callback);
                 return;
             }
-    
             self.svchandle = ret.handle;
             if (callback)
                 callback(undefined, ret);
         }
-    
         // For reconnect
         if (svc) {
             svc.connection = this;
             cb.response = svc;
-        } else {
-            cb.response = new ServiceManager(this);
+        }
+        else {
+            cb.response = new service_1.default(this);
             cb.response.removeAllListeners('error');
-            cb.response.on('error', noop);
+            cb.response.on('error', utils_1.noop);
         }
-    
         this._queueEvent(cb);
     }
-
-
     svcstart(spbaction, callback) {
         var msg = this._msg;
         var blr = this._blr;
         msg.pos = 0;
-        msg.addInt(Const.op_service_start);
+        msg.addInt(const_1.default.op_service_start);
         msg.addInt(this.svchandle);
-        msg.addInt(0)
+        msg.addInt(0);
         msg.addBlr(spbaction);
         this._queueEvent(callback);
     }
-
-
-    svcquery(spbquery, resultbuffersize, timeout,callback) {
-        if (resultbuffersize > Const.MAX_BUFFER_SIZE) {
-            doError(new Error('Buffer is too big'), callback);
+    svcquery(spbquery, resultbuffersize, timeout, callback) {
+        if (resultbuffersize > const_1.default.MAX_BUFFER_SIZE) {
+            (0, callback_1.doError)(new Error('Buffer is too big'), callback);
             return;
         }
-    
         var msg = this._msg;
         var blr = this._blr;
         msg.pos = 0;
         blr.pos = 0;
-        blr.addByte(Const.isc_spb_current_version);
+        blr.addByte(const_1.default.isc_spb_current_version);
         //blr.addByteInt32(Const.isc_info_svc_timeout, timeout);
-        msg.addInt(Const.op_service_info);
+        msg.addInt(const_1.default.op_service_info);
         msg.addInt(this.svchandle);
         msg.addInt(0);
         msg.addBlr(blr);
-        blr.pos = 0
+        blr.pos = 0;
         blr.addBytes(spbquery);
         msg.addBlr(blr);
         msg.addInt(resultbuffersize);
         this._queueEvent(callback);
     }
-
-
     svcdetach(callback) {
         var self = this;
-    
-        if (self._isClosed)
+        if (self._isClosed) {
+            (0, callback_1.doError)(new Error('Connection is closed.'), callback);
             return;
-    
+        }
         self._isUsed = false;
         self._isDetach = true;
-    
         var msg = self._msg;
-    
         msg.pos = 0;
-        msg.addInt(Const.op_service_detach);
+        msg.addInt(const_1.default.op_service_detach);
         msg.addInt(this.svchandle); // Database Object ID
-    
         self._queueEvent(function (err, ret) {
             delete (self.svchandle);
             if (callback)
                 callback(err, ret);
         });
     }
-
-
-
-    auxConnection(callback) {
+    auxConnection(eventid, callback) {
+        if (typeof eventid === 'function') {
+            // Preserve the older auxConnection(callback) call shape; plain
+            // auxiliary connections historically used event id 0.
+            callback = eventid;
+            eventid = 0;
+        }
         var self = this;
         if (self._isClosed)
             return this.throwClosed(callback);
         var msg = self._msg;
         msg.pos = 0;
-        msg.addInt(Const.op_connect_request);
+        msg.addInt(const_1.default.op_connect_request);
         msg.addInt(1); // async
         msg.addInt(self.dbhandle);
-        msg.addInt(0);
+        msg.addInt(eventid);
         if (process.env.FIREBIRD_DEBUG) {
-            console.log('[fb-debug] auxConnection: sending op_connect_request(53) dbhandle=%d queue_before=%d xdr_saved=%s',
-                self.dbhandle, self._queue.length, Boolean(self._xdr));
+            console.log('[fb-debug] auxConnection: sending op_connect_request(53) dbhandle=%d eventid=%d queue_before=%d xdr_saved=%s', self.dbhandle, eventid, self._queue.length, Boolean(self._xdr));
         }
         function cb(err, ret) {
-    
             if (err) {
                 if (process.env.FIREBIRD_DEBUG) {
                     console.log('[fb-debug] auxConnection: op_connect_request error: %s queue=%d', err.message, self._queue.length);
                 }
-                doError(err, callback);
+                (0, callback_1.doError)(err, callback);
                 return;
             }
-    
             var socket_info = {
                 family: ret.buffer.readInt16BE(0),
                 port: ret.buffer.readUInt16BE(2),
                 host: ret.buffer.readUInt8(4) + '.' + ret.buffer.readUInt8(5) + '.' + ret.buffer.readUInt8(6) + '.' + ret.buffer.readUInt8(7)
-            }
-
+            };
             if (process.env.FIREBIRD_DEBUG) {
-                console.log('[fb-debug] auxConnection: op_response ok → aux family=%d port=%d host=%s queue=%d',
-                    socket_info.family, socket_info.port, socket_info.host, self._queue.length);
+                console.log('[fb-debug] auxConnection: op_response ok → aux family=%d port=%d host=%s queue=%d', socket_info.family, socket_info.port, socket_info.host, self._queue.length);
             }
-    
             callback(undefined, socket_info);
         }
         this._queueEvent(cb);
     }
-
-
     queEvents(events, eventid, callback) {
         var self = this;
         if (this._isClosed)
@@ -1580,189 +1537,184 @@ class Connection {
         var blr = this._blr;
         blr.pos = 0;
         msg.pos = 0;
-        msg.addInt(Const.op_que_events);
+        msg.addInt(const_1.default.op_que_events);
         msg.addInt(this.dbhandle);
         // prepare EPB
-        blr.addByte(1) // epb_version
+        blr.addByte(1); // epb_version
         for (var event in events) {
-            var event_buffer = Buffer.from(event, 'UTF8');
+            var event_buffer = Buffer.from(event, 'utf8');
             blr.addByte(event_buffer.length);
             blr.addBytes(event_buffer);
             blr.addInt32(events[event]);
         }
-        msg.addBlr(blr);    // epb    
-        msg.addInt(0);    // ast
-        msg.addInt(0);   // args
+        msg.addBlr(blr); // epb    
+        msg.addInt(0); // ast
+        msg.addInt(0); // args
         msg.addInt(eventid);
-        
         function cb(err, ret) {
             if (err) {
-                doError(err, callback);
+                (0, callback_1.doError)(err, callback);
                 return;
             }
-            
             callback(null, ret);
         }
-        
         this._queueEvent(cb);
     }
-
-
     closeEvents(eventid, callback) {
         var self = this;
         if (this._isClosed)
             return this.throwClosed(callback);
         var msg = self._msg;
         msg.pos = 0;
-        msg.addInt(Const.op_cancel_events);
+        msg.addInt(const_1.default.op_cancel_events);
         msg.addInt(self.dbhandle);
         msg.addInt(eventid);
-    
         function cb(err, ret) {
             if (err) {
-                doError(err, callback);
+                (0, callback_1.doError)(err, callback);
                 return;
             }
-    
             callback(null);
         }
-    
         this._queueEvent(cb);
     }
-
 }
-
 // Reverse-lookup table: opcode number → name for FIREBIRD_DEBUG trace logging.
-const opcodeNames = Object.fromEntries(
-    Object.entries(Const).filter(([k]) => k.startsWith('op_')).map(([k, v]) => [v, k])
-);
-
+const opcodeNames = Object.fromEntries(Object.entries(const_1.default).filter(([k]) => k.startsWith('op_')).map(([k, v]) => [v, k]));
 function decodeResponse(data, callback, cnx, lowercase_keys, cb) {
     try {
         do {
             var r = data.r || data.readInt();
-        } while (r === Const.op_dummy);
-
+            if (data.r) {
+                data.r = null;
+            }
+            if (r === const_1.default.op_dummy) {
+                continue;
+            }
+            if (r === const_1.default.op_inline_blob) {
+                if (process.env.FIREBIRD_DEBUG) {
+                    console.log('[fb-debug] decodeResponse: opcode=op_inline_blob');
+                }
+                var tran_id = data.readInt();
+                var blob_id = data.readQuad();
+                var blob_data = data.readArray();
+                if (!cnx._inlineBlobs) {
+                    cnx._inlineBlobs = new Map();
+                }
+                const cacheKey = `${blob_id.high}:${blob_id.low}`;
+                cnx._inlineBlobs.set(cacheKey, blob_data);
+                r = const_1.default.op_dummy; // Continue loop to read next opcode
+            }
+        } while (r === const_1.default.op_dummy);
         if (process.env.FIREBIRD_DEBUG) {
-            console.log('[fb-debug] decodeResponse: opcode=%d(%s) pos=%d buflen=%d',
-                r, opcodeNames[r] || 'unknown', data.pos, data.buffer.length);
+            console.log('[fb-debug] decodeResponse: opcode=%d(%s) pos=%d buflen=%d', r, opcodeNames[r] || 'unknown', data.pos, data.buffer.length);
         }
-
         var item, op, response;
-
         switch (r) {
-            case Const.op_response:
-
+            case const_1.default.op_response:
                 if (callback) {
                     response = callback.response || {};
-                } else {
+                }
+                else {
                     response = {};
                 }
-
                 let loop = function (err) {
                     if (err) {
                         return cb(err);
-                    } else {
+                    }
+                    else {
                         if (callback && callback.lazy_count) {
                             callback.lazy_count--;
                             if (callback.lazy_count > 0) {
                                 r = data.readInt(); // Read new op
                                 parseOpResponse(data, response, loop);
-                            } else {
+                            }
+                            else {
                                 cb(null, response);
                             }
-                        } else {
+                        }
+                        else {
                             cb(null, response);
                         }
                     }
                 };
                 // Parse normal and lazy response
                 return parseOpResponse(data, response, loop);
-            case Const.op_fetch_response:
-            case Const.op_sql_response:
+            case const_1.default.op_fetch_response:
+            case const_1.default.op_sql_response:
                 var statement = callback.statement;
                 var output = statement.output;
                 var custom = statement.options || {};
-                var isOpFetch = r === Const.op_fetch_response;
+                var isOpFetch = r === const_1.default.op_fetch_response;
                 var _xdrpos;
                 statement.nbrowsfetched = statement.nbrowsfetched || 0;
-
                 if (isOpFetch && data.fop) { // could be set when a packet is not complete
                     data.readBuffer(68); // ??
                     op = data.readInt(); // ??
                     data.fop = false;
-                    if (op === Const.op_response) {
+                    if (op === const_1.default.op_response) {
                         return parseOpResponse(data, {}, cb);
                     }
                 }
-
                 if (!isOpFetch) {
                     data.fstatus = 0;
                 }
-
                 data.fstatus = data.fstatus !== undefined ? data.fstatus : data.readInt();
                 data.fcount = data.fcount !== undefined ? data.fcount : data.readInt();
                 data.fcolumn = data.fcolumn || 0;
                 data.frow = data.frow || (custom.asObject ? {} : new Array(output.length));
                 data.frows = data.frows || [];
-
                 if (custom.asObject && !data.fcols) {
                     if (lowercase_keys) {
                         data.fcols = output.map((column) => column.alias.toLowerCase());
-                    } else {
+                    }
+                    else {
                         data.fcols = output.map((column) => column.alias);
                     }
                 }
-
                 const arrBlob = [];
-                const lowerV13 = statement.connection.accept.protocolVersion <  Const.PROTOCOL_VERSION13;
-
+                const lowerV13 = statement.connection.accept.protocolVersion < const_1.default.PROTOCOL_VERSION13;
                 while (data.fcount && (data.fstatus !== 100)) {
                     let nullBitSet;
                     if (!lowerV13) {
                         const nullBitsLen = Math.floor((output.length + 7) / 8);
-                        nullBitSet = new BitSet(data.readBuffer(nullBitsLen, false));
+                        nullBitSet = new serialize_1.BitSet(data.readBuffer(nullBitsLen, false));
                         data.readBuffer((4 - nullBitsLen) & 3, false); // Skip padding
                     }
-
                     for (let length = output.length; data.fcolumn < length; data.fcolumn++) {
                         item = output[data.fcolumn];
-
                         if (!lowerV13 && nullBitSet.get(data.fcolumn)) {
                             if (custom.asObject) {
                                 data.frow[data.fcols[data.fcolumn]] = null;
-                            } else {
+                            }
+                            else {
                                 data.frow[data.fcolumn] = null;
                             }
-
                             continue;
                         }
-
                         try {
                             _xdrpos = data.pos;
                             const key = custom.asObject ? data.fcols[data.fcolumn] : data.fcolumn;
                             const row = data.frows.length;
                             let value = item.decode(data, lowerV13, cnx.options);
-
-                            if (item.type === Const.SQL_BLOB && value !== null) {
-                                if (item.subType === Const.isc_blob_text && cnx.options.blobAsText) {
+                            if (item.type === const_1.default.SQL_BLOB && value !== null) {
+                                if (item.subType === const_1.default.isc_blob_text && cnx.options.blobAsText) {
                                     value = fetch_blob_async_transaction(statement, value, key, row);
                                     arrBlob.push(value);
-                                } else {
+                                }
+                                else {
                                     value = fetch_blob_async(statement, value, key, row);
                                 }
                             }
-
-                            data.frow[key] = value;
-                        } catch (e) {
+                            data.frow[key] = parseValueIfJson(value, cnx.options);
+                        }
+                        catch (e) {
                             // uncomplete packet read
                             data.pos = _xdrpos;
                             data.r = r;
                             return cb(new Error('Packet is not complete'));
                         }
-
                     }
-
                     data.fcolumn = 0;
                     // ToDo: emit "row" with blob subtype string decoded
                     // use: data.frow['fieldBlob'](transaction?).then(({ value }) => console.log(value))
@@ -1770,28 +1722,29 @@ function decodeResponse(data, callback, cnx, lowercase_keys, cb) {
                     statement.connection.db.emit('row', data.frow, statement.nbrowsfetched, custom.asObject);
                     data.frows.push(data.frow);
                     data.frow = custom.asObject ? {} : new Array(output.length);
-
                     try {
                         _xdrpos = data.pos;
                         if (isOpFetch) {
                             delete data.fstatus;
                             delete data.fcount;
                             op = data.readInt(); // ??
-                            if (op === Const.op_response) {
+                            if (op === const_1.default.op_response) {
                                 return parseOpResponse(data, {}, cb);
                             }
                             data.fstatus = data.readInt();
                             data.fcount = data.readInt();
-                        } else {
+                        }
+                        else {
                             data.fcount--;
-                            if (r === Const.op_sql_response) {
+                            if (r === const_1.default.op_sql_response) {
                                 op = data.readInt();
-                                if (op === Const.op_response) {
+                                if (op === const_1.default.op_response) {
                                     parseOpResponse(data, {});
                                 }
                             }
                         }
-                    } catch (e) {
+                    }
+                    catch (e) {
                         if (_xdrpos === data.pos) {
                             data.fop = true;
                         }
@@ -1800,13 +1753,12 @@ function decodeResponse(data, callback, cnx, lowercase_keys, cb) {
                     }
                     statement.nbrowsfetched++;
                 }
-
                 // ToDo: emit "result" with blob subtype string decoded
                 statement.connection.db.emit('result', data.frows, arrBlob);
-                return cb(null, {data: data.frows, fetched: Boolean(!isOpFetch || data.fstatus === 100), arrBlob});
-            case Const.op_accept:
-            case Const.op_cond_accept:
-            case Const.op_accept_data:
+                return cb(null, { data: data.frows, fetched: Boolean(!isOpFetch || data.fstatus === 100), arrBlob });
+            case const_1.default.op_accept:
+            case const_1.default.op_cond_accept:
+            case const_1.default.op_accept_data:
                 let accept = {
                     protocolVersion: data.readInt(),
                     protocolArchitecture: data.readInt(),
@@ -1816,214 +1768,224 @@ function decodeResponse(data, callback, cnx, lowercase_keys, cb) {
                     authData: '',
                     sessionKey: ''
                 };
-
-                accept.compress = (accept.protocolMinimumType & Const.pflag_compress) !== 0;
-                accept.protocolMinimumType = accept.protocolMinimumType & Const.ptype_mask;
+                accept.compress = (accept.protocolMinimumType & const_1.default.pflag_compress) !== 0;
+                accept.protocolMinimumType = accept.protocolMinimumType & const_1.default.ptype_mask;
                 //accept.compress = (accept.acceptType & pflag_compress) !== 0; // TODO Handle zlib compression
                 if (accept.protocolVersion < 0) {
-                    accept.protocolVersion = (accept.protocolVersion & Const.FB_PROTOCOL_MASK) | Const.FB_PROTOCOL_FLAG;
+                    accept.protocolVersion = (accept.protocolVersion & const_1.default.FB_PROTOCOL_MASK) | const_1.default.FB_PROTOCOL_FLAG;
                 }
-
-                if (r === Const.op_cond_accept || r === Const.op_accept_data) {
-                    var d = new BlrReader(data.readArray());
-                    accept.pluginName = data.readString(Const.DEFAULT_ENCODING);
+                if (r === const_1.default.op_cond_accept || r === const_1.default.op_accept_data) {
+                    var d = new serialize_1.BlrReader(data.readArray());
+                    accept.pluginName = data.readString(const_1.default.DEFAULT_ENCODING);
                     var is_authenticated = data.readInt();
-                    var keys = data.readString(Const.DEFAULT_ENCODING); // keys
-
+                    var keys = data.readString(const_1.default.DEFAULT_ENCODING); // keys
+                    accept.keys = keys;
                     if (is_authenticated === 0) {
                         if (cnx.options.pluginName && cnx.options.pluginName !== accept.pluginName) {
                             var errPlugin = new Error('Server don\'t accept plugin : ' + cnx.options.pluginName + ', but support : ' + accept.pluginName);
-                            doError(errPlugin, callback);
+                            (0, callback_1.doError)(errPlugin, callback);
                             return cb(errPlugin);
                         }
-
-                        if (Const.AUTH_PLUGIN_SRP_LIST.indexOf(accept.pluginName) !== -1 && !cnx.clientKeys) {
+                        if (const_1.default.AUTH_PLUGIN_SRP_LIST.indexOf(accept.pluginName) !== -1 && !cnx.clientKeys) {
                             var errPlugin = new Error('Server accepted plugin : ' + accept.pluginName + ', but client did not initialize SRP keys');
-                            doError(errPlugin, callback);
+                            (0, callback_1.doError)(errPlugin, callback);
                             return cb(errPlugin);
                         }
-
-                        if (Const.AUTH_PLUGIN_SRP_LIST.indexOf(accept.pluginName) !== -1) {
+                        if (const_1.default.AUTH_PLUGIN_SRP_LIST.indexOf(accept.pluginName) !== -1) {
                             var crypto = {
                                 Srp: 'sha1',
-                                Srp256: 'sha256'
+                                Srp256: 'sha256',
+                                Srp384: 'sha384',
+                                Srp512: 'sha512'
                             };
                             accept.srpAlgo = crypto[accept.pluginName];
-
-                            // TODO : Fallback Srp256 to Srp ?
-                            /*if (!d.buffer) {
-                                cnx.sendOpContAuth(
-                                    cnx.clientKeys.public.toString(16),
-                                    DEFAULT_ENCODING,
-                                    accept.pluginName
-                                );
-
-                                return cb(new Error('login'));
-                            }*/
-
+                            if (!d.buffer) {
+                                cnx._pendingAccept = accept;
+                                cnx.sendOpContAuth(cnx.clientKeys.public.toString(16), const_1.default.DEFAULT_ENCODING, accept.pluginName);
+                                return;
+                            }
                             // Check buffer contains salt
                             var saltLen = d.buffer.readUInt16LE(0);
                             if (saltLen > 32 * 2) {
                                 console.log('salt to long'); // TODO : Throw error
                             }
-
                             // Check buffer contains key
                             var keyLen = d.buffer.readUInt16LE(saltLen + 2);
-                            var keyStart = saltLen + 4;
-                            if (d.buffer.length - keyStart !== keyLen) {
-                                console.log('key error'); // TODO : Throw error
+                            if (d.buffer.length < saltLen + 4) {
+                                var errBuf = new Error('Invalid buffer size for ' + accept.pluginName + ' login');
+                                (0, callback_1.doError)(errBuf, callback);
+                                return cb(errBuf);
                             }
-
+                            var keyStart = (saltLen + 2 + 3) & ~3;
                             // Server keys
                             cnx.serverKeys = {
                                 salt: d.buffer.slice(2, saltLen + 2).toString('utf8'),
-                                public: BigInt('0x' + d.buffer.slice(keyStart, d.buffer.length).toString('utf8'))
+                                public: BigInt('0x' + d.buffer.slice(keyStart, d.buffer.length).toString('utf8')),
+                                pluginName: accept.pluginName
                             };
-
+                            console.log('--- DEBUG SRP Handshake ---');
+                            console.log('salt:', cnx.serverKeys.salt);
+                            console.log('server public key:', cnx.serverKeys.public.toString(16));
+                            console.log('client public key:', cnx.clientKeys.public.toString(16));
+                            console.log('client private key:', cnx.clientKeys.private.toString(16));
+                            console.log('hashAlgo:', accept.srpAlgo);
                             const _t1 = Date.now();
-                            var proof = srp.clientProof(
-                                cnx.options.user.toUpperCase(),
-                                cnx.options.password,
-                                cnx.serverKeys.salt,
-                                cnx.clientKeys.public,
-                                cnx.serverKeys.public,
-                                cnx.clientKeys.private,
-                                accept.srpAlgo
-                            );
+                            var proof = srp.clientProof(cnx.options.user.toUpperCase(), cnx.options.password, cnx.serverKeys.salt, cnx.clientKeys.public, cnx.serverKeys.public, cnx.clientKeys.private, accept.srpAlgo);
+                            console.log('client proof M1:', proof.authData.toString(16));
+                            console.log('client session key K:', proof.clientSessionKey.toString(16));
                             if (process.env.FIREBIRD_DEBUG) {
                                 console.log('[fb-debug] srp.clientProof(%s): %dms', accept.srpAlgo, Date.now() - _t1);
                             }
-
                             accept.authData = proof.authData.toString(16);
                             accept.sessionKey = proof.clientSessionKey;
-                        } else if (accept.pluginName === Const.AUTH_PLUGIN_LEGACY) {
-                            accept.authData = crypt.crypt(cnx.options.password, Const.LEGACY_AUTH_SALT).substring(2);
-                        } else {
+                        }
+                        else if (accept.pluginName === const_1.default.AUTH_PLUGIN_LEGACY) {
+                            accept.authData = crypt.crypt(cnx.options.password, const_1.default.LEGACY_AUTH_SALT).substring(2);
+                        }
+                        else {
                             return cb(new Error('Unknow auth plugin : ' + accept.pluginName));
                         }
-                    } else {
+                    }
+                    else {
                         accept.authData = '';
                         accept.sessionKey = '';
                     }
                 }
-
                 if (accept.compress) {
                     cnx._socket.enableCompression();
                 }
-
                 if (process.env.FIREBIRD_DEBUG) {
-                    console.log('[fb-debug] auth: %s received plugin=%s proto=%d t=%dms',
-                        r === Const.op_cond_accept ? 'op_cond_accept' : r === Const.op_accept_data ? 'op_accept_data' : 'op_accept',
-                        accept.pluginName, accept.protocolVersion,
-                        cnx._authStartTime ? Date.now() - cnx._authStartTime : -1);
+                    console.log('[fb-debug] auth: %s received plugin=%s proto=%d t=%dms', r === const_1.default.op_cond_accept ? 'op_cond_accept' : r === const_1.default.op_accept_data ? 'op_accept_data' : 'op_accept', accept.pluginName, accept.protocolVersion, cnx._authStartTime ? Date.now() - cnx._authStartTime : -1);
                 }
-
                 // For op_cond_accept: send op_cont_auth and wait for response
-                if (r === Const.op_cond_accept && accept.authData) {
+                if (r === const_1.default.op_cond_accept && accept.authData) {
                     cnx._pendingAccept = accept;
                     if (process.env.FIREBIRD_DEBUG) {
-                        console.log('[fb-debug] auth: sending op_cont_auth plugin=%s t=%dms',
-                            accept.pluginName, cnx._authStartTime ? Date.now() - cnx._authStartTime : -1);
+                        console.log('[fb-debug] auth: sending op_cont_auth plugin=%s t=%dms', accept.pluginName, cnx._authStartTime ? Date.now() - cnx._authStartTime : -1);
                     }
-                    cnx.sendOpContAuth(
-                        accept.authData,
-                        Const.DEFAULT_ENCODING,
-                        accept.pluginName
-                    );
+                    cnx.sendOpContAuth(accept.authData, const_1.default.DEFAULT_ENCODING, accept.pluginName);
                     return; // Don't call cb - queue stays for op_response
                 }
-
                 return cb(undefined, accept);
-            case Const.op_cont_auth:
-                var d = new BlrReader(data.readArray());
-                var pluginName = data.readString(Const.DEFAULT_ENCODING);
-                data.readString(Const.DEFAULT_ENCODING); // plist
-                data.readString(Const.DEFAULT_ENCODING); // pkey
-
+            case const_1.default.op_cont_auth:
+                var d = new serialize_1.BlrReader(data.readArray());
+                var pluginName = data.readString(const_1.default.DEFAULT_ENCODING);
+                data.readString(const_1.default.DEFAULT_ENCODING); // plist
+                data.readString(const_1.default.DEFAULT_ENCODING); // pkey
                 if (process.env.FIREBIRD_DEBUG) {
-                    console.log('[fb-debug] auth: op_cont_auth received plugin=%s pendingAccept=%s t=%dms',
-                        pluginName,
-                        cnx._pendingAccept ? cnx._pendingAccept.pluginName : 'none',
-                        cnx._authStartTime ? Date.now() - cnx._authStartTime : -1);
+                    console.log('[fb-debug] auth: op_cont_auth received plugin=%s pendingAccept=%s t=%dms', pluginName, cnx._pendingAccept ? cnx._pendingAccept.pluginName : 'none', cnx._authStartTime ? Date.now() - cnx._authStartTime : -1);
                 }
-
                 // During SRP mutual authentication, the server sends op_cont_auth
                 // with its proof (M2) after receiving the client's proof (M1).
-                // When we have an active auth exchange for this plugin, just wait
-                // for the subsequent op_accept instead of treating it as an error.
-                if (cnx._pendingAccept && cnx._pendingAccept.pluginName === pluginName) {
-                    if (process.env.FIREBIRD_DEBUG) {
-                        console.log('[fb-debug] auth: server SRP proof (M2) received, waiting for op_accept t=%dms',
-                            cnx._authStartTime ? Date.now() - cnx._authStartTime : -1);
+                // When we have an active auth exchange for this plugin:
+                if (cnx._pendingAccept && (cnx._pendingAccept.pluginName === pluginName || const_1.default.AUTH_PLUGIN_SRP_LIST.indexOf(pluginName) !== -1)) {
+                    if (cnx._pendingAccept.pluginName !== pluginName) {
+                        cnx._pendingAccept.pluginName = pluginName;
+                    }
+                    // The server can switch SRP hash variants mid-handshake: after
+                    // the client answers with e.g. Srp256, some accounts make the
+                    // server come back with a fresh op_cont_auth naming a different
+                    // SRP plugin (e.g. plain Srp/sha1), reusing the same salt/B.
+                    // That must be treated as a brand-new challenge - recomputing
+                    // the proof with the new plugin's hash algorithm - rather than
+                    // as the server's M2 proof, otherwise the client silently waits
+                    // forever for an op_accept the server will never send (#254).
+                    if (!cnx.serverKeys || cnx.serverKeys.pluginName !== pluginName) {
+                        // Check buffer contains salt
+                        var saltLen = d.buffer.readUInt16LE(0);
+                        if (saltLen > 32 * 2) {
+                            console.log('salt to long'); // TODO : Throw error
+                        }
+                        // Check buffer contains key
+                        var keyLen = d.buffer.readUInt16LE(saltLen + 2);
+                        if (d.buffer.length < saltLen + 4) {
+                            var errBuf = new Error('Invalid buffer size for ' + pluginName + ' login');
+                            (0, callback_1.doError)(errBuf, callback);
+                            return cb(errBuf);
+                        }
+                        var keyStart = (saltLen + 2 + 3) & ~3;
+                        // Server keys
+                        cnx.serverKeys = {
+                            salt: d.buffer.slice(2, saltLen + 2).toString('utf8'),
+                            public: BigInt('0x' + d.buffer.slice(keyStart, d.buffer.length).toString('utf8')),
+                            pluginName: pluginName
+                        };
+                        var crypto = {
+                            Srp: 'sha1',
+                            Srp256: 'sha256',
+                            Srp384: 'sha384',
+                            Srp512: 'sha512'
+                        };
+                        var srpAlgo = crypto[pluginName];
+                        console.log('--- DEBUG SRP Handshake ---');
+                        console.log('salt:', cnx.serverKeys.salt);
+                        console.log('server public key:', cnx.serverKeys.public.toString(16));
+                        console.log('client public key:', cnx.clientKeys.public.toString(16));
+                        console.log('client private key:', cnx.clientKeys.private.toString(16));
+                        console.log('hashAlgo:', srpAlgo);
+                        const _t1 = Date.now();
+                        var proof = srp.clientProof(cnx.options.user.toUpperCase(), cnx.options.password, cnx.serverKeys.salt, cnx.clientKeys.public, cnx.serverKeys.public, cnx.clientKeys.private, srpAlgo);
+                        if (process.env.FIREBIRD_DEBUG) {
+                            console.log('[fb-debug] srp.clientProof(%s): %dms', srpAlgo, Date.now() - _t1);
+                        }
+                        cnx._pendingAccept.authData = proof.authData.toString(16);
+                        cnx._pendingAccept.sessionKey = proof.clientSessionKey;
+                        cnx.sendOpContAuth(cnx._pendingAccept.authData, const_1.default.DEFAULT_ENCODING, pluginName);
+                        return; // wait for server SRP proof (M2) and/or op_accept
+                    }
+                    else {
+                        if (process.env.FIREBIRD_DEBUG) {
+                            console.log('[fb-debug] auth: server SRP proof (M2) received, waiting for op_accept t=%dms', cnx._authStartTime ? Date.now() - cnx._authStartTime : -1);
+                        }
+                        return; // Server SRP proof received - wait for op_accept
                     }
-                    return; // Server SRP proof received - wait for op_accept
                 }
-
                 // Firebird 4/5 (protocols 16/17) chained-auth: after the client sends
                 // the SRP M1 proof, the server sends op_cont_auth with Legacy_Auth.
                 // SRP has already established the session key; the server additionally
                 // requires a Legacy_Auth verification step before sending op_accept.
                 // Respond with Legacy_Auth credentials and wait for op_accept.
-                if (cnx._pendingAccept && pluginName === Const.AUTH_PLUGIN_LEGACY) {
+                if (cnx._pendingAccept && pluginName === const_1.default.AUTH_PLUGIN_LEGACY) {
                     if (process.env.FIREBIRD_DEBUG) {
-                        console.log('[fb-debug] auth: SRP+Legacy_Auth chained-auth (proto %d), sending Legacy_Auth credentials t=%dms',
-                            cnx._pendingAccept.protocolVersion,
-                            cnx._authStartTime ? Date.now() - cnx._authStartTime : -1);
+                        console.log('[fb-debug] auth: SRP+Legacy_Auth chained-auth (proto %d), sending Legacy_Auth credentials t=%dms', cnx._pendingAccept.protocolVersion, cnx._authStartTime ? Date.now() - cnx._authStartTime : -1);
                     }
-                    var legacyAuthData = crypt.crypt(cnx.options.password, Const.LEGACY_AUTH_SALT).substring(2);
-                    cnx.sendOpContAuth(legacyAuthData, Const.DEFAULT_ENCODING, pluginName);
+                    var legacyAuthData = crypt.crypt(cnx.options.password, const_1.default.LEGACY_AUTH_SALT).substring(2);
+                    cnx.sendOpContAuth(legacyAuthData, const_1.default.DEFAULT_ENCODING, pluginName);
                     return; // wait for op_accept
                 }
-
                 if (!cnx.options.pluginName) {
                     if (cnx.accept && cnx.accept.pluginName === pluginName) {
                         // Erreur plugin not able to connect
                         return cb(new Error("Unable to connect with plugin " + cnx.accept.pluginName));
                     }
-
-                    if (pluginName === Const.AUTH_PLUGIN_LEGACY) { // Fallback to LegacyAuth
+                    if (pluginName === const_1.default.AUTH_PLUGIN_LEGACY) { // Fallback to LegacyAuth
                         cnx.accept.pluginName = pluginName;
-                        cnx.accept.authData = crypt.crypt(cnx.options.password, Const.LEGACY_AUTH_SALT).substring(2);
-
-                        cnx.sendOpContAuth(
-                            cnx.accept.authData,
-                            Const.DEFAULT_ENCODING,
-                            pluginName
-                        );
-
-                        return {error: new Error('login')};
+                        cnx.accept.authData = crypt.crypt(cnx.options.password, const_1.default.LEGACY_AUTH_SALT).substring(2);
+                        cnx.sendOpContAuth(cnx.accept.authData, const_1.default.DEFAULT_ENCODING, pluginName);
+                        return { error: new Error('login') };
                     }
                 }
-
                 // Server sent op_cont_auth but we don't know how to handle it.
                 if (process.env.FIREBIRD_DEBUG) {
-                    console.warn('[fb-debug] auth: op_cont_auth unhandled plugin=%s pendingAccept=%s options.plugin=%s t=%dms',
-                        pluginName,
-                        cnx._pendingAccept ? cnx._pendingAccept.pluginName : 'none',
-                        cnx.options.pluginName || 'none',
-                        cnx._authStartTime ? Date.now() - cnx._authStartTime : -1);
+                    console.warn('[fb-debug] auth: op_cont_auth unhandled plugin=%s pendingAccept=%s options.plugin=%s t=%dms', pluginName, cnx._pendingAccept ? cnx._pendingAccept.pluginName : 'none', cnx.options.pluginName || 'none', cnx._authStartTime ? Date.now() - cnx._authStartTime : -1);
                 }
                 return cb(new Error('Unhandled server op_cont_auth for plugin: ' + pluginName));
-            case Const.op_crypt_key_callback:
+            case const_1.default.op_crypt_key_callback:
                 // Database encryption key callback
                 // Read server data (plugin data sent by server)
                 var serverPluginData = data.readArray();
                 data.readInt(); // p_cc_reply
-                
                 // Get client response from dbCryptConfig option
                 var clientPluginData = parseDbCryptConfig(cnx.options.dbCryptConfig);
-                
                 // Create a BlrWriter to send the response
                 // Note: BlrWriter needs initial buffer size allocation
-                var responseBlr = new BlrWriter(clientPluginData.length + 4);
+                var responseBlr = new serialize_1.BlrWriter(clientPluginData.length + 4);
                 responseBlr.addBytes(clientPluginData);
-                
                 // Send the response back to the server
                 cnx.sendOpCryptKeyCallback(responseBlr);
-                
                 // Don't call cb - wait for next operation (likely op_response or another op_crypt_key_callback)
                 return;
-            case Const.op_event:
+            case const_1.default.op_event:
                 // op_event may occasionally arrive on the main connection
                 // (e.g. Firebird routing an async notification here instead of
                 // the dedicated aux socket).  Consume all its fields so the
@@ -2036,16 +1998,16 @@ function decodeResponse(data, callback, cnx, lowercase_keys, cb) {
                 //   p_event_ast      : Int64  – AST routine pointer (0 for remote)
                 //   p_event_rid      : Int32  – remote event ID
                 {
-                    const evtDb = data.readInt();    // p_event_database
-                    data.readArray();               // p_event_items (EPB buffer)
-                    data.readInt64();               // p_event_ast
-                    const evtRid = data.readInt();  // p_event_rid
+                    const evtDb = data.readInt(); // p_event_database
+                    data.readArray(); // p_event_items (EPB buffer)
+                    data.readInt64(); // p_event_ast
+                    const evtRid = data.readInt(); // p_event_rid
                     if (process.env.FIREBIRD_DEBUG) {
                         console.log('[fb-debug] op_event on main connection: db=%d rid=%d (consumed, not queued)', evtDb, evtRid);
                     }
                 }
                 return cb(null, { _isOpEvent: true });
-            case Const.op_response_piggyback:
+            case const_1.default.op_response_piggyback:
                 // Firebird 5 (Protocol 16/17) sends op_response_piggyback (72)
                 // as an unsolicited cleanup notification after certain operations
                 // (e.g. after the EventConnection aux socket is torn down).
@@ -2059,11 +2021,12 @@ function decodeResponse(data, callback, cnx, lowercase_keys, cb) {
                 //   object  : Quad (2x Int32)
                 //   data    : Array
                 //   status  : status-vector ending with isc_arg_end
-                parseOpResponse(data, {}, function(err) {
+                parseOpResponse(data, {}, function (err) {
                     if (process.env.FIREBIRD_DEBUG) {
                         if (err) {
                             console.warn('[fb-debug] op_response_piggyback parse error:', err.message);
-                        } else {
+                        }
+                        else {
                             console.log('[fb-debug] op_response_piggyback consumed (unsolicited Firebird 5 cleanup)');
                         }
                     }
@@ -2071,15 +2034,14 @@ function decodeResponse(data, callback, cnx, lowercase_keys, cb) {
                 return cb(null, { _isOpEvent: true });
             default:
                 if (process.env.FIREBIRD_DEBUG) {
-                    console.warn('[fb-debug] unknown opcode=%d at pos=%d buflen=%d queue=%d',
-                        r, data.pos, data.buffer.length, cnx && cnx._queue ? cnx._queue.length : 0);
+                    console.warn('[fb-debug] unknown opcode=%d at pos=%d buflen=%d queue=%d', r, data.pos, data.buffer.length, cnx && cnx._queue ? cnx._queue.length : 0);
                 }
                 return cb(new Error('Unexpected:' + r));
         }
-    } catch (err) {
+    }
+    catch (err) {
         if (process.env.FIREBIRD_DEBUG) {
-            console.warn('[fb-debug] decodeResponse exception: %s (RangeError=%s) pos=%d buflen=%d',
-                err.message, err instanceof RangeError, data.pos, data.buffer.length);
+            console.warn('[fb-debug] decodeResponse exception: %s (RangeError=%s) pos=%d buflen=%d', err.message, err instanceof RangeError, data.pos, data.buffer.length);
         }
         if (err instanceof RangeError) {
             return cb(err);
@@ -2087,177 +2049,218 @@ function decodeResponse(data, callback, cnx, lowercase_keys, cb) {
         throw err;
     }
 }
-
 function parseOpResponse(data, response, cb) {
     var handle = data.readInt();
-
     if (!response.handle) {
         response.handle = handle;
     }
-
     var oid = data.readQuad();
     if (oid.low || oid.high) {
         response.oid = oid;
     }
-
     var buf = data.readArray();
     if (buf) {
         response.buffer = buf;
     }
-
     var num, op, item = {};
     while (true) {
         op = data.readInt();
-
         switch (op) {
-            case Const.isc_arg_end:
+            case const_1.default.isc_arg_end:
                 return cb ? cb(undefined, response) : response;
-            case Const.isc_arg_gds:
+            case const_1.default.isc_arg_gds:
                 num = data.readInt();
                 if (!num) {
                     break;
                 }
-
-                item = {gdscode: num};
-
+                item = { gdscode: num };
                 if (response.status) {
                     response.status.push(item);
-                } else {
+                }
+                else {
                     response.status = [item];
                 }
-
                 break;
-            case Const.isc_arg_string:
-            case Const.isc_arg_interpreted:
-            case Const.isc_arg_sql_state:
+            case const_1.default.isc_arg_string:
+            case const_1.default.isc_arg_interpreted:
+            case const_1.default.isc_arg_sql_state:
                 if (item.params) {
-                    var str = data.readString(Const.DEFAULT_ENCODING);
+                    var str = data.readString(const_1.default.DEFAULT_ENCODING);
                     item.params.push(str);
-                } else {
-                    item.params = [data.readString(Const.DEFAULT_ENCODING)];
                 }
-
+                else {
+                    item.params = [data.readString(const_1.default.DEFAULT_ENCODING)];
+                }
                 break;
-            case Const.isc_arg_number:
+            case const_1.default.isc_arg_number:
                 num = data.readInt();
-
                 if (item.params) {
                     item.params.push(num);
-                } else {
+                }
+                else {
                     item.params = [num];
                 }
-
-                if (item.gdscode === Const.isc_sqlerr) {
+                if (item.gdscode === const_1.default.isc_sqlerr) {
                     response.sqlcode = num;
                 }
-
                 break;
             default:
                 if (cb) {
-                    cb(new Error('Unexpected: ' + op))
-                } else {
+                    cb(new Error('Unexpected: ' + op));
+                }
+                else {
                     throw new Error('Unexpected: ' + op);
                 }
         }
     }
 }
-
 function describe(buff, statement) {
-    var br = new BlrReader(buff);
+    var br = new serialize_1.BlrReader(buff);
     var parameters = null;
     var type, param;
-
     while (br.pos < br.buffer.length) {
         switch (br.readByteCode()) {
-            case Const.isc_info_sql_stmt_type:
+            case const_1.default.isc_info_sql_stmt_type:
                 statement.type = br.readInt();
                 break;
-            case Const.isc_info_sql_get_plan:
-                statement.plan = br.readString(Const.DEFAULT_ENCODING);
+            case const_1.default.isc_info_sql_get_plan:
+                statement.plan = br.readString(const_1.default.DEFAULT_ENCODING);
                 break;
-            case Const.isc_info_sql_select:
+            case const_1.default.isc_info_sql_select:
                 statement.output = parameters = [];
                 break;
-            case Const.isc_info_sql_bind:
+            case const_1.default.isc_info_sql_bind:
                 statement.input = parameters = [];
                 break;
-            case Const.isc_info_sql_num_variables:
+            case const_1.default.isc_info_sql_num_variables:
                 br.readInt(); // eat int
                 break;
-            case Const.isc_info_sql_describe_vars:
-                if (!parameters) {return}
+            case const_1.default.isc_info_sql_describe_vars:
+                if (!parameters) {
+                    return;
+                }
                 br.readInt(); // eat int ?
                 var finishDescribe = false;
                 param = null;
-                while (!finishDescribe){
+                while (!finishDescribe) {
                     switch (br.readByteCode()) {
-                        case Const.isc_info_sql_describe_end:
+                        case const_1.default.isc_info_sql_describe_end:
                             break;
-                        case Const.isc_info_sql_sqlda_seq:
+                        case const_1.default.isc_info_sql_sqlda_seq:
                             var num = br.readInt();
                             break;
-                        case Const.isc_info_sql_type:
+                        case const_1.default.isc_info_sql_type:
                             type = br.readInt();
-                            switch (type&~1) {
-                                case Const.SQL_VARYING:   param = new Xsql.SQLVarString(); break;
-                                case Const.SQL_NULL:      param = new Xsql.SQLVarNull(); break;
-                                case Const.SQL_TEXT:      param = new Xsql.SQLVarText(); break;
-                                case Const.SQL_DOUBLE:    param = new Xsql.SQLVarDouble(); break;
-                                case Const.SQL_FLOAT:
-                                case Const.SQL_D_FLOAT:   param = new Xsql.SQLVarFloat(); break;
-                                case Const.SQL_TYPE_DATE: param = new Xsql.SQLVarDate(); break;
-                                case Const.SQL_TYPE_TIME: param = new Xsql.SQLVarTime(); break;
-                                case Const.SQL_TIMESTAMP: param = new Xsql.SQLVarTimeStamp(); break;
-                                case Const.SQL_TIME_TZ:   param = new Xsql.SQLVarTimeTz(); break;
-                                case Const.SQL_TIME_TZ_EX: param = new Xsql.SQLVarTimeTzEx(); break;
-                                case Const.SQL_TIMESTAMP_TZ: param = new Xsql.SQLVarTimeStampTz(); break;
-                                case Const.SQL_TIMESTAMP_TZ_EX: param = new Xsql.SQLVarTimeStampTzEx(); break;
-                                case Const.SQL_BLOB:      param = new Xsql.SQLVarBlob(); break;
-                                case Const.SQL_ARRAY:     param = new Xsql.SQLVarArray(); break;
-                                case Const.SQL_QUAD:      param = new Xsql.SQLVarQuad(); break;
-                                case Const.SQL_LONG:      param = new Xsql.SQLVarInt(); break;
-                                case Const.SQL_SHORT:     param = new Xsql.SQLVarShort(); break;
-                                case Const.SQL_INT64:     param = new Xsql.SQLVarInt64(); break;
-                                case Const.SQL_INT128:     param = new Xsql.SQLVarInt128(); break;
-                                case Const.SQL_DEC16:     param = new Xsql.SQLVarDecFloat16(); break;
-                                case Const.SQL_DEC34:     param = new Xsql.SQLVarDecFloat34(); break;
-                                case Const.SQL_BOOLEAN:   param = new Xsql.SQLVarBoolean(); break;
+                            switch (type & ~1) {
+                                case const_1.default.SQL_VARYING:
+                                    param = new Xsql.SQLVarString();
+                                    break;
+                                case const_1.default.SQL_NULL:
+                                    param = new Xsql.SQLVarNull();
+                                    break;
+                                case const_1.default.SQL_TEXT:
+                                    param = new Xsql.SQLVarText();
+                                    break;
+                                case const_1.default.SQL_DOUBLE:
+                                    param = new Xsql.SQLVarDouble();
+                                    break;
+                                case const_1.default.SQL_FLOAT:
+                                case const_1.default.SQL_D_FLOAT:
+                                    param = new Xsql.SQLVarFloat();
+                                    break;
+                                case const_1.default.SQL_TYPE_DATE:
+                                    param = new Xsql.SQLVarDate();
+                                    break;
+                                case const_1.default.SQL_TYPE_TIME:
+                                    param = new Xsql.SQLVarTime();
+                                    break;
+                                case const_1.default.SQL_TIMESTAMP:
+                                    param = new Xsql.SQLVarTimeStamp();
+                                    break;
+                                case const_1.default.SQL_TIME_TZ:
+                                    param = new Xsql.SQLVarTimeTz();
+                                    break;
+                                case const_1.default.SQL_TIME_TZ_EX:
+                                    param = new Xsql.SQLVarTimeTzEx();
+                                    break;
+                                case const_1.default.SQL_TIMESTAMP_TZ:
+                                    param = new Xsql.SQLVarTimeStampTz();
+                                    break;
+                                case const_1.default.SQL_TIMESTAMP_TZ_EX:
+                                    param = new Xsql.SQLVarTimeStampTzEx();
+                                    break;
+                                case const_1.default.SQL_BLOB:
+                                    param = new Xsql.SQLVarBlob();
+                                    break;
+                                case const_1.default.SQL_ARRAY:
+                                    param = new Xsql.SQLVarArray();
+                                    break;
+                                case const_1.default.SQL_QUAD:
+                                    param = new Xsql.SQLVarQuad();
+                                    break;
+                                case const_1.default.SQL_LONG:
+                                    param = new Xsql.SQLVarInt();
+                                    break;
+                                case const_1.default.SQL_SHORT:
+                                    param = new Xsql.SQLVarShort();
+                                    break;
+                                case const_1.default.SQL_INT64:
+                                    param = new Xsql.SQLVarInt64();
+                                    break;
+                                case const_1.default.SQL_INT128:
+                                    param = new Xsql.SQLVarInt128();
+                                    break;
+                                case const_1.default.SQL_DEC16:
+                                    param = new Xsql.SQLVarDecFloat16();
+                                    break;
+                                case const_1.default.SQL_DEC34:
+                                    param = new Xsql.SQLVarDecFloat34();
+                                    break;
+                                case const_1.default.SQL_BOOLEAN:
+                                    param = new Xsql.SQLVarBoolean();
+                                    break;
                                 default:
                                     throw new Error('Unexpected');
                             }
-                            parameters[num-1] = param;
+                            parameters[num - 1] = param;
                             param.type = type;
                             param.nullable = Boolean(param.type & 1);
                             param.type &= ~1;
                             break;
-                        case Const.isc_info_sql_sub_type:
+                        case const_1.default.isc_info_sql_sub_type:
                             param.subType = br.readInt();
                             break;
-                        case Const.isc_info_sql_scale:
+                        case const_1.default.isc_info_sql_scale:
                             param.scale = br.readInt();
                             break;
-                        case Const.isc_info_sql_length:
+                        case const_1.default.isc_info_sql_length:
                             param.length = br.readInt();
                             break;
-                        case Const.isc_info_sql_null_ind:
+                        case const_1.default.isc_info_sql_null_ind:
                             param.nullable = Boolean(br.readInt());
                             break;
-                        case Const.isc_info_sql_field:
-                            param.field = br.readString(Const.DEFAULT_ENCODING);
+                        case const_1.default.isc_info_sql_field:
+                            param.field = br.readString(const_1.default.DEFAULT_ENCODING);
                             break;
-                        case Const.isc_info_sql_relation:
-                            param.relation = br.readString(Const.DEFAULT_ENCODING);
+                        case const_1.default.isc_info_sql_relation:
+                            param.relation = br.readString(const_1.default.DEFAULT_ENCODING);
                             break;
-                        case Const.isc_info_sql_owner:
-                            param.owner = br.readString(Const.DEFAULT_ENCODING);
+                        case const_1.default.isc_info_sql_relation_schema:
+                            // Firebird 6.0 (Protocol 20+): schema that owns the
+                            // source relation.  Empty string means the default
+                            // (PUBLIC) schema or a non-schema-aware server.
+                            param.relationSchema = br.readString(const_1.default.DEFAULT_ENCODING);
                             break;
-                        case Const.isc_info_sql_alias:
-                            param.alias = br.readString(Const.DEFAULT_ENCODING);
+                        case const_1.default.isc_info_sql_owner:
+                            param.owner = br.readString(const_1.default.DEFAULT_ENCODING);
                             break;
-                        case Const.isc_info_sql_relation_alias:
-                            param.relationAlias = br.readString(Const.DEFAULT_ENCODING);
+                        case const_1.default.isc_info_sql_alias:
+                            param.alias = br.readString(const_1.default.DEFAULT_ENCODING);
                             break;
-                        case Const.isc_info_truncated:
+                        case const_1.default.isc_info_sql_relation_alias:
+                            param.relationAlias = br.readString(const_1.default.DEFAULT_ENCODING);
+                            break;
+                        case const_1.default.isc_info_truncated:
                             throw new Error('Truncated');
                         default:
                             finishDescribe = true;
@@ -2266,103 +2269,112 @@ function describe(buff, statement) {
                 }
         }
     }
+    function unpackCharSetCollation(params) {
+        if (!params)
+            return;
+        for (let i = 0; i < params.length; i++) {
+            const p = params[i];
+            if (p && (p.type === const_1.default.SQL_TEXT || p.type === const_1.default.SQL_VARYING)) {
+                if (p.subType !== undefined) {
+                    p.charSetId = p.subType & 0xFF;
+                    p.collationId = p.subType >> 8;
+                }
+            }
+        }
+    }
+    unpackCharSetCollation(statement.input);
+    unpackCharSetCollation(statement.output);
 }
-
 function CalcBlr(blr, xsqlda) {
-    blr.addBytes([Const.blr_version5, Const.blr_begin, Const.blr_message, 0]); // + message number
+    blr.addBytes([const_1.default.blr_version5, const_1.default.blr_begin, const_1.default.blr_message, 0]); // + message number
     blr.addWord(xsqlda.length * 2);
-
     for (var i = 0, length = xsqlda.length; i < length; i++) {
         xsqlda[i].calcBlr(blr);
-        blr.addByte(Const.blr_short);
+        blr.addByte(const_1.default.blr_short);
         blr.addByte(0);
     }
-
-    blr.addByte(Const.blr_end);
-    blr.addByte(Const.blr_eoc);
+    blr.addByte(const_1.default.blr_end);
+    blr.addByte(const_1.default.blr_eoc);
 }
-
 function fetch_blob_async_transaction(statement, id, column, row) {
     const infoValue = { row, column, value: '' };
-
     return (transactionArg) => {
+        const cacheKey = `${id.high}:${id.low}`;
+        if (statement.connection._inlineBlobs && statement.connection._inlineBlobs.has(cacheKey)) {
+            const data = statement.connection._inlineBlobs.get(cacheKey);
+            infoValue.value = data ? data.toString(const_1.default.DEFAULT_ENCODING) : '';
+            return Promise.resolve(infoValue);
+        }
         const singleTransaction = transactionArg === undefined;
-
         let promiseTransaction;
         if (singleTransaction) {
             promiseTransaction = new Promise((resolve, reject) => {
-                statement.connection.startTransaction(Const.ISOLATION_READ_UNCOMMITTED, (err, transaction) => {
+                statement.connection.startTransaction(const_1.default.ISOLATION_READ_UNCOMMITTED, (err, transaction) => {
                     if (err) {
                         return reject(err);
                     }
                     resolve(transaction);
                 });
             });
-        } else {
+        }
+        else {
             promiseTransaction = Promise.resolve(transactionArg);
         }
-
         return promiseTransaction.then((transaction) => {
             return new Promise((resolve, reject) => {
                 statement.connection._pending.push('openBlob');
                 statement.connection.openBlob(id, transaction, (err, blob) => {
-
                     if (err) {
                         reject(err);
                         return;
                     }
-
                     const read = () => {
                         statement.connection.getSegment(blob, (err, ret) => {
-
                             if (err) {
                                 if (singleTransaction) {
                                     transaction.rollback(() => reject(err));
-                                } else {
+                                }
+                                else {
                                     reject(err);
                                 }
                                 return;
                             }
-
                             if (ret.buffer) {
-                                const blr = new BlrReader(ret.buffer);
+                                const blr = new serialize_1.BlrReader(ret.buffer);
                                 const data = blr.readSegment();
-                                infoValue.value += data.toString(Const.DEFAULT_ENCODING);
+                                infoValue.value += data.toString(const_1.default.DEFAULT_ENCODING);
                             }
-
                             if (ret.handle !== 2) {
                                 read();
                                 return;
                             }
-
                             statement.connection.closeBlob(blob);
                             if (singleTransaction) {
                                 transaction.commit((err) => {
                                     if (err) {
                                         reject(err);
-                                    } else {
+                                    }
+                                    else {
                                         resolve(infoValue);
                                     }
                                 });
-                            } else {
+                            }
+                            else {
                                 resolve(infoValue);
                             }
                         });
                     };
-
                     read();
                 });
             });
         });
     };
 }
-
 function fetch_blob_async(statement, id, name, row) {
     const cbTransaction = (transaction, close, callback) => {
         statement.connection._pending.push('openBlob');
         statement.connection.openBlob(id, transaction, (err, blob) => {
-            let e = new Events.EventEmitter();
-
+            let e = new events_1.default.EventEmitter();
             e.pipe = (stream) => {
                 e.on('data', (chunk) => {
                     stream.write(chunk);
@@ -2371,98 +2383,110 @@ function fetch_blob_async(statement, id, name, row) {
                     stream.end();
                 });
             };
-
             if (err) {
                 return callback(err, name, e, row);
             }
-
             const read = () => {
                 statement.connection.getSegment(blob, (err, ret) => {
-
                     if (err) {
                         transaction.rollback(() => {
                             e.emit('error', err);
                         });
                         return;
                     }
-
                     if (ret.buffer) {
-                        const blr = new BlrReader(ret.buffer);
+                        const blr = new serialize_1.BlrReader(ret.buffer);
                         const data = blr.readSegment();
-
                         e.emit('data', data);
                     }
-
                     if (ret.handle !== 2) {
                         read();
                         return;
                     }
-
                     statement.connection.closeBlob(blob);
                     if (close) {
                         transaction.commit((err) => {
                             if (err) {
                                 e.emit('error', err);
-                            } else {
+                            }
+                            else {
                                 e.emit('end');
                             }
                             e = null;
                         });
-                    } else {
+                    }
+                    else {
                         e.emit('end');
                         e = null;
                     }
                 });
             };
-
             callback(err, name, e, row);
             read();
         });
     };
-
     return (transaction, callback) => {
         // callback(error, nameField, eventEmitter, row)
         const singleTransaction = callback === undefined;
+        const actualCallback = singleTransaction ? transaction : callback;
+        const cacheKey = `${id.high}:${id.low}`;
+        if (statement.connection._inlineBlobs && statement.connection._inlineBlobs.has(cacheKey)) {
+            const data = statement.connection._inlineBlobs.get(cacheKey);
+            let e = new events_1.default.EventEmitter();
+            e.pipe = (stream) => {
+                e.on('data', (chunk) => {
+                    stream.write(chunk);
+                });
+                e.on('end', () => {
+                    stream.end();
+                });
+            };
+            actualCallback(null, name, e, row);
+            setImmediate(() => {
+                if (data) {
+                    e.emit('data', data);
+                }
+                e.emit('end');
+            });
+            return;
+        }
         if (singleTransaction) {
             callback = transaction;
-            statement.connection.startTransaction(Const.ISOLATION_READ_UNCOMMITTED, (err, transaction) => {
+            statement.connection.startTransaction(const_1.default.ISOLATION_READ_UNCOMMITTED, (err, transaction) => {
                 if (err) {
                     callback(err);
                     return;
                 }
                 cbTransaction(transaction, singleTransaction, callback);
             });
-        } else {
+        }
+        else {
             cbTransaction(transaction, singleTransaction, callback);
         }
     };
 }
-
 function doSynchronousLoop(data, processData, done) {
     if (!data || !data.length) {
         done();
         return;
     }
-
     const loop = (index) => {
         processData(data[index], index, (err) => {
             if (err) {
                 done(err);
                 return;
             }
-
             const nextIndex = index + 1;
             if (nextIndex < data.length) {
                 loop(nextIndex);
-            } else {
+            }
+            else {
                 done();
             }
         });
     };
-
     loop(0);
 }
-
 function executeStreamRow(custom, row, index, output, next) {
     let done = false;
     const finish = (err) => {
@@ -2472,47 +2496,40 @@ function executeStreamRow(custom, row, index, output, next) {
         done = true;
         next(err);
     };
-
     try {
         const ret = custom.on(row, index, output, finish);
         if (custom.on.length < 4) {
             if (ret && typeof ret.then === 'function') {
                 ret.then(() => finish()).catch(finish);
-            } else {
+            }
+            else {
                 finish();
             }
-        } else if (ret && typeof ret.then === 'function') {
+        }
+        else if (ret && typeof ret.then === 'function') {
             ret.catch(finish);
         }
-    } catch (err) {
+    }
+    catch (err) {
         finish(err);
     }
 }
-
 function bufferReader(buffer, max, writer, cb, beg, end) {
-
     if (!beg)
         beg = 0;
-
     if (!end)
         end = max;
-
     if (end >= buffer.length)
         end = undefined;
-
     var b = buffer.slice(beg, end);
-
-    writer(b, function() {
-
+    writer(b, function () {
         if (end === undefined) {
             cb();
             return;
         }
-
         bufferReader(buffer, max, writer, cb, beg + max, end + max);
     });
 }
-
 /**
  * Parse dbCryptConfig option and convert to bytes.
  * Supports:
@@ -2524,20 +2541,23 @@ function parseDbCryptConfig(config) {
     if (!config) {
         return Buffer.alloc(0);
     }
-
     // Check if it's a base64 encoded value
     if (config.startsWith('base64:')) {
         const base64Value = config.substring(7);
         try {
             return Buffer.from(base64Value, 'base64');
-        } catch (e) {
+        }
+        catch (e) {
             console.error('Failed to decode base64 dbCryptConfig, returning empty buffer:', e);
             return Buffer.alloc(0);
         }
     }
-
     // Plain string - encode as UTF-8
     return Buffer.from(config, 'utf8');
 }
-
+Connection.decodeResponse = decodeResponse;
+Connection.fetch_blob_async_transaction = fetch_blob_async_transaction;
+Connection.fetch_blob_async = fetch_blob_async;
+Connection.parseValueIfJson = parseValueIfJson;
+Connection.describe = describe;
 module.exports = Connection;