@trycourier/courier-react 8.0.14-beta → 8.0.16-beta

package/dist/index.mjs

@@ -4,92 +4,259 @@ import { flushSync } from "react-dom";
 var __defProp$1 = Object.defineProperty;
 var __defNormalProp$1 = (obj, key, value) => key in obj ? __defProp$1(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __publicField$1 = (obj, key, value) => __defNormalProp$1(obj, typeof key !== "symbol" ? key + "" : key, value);
+const CLOSE_CODE_NORMAL_CLOSURE = 1e3;
+const IPW_VERSION = "v1";
 const _CourierSocket = class _CourierSocket2 {
-  constructor(url, options) {
+  constructor(options) {
     __publicField$1(this, "webSocket", null);
-    __publicField$1(this, "pingInterval", null);
-    __publicField$1(this, "onOpen");
-    __publicField$1(this, "onMessageReceived");
-    __publicField$1(this, "onClose");
-    __publicField$1(this, "onError");
+    __publicField$1(this, "retryAttempt", 0);
+    __publicField$1(this, "retryTimeoutId", null);
     __publicField$1(this, "url");
     __publicField$1(this, "options");
-    this.url = url;
+    this.url = options.apiUrls.inbox.webSocket;
     this.options = options;
   }
   /**
-   * Dynamically checks if the WebSocket is connected
+   * Connects to the Courier WebSocket server.
+   *
+   * If the connection is already established, this is a no-op.
+   *
+   * @returns A promise that resolves when the connection is established or rejects if the connection could not be established.
    */
-  get isConnected() {
-    return this.webSocket !== null;
-  }
   async connect() {
-    this.disconnect();
+    var _a;
+    this.clearRetryTimeout();
+    if (this.isConnecting || this.isOpen) {
+      (_a = this.options.logger) == null ? void 0 : _a.info("Attempted to open a WebSocket connection, but one already exists.");
+      return Promise.reject(new Error("WebSocket connection already exists"));
+    }
     return new Promise((resolve, reject) => {
-      try {
-        this.webSocket = new WebSocket(this.url);
-        this.webSocket.onopen = () => {
-          var _a;
-          (_a = this.onOpen) == null ? void 0 : _a.call(this);
-          resolve();
-        };
-        this.webSocket.onmessage = (event) => {
-          var _a;
-          (_a = this.onMessageReceived) == null ? void 0 : _a.call(this, event.data);
-        };
-        this.webSocket.onclose = (event) => {
-          var _a;
-          this.webSocket = null;
-          (_a = this.onClose) == null ? void 0 : _a.call(this, event.code, event.reason);
-        };
-        this.webSocket.onerror = (event) => {
-          var _a;
-          this.webSocket = null;
-          const error = new Error("Courier Socket connection failed");
-          error.originalEvent = event;
-          (_a = this.onError) == null ? void 0 : _a.call(this, error);
-          reject(error);
-        };
-      } catch (error) {
-        this.webSocket = null;
-        reject(error);
-      }
+      this.webSocket = new WebSocket(this.getWebSocketUrl());
+      this.webSocket.addEventListener("open", (event) => {
+        this.retryAttempt = 0;
+        this.onOpen(event);
+        resolve();
+      });
+      this.webSocket.addEventListener("message", async (event) => {
+        var _a2;
+        try {
+          const json = JSON.parse(event.data);
+          if ("event" in json && json.event === "reconnect") {
+            this.close(CLOSE_CODE_NORMAL_CLOSURE);
+            await this.retryConnection(json.retryAfter * 1e3);
+            return;
+          }
+          this.onMessageReceived(json);
+        } catch (error) {
+          (_a2 = this.options.logger) == null ? void 0 : _a2.error("Error parsing socket message", error);
+        }
+      });
+      this.webSocket.addEventListener("close", (event) => {
+        if (event.code !== CLOSE_CODE_NORMAL_CLOSURE) {
+          const courierCloseEvent = _CourierSocket2.parseCloseEvent(event);
+          if (courierCloseEvent.retryAfterSeconds) {
+            this.retryConnection(courierCloseEvent.retryAfterSeconds * 1e3);
+          } else {
+            this.retryConnection();
+          }
+        }
+        this.onClose(event);
+      });
+      this.webSocket.addEventListener("error", (event) => {
+        this.retryConnection();
+        this.onError(event);
+        reject(event);
+      });
     });
   }
-  disconnect() {
-    this.stopPing();
-    if (this.webSocket) {
-      this.webSocket.close(_CourierSocket2.NORMAL_CLOSURE_STATUS);
-      this.webSocket = null;
+  /**
+   * Closes the WebSocket connection.
+   *
+   * See {@link https://developer.mozilla.org/en-US/docs/Web/API/WebSocket/close} for more details.
+   *
+   * @param code The WebSocket close code. Defaults to {@link CLOSE_CODE_NORMAL_CLOSURE}.
+   * @param reason The WebSocket close reason.
+   */
+  close(code = CLOSE_CODE_NORMAL_CLOSURE, reason) {
+    if (this.webSocket === null) {
+      return;
     }
+    this.webSocket.close(code, reason);
+    this.webSocket = null;
   }
-  async send(message) {
-    if (!this.webSocket) {
-      return false;
+  /**
+   * Sends a message to the Courier WebSocket server.
+   *
+   * @param message The message to send. The message will be serialized to a JSON string.
+   */
+  send(message) {
+    var _a;
+    if (this.webSocket === null || this.isConnecting) {
+      (_a = this.options.logger) == null ? void 0 : _a.info("Attempted to send a message, but the WebSocket is not yet open.");
+      return;
     }
     const json = JSON.stringify(message);
-    return this.webSocket.send(json) !== void 0;
+    this.webSocket.send(json);
   }
-  keepAlive(props) {
-    this.stopPing();
-    this.pingInterval = setInterval(async () => {
-      var _a;
+  get userId() {
+    return this.options.userId;
+  }
+  get logger() {
+    return this.options.logger;
+  }
+  /**
+   * Whether the WebSocket connection is currently being established.
+   */
+  get isConnecting() {
+    return this.webSocket !== null && this.webSocket.readyState === WebSocket.CONNECTING;
+  }
+  /**
+   * Whether the WebSocket connection is currently open.
+   */
+  get isOpen() {
+    return this.webSocket !== null && this.webSocket.readyState === WebSocket.OPEN;
+  }
+  /**
+   * Constructs the WebSocket URL for the Courier WebSocket server using context
+   * from the {@link CourierClientOptions} passed to the constructor.
+   *
+   * @returns The WebSocket URL
+   */
+  getWebSocketUrl() {
+    const accessToken = this.options.accessToken;
+    const connectionId = this.options.connectionId;
+    const userId = this.userId;
+    return `${this.url}?auth=${accessToken}&cid=${connectionId}&iwpv=${IPW_VERSION}&userId=${userId}`;
+  }
+  /**
+   * Parses the Retry-After time from the WebSocket close event reason,
+   * and returns a new {@link CourierCloseEvent} with the retry after time in seconds
+   * if present.
+   *
+   * The Courier WebSocket server may send the close event reason in the following format:
+   *
+   * ```json
+   * {
+   *   "Retry-After": "10" // The retry after time in seconds
+   * }
+   * ```
+   *
+   * @see https://developer.mozilla.org/en-US/docs/Web/API/CloseEvent/reason
+   *
+   * @param closeEvent The WebSocket close event.
+   * @returns The WebSocket close event with the retry after time in seconds.
+   */
+  static parseCloseEvent(closeEvent) {
+    if (closeEvent.reason === null || closeEvent.reason === "") {
+      return closeEvent;
+    }
+    try {
+      const jsonReason = JSON.parse(closeEvent.reason);
+      if (!jsonReason[_CourierSocket2.RETRY_AFTER_KEY]) {
+        return closeEvent;
+      }
+      const retryAfterSeconds = parseInt(jsonReason[_CourierSocket2.RETRY_AFTER_KEY]);
+      if (Number.isNaN(retryAfterSeconds) || retryAfterSeconds < 0) {
+        return closeEvent;
+      }
+      return {
+        ...closeEvent,
+        retryAfterSeconds
+      };
+    } catch (error) {
+      return closeEvent;
+    }
+  }
+  /**
+   * Calculates the retry backoff time in milliseconds based on the current retry attempt.
+   */
+  getBackoffTimeInMillis() {
+    const backoffIntervalInMillis = _CourierSocket2.BACKOFF_INTERVALS_IN_MILLIS[this.retryAttempt];
+    const lowerBound = backoffIntervalInMillis - backoffIntervalInMillis * _CourierSocket2.BACKOFF_JITTER_FACTOR;
+    const upperBound = backoffIntervalInMillis + backoffIntervalInMillis * _CourierSocket2.BACKOFF_JITTER_FACTOR;
+    return Math.floor(Math.random() * (upperBound - lowerBound) + lowerBound);
+  }
+  /**
+   * Retries the connection to the Courier WebSocket server after
+   * either {@param suggestedBackoffTimeInMillis} or a random backoff time
+   * calculated using {@link getBackoffTimeInMillis}.
+   *
+   * @param suggestedBackoffTimeInMillis The suggested backoff time in milliseconds.
+   * @returns A promise that resolves when the connection is established or rejects if the connection could not be established.
+   */
+  async retryConnection(suggestedBackoffTimeInMillis) {
+    var _a, _b, _c;
+    if (this.retryTimeoutId !== null) {
+      (_a = this.logger) == null ? void 0 : _a.debug("Skipping retry attempt because a previous retry is already scheduled.");
+      return;
+    }
+    if (this.retryAttempt >= _CourierSocket2.MAX_RETRY_ATTEMPTS) {
+      (_b = this.logger) == null ? void 0 : _b.error(`Max retry attempts (${_CourierSocket2.MAX_RETRY_ATTEMPTS}) reached.`);
+      return;
+    }
+    const backoffTimeInMillis = suggestedBackoffTimeInMillis ?? this.getBackoffTimeInMillis();
+    this.retryTimeoutId = window.setTimeout(async () => {
       try {
-        await this.send({ action: "keepAlive" });
+        await this.connect();
       } catch (error) {
-        (_a = this.options.logger) == null ? void 0 : _a.error("Error occurred on Keep Alive:", error);
       }
-    }, (props == null ? void 0 : props.intervalInMillis) ?? 3e5);
+    }, backoffTimeInMillis);
+    (_c = this.logger) == null ? void 0 : _c.debug(`Retrying connection in ${Math.floor(backoffTimeInMillis / 1e3)}s. Retry attempt ${this.retryAttempt + 1} of ${_CourierSocket2.MAX_RETRY_ATTEMPTS}.`);
+    this.retryAttempt++;
   }
-  stopPing() {
-    if (this.pingInterval) {
-      clearInterval(this.pingInterval);
-      this.pingInterval = null;
+  /**
+   * Clears the retry timeout if it exists.
+   */
+  clearRetryTimeout() {
+    if (this.retryTimeoutId !== null) {
+      window.clearTimeout(this.retryTimeoutId);
+      this.retryTimeoutId = null;
     }
   }
 };
-__publicField$1(_CourierSocket, "NORMAL_CLOSURE_STATUS", 1e3);
+__publicField$1(_CourierSocket, "BACKOFF_JITTER_FACTOR", 0.5);
+__publicField$1(_CourierSocket, "MAX_RETRY_ATTEMPTS", 5);
+__publicField$1(_CourierSocket, "BACKOFF_INTERVALS_IN_MILLIS", [
+  3e4,
+  // 30 seconds
+  6e4,
+  // 1 minute
+  12e4,
+  // 2 minutes
+  24e4,
+  // 4 minutes
+  48e4
+  // 8 minutes
+]);
+__publicField$1(_CourierSocket, "RETRY_AFTER_KEY", "Retry-After");
 let CourierSocket = _CourierSocket;
+var ClientAction = /* @__PURE__ */ ((ClientAction2) => {
+  ClientAction2["Subscribe"] = "subscribe";
+  ClientAction2["Unsubscribe"] = "unsubscribe";
+  ClientAction2["Pong"] = "pong";
+  ClientAction2["Ping"] = "ping";
+  return ClientAction2;
+})(ClientAction || {});
+var ServerAction = /* @__PURE__ */ ((ServerAction2) => {
+  ServerAction2["Ack"] = "ack";
+  ServerAction2["Ping"] = "ping";
+  ServerAction2["Pong"] = "pong";
+  return ServerAction2;
+})(ServerAction || {});
+var MessageEvent = /* @__PURE__ */ ((MessageEvent2) => {
+  MessageEvent2["NewMessage"] = "message";
+  MessageEvent2["Archive"] = "archive";
+  MessageEvent2["ArchiveAll"] = "archive-all";
+  MessageEvent2["ArchiveRead"] = "archive-read";
+  MessageEvent2["Clicked"] = "clicked";
+  MessageEvent2["MarkAllRead"] = "mark-all-read";
+  MessageEvent2["Opened"] = "opened";
+  MessageEvent2["Read"] = "read";
+  MessageEvent2["Unarchive"] = "unarchive";
+  MessageEvent2["Unopened"] = "unopened";
+  MessageEvent2["Unread"] = "unread";
+  return MessageEvent2;
+})(MessageEvent || {});
 const getCourierApiUrls = (urls) => ({
   courier: {
     rest: (urls == null ? void 0 : urls.courier.rest) || "https://api.courier.com",
@@ -131,12 +298,27 @@ class Logger {
     }
   }
 }
-class UUID {
-  static generate(prefix) {
-    const id = Math.random().toString(36).substring(2, 15) + Math.random().toString(36).substring(2, 15);
-    return prefix ? prefix + id : id;
+const _UUID = class _UUID2 {
+  /**
+   * nanoid
+   * Copyright 2017 Andrey Sitnik <andrey@sitnik.ru>
+   *
+   * https://github.com/ai/nanoid/blob/main/LICENSE
+   *
+   * @param size - The size of the UUID to generate.
+   * @returns A string representing the UUID.
+   */
+  static nanoid(size = 21) {
+    let id = "";
+    let bytes = crypto.getRandomValues(new Uint8Array(size |= 0));
+    while (size--) {
+      id += _UUID2.ALPHABET[bytes[size] & 63];
+    }
+    return id;
   }
-}
+};
+__publicField$1(_UUID, "ALPHABET", "useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict");
+let UUID = _UUID;
 class CourierRequestError extends Error {
   constructor(code, message, type) {
     super(message);
@@ -165,7 +347,7 @@ Response JSON: ${JSON.stringify(data.response, null, 2)}
 }
 async function http(props) {
   const validCodes = props.validCodes ?? [200];
-  const uid = props.options.showLogs ? UUID.generate() : void 0;
+  const uid = props.options.showLogs ? UUID.nanoid() : void 0;
   const request = new Request(props.url, {
     method: props.method,
     headers: {
@@ -215,7 +397,7 @@ async function http(props) {
   return data;
 }
 async function graphql(props) {
-  const uid = props.options.showLogs ? UUID.generate() : void 0;
+  const uid = props.options.showLogs ? UUID.nanoid() : void 0;
   if (uid) {
     logRequest(props.options.logger, uid, "GraphQL", {
       url: props.url,
@@ -304,70 +486,120 @@ class BrandClient extends Client {
     return json.data.brand;
   }
 }
-class InboxSocket extends CourierSocket {
+const _CourierInboxSocket = class _CourierInboxSocket2 extends CourierSocket {
   constructor(options) {
-    const url = InboxSocket.buildUrl(options);
-    super(url, options);
-    __publicField$1(this, "receivedMessage");
-    __publicField$1(this, "receivedMessageEvent");
-    this.onMessageReceived = (data) => this.convertToType(data);
+    super(options);
+    __publicField$1(this, "pingIntervalId", null);
+    __publicField$1(this, "messageEventListeners", []);
   }
-  convertToType(data) {
-    var _a, _b, _c, _d;
-    try {
-      const payload = JSON.parse(data);
-      switch (payload.type) {
-        case "event":
-          const messageEvent = JSON.parse(data);
-          (_a = this.receivedMessageEvent) == null ? void 0 : _a.call(this, messageEvent);
-          break;
-        case "message":
-          const message = JSON.parse(data);
-          (_b = this.receivedMessage) == null ? void 0 : _b.call(this, message);
-          break;
-      }
-    } catch (error) {
-      (_c = this.options.logger) == null ? void 0 : _c.error("Error parsing socket message", error);
-      if (error instanceof Error) {
-        (_d = this.onError) == null ? void 0 : _d.call(this, error);
+  onOpen(_) {
+    this.restartPingInterval();
+    return Promise.resolve();
+  }
+  onMessageReceived(data) {
+    if ("action" in data && data.action === ServerAction.Ping) {
+      const envelope = data;
+      this.sendPong(envelope);
+    }
+    if ("event" in data) {
+      for (const listener of this.messageEventListeners) {
+        listener(data);
       }
     }
+    this.restartPingInterval();
+    return Promise.resolve();
   }
-  async sendSubscribe(props) {
-    var _a;
-    const subscription = {
-      action: "subscribe",
+  onClose(_) {
+    return Promise.resolve();
+  }
+  onError(_) {
+    return Promise.resolve();
+  }
+  /**
+   * Sends a subscribe message to the server.
+   *
+   * Subscribes to all events for the user.
+   */
+  sendSubscribe() {
+    const envelope = {
+      tid: UUID.nanoid(),
+      action: ClientAction.Subscribe,
       data: {
-        userAgent: "courier-js",
-        // TODO: Equivalent to Courier.agent.value()
-        channel: this.options.userId,
-        event: "*",
-        version: (props == null ? void 0 : props.version) ?? 5
+        channel: this.userId,
+        event: "*"
       }
     };
-    if (this.options.connectionId) {
-      subscription.data.clientSourceId = this.options.connectionId;
-    }
-    if (this.options.tenantId) {
-      subscription.data.accountId = this.options.tenantId;
-    }
-    (_a = this.options.logger) == null ? void 0 : _a.debug("Sending subscribe request", subscription);
-    await this.send(subscription);
+    this.send(envelope);
   }
-  static buildUrl(options) {
-    var _a;
-    let url = ((_a = options.apiUrls) == null ? void 0 : _a.inbox.webSocket) ?? "";
-    if (options.accessToken) {
-      url += `/?auth=${options.accessToken}`;
+  /**
+   * Sends an unsubscribe message to the server.
+   *
+   * Unsubscribes from all events for the user.
+   */
+  sendUnsubscribe() {
+    const envelope = {
+      tid: UUID.nanoid(),
+      action: ClientAction.Unsubscribe,
+      data: {
+        channel: this.userId
+      }
+    };
+    this.send(envelope);
+  }
+  /**
+   * Adds a message event listener, called when a message event is received
+   * from the Courier WebSocket server.
+   *
+   * @param listener The listener function
+   */
+  addMessageEventListener(listener) {
+    this.messageEventListeners.push(listener);
+  }
+  /**
+   * Send a ping message to the server.
+   *
+   * ping/pong is implemented at the application layer since the browser's
+   * WebSocket implementation does not support control-level ping/pong.
+   */
+  sendPing() {
+    const envelope = {
+      tid: UUID.nanoid(),
+      action: ClientAction.Ping
+    };
+    this.send(envelope);
+  }
+  /**
+   * Send a pong response to the server.
+   *
+   * ping/pong is implemented at the application layer since the browser's
+   * WebSocket implementation does not support control-level ping/pong.
+   */
+  sendPong(incomingMessage) {
+    const response = {
+      tid: incomingMessage.tid,
+      action: ClientAction.Pong
+    };
+    this.send(response);
+  }
+  /**
+   * Restart the ping interval, clearing the previous interval if it exists.
+   */
+  restartPingInterval() {
+    if (this.pingIntervalId) {
+      window.clearInterval(this.pingIntervalId);
     }
-    return url;
+    this.pingIntervalId = window.setInterval(() => {
+      this.sendPing();
+    }, _CourierInboxSocket2.PING_INTERVAL_MILLIS);
   }
-}
+};
+__publicField$1(_CourierInboxSocket, "PING_INTERVAL_MILLIS", 6e4);
+let CourierInboxSocket = _CourierInboxSocket;
 class InboxClient extends Client {
   constructor(options) {
     super(options);
     __publicField$1(this, "socket");
-    this.socket = new InboxSocket(options);
+    this.socket = new CourierInboxSocket(options);
   }
   /**
    * Get paginated messages
@@ -977,7 +1209,7 @@ class TrackingClient extends Client {
 class CourierClient extends Client {
   constructor(props) {
     var _a, _b;
-    const showLogs = props.showLogs !== void 0 ? props.showLogs : process.env.NODE_ENV === "development";
+    const showLogs = props.showLogs !== void 0 ? props.showLogs : false;
     const baseOptions = {
       ...props,
       showLogs,
@@ -1027,7 +1259,7 @@ class AuthenticationListener {
 }
 const _Courier = class _Courier2 {
   constructor() {
-    __publicField$1(this, "id", UUID.generate());
+    __publicField$1(this, "id", UUID.nanoid());
     __publicField$1(this, "instanceClient");
     __publicField$1(this, "_paginationLimit", 24);
     __publicField$1(this, "authenticationListeners", []);
@@ -1060,7 +1292,7 @@ const _Courier = class _Courier2 {
    * @param options - The options for the Courier client
    */
   signIn(props) {
-    const connectionId = props.connectionId ?? UUID.generate();
+    const connectionId = props.connectionId ?? UUID.nanoid();
     this.instanceClient = new CourierClient({ ...props, connectionId });
     this.notifyAuthenticationListeners({ userId: props.userId });
   }
@@ -2042,73 +2274,70 @@ const _CourierInboxDatastore = class _CourierInboxDatastore2 {
     await Promise.all(dataSetPromises);
   }
   async connectSocket() {
-    var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l;
+    var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k;
     const socket = (_a = Courier.shared.client) == null ? void 0 : _a.inbox.socket;
     try {
       if (!socket) {
         (_c = (_b = Courier.shared.client) == null ? void 0 : _b.options.logger) == null ? void 0 : _c.info("CourierInbox socket not available");
         return;
       }
-      (_f = (_d = Courier.shared.client) == null ? void 0 : _d.options.logger) == null ? void 0 : _f.info("CourierInbox socket connectionId:", (_e = Courier.shared.client) == null ? void 0 : _e.options.connectionId);
-      if (socket.isConnected) {
-        (_h = (_g = Courier.shared.client) == null ? void 0 : _g.options.logger) == null ? void 0 : _h.info("CourierInbox socket already connected. Socket will not attempt reconnection.");
+      if (socket.isConnecting || socket.isOpen) {
+        (_f = (_d = Courier.shared.client) == null ? void 0 : _d.options.logger) == null ? void 0 : _f.info(`Inbox socket already connecting or open for client ID: [${(_e = Courier.shared.client) == null ? void 0 : _e.options.connectionId}]`);
         return;
       }
-      socket.receivedMessage = (message) => {
-        this.addMessage(message, 0, "inbox");
-      };
-      socket.receivedMessageEvent = (event) => {
-        let message;
-        if (event.messageId) {
-          message = this.getMessage({ messageId: event.messageId });
+      socket.addMessageEventListener((event) => {
+        if (event.event === MessageEvent.NewMessage) {
+          const message2 = event.data;
+          this.addMessage(message2, 0, "inbox");
+          return;
         }
+        const message = this.getMessage({ messageId: event.messageId });
         switch (event.event) {
-          case "mark-all-read":
+          case MessageEvent.MarkAllRead:
             this.readAllMessages({ canCallApi: false });
             break;
-          case "read":
+          case MessageEvent.Read:
             if (message) {
               this.readMessage({ message, canCallApi: false });
             }
             break;
-          case "unread":
+          case MessageEvent.Unread:
             if (message) {
               this.unreadMessage({ message, canCallApi: false });
             }
             break;
-          case "opened":
+          case MessageEvent.Opened:
             if (message) {
               this.openMessage({ message, canCallApi: false });
             }
             break;
-          case "archive":
+          case MessageEvent.Archive:
             if (message) {
               this.archiveMessage({ message, canCallApi: false });
             }
             break;
-          case "archive-read":
+          case MessageEvent.ArchiveRead:
             this.archiveReadMessages({ canCallApi: false });
             break;
-          case "click":
+          case MessageEvent.Clicked:
             if (message) {
               this.clickMessage({ message, canCallApi: false });
             }
             break;
-          case "unarchive":
+          case MessageEvent.Unarchive:
             if (message) {
               this.unarchiveMessage({ message, canCallApi: false });
             }
             break;
-          case "unopened":
+          case MessageEvent.Unopened:
             break;
         }
-      };
+      });
       await socket.connect();
       await socket.sendSubscribe();
-      socket.keepAlive();
-      (_j = (_i = Courier.shared.client) == null ? void 0 : _i.options.logger) == null ? void 0 : _j.info("CourierInbox socket connected");
+      (_i = (_g = Courier.shared.client) == null ? void 0 : _g.options.logger) == null ? void 0 : _i.info(`Inbox socket connected for client ID: [${(_h = Courier.shared.client) == null ? void 0 : _h.options.connectionId}]`);
     } catch (error) {
-      (_l = (_k = Courier.shared.client) == null ? void 0 : _k.options.logger) == null ? void 0 : _l.error("Failed to connect socket:", error);
+      (_k = (_j = Courier.shared.client) == null ? void 0 : _j.options.logger) == null ? void 0 : _k.error("Failed to connect socket:", error);
     }
   }
   /**
@@ -2118,6 +2347,9 @@ const _CourierInboxDatastore = class _CourierInboxDatastore2 {
    */
   getMessage(props) {
     var _a, _b;
+    if (!props.messageId) {
+      return void 0;
+    }
     return ((_a = this._inboxDataSet) == null ? void 0 : _a.messages.find((m) => m.messageId === props.messageId)) ?? ((_b = this._archiveDataSet) == null ? void 0 : _b.messages.find((m) => m.messageId === props.messageId));
   }
   /**
@@ -5562,284 +5794,12 @@ function requireReactJsxRuntime_production() {
   reactJsxRuntime_production.jsxs = jsxProd;
   return reactJsxRuntime_production;
 }
-var reactJsxRuntime_development = {};
-/**
- * @license React
- * react-jsx-runtime.development.js
- *
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- */
-var hasRequiredReactJsxRuntime_development;
-function requireReactJsxRuntime_development() {
-  if (hasRequiredReactJsxRuntime_development) return reactJsxRuntime_development;
-  hasRequiredReactJsxRuntime_development = 1;
-  "production" !== process.env.NODE_ENV && function() {
-    function getComponentNameFromType(type) {
-      if (null == type) return null;
-      if ("function" === typeof type)
-        return type.$$typeof === REACT_CLIENT_REFERENCE ? null : type.displayName || type.name || null;
-      if ("string" === typeof type) return type;
-      switch (type) {
-        case REACT_FRAGMENT_TYPE:
-          return "Fragment";
-        case REACT_PROFILER_TYPE:
-          return "Profiler";
-        case REACT_STRICT_MODE_TYPE:
-          return "StrictMode";
-        case REACT_SUSPENSE_TYPE:
-          return "Suspense";
-        case REACT_SUSPENSE_LIST_TYPE:
-          return "SuspenseList";
-        case REACT_ACTIVITY_TYPE:
-          return "Activity";
-      }
-      if ("object" === typeof type)
-        switch ("number" === typeof type.tag && console.error(
-          "Received an unexpected object in getComponentNameFromType(). This is likely a bug in React. Please file an issue."
-        ), type.$$typeof) {
-          case REACT_PORTAL_TYPE:
-            return "Portal";
-          case REACT_CONTEXT_TYPE:
-            return (type.displayName || "Context") + ".Provider";
-          case REACT_CONSUMER_TYPE:
-            return (type._context.displayName || "Context") + ".Consumer";
-          case REACT_FORWARD_REF_TYPE:
-            var innerType = type.render;
-            type = type.displayName;
-            type || (type = innerType.displayName || innerType.name || "", type = "" !== type ? "ForwardRef(" + type + ")" : "ForwardRef");
-            return type;
-          case REACT_MEMO_TYPE:
-            return innerType = type.displayName || null, null !== innerType ? innerType : getComponentNameFromType(type.type) || "Memo";
-          case REACT_LAZY_TYPE:
-            innerType = type._payload;
-            type = type._init;
-            try {
-              return getComponentNameFromType(type(innerType));
-            } catch (x) {
-            }
-        }
-      return null;
-    }
-    function testStringCoercion(value) {
-      return "" + value;
-    }
-    function checkKeyStringCoercion(value) {
-      try {
-        testStringCoercion(value);
-        var JSCompiler_inline_result = false;
-      } catch (e) {
-        JSCompiler_inline_result = true;
-      }
-      if (JSCompiler_inline_result) {
-        JSCompiler_inline_result = console;
-        var JSCompiler_temp_const = JSCompiler_inline_result.error;
-        var JSCompiler_inline_result$jscomp$0 = "function" === typeof Symbol && Symbol.toStringTag && value[Symbol.toStringTag] || value.constructor.name || "Object";
-        JSCompiler_temp_const.call(
-          JSCompiler_inline_result,
-          "The provided key is an unsupported type %s. This value must be coerced to a string before using it here.",
-          JSCompiler_inline_result$jscomp$0
-        );
-        return testStringCoercion(value);
-      }
-    }
-    function getTaskName(type) {
-      if (type === REACT_FRAGMENT_TYPE) return "<>";
-      if ("object" === typeof type && null !== type && type.$$typeof === REACT_LAZY_TYPE)
-        return "<...>";
-      try {
-        var name = getComponentNameFromType(type);
-        return name ? "<" + name + ">" : "<...>";
-      } catch (x) {
-        return "<...>";
-      }
-    }
-    function getOwner() {
-      var dispatcher = ReactSharedInternals.A;
-      return null === dispatcher ? null : dispatcher.getOwner();
-    }
-    function UnknownOwner() {
-      return Error("react-stack-top-frame");
-    }
-    function hasValidKey(config) {
-      if (hasOwnProperty.call(config, "key")) {
-        var getter = Object.getOwnPropertyDescriptor(config, "key").get;
-        if (getter && getter.isReactWarning) return false;
-      }
-      return void 0 !== config.key;
-    }
-    function defineKeyPropWarningGetter(props, displayName) {
-      function warnAboutAccessingKey() {
-        specialPropKeyWarningShown || (specialPropKeyWarningShown = true, console.error(
-          "%s: `key` is not a prop. Trying to access it will result in `undefined` being returned. If you need to access the same value within the child component, you should pass it as a different prop. (https://react.dev/link/special-props)",
-          displayName
-        ));
-      }
-      warnAboutAccessingKey.isReactWarning = true;
-      Object.defineProperty(props, "key", {
-        get: warnAboutAccessingKey,
-        configurable: true
-      });
-    }
-    function elementRefGetterWithDeprecationWarning() {
-      var componentName = getComponentNameFromType(this.type);
-      didWarnAboutElementRef[componentName] || (didWarnAboutElementRef[componentName] = true, console.error(
-        "Accessing element.ref was removed in React 19. ref is now a regular prop. It will be removed from the JSX Element type in a future release."
-      ));
-      componentName = this.props.ref;
-      return void 0 !== componentName ? componentName : null;
-    }
-    function ReactElement(type, key, self, source, owner, props, debugStack, debugTask) {
-      self = props.ref;
-      type = {
-        $$typeof: REACT_ELEMENT_TYPE,
-        type,
-        key,
-        props,
-        _owner: owner
-      };
-      null !== (void 0 !== self ? self : null) ? Object.defineProperty(type, "ref", {
-        enumerable: false,
-        get: elementRefGetterWithDeprecationWarning
-      }) : Object.defineProperty(type, "ref", { enumerable: false, value: null });
-      type._store = {};
-      Object.defineProperty(type._store, "validated", {
-        configurable: false,
-        enumerable: false,
-        writable: true,
-        value: 0
-      });
-      Object.defineProperty(type, "_debugInfo", {
-        configurable: false,
-        enumerable: false,
-        writable: true,
-        value: null
-      });
-      Object.defineProperty(type, "_debugStack", {
-        configurable: false,
-        enumerable: false,
-        writable: true,
-        value: debugStack
-      });
-      Object.defineProperty(type, "_debugTask", {
-        configurable: false,
-        enumerable: false,
-        writable: true,
-        value: debugTask
-      });
-      Object.freeze && (Object.freeze(type.props), Object.freeze(type));
-      return type;
-    }
-    function jsxDEVImpl(type, config, maybeKey, isStaticChildren, source, self, debugStack, debugTask) {
-      var children = config.children;
-      if (void 0 !== children)
-        if (isStaticChildren)
-          if (isArrayImpl(children)) {
-            for (isStaticChildren = 0; isStaticChildren < children.length; isStaticChildren++)
-              validateChildKeys(children[isStaticChildren]);
-            Object.freeze && Object.freeze(children);
-          } else
-            console.error(
-              "React.jsx: Static children should always be an array. You are likely explicitly calling React.jsxs or React.jsxDEV. Use the Babel transform instead."
-            );
-        else validateChildKeys(children);
-      if (hasOwnProperty.call(config, "key")) {
-        children = getComponentNameFromType(type);
-        var keys = Object.keys(config).filter(function(k) {
-          return "key" !== k;
-        });
-        isStaticChildren = 0 < keys.length ? "{key: someKey, " + keys.join(": ..., ") + ": ...}" : "{key: someKey}";
-        didWarnAboutKeySpread[children + isStaticChildren] || (keys = 0 < keys.length ? "{" + keys.join(": ..., ") + ": ...}" : "{}", console.error(
-          'A props object containing a "key" prop is being spread into JSX:\n  let props = %s;\n  <%s {...props} />\nReact keys must be passed directly to JSX without using spread:\n  let props = %s;\n  <%s key={someKey} {...props} />',
-          isStaticChildren,
-          children,
-          keys,
-          children
-        ), didWarnAboutKeySpread[children + isStaticChildren] = true);
-      }
-      children = null;
-      void 0 !== maybeKey && (checkKeyStringCoercion(maybeKey), children = "" + maybeKey);
-      hasValidKey(config) && (checkKeyStringCoercion(config.key), children = "" + config.key);
-      if ("key" in config) {
-        maybeKey = {};
-        for (var propName in config)
-          "key" !== propName && (maybeKey[propName] = config[propName]);
-      } else maybeKey = config;
-      children && defineKeyPropWarningGetter(
-        maybeKey,
-        "function" === typeof type ? type.displayName || type.name || "Unknown" : type
-      );
-      return ReactElement(
-        type,
-        children,
-        self,
-        source,
-        getOwner(),
-        maybeKey,
-        debugStack,
-        debugTask
-      );
-    }
-    function validateChildKeys(node) {
-      "object" === typeof node && null !== node && node.$$typeof === REACT_ELEMENT_TYPE && node._store && (node._store.validated = 1);
-    }
-    var React$1 = React, REACT_ELEMENT_TYPE = Symbol.for("react.transitional.element"), REACT_PORTAL_TYPE = Symbol.for("react.portal"), REACT_FRAGMENT_TYPE = Symbol.for("react.fragment"), REACT_STRICT_MODE_TYPE = Symbol.for("react.strict_mode"), REACT_PROFILER_TYPE = Symbol.for("react.profiler");
-    var REACT_CONSUMER_TYPE = Symbol.for("react.consumer"), REACT_CONTEXT_TYPE = Symbol.for("react.context"), REACT_FORWARD_REF_TYPE = Symbol.for("react.forward_ref"), REACT_SUSPENSE_TYPE = Symbol.for("react.suspense"), REACT_SUSPENSE_LIST_TYPE = Symbol.for("react.suspense_list"), REACT_MEMO_TYPE = Symbol.for("react.memo"), REACT_LAZY_TYPE = Symbol.for("react.lazy"), REACT_ACTIVITY_TYPE = Symbol.for("react.activity"), REACT_CLIENT_REFERENCE = Symbol.for("react.client.reference"), ReactSharedInternals = React$1.__CLIENT_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE, hasOwnProperty = Object.prototype.hasOwnProperty, isArrayImpl = Array.isArray, createTask = console.createTask ? console.createTask : function() {
-      return null;
-    };
-    React$1 = {
-      "react-stack-bottom-frame": function(callStackForError) {
-        return callStackForError();
-      }
-    };
-    var specialPropKeyWarningShown;
-    var didWarnAboutElementRef = {};
-    var unknownOwnerDebugStack = React$1["react-stack-bottom-frame"].bind(
-      React$1,
-      UnknownOwner
-    )();
-    var unknownOwnerDebugTask = createTask(getTaskName(UnknownOwner));
-    var didWarnAboutKeySpread = {};
-    reactJsxRuntime_development.Fragment = REACT_FRAGMENT_TYPE;
-    reactJsxRuntime_development.jsx = function(type, config, maybeKey, source, self) {
-      var trackActualOwner = 1e4 > ReactSharedInternals.recentlyCreatedOwnerStacks++;
-      return jsxDEVImpl(
-        type,
-        config,
-        maybeKey,
-        false,
-        source,
-        self,
-        trackActualOwner ? Error("react-stack-top-frame") : unknownOwnerDebugStack,
-        trackActualOwner ? createTask(getTaskName(type)) : unknownOwnerDebugTask
-      );
-    };
-    reactJsxRuntime_development.jsxs = function(type, config, maybeKey, source, self) {
-      var trackActualOwner = 1e4 > ReactSharedInternals.recentlyCreatedOwnerStacks++;
-      return jsxDEVImpl(
-        type,
-        config,
-        maybeKey,
-        true,
-        source,
-        self,
-        trackActualOwner ? Error("react-stack-top-frame") : unknownOwnerDebugStack,
-        trackActualOwner ? createTask(getTaskName(type)) : unknownOwnerDebugTask
-      );
-    };
-  }();
-  return reactJsxRuntime_development;
-}
 var hasRequiredJsxRuntime;
 function requireJsxRuntime() {
   if (hasRequiredJsxRuntime) return jsxRuntime.exports;
   hasRequiredJsxRuntime = 1;
-  if (process.env.NODE_ENV === "production") {
+  {
     jsxRuntime.exports = requireReactJsxRuntime_production();
-  } else {
-    jsxRuntime.exports = requireReactJsxRuntime_development();
   }
   return jsxRuntime.exports;
 }