@playdrop/playdrop-cli 0.16.12 → 0.17.0

package/node_modules/@playdrop/api-client/dist/domains/chat.js

@@ -21,175 +21,325 @@ __export(chat_exports, {
 });
 module.exports = __toCommonJS(chat_exports);
 var import_request = require("../core/request.js");
-function pageQuery(options = {}) {
+function chatWebSocketUrl(baseUrl) {
+  const url = new URL(baseUrl);
+  if (url.protocol === "https:")
+    url.protocol = "wss:";
+  else if (url.protocol === "http:")
+    url.protocol = "ws:";
+  else
+    throw new Error("chat_realtime_invalid_api_url");
+  url.pathname = `${url.pathname.replace(/\/$/, "")}/chat/ws`;
+  url.search = "";
+  url.hash = "";
+  return url.toString();
+}
+function parseRealtimeFrame(value) {
+  if (typeof value !== "string")
+    throw new Error("chat_realtime_invalid_frame");
+  let parsed;
+  try {
+    parsed = JSON.parse(value);
+  } catch {
+    throw new Error("chat_realtime_invalid_frame");
+  }
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
+    throw new Error("chat_realtime_invalid_frame");
+  const frame = parsed;
+  const type = frame["type"];
+  if (type === "ready" && typeof frame["heartbeatIntervalMs"] === "number")
+    return parsed;
+  if ((type === "subscribed" || type === "inbox.resync_required" || type === "resync_required") && typeof frame["conversationId"] === "string") {
+    return parsed;
+  }
+  if (type === "conversation.event" && frame["event"] && typeof frame["event"] === "object") {
+    return parsed;
+  }
+  if (type === "inbox.snapshot" && Array.isArray(frame["conversations"])) {
+    return parsed;
+  }
+  if (type === "inbox.event" && frame["event"] && typeof frame["event"] === "object") {
+    return parsed;
+  }
+  if (type === "typing.updated" && typeof frame["conversationId"] === "string" && typeof frame["userId"] === "number" && typeof frame["active"] === "boolean" && typeof frame["expiresAt"] === "string") {
+    return parsed;
+  }
+  if (type === "playtrade.activity.updated" && frame["activity"] && typeof frame["activity"] === "object") {
+    return parsed;
+  }
+  if (type === "playtrade.activity.error" && typeof frame["sessionId"] === "string" && typeof frame["code"] === "string") {
+    return parsed;
+  }
+  if (type === "presence.snapshot" && Array.isArray(frame["entries"]))
+    return parsed;
+  if (type === "presence.updated" && frame["entry"] && typeof frame["entry"] === "object") {
+    return parsed;
+  }
+  if ((type === "platform.subscribed" || type === "platform.event" || type === "platform.resync_required") && typeof frame["topic"] === "string" && typeof frame["eventVersion"] === "string") {
+    return parsed;
+  }
+  if (type === "error" && typeof frame["code"] === "string")
+    return parsed;
+  throw new Error("chat_realtime_invalid_frame");
+}
+function pageQuery(options = {}, legacy = false) {
   const params = new URLSearchParams();
-  if (options.beforeId !== void 0)
-    params.set("beforeId", String(options.beforeId));
+  if (legacy && options.beforeId !== void 0)
+    params.set("beforeId", options.beforeId);
+  if (!legacy && options.before !== void 0)
+    params.set("before", options.before);
+  if (!legacy && options.after !== void 0)
+    params.set("after", options.after);
+  if (!legacy && options.around !== void 0)
+    params.set("around", options.around);
   if (options.limit !== void 0)
     params.set("limit", String(options.limit));
   const query = params.toString();
   return query ? `?${query}` : "";
 }
-function fileName(input) {
-  const explicit = input.fileName?.trim();
-  if (explicit)
-    return explicit;
-  const named = input.file;
-  return typeof named.name === "string" && named.name.trim() ? named.name.trim() : "attachment";
-}
-function needsMultipart(input) {
-  return Boolean(input.files?.length || input.links?.length);
-}
-function jsonPayload(input) {
-  return {
-    ...input.body !== void 0 ? { body: input.body } : {},
-    ...input.attachments !== void 0 ? { attachments: input.attachments } : {},
-    ..."clientKey" in input && input.clientKey !== void 0 ? { clientKey: input.clientKey } : {},
-    ...input.eventType !== void 0 ? { eventType: input.eventType } : {},
-    ...input.eventData !== void 0 ? { eventData: input.eventData } : {},
-    ..."asSystem" in input && input.asSystem !== void 0 ? { asSystem: input.asSystem } : {}
-  };
+function listQuery(input = {}) {
+  const params = new URLSearchParams();
+  if (input.type)
+    params.set("type", input.type);
+  if (input.cursor)
+    params.set("cursor", input.cursor);
+  if (input.limit !== void 0)
+    params.set("limit", String(input.limit));
+  if (input.query)
+    params.set("query", input.query);
+  const query = params.toString();
+  return query ? `?${query}` : "";
 }
 function buildChatApiClientMethods(input) {
   const { request, handleApiError, fetchImpl, includeBrowserCredentials, resolveBaseUrl, resolveUrl, parseResponseBody, resolveToken, getClientHeaders } = input;
-  async function authorizedHeaders() {
+  async function authorizedHeaders(contentType) {
     const headers = new Headers(getClientHeaders());
-    headers.delete("content-type");
+    if (contentType)
+      headers.set("content-type", contentType);
+    else
+      headers.delete("content-type");
     headers.set("accept", "application/json");
     const token = await resolveToken();
     if (token)
       headers.set("authorization", `Bearer ${token}`);
     return headers;
   }
-  async function multipartWrite(method, path, message) {
-    const form = new FormData();
-    form.set("payload", JSON.stringify(jsonPayload(message)));
-    for (const link of message.links ?? [])
-      form.append("link", link);
-    for (const attachment of message.files ?? [])
-      form.append("file", attachment.file, fileName(attachment));
-    const response = await fetchImpl(resolveUrl(resolveBaseUrl(), path), {
-      method,
-      headers: await authorizedHeaders(),
-      body: form,
-      ...(0, import_request.buildBrowserCredentialsInit)(includeBrowserCredentials)
-    });
-    const body = await parseResponseBody(response);
-    const result = { status: response.status, body, headers: response.headers };
-    if (response.status !== 200 && response.status !== 201)
-      handleApiError(result, "chat_write_failed");
-    return body;
-  }
-  return {
-    async fetchChatChannels() {
-      const response = await request({ method: "GET", path: "/chat/channels" });
+  const methods = {
+    async fetchChatConversations(options = {}) {
+      const response = await request({ method: "GET", path: `/chat/conversations${listQuery(options)}` });
       if (response.status !== 200)
-        handleApiError(response, "fetch_chat_channels");
+        handleApiError(response, "fetch_chat_conversations");
       return response.body;
     },
-    async fetchChatMessages(channel, options = {}) {
+    async fetchChatConversation(conversationId) {
+      const response = await request({ method: "GET", path: `/chat/conversations/${encodeURIComponent(conversationId)}` });
+      if (response.status !== 200)
+        handleApiError(response, "fetch_chat_conversation");
+      return response.body;
+    },
+    async createDirectChatConversation(username) {
+      const response = await request({ method: "POST", path: "/chat/direct-conversations", body: { username } });
+      if (response.status !== 200 && response.status !== 201)
+        handleApiError(response, "create_direct_chat_conversation");
+      return response.body;
+    },
+    async fetchConversationMessages(conversationId, options = {}) {
       const response = await request({
         method: "GET",
-        path: `/chat/channels/${encodeURIComponent(channel)}/messages${pageQuery(options)}`
+        path: `/chat/conversations/${encodeURIComponent(conversationId)}/messages${pageQuery(options)}`
       });
       if (response.status !== 200)
         handleApiError(response, "fetch_chat_messages");
       return response.body;
     },
-    async markChatChannelRead(channel, lastReadMessageId) {
+    async sendConversationMessage(conversationId, message) {
       const response = await request({
-        method: "PUT",
-        path: `/chat/channels/${encodeURIComponent(channel)}/read`,
-        body: { lastReadMessageId }
+        method: "POST",
+        path: `/chat/conversations/${encodeURIComponent(conversationId)}/messages`,
+        body: message
       });
-      if (response.status !== 200)
-        handleApiError(response, "mark_chat_channel_read");
+      if (response.status !== 201)
+        handleApiError(response, "send_chat_message");
       return response.body;
     },
-    async fetchChatThread(messageId, options = {}) {
+    async sendSystemChatMessage(channel, message) {
       const response = await request({
-        method: "GET",
-        path: `/chat/messages/${encodeURIComponent(String(messageId))}/replies${pageQuery(options)}`
+        method: "POST",
+        path: `/admin/chat/channels/${encodeURIComponent(channel)}/system-messages`,
+        body: message
       });
-      if (response.status !== 200)
-        handleApiError(response, "fetch_chat_thread");
-      return response.body;
-    },
-    async sendChatMessage(channel, message) {
-      const path = `/chat/channels/${encodeURIComponent(channel)}/messages`;
-      if (needsMultipart(message))
-        return await multipartWrite("POST", path, message);
-      const response = await request({ method: "POST", path, body: jsonPayload(message) });
-      if (response.status !== 200 && response.status !== 201)
-        handleApiError(response, "send_chat_message");
+      if (response.status !== 201)
+        handleApiError(response, "send_system_chat_message");
       return response.body;
     },
     async replyChatMessage(messageId, message) {
-      const path = `/chat/messages/${encodeURIComponent(String(messageId))}/replies`;
-      if (needsMultipart(message))
-        return await multipartWrite("POST", path, message);
-      const response = await request({ method: "POST", path, body: jsonPayload(message) });
-      if (response.status !== 200 && response.status !== 201)
+      const response = await request({
+        method: "POST",
+        path: `/chat/messages/${encodeURIComponent(messageId)}/replies`,
+        body: message
+      });
+      if (response.status !== 201)
         handleApiError(response, "reply_chat_message");
       return response.body;
     },
+    async replySystemChatMessage(messageId, message) {
+      const response = await request({
+        method: "POST",
+        path: `/admin/chat/messages/${encodeURIComponent(messageId)}/system-replies`,
+        body: message
+      });
+      if (response.status !== 201)
+        handleApiError(response, "reply_system_chat_message");
+      return response.body;
+    },
     async editChatMessage(messageId, message) {
-      const path = `/chat/messages/${encodeURIComponent(String(messageId))}`;
-      if (needsMultipart(message))
-        return await multipartWrite("PATCH", path, message);
-      const response = await request({ method: "PATCH", path, body: jsonPayload(message) });
+      const response = await request({ method: "PATCH", path: `/chat/messages/${encodeURIComponent(messageId)}`, body: message });
       if (response.status !== 200)
         handleApiError(response, "edit_chat_message");
       return response.body;
     },
+    async deleteChatMessage(messageId) {
+      const response = await request({ method: "DELETE", path: `/chat/messages/${encodeURIComponent(messageId)}` });
+      if (response.status !== 200)
+        handleApiError(response, "delete_chat_message");
+      return response.body;
+    },
+    async fetchChatThread(messageId, options = {}) {
+      const response = await request({ method: "GET", path: `/chat/messages/${encodeURIComponent(messageId)}/thread${pageQuery(options)}` });
+      if (response.status !== 200)
+        handleApiError(response, "fetch_chat_thread");
+      return response.body;
+    },
     async reactChatMessage(messageId, emoji) {
-      const response = await request({
-        method: "PUT",
-        path: `/chat/messages/${encodeURIComponent(String(messageId))}/reactions/${encodeURIComponent(emoji)}`
-      });
+      const response = await request({ method: "PUT", path: `/chat/messages/${encodeURIComponent(messageId)}/reactions/${encodeURIComponent(emoji)}` });
       if (response.status !== 200)
         handleApiError(response, "react_chat_message");
       return response.body;
     },
     async unreactChatMessage(messageId, emoji) {
-      const response = await request({
-        method: "DELETE",
-        path: `/chat/messages/${encodeURIComponent(String(messageId))}/reactions/${encodeURIComponent(emoji)}`
-      });
+      const response = await request({ method: "DELETE", path: `/chat/messages/${encodeURIComponent(messageId)}/reactions/${encodeURIComponent(emoji)}` });
       if (response.status !== 200)
         handleApiError(response, "unreact_chat_message");
       return response.body;
     },
-    async grantChatAccess(channel, username, canWrite) {
+    async markChatConversationRead(conversationId, lastReadMessageId) {
       const response = await request({
         method: "PUT",
-        path: `/admin/chat/channels/${encodeURIComponent(channel)}/access/${encodeURIComponent(username)}`,
-        body: { canWrite }
+        path: `/chat/conversations/${encodeURIComponent(conversationId)}/read`,
+        body: { lastReadMessageId }
       });
       if (response.status !== 200)
-        handleApiError(response, "grant_chat_access");
+        handleApiError(response, "mark_chat_conversation_read");
       return response.body;
     },
-    async revokeChatAccess(channel, username) {
+    async updateChatConversationState(conversationId, state) {
       const response = await request({
-        method: "DELETE",
-        path: `/admin/chat/channels/${encodeURIComponent(channel)}/access/${encodeURIComponent(username)}`
+        method: "PATCH",
+        path: `/chat/conversations/${encodeURIComponent(conversationId)}/state`,
+        body: state
       });
+      if (response.status !== 200)
+        handleApiError(response, "update_chat_conversation_state");
+      return response.body;
+    },
+    async reportChatMessage(messageId, body) {
+      const response = await request({ method: "POST", path: `/chat/messages/${encodeURIComponent(messageId)}/report`, body });
+      if (response.status !== 201)
+        handleApiError(response, "report_chat_message");
+      return response.body;
+    },
+    async fetchChatFriends(options = {}) {
+      const response = await request({ method: "GET", path: `/me/friends${listQuery(options)}` });
+      if (response.status !== 200)
+        handleApiError(response, "fetch_chat_friends");
+      return response.body;
+    },
+    async fetchChatContacts(options = {}) {
+      const response = await request({ method: "GET", path: `/me/chat-contacts${listQuery(options)}` });
+      if (response.status !== 200)
+        handleApiError(response, "fetch_chat_contacts");
+      return response.body;
+    },
+    async fetchChatNotificationPreferences() {
+      const response = await request({ method: "GET", path: "/me/chat-notification-preferences" });
+      if (response.status !== 200)
+        handleApiError(response, "fetch_chat_notification_preferences");
+      return response.body;
+    },
+    async updateChatNotificationPreferences(preferences) {
+      const response = await request({ method: "PATCH", path: "/me/chat-notification-preferences", body: preferences });
+      if (response.status !== 200)
+        handleApiError(response, "update_chat_notification_preferences");
+      return response.body;
+    },
+    async createChatAttachmentUploadSession(conversationId, file) {
+      const response = await request({
+        method: "POST",
+        path: `/chat/conversations/${encodeURIComponent(conversationId)}/attachment-upload-sessions`,
+        body: file
+      });
+      if (response.status !== 201)
+        handleApiError(response, "create_chat_attachment_upload_session");
+      return response.body;
+    },
+    async uploadChatAttachment(session, file) {
+      const isSignedUpload = /^https?:/i.test(session.uploadUrl);
+      const response = await fetchImpl(resolveUrl(resolveBaseUrl(), session.uploadUrl), {
+        method: session.uploadMethod,
+        headers: isSignedUpload ? { "content-type": file.type || "application/octet-stream", ...session.uploadHeaders } : await authorizedHeaders(file.type || "application/octet-stream"),
+        body: file,
+        ...!isSignedUpload ? (0, import_request.buildBrowserCredentialsInit)(includeBrowserCredentials) : {}
+      });
+      if (!response.ok) {
+        const body = await parseResponseBody(response);
+        handleApiError({ status: response.status, body, headers: response.headers }, "upload_chat_attachment");
+      }
+    },
+    async completeChatAttachmentUploadSession(sessionId) {
+      const response = await request({ method: "POST", path: `/chat/attachment-upload-sessions/${encodeURIComponent(sessionId)}/complete` });
+      if (response.status !== 200)
+        handleApiError(response, "complete_chat_attachment_upload_session");
+    },
+    async abortChatAttachmentUploadSession(sessionId) {
+      const response = await request({ method: "DELETE", path: `/chat/attachment-upload-sessions/${encodeURIComponent(sessionId)}` });
       if (response.status !== 204)
-        handleApiError(response, "revoke_chat_access");
+        handleApiError(response, "abort_chat_attachment_upload_session");
+    },
+    async createCommunityChatChannel(input2) {
+      const response = await request({ method: "POST", path: "/admin/chat/community-channels", body: input2 });
+      if (response.status !== 201)
+        handleApiError(response, "create_community_chat_channel");
+      return response.body;
     },
-    async setChatVisibility(channel, readPolicy) {
+    async updateCommunityChatChannel(conversationId, input2) {
+      const response = await request({ method: "PATCH", path: `/admin/chat/community-channels/${encodeURIComponent(conversationId)}`, body: input2 });
+      if (response.status !== 200)
+        handleApiError(response, "update_community_chat_channel");
+      return response.body;
+    },
+    async fetchAdminDirectConversations(options = {}) {
+      const response = await request({ method: "GET", path: `/admin/chat/direct-conversations${listQuery(options)}` });
+      if (response.status !== 200)
+        handleApiError(response, "fetch_admin_direct_conversations");
+      return response.body;
+    },
+    async fetchAdminDirectConversationMessages(conversationId, options = {}) {
+      const response = await request({ method: "GET", path: `/admin/chat/direct-conversations/${encodeURIComponent(conversationId)}/messages${pageQuery(options)}` });
+      if (response.status !== 200)
+        handleApiError(response, "fetch_admin_direct_conversation_messages");
+      return response.body;
+    },
+    async moderateAdminDirectConversationMessage(conversationId, messageId) {
       const response = await request({
-        method: "PATCH",
-        path: `/admin/chat/channels/${encodeURIComponent(channel)}/read-policy`,
-        body: { readPolicy }
+        method: "DELETE",
+        path: `/admin/chat/direct-conversations/${encodeURIComponent(conversationId)}/messages/${encodeURIComponent(messageId)}`
       });
       if (response.status !== 200)
-        handleApiError(response, "set_chat_visibility");
+        handleApiError(response, "moderate_admin_direct_conversation_message");
       return response.body;
     },
     async fetchChatAttachment(attachmentId) {
-      const response = await fetchImpl(resolveUrl(resolveBaseUrl(), `/chat/attachments/${encodeURIComponent(String(attachmentId))}`), {
+      const response = await fetchImpl(resolveUrl(resolveBaseUrl(), `/chat/attachments/${encodeURIComponent(attachmentId)}`), {
         method: "GET",
         headers: await authorizedHeaders(),
         ...(0, import_request.buildBrowserCredentialsInit)(includeBrowserCredentials)
@@ -199,8 +349,235 @@ function buildChatApiClientMethods(input) {
         handleApiError({ status: response.status, body, headers: response.headers }, "fetch_chat_attachment");
       }
       return await response.blob();
+    },
+    async fetchChatChannels() {
+      const response = await request({ method: "GET", path: "/chat/channels" });
+      if (response.status !== 200)
+        handleApiError(response, "fetch_chat_channels");
+      return response.body;
+    },
+    async fetchChatMessages(channel, options = {}) {
+      const response = await request({ method: "GET", path: `/chat/channels/${encodeURIComponent(channel)}/messages${pageQuery(options, true)}` });
+      if (response.status !== 200)
+        handleApiError(response, "fetch_chat_messages");
+      return response.body;
+    },
+    async markChatChannelRead(channel, lastReadMessageId) {
+      const response = await request({ method: "PUT", path: `/chat/channels/${encodeURIComponent(channel)}/read`, body: { lastReadMessageId } });
+      if (response.status !== 200)
+        handleApiError(response, "mark_chat_channel_read");
+      return response.body;
+    },
+    async sendChatMessage(channel, message) {
+      const response = await request({ method: "POST", path: `/chat/channels/${encodeURIComponent(channel)}/messages`, body: message });
+      if (response.status !== 201)
+        handleApiError(response, "send_chat_message");
+      return response.body;
+    },
+    connectChatRealtime(options) {
+      let socket = null;
+      let reconnectTimer = null;
+      let stopped = false;
+      let attempt = 0;
+      let presenceContext = "ONLINE";
+      const subscriptions = new Map((options.subscriptions ?? []).map((subscription) => [
+        subscription.conversationId,
+        subscription.lastEventVersion ?? null
+      ]));
+      const platformSubscriptions = new Map((options.platformSubscriptions ?? []).map((subscription) => [
+        subscription.topic,
+        subscription.lastEventVersion ?? null
+      ]));
+      const notifyState = (state) => options.onStateChange?.(state);
+      const factory = options.webSocketFactory ?? ((url) => {
+        if (typeof globalThis.WebSocket !== "function")
+          throw new Error("chat_realtime_websocket_unavailable");
+        return new globalThis.WebSocket(url);
+      });
+      const send = (frame) => {
+        if (socket?.readyState === 1)
+          socket.send(JSON.stringify(frame));
+      };
+      const sendSubscriptions = () => {
+        for (const [conversationId, lastEventVersion] of subscriptions) {
+          send({ type: "subscribe", conversationId, lastEventVersion });
+        }
+        for (const [topic, lastEventVersion] of platformSubscriptions) {
+          send({ type: "platform.subscribe", topic, lastEventVersion });
+        }
+      };
+      const scheduleReconnect = () => {
+        if (stopped || reconnectTimer)
+          return;
+        notifyState("reconnecting");
+        const exponentialDelay = Math.min(500 * 2 ** Math.min(attempt, 6), 3e4);
+        const delay = Math.round(exponentialDelay * (0.8 + Math.random() * 0.4));
+        attempt += 1;
+        reconnectTimer = setTimeout(() => {
+          reconnectTimer = null;
+          void connect();
+        }, delay);
+      };
+      const connect = async () => {
+        if (stopped)
+          return;
+        notifyState(attempt === 0 ? "connecting" : "reconnecting");
+        let token;
+        try {
+          token = await resolveToken() ?? "cookie";
+          if (stopped)
+            return;
+          socket = factory(chatWebSocketUrl(resolveBaseUrl()));
+        } catch (error) {
+          const code = error instanceof Error ? error.message : "chat_realtime_connection_failed";
+          options.onError?.(code);
+          if (code === "chat_realtime_unauthorized") {
+            stopped = true;
+            notifyState("closed");
+          } else
+            scheduleReconnect();
+          return;
+        }
+        const activeSocket = socket;
+        activeSocket.addEventListener("open", () => {
+          if (!stopped && activeSocket === socket)
+            activeSocket.send(JSON.stringify({ type: "auth", token }));
+        });
+        activeSocket.addEventListener("message", (event) => {
+          if (stopped || activeSocket !== socket)
+            return;
+          try {
+            const frame = parseRealtimeFrame(event.data);
+            if (frame.type === "ready") {
+              attempt = 0;
+              notifyState("ready");
+              sendSubscriptions();
+              send({ type: "presence.context", context: presenceContext });
+            } else if (frame.type === "subscribed") {
+              subscriptions.set(frame.conversationId, frame.eventVersion);
+            } else if (frame.type === "conversation.event") {
+              try {
+                options.onEvent(frame.event);
+                subscriptions.set(frame.event.conversationId, frame.event.version);
+              } catch {
+                options.onError?.("chat_realtime_event_handler_failed");
+                activeSocket.close(1011, "chat_realtime_event_handler_failed");
+              }
+            } else if (frame.type === "inbox.snapshot") {
+              options.onInboxSnapshot?.(frame.conversations);
+            } else if (frame.type === "inbox.event") {
+              options.onInboxEvent?.(frame.event);
+            } else if (frame.type === "inbox.resync_required") {
+              options.onInboxResyncRequired?.(frame.conversationId);
+            } else if (frame.type === "typing.updated") {
+              options.onTypingUpdated?.(frame);
+            } else if (frame.type === "presence.snapshot") {
+              options.onPresenceSnapshot?.(frame.entries);
+            } else if (frame.type === "presence.updated") {
+              options.onPresenceUpdated?.(frame.entry);
+            } else if (frame.type === "platform.subscribed") {
+              platformSubscriptions.set(frame.topic, frame.eventVersion);
+            } else if (frame.type === "platform.event") {
+              options.onPlatformEvent?.({ topic: frame.topic, eventVersion: frame.eventVersion, resync: false });
+              platformSubscriptions.set(frame.topic, frame.eventVersion);
+            } else if (frame.type === "platform.resync_required") {
+              options.onPlatformEvent?.({ topic: frame.topic, eventVersion: frame.eventVersion, resync: true });
+              platformSubscriptions.set(frame.topic, frame.eventVersion);
+            } else if (frame.type === "playtrade.activity.updated") {
+              options.onPlayTradeActivity?.({ type: "updated", activity: frame.activity });
+            } else if (frame.type === "playtrade.activity.error") {
+              options.onPlayTradeActivity?.({
+                type: "error",
+                sessionId: frame.sessionId,
+                code: frame.code
+              });
+            } else if (frame.type === "resync_required") {
+              subscriptions.set(frame.conversationId, null);
+              options.onResyncRequired?.(frame.conversationId);
+            } else {
+              options.onError?.(frame.code);
+              if (frame.code === "chat_realtime_unauthorized")
+                stopped = true;
+            }
+          } catch (error) {
+            options.onError?.(error instanceof Error ? error.message : "chat_realtime_invalid_frame");
+            activeSocket.close(1008, "chat_realtime_invalid_frame");
+          }
+        });
+        activeSocket.addEventListener("error", () => {
+          if (!stopped && activeSocket === socket)
+            options.onError?.("chat_realtime_connection_failed");
+        });
+        activeSocket.addEventListener("close", (event) => {
+          if (activeSocket !== socket)
+            return;
+          socket = null;
+          if (stopped)
+            notifyState("closed");
+          else if (event.code === 1008 && event.reason === "chat_realtime_token_expired") {
+            attempt = Math.max(attempt, 1);
+            void connect();
+          } else if (event.code === 1008) {
+            stopped = true;
+            options.onError?.(event.reason || "chat_realtime_forbidden");
+            notifyState("closed");
+          } else
+            scheduleReconnect();
+        });
+      };
+      void connect();
+      return {
+        close() {
+          if (stopped)
+            return;
+          stopped = true;
+          if (reconnectTimer)
+            clearTimeout(reconnectTimer);
+          reconnectTimer = null;
+          socket?.close(1e3, "chat_realtime_client_closed");
+          socket = null;
+          notifyState("closed");
+        },
+        subscribe(conversationId, lastEventVersion = null) {
+          subscriptions.set(conversationId, lastEventVersion);
+          send({ type: "subscribe", conversationId, lastEventVersion });
+        },
+        unsubscribe(conversationId) {
+          subscriptions.delete(conversationId);
+          send({ type: "unsubscribe", conversationId });
+        },
+        setTyping(conversationId, active) {
+          if (!subscriptions.has(conversationId))
+            throw new Error("chat_realtime_not_subscribed");
+          send({ type: "typing", conversationId, active });
+        },
+        setPresenceContext(context) {
+          presenceContext = context;
+          send({ type: "presence.context", context });
+        },
+        getLastEventVersion(conversationId) {
+          return subscriptions.get(conversationId) ?? null;
+        },
+        subscribePlatform(topic, lastEventVersion = null) {
+          platformSubscriptions.set(topic, lastEventVersion);
+          send({ type: "platform.subscribe", topic, lastEventVersion });
+        },
+        unsubscribePlatform(topic) {
+          platformSubscriptions.delete(topic);
+          send({ type: "platform.unsubscribe", topic });
+        },
+        getPlatformEventVersion(topic) {
+          return platformSubscriptions.get(topic) ?? null;
+        },
+        sendPlayTradeActivity(frame) {
+          if (stopped || socket?.readyState !== 1)
+            throw new Error("chat_realtime_not_ready");
+          send({ type: "playtrade.activity", ...frame });
+        }
+      };
     }
   };
+  return methods;
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {