@antzsoft/chat-core 1.4.2 → 1.4.4

package/dist/index.cjs

@@ -108,6 +108,7 @@ __export(src_exports, {
   AntzChatPermissionError: () => AntzChatPermissionError,
   AntzChatServerError: () => AntzChatServerError,
   AntzChatValidationError: () => AntzChatValidationError,
+  HIGHLY_FORWARDED_DEPTH_THRESHOLD: () => HIGHLY_FORWARDED_DEPTH_THRESHOLD,
   MAX_FORWARD_TARGETS: () => MAX_FORWARD_TARGETS,
   MENTION_ALL_ID: () => MENTION_ALL_ID,
   appConfigApi: () => appConfigApi,
@@ -1012,530 +1013,16 @@ function resolveSystemMessageText(message, currentUserId) {
   }
 }
 
-// src/api/messages.ts
-var MAX_FORWARD_TARGETS = 5;
-var messagesApi = {
-  async list(conversationId, params = {}) {
-    const { cursor, direction, ...rest } = params;
-    const serverParams = { ...rest };
-    if (cursor) {
-      serverParams[direction === "after" ? "after" : "before"] = cursor;
-    }
-    const { data } = await getApiClient().get(
-      `/conversations/${conversationId}/messages`,
-      { params: serverParams }
-    );
-    const currentUserId = getAuthStore().useAuthStore.getState().user?.id;
-    if (!currentUserId) return data;
-    return {
-      ...data,
-      data: data.data.map(
-        (m) => m.content.type === "system" ? { ...m, content: { ...m.content, text: resolveSystemMessageText(m, currentUserId) } } : m
-      )
-    };
-  },
-  async get(messageId) {
-    const { data } = await getApiClient().get(`/messages/${messageId}`);
-    return data;
-  },
-  async send(conversationId, payload) {
-    const { data } = await getApiClient().post(
-      `/conversations/${conversationId}/messages`,
-      payload
-    );
-    return data;
-  },
-  async update(messageId, text) {
-    const { data } = await getApiClient().post(`/messages/${messageId}/update`, { text });
-    return data;
-  },
-  async delete(messageId) {
-    await getApiClient().post(`/messages/${messageId}/delete`);
-  },
-  async deleteForMe(messageId) {
-    await getApiClient().post(`/messages/${messageId}/delete-for-me`);
-  },
-  async addReaction(messageId, emoji) {
-    const { data } = await getApiClient().post(`/messages/${messageId}/reactions`, { emoji });
-    return data;
-  },
-  async removeReaction(messageId, emoji) {
-    const { data } = await getApiClient().post(
-      `/messages/${messageId}/reactions/${encodeURIComponent(emoji)}/remove`
-    );
-    return data;
-  },
-  async getReactions(messageId) {
-    const { data } = await getApiClient().post(`/messages/${messageId}/reactions/list`);
-    return data;
-  },
-  async star(messageId) {
-    await getApiClient().post(`/messages/${messageId}/star`);
-  },
-  async unstar(messageId) {
-    await getApiClient().post(`/messages/${messageId}/unstar`);
-  },
-  async getStarred(params = {}) {
-    const { data } = await getApiClient().get("/messages/starred", { params });
-    return data;
-  },
-  async search(params) {
-    const { data } = await getApiClient().get("/messages/search", { params });
-    return data;
-  },
-  async getLastRead(conversationId) {
-    const { data } = await getApiClient().get(
-      `/conversations/${conversationId}/read-receipt`
-    );
-    return data;
-  },
-  async markAsRead(conversationId, messageId) {
-    await getApiClient().post(`/conversations/${conversationId}/read`, messageId ? { messageId } : {});
-  },
-  async pin(messageId) {
-    const { data } = await getApiClient().post(`/messages/${messageId}/pin`);
-    return data;
-  },
-  async unpin(messageId) {
-    const { data } = await getApiClient().post(`/messages/${messageId}/unpin`);
-    return data;
-  },
-  async getPinned(conversationId) {
-    const { data } = await getApiClient().get(`/conversations/${conversationId}/pinned-messages`);
-    return data;
-  },
-  async getReceipts(messageId) {
-    const { data } = await getApiClient().get(`/messages/${messageId}/receipts`);
-    return data;
-  },
-  /**
-   * Forwards a message into one or more target conversations (max MAX_FORWARD_TARGETS
-   * per call, also enforced server-side). Each target is independent — one failing
-   * (e.g. no longer a participant) does not block the others; check `success`/`error`
-   * per entry in the returned array.
-   */
-  async forward(messageId, targetConversationIds) {
-    const { data } = await getApiClient().post(
-      `/messages/${messageId}/forward`,
-      { targetConversationIds }
-    );
-    return data;
-  }
-};
-
-// src/api/conversations.ts
-function normalizeParticipant(p) {
-  const hasUserDetails = p.displayName || p.username || p.avatarUrl;
-  return {
-    userId: p.userId,
-    externalId: p.externalId ?? p.user?.externalId,
-    role: p.role,
-    joinedAt: p.joinedAt,
-    isActive: p.isActive,
-    user: hasUserDetails ? {
-      id: p.userId,
-      externalId: p.externalId,
-      tenantId: "",
-      email: "",
-      username: p.username ?? "",
-      displayName: p.displayName ?? p.username ?? "",
-      avatarUrl: p.avatarUrl,
-      status: "offline",
-      createdAt: p.joinedAt ?? "",
-      updatedAt: p.joinedAt ?? ""
-    } : p.user
-  };
-}
-function normalizeLastMessage(lastMsg) {
-  if (!lastMsg) return void 0;
-  if (lastMsg.content !== void 0) return lastMsg;
-  return {
-    id: lastMsg.messageId ?? "",
-    tenantId: "",
-    conversationId: "",
-    senderId: lastMsg.senderId ?? "",
-    content: {
-      type: lastMsg.hasAttachments ? "attachment" : "text",
-      text: lastMsg.contentPreview
-    },
-    reactions: [],
-    lastReaction: lastMsg.lastReaction ?? null,
-    status: lastMsg.status ?? "active",
-    deliveryStatus: lastMsg.deliveryStatus ?? "sent",
-    isEdited: false,
-    sentAt: lastMsg.sentAt ?? "",
-    createdAt: lastMsg.sentAt ?? "",
-    ...lastMsg.senderName && { senderName: lastMsg.senderName },
-    ...lastMsg.attachmentType && { attachmentType: lastMsg.attachmentType }
-  };
-}
-function normalizeConversation(conv) {
-  return {
-    ...conv,
-    id: conv.id ?? conv.conversationId,
-    participants: (conv.participants ?? []).map(normalizeParticipant),
-    lastMessage: normalizeLastMessage(conv.lastMessage)
-  };
-}
-var conversationsApi = {
-  async list(params = {}) {
-    const { data } = await getApiClient().get("/conversations", { params });
-    return { ...data, data: data.data.map(normalizeConversation) };
-  },
-  async get(conversationId) {
-    const { data } = await getApiClient().get(`/conversations/${conversationId}`);
-    return normalizeConversation(data);
-  },
-  async createGroup(payload) {
-    const { data } = await getApiClient().post("/conversations", payload);
-    return normalizeConversation(data);
-  },
-  async createDirect(payload) {
-    const { data } = await getApiClient().post("/conversations/direct", payload);
-    return normalizeConversation(data);
-  },
-  async update(conversationId, payload) {
-    const { data } = await getApiClient().post(`/conversations/${conversationId}/update`, payload);
-    return normalizeConversation(data);
-  },
-  async delete(conversationId) {
-    await getApiClient().post(`/conversations/${conversationId}/delete`);
-  },
-  async addParticipants(conversationId, userIds, role) {
-    const { data } = await getApiClient().post(
-      `/conversations/${conversationId}/participants`,
-      { userIds, ...role && { role } }
-    );
-    return normalizeConversation(data);
-  },
-  async removeParticipant(conversationId, userId) {
-    const { data } = await getApiClient().post(
-      `/conversations/${conversationId}/participants/${userId}/remove`
-    );
-    return normalizeConversation(data);
-  },
-  async updateParticipantRole(conversationId, userId, role) {
-    const { data } = await getApiClient().post(
-      `/conversations/${conversationId}/participants/${userId}/role`,
-      { role }
-    );
-    return normalizeConversation(data);
-  },
-  async mute(conversationId, mutedUntil) {
-    await getApiClient().post(`/conversations/${conversationId}/mute`, mutedUntil ? { mutedUntil } : {});
-  },
-  async unmute(conversationId) {
-    await getApiClient().post(`/conversations/${conversationId}/unmute`);
-  },
-  async pin(conversationId) {
-    await getApiClient().post(`/conversations/${conversationId}/pin`);
-  },
-  async unpin(conversationId) {
-    await getApiClient().post(`/conversations/${conversationId}/unpin`);
-  },
-  async markUnread(conversationId) {
-    await getApiClient().post(`/conversations/${conversationId}/unread`);
-  },
-  async markRead(conversationId) {
-    await getApiClient().post(`/conversations/${conversationId}/unread/clear`);
-  },
-  async leave(conversationId, andDelete) {
-    const url = andDelete ? `/conversations/${conversationId}/leave?delete=true` : `/conversations/${conversationId}/leave`;
-    await getApiClient().post(url);
-  },
-  async getMembers(conversationId, filter) {
-    const { data } = await getApiClient().get(
-      `/conversations/${conversationId}/participants`,
-      filter ? { params: { filter } } : void 0
-    );
-    return (data ?? []).map(normalizeParticipant);
-  },
-  /**
-   * Get unread message count for a single conversation.
-   * Use this after app foreground or socket reconnect to refresh a specific count.
-   */
-  async getUnreadCount(conversationId) {
-    const { data } = await getApiClient().get(
-      `/conversations/${conversationId}/unread`
-    );
-    return data;
-  },
-  /**
-   * Get total unread count across all conversations + per-conversation breakdown.
-   * Use on app cold start, foreground resume, or after socket reconnect.
-   * The socket keeps counts live while connected — this is the source of truth
-   * when the socket was down.
-   */
-  async getUnreadSummary() {
-    const { data } = await getApiClient().get("/conversations/unread");
-    return data;
-  },
-  /**
-   * Set the group icon from an already-uploaded file (admin only).
-   * The fileId comes from uploadBatch() / client.uploadFiles() — same as attachments.
-   * Server copies storageKey into conversation.iconMeta and deletes the chat_files record.
-   */
-  async uploadIcon(conversationId, fileId) {
-    const { data } = await getApiClient().post(
-      `/conversations/${conversationId}/icon`,
-      { fileId }
-    );
-    return normalizeConversation(data);
-  },
-  async removeIcon(conversationId) {
-    const { data } = await getApiClient().post(`/conversations/${conversationId}/icon/remove`);
-    return normalizeConversation(data);
-  },
-  async clearChat(conversationId) {
-    await getApiClient().post(`/conversations/${conversationId}/clear-for-me`);
-  }
-};
-
-// src/crypto/uuid.ts
-function generateUUID() {
-  if (typeof globalThis.crypto?.randomUUID === "function") {
-    return globalThis.crypto.randomUUID();
-  }
-  return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
-    const r = Math.random() * 16 | 0;
-    return (c === "x" ? r : r & 3 | 8).toString(16);
-  });
-}
-
-// src/api/storage.ts
-var storageApi = {
-  async requestPresignedUrl(payload) {
-    const { data } = await getApiClient().post("/storage/presigned-url", payload);
-    return data;
-  },
-  async requestPresignedUrlBatch(files) {
-    const { data } = await getApiClient().post("/storage/presigned-url/batch", { files });
-    return data;
-  },
-  async confirmUpload(fileId) {
-    const { data } = await getApiClient().post(`/storage/confirm/${fileId}`);
-    return data;
-  },
-  async getFile(fileId) {
-    const { data } = await getApiClient().get(`/storage/files/${fileId}`);
-    return data;
-  },
-  async getFileUrl(fileId, expiresIn) {
-    const { data } = await getApiClient().get(`/storage/files/${fileId}/url`, {
-      params: expiresIn ? { expiresIn } : {}
-    });
-    return data;
-  },
-  async deleteFile(fileId) {
-    await getApiClient().post(`/storage/files/${fileId}/delete`);
-  },
-  async completeMultipartUpload(fileId, uploadId, parts) {
-    const { data } = await getApiClient().post(
-      `/storage/multipart/complete/${fileId}`,
-      { uploadId, parts }
-    );
-    return data;
-  },
-  async getConversationFiles(conversationId, params = {}) {
-    const { data } = await getApiClient().get(
-      `/storage/conversations/${conversationId}/files`,
-      { params }
-    );
-    return data;
-  },
-  async getMyFiles(params = {}) {
-    const { data } = await getApiClient().get("/storage/my-files", { params });
-    return data;
-  }
-};
-async function runMultipartUpload(presigned, file, platformUploadPartFn, onProgress) {
-  const { multipart } = presigned;
-  if (!multipart) throw new Error("No multipart info on presigned response");
-  const CONCURRENCY = 3;
-  const completedParts = [];
-  const partProgress = {};
-  multipart.partUrls.forEach(({ partNumber }) => {
-    partProgress[partNumber] = 0;
-  });
-  const reportProgress = () => {
-    if (!onProgress) return;
-    const vals = Object.values(partProgress);
-    const avg = vals.reduce((s, v) => s + v, 0) / Math.max(vals.length, 1);
-    onProgress(Math.round(avg * 0.95));
-  };
-  const uploadPart = async (partNumber, uploadUrl, method) => {
-    const offset = (partNumber - 1) * multipart.chunkSize;
-    const end = Math.min(offset + multipart.chunkSize, file.size);
-    const blob = await fetch(file.uri).then((r) => r.blob());
-    const slice = blob.slice(offset, end);
-    const etag = await platformUploadPartFn(uploadUrl, slice, (pct) => {
-      partProgress[partNumber] = pct;
-      reportProgress();
-    }, method);
-    completedParts.push({ partNumber, etag });
-    partProgress[partNumber] = 100;
-    reportProgress();
-  };
-  for (let i = 0; i < multipart.partUrls.length; i += CONCURRENCY) {
-    const batch = multipart.partUrls.slice(i, i + CONCURRENCY);
-    const results = await Promise.allSettled(
-      batch.map(({ partNumber, uploadUrl, method }) => uploadPart(partNumber, uploadUrl, method ?? "PUT"))
-    );
-    const failed = results.find((r) => r.status === "rejected");
-    if (failed) throw failed.reason;
-  }
-  completedParts.sort((a, b) => a.partNumber - b.partNumber);
-  const fileResponse = await storageApi.completeMultipartUpload(
-    presigned.fileId,
-    multipart.uploadId,
-    completedParts
-  );
-  onProgress?.(100);
-  return fileResponse;
-}
-async function runUploadBatch(files, platformUploadFn, slotIds, conversationId, onProgress, platformCompressFn, compressionConfig, platformUploadPartFn) {
-  const compressedFiles = await Promise.all(
-    files.map((f) => compressFile(f, platformCompressFn, compressionConfig ?? { enabled: false, imageQuality: 0.85, imageMaxDimension: 1920, compressDocuments: true }))
-  );
-  const slotted = compressedFiles.map((f, i) => ({ file: f, slotId: slotIds[i], clientIndex: i }));
-  const requests = slotted.map(({ file: f, clientIndex }) => ({
-    filename: f.name,
-    mimeType: f.type,
-    size: f.size,
-    conversationId,
-    clientIndex,
-    ...f.compressed && {
-      metadata: {
-        compressed: f.compressed,
-        originalSize: f.originalSize,
-        compressionAlgorithm: f.compressionAlgorithm
-      }
-    }
-  }));
-  const { urls, errors: requestErrors } = await storageApi.requestPresignedUrlBatch(requests);
-  const failedSlotIds = /* @__PURE__ */ new Set();
-  const failed = requestErrors.map((e) => {
-    const idx = e.clientIndex ?? slotted.findIndex((s) => s.file.name === e.filename);
-    const slotId = slotted[idx]?.slotId;
-    if (slotId) failedSlotIds.add(slotId);
-    return { filename: e.filename, error: e.error };
-  });
-  const progressMap = {};
-  const reportProgress = () => {
-    if (!onProgress) return;
-    const vals = Object.values(progressMap);
-    const avg = vals.reduce((s, v) => s + v, 0) / Math.max(vals.length, 1);
-    onProgress(Math.round(avg));
-  };
-  const successful = [];
-  const slotToFile = /* @__PURE__ */ new Map();
-  await Promise.all(
-    urls.map(async (presigned, idx) => {
-      const originalIdx = presigned.clientIndex ?? idx;
-      const { file, slotId } = slotted[originalIdx];
-      progressMap[originalIdx] = 0;
-      try {
-        let fileResponse;
-        if (presigned.multipart && platformUploadPartFn) {
-          fileResponse = await runMultipartUpload(presigned, file, platformUploadPartFn, (pct) => {
-            progressMap[originalIdx] = pct;
-            reportProgress();
-          });
-        } else {
-          await platformUploadFn(presigned, file, (pct) => {
-            progressMap[originalIdx] = Math.round(pct * 0.9);
-            reportProgress();
-          });
-          fileResponse = await storageApi.confirmUpload(presigned.fileId);
-        }
-        progressMap[originalIdx] = 100;
-        reportProgress();
-        successful.push(fileResponse);
-        slotToFile.set(slotId, fileResponse);
-      } catch (err) {
-        failed.push({ filename: file.name, error: err.message });
-      }
-    })
-  );
-  return { result: { successful, failed }, slotToFile };
-}
-async function uploadBatch(files, platformUploadFn, conversationId, onProgress, platformCompressFn, compressionConfig, platformUploadPartFn) {
-  const slotIds = files.map(() => generateUUID());
-  const { result } = await runUploadBatch(files, platformUploadFn, slotIds, conversationId, onProgress, platformCompressFn, compressionConfig, platformUploadPartFn);
-  return result;
-}
-
-// src/api/devices.ts
-var devicesApi = {
-  /**
-   * Register or update a device push token with the chat server.
-   *
-   * Upserts by `deviceId` — calling this multiple times with the same deviceId
-   * simply refreshes the token value (tokens can rotate silently on some platforms).
-   *
-   * The SDK never calls this automatically. The parent app or the `tokenProvider`
-   * option in `pushNotifications` config is responsible for calling it after
-   * obtaining the token from the OS / browser.
-   */
-  async register(payload) {
-    await getApiClient().post("/users/me/devices", payload);
-  },
-  /**
-   * Remove a device token from the chat server.
-   * Call this on logout so the user stops receiving push notifications on this device.
-   */
-  async remove(deviceId) {
-    await getApiClient().post(`/users/me/devices/${deviceId}/remove`);
-  }
-};
-
-// src/api/users.ts
-var usersApi = {
-  async list(params = {}) {
-    const { data } = await getApiClient().get("/users", { params });
-    return data;
-  },
-  async getById(userId) {
-    const { data } = await getApiClient().get(`/users/${userId}`);
-    return data;
-  },
-  async getLastSeen(userId) {
-    const { data } = await getApiClient().get(`/users/${userId}`);
-    return { lastSeenAt: data.lastSeenAt ?? null };
-  },
-  /**
-   * Update basic profile fields for the current user.
-   * Works in both builtin and non-builtin modes. Use this to push an immediate
-   * profile update to the chat server when the host app knows a change just
-   * happened — without waiting for the next 2-hour sync cycle.
-   */
-  async updateProfile(payload) {
-    const { data } = await getApiClient().post("/users/me/update", payload);
-    return data;
-  },
-  /**
-   * Update notification preferences for the current user.
-   * Partial update — only send fields you want to change.
-   * A prefs record is automatically created with defaults when a device
-   * token is first registered, so this never fails with "not found".
-   */
-  async updatePreferences(prefs) {
-    const { data } = await getApiClient().post("/users/me/preferences", prefs);
-    return data;
-  },
-  /**
-   * Fetch current notification preferences for the current user.
-   * Returns null if no prefs record exists yet (all defaults apply).
-   */
-  async getPreferences() {
-    try {
-      const { data } = await getApiClient().get("/users/me/preferences");
-      return data;
-    } catch {
-      return null;
-    }
+// src/crypto/uuid.ts
+function generateUUID() {
+  if (typeof globalThis.crypto?.randomUUID === "function") {
+    return globalThis.crypto.randomUUID();
   }
-};
+  return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
+    const r = Math.random() * 16 | 0;
+    return (c === "x" ? r : r & 3 | 8).toString(16);
+  });
+}
 
 // src/socket/socket.ts
 var import_socket = require("socket.io-client");
@@ -1854,127 +1341,684 @@ async function drainSendQueue(conversationId) {
       entry.reject(new AntzChatNetworkError("Message dropped: queued too long", "MESSAGE_DROPPED"));
       continue;
     }
-    entry.run().then(entry.resolve).catch(entry.reject);
+    entry.run().then(entry.resolve).catch(entry.reject);
+  }
+  sendQueues.delete(conversationId);
+  sendQueueRunning.delete(conversationId);
+}
+function queueSendMessage(payload) {
+  const conversationId = payload.conversationId;
+  if (!sendQueues.has(conversationId)) sendQueues.set(conversationId, []);
+  const queue = sendQueues.get(conversationId);
+  if (queue.length >= QUEUE_MAX_SIZE) {
+    return Promise.reject(new AntzChatNetworkError("Send queue full: too many messages in flight", "SEND_QUEUE_FULL", { conversationId }));
+  }
+  return new Promise((resolve, reject) => {
+    queue.push({ run: () => withAck("send_message", payload), resolve, reject, enqueuedAt: Date.now() });
+    drainSendQueue(conversationId);
+  });
+}
+function waitForReconnect() {
+  return new Promise((resolve, reject) => {
+    const timer = setTimeout(() => {
+      unsubscribe();
+      reject(new AntzChatNetworkError("Socket reconnect timeout", "SOCKET_TIMEOUT"));
+    }, RECONNECT_WAIT_TIMEOUT);
+    const unsubscribe = onSocketStatus((status) => {
+      if (status === "connected") {
+        clearTimeout(timer);
+        unsubscribe();
+        resolve();
+      } else if (status === "error") {
+        clearTimeout(timer);
+        unsubscribe();
+        reject(new AntzChatNetworkError("Socket reconnect failed", "SOCKET_NOT_CONNECTED"));
+      }
+    });
+  });
+}
+async function withAck(event, payload) {
+  let socket = tryGetSocket();
+  if (!socket) {
+    await waitForReconnect();
+    socket = tryGetSocket();
+  }
+  if (!socket) return Promise.reject(new AntzChatNetworkError(`Socket not connected (event: ${event})`, "SOCKET_NOT_CONNECTED", { event }));
+  return new Promise((resolve, reject) => {
+    let timer;
+    secureEmit(socket, event, payload, (response) => {
+      clearTimeout(timer);
+      resolve(response);
+    }).then(() => {
+      timer = setTimeout(() => reject(new AntzChatNetworkError(`Socket ack timeout: ${event}`, "SOCKET_TIMEOUT", { event })), ACK_TIMEOUT);
+    }).catch(reject);
+  });
+}
+function fireAndForget(event, payload) {
+  const socket = tryGetSocket();
+  if (!socket) return;
+  secureEmit(socket, event, payload);
+}
+var socketEmit = {
+  joinRoom(conversationId) {
+    fireAndForget("join_room", { conversationId });
+  },
+  leaveRoom(conversationId) {
+    fireAndForget("leave_room", { conversationId });
+  },
+  sendMessage(payload) {
+    return queueSendMessage({ ...payload, sentAt: Date.now() });
+  },
+  // Not queued like sendMessage — forward targets are independent conversations,
+  // not the single conversation ordering that queueSendMessage protects, and each
+  // target's own new_message/push already fires server-side via MessagesService.forward()'s
+  // internal create() calls, so there's nothing here that needs in-order draining.
+  forwardMessage(payload) {
+    return withAck("forward_message", payload);
+  },
+  updateMessage(messageId, text) {
+    return withAck("update_message", { messageId, text });
+  },
+  deleteMessage(messageId) {
+    return withAck("delete_message", { messageId });
+  },
+  deleteMessageForMe(messageId) {
+    return withAck("delete_message_for_me", { messageId });
+  },
+  clearChat(conversationId) {
+    return withAck("clear_chat_for_me", { conversationId });
+  },
+  addReaction(messageId, emoji) {
+    return withAck("add_reaction", { messageId, emoji });
+  },
+  removeReaction(messageId, emoji) {
+    return withAck("remove_reaction", { messageId, emoji });
+  },
+  pinMessage(messageId) {
+    return withAck("pin_message", { messageId });
+  },
+  unpinMessage(messageId) {
+    return withAck("unpin_message", { messageId });
+  },
+  // markRead and typing are best-effort — silently dropped if socket not ready
+  typing(conversationId, isTyping) {
+    fireAndForget("typing", { conversationId, isTyping });
+  },
+  markRead(conversationId, messageId) {
+    fireAndForget("mark_read", { conversationId, ...messageId ? { messageId } : {} });
+  },
+  getOnlineUsers(userIds) {
+    const socket = tryGetSocket();
+    if (!socket) return Promise.resolve([]);
+    return new Promise((resolve, reject) => {
+      let timer;
+      secureEmit(socket, "get_online_users", { userIds }, (response) => {
+        clearTimeout(timer);
+        if (response && typeof response === "object" && "onlineStatus" in response) {
+          const status = response.onlineStatus;
+          resolve(Object.entries(status).filter(([, v]) => v).map(([k]) => k));
+        } else if (Array.isArray(response)) {
+          resolve(response);
+        } else {
+          resolve([]);
+        }
+      }).then(() => {
+        timer = setTimeout(() => reject(new AntzChatNetworkError("Socket ack timeout: get_online_users", "SOCKET_TIMEOUT", { event: "get_online_users" })), ACK_TIMEOUT);
+      }).catch(reject);
+    });
+  },
+  getTypingUsers(conversationId) {
+    return withAck("get_typing_users", { conversationId });
+  }
+};
+
+// src/api/messages.ts
+var MAX_FORWARD_TARGETS = 5;
+var HIGHLY_FORWARDED_DEPTH_THRESHOLD = 5;
+var messagesApi = {
+  async list(conversationId, params = {}) {
+    const { cursor, direction, ...rest } = params;
+    const serverParams = { ...rest };
+    if (cursor) {
+      serverParams[direction === "after" ? "after" : "before"] = cursor;
+    }
+    const { data } = await getApiClient().get(
+      `/conversations/${conversationId}/messages`,
+      { params: serverParams }
+    );
+    const currentUserId = getAuthStore().useAuthStore.getState().user?.id;
+    if (!currentUserId) return data;
+    return {
+      ...data,
+      data: data.data.map(
+        (m) => m.content.type === "system" ? { ...m, content: { ...m.content, text: resolveSystemMessageText(m, currentUserId) } } : m
+      )
+    };
+  },
+  async get(messageId) {
+    const { data } = await getApiClient().get(`/messages/${messageId}`);
+    return data;
+  },
+  /**
+   * Sends a message via REST. For real-time delivery use `socketEmit.sendMessage`
+   * instead — this is a lower-level entry point (used e.g. by the socket path's
+   * REST-mirror flows). Pass `payload.tempId` and reuse the SAME value on retry to
+   * make a retry-after-timeout safe — see `SendData.tempId`.
+   */
+  async send(conversationId, payload) {
+    const { data } = await getApiClient().post(
+      `/conversations/${conversationId}/messages`,
+      payload
+    );
+    return data;
+  },
+  async update(messageId, text) {
+    const { data } = await getApiClient().post(`/messages/${messageId}/update`, { text });
+    return data;
+  },
+  async delete(messageId) {
+    await getApiClient().post(`/messages/${messageId}/delete`);
+  },
+  async deleteForMe(messageId) {
+    await getApiClient().post(`/messages/${messageId}/delete-for-me`);
+  },
+  async addReaction(messageId, emoji) {
+    const { data } = await getApiClient().post(`/messages/${messageId}/reactions`, { emoji });
+    return data;
+  },
+  async removeReaction(messageId, emoji) {
+    const { data } = await getApiClient().post(
+      `/messages/${messageId}/reactions/${encodeURIComponent(emoji)}/remove`
+    );
+    return data;
+  },
+  async getReactions(messageId) {
+    const { data } = await getApiClient().post(`/messages/${messageId}/reactions/list`);
+    return data;
+  },
+  async star(messageId) {
+    await getApiClient().post(`/messages/${messageId}/star`);
+  },
+  async unstar(messageId) {
+    await getApiClient().post(`/messages/${messageId}/unstar`);
+  },
+  async getStarred(params = {}) {
+    const { data } = await getApiClient().get("/messages/starred", { params });
+    return data;
+  },
+  async search(params) {
+    const { data } = await getApiClient().get("/messages/search", { params });
+    return data;
+  },
+  async getLastRead(conversationId) {
+    const { data } = await getApiClient().get(
+      `/conversations/${conversationId}/read-receipt`
+    );
+    return data;
+  },
+  async markAsRead(conversationId, messageId) {
+    await getApiClient().post(`/conversations/${conversationId}/read`, messageId ? { messageId } : {});
+  },
+  async pin(messageId) {
+    const { data } = await getApiClient().post(`/messages/${messageId}/pin`);
+    return data;
+  },
+  async unpin(messageId) {
+    const { data } = await getApiClient().post(`/messages/${messageId}/unpin`);
+    return data;
+  },
+  async getPinned(conversationId) {
+    const { data } = await getApiClient().get(`/conversations/${conversationId}/pinned-messages`);
+    return data;
+  },
+  async getReceipts(messageId) {
+    const { data } = await getApiClient().get(`/messages/${messageId}/receipts`);
+    return data;
+  },
+  /**
+   * Forwards a message into one or more target conversations (max MAX_FORWARD_TARGETS
+   * per call, also enforced server-side). Each target is independent — one failing
+   * (e.g. no longer a participant) does not block the others; check `success`/`error`
+   * per entry in the returned array.
+   *
+   * Pass `attachmentIds` to forward only a subset of the source message's attachments
+   * (e.g. one image out of a multi-image message) — omit it to forward the whole
+   * message, including all its attachments, unchanged. An ID not present on the
+   * source message is ignored server-side.
+   *
+   * Idempotency: pass `tempId` — generate ONE value per forward action (e.g. via
+   * `generateUUID` from '@antzsoft/chat-core/internal') and reuse that SAME value if
+   * you retry this exact forward (e.g. after a client-side timeout). The server then
+   * recognizes the retry per target and returns the already-created message instead
+   * of creating a duplicate. Never mint a new tempId for a retry — only when the user
+   * initiates a genuinely new forward action. If omitted, a fresh one is generated
+   * per call, which means a retry without an explicit tempId gets NO dedup protection.
+   *
+   * Transport: uses the 'forward_message' socket event when a socket is connected
+   * (lower latency, same server-side MessagesService.forward() path, so broadcast/
+   * push notification behavior is identical either way) and transparently falls back
+   * to the REST endpoint when no socket is available.
+   */
+  async forward(messageId, targetConversationIds, attachmentIds, tempId) {
+    const resolvedTempId = tempId ?? generateUUID();
+    if (tryGetSocket()) {
+      const ack = await socketEmit.forwardMessage({
+        messageId,
+        targetConversationIds,
+        ...attachmentIds ? { attachmentIds } : {},
+        tempId: resolvedTempId
+      });
+      if (ack.error) throw new Error(ack.error);
+      return ack.results;
+    }
+    const { data } = await getApiClient().post(
+      `/messages/${messageId}/forward`,
+      { targetConversationIds, ...attachmentIds ? { attachmentIds } : {}, tempId: resolvedTempId }
+    );
+    return data;
   }
-  sendQueues.delete(conversationId);
-  sendQueueRunning.delete(conversationId);
+};
+
+// src/api/conversations.ts
+function normalizeParticipant(p) {
+  const hasUserDetails = p.displayName || p.username || p.avatarUrl;
+  return {
+    userId: p.userId,
+    externalId: p.externalId ?? p.user?.externalId,
+    role: p.role,
+    joinedAt: p.joinedAt,
+    isActive: p.isActive,
+    user: hasUserDetails ? {
+      id: p.userId,
+      externalId: p.externalId,
+      tenantId: "",
+      email: "",
+      username: p.username ?? "",
+      displayName: p.displayName ?? p.username ?? "",
+      avatarUrl: p.avatarUrl,
+      status: "offline",
+      createdAt: p.joinedAt ?? "",
+      updatedAt: p.joinedAt ?? ""
+    } : p.user
+  };
 }
-function queueSendMessage(payload) {
-  const conversationId = payload.conversationId;
-  if (!sendQueues.has(conversationId)) sendQueues.set(conversationId, []);
-  const queue = sendQueues.get(conversationId);
-  if (queue.length >= QUEUE_MAX_SIZE) {
-    return Promise.reject(new AntzChatNetworkError("Send queue full: too many messages in flight", "SEND_QUEUE_FULL", { conversationId }));
-  }
-  return new Promise((resolve, reject) => {
-    queue.push({ run: () => withAck("send_message", payload), resolve, reject, enqueuedAt: Date.now() });
-    drainSendQueue(conversationId);
-  });
+function normalizeLastMessage(lastMsg) {
+  if (!lastMsg) return void 0;
+  if (lastMsg.content !== void 0) return lastMsg;
+  return {
+    id: lastMsg.messageId ?? "",
+    tenantId: "",
+    conversationId: "",
+    senderId: lastMsg.senderId ?? "",
+    content: {
+      type: lastMsg.hasAttachments ? "attachment" : "text",
+      text: lastMsg.contentPreview
+    },
+    reactions: [],
+    lastReaction: lastMsg.lastReaction ?? null,
+    status: lastMsg.status ?? "active",
+    deliveryStatus: lastMsg.deliveryStatus ?? "sent",
+    isEdited: false,
+    sentAt: lastMsg.sentAt ?? "",
+    createdAt: lastMsg.sentAt ?? "",
+    ...lastMsg.senderName && { senderName: lastMsg.senderName },
+    ...lastMsg.attachmentType && { attachmentType: lastMsg.attachmentType }
+  };
 }
-function waitForReconnect() {
-  return new Promise((resolve, reject) => {
-    const timer = setTimeout(() => {
-      unsubscribe();
-      reject(new AntzChatNetworkError("Socket reconnect timeout", "SOCKET_TIMEOUT"));
-    }, RECONNECT_WAIT_TIMEOUT);
-    const unsubscribe = onSocketStatus((status) => {
-      if (status === "connected") {
-        clearTimeout(timer);
-        unsubscribe();
-        resolve();
-      } else if (status === "error") {
-        clearTimeout(timer);
-        unsubscribe();
-        reject(new AntzChatNetworkError("Socket reconnect failed", "SOCKET_NOT_CONNECTED"));
-      }
-    });
-  });
+function normalizeConversation(conv) {
+  return {
+    ...conv,
+    id: conv.id ?? conv.conversationId,
+    participants: (conv.participants ?? []).map(normalizeParticipant),
+    lastMessage: normalizeLastMessage(conv.lastMessage)
+  };
 }
-async function withAck(event, payload) {
-  let socket = tryGetSocket();
-  if (!socket) {
-    await waitForReconnect();
-    socket = tryGetSocket();
+var conversationsApi = {
+  async list(params = {}) {
+    const { data } = await getApiClient().get("/conversations", { params });
+    return { ...data, data: data.data.map(normalizeConversation) };
+  },
+  async get(conversationId) {
+    const { data } = await getApiClient().get(`/conversations/${conversationId}`);
+    return normalizeConversation(data);
+  },
+  async createGroup(payload) {
+    const { data } = await getApiClient().post("/conversations", payload);
+    return normalizeConversation(data);
+  },
+  async createDirect(payload) {
+    const { data } = await getApiClient().post("/conversations/direct", payload);
+    return normalizeConversation(data);
+  },
+  async update(conversationId, payload) {
+    const { data } = await getApiClient().post(`/conversations/${conversationId}/update`, payload);
+    return normalizeConversation(data);
+  },
+  async delete(conversationId) {
+    await getApiClient().post(`/conversations/${conversationId}/delete`);
+  },
+  async addParticipants(conversationId, userIds, role) {
+    const { data } = await getApiClient().post(
+      `/conversations/${conversationId}/participants`,
+      { userIds, ...role && { role } }
+    );
+    return normalizeConversation(data);
+  },
+  async removeParticipant(conversationId, userId) {
+    const { data } = await getApiClient().post(
+      `/conversations/${conversationId}/participants/${userId}/remove`
+    );
+    return normalizeConversation(data);
+  },
+  async updateParticipantRole(conversationId, userId, role) {
+    const { data } = await getApiClient().post(
+      `/conversations/${conversationId}/participants/${userId}/role`,
+      { role }
+    );
+    return normalizeConversation(data);
+  },
+  async mute(conversationId, mutedUntil) {
+    await getApiClient().post(`/conversations/${conversationId}/mute`, mutedUntil ? { mutedUntil } : {});
+  },
+  async unmute(conversationId) {
+    await getApiClient().post(`/conversations/${conversationId}/unmute`);
+  },
+  async pin(conversationId) {
+    await getApiClient().post(`/conversations/${conversationId}/pin`);
+  },
+  async unpin(conversationId) {
+    await getApiClient().post(`/conversations/${conversationId}/unpin`);
+  },
+  async markUnread(conversationId) {
+    await getApiClient().post(`/conversations/${conversationId}/unread`);
+  },
+  async markRead(conversationId) {
+    await getApiClient().post(`/conversations/${conversationId}/unread/clear`);
+  },
+  async leave(conversationId, andDelete) {
+    const url = andDelete ? `/conversations/${conversationId}/leave?delete=true` : `/conversations/${conversationId}/leave`;
+    await getApiClient().post(url);
+  },
+  async getMembers(conversationId, filter) {
+    const { data } = await getApiClient().get(
+      `/conversations/${conversationId}/participants`,
+      filter ? { params: { filter } } : void 0
+    );
+    return (data ?? []).map(normalizeParticipant);
+  },
+  /**
+   * Get unread message count for a single conversation.
+   * Use this after app foreground or socket reconnect to refresh a specific count.
+   */
+  async getUnreadCount(conversationId) {
+    const { data } = await getApiClient().get(
+      `/conversations/${conversationId}/unread`
+    );
+    return data;
+  },
+  /**
+   * Get total unread count across all conversations + per-conversation breakdown.
+   * Use on app cold start, foreground resume, or after socket reconnect.
+   * The socket keeps counts live while connected — this is the source of truth
+   * when the socket was down.
+   */
+  async getUnreadSummary() {
+    const { data } = await getApiClient().get("/conversations/unread");
+    return data;
+  },
+  /**
+   * Set the group icon from an already-uploaded file (admin only).
+   * The fileId comes from uploadBatch() / client.uploadFiles() — same as attachments.
+   * Server copies storageKey into conversation.iconMeta and deletes the chat_files record.
+   */
+  async uploadIcon(conversationId, fileId) {
+    const { data } = await getApiClient().post(
+      `/conversations/${conversationId}/icon`,
+      { fileId }
+    );
+    return normalizeConversation(data);
+  },
+  async removeIcon(conversationId) {
+    const { data } = await getApiClient().post(`/conversations/${conversationId}/icon/remove`);
+    return normalizeConversation(data);
+  },
+  async clearChat(conversationId) {
+    await getApiClient().post(`/conversations/${conversationId}/clear-for-me`);
   }
-  if (!socket) return Promise.reject(new AntzChatNetworkError(`Socket not connected (event: ${event})`, "SOCKET_NOT_CONNECTED", { event }));
-  return new Promise((resolve, reject) => {
-    let timer;
-    secureEmit(socket, event, payload, (response) => {
-      clearTimeout(timer);
-      resolve(response);
-    }).then(() => {
-      timer = setTimeout(() => reject(new AntzChatNetworkError(`Socket ack timeout: ${event}`, "SOCKET_TIMEOUT", { event })), ACK_TIMEOUT);
-    }).catch(reject);
-  });
-}
-function fireAndForget(event, payload) {
-  const socket = tryGetSocket();
-  if (!socket) return;
-  secureEmit(socket, event, payload);
-}
-var socketEmit = {
-  joinRoom(conversationId) {
-    fireAndForget("join_room", { conversationId });
+};
+
+// src/api/storage.ts
+var storageApi = {
+  async requestPresignedUrl(payload) {
+    const { data } = await getApiClient().post("/storage/presigned-url", payload);
+    return data;
   },
-  leaveRoom(conversationId) {
-    fireAndForget("leave_room", { conversationId });
+  async requestPresignedUrlBatch(files) {
+    const { data } = await getApiClient().post("/storage/presigned-url/batch", { files });
+    return data;
   },
-  sendMessage(payload) {
-    return queueSendMessage({ ...payload, sentAt: Date.now() });
+  async confirmUpload(fileId) {
+    const { data } = await getApiClient().post(`/storage/confirm/${fileId}`);
+    return data;
   },
-  updateMessage(messageId, text) {
-    return withAck("update_message", { messageId, text });
+  async getFile(fileId) {
+    const { data } = await getApiClient().get(`/storage/files/${fileId}`);
+    return data;
   },
-  deleteMessage(messageId) {
-    return withAck("delete_message", { messageId });
+  async getFileUrl(fileId, expiresIn) {
+    const { data } = await getApiClient().get(`/storage/files/${fileId}/url`, {
+      params: expiresIn ? { expiresIn } : {}
+    });
+    return data;
   },
-  deleteMessageForMe(messageId) {
-    return withAck("delete_message_for_me", { messageId });
+  async deleteFile(fileId) {
+    await getApiClient().post(`/storage/files/${fileId}/delete`);
   },
-  clearChat(conversationId) {
-    return withAck("clear_chat_for_me", { conversationId });
+  async completeMultipartUpload(fileId, uploadId, parts) {
+    const { data } = await getApiClient().post(
+      `/storage/multipart/complete/${fileId}`,
+      { uploadId, parts }
+    );
+    return data;
   },
-  addReaction(messageId, emoji) {
-    return withAck("add_reaction", { messageId, emoji });
+  async getConversationFiles(conversationId, params = {}) {
+    const { data } = await getApiClient().get(
+      `/storage/conversations/${conversationId}/files`,
+      { params }
+    );
+    return data;
   },
-  removeReaction(messageId, emoji) {
-    return withAck("remove_reaction", { messageId, emoji });
+  async getMyFiles(params = {}) {
+    const { data } = await getApiClient().get("/storage/my-files", { params });
+    return data;
+  }
+};
+async function runMultipartUpload(presigned, file, platformUploadPartFn, onProgress) {
+  const { multipart } = presigned;
+  if (!multipart) throw new Error("No multipart info on presigned response");
+  const CONCURRENCY = 3;
+  const completedParts = [];
+  const partProgress = {};
+  multipart.partUrls.forEach(({ partNumber }) => {
+    partProgress[partNumber] = 0;
+  });
+  const reportProgress = () => {
+    if (!onProgress) return;
+    const vals = Object.values(partProgress);
+    const avg = vals.reduce((s, v) => s + v, 0) / Math.max(vals.length, 1);
+    onProgress(Math.round(avg * 0.95));
+  };
+  const uploadPart = async (partNumber, uploadUrl, method) => {
+    const offset = (partNumber - 1) * multipart.chunkSize;
+    const end = Math.min(offset + multipart.chunkSize, file.size);
+    const blob = await fetch(file.uri).then((r) => r.blob());
+    const slice = blob.slice(offset, end);
+    const etag = await platformUploadPartFn(uploadUrl, slice, (pct) => {
+      partProgress[partNumber] = pct;
+      reportProgress();
+    }, method);
+    completedParts.push({ partNumber, etag });
+    partProgress[partNumber] = 100;
+    reportProgress();
+  };
+  for (let i = 0; i < multipart.partUrls.length; i += CONCURRENCY) {
+    const batch = multipart.partUrls.slice(i, i + CONCURRENCY);
+    const results = await Promise.allSettled(
+      batch.map(({ partNumber, uploadUrl, method }) => uploadPart(partNumber, uploadUrl, method ?? "PUT"))
+    );
+    const failed = results.find((r) => r.status === "rejected");
+    if (failed) throw failed.reason;
+  }
+  completedParts.sort((a, b) => a.partNumber - b.partNumber);
+  const fileResponse = await storageApi.completeMultipartUpload(
+    presigned.fileId,
+    multipart.uploadId,
+    completedParts
+  );
+  onProgress?.(100);
+  return fileResponse;
+}
+async function runUploadBatch(files, platformUploadFn, slotIds, conversationId, onProgress, platformCompressFn, compressionConfig, platformUploadPartFn) {
+  const compressedFiles = await Promise.all(
+    files.map((f) => compressFile(f, platformCompressFn, compressionConfig ?? { enabled: false, imageQuality: 0.85, imageMaxDimension: 1920, compressDocuments: true }))
+  );
+  const slotted = compressedFiles.map((f, i) => ({ file: f, slotId: slotIds[i], clientIndex: i }));
+  const requests = slotted.map(({ file: f, clientIndex }) => ({
+    filename: f.name,
+    mimeType: f.type,
+    size: f.size,
+    conversationId,
+    clientIndex,
+    ...f.compressed && {
+      metadata: {
+        compressed: f.compressed,
+        originalSize: f.originalSize,
+        compressionAlgorithm: f.compressionAlgorithm
+      }
+    }
+  }));
+  const { urls, errors: requestErrors } = await storageApi.requestPresignedUrlBatch(requests);
+  const failedSlotIds = /* @__PURE__ */ new Set();
+  const failed = requestErrors.map((e) => {
+    const idx = e.clientIndex ?? slotted.findIndex((s) => s.file.name === e.filename);
+    const slotId = slotted[idx]?.slotId;
+    if (slotId) failedSlotIds.add(slotId);
+    return { filename: e.filename, error: e.error };
+  });
+  const progressMap = {};
+  const reportProgress = () => {
+    if (!onProgress) return;
+    const vals = Object.values(progressMap);
+    const avg = vals.reduce((s, v) => s + v, 0) / Math.max(vals.length, 1);
+    onProgress(Math.round(avg));
+  };
+  const successful = [];
+  const slotToFile = /* @__PURE__ */ new Map();
+  await Promise.all(
+    urls.map(async (presigned, idx) => {
+      const originalIdx = presigned.clientIndex ?? idx;
+      const { file, slotId } = slotted[originalIdx];
+      progressMap[originalIdx] = 0;
+      try {
+        let fileResponse;
+        if (presigned.multipart && platformUploadPartFn) {
+          fileResponse = await runMultipartUpload(presigned, file, platformUploadPartFn, (pct) => {
+            progressMap[originalIdx] = pct;
+            reportProgress();
+          });
+        } else {
+          await platformUploadFn(presigned, file, (pct) => {
+            progressMap[originalIdx] = Math.round(pct * 0.9);
+            reportProgress();
+          });
+          fileResponse = await storageApi.confirmUpload(presigned.fileId);
+        }
+        progressMap[originalIdx] = 100;
+        reportProgress();
+        successful.push(fileResponse);
+        slotToFile.set(slotId, fileResponse);
+      } catch (err) {
+        failed.push({ filename: file.name, error: err.message });
+      }
+    })
+  );
+  return { result: { successful, failed }, slotToFile };
+}
+async function uploadBatch(files, platformUploadFn, conversationId, onProgress, platformCompressFn, compressionConfig, platformUploadPartFn) {
+  const slotIds = files.map(() => generateUUID());
+  const { result } = await runUploadBatch(files, platformUploadFn, slotIds, conversationId, onProgress, platformCompressFn, compressionConfig, platformUploadPartFn);
+  return result;
+}
+
+// src/api/devices.ts
+var devicesApi = {
+  /**
+   * Register or update a device push token with the chat server.
+   *
+   * Upserts by `deviceId` — calling this multiple times with the same deviceId
+   * simply refreshes the token value (tokens can rotate silently on some platforms).
+   *
+   * The SDK never calls this automatically. The parent app or the `tokenProvider`
+   * option in `pushNotifications` config is responsible for calling it after
+   * obtaining the token from the OS / browser.
+   */
+  async register(payload) {
+    await getApiClient().post("/users/me/devices", payload);
   },
-  pinMessage(messageId) {
-    return withAck("pin_message", { messageId });
+  /**
+   * Remove a device token from the chat server.
+   * Call this on logout so the user stops receiving push notifications on this device.
+   */
+  async remove(deviceId) {
+    await getApiClient().post(`/users/me/devices/${deviceId}/remove`);
+  }
+};
+
+// src/api/users.ts
+var usersApi = {
+  async list(params = {}) {
+    const { data } = await getApiClient().get("/users", { params });
+    return data;
   },
-  unpinMessage(messageId) {
-    return withAck("unpin_message", { messageId });
+  async getById(userId) {
+    const { data } = await getApiClient().get(`/users/${userId}`);
+    return data;
   },
-  // markRead and typing are best-effort — silently dropped if socket not ready
-  typing(conversationId, isTyping) {
-    fireAndForget("typing", { conversationId, isTyping });
+  async getLastSeen(userId) {
+    const { data } = await getApiClient().get(`/users/${userId}`);
+    return { lastSeenAt: data.lastSeenAt ?? null };
   },
-  markRead(conversationId, messageId) {
-    fireAndForget("mark_read", { conversationId, ...messageId ? { messageId } : {} });
+  /**
+   * Update basic profile fields for the current user.
+   * Works in both builtin and non-builtin modes. Use this to push an immediate
+   * profile update to the chat server when the host app knows a change just
+   * happened — without waiting for the next 2-hour sync cycle.
+   */
+  async updateProfile(payload) {
+    const { data } = await getApiClient().post("/users/me/update", payload);
+    return data;
   },
-  getOnlineUsers(userIds) {
-    const socket = tryGetSocket();
-    if (!socket) return Promise.resolve([]);
-    return new Promise((resolve, reject) => {
-      let timer;
-      secureEmit(socket, "get_online_users", { userIds }, (response) => {
-        clearTimeout(timer);
-        if (response && typeof response === "object" && "onlineStatus" in response) {
-          const status = response.onlineStatus;
-          resolve(Object.entries(status).filter(([, v]) => v).map(([k]) => k));
-        } else if (Array.isArray(response)) {
-          resolve(response);
-        } else {
-          resolve([]);
-        }
-      }).then(() => {
-        timer = setTimeout(() => reject(new AntzChatNetworkError("Socket ack timeout: get_online_users", "SOCKET_TIMEOUT", { event: "get_online_users" })), ACK_TIMEOUT);
-      }).catch(reject);
-    });
+  /**
+   * Update notification preferences for the current user.
+   * Partial update — only send fields you want to change.
+   * A prefs record is automatically created with defaults when a device
+   * token is first registered, so this never fails with "not found".
+   */
+  async updatePreferences(prefs) {
+    const { data } = await getApiClient().post("/users/me/preferences", prefs);
+    return data;
   },
-  getTypingUsers(conversationId) {
-    return withAck("get_typing_users", { conversationId });
+  /**
+   * Fetch current notification preferences for the current user.
+   * Returns null if no prefs record exists yet (all defaults apply).
+   */
+  async getPreferences() {
+    try {
+      const { data } = await getApiClient().get("/users/me/preferences");
+      return data;
+    } catch {
+      return null;
+    }
   }
 };
 
@@ -2113,6 +2157,7 @@ var AntzChatClient = class {
   AntzChatPermissionError,
   AntzChatServerError,
   AntzChatValidationError,
+  HIGHLY_FORWARDED_DEPTH_THRESHOLD,
   MAX_FORWARD_TARGETS,
   MENTION_ALL_ID,
   appConfigApi,