@korajs/sync 0.1.2 → 0.1.4

package/dist/index.d.ts

@@ -121,6 +121,8 @@ interface WebSocketTransportOptions {
     serializer?: MessageSerializer;
     /** Injectable WebSocket constructor for testing. Defaults to globalThis.WebSocket. */
     WebSocketImpl?: WebSocketConstructor;
+    /** Connection timeout in ms. Defaults to 10000 (10s). */
+    connectTimeout?: number;
 }
 /**
  * WebSocket-based sync transport implementation.
@@ -132,6 +134,7 @@ declare class WebSocketTransport implements SyncTransport {
     private errorHandler;
     private readonly serializer;
     private readonly WebSocketImpl;
+    private readonly connectTimeout;
     constructor(options?: WebSocketTransportOptions);
     connect(url: string, options?: TransportOptions): Promise<void>;
     disconnect(): Promise<void>;
@@ -473,6 +476,7 @@ declare class ReconnectionManager {
     private attempt;
     private timer;
     private stopped;
+    private running;
     private waitResolve;
     constructor(config?: ReconnectionConfig);
     /**
@@ -495,6 +499,10 @@ declare class ReconnectionManager {
      * Exposed for testing purposes.
      */
     getNextDelay(): number;
+    /**
+     * Whether the reconnection loop is currently running.
+     */
+    isRunning(): boolean;
     /**
      * Current attempt number (for testing).
      */

package/dist/index.js

@@ -61,7 +61,8 @@ function isErrorMessage(value) {
 
 // src/protocol/serializer.ts
 import { SyncError } from "@korajs/core";
-import { Reader, Writer } from "protobufjs/minimal";
+import protobuf from "protobufjs/minimal";
+var { Reader, Writer } = protobuf;
 function versionVectorToWire(vector) {
   const wire = {};
   for (const [nodeId, seq] of vector) {
@@ -590,8 +591,10 @@ var WebSocketTransport = class {
   errorHandler = null;
   serializer;
   WebSocketImpl;
+  connectTimeout;
   constructor(options) {
     this.serializer = options?.serializer ?? new JsonMessageSerializer();
+    this.connectTimeout = options?.connectTimeout ?? 1e4;
     if (options?.WebSocketImpl) {
       this.WebSocketImpl = options.WebSocketImpl;
     } else if (typeof globalThis.WebSocket !== "undefined") {
@@ -607,12 +610,38 @@ var WebSocketTransport = class {
       });
     }
     return new Promise((resolve, reject) => {
+      let settled = false;
+      const settle = (fn) => {
+        if (settled) return;
+        settled = true;
+        clearTimeout(timer);
+        fn();
+      };
+      const timer = setTimeout(() => {
+        settle(() => {
+          const err = new SyncError2("WebSocket connection timed out", {
+            url,
+            timeout: this.connectTimeout
+          });
+          if (this.ws) {
+            try {
+              this.ws.onclose = null;
+              this.ws.onerror = null;
+              this.ws.close();
+            } catch {
+            }
+            this.ws = null;
+          }
+          this.errorHandler?.(err);
+          reject(err);
+        });
+      }, this.connectTimeout);
       try {
         const connectUrl = options?.authToken ? `${url}${url.includes("?") ? "&" : "?"}token=${encodeURIComponent(options.authToken)}` : url;
         const ws = new this.WebSocketImpl(connectUrl);
         this.ws = ws;
         ws.onopen = () => {
-          resolve();
+          settle(() => resolve());
         };
         ws.onmessage = (event) => {
           try {
@@ -636,15 +665,17 @@ var WebSocketTransport = class {
           this.errorHandler?.(err);
           if (!this.isConnected()) {
             this.ws = null;
-            reject(err);
+            settle(() => reject(err));
           }
         };
       } catch (err) {
-        reject(
-          err instanceof SyncError2 ? err : new SyncError2("Failed to create WebSocket", {
-            url,
-            error: String(err)
-          })
+        settle(
+          () => reject(
+            err instanceof SyncError2 ? err : new SyncError2("Failed to create WebSocket", {
+              url,
+              error: String(err)
+            })
+          )
         );
       }
     });
@@ -1186,8 +1217,7 @@ var SyncEngine = class {
       };
       this.transport.send(handshake);
     } catch (err) {
-      this.transitionTo("error");
-      this.transitionTo("disconnected");
+      this.ensureDisconnected();
       throw err;
     }
   }
@@ -1549,6 +1579,7 @@ var ReconnectionManager = class {
   attempt = 0;
   timer = null;
   stopped = false;
+  running = false;
   waitResolve = null;
   constructor(config) {
     this.initialDelay = config?.initialDelay ?? 1e3;
@@ -1566,25 +1597,30 @@ var ReconnectionManager = class {
    */
   async start(onReconnect) {
     this.stopped = false;
+    this.running = true;
     this.attempt = 0;
-    while (!this.stopped) {
-      if (this.maxAttempts > 0 && this.attempt >= this.maxAttempts) {
-        return false;
-      }
-      const delay = this.getNextDelay();
-      this.attempt++;
-      await this.wait(delay);
-      if (this.stopped) return false;
-      try {
-        const success = await onReconnect();
-        if (success) {
-          this.reset();
-          return true;
+    try {
+      while (!this.stopped) {
+        if (this.maxAttempts > 0 && this.attempt >= this.maxAttempts) {
+          return false;
+        }
+        const delay = this.getNextDelay();
+        this.attempt++;
+        await this.wait(delay);
+        if (this.stopped) return false;
+        try {
+          const success = await onReconnect();
+          if (success) {
+            this.reset();
+            return true;
+          }
+        } catch {
         }
-      } catch {
       }
+      return false;
+    } finally {
+      this.running = false;
     }
-    return false;
   }
   /**
    * Stop any pending reconnection attempt.
@@ -1617,6 +1653,12 @@ var ReconnectionManager = class {
     const jitterOffset = (this.random() - 0.5) * 2 * jitterRange;
     return Math.max(0, Math.round(baseDelay + jitterOffset));
   }
+  /**
+   * Whether the reconnection loop is currently running.
+   */
+  isRunning() {
+    return this.running;
+  }
   /**
    * Current attempt number (for testing).
    */