reachlo 1.2.2 → 1.3.1

package/index.js

@@ -9,6 +9,7 @@ class Reachlo {
         this.offlineBuffer = []; // Buffer for publish events when disconnected
 
         // Options
+        this.debug = options.debug || false; // Default: false (silent)
         this.bufferPublish = options.bufferPublish ?? false; // Drop by default for AI
         this.heartbeatInterval = options.heartbeatInterval || 20000;
         this.reconnectInterval = options.reconnectInterval || 3000;
@@ -20,11 +21,16 @@ class Reachlo {
         this.lastPong = Date.now();
         this.reconnecting = false; // Prevent duplicate events
 
+        // Protocol v2 State
+        this.msgId = 0;
+        this.ackPending = new Map(); // id -> { resolve, reject, timeout }
+
         // Lifecycle Listeners
         this.listeners = {
             connect: new Set(),
             disconnect: new Set(),
-            reconnecting: new Set()
+            reconnecting: new Set(),
+            error: new Set()
         };
     }
 
@@ -55,6 +61,18 @@ class Reachlo {
         }
     }
 
+    _log(...args) {
+        if (this.debug) console.log(...args);
+    }
+
+    _warn(...args) {
+        if (this.debug) console.warn(...args);
+    }
+
+    _error(...args) {
+        if (this.debug) console.error(...args);
+    }
+
     connect() {
         this.shouldReconnect = true;
         return new Promise((resolve, reject) => {
@@ -70,7 +88,7 @@ class Reachlo {
             this.socket = new WebSocket(this.url, protocols);
 
             this.socket.onopen = () => {
-                console.log("Reachlo: Connected");
+                this._log("Reachlo: Connected");
                 this.reconnecting = false;
                 this.lastPong = Date.now();
                 this._startHeartbeat();
@@ -78,9 +96,15 @@ class Reachlo {
 
                 // Resubscribe active channels + flush pending
                 const toSubscribe = new Set([...this.channels.keys(), ...this.pendingSubs]);
-                toSubscribe.forEach(channel =>
-                    this._send({ type: 'subscribe', channel })
-                );
+                toSubscribe.forEach(channelName => {
+                    const channel = this.channels.get(channelName);
+                    // Pass capabilities if available (if it was already created)
+                    // If it was just pendingSub (no channel obj yet? Wait, pendingSub is only added if channel obj created)
+                    // Yes, logic: create Channel obj -> if socket open send, else add to pending.
+                    // So channel obj always exists when using pendingSubs for resubscribe
+                    const options = channel ? channel.options : {};
+                    this._send({ type: 'subscribe', channel: channelName, options: options });
+                });
                 this.pendingSubs.clear();
 
                 // Flush Offline Buffer (if enabled)
@@ -94,8 +118,16 @@ class Reachlo {
             };
 
             this.socket.onclose = () => {
-                console.log("Reachlo: Connection closed");
+                this._log("Reachlo: Connection closed");
                 this._stopHeartbeat();
+
+                // SDK Review Fix: ACK Memory Leak Protection
+                this.ackPending.forEach(({ reject, timeout }) => {
+                    clearTimeout(timeout);
+                    reject(new Error('Disconnected'));
+                });
+                this.ackPending.clear();
+
                 this._emitLifecycle('disconnect');
 
                 if (this.shouldReconnect) {
@@ -109,7 +141,7 @@ class Reachlo {
             };
 
             this.socket.onerror = (err) => {
-                console.error("Reachlo: Socket error", err);
+                this._error("Reachlo: Socket error", err);
                 if (this.socket.readyState !== 1 && !this.reconnecting) reject(err);
             };
 
@@ -121,11 +153,30 @@ class Reachlo {
                         return;
                     }
 
-                    if (payload.channel && this.channels.has(payload.channel)) {
-                        this.channels.get(payload.channel)._emit(payload.data);
+                    if (payload.type === 'ack') {
+                        const pending = this.ackPending.get(payload.id);
+                        if (pending) {
+                            pending.resolve();
+                            clearTimeout(pending.timeout);
+                            this.ackPending.delete(payload.id);
+                        }
+                        return;
+                    }
+
+                    const channelObj = this.channels.get(payload.channel);
+                    if (channelObj) {
+                        if (payload.type === 'publish') {
+                            channelObj._emit(payload.data);
+                        } else if (payload.type === 'backpressure') {
+                            channelObj._emitEvent('backpressure', payload);
+                        } else if (payload.type === 'join') {
+                            channelObj._emitEvent('join', payload);
+                        } else if (payload.type === 'leave') {
+                            channelObj._emitEvent('leave', payload);
+                        }
                     }
                 } catch (e) {
-                    console.error("Reachlo: Message parse error", e);
+                    this._error("Reachlo: Message parse error", e);
                 }
             };
         });
@@ -139,7 +190,7 @@ class Reachlo {
 
             // Detect Half-Open: If Pong expired
             if (Date.now() - this.lastPong > (this.heartbeatInterval * 2)) {
-                console.warn("Reachlo: Heartbeat timeout. Simulating disconnect.");
+                this._warn("Reachlo: Heartbeat timeout. Simulating disconnect.");
                 if (this.socket) this.socket.close(); // Triggers onclose -> reconnect
             }
         }, this.heartbeatInterval);
@@ -154,7 +205,7 @@ class Reachlo {
         this.shouldReconnect = false;
         if (this.reconnectTimer) clearTimeout(this.reconnectTimer);
         this._stopHeartbeat();
-        this._emitLifecycle('disconnect');
+
 
         if (this.socket) {
             this.socket.close();
@@ -164,13 +215,13 @@ class Reachlo {
         this.offlineBuffer = [];
     }
 
-    channel(channelName) {
+    channel(channelName, options = {}) {
         if (!this.channels.has(channelName)) {
-            const channel = new ReachloChannel(channelName, this);
+            const channel = new ReachloChannel(channelName, this, options);
             this.channels.set(channelName, channel);
 
             if (this.socket?.readyState === 1) { // WebSocket.OPEN is 1
-                this._send({ type: 'subscribe', channel: channelName });
+                this._send({ type: 'subscribe', channel: channelName, options: options });
             } else {
                 this.pendingSubs.add(channelName);
             }
@@ -194,10 +245,16 @@ class Reachlo {
 }
 
 class ReachloChannel {
-    constructor(name, client) {
+    constructor(name, client, options = {}) {
         this.name = name;
         this.client = client;
+        this.options = options; // { type: 'durable' | 'presence' | 'stream' }
         this.callbacks = new Set();
+        this.eventListeners = {
+            join: new Set(),
+            leave: new Set(),
+            backpressure: new Set()
+        };
     }
 
     subscribe(cb) {
@@ -205,16 +262,76 @@ class ReachloChannel {
         return () => this.callbacks.delete(cb); // unsubscribe handle
     }
 
-    publish(data) {
-        return this.client._send({ type: 'publish', channel: this.name, data });
+    on(event, cb) {
+        if (this.eventListeners[event]) {
+            this.eventListeners[event].add(cb);
+        }
+        return () => this.off(event, cb);
+    }
+
+    off(event, cb) {
+        if (this.eventListeners[event]) {
+            this.eventListeners[event].delete(cb);
+        }
+    }
+
+    publish(data, options = {}) {
+        const payload = {
+            type: 'publish',
+            channel: this.name,
+            data
+        };
+
+        if (options.delivery === 'ack') {
+            payload.delivery = 'ack';
+            const id = ++this.client.msgId;
+            payload.id = id;
+
+            return new Promise((resolve, reject) => {
+                const timeoutMs = options.timeout || 5000;
+                const timeout = setTimeout(() => {
+                    this.client.ackPending.delete(id);
+                    reject(new Error('ACK timeout'));
+                }, timeoutMs);
+
+                this.client.ackPending.set(id, { resolve, reject, timeout });
+
+                const sentOrQueued = this.client._send(payload);
+                if (!sentOrQueued) {
+                    clearTimeout(timeout);
+                    this.client.ackPending.delete(id);
+                    reject(new Error('Socket not connected'));
+                }
+            });
+        }
+
+        // Fire-and-forget
+        this.client._send(payload);
+        return Promise.resolve();
+    }
+
+    sync(lastSeenId = 0) {
+        this.client._send({
+            type: 'sync',
+            channel: this.name,
+            lastSeenId
+        });
     }
 
     _emit(data) {
         // Microtask Delivery to prevent Event Loop Blocking
         this.callbacks.forEach(cb => {
-            queueMicrotask(() => cb(data)); // <-- The Fix
+            queueMicrotask(() => cb(data));
         });
     }
+
+    _emitEvent(event, payload) {
+        if (this.eventListeners[event]) {
+            this.eventListeners[event].forEach(cb => {
+                queueMicrotask(() => cb(payload));
+            });
+        }
+    }
 }
 
 export default Reachlo;

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "reachlo",
-    "version": "1.2.2",
-    "description": "Real-time infrastructure for AI streaming.",
+    "version": "1.3.1",
+    "description": "Streaming-native real-time infrastructure. Ordered channels, durable replay, presence, backpressure, and ACK delivery.",
     "main": "index.js",
     "type": "module",
     "author": "Reachlo Team",