@vuu-ui/vuu-data-remote 0.13.105 → 0.13.107

package/esm/inlined-worker.js

@@ -405,7 +405,18 @@ var MENU_RPC_TYPES = [
   "VIEW_PORT_MENU_ROW_RPC",
   "VIEW_PORT_MENU_CELL_RPC"
 ];
-var isSelectRequest = (message) => "type" in message && (message.type === "SELECT_ROW" || message.type === "DESELECT_ROW" || message.type === "SELECT_ROW_RANGE" || message.type === "SELECT_ALL" || message.type === "DESELECT_ALL");
+var INVALID_SESSION = "Invalid session";
+var SESSION_LIMIT_EXCEEDED = "User session limit exceeded";
+var INVALID_TOKEN = "Invalid token";
+var TOKEN_EXPIRED = "Token has expired";
+var InvalidLoginMessages = [
+  INVALID_SESSION,
+  SESSION_LIMIT_EXCEEDED,
+  INVALID_TOKEN,
+  TOKEN_EXPIRED
+];
+var isLoginErrorMessage = (message) => typeof message === "string" && InvalidLoginMessages.includes(message);
+var isSelectRequest = (message) => message && typeof message === "object" && "type" in message && (message.type === "SELECT_ROW" || message.type === "DESELECT_ROW" || message.type === "SELECT_ROW_RANGE" || message.type === "SELECT_ALL" || message.type === "DESELECT_ALL");
 var isRpcServiceRequest = (message) => message.type === "RPC_REQUEST";
 var hasViewPortContext = (message) => message.context.type === "VIEWPORT_CONTEXT";
 var isVuuMenuRpcRequest = (message) => MENU_RPC_TYPES.includes(message["type"]);
@@ -1437,9 +1448,195 @@ var toClientRowTree = ({ rowIndex, rowKey, sel: isSelected, data, ts }, keys) =>
   ].concat(rest);
 };
 
+// src/WebSocketConnection.ts
+var { debug: debug3, debugEnabled: debugEnabled3, info: info2 } = logger("WebSocketConnection");
+var isLoginRejectedMessage = (message) => message !== null && "type" in message && message.type === "LOGIN_REJECTED";
+var DEFAULT_CONNECTION_TIMEOUT = 1e4;
+var parseWebSocketMessage = (message) => {
+  try {
+    return JSON.parse(message);
+  } catch (e) {
+    throw Error(\`Error parsing JSON response from server \${message}\`);
+  }
+};
+var _callback, _confirmedOpen, _connectionPhase, _connectionStatus, _connectionTimeout, _deferredOpen, _protocols, _url, _ws;
+var WebSocketConnection = class extends EventEmitter {
+  constructor({
+    callback,
+    connectionTimeout = DEFAULT_CONNECTION_TIMEOUT,
+    protocols,
+    url
+  }) {
+    super();
+    __privateAdd(this, _callback);
+    /**
+     We are not confirmedOpen until we receive the first message from the
+     server. If we get an unexpected close event before that, we consider
+     the reconnect attempts as still within the connection phase, not true
+     reconnection. This can happen e.g. when connecting to remote host via
+     a proxy.
+    */
+    __privateAdd(this, _confirmedOpen, false);
+    __privateAdd(this, _connectionPhase, "initial-connection");
+    __privateAdd(this, _connectionStatus, "closed");
+    __privateAdd(this, _connectionTimeout);
+    __privateAdd(this, _deferredOpen);
+    __privateAdd(this, _protocols);
+    __privateAdd(this, _url);
+    __privateAdd(this, _ws);
+    __publicField(this, "receive", (evt) => {
+      if (isLoginErrorMessage(evt.data)) {
+        console.log(\`[WebSocketConnection] closed because of login issue\`);
+        if (__privateGet(this, _deferredOpen)) {
+          console.log(\`... and qwe have a deferred connection\`);
+        }
+        __privateGet(this, _callback).call(this, {
+          type: "LOGIN_REJECTED",
+          reason: evt.data
+        });
+        this.close(evt.data);
+      } else {
+        const vuuMessageFromServer = parseWebSocketMessage(evt.data);
+        if (debugEnabled3) {
+          if (vuuMessageFromServer.body.type !== "HB") {
+            debug3(\`\${vuuMessageFromServer.body.type}\`);
+            if (vuuMessageFromServer.body.type === "CHANGE_VP_SUCCESS") {
+              debug3(JSON.stringify(vuuMessageFromServer.body));
+            }
+          }
+        }
+        __privateGet(this, _callback).call(this, vuuMessageFromServer);
+        if (!this.confirmedOpen) {
+          if (vuuMessageFromServer.body.type === "LOGIN_SUCCESS") {
+            this.connectionStatus = __privateGet(this, _connectionPhase) === "initial-connection" ? "connected" : "reconnected";
+            this.confirmedOpen = true;
+          }
+        }
+      }
+    });
+    __publicField(this, "send", (msg) => {
+      var _a;
+      if (msg.body.type === "CHANGE_VP_RANGE") {
+        info2 == null ? void 0 : info2(
+          \`CHANGE_VP_RANGE<#\${msg.requestId}> \${msg.body.from}-\${msg.body.to}\`
+        );
+      }
+      (_a = __privateGet(this, _ws)) == null ? void 0 : _a.send(JSON.stringify(msg));
+    });
+    __privateSet(this, _callback, callback);
+    __privateSet(this, _connectionTimeout, connectionTimeout);
+    __privateSet(this, _url, url);
+    __privateSet(this, _protocols, protocols);
+  }
+  get connectionTimeout() {
+    return __privateGet(this, _connectionTimeout);
+  }
+  get protocols() {
+    return __privateGet(this, _protocols);
+  }
+  get isClosed() {
+    return __privateGet(this, _connectionStatus) === "closed";
+  }
+  get isDisconnected() {
+    return __privateGet(this, _connectionStatus) === "disconnected";
+  }
+  get connectionPhase() {
+    return __privateGet(this, _connectionPhase);
+  }
+  get connectionStatus() {
+    return __privateGet(this, _connectionStatus);
+  }
+  set connectionStatus(connectionStatus) {
+    if (connectionStatus !== "connecting" && connectionStatus !== "reconnecting") {
+      __privateSet(this, _connectionStatus, connectionStatus);
+      this.emit("connection-status", __privateGet(this, _connectionStatus));
+    }
+  }
+  get confirmedOpen() {
+    return __privateGet(this, _confirmedOpen);
+  }
+  /**
+   * We are 'confirmedOpen' when we see the first message transmitted
+   * from the server. This ensures that even if we have one or more
+   * proxies in our route to the endPoint, all connections have been
+   * opened successfully.
+   * First time in here (on our initial successful connection) we switch
+   * from 'connect' phase to 'reconnect' phase. We may have different
+   * retry configurations for these two phases.
+   */
+  set confirmedOpen(confirmedOpen) {
+    __privateSet(this, _confirmedOpen, confirmedOpen);
+    if (confirmedOpen && __privateGet(this, _connectionPhase) === "initial-connection") {
+      __privateSet(this, _connectionPhase, "post-disconnect-reconnection");
+    }
+  }
+  get url() {
+    return __privateGet(this, _url);
+  }
+  async openWebSocket() {
+    var _a;
+    const initialConnect = __privateGet(this, _connectionPhase) === "initial-connection";
+    if (__privateGet(this, _deferredOpen) === void 0) {
+      __privateSet(this, _deferredOpen, new DeferredPromise());
+    }
+    const { connectionTimeout, protocols, url } = this;
+    __privateSet(this, _connectionStatus, initialConnect ? "connecting" : "reconnecting");
+    const timer = setTimeout(() => {
+      throw Error(
+        \`Failed to open WebSocket connection to \${url}, timed out after \${connectionTimeout}ms\`
+      );
+    }, connectionTimeout);
+    const ws = __privateSet(this, _ws, new WebSocket(url, protocols));
+    ws.onopen = () => {
+      this.connectionStatus = "websocket-open";
+      clearTimeout(timer);
+      if (__privateGet(this, _deferredOpen)) {
+        __privateGet(this, _deferredOpen).resolve(void 0);
+        __privateSet(this, _deferredOpen, void 0);
+      }
+    };
+    ws.onerror = () => {
+      clearTimeout(timer);
+    };
+    ws.onclose = () => {
+      if (!this.isClosed) {
+        this.confirmedOpen = false;
+        this.connectionStatus = "disconnected";
+        this.close("failure");
+      }
+    };
+    ws.onmessage = (evt) => {
+      this.receive(evt);
+    };
+    return (_a = __privateGet(this, _deferredOpen)) == null ? void 0 : _a.promise;
+  }
+  close(reason = "shutdown") {
+    var _a;
+    this.connectionStatus = "closed";
+    if (reason === "failure") {
+      if (__privateGet(this, _deferredOpen)) {
+        __privateGet(this, _deferredOpen).reject(Error("connection failed"));
+        __privateSet(this, _deferredOpen, void 0);
+      }
+    } else {
+      (_a = __privateGet(this, _ws)) == null ? void 0 : _a.close();
+    }
+    __privateSet(this, _ws, void 0);
+  }
+};
+_callback = new WeakMap();
+_confirmedOpen = new WeakMap();
+_connectionPhase = new WeakMap();
+_connectionStatus = new WeakMap();
+_connectionTimeout = new WeakMap();
+_deferredOpen = new WeakMap();
+_protocols = new WeakMap();
+_url = new WeakMap();
+_ws = new WeakMap();
+
 // src/server-proxy/server-proxy.ts
 var _requestId = 1;
-var { debug: debug3, debugEnabled: debugEnabled3, error: error2, info: info2, infoEnabled: infoEnabled2, warn: warn2 } = logger("ServerProxy");
+var { debug: debug4, debugEnabled: debugEnabled4, error: error2, info: info3, infoEnabled: infoEnabled2, warn: warn2 } = logger("ServerProxy");
 var nextRequestId = () => \`\${_requestId++}\`;
 var DEFAULT_OPTIONS = {};
 var isActiveViewport = (viewPort) => viewPort.disabled !== true && viewPort.suspended !== true;
@@ -1476,13 +1673,15 @@ var ServerProxy = class {
     __publicField(this, "cachedTableMetaRequests", /* @__PURE__ */ new Map());
     __publicField(this, "cachedTableSchemas", /* @__PURE__ */ new Map());
     __publicField(this, "tableList");
-    __publicField(this, "connectionStatusChanged", (message) => {
-      if (message.connectionStatus === "disconnected") {
+    __publicField(this, "connectionStatusChanged", (status) => {
+      if (status === "disconnected") {
+        this.sessionId = void 0;
         this.clearAllViewports();
+      } else if (status === "reconnected") {
+        this.reconnect();
       }
     });
     __publicField(this, "reconnect", async () => {
-      await this.login(this.authToken);
       const [activeViewports, inactiveViewports] = partition(
         Array.from(this.viewports.values()),
         isActiveViewport
@@ -1518,7 +1717,6 @@ var ServerProxy = class {
     this.postMessageToClient = callback;
     this.viewports = /* @__PURE__ */ new Map();
     this.mapClientToServerViewport = /* @__PURE__ */ new Map();
-    connection.on("reconnected", this.reconnect);
     connection.on("connection-status", this.connectionStatusChanged);
   }
   async login(authToken) {
@@ -1574,8 +1772,8 @@ var ServerProxy = class {
         );
         if (clientResponse) {
           this.postMessageToClient(clientResponse);
-          if (debugEnabled3) {
-            debug3(
+          if (debugEnabled4) {
+            debug4(
               \`post DataSourceSubscribedMessage to client: \${JSON.stringify(
                 clientResponse
               )}\`
@@ -1649,7 +1847,7 @@ var ServerProxy = class {
   unsubscribe(clientViewportId) {
     const serverViewportId = this.mapClientToServerViewport.get(clientViewportId);
     if (serverViewportId) {
-      info2 == null ? void 0 : info2(
+      info3 == null ? void 0 : info3(
         \`Unsubscribe Message (Client to Server):
         \${serverViewportId}\`
       );
@@ -1691,26 +1889,26 @@ var ServerProxy = class {
   /**********************************************************************/
   setViewRange(viewport, message) {
     const requestId = nextRequestId();
-    infoEnabled2 && info2(\`setViewRange (\${message.range.from}:\${message.range.to})\`);
+    infoEnabled2 && info3(\`setViewRange (\${message.range.from}:\${message.range.to})\`);
     const [serverRequest, rows, debounceRequest] = viewport.rangeRequest(
       requestId,
       message.range
     );
     if (viewport.status === "subscribed") {
-      info2 == null ? void 0 : info2(\`setViewRange \${message.range.from} - \${message.range.to}\`);
+      info3 == null ? void 0 : info3(\`setViewRange \${message.range.from} - \${message.range.to}\`);
       if (serverRequest) {
         if (true) {
-          info2 == null ? void 0 : info2(
+          info3 == null ? void 0 : info3(
             \`CHANGE_VP_RANGE (\${message.range.from}-\${message.range.to}) => (\${serverRequest.from}-\${serverRequest.to})\`
           );
         }
-        infoEnabled2 && info2(
+        infoEnabled2 && info3(
           \`setViewRange send CHANGE_VP_RANGE<#\${requestId}> (\${serverRequest.from}-\${serverRequest.to})\`
         );
         this.sendMessageToServer(serverRequest, requestId);
       }
       if (rows) {
-        info2 == null ? void 0 : info2(\`setViewRange \${rows.length} rows returned from cache\`);
+        info3 == null ? void 0 : info3(\`setViewRange \${rows.length} rows returned from cache\`);
         this.postMessageToClient({
           mode: "update",
           type: "viewport-update",
@@ -1774,19 +1972,19 @@ var ServerProxy = class {
     viewport.suspend();
     if (escalateToDisable) {
       viewport.suspendTimer = setTimeout(() => {
-        info2 == null ? void 0 : info2("suspendTimer expired, escalate suspend to disable");
+        info3 == null ? void 0 : info3("suspendTimer expired, escalate suspend to disable");
         this.disableViewport(viewport);
       }, escalateDelay);
     }
   }
   resumeViewport(viewport) {
     if (viewport.suspendTimer) {
-      debug3 == null ? void 0 : debug3("clear suspend timer");
+      debug4 == null ? void 0 : debug4("clear suspend timer");
       clearTimeout(viewport.suspendTimer);
       viewport.suspendTimer = null;
     }
     const [size, rows] = viewport.resume();
-    debug3 == null ? void 0 : debug3(\`resumeViewport size \${size}, \${rows.length} rows sent to client\`);
+    debug4 == null ? void 0 : debug4(\`resumeViewport size \${size}, \${rows.length} rows sent to client\`);
     this.postMessageToClient({
       clientViewportId: viewport.clientViewportId,
       mode: "update",
@@ -2036,6 +2234,14 @@ var ServerProxy = class {
   }
   handleMessageFromServer(message) {
     var _a, _b;
+    if (isLoginRejectedMessage(message)) {
+      if (this.pendingLogin) {
+        this.pendingLogin.reject(message.reason);
+        this.pendingLogin = void 0;
+        this.authToken = "";
+      }
+      return;
+    }
     const { body, requestId, sessionId } = message;
     const pendingRequest = this.pendingRequests.get(requestId);
     if (pendingRequest) {
@@ -2065,9 +2271,6 @@ var ServerProxy = class {
           throw Error("LOGIN_SUCCESS did not provide sessionId");
         }
         break;
-      case "LOGIN_FAIL":
-        this.postMessageToClient(body);
-        break;
       case "REMOVE_VP_SUCCESS":
         {
           const viewport = viewports.get(body.viewPortId);
@@ -2114,8 +2317,8 @@ var ServerProxy = class {
             const response = viewport.completeOperation(requestId);
             if (response !== void 0) {
               this.postMessageToClient(response);
-              if (debugEnabled3) {
-                debug3(\`postMessageToClient \${JSON.stringify(response)}\`);
+              if (debugEnabled4) {
+                debug4(\`postMessageToClient \${JSON.stringify(response)}\`);
               }
             }
           }
@@ -2165,28 +2368,28 @@ var ServerProxy = class {
       case "TABLE_ROW":
         {
           const viewportRowMap = groupRowsByViewport(body.rows);
-          if (debugEnabled3) {
+          if (debugEnabled4) {
             const [firstRow] = body.rows;
             if (body.rows.length === 0) {
-              infoEnabled2 && info2("handleMessageFromServer TABLE_ROW 0 rows");
+              infoEnabled2 && info3("handleMessageFromServer TABLE_ROW 0 rows");
             } else if ((firstRow == null ? void 0 : firstRow.rowIndex) === -1) {
               if (body.rows.length === 1) {
                 if (firstRow.updateType === "SIZE") {
-                  infoEnabled2 && info2(
+                  infoEnabled2 && info3(
                     \`handleMessageFromServer [\${firstRow.viewPortId}] TABLE_ROW SIZE ONLY \${firstRow.vpSize}\`
                   );
                 } else {
-                  infoEnabled2 && info2(
+                  infoEnabled2 && info3(
                     \`handleMessageFromServer [\${firstRow.viewPortId}] TABLE_ROW SIZE \${firstRow.vpSize} rowIdx \${firstRow.rowIndex}\`
                   );
                 }
               } else {
-                infoEnabled2 && info2(
+                infoEnabled2 && info3(
                   \`handleMessageFromServer TABLE_ROW \${body.rows.length} rows, SIZE \${firstRow.vpSize}, [\${body.rows.map((r) => r.rowIndex).join(",")}]\`
                 );
               }
             } else {
-              infoEnabled2 && info2(
+              infoEnabled2 && info3(
                 \`handleMessageFromServer TABLE_ROW \${body.rows.length} rows [\${body.rows.map((r) => r.rowIndex).join(",")}]\`
               );
             }
@@ -2209,7 +2412,7 @@ var ServerProxy = class {
           const viewport = this.viewports.get(body.viewPortId);
           if (viewport) {
             const { from, to } = body;
-            infoEnabled2 && info2(\`CHANGE_VP_RANGE_SUCCESS<#\${requestId}> \${from} - \${to}\`);
+            infoEnabled2 && info3(\`CHANGE_VP_RANGE_SUCCESS<#\${requestId}> \${from} - \${to}\`);
             viewport.completeOperation(requestId, from, to);
           }
         }
@@ -2354,7 +2557,7 @@ var ServerProxy = class {
         error2(body.msg);
         break;
       default:
-        infoEnabled2 && info2(\`handleMessageFromServer \${body["type"]}.\`);
+        infoEnabled2 && info3(\`handleMessageFromServer \${body["type"]}.\`);
     }
   }
   cacheTableMeta(messageBody) {
@@ -2393,7 +2596,7 @@ var ServerProxy = class {
           const [rows, mode] = result;
           const size = viewport.getNewRowCount();
           if (size !== void 0 || rows && rows.length > 0) {
-            debugEnabled3 && debug3(
+            debugEnabled4 && debug4(
               \`postMessageToClient #\${viewport.clientViewportId} viewport-update \${mode}, \${(_a = rows == null ? void 0 : rows.length) != null ? _a : "no"} rows, size \${size}\`
             );
             if (mode) {
@@ -2412,316 +2615,31 @@ var ServerProxy = class {
   }
 };
 
-// src/WebSocketConnection.ts
-var { debug: debug4, debugEnabled: debugEnabled4, info: info3 } = logger("WebSocketConnection");
-var isNotConnecting = (connectionState) => connectionState.connectionStatus !== "connecting" && connectionState.connectionStatus !== "reconnecting";
-var isWebSocketConnectionMessage = (msg) => {
-  if ("connectionStatus" in msg) {
-    return [
-      "connecting",
-      "connected",
-      "connection-open-awaiting-session",
-      "reconnecting",
-      "reconnected",
-      "disconnected",
-      "closed",
-      "failed"
-    ].includes(msg.connectionStatus);
-  } else {
-    return false;
-  }
-};
-var DEFAULT_RETRY_LIMITS = {
-  connect: 5,
-  reconnect: 8
-};
-var DEFAULT_CONNECTION_TIMEOUT = 1e4;
-var ConnectingEndState = {
-  connecting: "connected",
-  reconnecting: "reconnected"
-};
-var parseWebSocketMessage = (message) => {
-  try {
-    return JSON.parse(message);
-  } catch (e) {
-    throw Error(\`Error parsing JSON response from server \${message}\`);
-  }
-};
-var _callback, _confirmedOpen, _connectionState, _connectionTimeout, _deferredConnection, _protocols, _reconnectAttempts, _requiresLogin, _url, _ws;
-var WebSocketConnection = class extends EventEmitter {
-  constructor({
-    callback,
-    connectionTimeout = DEFAULT_CONNECTION_TIMEOUT,
-    protocols,
-    retryLimits = DEFAULT_RETRY_LIMITS,
-    url
-  }) {
-    super();
-    __privateAdd(this, _callback);
-    /**
-     We are not confirmedOpen until we receive the first message from the
-     server. If we get an unexpected close event before that, we consider
-     the reconnect attempts as still within the connection phase, not true
-     reconnection. This can happen e.g. when connecting to remote host via
-     a proxy.
-    */
-    __privateAdd(this, _confirmedOpen, false);
-    __privateAdd(this, _connectionState);
-    __privateAdd(this, _connectionTimeout);
-    __privateAdd(this, _deferredConnection);
-    __privateAdd(this, _protocols);
-    __privateAdd(this, _reconnectAttempts);
-    __privateAdd(this, _requiresLogin, true);
-    __privateAdd(this, _url);
-    __privateAdd(this, _ws);
-    __publicField(this, "receive", (evt) => {
-      if (evt.data === "Invalid token" || evt.data === "Token has expired") {
-        const closeReason = evt.data === "Invalid token" ? "invalid-token" : "token-expired";
-        this.close(closeReason);
-      } else {
-        const vuuMessageFromServer = parseWebSocketMessage(evt.data);
-        if (vuuMessageFromServer.body.type === "CHANGE_VP_RANGE_SUCCESS") {
-          info3 == null ? void 0 : info3(\`CHANGE_VP_RANGE_SUCCESS<#\${vuuMessageFromServer.requestId}>\`);
-        }
-        if (debugEnabled4) {
-          if (vuuMessageFromServer.body.type !== "HB") {
-            debug4(\`\${vuuMessageFromServer.body.type}\`);
-            if (vuuMessageFromServer.body.type === "CHANGE_VP_SUCCESS") {
-              debug4(JSON.stringify(vuuMessageFromServer.body));
-            }
-          }
-        }
-        __privateGet(this, _callback).call(this, vuuMessageFromServer);
-      }
-    });
-    __publicField(this, "send", (msg) => {
-      var _a;
-      if (msg.body.type === "CHANGE_VP_RANGE") {
-        info3 == null ? void 0 : info3(
-          \`CHANGE_VP_RANGE<#\${msg.requestId}> \${msg.body.from}-\${msg.body.to}\`
-        );
-      }
-      (_a = __privateGet(this, _ws)) == null ? void 0 : _a.send(JSON.stringify(msg));
-    });
-    __privateSet(this, _callback, callback);
-    __privateSet(this, _connectionTimeout, connectionTimeout);
-    __privateSet(this, _url, url);
-    __privateSet(this, _protocols, protocols);
-    __privateSet(this, _reconnectAttempts, {
-      retryAttemptsTotal: retryLimits.reconnect,
-      retryAttemptsRemaining: retryLimits.reconnect,
-      secondsToNextRetry: 1
-    });
-    __privateSet(this, _connectionState, {
-      connectionPhase: "connecting",
-      connectionStatus: "closed",
-      retryAttemptsTotal: retryLimits.connect,
-      retryAttemptsRemaining: retryLimits.connect,
-      secondsToNextRetry: 1
-    });
-  }
-  get connectionTimeout() {
-    return __privateGet(this, _connectionTimeout);
-  }
-  get protocols() {
-    return __privateGet(this, _protocols);
-  }
-  get requiresLogin() {
-    return __privateGet(this, _requiresLogin);
-  }
-  get isClosed() {
-    return this.status === "closed";
-  }
-  get isDisconnected() {
-    return this.status === "disconnected";
-  }
-  get isConnecting() {
-    return __privateGet(this, _connectionState).connectionPhase === "connecting";
-  }
-  get status() {
-    return __privateGet(this, _connectionState).connectionStatus;
-  }
-  set status(connectionStatus) {
-    __privateSet(this, _connectionState, {
-      ...__privateGet(this, _connectionState),
-      connectionStatus
-    });
-    if (isNotConnecting(__privateGet(this, _connectionState))) {
-      this.emit("connection-status", __privateGet(this, _connectionState));
-    }
-  }
-  get connectionState() {
-    return __privateGet(this, _connectionState);
-  }
-  get hasConnectionAttemptsRemaining() {
-    return __privateGet(this, _connectionState).retryAttemptsRemaining > 0;
-  }
-  get confirmedOpen() {
-    return __privateGet(this, _confirmedOpen);
-  }
-  /**
-   * We are 'confirmedOpen' when we see the first message transmitted
-   * from the server. This ensures that even if we have one or more
-   * proxies in our route to the endPoint, all connections have been
-   * opened successfully.
-   * First time in here (on our initial successful connection) we switch
-   * from 'connect' phase to 'reconnect' phase. We may have different
-   * retry configurations for these two phases.
-   */
-  set confirmedOpen(confirmedOpen) {
-    __privateSet(this, _confirmedOpen, confirmedOpen);
-    if (confirmedOpen && this.isConnecting) {
-      __privateSet(this, _connectionState, {
-        ...__privateGet(this, _connectionState),
-        connectionPhase: "reconnecting",
-        ...__privateGet(this, _reconnectAttempts)
-      });
-    } else if (confirmedOpen) {
-      __privateSet(this, _connectionState, {
-        ...__privateGet(this, _connectionState),
-        ...__privateGet(this, _reconnectAttempts)
-      });
-    }
-  }
-  get url() {
-    return __privateGet(this, _url);
-  }
-  async connect(clientCall = true) {
-    var _a;
-    const state = __privateGet(this, _connectionState);
-    if (this.isConnecting && __privateGet(this, _deferredConnection) === void 0) {
-      __privateSet(this, _deferredConnection, new DeferredPromise());
-    }
-    const { connectionTimeout, protocols, url } = this;
-    this.status = state.connectionPhase;
-    const timer = setTimeout(() => {
-      throw Error(
-        \`Failed to open WebSocket connection to \${url}, timed out after \${connectionTimeout}ms\`
-      );
-    }, connectionTimeout);
-    const ws2 = __privateSet(this, _ws, new WebSocket(url, protocols));
-    ws2.onopen = () => {
-      const connectedStatus = ConnectingEndState[state.connectionPhase];
-      this.status = connectedStatus;
-      clearTimeout(timer);
-      if (__privateGet(this, _deferredConnection)) {
-        __privateGet(this, _deferredConnection).resolve(void 0);
-        __privateSet(this, _deferredConnection, void 0);
-      }
-      if (this.isConnecting) {
-        this.emit("connected");
-      } else {
-        this.emit("reconnected");
-      }
-    };
-    ws2.onerror = () => {
-      clearTimeout(timer);
-    };
-    ws2.onclose = () => {
-      if (!this.isClosed) {
-        this.confirmedOpen = false;
-        this.status = "disconnected";
-        if (this.hasConnectionAttemptsRemaining) {
-          this.reconnect();
-        } else {
-          this.close("failure");
-        }
-      }
-    };
-    ws2.onmessage = (evt) => {
-      if (!this.confirmedOpen) {
-        this.confirmedOpen = true;
-      }
-      this.receive(evt);
-    };
-    if (clientCall) {
-      return (_a = __privateGet(this, _deferredConnection)) == null ? void 0 : _a.promise;
-    }
-  }
-  reconnect() {
-    const { retryAttemptsRemaining, secondsToNextRetry } = __privateGet(this, _connectionState);
-    setTimeout(() => {
-      __privateSet(this, _connectionState, {
-        ...__privateGet(this, _connectionState),
-        retryAttemptsRemaining: retryAttemptsRemaining - 1,
-        secondsToNextRetry: secondsToNextRetry * 2
-      });
-      this.connect(false);
-    }, secondsToNextRetry * 1e3);
-  }
-  close(reason = "shutdown") {
-    var _a;
-    this.status = "closed";
-    if (reason === "failure") {
-      if (__privateGet(this, _deferredConnection)) {
-        __privateGet(this, _deferredConnection).reject(Error("connection failed"));
-        __privateSet(this, _deferredConnection, void 0);
-      }
-    } else {
-      (_a = __privateGet(this, _ws)) == null ? void 0 : _a.close();
-    }
-    this.emit("closed", { type: "websocket-closed", reason });
-    __privateSet(this, _ws, void 0);
-  }
-};
-_callback = new WeakMap();
-_confirmedOpen = new WeakMap();
-_connectionState = new WeakMap();
-_connectionTimeout = new WeakMap();
-_deferredConnection = new WeakMap();
-_protocols = new WeakMap();
-_reconnectAttempts = new WeakMap();
-_requiresLogin = new WeakMap();
-_url = new WeakMap();
-_ws = new WeakMap();
-
 // src/worker.ts
-var server;
+var serverProxy;
+var webSocketConnection;
 var { info: info4, infoEnabled: infoEnabled3 } = logger("worker");
-var getRetryLimits = (retryLimitDisconnect, retryLimitStartup) => {
-  if (retryLimitDisconnect !== void 0 && retryLimitStartup !== void 0) {
-    return {
-      connect: retryLimitStartup,
-      reconnect: retryLimitDisconnect
-    };
-  } else if (retryLimitDisconnect !== void 0) {
-    return {
-      connect: retryLimitDisconnect,
-      reconnect: retryLimitDisconnect
-    };
-  } else if (retryLimitStartup !== void 0) {
-    return {
-      connect: retryLimitStartup,
-      reconnect: retryLimitStartup
-    };
-  }
-};
-var ws;
 var sendMessageToClient = (message) => {
   postMessage(message);
 };
-async function connectToServer(url, protocols, token, retryLimitDisconnect, retryLimitStartup) {
-  const websocketConnection = ws = new WebSocketConnection({
-    callback: (msg) => {
-      if (isConnectionQualityMetrics(msg)) {
-        postMessage({ type: "connection-metrics", messages: msg });
-      } else if (isWebSocketConnectionMessage(msg)) {
-        postMessage(msg);
-      } else {
-        server.handleMessageFromServer(msg);
-      }
-    },
-    protocols,
-    retryLimits: getRetryLimits(retryLimitStartup, retryLimitDisconnect),
-    url
-  });
-  websocketConnection.on("connection-status", postMessage);
-  websocketConnection.on("closed", postMessage);
-  await websocketConnection.connect();
-  server = new ServerProxy(websocketConnection, sendMessageToClient);
-  if (websocketConnection.requiresLogin) {
-    return await server.login(token);
+async function connectToServer(url, protocols, token) {
+  if (webSocketConnection === void 0 && serverProxy === void 0) {
+    webSocketConnection = new WebSocketConnection({
+      callback: (msg) => {
+        if (isConnectionQualityMetrics(msg)) {
+          postMessage({ type: "connection-metrics", messages: msg });
+        } else {
+          serverProxy.handleMessageFromServer(msg);
+        }
+      },
+      protocols,
+      url
+    });
+    webSocketConnection.on("connection-status", postMessage);
+    serverProxy = new ServerProxy(webSocketConnection, sendMessageToClient);
   }
+  await webSocketConnection.openWebSocket();
+  return serverProxy.login(token);
 }
 var handleMessageFromClient = async ({
   data: message
@@ -2732,9 +2650,7 @@ var handleMessageFromClient = async ({
         const sessionId = await connectToServer(
           message.url,
           message.protocol,
-          message.token,
-          message.retryLimitDisconnect,
-          message.retryLimitStartup
+          message.token
         );
         postMessage({ type: "connected", sessionId });
       } catch (err) {
@@ -2744,20 +2660,20 @@ var handleMessageFromClient = async ({
     // If any of the messages below are received BEFORE we have connected and created
     // the server - handle accordingly
     case "disconnect":
-      server.disconnect();
-      ws == null ? void 0 : ws.close();
+      serverProxy.disconnect();
+      webSocketConnection == null ? void 0 : webSocketConnection.close();
       break;
     case "subscribe":
       infoEnabled3 && info4(\`client subscribe: \${JSON.stringify(message)}\`);
-      server.subscribe(message);
+      serverProxy.subscribe(message);
       break;
     case "unsubscribe":
       infoEnabled3 && info4(\`client unsubscribe: \${JSON.stringify(message)}\`);
-      server.unsubscribe(message.viewport);
+      serverProxy.unsubscribe(message.viewport);
       break;
     default:
       infoEnabled3 && info4(\`client message: \${JSON.stringify(message)}\`);
-      server.handleMessageFromClient(message);
+      serverProxy.handleMessageFromClient(message);
   }
 };
 self.addEventListener("message", handleMessageFromClient);