@antzsoft/chat-core 1.4.3 → 1.4.5

package/dist/index.cjs

@@ -134,6 +134,7 @@ __export(src_exports, {
   getSocketStatus: () => getSocketStatus,
   initApiClient: () => initApiClient,
   initAuthStore: () => initAuthStore,
+  isApiClientConfigured: () => isApiClientConfigured,
   isMentionAll: () => isMentionAll,
   isTransitEnvelope: () => isTransitEnvelope,
   messagesApi: () => messagesApi,
@@ -146,9 +147,11 @@ __export(src_exports, {
   refreshSocketAuth: () => refreshSocketAuth,
   renderMentionParts: () => renderMentionParts,
   resetAuthStore: () => resetAuthStore,
+  resetTrackedRooms: () => resetTrackedRooms,
   resolveConfig: () => resolveConfig,
   resolveSystemMessageText: () => resolveSystemMessageText,
   setApiClientInstance: () => setApiClientInstance,
+  setAuthReadyPromise: () => setAuthReadyPromise,
   setTransitSession: () => setTransitSession,
   socketEmit: () => socketEmit,
   storageApi: () => storageApi,
@@ -214,6 +217,7 @@ function resolveConfig(config) {
       compressDocuments: config.compression?.compressDocuments ?? true
     },
     persistStorage: config.persistStorage,
+    onSendError: config.onSendError,
     messagePageSize: config.messagePageSize ?? 40,
     starredMessagePageSize: config.starredMessagePageSize ?? 30,
     searchPageSize: config.searchPageSize ?? 50
@@ -386,7 +390,8 @@ function getState() {
       sessionEverEstablished: false,
       readyResolve: null,
       readyPromise: null,
-      transitConfigured: null
+      transitConfigured: null,
+      readyListeners: /* @__PURE__ */ new Set()
     };
   }
   return g[_KEY];
@@ -399,11 +404,13 @@ function configureTransit(enabled) {
     s.readyResolve = null;
   }
 }
+function configureTransitIfUnset(enabled) {
+  if (getState().transitConfigured === null) configureTransit(enabled);
+}
 function waitForTransitReady() {
   const s = getState();
   if (!s.transitConfigured) return Promise.resolve();
   if (s.session) return Promise.resolve();
-  if (s.sessionEverEstablished) return Promise.resolve();
   if (!s.readyPromise) {
     s.readyPromise = new Promise((resolve) => {
       s.readyResolve = resolve;
@@ -417,6 +424,29 @@ function setTransitSession(session) {
   s.sessionEverEstablished = true;
   s.readyResolve?.();
   s.readyResolve = null;
+  s.readyListeners.forEach((fn) => {
+    try {
+      fn();
+    } catch {
+    }
+  });
+}
+function onTransitReady(listener) {
+  const s = getState();
+  s.readyListeners.add(listener);
+  return () => {
+    s.readyListeners.delete(listener);
+  };
+}
+async function awaitTransitReadyOr(timeoutMs) {
+  const s = getState();
+  if (!s.transitConfigured || s.session) return true;
+  await Promise.race([
+    waitForTransitReady(),
+    new Promise((r) => setTimeout(r, timeoutMs))
+  ]);
+  const now = getState();
+  return Boolean(now.session) || now.transitConfigured !== true;
 }
 function getTransitSession() {
   return getState().session;
@@ -424,12 +454,16 @@ function getTransitSession() {
 function clearTransitSession() {
   const s = getState();
   s.session = null;
+  s.sessionEverEstablished = false;
   s.readyPromise = null;
   s.readyResolve = null;
 }
 function isTransitEnabled() {
   return getState().session?.enabled === true;
 }
+function isTransitRequired() {
+  return getState().transitConfigured === true;
+}
 function getSessionKey() {
   return getState().session?.sessionKey ?? null;
 }
@@ -668,13 +702,52 @@ function normalizeAxiosError(error) {
 }
 
 // src/api/client.ts
+var TRANSIT_GATE_MAX_WAIT_MS = 3e4;
 var _tokenStore = null;
 var _config = null;
 var _avatarSent = false;
 var _transitHandshakePromise = null;
+var _authReadyPromise = null;
 function getTransitHandshakePromise() {
   return _transitHandshakePromise;
 }
+function setAuthReadyPromise(promise) {
+  _authReadyPromise = promise;
+}
+function isApiClientConfigured() {
+  return _config !== null;
+}
+function ensureRestTransitHandshake() {
+  if (!_config?.transitEncryption || getTransitSession() || _transitHandshakePromise) return;
+  const apiUrl = _config.apiUrl;
+  _transitHandshakePromise = (async () => {
+    try {
+      for (let attempt = 0; attempt < 5; attempt++) {
+        if (getTransitSession()) return;
+        try {
+          const keys = await fetchServerKeys(apiUrl);
+          if (!keys?.enabled) {
+            configureTransit(false);
+            return;
+          }
+          const session = await createRestTransitSession(apiUrl);
+          if (session && !getTransitSession()) {
+            const algo = typeof globalThis.crypto?.subtle !== "undefined" ? await detectTransitAlgo() : "x25519";
+            setTransitSession({ sessionKey: session.sessionKey, algo, sessionId: session.sessionId, enabled: true });
+            return;
+          }
+        } catch {
+        }
+        await new Promise((r) => setTimeout(r, Math.min(500 * 2 ** attempt, 8e3)));
+      }
+      console.error(
+        "[AntzChat] transit handshake could not establish a session after 5 attempts \u2014 chat requests stay gated until one succeeds (server requires transit)."
+      );
+    } finally {
+      _transitHandshakePromise = null;
+    }
+  })();
+}
 function initApiClient(config, tokenStore) {
   _config = config;
   _tokenStore = tokenStore;
@@ -684,24 +757,9 @@ function initApiClient(config, tokenStore) {
     headers: { "Content-Type": "application/json" }
   });
   configureTransit(config.transitEncryption);
-  if (config.transitEncryption && !getTransitSession() && !_transitHandshakePromise) {
-    _transitHandshakePromise = (async () => {
-      try {
-        const session = await createRestTransitSession(config.apiUrl);
-        if (session && !getTransitSession()) {
-          const algo = typeof globalThis.crypto?.subtle !== "undefined" ? await detectTransitAlgo() : "x25519";
-          setTransitSession({ sessionKey: session.sessionKey, algo, sessionId: session.sessionId, enabled: true });
-        } else if (!session) {
-          configureTransit(false);
-        }
-      } catch {
-        configureTransit(false);
-      } finally {
-        _transitHandshakePromise = null;
-      }
-    })();
-  }
+  ensureRestTransitHandshake();
   client.interceptors.request.use(async (req) => {
+    if (_authReadyPromise) await _authReadyPromise;
     const token = _tokenStore?.getAccessToken();
     if (token) req.headers["Authorization"] = `Bearer ${token}`;
     if (_config?.userId) req.headers["x-user-id"] = _config.userId;
@@ -711,7 +769,17 @@ function initApiClient(config, tokenStore) {
       else if (_config.avatar.url) req.headers["x-avatar-url"] = _config.avatar.url;
       _avatarSent = true;
     }
-    if (token) await waitForTransitReady();
+    if (_config?.transitEncryption) {
+      if (!getTransitSession()) ensureRestTransitHandshake();
+      const ready = await awaitTransitReadyOr(TRANSIT_GATE_MAX_WAIT_MS);
+      if (!ready) {
+        throw new AntzChatNetworkError(
+          "Secure channel to chat server not established \u2014 request not sent. It will retry automatically.",
+          "TRANSIT_NOT_READY",
+          { url: req.url }
+        );
+      }
+    }
     if (isTransitEnabled()) {
       const sessionId = getSessionId();
       const key = getSessionKey();
@@ -1013,559 +1081,38 @@ function resolveSystemMessageText(message, currentUserId) {
   }
 }
 
-// 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;
-  },
-  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.
-   */
-  async forward(messageId, targetConversationIds, attachmentIds) {
-    const { data } = await getApiClient().post(
-      `/messages/${messageId}/forward`,
-      { targetConversationIds, ...attachmentIds ? { attachmentIds } : {} }
-    );
-    return data;
+// 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/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
-  };
+// src/socket/socket.ts
+var import_socket = require("socket.io-client");
+var _socket = null;
+var _socketProxy = null;
+var _connectingPromise = null;
+var _status = "disconnected";
+var _statusListeners = /* @__PURE__ */ new Set();
+var _getToken = null;
+var _userId;
+var _tenantId;
+var _config2 = null;
+function setStatus(s) {
+  _status = s;
+  _statusListeners.forEach((l) => l(s));
 }
-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 getSocket() {
+  if (!_socketProxy) throw new Error("[AntzChat] Socket not initialized. Call connectSocket first.");
+  return _socketProxy;
 }
-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/socket/socket.ts
-var import_socket = require("socket.io-client");
-var _socket = null;
-var _socketProxy = null;
-var _connectingPromise = null;
-var _status = "disconnected";
-var _statusListeners = /* @__PURE__ */ new Set();
-var _getToken = null;
-var _userId;
-var _tenantId;
-var _config2 = null;
-var _preservingSession = false;
-function setStatus(s) {
-  _status = s;
-  _statusListeners.forEach((l) => l(s));
-}
-function getSocket() {
-  if (!_socketProxy) throw new Error("[AntzChat] Socket not initialized. Call connectSocket first.");
-  return _socketProxy;
-}
-function tryGetSocket() {
-  return _socket?.connected ? _socketProxy : null;
+function tryGetSocket() {
+  return _socket?.connected ? _socketProxy : null;
 }
 function getSocketStatus() {
   return _status;
@@ -1574,29 +1121,48 @@ function onSocketStatus(listener) {
   _statusListeners.add(listener);
   return () => _statusListeners.delete(listener);
 }
-async function secureEmit(socket, event, payload, ack) {
-  if (isTransitEnabled()) {
-    const key = getSessionKey();
-    if (key) {
-      const envelope = await encryptPayload(payload, key);
-      if (ack) {
-        socket.emit(event, envelope, async (encryptedResponse) => {
-          if (isTransitEnvelope(encryptedResponse)) {
-            try {
-              const decrypted = await decryptPayload(encryptedResponse, key);
-              ack(decrypted);
-            } catch {
-              ack(encryptedResponse);
-            }
-          } else {
-            ack(encryptedResponse);
-          }
-        });
+var SECURE_EMIT_WAIT_MS = 4e3;
+function emitEncrypted(socket, event, envelope, key, ack) {
+  if (ack) {
+    socket.emit(event, envelope, async (encryptedResponse) => {
+      if (isTransitEnvelope(encryptedResponse)) {
+        try {
+          ack(await decryptPayload(encryptedResponse, key));
+        } catch {
+          ack(encryptedResponse);
+        }
       } else {
-        socket.emit(event, envelope);
+        ack(encryptedResponse);
       }
+    });
+  } else {
+    socket.emit(event, envelope);
+  }
+}
+async function secureEmit(socket, event, payload, ack) {
+  let key = getSessionKey();
+  if (key && isTransitEnabled()) {
+    emitEncrypted(socket, event, await encryptPayload(payload, key), key, ack);
+    return;
+  }
+  if (isTransitRequired()) {
+    try {
+      ensureRestTransitHandshake();
+    } catch {
+    }
+    const ok = await awaitTransitReadyOr(SECURE_EMIT_WAIT_MS);
+    key = getSessionKey();
+    if (ok && key && isTransitEnabled()) {
+      emitEncrypted(socket, event, await encryptPayload(payload, key), key, ack);
       return;
     }
+    if (isTransitRequired()) {
+      throw new AntzChatNetworkError(
+        `Transit encryption required but no session established \u2014 "${event}" not sent`,
+        "TRANSIT_NOT_READY",
+        { event }
+      );
+    }
   }
   if (ack) {
     socket.emit(event, payload, ack);
@@ -1622,6 +1188,28 @@ function secureOn(socket, event, handler) {
     handler(raw);
   });
 }
+var _joinedRooms = /* @__PURE__ */ new Set();
+function trackRoomJoin(conversationId) {
+  _joinedRooms.add(conversationId);
+}
+function trackRoomLeave(conversationId) {
+  _joinedRooms.delete(conversationId);
+}
+function resetTrackedRooms() {
+  _joinedRooms.clear();
+}
+function flushJoinedRooms() {
+  const socket = tryGetSocket();
+  if (!socket || _joinedRooms.size === 0) return;
+  for (const conversationId of _joinedRooms) {
+    void secureEmit(socket, "join_room", { conversationId }).catch(() => {
+    });
+  }
+}
+onTransitReady(flushJoinedRooms);
+onSocketStatus((status) => {
+  if (status === "connected") flushJoinedRooms();
+});
 async function connectSocket(config, getToken) {
   if (_socket && !_socket.disconnected) return _socket;
   if (_connectingPromise) return _connectingPromise;
@@ -1643,6 +1231,7 @@ async function _doConnect(config, getToken) {
     ...config.avatar?.url && { avatarUrl: config.avatar.url },
     ...config.avatar?.base64 && { avatarBase64: config.avatar.base64 }
   };
+  configureTransitIfUnset(config.transitEncryption);
   let boundDeriveSessionKey = null;
   if (config.transitEncryption) {
     const inFlight = getTransitHandshakePromise();
@@ -1707,7 +1296,6 @@ async function _doConnect(config, getToken) {
   _socket.on("connect", () => setStatus("connected"));
   _socket.on("disconnect", () => {
     setStatus("disconnected");
-    if (!_preservingSession) clearTransitSession();
   });
   _socket.on("connect_error", (err) => {
     console.error("[AntzChat] Socket connect_error:", err?.message, err?.data);
@@ -1722,8 +1310,9 @@ async function _doConnect(config, getToken) {
         resolve();
       };
       const timeout = setTimeout(() => {
-        console.warn("[AntzChat] transit_session timeout \u2014 unblocking HTTP without transit encryption");
-        configureTransit(false);
+        console.error(
+          "[AntzChat] transit_session did not arrive within 5s. Transit stays REQUIRED \u2014 chat requests are gated (not downgraded to plaintext) until the handshake succeeds via REST retry or socket reconnect. Persistent failure = check POST /crypto/session (rate limit / 5xx) and the socket transit middleware."
+        );
         done();
       }, 5e3);
       _socket.on("transit_session", async ({ sessionId }) => {
@@ -1763,225 +1352,796 @@ async function _doConnect(config, getToken) {
       if (e.lastSeenAt) store.setLastSeen(e.userId, e.lastSeenAt);
     });
   });
-  _socketProxy = createSecureSocketProxy(_socket);
-  return _socketProxy;
+  _socketProxy = createSecureSocketProxy(_socket);
+  return _socketProxy;
+}
+function createSecureSocketProxy(socket) {
+  return new Proxy(socket, {
+    get(target, prop) {
+      if (prop === "on") {
+        return (event, handler) => {
+          const internal = ["connect", "disconnect", "connect_error", "reconnect", "reconnecting", "error"];
+          if (internal.includes(event)) {
+            return target.on(event, handler);
+          }
+          secureOn(target, event, handler);
+          return socket;
+        };
+      }
+      const val = target[prop];
+      return typeof val === "function" ? val.bind(target) : val;
+    }
+  });
+}
+function disconnectSocket() {
+  _connectingPromise = null;
+  if (_socket) {
+    _socket.disconnect();
+    _socket = null;
+    _socketProxy = null;
+    setStatus("disconnected");
+  }
+  clearTransitSession();
+  resetAlgoCache();
+  _getToken = null;
+  _userId = void 0;
+  _tenantId = void 0;
+  _config2 = null;
+}
+function reconnectSocket(token, userId, tenantId) {
+  if (!_socket) return;
+  if (_config2?.transitEncryption) {
+    const existing = getTransitSession();
+    if (existing?.enabled && existing.sessionId) {
+      _socket.auth = {
+        token: `Bearer ${token}`,
+        ...userId && { userId },
+        ...tenantId && { tenantId },
+        transitSessionId: existing.sessionId
+      };
+      if (_socket.connected) _socket.disconnect();
+      _socket.connect();
+      return;
+    }
+    if (_getToken) {
+      if (!_socket.disconnected) _socket.disconnect();
+      void connectSocket(_config2, _getToken);
+      return;
+    }
+  }
+  _socket.auth = {
+    token: `Bearer ${token}`,
+    ...userId && { userId },
+    ...tenantId && { tenantId }
+  };
+  _socket.connect();
+}
+function refreshSocketAuth() {
+  if (!_socket || !_getToken) return false;
+  const fresh = _getToken();
+  if (!fresh) return false;
+  _socket.auth = {
+    token: `Bearer ${fresh}`,
+    ..._userId && { userId: _userId },
+    ..._tenantId && { tenantId: _tenantId }
+  };
+  return true;
+}
+
+// src/socket/emitters.ts
+var ACK_TIMEOUT = 5e3;
+var RECONNECT_WAIT_TIMEOUT = 15e3;
+var QUEUE_MAX_SIZE = 100;
+var QUEUE_ENTRY_TTL = 3e4;
+var sendQueues = /* @__PURE__ */ new Map();
+var sendQueueRunning = /* @__PURE__ */ new Map();
+async function drainSendQueue(conversationId) {
+  if (sendQueueRunning.get(conversationId)) return;
+  sendQueueRunning.set(conversationId, true);
+  const queue = sendQueues.get(conversationId);
+  while (queue.length > 0) {
+    const entry = queue.shift();
+    if (Date.now() - entry.enqueuedAt > QUEUE_ENTRY_TTL) {
+      entry.reject(new AntzChatNetworkError("Message dropped: queued too long", "MESSAGE_DROPPED"));
+      continue;
+    }
+    let acked;
+    try {
+      ({ acked } = await emitWithAck("send_message", entry.payload));
+    } catch (err) {
+      entry.reject(err);
+      while (queue.length > 0) queue.shift().reject(err);
+      break;
+    }
+    acked.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({ payload, resolve, reject, enqueuedAt: Date.now() });
+    drainSendQueue(conversationId);
+  });
 }
-function createSecureSocketProxy(socket) {
-  return new Proxy(socket, {
-    get(target, prop) {
-      if (prop === "on") {
-        return (event, handler) => {
-          const internal = ["connect", "disconnect", "connect_error", "reconnect", "reconnecting", "error"];
-          if (internal.includes(event)) {
-            return target.on(event, handler);
-          }
-          secureOn(target, event, handler);
-          return socket;
-        };
+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"));
       }
-      const val = target[prop];
-      return typeof val === "function" ? val.bind(target) : val;
-    }
+    });
   });
 }
-function disconnectSocket() {
-  _connectingPromise = null;
-  if (_socket) {
-    _socket.disconnect();
-    _socket = null;
-    _socketProxy = null;
-    setStatus("disconnected");
+async function emitWithAck(event, payload) {
+  let socket = tryGetSocket();
+  if (!socket) {
+    await waitForReconnect();
+    socket = tryGetSocket();
   }
-  clearTransitSession();
-  resetAlgoCache();
-  _getToken = null;
-  _userId = void 0;
-  _tenantId = void 0;
-  _config2 = null;
+  if (!socket) throw new AntzChatNetworkError(`Socket not connected (event: ${event})`, "SOCKET_NOT_CONNECTED", { event });
+  let resolveAck;
+  let rejectAck;
+  const acked = new Promise((res, rej) => {
+    resolveAck = res;
+    rejectAck = rej;
+  });
+  await secureEmit(socket, event, payload, (response) => resolveAck(response));
+  const timer = setTimeout(
+    () => rejectAck(new AntzChatNetworkError(`Socket ack timeout: ${event}`, "SOCKET_TIMEOUT", { event })),
+    ACK_TIMEOUT
+  );
+  void acked.then(() => clearTimeout(timer), () => clearTimeout(timer));
+  return { acked };
 }
-function reconnectSocket(token, userId, tenantId) {
-  if (!_socket) return;
-  if (_config2?.transitEncryption) {
-    const existing = getTransitSession();
-    if (existing?.enabled && existing.sessionId) {
-      _socket.auth = {
-        token: `Bearer ${token}`,
-        ...userId && { userId },
-        ...tenantId && { tenantId },
-        transitSessionId: existing.sessionId
-      };
-      _preservingSession = true;
-      try {
-        if (_socket.connected) _socket.disconnect();
-        _socket.connect();
-      } finally {
-        _preservingSession = false;
-      }
-      return;
+async function withAck(event, payload) {
+  const { acked } = await emitWithAck(event, payload);
+  return acked;
+}
+function fireAndForget(event, payload) {
+  const socket = tryGetSocket();
+  if (!socket) return;
+  secureEmit(socket, event, payload).catch(() => {
+  });
+}
+var socketEmit = {
+  joinRoom(conversationId) {
+    trackRoomJoin(conversationId);
+    fireAndForget("join_room", { conversationId });
+  },
+  leaveRoom(conversationId) {
+    trackRoomLeave(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;
     }
-    if (_getToken) {
-      if (!_socket.disconnected) _socket.disconnect();
-      void connectSocket(_config2, _getToken);
-      return;
+    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;
   }
-  _socket.auth = {
-    token: `Bearer ${token}`,
-    ...userId && { userId },
-    ...tenantId && { tenantId }
+};
+
+// 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
   };
-  _socket.connect();
 }
-function refreshSocketAuth() {
-  if (!_socket || !_getToken) return false;
-  const fresh = _getToken();
-  if (!fresh) return false;
-  _socket.auth = {
-    token: `Bearer ${fresh}`,
-    ..._userId && { userId: _userId },
-    ..._tenantId && { tenantId: _tenantId }
+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 }
   };
-  return true;
-}
-
-// src/socket/emitters.ts
-var ACK_TIMEOUT = 5e3;
-var RECONNECT_WAIT_TIMEOUT = 15e3;
-var QUEUE_MAX_SIZE = 100;
-var QUEUE_ENTRY_TTL = 3e4;
-var sendQueues = /* @__PURE__ */ new Map();
-var sendQueueRunning = /* @__PURE__ */ new Map();
-async function drainSendQueue(conversationId) {
-  if (sendQueueRunning.get(conversationId)) return;
-  sendQueueRunning.set(conversationId, true);
-  const queue = sendQueues.get(conversationId);
-  while (queue.length > 0) {
-    const entry = queue.shift();
-    if (Date.now() - entry.enqueuedAt > QUEUE_ENTRY_TTL) {
-      entry.reject(new AntzChatNetworkError("Message dropped: queued too long", "MESSAGE_DROPPED"));
-      continue;
-    }
-    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"));
-      }
-    });
-  });
+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;
+    }
   }
 };
 
@@ -2146,6 +2306,7 @@ var AntzChatClient = class {
   getSocketStatus,
   initApiClient,
   initAuthStore,
+  isApiClientConfigured,
   isMentionAll,
   isTransitEnvelope,
   messagesApi,
@@ -2158,9 +2319,11 @@ var AntzChatClient = class {
   refreshSocketAuth,
   renderMentionParts,
   resetAuthStore,
+  resetTrackedRooms,
   resolveConfig,
   resolveSystemMessageText,
   setApiClientInstance,
+  setAuthReadyPromise,
   setTransitSession,
   socketEmit,
   storageApi,