@dxos/edge-client 0.6.14-staging.e15392e → 0.7.0

package/dist/lib/node/index.cjs

@@ -47,24 +47,29 @@ __export(node_exports, {
 module.exports = __toCommonJS(node_exports);
 var import_chunk_ANV2HBEH = require("./chunk-ANV2HBEH.cjs");
 __reExport(node_exports, require("@dxos/protocols/buf/dxos/edge/messenger_pb"), module.exports);
-var import_isomorphic_ws = __toESM(require("isomorphic-ws"));
 var import_async = require("@dxos/async");
 var import_context = require("@dxos/context");
 var import_log = require("@dxos/log");
-var import_buf = require("@dxos/protocols/buf");
-var import_messenger_pb = require("@dxos/protocols/buf/dxos/edge/messenger_pb");
 var import_invariant = require("@dxos/invariant");
 var import_proto = require("@dxos/protocols/proto");
+var import_isomorphic_ws = __toESM(require("isomorphic-ws"));
 var import_async2 = require("@dxos/async");
 var import_context2 = require("@dxos/context");
-var import_debug = require("@dxos/debug");
+var import_invariant2 = require("@dxos/invariant");
 var import_log2 = require("@dxos/log");
-var import_credentials = require("@dxos/credentials");
-var import_keyring = require("@dxos/keyring");
-var import_keys = require("@dxos/keys");
+var import_buf = require("@dxos/protocols/buf");
+var import_messenger_pb = require("@dxos/protocols/buf/dxos/edge/messenger_pb");
 var import_async3 = require("@dxos/async");
 var import_context3 = require("@dxos/context");
+var import_debug = require("@dxos/debug");
 var import_log3 = require("@dxos/log");
+var import_credentials = require("@dxos/credentials");
+var import_invariant3 = require("@dxos/invariant");
+var import_keyring = require("@dxos/keyring");
+var import_keys = require("@dxos/keys");
+var import_async4 = require("@dxos/async");
+var import_context4 = require("@dxos/context");
+var import_log4 = require("@dxos/log");
 var import_protocols = require("@dxos/protocols");
 var __dxlog_file = "/home/runner/work/dxos/dxos/packages/core/mesh/edge-client/src/edge-identity.ts";
 var handleAuthChallenge = async (failedResponse, identity) => {
@@ -102,6 +107,195 @@ var handleAuthChallenge = async (failedResponse, identity) => {
   });
   return import_proto.schema.getCodecForType("dxos.halo.credentials.Presentation").encode(presentation);
 };
+function _ts_decorate(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+var __dxlog_file2 = "/home/runner/work/dxos/dxos/packages/core/mesh/edge-client/src/edge-ws-connection.ts";
+var SIGNAL_KEEPALIVE_INTERVAL = 5e3;
+var EdgeWsConnection = class extends import_context2.Resource {
+  constructor(_identity, _connectionInfo, _callbacks) {
+    super();
+    this._identity = _identity;
+    this._connectionInfo = _connectionInfo;
+    this._callbacks = _callbacks;
+  }
+  get info() {
+    return {
+      open: this.isOpen,
+      identity: this._identity.identityKey,
+      device: this._identity.peerKey
+    };
+  }
+  send(message) {
+    (0, import_invariant2.invariant)(this._ws, void 0, {
+      F: __dxlog_file2,
+      L: 48,
+      S: this,
+      A: [
+        "this._ws",
+        ""
+      ]
+    });
+    (0, import_log2.log)("sending...", {
+      peerKey: this._identity.peerKey,
+      payload: import_chunk_ANV2HBEH.protocol.getPayloadType(message)
+    }, {
+      F: __dxlog_file2,
+      L: 49,
+      S: this,
+      C: (f, a) => f(...a)
+    });
+    this._ws.send(import_buf.buf.toBinary(import_messenger_pb.MessageSchema, message));
+  }
+  async _open() {
+    this._ws = new import_isomorphic_ws.default(this._connectionInfo.url, this._connectionInfo.protocolHeader ? [
+      this._connectionInfo.protocolHeader
+    ] : []);
+    this._ws.onopen = () => {
+      if (this.isOpen) {
+        (0, import_log2.log)("connected", void 0, {
+          F: __dxlog_file2,
+          L: 61,
+          S: this,
+          C: (f, a) => f(...a)
+        });
+        this._callbacks.onConnected();
+        this._scheduleHeartbeats();
+      } else {
+        import_log2.log.verbose("connected after becoming inactive", {
+          currentIdentity: this._identity
+        }, {
+          F: __dxlog_file2,
+          L: 65,
+          S: this,
+          C: (f, a) => f(...a)
+        });
+      }
+    };
+    this._ws.onclose = () => {
+      if (this.isOpen) {
+        (0, import_log2.log)("disconnected while being open", void 0, {
+          F: __dxlog_file2,
+          L: 70,
+          S: this,
+          C: (f, a) => f(...a)
+        });
+        this._callbacks.onRestartRequired();
+      }
+    };
+    this._ws.onerror = (event) => {
+      if (this.isOpen) {
+        import_log2.log.warn("edge connection socket error", {
+          error: event.error,
+          info: event.message
+        }, {
+          F: __dxlog_file2,
+          L: 76,
+          S: this,
+          C: (f, a) => f(...a)
+        });
+        this._callbacks.onRestartRequired();
+      } else {
+        import_log2.log.verbose("error ignored on closed connection", {
+          error: event.error
+        }, {
+          F: __dxlog_file2,
+          L: 79,
+          S: this,
+          C: (f, a) => f(...a)
+        });
+      }
+    };
+    this._ws.onmessage = async (event) => {
+      if (!this.isOpen) {
+        import_log2.log.verbose("message ignored on closed connection", {
+          event: event.type
+        }, {
+          F: __dxlog_file2,
+          L: 87,
+          S: this,
+          C: (f, a) => f(...a)
+        });
+        return;
+      }
+      if (event.data === "__pong__") {
+        this._rescheduleHeartbeatTimeout();
+        return;
+      }
+      const data = await (0, import_chunk_ANV2HBEH.toUint8Array)(event.data);
+      if (this.isOpen) {
+        const message = import_buf.buf.fromBinary(import_messenger_pb.MessageSchema, data);
+        (0, import_log2.log)("received", {
+          from: message.source,
+          payload: import_chunk_ANV2HBEH.protocol.getPayloadType(message)
+        }, {
+          F: __dxlog_file2,
+          L: 97,
+          S: this,
+          C: (f, a) => f(...a)
+        });
+        this._callbacks.onMessage(message);
+      }
+    };
+  }
+  async _close() {
+    void this._inactivityTimeoutCtx?.dispose().catch(() => {
+    });
+    try {
+      this._ws?.close();
+      this._ws = void 0;
+    } catch (err) {
+      if (err instanceof Error && err.message.includes("WebSocket is closed before the connection is established.")) {
+        return;
+      }
+      import_log2.log.warn("Error closing websocket", {
+        err
+      }, {
+        F: __dxlog_file2,
+        L: 113,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+    }
+  }
+  _scheduleHeartbeats() {
+    (0, import_invariant2.invariant)(this._ws, void 0, {
+      F: __dxlog_file2,
+      L: 118,
+      S: this,
+      A: [
+        "this._ws",
+        ""
+      ]
+    });
+    (0, import_async2.scheduleTaskInterval)(this._ctx, async () => {
+      this._ws?.send("__ping__");
+    }, SIGNAL_KEEPALIVE_INTERVAL);
+    this._ws.send("__ping__");
+    this._rescheduleHeartbeatTimeout();
+  }
+  _rescheduleHeartbeatTimeout() {
+    if (!this.isOpen) {
+      return;
+    }
+    void this._inactivityTimeoutCtx?.dispose();
+    this._inactivityTimeoutCtx = new import_context2.Context(void 0, {
+      F: __dxlog_file2,
+      L: 137
+    });
+    (0, import_async2.scheduleTask)(this._inactivityTimeoutCtx, () => {
+      if (this.isOpen) {
+        this._callbacks.onRestartRequired();
+      }
+    }, 2 * SIGNAL_KEEPALIVE_INTERVAL);
+  }
+};
+_ts_decorate([
+  import_log2.logInfo
+], EdgeWsConnection.prototype, "info", null);
 var EdgeConnectionClosedError = class extends Error {
   constructor() {
     super("Edge connection closed.");
@@ -112,18 +306,19 @@ var EdgeIdentityChangedError = class extends Error {
     super("Edge identity changed.");
   }
 };
-function _ts_decorate(decorators, target, key, desc) {
+function _ts_decorate2(decorators, target, key, desc) {
   var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
   if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
   else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
   return c > 3 && r && Object.defineProperty(target, key, r), r;
 }
-var __dxlog_file2 = "/home/runner/work/dxos/dxos/packages/core/mesh/edge-client/src/persistent-lifecycle.ts";
+var __dxlog_file3 = "/home/runner/work/dxos/dxos/packages/core/mesh/edge-client/src/persistent-lifecycle.ts";
 var INIT_RESTART_DELAY = 100;
 var DEFAULT_MAX_RESTART_DELAY = 5e3;
-var PersistentLifecycle = class extends import_context2.Resource {
+var PersistentLifecycle = class extends import_context3.Resource {
   constructor({ start, stop, onRestart, maxRestartDelay = DEFAULT_MAX_RESTART_DELAY }) {
     super();
+    this._currentContext = void 0;
     this._restartTask = void 0;
     this._restartAfter = 0;
     this._start = start;
@@ -132,72 +327,90 @@ var PersistentLifecycle = class extends import_context2.Resource {
     this._maxRestartDelay = maxRestartDelay;
   }
   async _open() {
-    this._restartTask = new import_async2.DeferredTask(this._ctx, async () => {
+    this._restartTask = new import_async3.DeferredTask(this._ctx, async () => {
       try {
         await this._restart();
       } catch (err) {
-        import_log2.log.warn("Restart failed", {
+        import_log3.log.warn("Restart failed", {
           err
         }, {
-          F: __dxlog_file2,
-          L: 64,
+          F: __dxlog_file3,
+          L: 65,
           S: this,
           C: (f, a) => f(...a)
         });
         this._restartTask?.schedule();
       }
     });
-    await this._start().catch((err) => {
-      import_log2.log.warn("Start failed", {
+    this._currentContext = await this._start().catch((err) => {
+      import_log3.log.warn("Start failed", {
         err
       }, {
-        F: __dxlog_file2,
-        L: 69,
+        F: __dxlog_file3,
+        L: 70,
         S: this,
         C: (f, a) => f(...a)
       });
       this._restartTask?.schedule();
+      return void 0;
     });
   }
   async _close() {
     await this._restartTask?.join();
-    await this._stop();
+    await this._stopCurrentContext();
     this._restartTask = void 0;
   }
   async _restart() {
-    (0, import_log2.log)(`restarting in ${this._restartAfter}ms`, {
+    (0, import_log3.log)(`restarting in ${this._restartAfter}ms`, {
       state: this._lifecycleState
     }, {
-      F: __dxlog_file2,
-      L: 81,
+      F: __dxlog_file3,
+      L: 83,
       S: this,
       C: (f, a) => f(...a)
     });
-    await this._stop();
-    if (this._lifecycleState !== import_context2.LifecycleState.OPEN) {
+    await this._stopCurrentContext();
+    if (this._lifecycleState !== import_context3.LifecycleState.OPEN) {
       return;
     }
-    await (0, import_context2.cancelWithContext)(this._ctx, (0, import_async2.sleep)(this._restartAfter));
+    await (0, import_context3.cancelWithContext)(this._ctx, (0, import_async3.sleep)(this._restartAfter));
     this._restartAfter = Math.min(Math.max(this._restartAfter * 2, INIT_RESTART_DELAY), this._maxRestartDelay);
-    await (0, import_debug.warnAfterTimeout)(5e3, "Connection establishment takes too long", () => this._start());
+    await (0, import_debug.warnAfterTimeout)(5e3, "Connection establishment takes too long", async () => {
+      this._currentContext = await this._start();
+    });
     this._restartAfter = 0;
     await this._onRestart?.();
   }
+  async _stopCurrentContext() {
+    if (this._currentContext) {
+      try {
+        await this._stop(this._currentContext);
+      } catch (err) {
+        import_log3.log.catch(err, void 0, {
+          F: __dxlog_file3,
+          L: 105,
+          S: this,
+          C: (f, a) => f(...a)
+        });
+      }
+      this._currentContext = void 0;
+    }
+  }
   /**
   * Scheduling restart should be done from outside.
   */
   scheduleRestart() {
-    if (this._lifecycleState !== import_context2.LifecycleState.OPEN) {
+    if (this._lifecycleState !== import_context3.LifecycleState.OPEN) {
       return;
     }
     this._restartTask.schedule();
   }
 };
-_ts_decorate([
-  import_async2.synchronized
+_ts_decorate2([
+  import_async3.synchronized
 ], PersistentLifecycle.prototype, "_open", null);
-_ts_decorate([
-  import_async2.synchronized
+_ts_decorate2([
+  import_async3.synchronized
 ], PersistentLifecycle.prototype, "scheduleRestart", null);
 var getEdgeUrlWithProtocol = (baseUrl, protocol2) => {
   const isSecure = baseUrl.startsWith("https") || baseUrl.startsWith("wss");
@@ -205,30 +418,31 @@ var getEdgeUrlWithProtocol = (baseUrl, protocol2) => {
   url.protocol = protocol2 + (isSecure ? "s" : "");
   return url.toString();
 };
-var __dxlog_file3 = "/home/runner/work/dxos/dxos/packages/core/mesh/edge-client/src/edge-client.ts";
+function _ts_decorate3(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+var __dxlog_file4 = "/home/runner/work/dxos/dxos/packages/core/mesh/edge-client/src/edge-client.ts";
 var DEFAULT_TIMEOUT = 1e4;
-var SIGNAL_KEEPALIVE_INTERVAL = 5e3;
 var EdgeClient = class extends import_context.Resource {
   constructor(_identity, _config) {
     super();
     this._identity = _identity;
     this._config = _config;
-    this.reconnect = new import_async.Event();
-    this.connected = new import_async.Event();
     this._persistentLifecycle = new PersistentLifecycle({
-      start: async () => this._openWebSocket(),
-      stop: async () => this._closeWebSocket(),
-      onRestart: async () => this.reconnect.emit()
+      start: async () => this._connect(),
+      stop: async (state) => this._disconnect(state)
     });
-    this._listeners = /* @__PURE__ */ new Set();
+    this._messageListeners = /* @__PURE__ */ new Set();
+    this._reconnectListeners = /* @__PURE__ */ new Set();
+    this._currentConnection = void 0;
     this._ready = new import_async.Trigger();
-    this._ws = void 0;
-    this._keepaliveCtx = void 0;
-    this._heartBeatContext = void 0;
+    this._isActive = (connection) => connection === this._currentConnection;
     this._baseWsUrl = getEdgeUrlWithProtocol(_config.socketEndpoint, "ws");
     this._baseHttpUrl = getEdgeUrlWithProtocol(_config.socketEndpoint, "http");
   }
-  // TODO(burdon): Attach logging.
   get info() {
     return {
       open: this.isOpen,
@@ -237,7 +451,7 @@ var EdgeClient = class extends import_context.Resource {
     };
   }
   get isConnected() {
-    return Boolean(this._ws) && this._ready.state === import_async.TriggerState.RESOLVED;
+    return Boolean(this._currentConnection) && this._ready.state === import_async.TriggerState.RESOLVED;
   }
   get identityKey() {
     return this._identity.identityKey;
@@ -251,18 +465,39 @@ var EdgeClient = class extends import_context.Resource {
         identity,
         oldIdentity: this._identity
       }, {
-        F: __dxlog_file3,
-        L: 99,
+        F: __dxlog_file4,
+        L: 95,
         S: this,
         C: (f, a) => f(...a)
       });
       this._identity = identity;
+      this._closeCurrentConnection(new EdgeIdentityChangedError());
       this._persistentLifecycle.scheduleRestart();
     }
   }
-  addListener(listener) {
-    this._listeners.add(listener);
-    return () => this._listeners.delete(listener);
+  onMessage(listener) {
+    this._messageListeners.add(listener);
+    return () => this._messageListeners.delete(listener);
+  }
+  onReconnected(listener) {
+    this._reconnectListeners.add(listener);
+    if (this._ready.state === import_async.TriggerState.RESOLVED) {
+      (0, import_async.scheduleMicroTask)(this._ctx, () => {
+        if (this._reconnectListeners.has(listener)) {
+          try {
+            listener();
+          } catch (error) {
+            import_log.log.catch(error, void 0, {
+              F: __dxlog_file4,
+              L: 117,
+              S: this,
+              C: (f, a) => f(...a)
+            });
+          }
+        }
+      });
+    }
+    return () => this._reconnectListeners.delete(listener);
   }
   /**
   * Open connection to messaging service.
@@ -271,8 +506,8 @@ var EdgeClient = class extends import_context.Resource {
     (0, import_log.log)("opening...", {
       info: this.info
     }, {
-      F: __dxlog_file3,
-      L: 114,
+      F: __dxlog_file4,
+      L: 129,
       S: this,
       C: (f, a) => f(...a)
     });
@@ -280,8 +515,8 @@ var EdgeClient = class extends import_context.Resource {
       import_log.log.warn("Error while opening connection", {
         err
       }, {
-        F: __dxlog_file3,
-        L: 116,
+        F: __dxlog_file4,
+        L: 131,
         S: this,
         C: (f, a) => f(...a)
       });
@@ -294,150 +529,137 @@ var EdgeClient = class extends import_context.Resource {
     (0, import_log.log)("closing...", {
       peerKey: this._identity.peerKey
     }, {
-      F: __dxlog_file3,
-      L: 124,
+      F: __dxlog_file4,
+      L: 139,
       S: this,
       C: (f, a) => f(...a)
     });
+    this._closeCurrentConnection();
     await this._persistentLifecycle.close();
   }
-  async _openWebSocket() {
+  async _connect() {
     if (this._ctx.disposed) {
-      return;
+      return void 0;
     }
-    const path = `/ws/${this._identity.identityKey}/${this._identity.peerKey}`;
+    const identity = this._identity;
+    const path = `/ws/${identity.identityKey}/${identity.peerKey}`;
     const protocolHeader = this._config.disableAuth ? void 0 : await this._createAuthHeader(path);
+    if (this._identity !== identity) {
+      (0, import_log.log)("identity changed during auth header request", void 0, {
+        F: __dxlog_file4,
+        L: 153,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+      return void 0;
+    }
+    const restartRequired = new import_async.Trigger();
     const url = new URL(path, this._baseWsUrl);
     (0, import_log.log)("Opening websocket", {
       url: url.toString(),
       protocolHeader
     }, {
-      F: __dxlog_file3,
-      L: 136,
+      F: __dxlog_file4,
+      L: 159,
       S: this,
       C: (f, a) => f(...a)
     });
-    this._ws = new import_isomorphic_ws.default(url, protocolHeader ? [
+    const connection = new EdgeWsConnection(identity, {
+      url,
       protocolHeader
-    ] : []);
-    this._ws.onopen = () => {
-      (0, import_log.log)("opened", this.info, {
-        F: __dxlog_file3,
-        L: 140,
-        S: this,
-        C: (f, a) => f(...a)
-      });
-      this._ready.wake();
-      this.connected.emit();
-    };
-    this._ws.onclose = () => {
-      (0, import_log.log)("closed", this.info, {
-        F: __dxlog_file3,
-        L: 145,
-        S: this,
-        C: (f, a) => f(...a)
-      });
-      this._persistentLifecycle.scheduleRestart();
-    };
-    this._ws.onerror = (event) => {
-      import_log.log.warn("EdgeClient socket error", {
-        error: event.error,
-        info: event.message
-      }, {
-        F: __dxlog_file3,
-        L: 149,
-        S: this,
-        C: (f, a) => f(...a)
-      });
-      this._persistentLifecycle.scheduleRestart();
-    };
-    this._ws.onmessage = async (event) => {
-      if (event.data === "__pong__") {
-        this._onHeartbeat();
-        return;
-      }
-      const data = await (0, import_chunk_ANV2HBEH.toUint8Array)(event.data);
-      const message = import_buf.buf.fromBinary(import_messenger_pb.MessageSchema, data);
-      (0, import_log.log)("received", {
-        peerKey: this._identity.peerKey,
-        payload: import_chunk_ANV2HBEH.protocol.getPayloadType(message)
-      }, {
-        F: __dxlog_file3,
-        L: 162,
-        S: this,
-        C: (f, a) => f(...a)
-      });
-      if (message) {
-        for (const listener of this._listeners) {
-          try {
-            await listener(message);
-          } catch (err) {
-            import_log.log.error("processing", {
-              err,
-              payload: import_chunk_ANV2HBEH.protocol.getPayloadType(message)
-            }, {
-              F: __dxlog_file3,
-              L: 168,
-              S: this,
-              C: (f, a) => f(...a)
-            });
-          }
+    }, {
+      onConnected: () => {
+        if (this._isActive(connection)) {
+          this._ready.wake();
+          this._notifyReconnected();
+        } else {
+          import_log.log.verbose("connected callback ignored, because connection is not active", void 0, {
+            F: __dxlog_file4,
+            L: 169,
+            S: this,
+            C: (f, a) => f(...a)
+          });
+        }
+      },
+      onRestartRequired: () => {
+        if (this._isActive(connection)) {
+          this._closeCurrentConnection();
+          this._persistentLifecycle.scheduleRestart();
+        } else {
+          import_log.log.verbose("restart requested by inactive connection", void 0, {
+            F: __dxlog_file4,
+            L: 177,
+            S: this,
+            C: (f, a) => f(...a)
+          });
+        }
+        restartRequired.wake();
+      },
+      onMessage: (message) => {
+        if (this._isActive(connection)) {
+          this._notifyMessageReceived(message);
+        } else {
+          import_log.log.verbose("ignored a message on inactive connection", {
+            from: message.source,
+            type: message.payload?.typeUrl
+          }, {
+            F: __dxlog_file4,
+            L: 185,
+            S: this,
+            C: (f, a) => f(...a)
+          });
         }
       }
-    };
-    await this._ready.wait({
-      timeout: this._config.timeout ?? DEFAULT_TIMEOUT
-    });
-    (0, import_log.log)("Websocket is ready", {
-      identity: this._identity.identityKey,
-      peer: this._identity.peerKey
-    }, {
-      F: __dxlog_file3,
-      L: 176,
-      S: this,
-      C: (f, a) => f(...a)
-    });
-    this._keepaliveCtx = new import_context.Context(void 0, {
-      F: __dxlog_file3,
-      L: 179
     });
-    (0, import_async.scheduleTaskInterval)(this._keepaliveCtx, async () => {
-      this._ws?.send("__ping__");
-    }, SIGNAL_KEEPALIVE_INTERVAL);
-    this._ws.send("__ping__");
-    this._onHeartbeat();
+    this._currentConnection = connection;
+    await connection.open();
+    await Promise.race([
+      this._ready.wait({
+        timeout: this._config.timeout ?? DEFAULT_TIMEOUT
+      }),
+      restartRequired
+    ]);
+    return connection;
   }
-  async _closeWebSocket() {
-    if (!this._ws) {
-      return;
+  async _disconnect(state) {
+    await state.close();
+  }
+  _closeCurrentConnection(error = new EdgeConnectionClosedError()) {
+    this._currentConnection = void 0;
+    this._ready.throw(error);
+    this._ready.reset();
+  }
+  _notifyReconnected() {
+    for (const listener of this._reconnectListeners) {
+      try {
+        listener();
+      } catch (err) {
+        import_log.log.error("ws reconnect listener failed", {
+          err
+        }, {
+          F: __dxlog_file4,
+          L: 218,
+          S: this,
+          C: (f, a) => f(...a)
+        });
+      }
     }
-    try {
-      this._ready.throw(this.isOpen ? new EdgeIdentityChangedError() : new EdgeConnectionClosedError());
-      this._ready.reset();
-      void this._keepaliveCtx?.dispose();
-      this._keepaliveCtx = void 0;
-      void this._heartBeatContext?.dispose();
-      this._heartBeatContext = void 0;
-      this._ws.onopen = () => {
-      };
-      this._ws.onclose = () => {
-      };
-      this._ws.onerror = () => {
-      };
-      this._ws.close();
-      this._ws = void 0;
-    } catch (err) {
-      if (err instanceof Error && err.message.includes("WebSocket is closed before the connection is established.")) {
-        return;
+  }
+  _notifyMessageReceived(message) {
+    for (const listener of this._messageListeners) {
+      try {
+        listener(message);
+      } catch (err) {
+        import_log.log.error("ws incoming message processing failed", {
+          err,
+          payload: import_chunk_ANV2HBEH.protocol.getPayloadType(message)
+        }, {
+          F: __dxlog_file4,
+          L: 228,
+          S: this,
+          C: (f, a) => f(...a)
+        });
       }
-      import_log.log.warn("Error closing websocket", {
-        err
-      }, {
-        F: __dxlog_file3,
-        L: 215,
-        S: this,
-        C: (f, a) => f(...a)
-      });
     }
   }
   /**
@@ -447,8 +669,8 @@ var EdgeClient = class extends import_context.Resource {
   async send(message) {
     if (this._ready.state !== import_async.TriggerState.RESOLVED) {
       (0, import_log.log)("waiting for websocket to become ready", void 0, {
-        F: __dxlog_file3,
-        L: 225,
+        F: __dxlog_file4,
+        L: 239,
         S: this,
         C: (f, a) => f(...a)
       });
@@ -456,35 +678,13 @@ var EdgeClient = class extends import_context.Resource {
         timeout: this._config.timeout ?? DEFAULT_TIMEOUT
       });
     }
-    if (!this._ws) {
+    if (!this._currentConnection) {
       throw new EdgeConnectionClosedError();
     }
     if (message.source && (message.source.peerKey !== this._identity.peerKey || message.source.identityKey !== this.identityKey)) {
       throw new EdgeIdentityChangedError();
     }
-    (0, import_log.log)("sending...", {
-      peerKey: this._identity.peerKey,
-      payload: import_chunk_ANV2HBEH.protocol.getPayloadType(message)
-    }, {
-      F: __dxlog_file3,
-      L: 238,
-      S: this,
-      C: (f, a) => f(...a)
-    });
-    this._ws.send(import_buf.buf.toBinary(import_messenger_pb.MessageSchema, message));
-  }
-  _onHeartbeat() {
-    if (this._lifecycleState !== import_context.LifecycleState.OPEN) {
-      return;
-    }
-    void this._heartBeatContext?.dispose();
-    this._heartBeatContext = new import_context.Context(void 0, {
-      F: __dxlog_file3,
-      L: 247
-    });
-    (0, import_async.scheduleTask)(this._heartBeatContext, () => {
-      this._persistentLifecycle.scheduleRestart();
-    }, 2 * SIGNAL_KEEPALIVE_INTERVAL);
+    this._currentConnection.send(message);
   }
   async _createAuthHeader(path) {
     const httpUrl = new URL(path, this._baseHttpUrl);
@@ -499,7 +699,7 @@ var EdgeClient = class extends import_context.Resource {
         status: response.status,
         statusText: response.statusText
       }, {
-        F: __dxlog_file3,
+        F: __dxlog_file4,
         L: 264,
         S: this,
         C: (f, a) => f(...a)
@@ -508,10 +708,14 @@ var EdgeClient = class extends import_context.Resource {
     }
   }
 };
+_ts_decorate3([
+  import_log.logInfo
+], EdgeClient.prototype, "info", null);
 var encodePresentationWsAuthHeader = (encodedPresentation) => {
   const encodedToken = Buffer.from(encodedPresentation).toString("base64").replace(/=*$/, "").replaceAll("/", "|");
   return `base64url.bearer.authorization.dxos.org.${encodedToken}`;
 };
+var __dxlog_file5 = "/home/runner/work/dxos/dxos/packages/core/mesh/edge-client/src/auth.ts";
 var createDeviceEdgeIdentity = async (signer, key) => {
   return {
     identityKey: key.toHex(),
@@ -555,6 +759,15 @@ var createChainEdgeIdentity = async (signer, identityKey, peerKey, chain, creden
     identityKey: identityKey.toHex(),
     peerKey: peerKey.toHex(),
     presentCredentials: async ({ challenge }) => {
+      (0, import_invariant3.invariant)(chain, void 0, {
+        F: __dxlog_file5,
+        L: 75,
+        S: void 0,
+        A: [
+          "chain",
+          ""
+        ]
+      });
       return (0, import_credentials.signPresentation)({
         presentation: {
           credentials: credentialsToSign
@@ -607,24 +820,27 @@ var createStubEdgeIdentity = () => {
     }
   };
 };
-var __dxlog_file4 = "/home/runner/work/dxos/dxos/packages/core/mesh/edge-client/src/edge-http-client.ts";
+var __dxlog_file6 = "/home/runner/work/dxos/dxos/packages/core/mesh/edge-client/src/edge-http-client.ts";
 var DEFAULT_RETRY_TIMEOUT = 1500;
 var DEFAULT_RETRY_JITTER = 500;
 var DEFAULT_MAX_RETRIES_COUNT = 3;
 var EdgeHttpClient = class {
   constructor(baseUrl) {
     this._baseUrl = getEdgeUrlWithProtocol(baseUrl, "http");
-    (0, import_log3.log)("created", {
+    (0, import_log4.log)("created", {
       url: this._baseUrl
     }, {
-      F: __dxlog_file4,
+      F: __dxlog_file6,
       L: 42,
       S: this,
       C: (f, a) => f(...a)
     });
   }
   setIdentity(identity) {
-    this._edgeIdentity = identity;
+    if (this._edgeIdentity?.identityKey !== identity.identityKey || this._edgeIdentity?.peerKey !== identity.peerKey) {
+      this._edgeIdentity = identity;
+      this._authHeader = void 0;
+    }
   }
   createAgent(body, args) {
     return this._call("/agents/create", {
@@ -667,19 +883,19 @@ var EdgeHttpClient = class {
     });
   }
   async _call(path, args) {
-    const requestContext = args.context ?? new import_context3.Context(void 0, {
-      F: __dxlog_file4,
-      L: 88
+    const requestContext = args.context ?? new import_context4.Context(void 0, {
+      F: __dxlog_file6,
+      L: 91
     });
     const shouldRetry = createRetryHandler(args);
     const url = `${this._baseUrl}${path.startsWith("/") ? path.slice(1) : path}`;
-    import_log3.log.info("call", {
+    import_log4.log.info("call", {
       method: args.method,
       path,
       request: args.body
     }, {
-      F: __dxlog_file4,
-      L: 92,
+      F: __dxlog_file6,
+      L: 95,
       S: this,
       C: (f, a) => f(...a)
     });
@@ -697,12 +913,12 @@ var EdgeHttpClient = class {
           if (body.success) {
             return body.data;
           }
-          import_log3.log.info("unsuccessful edge response", {
+          import_log4.log.info("unsuccessful edge response", {
             path,
             body
           }, {
-            F: __dxlog_file4,
-            L: 111,
+            F: __dxlog_file6,
+            L: 114,
             S: this,
             C: (f, a) => f(...a)
           });
@@ -722,12 +938,12 @@ var EdgeHttpClient = class {
         processingError = import_protocols.EdgeCallFailedError.fromProcessingFailureCause(error);
       }
       if (processingError.isRetryable && await shouldRetry(requestContext, retryAfterHeaderValue)) {
-        import_log3.log.info("retrying edge request", {
+        import_log4.log.info("retrying edge request", {
           path,
           processingError
         }, {
-          F: __dxlog_file4,
-          L: 130,
+          F: __dxlog_file6,
+          L: 133,
           S: this,
           C: (f, a) => f(...a)
         });
@@ -738,9 +954,9 @@ var EdgeHttpClient = class {
   }
   async _handleUnauthorized(response) {
     if (!this._edgeIdentity) {
-      import_log3.log.warn("edge unauthorized response received before identity was set", void 0, {
-        F: __dxlog_file4,
-        L: 139,
+      import_log4.log.warn("edge unauthorized response received before identity was set", void 0, {
+        F: __dxlog_file6,
+        L: 142,
         S: this,
         C: (f, a) => f(...a)
       });
@@ -748,9 +964,9 @@ var EdgeHttpClient = class {
     }
     const challenge = await handleAuthChallenge(response, this._edgeIdentity);
     this._authHeader = encodeAuthHeader(challenge);
-    (0, import_log3.log)("auth header updated", void 0, {
-      F: __dxlog_file4,
-      L: 144,
+    (0, import_log4.log)("auth header updated", void 0, {
+      F: __dxlog_file6,
+      L: 147,
       S: this,
       C: (f, a) => f(...a)
     });
@@ -770,10 +986,10 @@ var createRetryHandler = (args) => {
       return false;
     }
     if (retryAfter) {
-      await (0, import_async3.sleep)(retryAfter);
+      await (0, import_async4.sleep)(retryAfter);
     } else {
       const timeout = baseTimeout + Math.random() * jitter;
-      await (0, import_async3.sleep)(timeout);
+      await (0, import_async4.sleep)(timeout);
     }
     return true;
   };