@antzsoft/chat-core 1.2.3 → 1.2.5

package/dist/index.cjs

@@ -52,6 +52,7 @@ var init_chat_store = __esm({
       isSidebarOpen: true,
       isGroupInfoOpen: false,
       isStarredPanelOpen: false,
+      messageInfoId: null,
       setActiveConversation: (id) => set({ activeConversationId: id, replyingTo: null, editingMessage: null }),
       setPendingTarget: (target) => set({ pendingTarget: target }),
       addTypingUser: (conversationId, user) => set((state) => {
@@ -89,7 +90,8 @@ var init_chat_store = __esm({
       toggleGroupInfo: () => set((state) => ({ isGroupInfoOpen: !state.isGroupInfoOpen })),
       setGroupInfoOpen: (open) => set({ isGroupInfoOpen: open }),
       toggleStarredPanel: () => set((state) => ({ isStarredPanelOpen: !state.isStarredPanelOpen })),
-      setStarredPanelOpen: (open) => set({ isStarredPanelOpen: open })
+      setStarredPanelOpen: (open) => set({ isStarredPanelOpen: open }),
+      setMessageInfoId: (id) => set({ messageInfoId: id })
     }));
   }
 });
@@ -103,18 +105,27 @@ __export(src_exports, {
   connectSocket: () => connectSocket,
   conversationsApi: () => conversationsApi,
   createAuthStore: () => createAuthStore,
+  createRestTransitSession: () => createRestTransitSession,
+  decryptPayload: () => decryptPayload,
   devicesApi: () => devicesApi,
   disconnectSocket: () => disconnectSocket,
+  encryptPayload: () => encryptPayload,
+  fetchServerKeys: () => fetchServerKeys,
+  generateEphemeralKey: () => generateEphemeralKey,
   getApiClient: () => getApiClient,
   getAuthStore: () => getAuthStore,
   getCompressionStrategy: () => getCompressionStrategy,
+  getSessionId: () => getSessionId,
+  getSessionKey: () => getSessionKey,
   getSocket: () => getSocket,
   getSocketStatus: () => getSocketStatus,
   initApiClient: () => initApiClient,
   initAuthStore: () => initAuthStore,
+  isTransitEnvelope: () => isTransitEnvelope,
   messagesApi: () => messagesApi,
   normalizeConversation: () => normalizeConversation,
   onSocketStatus: () => onSocketStatus,
+  performHandshake: () => performHandshake,
   reconnectSocket: () => reconnectSocket,
   refreshSocketAuth: () => refreshSocketAuth,
   resetAuthStore: () => resetAuthStore,
@@ -176,6 +187,7 @@ function resolveConfig(config) {
       onProgress: config.upload?.onProgress
     },
     platformUploadFn: config.platformUploadFn,
+    platformUploadPartFn: config.platformUploadPartFn,
     platformCompressFn: config.platformCompressFn,
     compression: {
       enabled: config.compression?.enabled ?? config.platformCompressFn != null,
@@ -388,6 +400,9 @@ function setTransitSession(session) {
   s.readyResolve?.();
   s.readyResolve = null;
 }
+function getTransitSession() {
+  return getState().session;
+}
 function clearTransitSession() {
   const s = getState();
   s.session = null;
@@ -404,10 +419,156 @@ function getSessionId() {
   return getState().session?.sessionId ?? null;
 }
 
+// src/crypto/detect.ts
+var _cached = null;
+async function detectTransitAlgo() {
+  if (_cached) return _cached;
+  try {
+    await globalThis.crypto.subtle.generateKey(
+      { name: "X25519" },
+      false,
+      ["deriveKey"]
+    );
+    _cached = "x25519";
+  } catch {
+    _cached = "p256";
+  }
+  return _cached;
+}
+function resetAlgoCache() {
+  _cached = null;
+}
+
+// src/crypto/handshake.ts
+function hasWebCrypto2() {
+  return typeof globalThis.crypto?.subtle !== "undefined";
+}
+async function fetchServerKeys(apiUrl) {
+  const res = await fetch(`${apiUrl}/crypto/pubkey`);
+  if (!res.ok) throw new Error(`[AntzChat] Failed to fetch server public key: ${res.status}`);
+  const body = await res.json();
+  return body?.data ?? body;
+}
+async function generateEphemeralKey(algo, serverKeys) {
+  if (hasWebCrypto2()) {
+    return generateWebCryptoEphemeralKey(algo, serverKeys);
+  }
+  return generateNobleEphemeralKey(serverKeys);
+}
+async function createRestTransitSession(apiUrl) {
+  try {
+    const serverKeys = await fetchServerKeys(apiUrl);
+    if (!serverKeys.enabled) return null;
+    const algo = hasWebCrypto2() ? await detectTransitAlgo() : "x25519";
+    const { ephemeralPubB64, deriveSessionKey } = await generateEphemeralKey(algo, serverKeys);
+    const res = await fetch(`${apiUrl}/crypto/session`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ ephemeralPub: ephemeralPubB64, algo })
+    });
+    if (!res.ok) return null;
+    const body = await res.json();
+    const sessionId = (body?.data ?? body)?.sessionId ?? body?.sessionId;
+    if (!sessionId) return null;
+    const sessionKey = await deriveSessionKey(sessionId);
+    return { sessionId, sessionKey };
+  } catch {
+    return null;
+  }
+}
+async function performHandshake(algo, serverKeys, socketHandshakeAuth) {
+  const { ephemeralPubB64, deriveSessionKey } = await generateEphemeralKey(algo, serverKeys);
+  socketHandshakeAuth["transitEphemeralPub"] = ephemeralPubB64;
+  socketHandshakeAuth["transitAlgo"] = algo;
+  return deriveSessionKey;
+}
+async function generateWebCryptoEphemeralKey(algo, serverKeys) {
+  const ephemeral = await globalThis.crypto.subtle.generateKey(
+    algo === "x25519" ? { name: "X25519" } : { name: "ECDH", namedCurve: "P-256" },
+    false,
+    ["deriveBits"]
+  );
+  const pubRaw = await globalThis.crypto.subtle.exportKey("raw", ephemeral.publicKey);
+  const ephemeralPriv = ephemeral.privateKey;
+  return {
+    ephemeralPubB64: bufToB642(pubRaw),
+    deriveSessionKey: (sessionId) => deriveWebCryptoSessionKey(ephemeralPriv, algo, serverKeys, sessionId)
+  };
+}
+async function deriveWebCryptoSessionKey(ephemeralPriv, algo, serverKeys, sessionId) {
+  const serverPubRaw = b64ToBuf2(algo === "x25519" ? serverKeys.x25519 : serverKeys.p256);
+  const keyAlgoParams = algo === "x25519" ? { name: "X25519" } : { name: "ECDH", namedCurve: "P-256" };
+  const serverPubKey = await globalThis.crypto.subtle.importKey("raw", serverPubRaw, keyAlgoParams, false, []);
+  const sharedBits = await globalThis.crypto.subtle.deriveBits(
+    { name: algo === "x25519" ? "X25519" : "ECDH", public: serverPubKey },
+    ephemeralPriv,
+    256
+  );
+  const hkdfKey = await globalThis.crypto.subtle.importKey("raw", sharedBits, "HKDF", false, ["deriveKey"]);
+  const salt = new TextEncoder().encode(sessionId);
+  const info = new TextEncoder().encode("antz-transit-v1");
+  return globalThis.crypto.subtle.deriveKey(
+    { name: "HKDF", hash: "SHA-256", salt, info },
+    hkdfKey,
+    { name: "AES-GCM", length: 256 },
+    false,
+    ["encrypt", "decrypt"]
+  );
+}
+async function generateNobleEphemeralKey(serverKeys) {
+  const { x25519 } = await import("@noble/curves/ed25519");
+  const { hkdf } = await import("@noble/hashes/hkdf");
+  const { sha256 } = await import("@noble/hashes/sha256");
+  const { randomBytes } = await import("@noble/hashes/utils");
+  const ephemeralPriv = randomBytes(32);
+  const ephemeralPub = x25519.getPublicKey(ephemeralPriv);
+  const serverPubBytes = base64ToUint82(serverKeys.x25519);
+  return {
+    ephemeralPubB64: uint8ToBase64(ephemeralPub),
+    deriveSessionKey: (sessionId) => {
+      const sharedSecret = x25519.getSharedSecret(ephemeralPriv, serverPubBytes);
+      const salt = new TextEncoder().encode(sessionId);
+      const info = new TextEncoder().encode("antz-transit-v1");
+      return Promise.resolve(hkdf(sha256, sharedSecret, salt, info, 32));
+    }
+  };
+}
+function bufToB642(buf) {
+  const bytes = new Uint8Array(buf);
+  let str = "";
+  bytes.forEach((b) => {
+    str += String.fromCharCode(b);
+  });
+  return btoa(str);
+}
+function b64ToBuf2(b64) {
+  const bin = atob(b64);
+  const buf = new Uint8Array(bin.length);
+  for (let i = 0; i < bin.length; i++) buf[i] = bin.charCodeAt(i);
+  return buf.buffer;
+}
+function uint8ToBase64(bytes) {
+  let str = "";
+  bytes.forEach((b) => {
+    str += String.fromCharCode(b);
+  });
+  return btoa(str);
+}
+function base64ToUint82(b64) {
+  const bin = atob(b64);
+  const buf = new Uint8Array(bin.length);
+  for (let i = 0; i < bin.length; i++) buf[i] = bin.charCodeAt(i);
+  return buf;
+}
+
 // src/api/client.ts
 var _tokenStore = null;
 var _config = null;
 var _avatarSent = false;
+var _transitHandshakePromise = null;
+function getTransitHandshakePromise() {
+  return _transitHandshakePromise;
+}
 function initApiClient(config, tokenStore) {
   _config = config;
   _tokenStore = tokenStore;
@@ -417,6 +578,23 @@ 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;
+      }
+    })();
+  }
   client.interceptors.request.use(async (req) => {
     const token = _tokenStore?.getAccessToken();
     if (token) req.headers["Authorization"] = `Bearer ${token}`;
@@ -813,7 +991,7 @@ function normalizeLastMessage(lastMsg) {
     id: lastMsg.messageId ?? "",
     tenantId: "",
     conversationId: "",
-    senderId: "",
+    senderId: lastMsg.senderId ?? "",
     content: {
       type: lastMsg.hasAttachments ? "attachment" : "text",
       text: lastMsg.contentPreview
@@ -824,7 +1002,8 @@ function normalizeLastMessage(lastMsg) {
     isEdited: false,
     sentAt: lastMsg.sentAt ?? "",
     createdAt: lastMsg.sentAt ?? "",
-    ...lastMsg.senderName && { senderName: lastMsg.senderName }
+    ...lastMsg.senderName && { senderName: lastMsg.senderName },
+    ...lastMsg.attachmentType && { attachmentType: lastMsg.attachmentType }
   };
 }
 function normalizeConversation(conv) {
@@ -978,6 +1157,13 @@ var storageApi = {
   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`,
@@ -990,7 +1176,52 @@ var storageApi = {
     return data;
   }
 };
-async function runUploadBatch(files, platformUploadFn, slotIds, conversationId, onProgress, platformCompressFn, compressionConfig) {
+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 }))
   );
@@ -1032,11 +1263,19 @@ async function runUploadBatch(files, platformUploadFn, slotIds, conversationId,
       const { file, slotId } = slotted[originalIdx];
       progressMap[originalIdx] = 0;
       try {
-        await platformUploadFn(presigned, file, (pct) => {
-          progressMap[originalIdx] = Math.round(pct * 0.9);
-          reportProgress();
-        });
-        const fileResponse = await storageApi.confirmUpload(presigned.fileId);
+        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);
@@ -1048,9 +1287,9 @@ async function runUploadBatch(files, platformUploadFn, slotIds, conversationId,
   );
   return { result: { successful, failed }, slotToFile };
 }
-async function uploadBatch(files, platformUploadFn, conversationId, onProgress, platformCompressFn, compressionConfig) {
+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);
+  const { result } = await runUploadBatch(files, platformUploadFn, slotIds, conversationId, onProgress, platformCompressFn, compressionConfig, platformUploadPartFn);
   return result;
 }
 
@@ -1128,122 +1367,6 @@ var usersApi = {
 
 // src/socket/socket.ts
 var import_socket = require("socket.io-client");
-
-// src/crypto/detect.ts
-var _cached = null;
-async function detectTransitAlgo() {
-  if (_cached) return _cached;
-  try {
-    await globalThis.crypto.subtle.generateKey(
-      { name: "X25519" },
-      false,
-      ["deriveKey"]
-    );
-    _cached = "x25519";
-  } catch {
-    _cached = "p256";
-  }
-  return _cached;
-}
-function resetAlgoCache() {
-  _cached = null;
-}
-
-// src/crypto/handshake.ts
-function hasWebCrypto2() {
-  return typeof globalThis.crypto?.subtle !== "undefined";
-}
-async function fetchServerKeys(apiUrl) {
-  const res = await fetch(`${apiUrl}/crypto/pubkey`);
-  if (!res.ok) throw new Error(`[AntzChat] Failed to fetch server public key: ${res.status}`);
-  const body = await res.json();
-  return body?.data ?? body;
-}
-async function performHandshake(algo, serverKeys, socketHandshakeAuth) {
-  if (hasWebCrypto2()) {
-    return performWebCryptoHandshake(algo, serverKeys, socketHandshakeAuth);
-  }
-  return performNobleHandshake(serverKeys, socketHandshakeAuth);
-}
-async function performWebCryptoHandshake(algo, serverKeys, socketHandshakeAuth) {
-  const ephemeral = await globalThis.crypto.subtle.generateKey(
-    algo === "x25519" ? { name: "X25519" } : { name: "ECDH", namedCurve: "P-256" },
-    false,
-    ["deriveBits"]
-  );
-  const pubRaw = await globalThis.crypto.subtle.exportKey("raw", ephemeral.publicKey);
-  socketHandshakeAuth["transitEphemeralPub"] = bufToB642(pubRaw);
-  socketHandshakeAuth["transitAlgo"] = algo;
-  const ephemeralPriv = ephemeral.privateKey;
-  return (sessionId) => deriveWebCryptoSessionKey(ephemeralPriv, algo, serverKeys, sessionId);
-}
-async function deriveWebCryptoSessionKey(ephemeralPriv, algo, serverKeys, sessionId) {
-  const serverPubRaw = b64ToBuf2(algo === "x25519" ? serverKeys.x25519 : serverKeys.p256);
-  const keyAlgoParams = algo === "x25519" ? { name: "X25519" } : { name: "ECDH", namedCurve: "P-256" };
-  const serverPubKey = await globalThis.crypto.subtle.importKey("raw", serverPubRaw, keyAlgoParams, false, []);
-  const sharedBits = await globalThis.crypto.subtle.deriveBits(
-    { name: algo === "x25519" ? "X25519" : "ECDH", public: serverPubKey },
-    ephemeralPriv,
-    256
-  );
-  const hkdfKey = await globalThis.crypto.subtle.importKey("raw", sharedBits, "HKDF", false, ["deriveKey"]);
-  const salt = new TextEncoder().encode(sessionId);
-  const info = new TextEncoder().encode("antz-transit-v1");
-  return globalThis.crypto.subtle.deriveKey(
-    { name: "HKDF", hash: "SHA-256", salt, info },
-    hkdfKey,
-    { name: "AES-GCM", length: 256 },
-    false,
-    ["encrypt", "decrypt"]
-  );
-}
-async function performNobleHandshake(serverKeys, socketHandshakeAuth) {
-  const { x25519 } = await import("@noble/curves/ed25519");
-  const { hkdf } = await import("@noble/hashes/hkdf");
-  const { sha256 } = await import("@noble/hashes/sha256");
-  const { randomBytes } = await import("@noble/hashes/utils");
-  const ephemeralPriv = randomBytes(32);
-  const ephemeralPub = x25519.getPublicKey(ephemeralPriv);
-  const serverPubBytes = base64ToUint82(serverKeys.x25519);
-  socketHandshakeAuth["transitEphemeralPub"] = uint8ToBase64(ephemeralPub);
-  socketHandshakeAuth["transitAlgo"] = "x25519";
-  return (sessionId) => {
-    const sharedSecret = x25519.getSharedSecret(ephemeralPriv, serverPubBytes);
-    const salt = new TextEncoder().encode(sessionId);
-    const info = new TextEncoder().encode("antz-transit-v1");
-    const sessionKey = hkdf(sha256, sharedSecret, salt, info, 32);
-    return Promise.resolve(sessionKey);
-  };
-}
-function bufToB642(buf) {
-  const bytes = new Uint8Array(buf);
-  let str = "";
-  bytes.forEach((b) => {
-    str += String.fromCharCode(b);
-  });
-  return btoa(str);
-}
-function b64ToBuf2(b64) {
-  const bin = atob(b64);
-  const buf = new Uint8Array(bin.length);
-  for (let i = 0; i < bin.length; i++) buf[i] = bin.charCodeAt(i);
-  return buf.buffer;
-}
-function uint8ToBase64(bytes) {
-  let str = "";
-  bytes.forEach((b) => {
-    str += String.fromCharCode(b);
-  });
-  return btoa(str);
-}
-function base64ToUint82(b64) {
-  const bin = atob(b64);
-  const buf = new Uint8Array(bin.length);
-  for (let i = 0; i < bin.length; i++) buf[i] = bin.charCodeAt(i);
-  return buf;
-}
-
-// src/socket/socket.ts
 var _socket = null;
 var _socketProxy = null;
 var _connectingPromise = null;
@@ -1340,17 +1463,35 @@ async function _doConnect(config, getToken) {
   };
   let boundDeriveSessionKey = null;
   if (config.transitEncryption) {
-    try {
-      const serverKeys = await fetchServerKeys(config.apiUrl);
-      if (!serverKeys.enabled) {
-        throw new Error(
-          "[AntzChat] Transit encryption mismatch: SDK has transitEncryption=true but server has TRANSIT_ENCRYPTION_ENABLED=false. Align the config on both sides."
-        );
+    const inFlight = getTransitHandshakePromise();
+    if (inFlight) await inFlight;
+    const existingSession = getTransitSession();
+    let httpsSession = null;
+    if (existingSession?.enabled && existingSession.sessionId) {
+      httpsSession = { sessionId: existingSession.sessionId, sessionKey: existingSession.sessionKey };
+    } else {
+      httpsSession = await createRestTransitSession(config.apiUrl);
+      if (httpsSession) {
+        const algo = globalThis.crypto?.subtle ? await detectTransitAlgo() : "x25519";
+        setTransitSession({ sessionKey: httpsSession.sessionKey, algo, sessionId: httpsSession.sessionId, enabled: true });
+      }
+    }
+    if (httpsSession) {
+      socketHandshakeAuth["transitSessionId"] = httpsSession.sessionId;
+      boundDeriveSessionKey = null;
+    } else {
+      try {
+        const serverKeys = await fetchServerKeys(config.apiUrl);
+        if (!serverKeys.enabled) {
+          throw new Error(
+            "[AntzChat] Transit encryption mismatch: SDK has transitEncryption=true but server has TRANSIT_ENCRYPTION_ENABLED=false. Align the config on both sides."
+          );
+        }
+        const algo = globalThis.crypto?.subtle ? await detectTransitAlgo() : "x25519";
+        boundDeriveSessionKey = await performHandshake(algo, serverKeys, socketHandshakeAuth);
+      } catch (err) {
+        throw err;
       }
-      const algo = globalThis.crypto?.subtle ? await detectTransitAlgo() : "x25519";
-      boundDeriveSessionKey = await performHandshake(algo, serverKeys, socketHandshakeAuth);
-    } catch (err) {
-      throw err;
     }
   } else {
     try {
@@ -1508,11 +1649,7 @@ async function drainSendQueue(conversationId) {
       entry.reject(new Error("[AntzChat] Message dropped: queued too long"));
       continue;
     }
-    try {
-      entry.resolve(await entry.run());
-    } catch (e) {
-      entry.reject(e);
-    }
+    entry.run().then(entry.resolve).catch(entry.reject);
   }
   sendQueues.delete(conversationId);
   sendQueueRunning.delete(conversationId);
@@ -1556,11 +1693,13 @@ async function withAck(event, payload) {
   }
   if (!socket) return Promise.reject(new Error(`[AntzChat] Socket not connected (event: ${event})`));
   return new Promise((resolve, reject) => {
-    const timer = setTimeout(() => reject(new Error(`Socket ack timeout: ${event}`)), ACK_TIMEOUT);
+    let timer;
     secureEmit(socket, event, payload, (response) => {
       clearTimeout(timer);
       resolve(response);
-    });
+    }).then(() => {
+      timer = setTimeout(() => reject(new Error(`Socket ack timeout: ${event}`)), ACK_TIMEOUT);
+    }).catch(reject);
   });
 }
 function fireAndForget(event, payload) {
@@ -1610,7 +1749,7 @@ var socketEmit = {
     const socket = tryGetSocket();
     if (!socket) return Promise.resolve([]);
     return new Promise((resolve, reject) => {
-      const timer = setTimeout(() => reject(new Error("get_online_users timeout")), ACK_TIMEOUT);
+      let timer;
       secureEmit(socket, "get_online_users", { userIds }, (response) => {
         clearTimeout(timer);
         if (response && typeof response === "object" && "onlineStatus" in response) {
@@ -1621,7 +1760,9 @@ var socketEmit = {
         } else {
           resolve([]);
         }
-      });
+      }).then(() => {
+        timer = setTimeout(() => reject(new Error("get_online_users timeout")), ACK_TIMEOUT);
+      }).catch(reject);
     });
   },
   getTypingUsers(conversationId) {
@@ -1689,18 +1830,27 @@ var AntzChatClient = class {
   connectSocket,
   conversationsApi,
   createAuthStore,
+  createRestTransitSession,
+  decryptPayload,
   devicesApi,
   disconnectSocket,
+  encryptPayload,
+  fetchServerKeys,
+  generateEphemeralKey,
   getApiClient,
   getAuthStore,
   getCompressionStrategy,
+  getSessionId,
+  getSessionKey,
   getSocket,
   getSocketStatus,
   initApiClient,
   initAuthStore,
+  isTransitEnvelope,
   messagesApi,
   normalizeConversation,
   onSocketStatus,
+  performHandshake,
   reconnectSocket,
   refreshSocketAuth,
   resetAuthStore,