aes70 2.0.15 → 2.0.17

package/dist/AES70.es5.js

@@ -939,6 +939,14 @@
       };
     }
 
+    get bufferedAmount() {
+      return this._currentSize;
+    }
+
+    get batchSize() {
+      return this._batchSize;
+    }
+
     add(pdu) {
       const currentSize = this._currentSize;
       const encodedLength = pdu.encoded_length();
@@ -971,7 +979,7 @@
       /* Keepalive packets are never combined into one message. */
       this._lastMessageType = messageType;
 
-      if (this._currentSize > this._batchSize) {
+      if (this._currentSize + additionalSize > this._batchSize) {
         this.flush();
       } else if (this._pdus.length === 1) {
         this.scheduleFlush();
@@ -1036,6 +1044,130 @@
     }
   }
 
+  function isItTime(target, now) {
+    // We are ok with 1ms accuracy.
+    return target - now < 1;
+  }
+
+  class Timer {
+    constructor(callback, getNow) {
+      this._callback = callback;
+      this._getNow = getNow;
+      this._targetTime = undefined;
+      this._timerId = undefined;
+      this._timerAt = undefined;
+    }
+
+    poll() {
+      const now = this._getNow();
+
+      if (this._targetTime === undefined) return;
+
+      if (isItTime(this._targetTime, now)) {
+        this._targetTime = undefined;
+        try {
+          this._callback();
+        } catch (err) {
+          console.error('Timer callback threw an exception', err);
+        }
+      } else {
+        this._reschedule();
+      }
+    }
+
+    _reschedule() {
+      const target = this._targetTime;
+      const interval = target - this._getNow();
+
+      if (this._timerId !== undefined) {
+        if (target >= this._timerAt) {
+          // The timer will fire before target. We will then reschedule it.
+          return;
+        }
+
+        clearTimeout(this._timerId);
+        this._timerId = undefined;
+      }
+
+      this._timerAt = target;
+      this._timerId = setTimeout(() => {
+        this._timerId = undefined;
+        this._timerAt = undefined;
+        this.poll();
+      }, Math.max(0, interval));
+    }
+
+    /**
+     *
+     * @param {number} interval
+     *   Interval in milliseconds.
+     */
+    scheduleIn(interval) {
+      if (!(interval >= 0)) {
+        throw new TypeError(`Expected positive interval.`);
+      }
+
+      this._targetTime = this._getNow() + interval;
+      this._reschedule();
+    }
+
+    /**
+     * Schedule the timer in a given number of milliseconds. If the timer
+     * is already running and scheduled to run before, do not modify it.
+     *
+     * @param {number} interval
+     */
+    scheduleDeadlineIn(interval) {
+      if (!(interval >= 0)) {
+        throw new TypeError(`Expected positive interval.`);
+      }
+
+      const target = this._getNow() + interval;
+
+      if (this._targetTime !== undefined && this._targetTime <= target) {
+        this.poll();
+        return;
+      }
+
+      this.scheduleAt(target);
+    }
+
+    /**
+     *
+     * @param {number} target
+     *   Target time in milliseconds.
+     */
+    scheduleAt(target) {
+      if (!(target >= 0)) {
+        throw new TypeError();
+      }
+
+      this._targetTime = target;
+      this._reschedule();
+    }
+
+    stop() {
+      this._targetTime = undefined;
+    }
+
+    cancel() {
+      this.stop();
+      this._clearTimeout();
+    }
+
+    _clearTimeout() {
+      if (this._timerId) {
+        clearTimeout(this._timerId);
+        this._timerId = undefined;
+        this._timerAt = undefined;
+      }
+    }
+
+    dispose() {
+      this.cancel();
+    }
+  }
+
   /**
    * Connection base class. It extends :class:`Events` and defines two events:
    *
@@ -1072,8 +1204,11 @@
       this.last_tx_time = now;
       this.rx_bytes = 0;
       this.tx_bytes = 0;
+      this._keepalive_timer = new Timer(
+        () => this._check_keepalive(),
+        () => this._now()
+      );
       this.keepalive_interval = -1;
-      this._keepalive_interval_id = null;
       this._closed = false;
       this.on('close', () => {
         if (this._closed) return;
@@ -1092,6 +1227,18 @@
       return true;
     }
 
+    get bufferedAmount() {
+      return this._message_generator.bufferedAmount;
+    }
+
+    get batchSize() {
+      return this._message_generator.batchSize;
+    }
+
+    get pendingWrites() {
+      return this._message_generator.bufferedAmount > 0 ? 1 : 0;
+    }
+
     send(pdu) {
       if (this.is_closed()) throw new Error('Connection is closed.');
       this.emit('send', pdu);
@@ -1149,7 +1296,7 @@
         }
       }
 
-      this._check_keepalive();
+      this.poll();
     }
 
     incoming(a) {}
@@ -1180,16 +1327,18 @@
       if (this.is_closed()) throw new Error('cleanup() called twice.');
 
       // disable keepalive
-      this.set_keepalive_interval(0);
+      this._keepalive_timer.dispose();
       this._message_generator.dispose();
       this._message_generator = null;
       this.removeAllEventListeners();
     }
 
     _check_keepalive() {
-      if (!(this.keepalive_interval > 0)) return;
-
+      if (this.is_closed()) return;
       const t = this.keepalive_interval;
+      if (!(t > 0)) return;
+
+      this._keepalive_timer.scheduleIn(t / 2 + 10);
 
       if (this.rx_idle_time() > t * 3) {
         this.emit('timeout');
@@ -1201,6 +1350,13 @@
       }
     }
 
+    /**
+     * Check if some regular internal timers must run.
+     */
+    poll() {
+      this._keepalive_timer.poll();
+    }
+
     /**
      * Flush write buffers. This are usually PDUs or may also be unwritten
      * buffers.
@@ -1226,11 +1382,6 @@
 
       const t = seconds * 1000;
 
-      if (this._keepalive_interval_id !== null) {
-        clearInterval(this._keepalive_interval_id);
-        this._keepalive_interval_id = null;
-      }
-
       this.keepalive_interval = t;
 
       // Notify the other side about our new keepalive
@@ -1238,12 +1389,12 @@
 
       this.send(new KeepAlive(t));
 
-      if (!(t > 0)) return;
-
-      // we check twice as often to make sure we stay within the timers
-      this._keepalive_interval_id = setInterval(() => {
-        this._check_keepalive();
-      }, t / 2);
+      if (t > 0) {
+        // we check twice as often to make sure we stay within the timers
+        this._keepalive_timer.scheduleIn(t / 2 + 10);
+      } else {
+        this._keepalive_timer.stop();
+      }
     }
   }
 
@@ -1729,17 +1880,57 @@
   class ClientConnection extends Connection {
     constructor(options) {
       super(options);
+      // All pending commands by id/handle
       this._pendingCommands = new Map();
+      // All pending commands scheduled to be sent.
+      this._scheduledPendingCommands = new Set();
+      // All pending commands wich have been sent.
+      this._sentPendingCommands = new Set();
       this._nextCommandHandle = 0;
       this._subscribers = new Map();
+      this._sendCommandsTimer = new Timer(
+        () => {
+          this.sendCommands();
+        },
+        () => this._now()
+      );
+    }
+
+    shouldSendMoreCommands() {
+      return this.is_reliable;
+    }
+
+    sendCommands() {
+      const { _scheduledPendingCommands, _sentPendingCommands } = this;
+
+      for (const pendingCommand of _scheduledPendingCommands) {
+        if (!this.shouldSendMoreCommands()) break;
+        _scheduledPendingCommands.delete(pendingCommand);
+        _sentPendingCommands.add(pendingCommand);
+        this.send(pendingCommand.command);
+        pendingCommand.lastSent = this._now();
+        pendingCommand.retries++;
+      }
+    }
+
+    scheduleSendCommands() {
+      this._sendCommandsTimer.scheduleDeadlineIn(5);
+    }
+
+    poll() {
+      super.poll();
+      this._sendCommandsTimer.poll();
     }
 
     cleanup(error) {
       super.cleanup(error);
+      this._sendCommandsTimer.dispose();
       const subscribers = this._subscribers;
       this._subscribers = null;
       const pendingCommands = this._pendingCommands;
       this._pendingCommands = null;
+      this._scheduledPendingCommands.clear();
+      this._sentPendingCommands.clear();
 
       const e = new CloseError(error);
       pendingCommands.forEach((pendingCommand, id) => {
@@ -1818,9 +2009,8 @@
         );
 
         this._pendingCommands.set(handle, pendingCommand);
-
-        pendingCommand.lastSent = this._estimate_next_tx_time();
-        this.send(command);
+        this._scheduledPendingCommands.add(pendingCommand);
+        this.scheduleSendCommands();
       };
 
       if (callback) {
@@ -1841,6 +2031,9 @@
 
       pendingCommands.delete(handle);
 
+      if (!this._sentPendingCommands.delete(pendingCommand))
+        this._scheduledPendingCommands.delete(pendingCommand);
+
       return pendingCommand;
     }
 
@@ -28806,15 +28999,20 @@
       this.retry_interval =
         options.retry_interval >= 0 ? options.retry_interval : 250;
       this.retry_count = options.retry_count >= 0 ? options.retry_count : 3;
-      this._write_out_id = -1;
-      this._write_out_callback = () => {
-        this._write_out_id = -1;
-        this._write_out();
-      };
-      this._retry_id =
-        this.retry_interval > 0
-          ? setInterval(() => this._retryCommands(), this.retry_interval)
-          : -1;
+      this._write_out_timer = new Timer(
+        () => {
+          this._write_out();
+        },
+        () => this._now()
+      );
+      this._retry_timer = new Timer(
+        () => {
+          this._retryCommands();
+          this._retry_timer.scheduleIn(this.retry_interval);
+        },
+        () => this._now()
+      );
+      this._retry_timer.scheduleIn(this.retry_interval);
       this.q = [];
       socket.onmessage = (buffer) => {
         try {
@@ -28832,6 +29030,24 @@
       return false;
     }
 
+    get bufferedAmount() {
+      let amount = super.bufferedAmount;
+
+      for (const buf of this.q) {
+        amount += buf.byteLength;
+      }
+
+      return amount;
+    }
+
+    get pendingWrites() {
+      return super.pendingWrites + this.q.length;
+    }
+
+    shouldSendMoreCommands() {
+      return this.q.length < 3;
+    }
+
     /**
      * Connect to the given endpoint.
      *
@@ -28901,14 +29117,8 @@
         this.socket.close();
         this.socket = null;
       }
-      if (this._write_out_id !== -1) {
-        clearTimeout(this._write_out_id);
-        this._write_out_id = -1;
-      }
-      if (this._retry_id !== -1) {
-        clearInterval(this._retry_id);
-        this._retry_id = -1;
-      }
+      this._write_out_timer.dispose();
+      this._retry_timer.dispose();
     }
 
     _estimate_next_tx_time() {
@@ -28927,6 +29137,13 @@
       super.write(buf);
 
       if (q.length) this._schedule_write_out();
+      this.scheduleSendCommands();
+    }
+
+    poll() {
+      super.poll();
+      this._write_out_timer.poll();
+      this._retry_timer.poll();
     }
 
     _schedule_write_out() {
@@ -28938,54 +29155,45 @@
         return;
       }
 
-      // Already scheduled.
-      if (this._write_out_id !== -1) return;
-
-      this._write_out_id = setTimeout(
-        this._write_out_callback,
-        delay - tx_idle_time
-      );
+      this._write_out_timer.scheduleIn(delay - tx_idle_time);
     }
 
     _retryCommands() {
       const now = this._now();
       const retryTime = now - this.retry_interval;
-      // This is an estimate for how many commands we would manage to send
-      // off.
-      const max = 5 * (this.retry_interval / this.delay) - this.q.length;
       const pendingCommands = this._pendingCommands;
+      const _sentPendingCommands = this._sentPendingCommands;
+      const _scheduledPendingCommands = this._scheduledPendingCommands;
 
-      const retries = [];
+      let scheduledCount = 0;
       const failed = [];
 
-      for (const entry of pendingCommands) {
-        const [, pendingCommand] = entry;
-
-        // All later commands are newer than the cutoff.
+      for (const pendingCommand of _sentPendingCommands) {
         if (pendingCommand.lastSent > retryTime) break;
+
+        _sentPendingCommands.delete(pendingCommand);
+
         if (pendingCommand.retries >= this.retry_count) {
-          failed.push(entry);
-        } else if (retries.length < max) {
-          retries.push(entry);
+          failed.push(pendingCommand);
+        } else {
+          _scheduledPendingCommands.add(pendingCommand);
+          scheduledCount++;
         }
       }
 
+      if (scheduledCount) {
+        this.scheduleSendCommands();
+      }
+
       if (failed.length) {
         const timeoutError = new Error('Timeout.');
 
-        failed.forEach(([handle, pendingCommand]) => {
+        failed.forEach((pendingCommand) => {
+          const handle = pendingCommand.handle;
           pendingCommands.delete(handle);
           pendingCommand.reject(timeoutError);
         });
       }
-
-      retries.forEach(([handle, pendingCommand]) => {
-        pendingCommands.delete(handle);
-        pendingCommands.set(handle, pendingCommand);
-        this.send(pendingCommand.command);
-        pendingCommand.lastSent = now;
-        pendingCommand.retries++;
-      });
     }
   }
 
@@ -29114,6 +29322,10 @@
         }
         return value;
       }
+    } else if (typeof value === 'bigint') {
+      return value >= Number.MIN_SAFE_INTEGER && value <= Number.MAX_SAFE_INTEGER
+        ? Number(value)
+        : value.toString();
     } else {
       return value;
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "aes70",
-  "version": "2.0.15",
+  "version": "2.0.17",
   "description": "A controller library for the AES70 protocol.",
   "type": "module",
   "main": "src/index.js",

package/src/OCP1/message_generator.js

@@ -19,6 +19,14 @@ export class MessageGenerator {
     };
   }
 
+  get bufferedAmount() {
+    return this._currentSize;
+  }
+
+  get batchSize() {
+    return this._batchSize;
+  }
+
   add(pdu) {
     const currentSize = this._currentSize;
     const encodedLength = pdu.encoded_length();
@@ -51,7 +59,7 @@ export class MessageGenerator {
     /* Keepalive packets are never combined into one message. */
     this._lastMessageType = messageType;
 
-    if (this._currentSize > this._batchSize) {
+    if (this._currentSize + additionalSize > this._batchSize) {
       this.flush();
     } else if (this._pdus.length === 1) {
       this.scheduleFlush();

package/src/connection.d.ts

@@ -56,6 +56,23 @@ export declare class Connection extends Events {
    */
   get rx_idle_time(): number;
 
+  /**
+   * Amount of bytes currently buffered to be sent out.
+   */
+  get bufferedAmount(): number;
+
+  /**
+   * Amount of bytes which will be batched into single
+   * aes70 messages. This can be configured using the
+   * `batch` option when creating a connection.
+   */
+  get batchSize(): number;
+
+  /**
+   * The number of currently pending write operations.
+   */
+  get pendingWrites(): number;
+
   /**
    * Closes this connection.
    */

package/src/connection.js

@@ -3,6 +3,7 @@ import { decodeMessage } from './OCP1/decode_message.js';
 import { KeepAlive } from './OCP1/keepalive.js';
 import { MessageGenerator } from './OCP1/message_generator.js';
 import { TimeoutError } from './timeout_error.js';
+import { Timer } from './utils/timer.js';
 
 /**
  * Connection base class. It extends :class:`Events` and defines two events:
@@ -40,8 +41,11 @@ export class Connection extends Events {
     this.last_tx_time = now;
     this.rx_bytes = 0;
     this.tx_bytes = 0;
+    this._keepalive_timer = new Timer(
+      () => this._check_keepalive(),
+      () => this._now()
+    );
     this.keepalive_interval = -1;
-    this._keepalive_interval_id = null;
     this._closed = false;
     this.on('close', () => {
       if (this._closed) return;
@@ -60,6 +64,18 @@ export class Connection extends Events {
     return true;
   }
 
+  get bufferedAmount() {
+    return this._message_generator.bufferedAmount;
+  }
+
+  get batchSize() {
+    return this._message_generator.batchSize;
+  }
+
+  get pendingWrites() {
+    return this._message_generator.bufferedAmount > 0 ? 1 : 0;
+  }
+
   send(pdu) {
     if (this.is_closed()) throw new Error('Connection is closed.');
     this.emit('send', pdu);
@@ -117,7 +133,7 @@ export class Connection extends Events {
       }
     }
 
-    this._check_keepalive();
+    this.poll();
   }
 
   incoming(a) {}
@@ -148,16 +164,18 @@ export class Connection extends Events {
     if (this.is_closed()) throw new Error('cleanup() called twice.');
 
     // disable keepalive
-    this.set_keepalive_interval(0);
+    this._keepalive_timer.dispose();
     this._message_generator.dispose();
     this._message_generator = null;
     this.removeAllEventListeners();
   }
 
   _check_keepalive() {
-    if (!(this.keepalive_interval > 0)) return;
-
+    if (this.is_closed()) return;
     const t = this.keepalive_interval;
+    if (!(t > 0)) return;
+
+    this._keepalive_timer.scheduleIn(t / 2 + 10);
 
     if (this.rx_idle_time() > t * 3) {
       this.emit('timeout');
@@ -169,6 +187,13 @@ export class Connection extends Events {
     }
   }
 
+  /**
+   * Check if some regular internal timers must run.
+   */
+  poll() {
+    this._keepalive_timer.poll();
+  }
+
   /**
    * Flush write buffers. This are usually PDUs or may also be unwritten
    * buffers.
@@ -194,11 +219,6 @@ export class Connection extends Events {
 
     const t = seconds * 1000;
 
-    if (this._keepalive_interval_id !== null) {
-      clearInterval(this._keepalive_interval_id);
-      this._keepalive_interval_id = null;
-    }
-
     this.keepalive_interval = t;
 
     // Notify the other side about our new keepalive
@@ -206,11 +226,11 @@ export class Connection extends Events {
 
     this.send(new KeepAlive(t));
 
-    if (!(t > 0)) return;
-
-    // we check twice as often to make sure we stay within the timers
-    this._keepalive_interval_id = setInterval(() => {
-      this._check_keepalive();
-    }, t / 2);
+    if (t > 0) {
+      // we check twice as often to make sure we stay within the timers
+      this._keepalive_timer.scheduleIn(t / 2 + 10);
+    } else {
+      this._keepalive_timer.stop();
+    }
   }
 }

package/src/controller/abstract_udp_connection.js

@@ -1,4 +1,5 @@
 /* eslint-env node */
+import { Timer } from '../utils/timer.js';
 import { ClientConnection } from './client_connection.js';
 
 /**
@@ -17,15 +18,20 @@ export class AbstractUDPConnection extends ClientConnection {
     this.retry_interval =
       options.retry_interval >= 0 ? options.retry_interval : 250;
     this.retry_count = options.retry_count >= 0 ? options.retry_count : 3;
-    this._write_out_id = -1;
-    this._write_out_callback = () => {
-      this._write_out_id = -1;
-      this._write_out();
-    };
-    this._retry_id =
-      this.retry_interval > 0
-        ? setInterval(() => this._retryCommands(), this.retry_interval)
-        : -1;
+    this._write_out_timer = new Timer(
+      () => {
+        this._write_out();
+      },
+      () => this._now()
+    );
+    this._retry_timer = new Timer(
+      () => {
+        this._retryCommands();
+        this._retry_timer.scheduleIn(this.retry_interval);
+      },
+      () => this._now()
+    );
+    this._retry_timer.scheduleIn(this.retry_interval);
     this.q = [];
     socket.onmessage = (buffer) => {
       try {
@@ -43,6 +49,24 @@ export class AbstractUDPConnection extends ClientConnection {
     return false;
   }
 
+  get bufferedAmount() {
+    let amount = super.bufferedAmount;
+
+    for (const buf of this.q) {
+      amount += buf.byteLength;
+    }
+
+    return amount;
+  }
+
+  get pendingWrites() {
+    return super.pendingWrites + this.q.length;
+  }
+
+  shouldSendMoreCommands() {
+    return this.q.length < 3;
+  }
+
   /**
    * Connect to the given endpoint.
    *
@@ -112,14 +136,8 @@ export class AbstractUDPConnection extends ClientConnection {
       this.socket.close();
       this.socket = null;
     }
-    if (this._write_out_id !== -1) {
-      clearTimeout(this._write_out_id);
-      this._write_out_id = -1;
-    }
-    if (this._retry_id !== -1) {
-      clearInterval(this._retry_id);
-      this._retry_id = -1;
-    }
+    this._write_out_timer.dispose();
+    this._retry_timer.dispose();
   }
 
   _estimate_next_tx_time() {
@@ -138,6 +156,13 @@ export class AbstractUDPConnection extends ClientConnection {
     super.write(buf);
 
     if (q.length) this._schedule_write_out();
+    this.scheduleSendCommands();
+  }
+
+  poll() {
+    super.poll();
+    this._write_out_timer.poll();
+    this._retry_timer.poll();
   }
 
   _schedule_write_out() {
@@ -149,53 +174,44 @@ export class AbstractUDPConnection extends ClientConnection {
       return;
     }
 
-    // Already scheduled.
-    if (this._write_out_id !== -1) return;
-
-    this._write_out_id = setTimeout(
-      this._write_out_callback,
-      delay - tx_idle_time
-    );
+    this._write_out_timer.scheduleIn(delay - tx_idle_time);
   }
 
   _retryCommands() {
     const now = this._now();
     const retryTime = now - this.retry_interval;
-    // This is an estimate for how many commands we would manage to send
-    // off.
-    const max = 5 * (this.retry_interval / this.delay) - this.q.length;
     const pendingCommands = this._pendingCommands;
+    const _sentPendingCommands = this._sentPendingCommands;
+    const _scheduledPendingCommands = this._scheduledPendingCommands;
 
-    const retries = [];
+    let scheduledCount = 0;
     const failed = [];
 
-    for (const entry of pendingCommands) {
-      const [, pendingCommand] = entry;
-
-      // All later commands are newer than the cutoff.
+    for (const pendingCommand of _sentPendingCommands) {
       if (pendingCommand.lastSent > retryTime) break;
+
+      _sentPendingCommands.delete(pendingCommand);
+
       if (pendingCommand.retries >= this.retry_count) {
-        failed.push(entry);
-      } else if (retries.length < max) {
-        retries.push(entry);
+        failed.push(pendingCommand);
+      } else {
+        _scheduledPendingCommands.add(pendingCommand);
+        scheduledCount++;
       }
     }
 
+    if (scheduledCount) {
+      this.scheduleSendCommands();
+    }
+
     if (failed.length) {
       const timeoutError = new Error('Timeout.');
 
-      failed.forEach(([handle, pendingCommand]) => {
+      failed.forEach((pendingCommand) => {
+        const handle = pendingCommand.handle;
         pendingCommands.delete(handle);
         pendingCommand.reject(timeoutError);
       });
     }
-
-    retries.forEach(([handle, pendingCommand]) => {
-      pendingCommands.delete(handle);
-      pendingCommands.set(handle, pendingCommand);
-      this.send(pendingCommand.command);
-      pendingCommand.lastSent = now;
-      pendingCommand.retries++;
-    });
   }
 }

package/src/controller/client_connection.js

@@ -11,6 +11,7 @@ import { EncodedArguments } from '../OCP1/encoded_arguments.js';
 import { CloseError } from '../close_error.js';
 import { Subscriptions } from '../utils/subscriptions.js';
 import { subscribeEvent } from '../utils/subscribeEvent.js';
+import { Timer } from '../utils/timer.js';
 
 class PendingCommand {
   get handle() {
@@ -90,17 +91,57 @@ function eventToKey(event) {
 export class ClientConnection extends Connection {
   constructor(options) {
     super(options);
+    // All pending commands by id/handle
     this._pendingCommands = new Map();
+    // All pending commands scheduled to be sent.
+    this._scheduledPendingCommands = new Set();
+    // All pending commands wich have been sent.
+    this._sentPendingCommands = new Set();
     this._nextCommandHandle = 0;
     this._subscribers = new Map();
+    this._sendCommandsTimer = new Timer(
+      () => {
+        this.sendCommands();
+      },
+      () => this._now()
+    );
+  }
+
+  shouldSendMoreCommands() {
+    return this.is_reliable;
+  }
+
+  sendCommands() {
+    const { _scheduledPendingCommands, _sentPendingCommands } = this;
+
+    for (const pendingCommand of _scheduledPendingCommands) {
+      if (!this.shouldSendMoreCommands()) break;
+      _scheduledPendingCommands.delete(pendingCommand);
+      _sentPendingCommands.add(pendingCommand);
+      this.send(pendingCommand.command);
+      pendingCommand.lastSent = this._now();
+      pendingCommand.retries++;
+    }
+  }
+
+  scheduleSendCommands() {
+    this._sendCommandsTimer.scheduleDeadlineIn(5);
+  }
+
+  poll() {
+    super.poll();
+    this._sendCommandsTimer.poll();
   }
 
   cleanup(error) {
     super.cleanup(error);
+    this._sendCommandsTimer.dispose();
     const subscribers = this._subscribers;
     this._subscribers = null;
     const pendingCommands = this._pendingCommands;
     this._pendingCommands = null;
+    this._scheduledPendingCommands.clear();
+    this._sentPendingCommands.clear();
 
     const e = new CloseError(error);
     pendingCommands.forEach((pendingCommand, id) => {
@@ -179,9 +220,8 @@ export class ClientConnection extends Connection {
       );
 
       this._pendingCommands.set(handle, pendingCommand);
-
-      pendingCommand.lastSent = this._estimate_next_tx_time();
-      this.send(command);
+      this._scheduledPendingCommands.add(pendingCommand);
+      this.scheduleSendCommands();
     };
 
     if (callback) {
@@ -202,6 +242,9 @@ export class ClientConnection extends Connection {
 
     pendingCommands.delete(handle);
 
+    if (!this._sentPendingCommands.delete(pendingCommand))
+      this._scheduledPendingCommands.delete(pendingCommand);
+
     return pendingCommand;
   }
 

package/src/controller/fetch_device_content.js

@@ -13,6 +13,10 @@ function formatValue(value) {
       }
       return value;
     }
+  } else if (typeof value === 'bigint') {
+    return value >= Number.MIN_SAFE_INTEGER && value <= Number.MAX_SAFE_INTEGER
+      ? Number(value)
+      : value.toString();
   } else {
     return value;
   }

package/src/utils/timer.js

@@ -0,0 +1,123 @@
+function isItTime(target, now) {
+  // We are ok with 1ms accuracy.
+  return target - now < 1;
+}
+
+export class Timer {
+  constructor(callback, getNow) {
+    this._callback = callback;
+    this._getNow = getNow;
+    this._targetTime = undefined;
+    this._timerId = undefined;
+    this._timerAt = undefined;
+  }
+
+  poll() {
+    const now = this._getNow();
+
+    if (this._targetTime === undefined) return;
+
+    if (isItTime(this._targetTime, now)) {
+      this._targetTime = undefined;
+      try {
+        this._callback();
+      } catch (err) {
+        console.error('Timer callback threw an exception', err);
+      }
+    } else {
+      this._reschedule();
+    }
+  }
+
+  _reschedule() {
+    const target = this._targetTime;
+    const interval = target - this._getNow();
+
+    if (this._timerId !== undefined) {
+      if (target >= this._timerAt) {
+        // The timer will fire before target. We will then reschedule it.
+        return;
+      }
+
+      clearTimeout(this._timerId);
+      this._timerId = undefined;
+    }
+
+    this._timerAt = target;
+    this._timerId = setTimeout(() => {
+      this._timerId = undefined;
+      this._timerAt = undefined;
+      this.poll();
+    }, Math.max(0, interval));
+  }
+
+  /**
+   *
+   * @param {number} interval
+   *   Interval in milliseconds.
+   */
+  scheduleIn(interval) {
+    if (!(interval >= 0)) {
+      throw new TypeError(`Expected positive interval.`);
+    }
+
+    this._targetTime = this._getNow() + interval;
+    this._reschedule();
+  }
+
+  /**
+   * Schedule the timer in a given number of milliseconds. If the timer
+   * is already running and scheduled to run before, do not modify it.
+   *
+   * @param {number} interval
+   */
+  scheduleDeadlineIn(interval) {
+    if (!(interval >= 0)) {
+      throw new TypeError(`Expected positive interval.`);
+    }
+
+    const target = this._getNow() + interval;
+
+    if (this._targetTime !== undefined && this._targetTime <= target) {
+      this.poll();
+      return;
+    }
+
+    this.scheduleAt(target);
+  }
+
+  /**
+   *
+   * @param {number} target
+   *   Target time in milliseconds.
+   */
+  scheduleAt(target) {
+    if (!(target >= 0)) {
+      throw new TypeError();
+    }
+
+    this._targetTime = target;
+    this._reschedule();
+  }
+
+  stop() {
+    this._targetTime = undefined;
+  }
+
+  cancel() {
+    this.stop();
+    this._clearTimeout();
+  }
+
+  _clearTimeout() {
+    if (this._timerId) {
+      clearTimeout(this._timerId);
+      this._timerId = undefined;
+      this._timerAt = undefined;
+    }
+  }
+
+  dispose() {
+    this.cancel();
+  }
+}