node-firebird 2.16.0 → 2.16.2

package/README.md

@@ -763,16 +763,29 @@ option `numericMode` controls how those result values are exposed:
 
 | Mode | Result policy |
 | :--- | :--- |
-| `Firebird.NUMERIC_MODE_LOSSY` | INT64-backed values are returned as `number`; INT128 uses a mixed `number`/`string` path. Unsafe coefficients may lose precision. |
+| `Firebird.NUMERIC_MODE_LOSSY` | INT64-backed values are returned as `number`, losing precision beyond the safe integer range; INT128 returns a `number` for a safe coefficient and an exact scaled `string` for an unsafe one. |
 | `Firebird.NUMERIC_MODE_SAFE` | Safe coefficients are returned as `number`; unsafe coefficients as exact scaled `string`. |
 | `Firebird.NUMERIC_MODE_STRING` | All values are returned as exact scaled `string`. |
 
-`LOSSY` decodes INT64-backed values through JavaScript `Number`. INT128 uses a
-mixed number/string decoding path. For coefficients outside JavaScript's safe
-integer range, the result type can depend on the Firebird wire type and value,
-and numeric precision is not guaranteed. `LOSSY` remains the default so that
-adding `numericMode` does not silently change result types for applications
-upgrading from earlier node-firebird releases.
+`LOSSY` decodes INT64-backed values through JavaScript `Number`, so a
+coefficient beyond JavaScript's safe integer range loses digits silently.
+INT128 instead takes a mixed path: a coefficient inside the inclusive safe
+range is returned as a scaled `number`, and one outside it — in either
+direction — is returned as an exact scaled `string`, formatted just as
+`STRING` would format it. The result type of an INT128 column therefore
+depends on the value:
+
+```js
+// numericMode: LOSSY, INT128 column
+// coefficient 12345, scale -2   -> 123.45   (number)
+// coefficient -12345, scale -2  -> -123.45  (number)
+// coefficient 2^127-1, scale 0  -> '170141183460469231731687303715884105727'
+// coefficient -2^127, scale 0   -> '-170141183460469231731687303715884105728'
+```
+
+Use `SAFE` or `STRING` when a stable result type matters. `LOSSY` remains the
+default so that adding `numericMode` does not silently change result types for
+applications upgrading from earlier node-firebird releases.
 
 `SAFE` tests the raw integer coefficient against JavaScript's inclusive safe
 range (`Number.MIN_SAFE_INTEGER` through `Number.MAX_SAFE_INTEGER`) before
@@ -789,6 +802,12 @@ const db = await Firebird.attachAsync({
 // DECIMAL coefficient 420000,-4 -> '42.0000'
 ```
 
+Every declared scale is supported in all three modes, including the 18
+fractional digits an INT64-backed `NUMERIC(18,18)` allows and the 38 an INT128
+column can declare. A Firebird coefficient represents `value * 10^scale`, so
+the positive scales that dialect 1 and some legacy metadata still produce
+scale the value up rather than down.
+
 The string literals `'lossy'`, `'safe'`, and `'string'` are accepted too,
 including in connection URIs (`?numericMode=safe`). `NULL` remains `null` in
 every mode. The option does not change `FLOAT`, `DOUBLE`, `DECFLOAT`, or input
@@ -1415,6 +1434,49 @@ Firebird.attach(options, function (err, db) {
 });
 ```
 
+#### The auxiliary connection, and when `attachEvent` fails
+
+Events do **not** travel over the connection you attached with. `db.attachEvent()` sends
+`op_connect_request`; the server opens a fresh listening socket, replies with its address and
+port, and the driver dials that address as a **second, independent TCP connection**. Only once
+that aux socket is up is the `FbEventManager` created and handed to your callback.
+
+The aux port is chosen by the server and is *not* the port you connected to, so it has to be
+reachable from the client in its own right. Two deployments commonly get this wrong:
+
+- **Containers.** A Firebird container that publishes only `3050` answers `op_connect_request`
+  with an aux port nothing outside the container can reach. Pin it with `RemoteAuxPort` in
+  `firebird.conf` and publish that port too, or run the client on the same network.
+- **Firewalls.** A rule that DROPs the aux port (rather than REJECTing it) leaves the dial
+  waiting out the operating system's connect timeout — around two minutes on Linux — before
+  the failure is reported.
+
+If the server reports `0.0.0.0` or `::` as the aux address — usual when it listens on all
+interfaces — the driver dials the host from your connection options instead, so that host must
+be the one reaching the aux port.
+
+Since **2.16.2** a failed dial is reported to the attachment callback as an `Error`, exactly
+once, carrying Node's socket `code`. Earlier versions recorded it internally and never called
+back, so `attachEvent()` and `attachEventAsync()` hung indefinitely:
+
+```js
+db.attachEvent(function (err, evtmgr) {
+  if (err) {
+    // ECONNREFUSED  → aux port not reachable (unpublished container port, nothing listening)
+    // ETIMEDOUT     → aux port filtered by a firewall
+    // EHOSTUNREACH  → wrong host: the address the server reported, or your connection host
+    //                 when the server reported 0.0.0.0/::
+    console.error('event attachment failed:', err.code || err.message);
+    return;
+  }
+  // ...
+});
+```
+
+Errors on the aux socket *after* it connects are not delivered to this callback. Poll
+`evtmgr.getState().isEventConnectionOpen` if you need to detect an aux connection that dies
+mid-subscription.
+
 ### Escaping Query values
 
 ```js
@@ -1908,10 +1970,14 @@ in bytes).
 Notes:
 
 - Requires wire protocol 16+ (Firebird 4.0 or newer server).
-- Values are encoded from the statement's own parameter metadata, so
-  NUMERIC/DECIMAL scale, `BIGINT`/`INT128` (pass `BigInt`), `BOOLEAN`,
-  `TIMESTAMP`/`DATE`/`TIME`, `FLOAT`/`DOUBLE` and `DECFLOAT` all round-trip
-  exactly.
+- Values are encoded from the statement's own parameter metadata. Fixed-point
+  `NUMERIC`/`DECIMAL`, `BIGINT`, and `INT128` parameters accept numbers, decimal
+  strings, and `BigInt`. Decimal strings retain their exact digits; finite
+  numbers are interpreted through their canonical decimal representation and
+  rounded to the declared scale with ties away from zero. Use a string (or
+  `BigInt` for whole values) when the input is outside JavaScript's safe integer
+  range. `BOOLEAN`, `TIMESTAMP`/`DATE`/`TIME`, `FLOAT`/`DOUBLE`, and `DECFLOAT`
+  use their corresponding wire types.
 - `BLOB` columns accept Buffers, strings, JSON-able objects, or
   pre-created blob quad ids: values are uploaded as transaction blobs
   first — all initiated back-to-back so the blob ops pipeline on the
@@ -2406,6 +2472,21 @@ If the failure is intermittent — the same code with the same credentials succe
 
 If the failure is consistent, the credentials really don't match an account for the authentication plugin in use: check `AuthServer`/`UserManager` in `firebird.conf` and remember that SRP and Legacy user managers keep separate password stores — a user created under one plugin does not automatically exist for the other.
 
+#### `db.attachEvent()` never calls back, or hangs, in Docker or behind a firewall
+
+Upgrade to **2.16.2 or later**: before that release the driver recorded a failure to open the
+auxiliary event connection internally and never invoked the attachment callback, so
+`attachEvent()` silently stalled and `attachEventAsync()` returned a promise that never settled.
+From 2.16.2 the failure reaches your callback as an `Error` carrying Node's socket `code`.
+
+The failure itself is a reachability problem, not a driver bug, and upgrading only makes it
+visible. Firebird events use a **second TCP connection** to a port the *server* chooses, which
+is not the port you connected to, so publishing `3050` alone is not enough: pin `RemoteAuxPort`
+in `firebird.conf` and publish that port too. See
+[§ The auxiliary connection](#the-auxiliary-connection-and-when-attachevent-fails) for the full
+picture, including the `0.0.0.0`/`::` case and why a DROP firewall rule delays the error by
+roughly two minutes.
+
 ## Contributing
 
 Contributions are welcome — code, documentation, and bug reports alike.

package/lib/wire/connection.js

@@ -1194,6 +1194,17 @@ class Connection {
                 return;
             }
         }
+        // Validate fixed-point values before the BLOB pre-pass. Blob uploads
+        // write immediately, so deferring numeric validation until message
+        // encoding could leave transaction blob state behind for a batch that
+        // can never be sent.
+        try {
+            validateBatchFixedPointRows(input, rows);
+        }
+        catch (err) {
+            (0, callback_1.doError)(err, callback);
+            return;
+        }
         var self = this;
         // BLOB pre-pass: upload every Buffer/string blob value as a
         // transaction blob and replace it (in a cloned row) with the quad
@@ -3065,6 +3076,46 @@ function scaleOutputLengths(output, options) {
         p.length = Math.min(Math.floor(p.length / colWidth) * connWidth, Math.floor(0xFFFF / connWidth) * connWidth);
     }
 }
+function scaleBatchFixedPoint(value, meta, bits, column) {
+    try {
+        return Xsql.toScaledInteger(value, meta.scale, bits);
+    }
+    catch (err) {
+        var message = err instanceof Error ? err.message : String(err);
+        throw new Error('Invalid fixed-point batch value for column ' + column +
+            ' (' + (meta.field || '?') + '): ' + message);
+    }
+}
+/** Validate values whose batch wire representation is metadata-directed.
+ * This runs before BLOB uploads, which may write to the transaction as soon
+ * as executeBatch starts its asynchronous pre-pass. */
+function validateBatchFixedPointRows(input, rows) {
+    for (var i = 0; i < rows.length; i++) {
+        for (var j = 0; j < input.length; j++) {
+            var value = rows[i][j];
+            if (value === null || value === undefined)
+                continue;
+            var bits = undefined;
+            switch (input[j].type) {
+                case const_1.default.SQL_SHORT:
+                    bits = 16;
+                    break;
+                case const_1.default.SQL_LONG:
+                    bits = 32;
+                    break;
+                case const_1.default.SQL_INT64:
+                    bits = 64;
+                    break;
+                case const_1.default.SQL_INT128:
+                    bits = 128;
+                    break;
+            }
+            if (bits !== undefined) {
+                scaleBatchFixedPoint(value, input[j], bits, j + 1);
+            }
+        }
+    }
+}
 /**
  * Batch support: the engine requires every batch message to use EXACTLY the
  * statement's described input format (unlike op_execute, where the client
@@ -3104,16 +3155,6 @@ function buildBatchEncoders(input, options) {
             return (0, utils_1.parseDate)(v);
         return new Date(v);
     };
-    var scaled = function (v, scale) {
-        var n = typeof v === 'string' ? parseFloat(v) : Number(v);
-        return scale ? Math.round(n * Math.pow(10, -scale)) : n;
-    };
-    var scaledBig = function (v, scale) {
-        if (typeof v === 'bigint') {
-            return scale ? v * (10n ** BigInt(-scale)) : v;
-        }
-        return BigInt(scaled(v, scale));
-    };
     for (var j = 0; j < input.length; j++) {
         var meta = input[j];
         var column = j + 1;
@@ -3144,32 +3185,32 @@ function buildBatchEncoders(input, options) {
                 break;
             case const_1.default.SQL_SHORT:
                 // 2 bytes in the message struct (msglen), 4 on the XDR wire
-                encoders.push((function (m) {
-                    return function (msg, v) { msg.addInt(scaled(v, m.scale)); };
-                })(meta));
+                encoders.push((function (m, col) {
+                    return function (msg, v) { msg.addInt(Number(scaleBatchFixedPoint(v, m, 16, col))); };
+                })(meta, column));
                 align(2);
                 offset += 2;
                 break;
             case const_1.default.SQL_LONG:
-                encoders.push((function (m) {
-                    return function (msg, v) { msg.addInt(scaled(v, m.scale)); };
-                })(meta));
+                encoders.push((function (m, col) {
+                    return function (msg, v) { msg.addInt(Number(scaleBatchFixedPoint(v, m, 32, col))); };
+                })(meta, column));
                 align(4);
                 offset += 4;
                 break;
             case const_1.default.SQL_INT64:
-                encoders.push((function (m) {
+                encoders.push((function (m, col) {
                     return function (msg, v) {
-                        msg.addInt64(typeof v === 'bigint' ? scaledBig(v, m.scale) : scaled(v, m.scale));
+                        msg.addInt64(scaleBatchFixedPoint(v, m, 64, col));
                     };
-                })(meta));
+                })(meta, column));
                 align(8);
                 offset += 8;
                 break;
             case const_1.default.SQL_INT128:
-                encoders.push((function (m) {
-                    return function (msg, v) { msg.addInt128(scaledBig(v, m.scale)); };
-                })(meta));
+                encoders.push((function (m, col) {
+                    return function (msg, v) { msg.addInt128(scaleBatchFixedPoint(v, m, 128, col)); };
+                })(meta, column));
                 align(8);
                 offset += 16;
                 break;

package/lib/wire/eventConnection.d.ts

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

package/lib/wire/eventConnection.js

@@ -13,6 +13,7 @@ class EventConnection {
         this.emgr = null;
         this._isClosed = false;
         this._isOpened = false;
+        this._connectSettled = false;
         this._socket = net_1.default.createConnection(port, host);
         this._bind_events(host, port, callback);
         this.error = null;
@@ -20,17 +21,31 @@ class EventConnection {
     }
     _bind_events(host, port, callback) {
         var self = this;
+        function finishConnect(err) {
+            if (self._connectSettled)
+                return;
+            self._connectSettled = true;
+            if (callback)
+                callback(err);
+        }
         self._socket.on('close', function () {
             self._isClosed = true;
+            if (!self._isOpened) {
+                finishConnect(self.error || new Error(`Event connection to ${host}:${port} closed before connecting.`));
+            }
         });
         self._socket.on('error', function (e) {
             self.error = e;
+            if (!self._isOpened) {
+                if (!self._socket.destroyed)
+                    self._socket.destroy();
+                finishConnect(e);
+            }
         });
         self._socket.on('connect', function () {
             self._isClosed = false;
             self._isOpened = true;
-            if (callback)
-                callback();
+            finishConnect();
         });
         self._socket.on('data', function (data) {
             var xdr, buf;

package/lib/wire/serialize.js

@@ -241,7 +241,7 @@ class XdrWriter {
         const bigValue = BigInt(value);
         const high = bigValue >> BigInt(64);
         const low = bigValue & BigInt("0xFFFFFFFFFFFFFFFF");
-        this.buffer.writeBigUInt64BE(high, this.pos);
+        this.buffer.writeBigInt64BE(high, this.pos);
         this.pos += 8;
         this.buffer.writeBigUInt64BE(low, this.pos);
         this.pos += 8;

package/lib/wire/xsqlvar.d.ts

@@ -273,6 +273,14 @@ export declare class SQLParamInt128 {
     calcBlr(blr: BlrWriter): void;
     encode(data: XdrWriter): void;
 }
+/**
+ * Convert a decimal input to the signed integer coefficient used by a
+ * Firebird fixed-point wire type. Numbers are interpreted through their
+ * canonical decimal string; strings and bigints never pass through Number.
+ * Digits discarded by the target scale are rounded to nearest, ties away
+ * from zero, matching Firebird's conversion of decimal parameter text.
+ */
+export declare function toScaledInteger(value: number | string | bigint, scale: number, bits: 16 | 32 | 64 | 128): bigint;
 export declare class SQLParamDecFloat16 {
     value: any;
     constructor(value: any);

package/lib/wire/xsqlvar.js

@@ -18,6 +18,7 @@ exports.nestCell = nestCell;
 exports.describeField = describeField;
 exports.describeFields = describeFields;
 exports.parseRecordCounts = parseRecordCounts;
+exports.toScaledInteger = toScaledInteger;
 exports.encodeDateTimeParts = encodeDateTimeParts;
 const const_1 = __importDefault(require("./const"));
 const serialize_1 = require("./serialize");
@@ -27,11 +28,29 @@ const codepages_1 = require("./codepages");
  *   SQLVar
  *
  ***************************************/
-const ScaleDivisor = [1, 10, 100, 1000, 10000, 100000, 1000000, 10000000, 100000000, 1000000000, 10000000000, 100000000000, 1000000000000, 10000000000000, 100000000000000, 1000000000000000];
 const DateOffset = 40587, TimeCoeff = 86400000, MsPerMinute = 60000;
 const EMPTY_BUFFER = Buffer.alloc(0);
 const MAX_SAFE_BIGINT = BigInt(Number.MAX_SAFE_INTEGER);
 const MIN_SAFE_BIGINT = BigInt(Number.MIN_SAFE_INTEGER);
+/**
+ * Apply a Firebird numeric scale to a value already narrowed to a JS number.
+ *
+ * This replaces the former lookup table of divisors, which only held
+ * 10^0..10^15: any larger scale indexed past its end and yielded NaN. That is
+ * reachable for INT64 (NUMERIC(18,18)) and routine for INT128, where the scale
+ * runs to 38. Math.pow(10, n) returns the identical double for every exponent
+ * the table did cover, so in-range results are unchanged.
+ *
+ * Positive scales multiply, matching decodeExactNumeric and formatScaledBigInt;
+ * the table path divided by them, which was the wrong direction.
+ */
+function applyScale(value, scale) {
+    if (!scale)
+        return value;
+    return scale < 0
+        ? value / Math.pow(10, -scale)
+        : value * Math.pow(10, scale);
+}
 /** Format a signed Firebird integer coefficient without passing through Number. */
 function formatScaledBigInt(value, scale) {
     const negative = value < 0n;
@@ -56,10 +75,16 @@ function decodeExactNumeric(value, scale, mode) {
 }
 /** Decode INT128 using the mixed number/string policy of lossy mode. */
 function decodeLossyInt128(value, scale) {
-    if (value > MAX_SAFE_BIGINT) {
+    // Both bounds matter, as in decodeExactNumeric. While this path read the
+    // coefficient unsigned, every negative arrived as a huge positive and so
+    // always took the exact-string branch, which masked the missing lower
+    // bound. Now that the reader is signed, a large negative would otherwise
+    // fall through to Number() and lose precision while its positive twin
+    // stayed exact.
+    if (value > MAX_SAFE_BIGINT || value < MIN_SAFE_BIGINT) {
         return formatScaledBigInt(value, scale);
     }
-    return Number(value) / ScaleDivisor[Math.abs(scale)];
+    return applyScale(Number(value), scale);
 }
 /**
  * Maps Firebird character-set names (upper-case) to the Node.js Buffer
@@ -487,9 +512,7 @@ exports.SQLVarArray = SQLVarArray;
 class SQLVarInt extends SQLVarBase {
     decode(data, lowerV13) {
         var ret = data.readInt();
-        if (this.scale) {
-            ret = ret / ScaleDivisor[Math.abs(this.scale)];
-        }
+        ret = applyScale(ret, this.scale);
         if (!lowerV13 || !data.readInt()) {
             return ret;
         }
@@ -516,8 +539,7 @@ class SQLVarInt64 extends SQLVarBase {
         let ret;
         if (mode === const_1.default.NUMERIC_MODE_LOSSY) {
             ret = data.readInt64();
-            if (this.scale)
-                ret = ret / ScaleDivisor[Math.abs(this.scale)];
+            ret = applyScale(ret, this.scale);
         }
         else {
             ret = decodeExactNumeric(data.readInt64BigInt(), this.scale, mode);
@@ -538,7 +560,7 @@ class SQLVarInt128 extends SQLVarBase {
     decode(data, lowerV13, options) {
         const mode = options?.numericMode || const_1.default.NUMERIC_MODE_LOSSY;
         const ret = mode === const_1.default.NUMERIC_MODE_LOSSY
-            ? decodeLossyInt128(data.readInt128(), this.scale)
+            ? decodeLossyInt128(data.readInt128Signed(), this.scale)
             : decodeExactNumeric(data.readInt128Signed(), this.scale, mode);
         if (!lowerV13 || !data.readInt()) {
             return ret;
@@ -813,6 +835,78 @@ class SQLParamInt128 {
 }
 exports.SQLParamInt128 = SQLParamInt128;
 //------------------------------------------------------
+const FIXED_POINT_RE = /^([+-]?)(?:(\d+)(?:\.(\d*))?|\.(\d+))(?:[eE]([+-]?\d+))?$/;
+/**
+ * Convert a decimal input to the signed integer coefficient used by a
+ * Firebird fixed-point wire type. Numbers are interpreted through their
+ * canonical decimal string; strings and bigints never pass through Number.
+ * Digits discarded by the target scale are rounded to nearest, ties away
+ * from zero, matching Firebird's conversion of decimal parameter text.
+ */
+function toScaledInteger(value, scale, bits) {
+    if (!Number.isSafeInteger(scale)) {
+        throw new TypeError('Fixed-point scale must be an integer');
+    }
+    if (typeof value === 'number' && !Number.isFinite(value)) {
+        throw new TypeError('Fixed-point value must be finite');
+    }
+    if (typeof value !== 'number' && typeof value !== 'string' && typeof value !== 'bigint') {
+        throw new TypeError('Fixed-point value must be a number, string, or bigint');
+    }
+    const text = String(value).trim();
+    const match = FIXED_POINT_RE.exec(text);
+    if (!match) {
+        throw new TypeError('Invalid fixed-point value: ' + text);
+    }
+    const negative = match[1] === '-';
+    const integer = match[2] || '0';
+    const fraction = match[3] !== undefined ? match[3] : (match[4] || '');
+    const exponent = match[5] === undefined ? 0 : Number(match[5]);
+    if (!Number.isSafeInteger(exponent)) {
+        throw new RangeError('Fixed-point exponent is outside the supported range: ' + match[5]);
+    }
+    let digits = (integer + fraction).replace(/^0+/, '') || '0';
+    if (digits === '0')
+        return 0n;
+    const shift = exponent - fraction.length - scale;
+    let coefficientDigits;
+    let roundUp = false;
+    if (shift >= 0) {
+        // Every supported destination is at most 39 decimal digits. Avoid
+        // constructing an arbitrarily large BigInt for inputs such as 1e999999.
+        if (digits.length + shift > 40) {
+            throw new RangeError('Fixed-point value is outside the signed ' + bits + '-bit range: ' + text);
+        }
+        coefficientDigits = digits + '0'.repeat(shift);
+    }
+    else {
+        const discarded = -shift;
+        if (discarded < digits.length) {
+            const split = digits.length - discarded;
+            coefficientDigits = digits.slice(0, split);
+            roundUp = digits.charCodeAt(split) >= 0x35;
+        }
+        else {
+            coefficientDigits = '0';
+            // If discarded exceeds the number of significant digits, the
+            // magnitude is below 0.1 coefficient and cannot round to one.
+            roundUp = discarded === digits.length && digits.charCodeAt(0) >= 0x35;
+        }
+    }
+    let coefficient = BigInt(coefficientDigits);
+    if (roundUp)
+        coefficient += 1n;
+    if (negative)
+        coefficient = -coefficient;
+    const width = BigInt(bits);
+    const min = -(1n << (width - 1n));
+    const max = (1n << (width - 1n)) - 1n;
+    if (coefficient < min || coefficient > max) {
+        throw new RangeError('Fixed-point value is outside the signed ' + bits + '-bit range: ' + text);
+    }
+    return coefficient;
+}
+//------------------------------------------------------
 class SQLParamDecFloat16 {
     constructor(value) {
         this.value = value;

package/package.json

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

package/src/wire/connection.ts

@@ -1454,6 +1454,17 @@ class Connection {
             }
         }
 
+        // Validate fixed-point values before the BLOB pre-pass. Blob uploads
+        // write immediately, so deferring numeric validation until message
+        // encoding could leave transaction blob state behind for a batch that
+        // can never be sent.
+        try {
+            validateBatchFixedPointRows(input, rows as any[][]);
+        } catch (err) {
+            doError(err, callback);
+            return;
+        }
+
         var self = this;
 
         // BLOB pre-pass: upload every Buffer/string blob value as a
@@ -3538,6 +3549,39 @@ function scaleOutputLengths(output: any[], options: any) {
     }
 }
 
+function scaleBatchFixedPoint(value: any, meta: any, bits: 16 | 32 | 64 | 128, column: number): bigint {
+    try {
+        return Xsql.toScaledInteger(value, meta.scale, bits);
+    } catch (err) {
+        var message = err instanceof Error ? err.message : String(err);
+        throw new Error('Invalid fixed-point batch value for column ' + column +
+            ' (' + (meta.field || '?') + '): ' + message);
+    }
+}
+
+/** Validate values whose batch wire representation is metadata-directed.
+ * This runs before BLOB uploads, which may write to the transaction as soon
+ * as executeBatch starts its asynchronous pre-pass. */
+function validateBatchFixedPointRows(input: any[], rows: any[][]): void {
+    for (var i = 0; i < rows.length; i++) {
+        for (var j = 0; j < input.length; j++) {
+            var value = rows[i][j];
+            if (value === null || value === undefined) continue;
+
+            var bits: 16 | 32 | 64 | 128 | undefined = undefined;
+            switch (input[j].type) {
+                case Const.SQL_SHORT: bits = 16; break;
+                case Const.SQL_LONG: bits = 32; break;
+                case Const.SQL_INT64: bits = 64; break;
+                case Const.SQL_INT128: bits = 128; break;
+            }
+            if (bits !== undefined) {
+                scaleBatchFixedPoint(value, input[j], bits, j + 1);
+            }
+        }
+    }
+}
+
 /**
  * Batch support: the engine requires every batch message to use EXACTLY the
  * statement's described input format (unlike op_execute, where the client
@@ -3573,17 +3617,6 @@ function buildBatchEncoders(input: any[], options: any) {
         if (typeof v === 'string') return parseDate(v);
         return new Date(v);
     };
-    var scaled = function(v: any, scale: number): number {
-        var n = typeof v === 'string' ? parseFloat(v) : Number(v);
-        return scale ? Math.round(n * Math.pow(10, -scale)) : n;
-    };
-    var scaledBig = function(v: any, scale: number): bigint {
-        if (typeof v === 'bigint') {
-            return scale ? v * (10n ** BigInt(-scale)) : v;
-        }
-        return BigInt(scaled(v, scale));
-    };
-
     for (var j = 0; j < input.length; j++) {
         var meta = input[j];
         var column = j + 1;
@@ -3616,32 +3649,32 @@ function buildBatchEncoders(input: any[], options: any) {
 
             case Const.SQL_SHORT:
                 // 2 bytes in the message struct (msglen), 4 on the XDR wire
-                encoders.push((function(m) {
-                    return function(msg: any, v: any) { msg.addInt(scaled(v, m.scale)); };
-                })(meta));
+                encoders.push((function(m, col) {
+                    return function(msg: any, v: any) { msg.addInt(Number(scaleBatchFixedPoint(v, m, 16, col))); };
+                })(meta, column));
                 align(2); offset += 2;
                 break;
 
             case Const.SQL_LONG:
-                encoders.push((function(m) {
-                    return function(msg: any, v: any) { msg.addInt(scaled(v, m.scale)); };
-                })(meta));
+                encoders.push((function(m, col) {
+                    return function(msg: any, v: any) { msg.addInt(Number(scaleBatchFixedPoint(v, m, 32, col))); };
+                })(meta, column));
                 align(4); offset += 4;
                 break;
 
             case Const.SQL_INT64:
-                encoders.push((function(m) {
+                encoders.push((function(m, col) {
                     return function(msg: any, v: any) {
-                        msg.addInt64(typeof v === 'bigint' ? (scaledBig(v, m.scale) as any) : scaled(v, m.scale));
+                        msg.addInt64(scaleBatchFixedPoint(v, m, 64, col));
                     };
-                })(meta));
+                })(meta, column));
                 align(8); offset += 8;
                 break;
 
             case Const.SQL_INT128:
-                encoders.push((function(m) {
-                    return function(msg: any, v: any) { msg.addInt128(scaledBig(v, m.scale)); };
-                })(meta));
+                encoders.push((function(m, col) {
+                    return function(msg: any, v: any) { msg.addInt128(scaleBatchFixedPoint(v, m, 128, col)); };
+                })(meta, column));
                 align(8); offset += 16;
                 break;
 

package/src/wire/eventConnection.ts

@@ -13,37 +13,49 @@ class EventConnection {
     _xdr?: XdrReader;
     error: any;
     eventcallback: ((err: any, ret?: any) => void) | null;
+    _connectSettled: boolean;
 
-    constructor(host: string, port: number, callback: (() => void) | undefined, db: any) {
+    constructor(host: string, port: number, callback: ((err?: Error) => void) | undefined, db: any) {
         var self = this;
         this.db = db;
         this.emgr = null;
         this._isClosed = false;
         this._isOpened = false;
+        this._connectSettled = false;
         this._socket = net.createConnection(port, host);
         this._bind_events(host, port, callback);
         this.error = null;
         this.eventcallback = null;
     }
 
-    _bind_events(host: string, port: number, callback?: () => void): void {
+    _bind_events(host: string, port: number, callback?: (err?: Error) => void): void {
         var self = this;
 
-        self._socket.on('close', function () {
+        function finishConnect(err?: Error) {
+            if (self._connectSettled) return;
+            self._connectSettled = true;
+            if (callback) callback(err);
+        }
 
+        self._socket.on('close', function () {
             self._isClosed = true;
+            if (!self._isOpened) {
+                finishConnect(self.error || new Error(`Event connection to ${host}:${port} closed before connecting.`));
+            }
         })
 
         self._socket.on('error', function (e) {
-
             self.error = e;
+            if (!self._isOpened) {
+                if (!self._socket.destroyed) self._socket.destroy();
+                finishConnect(e);
+            }
         })
 
         self._socket.on('connect', function () {
             self._isClosed = false;
             self._isOpened = true;
-            if (callback)
-                callback();
+            finishConnect();
         });
 
         self._socket.on('data', function (data: Buffer) {

package/src/wire/serialize.ts

@@ -303,7 +303,7 @@ export class XdrWriter {
         const high = bigValue >> BigInt(64);
         const low = bigValue & BigInt("0xFFFFFFFFFFFFFFFF");
 
-        this.buffer.writeBigUInt64BE(high, this.pos);
+        this.buffer.writeBigInt64BE(high, this.pos);
         this.pos += 8;
         this.buffer.writeBigUInt64BE(low, this.pos);
         this.pos += 8;

package/src/wire/xsqlvar.ts

@@ -11,8 +11,6 @@ import type { NumericMode, RecordCounts } from '../types';
  *
  ***************************************/
 
-const
-    ScaleDivisor = [1,10,100,1000,10000,100000,1000000,10000000,100000000,1000000000,10000000000, 100000000000,1000000000000,10000000000000,100000000000000,1000000000000000];
 const
     DateOffset = 40587,
     TimeCoeff = 86400000,
@@ -26,6 +24,25 @@ type NumericDecodeOptions = {
     numericMode?: NumericMode;
 };
 
+/**
+ * Apply a Firebird numeric scale to a value already narrowed to a JS number.
+ *
+ * This replaces the former lookup table of divisors, which only held
+ * 10^0..10^15: any larger scale indexed past its end and yielded NaN. That is
+ * reachable for INT64 (NUMERIC(18,18)) and routine for INT128, where the scale
+ * runs to 38. Math.pow(10, n) returns the identical double for every exponent
+ * the table did cover, so in-range results are unchanged.
+ *
+ * Positive scales multiply, matching decodeExactNumeric and formatScaledBigInt;
+ * the table path divided by them, which was the wrong direction.
+ */
+function applyScale(value: number, scale: number): number {
+    if (!scale) return value;
+    return scale < 0
+        ? value / Math.pow(10, -scale)
+        : value * Math.pow(10, scale);
+}
+
 /** Format a signed Firebird integer coefficient without passing through Number. */
 function formatScaledBigInt(value: bigint, scale: number): string {
     const negative = value < 0n;
@@ -51,11 +68,17 @@ function decodeExactNumeric(value: bigint, scale: number, mode: 'safe' | 'string
 
 /** Decode INT128 using the mixed number/string policy of lossy mode. */
 function decodeLossyInt128(value: bigint, scale: number): number | string {
-    if (value > MAX_SAFE_BIGINT) {
+    // Both bounds matter, as in decodeExactNumeric. While this path read the
+    // coefficient unsigned, every negative arrived as a huge positive and so
+    // always took the exact-string branch, which masked the missing lower
+    // bound. Now that the reader is signed, a large negative would otherwise
+    // fall through to Number() and lose precision while its positive twin
+    // stayed exact.
+    if (value > MAX_SAFE_BIGINT || value < MIN_SAFE_BIGINT) {
         return formatScaledBigInt(value, scale);
     }
 
-    return Number(value) / ScaleDivisor[Math.abs(scale)];
+    return applyScale(Number(value), scale);
 }
 
 /**
@@ -564,9 +587,7 @@ export class SQLVarInt extends SQLVarBase {
     decode(data: XdrReader, lowerV13: boolean) {
         var ret = data.readInt();
 
-        if (this.scale) {
-            ret = ret / ScaleDivisor[Math.abs(this.scale)];
-        }
+        ret = applyScale(ret, this.scale);
 
         if (!lowerV13 || !data.readInt()) {
             return ret;
@@ -599,7 +620,7 @@ export class SQLVarInt64 extends SQLVarBase {
 
         if (mode === Const.NUMERIC_MODE_LOSSY) {
             ret = data.readInt64();
-            if (this.scale) ret = ret / ScaleDivisor[Math.abs(this.scale)];
+            ret = applyScale(ret, this.scale);
         } else {
             ret = decodeExactNumeric(data.readInt64BigInt(), this.scale, mode);
         }
@@ -622,7 +643,7 @@ export class SQLVarInt128 extends SQLVarBase {
     decode(data: XdrReader, lowerV13: boolean, options?: NumericDecodeOptions) {
         const mode = options?.numericMode || Const.NUMERIC_MODE_LOSSY;
         const ret = mode === Const.NUMERIC_MODE_LOSSY
-            ? decodeLossyInt128(data.readInt128(), this.scale)
+            ? decodeLossyInt128(data.readInt128Signed(), this.scale)
             : decodeExactNumeric(data.readInt128Signed(), this.scale, mode);
 
         if (!lowerV13 || !data.readInt()) {
@@ -957,6 +978,83 @@ export class SQLParamInt128 {
 
 //------------------------------------------------------
 
+const FIXED_POINT_RE = /^([+-]?)(?:(\d+)(?:\.(\d*))?|\.(\d+))(?:[eE]([+-]?\d+))?$/;
+
+/**
+ * Convert a decimal input to the signed integer coefficient used by a
+ * Firebird fixed-point wire type. Numbers are interpreted through their
+ * canonical decimal string; strings and bigints never pass through Number.
+ * Digits discarded by the target scale are rounded to nearest, ties away
+ * from zero, matching Firebird's conversion of decimal parameter text.
+ */
+export function toScaledInteger(value: number | string | bigint, scale: number, bits: 16 | 32 | 64 | 128): bigint {
+    if (!Number.isSafeInteger(scale)) {
+        throw new TypeError('Fixed-point scale must be an integer');
+    }
+    if (typeof value === 'number' && !Number.isFinite(value)) {
+        throw new TypeError('Fixed-point value must be finite');
+    }
+    if (typeof value !== 'number' && typeof value !== 'string' && typeof value !== 'bigint') {
+        throw new TypeError('Fixed-point value must be a number, string, or bigint');
+    }
+
+    const text = String(value).trim();
+    const match = FIXED_POINT_RE.exec(text);
+    if (!match) {
+        throw new TypeError('Invalid fixed-point value: ' + text);
+    }
+
+    const negative = match[1] === '-';
+    const integer = match[2] || '0';
+    const fraction = match[3] !== undefined ? match[3] : (match[4] || '');
+    const exponent = match[5] === undefined ? 0 : Number(match[5]);
+    if (!Number.isSafeInteger(exponent)) {
+        throw new RangeError('Fixed-point exponent is outside the supported range: ' + match[5]);
+    }
+
+    let digits = (integer + fraction).replace(/^0+/, '') || '0';
+    if (digits === '0') return 0n;
+
+    const shift = exponent - fraction.length - scale;
+    let coefficientDigits: string;
+    let roundUp = false;
+
+    if (shift >= 0) {
+        // Every supported destination is at most 39 decimal digits. Avoid
+        // constructing an arbitrarily large BigInt for inputs such as 1e999999.
+        if (digits.length + shift > 40) {
+            throw new RangeError('Fixed-point value is outside the signed ' + bits + '-bit range: ' + text);
+        }
+        coefficientDigits = digits + '0'.repeat(shift);
+    } else {
+        const discarded = -shift;
+        if (discarded < digits.length) {
+            const split = digits.length - discarded;
+            coefficientDigits = digits.slice(0, split);
+            roundUp = digits.charCodeAt(split) >= 0x35;
+        } else {
+            coefficientDigits = '0';
+            // If discarded exceeds the number of significant digits, the
+            // magnitude is below 0.1 coefficient and cannot round to one.
+            roundUp = discarded === digits.length && digits.charCodeAt(0) >= 0x35;
+        }
+    }
+
+    let coefficient = BigInt(coefficientDigits);
+    if (roundUp) coefficient += 1n;
+    if (negative) coefficient = -coefficient;
+
+    const width = BigInt(bits);
+    const min = -(1n << (width - 1n));
+    const max = (1n << (width - 1n)) - 1n;
+    if (coefficient < min || coefficient > max) {
+        throw new RangeError('Fixed-point value is outside the signed ' + bits + '-bit range: ' + text);
+    }
+    return coefficient;
+}
+
+//------------------------------------------------------
+
 export class SQLParamDecFloat16 {
     value: any;