@antzsoft/chat-core 1.2.4 → 1.2.6

package/dist/index.cjs

@@ -99,24 +99,40 @@ var init_chat_store = __esm({
 // src/index.ts
 var src_exports = {};
 __export(src_exports, {
+  AntzChatAuthError: () => AntzChatAuthError,
   AntzChatClient: () => AntzChatClient,
+  AntzChatError: () => AntzChatError,
+  AntzChatNetworkError: () => AntzChatNetworkError,
+  AntzChatPermissionError: () => AntzChatPermissionError,
+  AntzChatServerError: () => AntzChatServerError,
+  AntzChatValidationError: () => AntzChatValidationError,
   appConfigApi: () => appConfigApi,
   authApi: () => authApi,
   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,
+  normalizeAxiosError: () => normalizeAxiosError,
   normalizeConversation: () => normalizeConversation,
   onSocketStatus: () => onSocketStatus,
+  performHandshake: () => performHandshake,
   reconnectSocket: () => reconnectSocket,
   refreshSocketAuth: () => refreshSocketAuth,
   resetAuthStore: () => resetAuthStore,
@@ -256,7 +272,7 @@ async function compressFile(file, platformCompressFn, config) {
 }
 
 // src/api/client.ts
-var import_axios = __toESM(require("axios"), 1);
+var import_axios2 = __toESM(require("axios"), 1);
 
 // src/crypto/transit.ts
 function hasWebCrypto() {
@@ -391,6 +407,9 @@ function setTransitSession(session) {
   s.readyResolve?.();
   s.readyResolve = null;
 }
+function getTransitSession() {
+  return getState().session;
+}
 function clearTransitSession() {
   const s = getState();
   s.session = null;
@@ -407,19 +426,270 @@ 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/errors.ts
+var import_axios = require("axios");
+var AntzChatError = class extends Error {
+  constructor(code, message, retryable = false, context) {
+    super(message);
+    this.name = "AntzChatError";
+    this.code = code;
+    this.retryable = retryable;
+    this.context = context;
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+};
+var AntzChatAuthError = class extends AntzChatError {
+  constructor(message, code = "AUTH_FAILED", context) {
+    super(code, message, false, context);
+    this.name = "AntzChatAuthError";
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+};
+var AntzChatValidationError = class extends AntzChatError {
+  constructor(message, context) {
+    const msg = Array.isArray(message) ? message.join("; ") : message;
+    super("VALIDATION_ERROR", msg, false, context);
+    this.name = "AntzChatValidationError";
+    this.fields = Array.isArray(message) ? message : void 0;
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+};
+var AntzChatNetworkError = class extends AntzChatError {
+  constructor(message, code = "NETWORK_ERROR", context) {
+    super(code, message, true, context);
+    this.name = "AntzChatNetworkError";
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+};
+var AntzChatPermissionError = class extends AntzChatError {
+  constructor(message, context) {
+    super("PERMISSION_DENIED", message, false, context);
+    this.name = "AntzChatPermissionError";
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+};
+var AntzChatServerError = class extends AntzChatError {
+  constructor(message, httpStatus, context) {
+    super("SERVER_ERROR", message, true, context);
+    this.name = "AntzChatServerError";
+    this.httpStatus = httpStatus;
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+};
+function normalizeAxiosError(error) {
+  if (error instanceof AntzChatError) return error;
+  if ((0, import_axios.isAxiosError)(error)) {
+    const status = error.response?.status;
+    const body = error.response?.data;
+    const decryptionFailed = body != null && isTransitEnvelope(body);
+    const rawMessage = decryptionFailed ? void 0 : body?.message ?? void 0;
+    const message = (Array.isArray(rawMessage) ? rawMessage.join("; ") : rawMessage) || error.message || "Request failed";
+    const ctx = {
+      ...status != null && { httpStatus: status },
+      ...body?.path != null && { path: body.path },
+      ...body?.error != null && { serverError: body.error },
+      ...error.code != null && { axiosCode: error.code },
+      ...decryptionFailed && { decryptionFailed: true, note: "Transit decryption failed \u2014 server error body is an encrypted envelope" }
+    };
+    if (!error.response) {
+      return new AntzChatNetworkError(message || "Network error", "NETWORK_ERROR", ctx);
+    }
+    if (status === 401) {
+      const code = error.config?._retry ? "AUTH_FAILED" : "SESSION_EXPIRED";
+      return new AntzChatAuthError(message, code, ctx);
+    }
+    if (status === 403) return new AntzChatPermissionError(message, ctx);
+    if (status === 400 || status === 422) {
+      return new AntzChatValidationError(
+        Array.isArray(rawMessage) ? rawMessage : message,
+        ctx
+      );
+    }
+    if (status === 404) return new AntzChatServerError(message, 404, ctx);
+    if (status === 429) return new AntzChatNetworkError(message, "RATE_LIMITED", ctx);
+    if (status != null && status >= 500) return new AntzChatServerError(message, status, ctx);
+    return new AntzChatServerError(message, status, ctx);
+  }
+  const msg = error instanceof Error ? error.message : String(error);
+  return new AntzChatError("UNKNOWN_ERROR", msg, false);
+}
+
 // 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;
   _avatarSent = false;
-  const client = import_axios.default.create({
+  const client = import_axios2.default.create({
     baseURL: config.apiUrl,
     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}`;
@@ -483,7 +753,7 @@ function initApiClient(config, tokenStore) {
         const refreshToken = _tokenStore?.getRefreshToken();
         if (!refreshToken) {
           _tokenStore?.clearTokens();
-          return Promise.reject(error);
+          return Promise.reject(normalizeAxiosError(error));
         }
         if (isRefreshing) {
           return new Promise((resolve) => {
@@ -496,7 +766,7 @@ function initApiClient(config, tokenStore) {
         original._retry = true;
         isRefreshing = true;
         try {
-          const { data } = await import_axios.default.post(
+          const { data } = await import_axios2.default.post(
             `${_config.apiUrl}/auth/refresh`,
             { refreshToken }
           );
@@ -508,12 +778,12 @@ function initApiClient(config, tokenStore) {
           return client(original);
         } catch {
           _tokenStore?.clearTokens();
-          return Promise.reject(error);
+          return Promise.reject(normalizeAxiosError(error));
         } finally {
           isRefreshing = false;
         }
       }
-      return Promise.reject(error);
+      return Promise.reject(normalizeAxiosError(error));
     }
   );
   return client;
@@ -827,7 +1097,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) {
@@ -940,6 +1211,9 @@ var conversationsApi = {
   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`);
   }
 };
 
@@ -1191,122 +1465,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;
@@ -1403,28 +1561,52 @@ 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 AntzChatError(
+            "TRANSIT_MISMATCH",
+            "[AntzChat] Transit encryption mismatch: SDK has transitEncryption=true but server has TRANSIT_ENCRYPTION_ENABLED=false. Align the config on both sides.",
+            false,
+            { sdkEnabled: true, serverEnabled: false }
+          );
+        }
+        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 {
       const serverKeys = await fetchServerKeys(config.apiUrl);
       if (serverKeys.enabled) {
-        throw new Error(
-          "[AntzChat] Transit encryption mismatch: SDK has transitEncryption=false but server has TRANSIT_ENCRYPTION_ENABLED=true. Align the config on both sides."
+        throw new AntzChatError(
+          "TRANSIT_MISMATCH",
+          "[AntzChat] Transit encryption mismatch: SDK has transitEncryption=false but server has TRANSIT_ENCRYPTION_ENABLED=true. Align the config on both sides.",
+          false,
+          { sdkEnabled: false, serverEnabled: true }
         );
       }
     } catch (err) {
-      if (err.message?.startsWith("[AntzChat] Transit encryption mismatch")) throw err;
+      if (err?.code === "TRANSIT_MISMATCH") throw err;
     }
   }
   _socket = (0, import_socket.io)(`${config.socketOrigin}/chat`, {
@@ -1568,14 +1750,10 @@ async function drainSendQueue(conversationId) {
   while (queue.length > 0) {
     const entry = queue.shift();
     if (Date.now() - entry.enqueuedAt > QUEUE_ENTRY_TTL) {
-      entry.reject(new Error("[AntzChat] Message dropped: queued too long"));
+      entry.reject(new AntzChatNetworkError("Message dropped: queued too long", "MESSAGE_DROPPED"));
       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);
@@ -1585,7 +1763,7 @@ function queueSendMessage(payload) {
   if (!sendQueues.has(conversationId)) sendQueues.set(conversationId, []);
   const queue = sendQueues.get(conversationId);
   if (queue.length >= QUEUE_MAX_SIZE) {
-    return Promise.reject(new Error("[AntzChat] Send queue full: too many messages in flight"));
+    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() });
@@ -1596,7 +1774,7 @@ function waitForReconnect() {
   return new Promise((resolve, reject) => {
     const timer = setTimeout(() => {
       unsubscribe();
-      reject(new Error("[AntzChat] Socket reconnect timeout"));
+      reject(new AntzChatNetworkError("Socket reconnect timeout", "SOCKET_TIMEOUT"));
     }, RECONNECT_WAIT_TIMEOUT);
     const unsubscribe = onSocketStatus((status) => {
       if (status === "connected") {
@@ -1606,7 +1784,7 @@ function waitForReconnect() {
       } else if (status === "error") {
         clearTimeout(timer);
         unsubscribe();
-        reject(new Error("[AntzChat] Socket reconnect failed"));
+        reject(new AntzChatNetworkError("Socket reconnect failed", "SOCKET_NOT_CONNECTED"));
       }
     });
   });
@@ -1617,13 +1795,15 @@ async function withAck(event, payload) {
     await waitForReconnect();
     socket = tryGetSocket();
   }
-  if (!socket) return Promise.reject(new Error(`[AntzChat] Socket not connected (event: ${event})`));
+  if (!socket) return Promise.reject(new AntzChatNetworkError(`Socket not connected (event: ${event})`, "SOCKET_NOT_CONNECTED", { 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 AntzChatNetworkError(`Socket ack timeout: ${event}`, "SOCKET_TIMEOUT", { event })), ACK_TIMEOUT);
+    }).catch(reject);
   });
 }
 function fireAndForget(event, payload) {
@@ -1650,6 +1830,9 @@ var socketEmit = {
   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 });
   },
@@ -1673,7 +1856,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) {
@@ -1684,7 +1867,9 @@ var socketEmit = {
         } 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) {
@@ -1746,24 +1931,40 @@ var AntzChatClient = class {
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  AntzChatAuthError,
   AntzChatClient,
+  AntzChatError,
+  AntzChatNetworkError,
+  AntzChatPermissionError,
+  AntzChatServerError,
+  AntzChatValidationError,
   appConfigApi,
   authApi,
   connectSocket,
   conversationsApi,
   createAuthStore,
+  createRestTransitSession,
+  decryptPayload,
   devicesApi,
   disconnectSocket,
+  encryptPayload,
+  fetchServerKeys,
+  generateEphemeralKey,
   getApiClient,
   getAuthStore,
   getCompressionStrategy,
+  getSessionId,
+  getSessionKey,
   getSocket,
   getSocketStatus,
   initApiClient,
   initAuthStore,
+  isTransitEnvelope,
   messagesApi,
+  normalizeAxiosError,
   normalizeConversation,
   onSocketStatus,
+  performHandshake,
   reconnectSocket,
   refreshSocketAuth,
   resetAuthStore,