jsgar 4.13.0 → 4.13.2

package/dist/gar.umd.js

@@ -852,6 +852,31 @@
          */
         sendMessage(message) {
             this.messageQueue.push(message);
+            // Drain synchronously when possible: background tabs throttle timers — the polling
+            // drain loop (and any setInterval sender) can stretch from 100ms to minutes — but
+            // synchronous sends from an event or enqueue are never throttled.
+            this._flushQueue();
+        }
+
+        /**
+         * Synchronously send everything sendable. Safe alongside the polling loop (same JS
+         * thread); leaves the null shutdown sentinel for the loop's exit handling.
+         */
+        _flushQueue() {
+            while (this.connected && this.messageQueue.length > 0 && this._isSocketOpen()) {
+                if (this.messageQueue[0] === null) return;
+                const message = this.messageQueue.shift();
+                try {
+                    this.websocket.send(JSON.stringify(message));
+                    if (this.logEveryMessage) {
+                        this.log('INFO', `Sent: ${JSON.stringify(message)}`);
+                    }
+                } catch (e) {
+                    this.log('WARNING', `Error sending message: ${e.message}`);
+                    this.halt();
+                    return;
+                }
+            }
         }
 
         /**
@@ -979,6 +1004,13 @@
                 this.invalidatedKeyIds.add(message.value.client_introduced_key_id);
             } else if (msgType === 'Heartbeat') {
                 this.lastHeartbeatTime = Date.now() / 1000;
+                // Echo our own heartbeat on the server's cadence. A hidden tab's throttled timers
+                // can silence the periodic sender far past the server's timeout while this
+                // (unthrottled) receive path keeps delivering — the server then rightly declares
+                // us dead. Event-driven liveness: receive -> reply, flushed synchronously above.
+                if (this.running) {
+                    this.sendMessage({ message_type: 'Heartbeat', value: { u_milliseconds: Date.now() } });
+                }
                 if (this._initialGracePeriod) {
                     // Resolve first-heartbeat waiters and end the initial grace window
                     if (this._firstHeartbeatResolve) {

package/gar.js

@@ -845,6 +845,31 @@ class GARClient {
      */
     sendMessage(message) {
         this.messageQueue.push(message);
+        // Drain synchronously when possible: background tabs throttle timers — the polling
+        // drain loop (and any setInterval sender) can stretch from 100ms to minutes — but
+        // synchronous sends from an event or enqueue are never throttled.
+        this._flushQueue();
+    }
+
+    /**
+     * Synchronously send everything sendable. Safe alongside the polling loop (same JS
+     * thread); leaves the null shutdown sentinel for the loop's exit handling.
+     */
+    _flushQueue() {
+        while (this.connected && this.messageQueue.length > 0 && this._isSocketOpen()) {
+            if (this.messageQueue[0] === null) return;
+            const message = this.messageQueue.shift();
+            try {
+                this.websocket.send(JSON.stringify(message));
+                if (this.logEveryMessage) {
+                    this.log('INFO', `Sent: ${JSON.stringify(message)}`);
+                }
+            } catch (e) {
+                this.log('WARNING', `Error sending message: ${e.message}`);
+                this.halt();
+                return;
+            }
+        }
     }
 
     /**
@@ -972,6 +997,13 @@ class GARClient {
             this.invalidatedKeyIds.add(message.value.client_introduced_key_id);
         } else if (msgType === 'Heartbeat') {
             this.lastHeartbeatTime = Date.now() / 1000;
+            // Echo our own heartbeat on the server's cadence. A hidden tab's throttled timers
+            // can silence the periodic sender far past the server's timeout while this
+            // (unthrottled) receive path keeps delivering — the server then rightly declares
+            // us dead. Event-driven liveness: receive -> reply, flushed synchronously above.
+            if (this.running) {
+                this.sendMessage({ message_type: 'Heartbeat', value: { u_milliseconds: Date.now() } });
+            }
             if (this._initialGracePeriod) {
                 // Resolve first-heartbeat waiters and end the initial grace window
                 if (this._firstHeartbeatResolve) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jsgar",
-  "version": "4.13.0",
+  "version": "4.13.2",
   "description": "A Javascript client for the GAR protocol",
   "type": "module",
   "main": "dist/gar.umd.js",
@@ -36,6 +36,8 @@
     "@eslint/json": "^0.13.2",
     "@rollup/plugin-commonjs": "^24.0.0",
     "@rollup/plugin-node-resolve": "^15.0.0",
+    "@xterm/addon-fit": "^0.10.0",
+    "@xterm/xterm": "^5.5.0",
     "ag-grid-community": "^34.1.1",
     "ag-grid-enterprise": "^34.1.1",
     "eslint": "^9.39.4",