vanshi-sdk 1.0.6 → 1.2.26

package/dist/index.mjs

@@ -1,131 +1,1040 @@
-// src/plugins/socketio/client.ts
-import io from "socket.io-client";
+// src/sdk/storage/store.ts
+import Dexie from "dexie";
+
+// src/sdk/storage/sendState.ts
+function numericSendState(value) {
+  if (value === 0 || value === 1 || value === 2)
+    return value;
+  if (value === "0" || value === "1" || value === "2")
+    return Number(value);
+}
+function messageSendState(data, fallback = 1) {
+  const state = numericSendState(data.sentStatus) ?? numericSendState(data.sendState);
+  if (state !== void 0)
+    return state;
+  switch (data.sendState) {
+    case "pending":
+    case "sending":
+    case "unknown":
+      return 0;
+    case "sent":
+      return 1;
+    case "failed":
+      return 2;
+    default:
+      return fallback;
+  }
+}
+
+// src/sdk/message/replyIdentity.ts
+var INVALID_REPLY_RESPONSE = "INVALID_REPLY_RESPONSE";
+function isSelfReferencingReply(row) {
+  const id = row?.messageID;
+  const quoted = row?.repliedInfo;
+  return !!id && [quoted?.messageID, quoted?.messageInfo?.messageID].some((originalID) => originalID && String(originalID) === String(id));
+}
+function filterInvalidReplyMessages(data) {
+  if (!data || typeof data !== "object")
+    return data;
+  if (Array.isArray(data)) {
+    const filtered2 = data.map(filterInvalidReplyMessages).filter((row) => row !== void 0);
+    return filtered2.length === data.length && filtered2.every((row, index) => row === data[index]) ? data : filtered2;
+  }
+  if (isSelfReferencingReply(data))
+    return void 0;
+  let filtered = data;
+  for (const key of ["messageList", "infos", "message"]) {
+    if (filtered[key] && typeof filtered[key] === "object") {
+      const value = filterInvalidReplyMessages(filtered[key]);
+      if (value === void 0)
+        return void 0;
+      if (value !== filtered[key])
+        filtered = { ...filtered, [key]: value };
+    }
+  }
+  return filtered;
+}
+var MESSAGE_EVENTS = /* @__PURE__ */ new Set(["receivePeerMessage", "receiveGroupMessage", "messageSentStatusChanged", "messageEdited", "messageRevokeReceived", "messageDeleted", "messageReceiptChanged"]);
+function filterReplyPushArgs(event, args) {
+  if (!MESSAGE_EVENTS.has(event))
+    return args;
+  const filtered = args.map(filterInvalidReplyMessages);
+  return filtered.some((value, index) => value === void 0 && args[index] !== void 0) ? void 0 : filtered;
+}
+
+// src/sdk/storage/mediaPreview.ts
+var previews = /* @__PURE__ */ new Map();
+function preview(row, field) {
+  const blob = row[field];
+  if (typeof Blob === "undefined" || !(blob instanceof Blob) || typeof URL === "undefined" || typeof URL.createObjectURL !== "function")
+    return;
+  const key = `${row.localID}:${field}`;
+  const existing = previews.get(key);
+  if (existing?.version === row.updatedAt)
+    return existing.url;
+  if (existing)
+    URL.revokeObjectURL(existing.url);
+  const url = URL.createObjectURL(blob);
+  previews.set(key, { version: row.updatedAt, url });
+  return url;
+}
+function restoreMediaPreviews(row) {
+  if (!row.file && !row.thumbnailFile)
+    return row;
+  return {
+    ...row,
+    fileDownloadUrl: row.fileDownloadUrl || preview(row, "file"),
+    thumbnailDownloadUrl: row.thumbnailDownloadUrl || preview(row, "thumbnailFile") || (String(row.type) === "11" ? preview(row, "file") : void 0)
+  };
+}
+function clearMediaPreviews() {
+  for (const { url } of previews.values())
+    URL.revokeObjectURL(url);
+  previews.clear();
+}
+function invalidateMediaPreviews(localID) {
+  for (const field of ["file", "thumbnailFile"]) {
+    const key = `${localID}:${field}`;
+    const existing = previews.get(key);
+    if (existing)
+      URL.revokeObjectURL(existing.url);
+    previews.delete(key);
+  }
+}
+
+// src/sdk/storage/store.ts
+var listeners = /* @__PURE__ */ new Map();
+function onStorageEvent(event, handler) {
+  const set = listeners.get(event) || /* @__PURE__ */ new Set();
+  set.add(handler);
+  listeners.set(event, set);
+}
+function offStorageEvent(event, handler) {
+  if (handler)
+    listeners.get(event)?.delete(handler);
+  else
+    listeners.delete(event);
+}
+function emitStorageEvent(event, data) {
+  listeners.get(event)?.forEach((handler) => {
+    try {
+      const result = handler(data);
+      if (result && typeof result.then === "function")
+        Promise.resolve(result).catch((error) => console.error("[VanshiSdk] async storage event handler failed", error));
+    } catch (error) {
+      console.error("[VanshiSdk] storage event handler failed", error);
+    }
+  });
+}
+var STORAGE_EVENTS = /* @__PURE__ */ new Set(["localMessagesChanged", "localStorageError", "localSyncStateChanged"]);
+function migrateLegacySendState(row) {
+  const unconfirmed = ["pending", "sending", "unknown"].includes(row.sendState);
+  row.sendState = unconfirmed ? 0 : messageSendState(row);
+  if (unconfirmed) {
+    row.sentStatus = 0;
+    row._deliveryUnconfirmed = true;
+  } else if (row.sentStatus === void 0)
+    row.sentStatus = row.sendState;
+}
+var MessageDatabase = class extends Dexie {
+  constructor(name) {
+    super(name);
+    const schema = {
+      messages: "&localID, &[conversationKey+messageID], &[conversationKey+clientBizId], [conversationKey+timestamp], timestamp, sendState",
+      meta: "&key"
+    };
+    this.version(1).stores(schema);
+    this.version(2).stores(schema).upgrade(async (tx) => {
+      await tx.table("messages").toCollection().modify(migrateLegacySendState);
+      await tx.table("meta").toCollection().modify((row) => {
+        if (row.patch && ("sendState" in row.patch || "sentStatus" in row.patch))
+          migrateLegacySendState(row.patch);
+      });
+    });
+    this.version(3).stores({ ...schema, messages: `${schema.messages}, [conversationKey+sendState], [conversationKey+hasServerID], conversationKey` }).upgrade((tx) => tx.table("messages").toCollection().modify((row) => {
+      row.hasServerID = row.messageID ? 1 : 0;
+    }));
+  }
+};
+var active;
+var generation = 0;
+var lastError;
+var captureStorage = () => active;
+var isCurrentStorage = (ctx) => !!ctx && ctx === active && ctx.active;
+var conversationKey = (id, type) => JSON.stringify([String(type), String(id)]);
+var newLocalID = () => `local_${Date.now()}_${Math.random().toString(36).slice(2)}_${Math.random().toString(36).slice(2)}`;
+function reportStorageError(error, ctx) {
+  if (ctx && !isCurrentStorage(ctx))
+    return;
+  if (ctx)
+    ctx.failureCount = (ctx.failureCount || 0) + 1;
+  lastError = error instanceof Error ? error.message : String(error);
+  emitStorageEvent("localStorageError", { userId: ctx?.userId, message: lastError });
+}
+function closeLocalStorage() {
+  clearMediaPreviews();
+  generation++;
+  if (active) {
+    active.active = false;
+    active.channel?.close();
+    active.db.close();
+  }
+  active = void 0;
+  lastError = void 0;
+}
+function getLocalStorageStatus() {
+  return { enabled: !!active, userId: active?.userId, databaseName: active?.db.name, error: lastError };
+}
+async function openLocalStorage(userId, environment) {
+  closeLocalStorage();
+  const name = `vanshi_chat_${encodeURIComponent(environment)}_${encodeURIComponent(userId)}`;
+  const db = new MessageDatabase(name);
+  const ctx = { generation, epoch: newLocalID(), userId, db, active: true, ready: Promise.resolve() };
+  active = ctx;
+  ctx.ready = (async () => {
+    await db.open();
+    if (!isCurrentStorage(ctx)) {
+      db.close();
+      return;
+    }
+    await db.messages.where("sendState").equals(0).modify((row) => {
+      if (!row._deliveryUnconfirmed)
+        row.errorMessage = "Sending interrupted; delivery not confirmed";
+      row._deliveryUnconfirmed = true;
+      row.sentStatus = 0;
+      row.updatedAt = Date.now();
+    });
+    if (typeof BroadcastChannel !== "undefined" && isCurrentStorage(ctx)) {
+      ctx.channel = new BroadcastChannel(name);
+      ctx.channel.onmessage = ({ data }) => {
+        if (isCurrentStorage(ctx))
+          emitStorageEvent("localMessagesChanged", { ...data, userId });
+      };
+    }
+  })();
+  try {
+    await ctx.ready;
+  } catch (error) {
+    if (isCurrentStorage(ctx)) {
+      reportStorageError(error, ctx);
+      ctx.active = false;
+      db.close();
+      active = void 0;
+    }
+  }
+}
+async function storageWork(ctx, work) {
+  if (!isCurrentStorage(ctx))
+    return;
+  try {
+    await ctx.ready;
+    if (!isCurrentStorage(ctx))
+      return;
+    return await work(ctx);
+  } catch (error) {
+    reportStorageError(error, ctx);
+  }
+}
+function changed(ctx, key) {
+  if (!isCurrentStorage(ctx))
+    return;
+  const data = { userId: ctx.userId, conversationKey: key };
+  emitStorageEvent("localMessagesChanged", data);
+  ctx.channel?.postMessage(data);
+}
+function clean(input) {
+  const output = {};
+  for (const [key, value] of Object.entries(input)) {
+    if (value !== void 0 && typeof value !== "function" && key !== "localPreviewUrl") {
+      output[key] = value;
+    }
+  }
+  for (const key of ["fileDownloadUrl", "thumbnailDownloadUrl"]) {
+    if (typeof output[key] === "string" && output[key].startsWith("blob:"))
+      delete output[key];
+  }
+  return output;
+}
+function version(row) {
+  return Number(row.editedTime || row.editedAt || 0) || 0;
+}
+async function saveMessages(ctx, messages, fallback = {}, source = "server") {
+  const fromServer = source === "server" || source === "receive";
+  return storageWork(ctx, async (ctx2) => {
+    const released = /* @__PURE__ */ new Set();
+    await ctx2.db.transaction("rw", ctx2.db.messages, ctx2.db.meta, async () => {
+      for (const input of messages) {
+        if (!input || typeof input !== "object")
+          continue;
+        const data = clean({ ...fallback, ...input });
+        if (isSelfReferencingReply(data))
+          continue;
+        const id = data.conversationID ?? fallback.toConversationID;
+        const type = data.conversationType;
+        if (id === void 0 || type === void 0)
+          continue;
+        const key = conversationKey(id, type);
+        const messageID = data.messageID ? String(data.messageID) : void 0;
+        let clientBizId = data.clientBizId ? String(data.clientBizId) : void 0;
+        const byServer = messageID ? await ctx2.db.messages.where("[conversationKey+messageID]").equals([key, messageID]).first() : void 0;
+        let byClient = clientBizId ? await ctx2.db.messages.where("[conversationKey+clientBizId]").equals([key, clientBizId]).first() : void 0;
+        if (messageID && byClient?.messageID && byClient.messageID !== messageID) {
+          byClient = void 0;
+          clientBizId = void 0;
+          delete data.clientBizId;
+          delete data.localID;
+          delete data.localMessageID;
+        }
+        let previous = byClient && byServer && byClient.localID !== byServer.localID ? { ...byServer, ...byClient, deleted: byServer.deleted || byClient.deleted, revoked: byServer.revoked || byClient.revoked } : byClient || byServer;
+        if (!previous && data.localID) {
+          const candidate = await ctx2.db.messages.get(data.localID);
+          if (candidate?.conversationKey === key)
+            previous = candidate;
+        }
+        if (byServer && byClient && byServer.localID !== byClient.localID)
+          await ctx2.db.messages.delete(byServer.localID);
+        if (source === "receive" && data.direction == null) {
+          data.direction = data.senderUserID != null ? String(data.senderUserID) === ctx2.userId ? 0 : 1 : previous?.direction ?? 1;
+        }
+        const globalClear = await ctx2.db.meta.get("clear:all");
+        const cleared = await ctx2.db.meta.get(`clear:${key}`);
+        const timestamp = Number(data.timestamp ?? previous?.timestamp ?? (source === "patch" ? 0 : Date.now()));
+        const row = {
+          type: 0,
+          ...previous,
+          ...data,
+          localID: previous?.localID || data.localID || newLocalID(),
+          conversationKey: key,
+          conversationID: String(id),
+          conversationType: String(type),
+          hasServerID: messageID || previous?.messageID ? 1 : 0,
+          timestamp: Number.isFinite(timestamp) ? timestamp : Date.now(),
+          sendState: messageSendState(data, fromServer ? 1 : previous?.sendState ?? (source === "patch" ? 1 : 0)),
+          updatedAt: Date.now()
+        };
+        if (fromServer)
+          row.sentStatus = data.sentStatus ?? row.sendState;
+        if (fromServer)
+          delete row._deliveryUnconfirmed;
+        if (messageID) {
+          row.messageID = messageID;
+          const deferred = await ctx2.db.meta.get(`patch:${messageID}`);
+          if (deferred?.patch) {
+            const patch = { ...deferred.patch };
+            if (fromServer && data._fetchSequence !== void 0) {
+              const newer = (epoch, sequence2) => patch[epoch] === ctx2.epoch && patch[sequence2] > data._fetchSequence;
+              if (!newer("_sendEpoch", "_sendSequence")) {
+                for (const field of ["sentStatus", "sendState", "_sendEpoch", "_sendSequence", "_deliveryUnconfirmed"])
+                  delete patch[field];
+              }
+              if (!newer("_mutationEpoch", "_receiptSequence")) {
+                for (const field of ["receiptStatus", "_receiptSequence"])
+                  delete patch[field];
+              }
+              if (version(patch) <= version(data) && !newer("_mutationEpoch", "_contentSequence")) {
+                for (const field of ["message", "massage", "extendedData", "editedTime", "editedAt", "_contentSequence"])
+                  delete patch[field];
+              }
+            }
+            Object.assign(row, patch, { localID: row.localID, conversationKey: key, conversationID: String(id), conversationType: String(type) });
+            await ctx2.db.meta.delete(`patch:${messageID}`);
+          }
+        }
+        row.sendState = messageSendState(row, row.sendState);
+        if (clientBizId)
+          row.clientBizId = clientBizId;
+        if (!row.messageID)
+          delete row.messageID;
+        if (!row.clientBizId)
+          delete row.clientBizId;
+        if (previous?.sendState === 1 && source === "local") {
+          row.sendState = 1;
+          row.sentStatus = previous.sentStatus ?? 1;
+          delete row.errorCode;
+          delete row.errorMessage;
+        }
+        if (fromServer) {
+          delete row.errorCode;
+          delete row.errorMessage;
+        }
+        const staleContent = previous && (version(previous) > version(data) || // A replay of the creation event is not a new edit, even after reopening the DB.
+        source === "receive" && previous._contentSequence > 0 && version(data) <= version(previous) || fromServer && data._fetchSequence !== void 0 && previous._mutationEpoch === ctx2.epoch && previous._contentSequence > data._fetchSequence && version(data) <= version(previous) || fromServer && data._fetchedAt !== void 0 && previous._mutationAt > data._fetchedAt && version(data) <= version(previous));
+        if (staleContent) {
+          for (const field of ["message", "massage", "editedTime", "editedAt", "extendedData", "repliedInfo", "fileName", "fileSize", "fileDownloadUrl", "thumbnailDownloadUrl"]) {
+            if (field in previous)
+              row[field] = previous[field];
+            else
+              delete row[field];
+          }
+          row._contentSequence = previous._contentSequence;
+          row._mutationEpoch = previous._mutationEpoch;
+        }
+        if (previous && (source === "receive" && previous._receiptSequence > 0 || fromServer && data._fetchSequence !== void 0 && previous._mutationEpoch === ctx2.epoch && previous._receiptSequence > data._fetchSequence)) {
+          row.receiptStatus = previous.receiptStatus;
+          row._receiptSequence = previous._receiptSequence;
+        }
+        if (previous && fromServer && data._fetchSequence !== void 0 && previous._sendEpoch === ctx2.epoch && previous._sendSequence > data._fetchSequence) {
+          row.sendState = previous.sendState;
+          row.sentStatus = previous.sentStatus;
+          row._sendSequence = previous._sendSequence;
+          row._sendEpoch = previous._sendEpoch;
+          if (previous._deliveryUnconfirmed)
+            row._deliveryUnconfirmed = true;
+        }
+        if (row.sendState !== 0)
+          delete row._deliveryUnconfirmed;
+        if (row.sendState === 1) {
+          delete row.errorCode;
+          delete row.errorMessage;
+          if (fromServer) {
+            delete row.file;
+            delete row.thumbnailFile;
+          }
+        }
+        if (previous?.deleted || data.deleted || (globalClear || cleared) && row.timestamp <= Math.max(globalClear?.at || 0, cleared?.at || 0))
+          row.deleted = true;
+        if (row.deleted) {
+          row.message = "";
+          row.massage = "";
+          delete row.file;
+          delete row.thumbnailFile;
+          delete row.fileDownloadUrl;
+          delete row.thumbnailDownloadUrl;
+        }
+        if (row.revoked || previous?.revoked || data.revoked) {
+          row.revoked = true;
+          row.message = "";
+          row.massage = "";
+          delete row.file;
+          delete row.thumbnailFile;
+          delete row.fileDownloadUrl;
+          delete row.thumbnailDownloadUrl;
+        }
+        delete row._fetchedAt;
+        delete row._fetchSequence;
+        await ctx2.db.messages.put(row);
+        if (!row.file && !row.thumbnailFile)
+          released.add(row.localID);
+        else
+          released.delete(row.localID);
+      }
+    });
+    for (const localID of released)
+      invalidateMediaPreviews(localID);
+    changed(ctx2);
+  });
+}
+async function markSendError(ctx, clientBizId, fallback, error) {
+  const unknown = error?.code === INVALID_REPLY_RESPONSE || /timeout|disconnected|reconnect|socket not connected|socket not initialized/i.test(error?.message || String(error));
+  await saveMessages(ctx, [{
+    clientBizId,
+    sendState: unknown ? 0 : 2,
+    _deliveryUnconfirmed: unknown,
+    sentStatus: unknown ? 0 : 2,
+    errorCode: error?.code,
+    errorMessage: error?.message || String(error)
+  }], fallback, "local");
+}
+async function deleteStoredMessages(ctx, id, type, ids) {
+  if (id === void 0 !== (type === void 0))
+    throw new Error("Both conversationID and conversationType are required");
+  await storageWork(ctx, async (ctx2) => {
+    const released = [];
+    const key = id !== void 0 && type !== void 0 ? conversationKey(id, type) : void 0;
+    await ctx2.db.transaction("rw", ctx2.db.messages, ctx2.db.meta, async () => {
+      const rows = key ? await ctx2.db.messages.where("[conversationKey+timestamp]").between([key, Dexie.minKey], [key, Dexie.maxKey]).toArray() : await ctx2.db.messages.toArray();
+      const selected = ids ? rows.filter((row) => ids.includes(row.messageID || "") || ids.includes(row.localID)) : rows;
+      for (const row of selected) {
+        const removed = { ...row, deleted: true, message: "", massage: "", updatedAt: Date.now() };
+        delete removed.file;
+        delete removed.thumbnailFile;
+        delete removed.fileDownloadUrl;
+        delete removed.thumbnailDownloadUrl;
+        await ctx2.db.messages.put(removed);
+        released.push(row.localID);
+      }
+      if (!ids)
+        await ctx2.db.meta.put({ key: key ? `clear:${key}` : "clear:all", at: Date.now() });
+      if (ids && key)
+        for (const messageID of ids) {
+          if (!selected.some((row) => row.messageID === messageID))
+            await ctx2.db.messages.put({ localID: newLocalID(), conversationID: String(id), conversationType: String(type), conversationKey: key, messageID, hasServerID: 1, type: 0, timestamp: 0, sendState: 1, sentStatus: 1, deleted: true, updatedAt: Date.now() });
+        }
+    });
+    for (const localID of released)
+      invalidateMediaPreviews(localID);
+    changed(ctx2, key);
+  });
+}
+async function queryStoredMessages(query, failedOnly = false) {
+  const ctx = active;
+  if (!ctx)
+    throw new Error("Local message storage is not enabled; login with userId first");
+  await ctx.ready;
+  await ctx.pending;
+  if (!isCurrentStorage(ctx))
+    throw new Error("Local storage account changed");
+  const count = Math.min(500, Math.max(1, Math.floor(query.count || 30)));
+  const key = query.conversationID !== void 0 && query.conversationType !== void 0 ? conversationKey(query.conversationID, query.conversationType) : void 0;
+  let collection = key ? ctx.db.messages.where("[conversationKey+timestamp]").between([key, Dexie.minKey], [key, Dexie.maxKey]) : ctx.db.messages.orderBy("timestamp");
+  if (query.order !== "asc")
+    collection = collection.reverse();
+  const rows = await collection.filter((row) => {
+    if (row.deleted)
+      return false;
+    if (failedOnly && row.sendState !== 2 && !(row.sendState === 0 && row._deliveryUnconfirmed))
+      return false;
+    if (query.conversationID !== void 0 && row.conversationID !== String(query.conversationID))
+      return false;
+    if (query.conversationType !== void 0 && row.conversationType !== String(query.conversationType))
+      return false;
+    if (query.sendStates?.length && !query.sendStates.includes(row.sendState))
+      return false;
+    if (query.startTime !== void 0 && row.timestamp < query.startTime)
+      return false;
+    if (query.endTime !== void 0 && row.timestamp > query.endTime)
+      return false;
+    if (query.messageTypes?.length && !query.messageTypes.some((type) => String(type) === String(row.type)))
+      return false;
+    if (query.senderUserIDs?.length && !query.senderUserIDs.includes(row.senderUserID))
+      return false;
+    if (query.keywords?.some((word) => !String(row.message ?? row.massage ?? "").toLocaleLowerCase().includes(word.toLocaleLowerCase())))
+      return false;
+    if (query.before) {
+      const cmp = row.timestamp - query.before.timestamp || (row.localID < query.before.localID ? -1 : row.localID > query.before.localID ? 1 : 0);
+      if (query.order === "asc" ? cmp <= 0 : cmp >= 0)
+        return false;
+    }
+    return true;
+  }).limit(count + 1).toArray();
+  rows.sort((a, b) => (query.order === "asc" ? 1 : -1) * (a.timestamp - b.timestamp || (a.localID < b.localID ? -1 : a.localID > b.localID ? 1 : 0)));
+  if (!isCurrentStorage(ctx))
+    throw new Error("Local storage account changed");
+  const messageList = rows.slice(0, count);
+  const last = messageList[messageList.length - 1];
+  return { messageList, hasMore: rows.length > count, nextCursor: last ? { timestamp: last.timestamp, localID: last.localID } : void 0 };
+}
+function queryLocalMessages(query = {}) {
+  return queryStoredMessages(query);
+}
+function queryFailedMessages(query = {}) {
+  return queryStoredMessages({ ...query, sendStates: void 0 }, true);
+}
+async function clearLocalMessages(query = {}) {
+  if (!active)
+    throw new Error("Local message storage is not enabled");
+  await deleteStoredMessages(active, query.conversationID, query.conversationType);
+}
+
+// src/sdk/sessionGuard.ts
+var generation2 = 0;
+var authenticating = false;
+var listeners2 = /* @__PURE__ */ new Set();
+var authenticationWaiters = /* @__PURE__ */ new Set();
+function releaseAuthenticationWaiters() {
+  for (const resolve of authenticationWaiters)
+    resolve();
+  authenticationWaiters.clear();
+}
+var captureSession = () => generation2;
+var isCurrentSession = (value) => value === generation2;
+var isAuthenticating = () => authenticating;
+function invalidateSession() {
+  generation2++;
+  authenticating = false;
+  releaseAuthenticationWaiters();
+  for (const listener of listeners2)
+    listener();
+  return generation2;
+}
+function beginAuthentication() {
+  authenticating = true;
+  return generation2;
+}
+function finishAuthentication(value) {
+  if (isCurrentSession(value)) {
+    authenticating = false;
+    releaseAuthenticationWaiters();
+  }
+}
+async function waitForAuthentication(value) {
+  if (authenticating && isCurrentSession(value))
+    await new Promise((resolve) => authenticationWaiters.add(resolve));
+  assertCurrentSession(value);
+}
+function onSessionInvalidated(listener) {
+  listeners2.add(listener);
+  return () => {
+    listeners2.delete(listener);
+  };
+}
+function assertCurrentSession(value) {
+  if (!isCurrentSession(value))
+    throw new Error("SDK session changed; operation canceled");
+}
+
+// src/sdk/storage/bridge.ts
+function extractMessages(data) {
+  if (!data)
+    return [];
+  if (Array.isArray(data))
+    return data.flatMap((item) => extractMessages(item));
+  if (typeof data !== "object")
+    return [];
+  if (Array.isArray(data.messageList))
+    return data.messageList;
+  if (Array.isArray(data.infos))
+    return data.infos.flatMap((info) => extractMessages(info));
+  if (data.message && typeof data.message === "object")
+    return [data.message];
+  if (data.messageID || data.clientBizId)
+    return [data];
+  return [];
+}
+function makeClientBizId() {
+  return `cbiz_${newLocalID()}`;
+}
+function outgoingFallback(payload, ctx) {
+  return {
+    conversationID: payload.toConversationID ?? payload.conversationID ?? payload.toOriginalMessage?.conversationID ?? payload.message?.conversationID,
+    conversationType: payload.conversationType ?? payload.toOriginalMessage?.conversationType ?? payload.message?.conversationType,
+    senderUserID: ctx?.userId,
+    direction: 0
+  };
+}
+async function persistOutgoing(ctx, payload) {
+  await saveMessages(ctx, [{ ...payload.message, sendState: 0, sentStatus: 0, _deliveryUnconfirmed: false }], outgoingFallback(payload, ctx), "local");
+}
+async function cacheApiResult(ctx, method, payload, data, startedAt = Date.now(), fetchSequence = ctx?.mutationSequence || 0) {
+  const fallback = { ...outgoingFallback(payload || {}, ctx), _fetchedAt: startedAt, _fetchSequence: fetchSequence };
+  if (!/^(sendMessage|sendMediaMessage|replyMessage)$/.test(method)) {
+    delete fallback.senderUserID;
+    delete fallback.direction;
+  }
+  if (/^(sendMessage|sendMediaMessage|replyMessage)$/.test(method)) {
+    const confirmation = { _sendSequence: nextMutation(ctx), _sendEpoch: ctx?.epoch };
+    const messages = extractMessages(data).map((row) => {
+      const sendState = messageSendState(row);
+      const normalized = { ...row, ...confirmation, sentStatus: row.sentStatus ?? sendState, sendState, clientBizId: row.clientBizId || payload.message?.clientBizId };
+      return normalized;
+    });
+    await saveMessages(ctx, messages.length ? messages : [{ ...payload.message, ...confirmation, sentStatus: 1, sendState: 1 }], fallback);
+  } else if (/^(queryHistoryMessage|queryMessages|queryMessageRepliedList|queryCombineMessageDetail|editMessage)$/.test(method)) {
+    await saveMessages(ctx, extractMessages(data).map((row) => ({
+      ...row,
+      _sendSequence: fetchSequence,
+      _sendEpoch: ctx?.epoch,
+      ...method === "editMessage" ? { _mutationAt: Date.now(), _contentSequence: nextMutation(ctx), _mutationEpoch: ctx?.epoch } : {}
+    })), { ...fallback, conversationID: data?.conversationID ?? fallback.conversationID, conversationType: data?.conversationType ?? fallback.conversationType });
+  } else if (method === "queryMessageReceiptsInfo") {
+    for (const row of extractMessages(data))
+      await applyMessagePatch(ctx, row, fallback);
+  } else if (method === "sendMessageReceiptsRead") {
+    for (const messageID of payload.messageList || [])
+      await applyMessagePatch(ctx, { messageID, locallyRead: true }, fallback);
+  } else if (method === "deleteMessages") {
+    await deleteStoredMessages(ctx, payload.conversationID, payload.conversationType, payload.messageList?.map((m) => m.messageID));
+  } else if (method === "deleteAllMessage") {
+    await deleteStoredMessages(ctx, payload.conversationID, payload.conversationType);
+  } else if (method === "deleteAllConversationMessages") {
+    await deleteStoredMessages(ctx);
+  } else if (method === "revokeMessage") {
+    await applyMessagePatch(ctx, { ...payload.message, revoked: true }, {});
+  }
+}
+function nextMutation(ctx) {
+  if (!ctx)
+    return 0;
+  return ctx.mutationSequence = (ctx.mutationSequence || 0) + 1;
+}
+function mergeDeferred(previous = {}, patch) {
+  const merged = { ...previous, ...patch };
+  if (previous.revoked || patch.revoked)
+    merged.revoked = true;
+  if (previous.deleted || patch.deleted)
+    merged.deleted = true;
+  const oldVersion = Number(previous.editedTime || previous.editedAt || 0);
+  const newVersion = Number(patch.editedTime || patch.editedAt || 0);
+  if (oldVersion > newVersion && newVersion > 0) {
+    for (const field of ["message", "massage", "editedTime", "editedAt", "extendedData"]) {
+      if (field in previous)
+        merged[field] = previous[field];
+      else
+        delete merged[field];
+    }
+  }
+  return merged;
+}
+async function applyMessagePatch(ctx, patch, fallback) {
+  if (!patch?.messageID && !patch?.clientBizId)
+    return;
+  patch = { ...patch, _mutationAt: Date.now(), _mutationEpoch: ctx?.epoch };
+  const sequence2 = nextMutation(ctx);
+  if ("message" in patch || "massage" in patch || "editedTime" in patch || "extendedData" in patch)
+    patch._contentSequence = sequence2;
+  if ("receiptStatus" in patch)
+    patch._receiptSequence = sequence2;
+  if ("sentStatus" in patch || "sendState" in patch) {
+    patch._sendSequence = sequence2;
+    patch._sendEpoch = ctx?.epoch;
+  }
+  if ((patch.conversationID ?? fallback.conversationID) !== void 0 && (patch.conversationType ?? fallback.conversationType) !== void 0) {
+    await saveMessages(ctx, [{ ...patch, _mutationAt: Date.now() }], fallback, "patch");
+    return;
+  }
+  await storageWork(ctx, async (ctx2) => {
+    const rows = await ctx2.db.messages.filter((row) => patch.messageID ? row.messageID === String(patch.messageID) : row.clientBizId === String(patch.clientBizId)).toArray();
+    if (!rows.length && patch.messageID) {
+      await ctx2.db.transaction("rw", ctx2.db.meta, async () => {
+        const key = `patch:${String(patch.messageID)}`;
+        const prior = await ctx2.db.meta.get(key);
+        await ctx2.db.meta.put({ key, patch: mergeDeferred(prior?.patch, patch) });
+      });
+    }
+    for (const row of rows)
+      await saveMessages(ctx2, [patch], { conversationID: row.conversationID, conversationType: row.conversationType }, "patch");
+  });
+}
+var PERSISTED_PUSH_EVENTS = /* @__PURE__ */ new Set(["receivePeerMessage", "receiveGroupMessage", "messageSentStatusChanged", "messageDeleted", "messageRevokeReceived", "messageEdited", "messageReceiptChanged"]);
+var loginBuffer;
+onSessionInvalidated(() => {
+  loginBuffer = void 0;
+});
+function beginLoginMessageBuffer(session) {
+  loginBuffer = { session, events: [] };
+}
+function discardLoginMessageBuffer(session) {
+  if (loginBuffer?.session === session)
+    loginBuffer = void 0;
+}
+async function flushLoginMessageBuffer(session) {
+  const buffer = loginBuffer;
+  if (buffer?.session !== session || !isCurrentSession(session))
+    return;
+  loginBuffer = void 0;
+  for (const { event, args } of buffer.events)
+    observeMessagePush(event, args);
+  await captureStorage()?.pending;
+}
+function snapshotPushData(value) {
+  if (typeof structuredClone === "function") {
+    try {
+      return structuredClone(value);
+    } catch {
+    }
+  }
+  if (Array.isArray(value))
+    return value.map(snapshotPushData);
+  if (value && Object.prototype.toString.call(value) === "[object Object]") {
+    return Object.fromEntries(Object.entries(value).filter(([, item]) => typeof item !== "function").map(([key, item]) => [key, snapshotPushData(item)]));
+  }
+  if (ArrayBuffer.isView(value)) {
+    const bytes = value.buffer.slice(value.byteOffset, value.byteOffset + value.byteLength);
+    return new value.constructor(bytes);
+  }
+  if (Object.prototype.toString.call(value) === "[object ArrayBuffer]")
+    return value.slice(0);
+  if (Object.prototype.toString.call(value) === "[object Date]")
+    return new Date(value.getTime());
+  return value;
+}
+function observeMessagePush(event, args) {
+  if (!PERSISTED_PUSH_EVENTS.has(event))
+    return;
+  if (loginBuffer && isCurrentSession(loginBuffer.session)) {
+    loginBuffer.events.push({ event, args: snapshotPushData(args.filter((arg) => typeof arg !== "function")) });
+    return;
+  }
+  const filtered = filterReplyPushArgs(event, args);
+  if (!filtered)
+    return;
+  args = filtered;
+  const ctx = captureStorage();
+  if (!ctx)
+    return;
+  const received = event === "receivePeerMessage" || event === "receiveGroupMessage";
+  const payload = args.find((arg) => arg && typeof arg === "object" && !Array.isArray(arg) && (arg.messageList || arg.message || arg.infos || arg.conversationID || arg.fromConversationID)) || args[0];
+  const data = snapshotPushData(payload);
+  const run = async () => {
+    const fallback = {
+      _fetchedAt: Date.now(),
+      _fetchSequence: ctx.mutationSequence || 0,
+      conversationID: data?.conversationID ?? data?.fromConversationID,
+      conversationType: data?.conversationType ?? (event === "receivePeerMessage" ? 0 : event === "receiveGroupMessage" ? 2 : void 0)
+    };
+    if (event === "messageDeleted") {
+      if (data?.isDeleteConversationAllMessage && fallback.conversationID !== void 0 && fallback.conversationType === void 0) {
+        for (const type of [0, 1, 2, 3])
+          await deleteStoredMessages(ctx, fallback.conversationID, type);
+        return;
+      }
+      if (fallback.conversationID === void 0 || fallback.conversationType === void 0) {
+        for (const message of extractMessages(data))
+          await applyMessagePatch(ctx, { ...message, deleted: true }, fallback);
+        return;
+      }
+      await deleteStoredMessages(
+        ctx,
+        fallback.conversationID,
+        fallback.conversationType,
+        data?.isDeleteConversationAllMessage ? void 0 : (data?.messageList || []).map((row) => row.messageID)
+      );
+      return;
+    }
+    const messages = extractMessages(data);
+    if (received) {
+      await saveMessages(ctx, messages.filter((message) => message && typeof message === "object" && (message.messageID || message.clientBizId)).map((message) => ({
+        ...message,
+        sentStatus: message.sentStatus ?? messageSendState(message),
+        sendState: messageSendState(message),
+        _sendSequence: nextMutation(ctx),
+        _sendEpoch: ctx.epoch
+      })), fallback, "receive");
+    } else {
+      for (const message of messages) {
+        const patch = { ...message };
+        if (event === "messageRevokeReceived")
+          patch.revoked = true;
+        if (event === "messageSentStatusChanged") {
+          const info = data?.infos?.find((item) => item.message?.messageID === message.messageID);
+          const status = info?.status ?? message.sentStatus;
+          if (status !== void 0) {
+            patch.sentStatus = status;
+            patch.sendState = Number(status) === 1 ? 1 : Number(status) === 2 ? 2 : 0;
+          }
+        }
+        await applyMessagePatch(ctx, patch, fallback);
+      }
+    }
+  };
+  ctx.pending = (ctx.pending || Promise.resolve()).then(run).catch((error) => {
+    console.error("[VanshiSdk] message persistence failed", error);
+  });
+}
 
 // src/sdk/runtime.ts
 var SDK_TOKEN_KEY = "VanshiSdk_Token";
 var SDK_LOGIN_KEY = "VanshiSdk_isLogin";
+var inMemorySdkToken = "";
+var sessionTokenInitialized = false;
+var inMemorySdkUserID = "";
+function setSdkUserID(userID) {
+  inMemorySdkUserID = userID == null ? "" : String(userID).trim();
+}
+function getSdkUserID() {
+  return inMemorySdkUserID;
+}
 function getBrowserStorage() {
-  if (typeof localStorage === "undefined") {
+  try {
+    if (typeof localStorage === "undefined") {
+      return void 0;
+    }
+    return localStorage;
+  } catch {
     return void 0;
   }
-  return localStorage;
+}
+function getSdkErrorMessage(result) {
+  return result.message || `SDK request failed${result.code !== void 0 ? `: ${String(result.code)}` : ""}`;
 }
 var SdkRuntimeError = class extends Error {
   constructor(result) {
-    super(result.message || `SDK request failed${result.code !== void 0 ? `: ${String(result.code)}` : ""}`);
+    super(getSdkErrorMessage(result));
     this.name = "SdkRuntimeError";
+    this.success = false;
     this.code = result.code;
     this.data = result.data;
     this.raw = result.raw;
-    this.parsed = result.parsed;
+    Object.defineProperties(this, {
+      name: { value: this.name, enumerable: true },
+      message: { value: this.message, enumerable: true },
+      success: { value: this.success, enumerable: true },
+      code: { value: this.code, enumerable: true },
+      data: { value: this.data, enumerable: true },
+      raw: { value: this.raw, enumerable: true }
+    });
+  }
+  toObject() {
+    return {
+      name: "SdkRuntimeError",
+      success: false,
+      code: this.code,
+      message: this.message,
+      data: this.data,
+      raw: this.raw
+    };
+  }
+  toJSON() {
+    return this.toObject();
   }
 };
-function parseJsonSafely(value) {
-  if (value == null) {
-    return void 0;
+function isRecord(value) {
+  return Boolean(value) && typeof value === "object";
+}
+function getErrorField(error, field) {
+  return isRecord(error) ? error[field] : void 0;
+}
+function getSdkErrorCode(error) {
+  const code = getErrorField(error, "code");
+  return typeof code === "string" || typeof code === "number" ? code : void 0;
+}
+function getSdkErrorMessageFromUnknown(error, fallback = "SDK request failed") {
+  const message = getErrorField(error, "message");
+  if (typeof message === "string" && message) {
+    return message;
   }
-  if (typeof value !== "string") {
-    return value;
+  if (error instanceof Error && error.message) {
+    return error.message;
   }
-  try {
-    return JSON.parse(value);
-  } catch {
-    return void 0;
+  if (typeof error === "string" && error) {
+    return error;
   }
+  return fallback;
 }
-function isSuccessCode(code) {
-  return code === 0 || code === "0" || code === true;
+function isSdkRuntimeErrorObject(value) {
+  return isRecord(value) && value.name === "SdkRuntimeError" && value.success === false && typeof value.message === "string";
 }
-function toSdkEnvelope(response) {
-  if (response && typeof response === "object") {
-    return response;
+function isAuthFailureCode(code) {
+  return code === 3 || code === "3" || code === 4 || code === "4" || code === 303 || code === "303";
+}
+function hasSdkCode(value) {
+  return isRecord(value) && "code" in value;
+}
+function logSdkRuntimeError(result) {
+  if (typeof console === "undefined" || typeof console.error !== "function") {
+    return;
+  }
+  console.error("[VanshiSdk] API request failed", {
+    code: result.code,
+    message: result.message,
+    data: result.data,
+    raw: result.raw
+  });
+}
+function throwSdkRuntimeError(result) {
+  const detailedResult = {
+    ...result,
+    success: false
+  };
+  logSdkRuntimeError(detailedResult);
+  if (isAuthFailureCode(detailedResult.code)) {
+    clearSdkSession();
+  }
+  throw new SdkRuntimeError(detailedResult).toObject();
+}
+function throwSdkTransportError(error, fallbackMessage = "SDK request failed") {
+  if (isSdkRuntimeErrorObject(error)) {
+    throw error;
   }
-  return {};
+  throwSdkRuntimeError({
+    code: getSdkErrorCode(error),
+    message: getSdkErrorMessageFromUnknown(error, fallbackMessage),
+    raw: error
+  });
+}
+function isSuccessCode(code) {
+  return code === 0 || code === "0" || code === true;
 }
 function unwrapSdkData(response) {
+  const result = assertSdkSuccess(response);
+  return result.data;
+}
+function assertSdkSuccess(response) {
   const result = unwrapSdkDetailedData(response);
   if (!result.success) {
-    throw new SdkRuntimeError(result);
+    throwSdkRuntimeError(result);
   }
-  return result.data;
+  return result;
 }
 function unwrapSdkResponse(response) {
+  const result = assertSdkSuccess(response);
   const envelope = toSdkEnvelope(response);
-  const parsed = parseJsonSafely(envelope.data);
-  if (parsed && typeof parsed === "object" && "code" in parsed) {
-    return parsed;
-  }
   return {
     code: envelope.code,
     message: envelope.message,
-    data: parsed !== void 0 ? parsed : envelope.data
+    data: result.data
   };
 }
 function unwrapSdkDetailedData(response) {
   const envelope = toSdkEnvelope(response);
-  const parsed = parseJsonSafely(envelope.data);
-  if (parsed && typeof parsed === "object" && "code" in parsed) {
-    const success = isSuccessCode(parsed.code);
-    return {
-      success,
-      code: parsed.code,
-      message: parsed.message || envelope.message,
-      data: parsed.data,
-      raw: response,
-      parsed
-    };
-  }
   if (envelope.code !== void 0 || envelope.message !== void 0) {
     return {
       success: isSuccessCode(envelope.code),
       code: envelope.code,
       message: envelope.message,
-      data: parsed !== void 0 ? parsed : envelope.data,
-      raw: response,
-      parsed
+      data: envelope.data,
+      raw: response
     };
   }
   return {
     success: true,
-    data: parsed !== void 0 ? parsed : envelope.data,
-    raw: response,
-    parsed
+    data: envelope.data,
+    raw: response
   };
 }
+function toSdkEnvelope(response) {
+  return isRecord(response) ? response : {};
+}
 function getStoredToken() {
-  return getBrowserStorage()?.getItem(SDK_TOKEN_KEY) || "";
+  const memoryToken = inMemorySdkToken;
+  try {
+    return sessionTokenInitialized ? memoryToken : getBrowserStorage()?.getItem(SDK_TOKEN_KEY) || "";
+  } catch {
+    return memoryToken;
+  }
 }
 function setSdkSession(token) {
-  const storage = getBrowserStorage();
-  if (!storage) {
-    return;
+  inMemorySdkToken = token;
+  sessionTokenInitialized = true;
+  try {
+    const storage = getBrowserStorage();
+    if (!storage) {
+      return;
+    }
+    storage.setItem(SDK_TOKEN_KEY, token);
+    storage.setItem(SDK_LOGIN_KEY, "true");
+  } catch {
   }
-  storage.setItem(SDK_TOKEN_KEY, token);
-  storage.setItem(SDK_LOGIN_KEY, "true");
 }
 function clearSdkSession() {
-  const storage = getBrowserStorage();
-  if (!storage) {
-    return;
+  const ownedToken = inMemorySdkToken;
+  const hadOwnedSession = sessionTokenInitialized;
+  sessionTokenInitialized = true;
+  invalidateSession();
+  closeLocalStorage();
+  inMemorySdkToken = "";
+  inMemorySdkUserID = "";
+  try {
+    const storage = getBrowserStorage();
+    if (!storage) {
+      return;
+    }
+    if (!hadOwnedSession || ownedToken && storage.getItem(SDK_TOKEN_KEY) === ownedToken) {
+      storage.removeItem(SDK_TOKEN_KEY);
+      storage.removeItem(SDK_LOGIN_KEY);
+    }
+  } catch {
   }
-  storage.removeItem(SDK_TOKEN_KEY);
-  storage.removeItem(SDK_LOGIN_KEY);
 }
 function getSocketUrl() {
   const globalUrl = typeof window !== "undefined" ? window.__VANSHI_SOCKET_URL : void 0;
-  return globalUrl || "wss://ws-vanshi-chat-sdk.xchatclub.com";
+  return globalUrl || "wss://ws-baobaoshibu.bnrfdv.com";
 }
 function getUploadUrl() {
   const globalHttpUrl = typeof window !== "undefined" ? window.__VANSHI_HTTP_URL : void 0;
-  return globalHttpUrl || "https://vanshi-chat-api.xchatclub.com/api/files/sdkUpload";
+  return globalHttpUrl || "https://baobaoshibu.bnrfdv.com/api/files/sdkUpload";
 }
 
+// src/plugins/socketio/client.ts
+import io from "socket.io-client";
+
 // src/sdk/session.ts
 var reconnectLoginHandler = null;
 function registerReconnectLoginHandler(handler) {
   reconnectLoginHandler = handler;
 }
 async function restoreSessionAfterReconnect() {
+  const session = captureSession();
   if (!reconnectLoginHandler) {
     return false;
   }
@@ -134,7 +1043,8 @@ async function restoreSessionAfterReconnect() {
     return false;
   }
   try {
-    return await reconnectLoginHandler(token);
+    const success = await reconnectLoginHandler(token);
+    return isCurrentSession(session) && success;
   } catch {
     return false;
   }
@@ -143,7 +1053,99 @@ function clearSessionState() {
   clearSdkSession();
 }
 
+// src/constants/eventListenerOn.ts
+var ZIMConnectionState = /* @__PURE__ */ ((ZIMConnectionState2) => {
+  ZIMConnectionState2[ZIMConnectionState2["Disconnected"] = 0] = "Disconnected";
+  ZIMConnectionState2[ZIMConnectionState2["Connecting"] = 1] = "Connecting";
+  ZIMConnectionState2[ZIMConnectionState2["Connected"] = 2] = "Connected";
+  ZIMConnectionState2[ZIMConnectionState2["Reconnecting"] = 3] = "Reconnecting";
+  return ZIMConnectionState2;
+})(ZIMConnectionState || {});
+var ZIMConnectionEvent = /* @__PURE__ */ ((ZIMConnectionEvent2) => {
+  ZIMConnectionEvent2[ZIMConnectionEvent2["Success"] = 0] = "Success";
+  ZIMConnectionEvent2[ZIMConnectionEvent2["ActiveLogin"] = 1] = "ActiveLogin";
+  ZIMConnectionEvent2[ZIMConnectionEvent2["LoginTimeout"] = 2] = "LoginTimeout";
+  ZIMConnectionEvent2[ZIMConnectionEvent2["LoginInterrupted"] = 3] = "LoginInterrupted";
+  ZIMConnectionEvent2[ZIMConnectionEvent2["KickedOut"] = 4] = "KickedOut";
+  ZIMConnectionEvent2[ZIMConnectionEvent2["TokenExpired"] = 5] = "TokenExpired";
+  return ZIMConnectionEvent2;
+})(ZIMConnectionEvent || {});
+var ZIMEventEnum = /* @__PURE__ */ ((ZIMEventEnum2) => {
+  ZIMEventEnum2["connect"] = "connect";
+  ZIMEventEnum2["disconnect"] = "disconnect";
+  ZIMEventEnum2["connectError"] = "connect_error";
+  ZIMEventEnum2["connectionStateChanged"] = "connectionStateChanged";
+  ZIMEventEnum2["reconnect"] = "reconnect";
+  ZIMEventEnum2["reconnectAttempt"] = "reconnect_attempt";
+  ZIMEventEnum2["reconnectError"] = "reconnect_error";
+  ZIMEventEnum2["reconnectFailed"] = "reconnect_failed";
+  ZIMEventEnum2["reconnectLoginSuccess"] = "reconnectLoginSuccess";
+  ZIMEventEnum2["reconnectLoginFailed"] = "reconnectLoginFailed";
+  ZIMEventEnum2["receiveGroupMessage"] = "receiveGroupMessage";
+  ZIMEventEnum2["receivePeerMessage"] = "receivePeerMessage";
+  ZIMEventEnum2["sendSingLing"] = "sendSingLing";
+  ZIMEventEnum2["conversationChanged"] = "conversationChanged";
+  ZIMEventEnum2["messageSentStatusChanged"] = "messageSentStatusChanged";
+  ZIMEventEnum2["messageDeleted"] = "messageDeleted";
+  ZIMEventEnum2["messageRevokeReceived"] = "messageRevokeReceived";
+  ZIMEventEnum2["messageEdited"] = "messageEdited";
+  ZIMEventEnum2["messageReceiptChanged"] = "messageReceiptChanged";
+  ZIMEventEnum2["tokenWillExpire"] = "tokenWillExpire";
+  ZIMEventEnum2["error"] = "error";
+  ZIMEventEnum2["userInfoUpdated"] = "userInfoUpdated";
+  ZIMEventEnum2["userStatusUpdated"] = "userStatusUpdated";
+  ZIMEventEnum2["groupStateChanged"] = "groupStateChanged";
+  ZIMEventEnum2["friendListChanged"] = "friendListChanged";
+  ZIMEventEnum2["blacklistChanged"] = "blacklistChanged";
+  ZIMEventEnum2["callInvitationReceived"] = "callInvitationReceived";
+  ZIMEventEnum2["callAccepted"] = "callAccepted";
+  ZIMEventEnum2["callRejected"] = "callRejected";
+  ZIMEventEnum2["callCanceled"] = "callCanceled";
+  ZIMEventEnum2["callEnded"] = "callEnded";
+  ZIMEventEnum2["callTimeout"] = "callTimeout";
+  ZIMEventEnum2["callParticipantJoined"] = "callParticipantJoined";
+  ZIMEventEnum2["callParticipantLeft"] = "callParticipantLeft";
+  ZIMEventEnum2["callMediaStateChanged"] = "callMediaStateChanged";
+  ZIMEventEnum2["callConnectionStateChanged"] = "callConnectionStateChanged";
+  ZIMEventEnum2["callMediaTrackSubscribed"] = "callMediaTrackSubscribed";
+  ZIMEventEnum2["callMediaTrackUnsubscribed"] = "callMediaTrackUnsubscribed";
+  return ZIMEventEnum2;
+})(ZIMEventEnum || {});
+
 // src/plugins/socketio/client.ts
+var SOCKET_NAMESPACE = "/im/user";
+var DEFAULT_RECONNECT_DELAY_MS = 1e4;
+var DEFAULT_CONNECT_TIMEOUT_MS = 6e4;
+var RECONNECT_LOGIN_DELAY_MS = 200;
+var HEARTBEAT_INTERVAL_MS = 3e4;
+var HEARTBEAT_TIMEOUT_MS = 9e4;
+var HEARTBEAT_PACKET_PREFIX = "ping:";
+var MAX_OPERATION_QUEUE_SIZE = 1e3;
+var CALL_PUSH_EVENT = "push:call";
+var AUTO_ACK_EVENTS = /* @__PURE__ */ new Set(["conversationChanged", "receivePeerMessage", "receiveGroupMessage"]);
+var CALL_PUSH_EVENTS = /* @__PURE__ */ new Set([
+  "callInvitationReceived",
+  "callAccepted",
+  "callRejected",
+  "callCanceled",
+  "callEnded",
+  "callTimeout",
+  "callParticipantJoined",
+  "callParticipantLeft",
+  "callMediaStateChanged"
+]);
+var LOCAL_CONNECTION_EVENTS = /* @__PURE__ */ new Set([
+  "connect",
+  "disconnect",
+  "connect_error",
+  "connectionStateChanged",
+  "reconnect",
+  "reconnect_attempt",
+  "reconnect_error",
+  "reconnect_failed",
+  "reconnectLoginSuccess",
+  "reconnectLoginFailed"
+]);
 function parseSocketConnectErrorPayload(value) {
   if (!value) {
     return void 0;
@@ -163,27 +1165,71 @@ function parseSocketConnectErrorPayload(value) {
   }
   return void 0;
 }
-function normalizeSocketConnectError(error) {
+function getErrorRecord(error) {
+  return error && typeof error === "object" ? error : void 0;
+}
+function getSocketConnectErrorDetails(error, url) {
+  const record = getErrorRecord(error);
+  const message = typeof record?.message === "string" && record.message ? record.message : typeof error === "string" && error ? error : "";
+  return {
+    message,
+    type: typeof record?.type === "string" ? record.type : void 0,
+    description: record?.description,
+    transport: typeof record?.transport === "string" ? record.transport : void 0,
+    url
+  };
+}
+function normalizeSocketConnectError(error, url) {
   const rawMessage = error && typeof error === "object" && "message" in error ? error.message : void 0;
   const rawData = error && typeof error === "object" && "data" in error ? error.data : void 0;
   const payload = parseSocketConnectErrorPayload(rawData) || parseSocketConnectErrorPayload(rawMessage);
+  const details = getSocketConnectErrorDetails(error, url);
   const normalized = new Error(
-    payload?.message || (typeof rawMessage === "string" ? rawMessage : "") || "socket connect failed"
+    payload?.message || details.message || (details.type ? `socket connect failed: ${details.type}` : "") || (typeof rawMessage === "string" ? rawMessage : "") || "socket connect failed"
   );
   normalized.name = "SocketConnectError";
   normalized.code = payload?.code;
   normalized.data = payload;
+  normalized.details = details;
   normalized.requestId = payload?.requestId;
   normalized.raw = error;
   return normalized;
 }
+function debugSocketLog(...args) {
+  if (typeof window !== "undefined" && window.__VANSHI_SDK_DEBUG__) {
+    console.log(...args);
+  }
+}
+function normalizeTimeoutMs(timeoutMs, fallback) {
+  return typeof timeoutMs === "number" && Number.isFinite(timeoutMs) && timeoutMs > 0 ? timeoutMs : fallback;
+}
 var SocketClient = class {
   constructor() {
     this.pending = /* @__PURE__ */ new Map();
-    this.emitQueue = [];
+    this.pendingAcks = /* @__PURE__ */ new Map();
+    this.eventHandlers = /* @__PURE__ */ new Map();
+    this.operationQueue = [];
+    this.operationQueueProcessing = false;
+    this.operationQueueRunId = 0;
     this.connectPromise = null;
-    this.url = "";
+    this.connectReject = null;
+    this.intentionallyDisconnected = false;
+    this.latestReconnectAttempt = 0;
+    this.reconnectRestorePromise = null;
+    this.reconnectRestoreGeneration = 0;
+    this.reconnecting = false;
+    this.restoringSession = false;
+    this.hasEstablishedConnection = false;
+    this.heartbeatSequence = 0;
+    this.connectionStatePayload = {
+      state: 0 /* Disconnected */,
+      event: 3 /* LoginInterrupted */,
+      extendedData: ""
+    };
+    this.socketHandlers = /* @__PURE__ */ new WeakMap();
     this.handleResponse = (res) => {
+      if (!res || typeof res.id !== "string")
+        return;
       const entry = this.pending.get(res.id);
       if (!entry)
         return;
@@ -191,141 +1237,492 @@ var SocketClient = class {
       this.pending.delete(res.id);
       res.error ? entry.reject(res.error) : entry.resolve(res.payload);
     };
+    this.handleCallPush = (message, ackCallback) => {
+      const valid = typeof message?.event === "string" && message.event.length > 0 && message.payload !== null && typeof message.payload === "object" && !Array.isArray(message.payload);
+      if (typeof ackCallback === "function") {
+        const ack = {
+          success: valid,
+          receivedAt: Date.now(),
+          platform: "web",
+          uuids: [message?.wsId],
+          appId: message?.appid,
+          userId: message?.userId,
+          ...valid ? {
+            event: message.event,
+            ...typeof message.payload.callID === "string" ? { callId: message.payload.callID } : {}
+          } : { error: "Invalid data format" }
+        };
+        try {
+          ackCallback(ack);
+        } catch (error) {
+          console.error("[SocketClient] call push ACK failed:", error);
+        }
+      }
+      if (!valid)
+        return;
+      const handlers = this.eventHandlers.get(message.event) || /* @__PURE__ */ new Set();
+      handlers.forEach((handler) => {
+        try {
+          this.invokeHandler(message.event, handler, [message.payload]);
+        } catch (err) {
+          console.error("[SocketClient] call event handler failed:", message.event, err);
+        }
+      });
+    };
+  }
+  watchSession() {
+    if (!this.removeSessionListener)
+      this.removeSessionListener = onSessionInvalidated(() => {
+        this.reconnectRestoreGeneration++;
+        this.reconnectRestorePromise = null;
+        this.restoringSession = false;
+        this.invalidateOperationQueueProcessor();
+        this.cleanupAllPending(new Error("SDK session changed; operation canceled"), true);
+      });
   }
   connect(url, auth, opts = {}) {
+    this.watchSession();
     if (this.connectPromise)
       return this.connectPromise;
     if (this.isConnected())
       return Promise.resolve();
+    if (this.socket && !this.intentionallyDisconnected && (this.hasEstablishedConnection || this.reconnecting || this.restoringSession)) {
+      return this.waitForSocketConnected(
+        normalizeTimeoutMs(opts.timeout, DEFAULT_CONNECT_TIMEOUT_MS)
+      );
+    }
+    this.intentionallyDisconnected = false;
+    this.latestReconnectAttempt = 0;
+    this.reconnecting = false;
+    this.restoringSession = false;
+    this.hasEstablishedConnection = false;
+    this.reconnectRestoreGeneration += 1;
+    this.reconnectRestorePromise = null;
+    this.invalidateOperationQueueProcessor();
+    this.stopHeartbeat();
+    this.cleanupAllPending(new Error("socket reinitialized"), true);
     if (this.socket) {
+      const previousSocket = this.socket;
+      this.socket = void 0;
       try {
-        this.socket.off();
-        this.socket.io.off();
-        this.socket = void 0;
+        previousSocket.off();
+        previousSocket.io.off();
+        previousSocket.disconnect();
       } catch {
       }
     }
     if (this.isConnected())
       return Promise.resolve();
     const { baseUrl, namespace } = this.parseUrl(url);
-    this.url = url;
+    const connectTimeoutMs = normalizeTimeoutMs(
+      opts.timeout,
+      DEFAULT_CONNECT_TIMEOUT_MS
+    );
     const ioOpts = {
       ...opts,
+      auth,
       transports: ["websocket"],
-      // 🔥 只保留 websocket，不会多条连接
       query: { namespace },
       forceNew: true,
       reconnection: true,
       reconnectionAttempts: 9999,
-      reconnectionDelay: 1e4,
-      timeout: 15e3
+      reconnectionDelay: DEFAULT_RECONNECT_DELAY_MS,
+      timeout: connectTimeoutMs
     };
     this.connectPromise = new Promise((resolve, reject) => {
-      const socket = io(`${baseUrl}/im/user`, ioOpts);
+      this.connectReject = reject;
+      const socket = io(`${baseUrl}${SOCKET_NAMESPACE}`, ioOpts);
       this.socket = socket;
-      console.log("[SocketClient] \u65B0\u8FDE\u63A5\u521B\u5EFA\uFF1A", `${baseUrl}/im/user`);
-      const handleConnect = () => {
-        socket.off("connect_error", handleError);
-        socket.on("api:response", this.handleResponse);
-        this.processEmitQueue();
-        resolve();
-      };
-      const handleError = (err) => {
-        const normalizedError = normalizeSocketConnectError(err);
-        console.error("[SocketClient] \u8FDE\u63A5\u5931\u8D25\uFF1A:", normalizedError);
-        socket.off("connect", handleConnect);
-        reject(normalizedError);
-      };
-      socket.once("connect", handleConnect);
-      socket.once("connect_error", handleError);
-      socket.on("disconnect", (reason) => {
-        this.cleanupAllPending("disconnected: " + reason);
-        this.connectPromise = null;
+      socket.onAny((event, ...args) => {
+        if (this.socket !== socket)
+          return;
+        if (AUTO_ACK_EVENTS.has(event))
+          this.ackPush(socket, event, args);
+        observeMessagePush(event, args);
       });
-      socket.io.off("reconnect");
-      socket.io.on("reconnect", async () => {
-        console.log("[SocketClient] \u91CD\u8FDE\u6210\u529F \u2192 \u7B49\u5F85 socket \u5B8C\u5168\u5C31\u7EEA", this.socket?.connected);
-        await new Promise(
-          (resolveReconnect) => setTimeout(resolveReconnect, 200)
+      this.emitConnectionStateChanged(
+        1 /* Connecting */,
+        1 /* ActiveLogin */
+      );
+      debugSocketLog(
+        "[SocketClient] connected target:",
+        `${baseUrl}${SOCKET_NAMESPACE}`
+      );
+      let isInitialConnect = true;
+      let initialConnectSettled = false;
+      const handleConnect = () => {
+        if (this.socket !== socket) {
+          return;
+        }
+        if (isInitialConnect) {
+          this.hasEstablishedConnection = true;
+          this.reconnecting = false;
+          this.restoringSession = false;
+          socket.on("api:response", this.handleResponse);
+          socket.on(CALL_PUSH_EVENT, this.handleCallPush);
+          this.bindEventHandlers(socket);
+          this.processOperationQueue();
+          isInitialConnect = false;
+          if (!initialConnectSettled) {
+            initialConnectSettled = true;
+            resolve();
+          }
+        } else {
+          this.reconnecting = false;
+          this.restoringSession = true;
+          this.emitLocalEvent("reconnect", this.latestReconnectAttempt);
+          const generation3 = ++this.reconnectRestoreGeneration;
+          void this.restoreAfterReconnect(generation3);
+        }
+        this.startHeartbeat(socket);
+        this.emitLocalEvent("connect");
+        this.emitConnectionStateChanged(
+          2 /* Connected */,
+          0 /* Success */
         );
-        if (!this.isConnected() || !this.socket) {
-          console.log("[SocketClient] socket \u672A\u5C31\u7EEA\uFF0C\u8DF3\u8FC7\u767B\u5F55");
+      };
+      const handleError = (err) => {
+        if (this.socket !== socket) {
           return;
         }
-        try {
-          console.log("[SocketClient] \u5F00\u59CB\u81EA\u52A8\u767B\u5F55 \u2705");
-          const res = await restoreSessionAfterReconnect();
-          if (res) {
-            this.processEmitQueue();
-          } else {
-            clearSessionState();
+        const normalizedError = normalizeSocketConnectError(
+          err,
+          `${baseUrl}${SOCKET_NAMESPACE}`
+        );
+        console.error("[SocketClient] connect failed:", normalizedError);
+        this.emitLocalEvent("connect_error", normalizedError);
+        this.emitConnectionStateChanged(
+          0 /* Disconnected */,
+          2 /* LoginTimeout */,
+          normalizedError.message
+        );
+        if (isInitialConnect && !initialConnectSettled) {
+          initialConnectSettled = true;
+          this.connectReject = null;
+          this.rejectQueuedOperations(normalizedError);
+          try {
+            socket.io.opts.reconnection = false;
+            socket.disconnect();
+          } catch {
           }
-        } catch (err) {
-          console.error("[SocketClient] \u81EA\u52A8\u767B\u5F55\u5931\u8D25", err);
-          clearSessionState();
+          reject(normalizedError);
+        }
+      };
+      socket.on("connect", handleConnect);
+      socket.on("connect_error", handleError);
+      socket.on("disconnect", (reason) => {
+        if (this.socket !== socket) {
+          return;
+        }
+        const hadEstablishedConnection = this.hasEstablishedConnection;
+        const shouldReconnect = !this.intentionallyDisconnected && hadEstablishedConnection;
+        const disconnectError = new Error("disconnected: " + reason);
+        this.stopHeartbeat();
+        this.reconnectRestoreGeneration += 1;
+        this.reconnectRestorePromise = null;
+        this.restoringSession = false;
+        this.reconnecting = shouldReconnect;
+        this.cleanupAllPending(disconnectError, !shouldReconnect);
+        if (!hadEstablishedConnection && !initialConnectSettled) {
+          initialConnectSettled = true;
+          this.connectReject?.(disconnectError);
+          this.connectReject = null;
+          this.rejectQueuedOperations(disconnectError);
+        }
+        this.emitLocalEvent("disconnect", reason);
+        this.emitConnectionStateChanged(
+          0 /* Disconnected */,
+          this.getDisconnectEvent(reason),
+          String(reason || "")
+        );
+        if (reason === "io server disconnect" && !this.intentionallyDisconnected) {
+          this.latestReconnectAttempt += 1;
+          this.emitLocalEvent("reconnect_attempt", this.latestReconnectAttempt);
+          this.emitConnectionStateChanged(
+            3 /* Reconnecting */,
+            3 /* LoginInterrupted */,
+            String(this.latestReconnectAttempt)
+          );
+          socket.connect();
         }
       });
+      socket.io.off("reconnect");
+      socket.io.off("reconnect_attempt");
+      socket.io.off("reconnect_error");
+      socket.io.off("reconnect_failed");
+      socket.io.on("reconnect_attempt", (attempt) => {
+        if (this.socket !== socket) {
+          return;
+        }
+        this.latestReconnectAttempt = attempt;
+        this.emitLocalEvent("reconnect_attempt", attempt);
+        this.emitConnectionStateChanged(
+          3 /* Reconnecting */,
+          3 /* LoginInterrupted */,
+          String(attempt)
+        );
+      });
+      socket.io.on("reconnect_error", (err) => {
+        if (this.socket !== socket) {
+          return;
+        }
+        this.emitLocalEvent("reconnect_error", err);
+      });
+      socket.io.on("reconnect_failed", () => {
+        if (this.socket !== socket) {
+          return;
+        }
+        this.reconnecting = false;
+        this.restoringSession = false;
+        this.hasEstablishedConnection = false;
+        this.rejectQueuedOperations(new Error("reconnect failed"));
+        this.emitConnectionStateChanged(
+          0 /* Disconnected */,
+          3 /* LoginInterrupted */,
+          "reconnect failed"
+        );
+        this.emitLocalEvent("reconnect_failed");
+      });
+      socket.io.on("reconnect", (attempt) => {
+        if (this.socket !== socket) {
+          return;
+        }
+        debugSocketLog("[SocketClient] reconnect:", this.socket?.connected);
+        this.latestReconnectAttempt = attempt;
+      });
     });
-    this.connectPromise.finally(() => {
-      this.connectPromise = null;
-    });
+    const trackedConnectPromise = this.connectPromise;
+    trackedConnectPromise.then(
+      () => {
+        if (this.connectPromise === trackedConnectPromise) {
+          this.connectPromise = null;
+          this.connectReject = null;
+        }
+      },
+      () => {
+        if (this.connectPromise === trackedConnectPromise) {
+          this.connectPromise = null;
+          this.connectReject = null;
+        }
+      }
+    );
     return this.connectPromise;
   }
   disconnect() {
-    if (!this.socket)
-      return;
-    try {
-      this.socket.off("api:response", this.handleResponse);
-      this.socket.io.off("reconnect");
-      this.socket.disconnect();
-    } catch {
+    this.intentionallyDisconnected = true;
+    this.reconnecting = false;
+    this.restoringSession = false;
+    this.hasEstablishedConnection = false;
+    this.reconnectRestoreGeneration += 1;
+    this.reconnectRestorePromise = null;
+    this.invalidateOperationQueueProcessor();
+    this.stopHeartbeat();
+    const disconnectError = new Error("client disconnected");
+    this.connectReject?.(disconnectError);
+    this.connectReject = null;
+    if (this.socket) {
+      const currentSocket = this.socket;
+      try {
+        currentSocket.off("api:response", this.handleResponse);
+        currentSocket.off(CALL_PUSH_EVENT, this.handleCallPush);
+        currentSocket.io.off("reconnect");
+        currentSocket.io.off("reconnect_attempt");
+        currentSocket.io.off("reconnect_error");
+        currentSocket.io.off("reconnect_failed");
+        currentSocket.disconnect();
+      } catch {
+      } finally {
+        try {
+          currentSocket.off();
+          currentSocket.io.off();
+        } catch {
+        }
+      }
     }
     this.socket = void 0;
-    this.cleanupAllPending("client disconnected");
+    this.connectPromise = null;
+    this.cleanupAllPending(disconnectError, true);
+    this.removeSessionListener?.();
+    this.removeSessionListener = void 0;
   }
   emitWithAck(event, payload, timeoutMs = 1e4) {
-    if (this.isConnected()) {
+    this.watchSession();
+    timeoutMs = normalizeTimeoutMs(timeoutMs, 1e4);
+    const canSendDuringRestore = event === "login";
+    const hasQueuedOperations = this.operationQueueProcessing || this.operationQueue.length > 0;
+    if (this.isConnected() && (!hasQueuedOperations || canSendDuringRestore) && (!this.restoringSession && !isAuthenticating() || canSendDuringRestore)) {
       return this.createEmitPromise(event, payload, timeoutMs);
     }
-    if (this.connectPromise) {
-      return new Promise((resolve, reject) => {
-        this.emitQueue.push({ event, payload, timeoutMs, resolve, reject });
-      });
+    if (this.connectPromise || this.reconnecting || isAuthenticating() && !canSendDuringRestore || hasQueuedOperations || this.restoringSession && !canSendDuringRestore) {
+      return this.queueOperation(
+        () => this.createEmitPromise(event, payload, timeoutMs),
+        canSendDuringRestore ? "login" : "request"
+      );
     }
-    return Promise.reject(new Error("socket not initialized"));
+    return Promise.reject(new Error("socket not connected"));
   }
   request(path, payload, timeoutMs = 1e4) {
-    if (!this.socket) {
-      return Promise.reject(new Error("socket not initialized"));
+    this.watchSession();
+    timeoutMs = normalizeTimeoutMs(timeoutMs, 1e4);
+    const hasQueuedOperations = this.operationQueueProcessing || this.operationQueue.length > 0;
+    if (this.isConnected() && !this.restoringSession && !isAuthenticating() && !hasQueuedOperations) {
+      return this.createRequestPromise(path, payload, timeoutMs);
     }
-    const id = this.generateId();
-    const envelope = { id, path, payload };
-    return new Promise((resolve, reject) => {
-      const timer = setTimeout(() => {
-        this.pending.delete(id);
-        reject(new Error("request timeout"));
-      }, timeoutMs);
-      this.pending.set(id, { resolve, reject, timer });
-      try {
-        this.socket.emit("api:request", envelope);
-      } catch (err) {
-        clearTimeout(timer);
-        this.pending.delete(id);
-        reject(err);
-      }
-    });
+    if (this.connectPromise || this.reconnecting || this.restoringSession || isAuthenticating() || hasQueuedOperations) {
+      return this.queueOperation(
+        () => this.createRequestPromise(path, payload, timeoutMs)
+      );
+    }
+    return Promise.reject(new Error("socket not connected"));
+  }
+  resumeQueuedRequestsAfterLogin() {
+    if (!this.isConnected()) {
+      return;
+    }
+    this.reconnectRestoreGeneration += 1;
+    this.reconnecting = false;
+    this.restoringSession = false;
+    this.processOperationQueue();
+  }
+  rejectQueuedRequestsAfterLoginFailure(reason = new Error("login failed")) {
+    this.rejectQueuedOperations(reason, true);
   }
   on(event, handler) {
-    this.socket?.on(event, handler);
+    const handlers = this.eventHandlers.get(event) || /* @__PURE__ */ new Set();
+    if (handlers.has(handler))
+      return;
+    handlers.add(handler);
+    this.eventHandlers.set(event, handlers);
+    if (!LOCAL_CONNECTION_EVENTS.has(event) && !CALL_PUSH_EVENTS.has(event)) {
+      this.socket?.on(event, this.socketHandler(event, handler));
+    } else if (event === "connect" && this.isConnected()) {
+      queueMicrotask(() => {
+        if (this.eventHandlers.get(event) === handlers && handlers.has(handler))
+          this.invokeHandler(event, handler, []);
+      });
+    } else if (event === "connectionStateChanged") {
+      queueMicrotask(() => {
+        if (this.eventHandlers.get(event) === handlers && handlers.has(handler))
+          this.invokeHandler(event, handler, [this.connectionStatePayload]);
+      });
+    }
   }
   off(event, handler) {
-    if (!this.socket)
+    if (handler) {
+      const handlers = this.eventHandlers.get(event);
+      handlers?.delete(handler);
+      if (handlers?.size === 0) {
+        this.eventHandlers.delete(event);
+      }
+    } else {
+      this.eventHandlers.delete(event);
+    }
+    if (!this.socket || LOCAL_CONNECTION_EVENTS.has(event) || CALL_PUSH_EVENTS.has(event)) {
       return;
-    handler ? this.socket.off(event, handler) : this.socket.off(event);
+    }
+    handler ? this.socket.off(event, this.socketHandler(event, handler)) : this.socket.off(event);
+  }
+  socketHandler(event, handler) {
+    let events = this.socketHandlers.get(handler);
+    if (!events) {
+      events = /* @__PURE__ */ new Map();
+      this.socketHandlers.set(handler, events);
+    }
+    let wrapped = events.get(event);
+    if (!wrapped) {
+      wrapped = (...args) => {
+        const publicArgs = AUTO_ACK_EVENTS.has(event) ? args.filter((arg) => typeof arg !== "function") : args;
+        const filtered = filterReplyPushArgs(event, publicArgs);
+        if (filtered)
+          this.invokeHandler(event, handler, filtered);
+      };
+      events.set(event, wrapped);
+    }
+    return wrapped;
   }
   isConnected() {
     return !!this.socket?.connected;
   }
+  invokeHandler(event, handler, args) {
+    try {
+      const result = handler.apply(this.socket, args);
+      if (result && typeof result.then === "function")
+        Promise.resolve(result).catch((error) => {
+          console.error("[SocketClient] async event handler failed:", event, error);
+        });
+    } catch (error) {
+      console.error("[SocketClient] event handler failed:", event, error);
+    }
+  }
+  startHeartbeat(socket) {
+    this.stopHeartbeat();
+    const engine = socket?.io?.engine;
+    if (!engine || typeof engine._sendPacket !== "function") {
+      return;
+    }
+    const handlePacket = (packet) => {
+      if (packet?.type !== "pong" || typeof packet.data !== "string" || packet.data !== this.pendingHeartbeatID) {
+        return;
+      }
+      debugSocketLog("[SocketClient] heartbeat pong:", packet.data);
+      this.pendingHeartbeatID = void 0;
+      if (this.heartbeatTimeout !== void 0) {
+        clearTimeout(this.heartbeatTimeout);
+        this.heartbeatTimeout = void 0;
+      }
+    };
+    const sendHeartbeat = () => {
+      if (this.socket !== socket || socket.io?.engine !== engine || !socket.connected || engine.readyState !== "open" || this.pendingHeartbeatID) {
+        return;
+      }
+      const heartbeatID = `${HEARTBEAT_PACKET_PREFIX}${++this.heartbeatSequence}`;
+      this.pendingHeartbeatID = heartbeatID;
+      debugSocketLog("[SocketClient] heartbeat ping:", heartbeatID);
+      try {
+        engine._sendPacket("ping", heartbeatID);
+      } catch (error) {
+        debugSocketLog("[SocketClient] heartbeat send failed:", error);
+        this.stopHeartbeat();
+        engine.close();
+        return;
+      }
+      this.heartbeatTimeout = setTimeout(() => {
+        this.heartbeatTimeout = void 0;
+        if (this.socket !== socket || socket.io?.engine !== engine || !socket.connected || this.pendingHeartbeatID !== heartbeatID) {
+          return;
+        }
+        debugSocketLog(
+          `[SocketClient] heartbeat timeout after ${HEARTBEAT_TIMEOUT_MS}ms`
+        );
+        this.stopHeartbeat();
+        engine.close();
+      }, HEARTBEAT_TIMEOUT_MS);
+    };
+    this.heartbeatEngine = engine;
+    this.heartbeatPacketHandler = handlePacket;
+    engine.on("packet", handlePacket);
+    sendHeartbeat();
+    this.heartbeatInterval = setInterval(
+      sendHeartbeat,
+      HEARTBEAT_INTERVAL_MS
+    );
+  }
+  stopHeartbeat() {
+    if (this.heartbeatInterval !== void 0) {
+      clearInterval(this.heartbeatInterval);
+      this.heartbeatInterval = void 0;
+    }
+    if (this.heartbeatTimeout !== void 0) {
+      clearTimeout(this.heartbeatTimeout);
+      this.heartbeatTimeout = void 0;
+    }
+    if (this.heartbeatEngine && this.heartbeatPacketHandler) {
+      this.heartbeatEngine.off("packet", this.heartbeatPacketHandler);
+    }
+    this.heartbeatEngine = void 0;
+    this.heartbeatPacketHandler = void 0;
+    this.pendingHeartbeatID = void 0;
+  }
   parseUrl(url) {
     let baseUrl = url;
     let namespace = "/im/user";
@@ -336,95 +1733,601 @@ var SocketClient = class {
         namespace = queryNs;
       baseUrl = urlObj.origin + urlObj.pathname.replace(/\/$/, "");
     } catch {
-      console.warn("[Socket] URL parse failed:", url);
+      console.warn("[SocketClient] url parse failed:", url);
     }
     return { baseUrl, namespace };
   }
+  ackPush(socket, event, args) {
+    const ack = args.find((arg) => typeof arg === "function");
+    if (typeof ack !== "function" || !socket.id)
+      return;
+    const data = args[0];
+    let receipt;
+    const normalizeIds = (ids) => [...new Set(ids.filter((id) => typeof id === "string" && id.length > 0 || typeof id === "number" && Number.isFinite(id)).map(String))];
+    if (event === "conversationChanged") {
+      const infos = Array.isArray(data) ? data : Array.isArray(data?.infoList) ? data.infoList : [];
+      const ackIds = normalizeIds(infos.map((info) => info?.conversation?.ackId));
+      const userId = getSdkUserID();
+      receipt = { clientId: socket.id, platform: "web", ...ackIds.length ? { ackIds } : {}, ...userId ? { userId } : {} };
+    } else {
+      const messages = Array.isArray(data?.messageList) ? data.messageList : [];
+      const msgid = normalizeIds(messages.map((message) => message?.messageID));
+      receipt = { clientId: socket.id, platform: "web", ...msgid.length ? { msgid } : {} };
+    }
+    try {
+      ack(receipt);
+    } catch (error) {
+      console.error("[SocketClient] push ACK failed:", event, error);
+    }
+  }
+  bindEventHandlers(socket) {
+    this.eventHandlers.forEach((handlers, event) => {
+      if (LOCAL_CONNECTION_EVENTS.has(event) || CALL_PUSH_EVENTS.has(event)) {
+        return;
+      }
+      handlers.forEach((handler) => {
+        socket.on(event, this.socketHandler(event, handler));
+      });
+    });
+  }
+  emitLocalEvent(event, ...args) {
+    const handlers = this.eventHandlers.get(event);
+    if (!handlers)
+      return;
+    handlers.forEach((handler) => {
+      try {
+        this.invokeHandler(event, handler, args);
+      } catch (err) {
+        console.error("[SocketClient] event handler failed:", event, err);
+      }
+    });
+  }
+  emitConnectionStateChanged(state, event, extendedData = "") {
+    const payload = {
+      state,
+      event,
+      extendedData
+    };
+    this.connectionStatePayload = payload;
+    this.emitLocalEvent("connectionStateChanged", payload);
+  }
+  getDisconnectEvent(reason) {
+    if (reason === "io server disconnect") {
+      return 4 /* KickedOut */;
+    }
+    return 3 /* LoginInterrupted */;
+  }
+  restoreAfterReconnect(generation3) {
+    if (this.reconnectRestorePromise) {
+      return this.reconnectRestorePromise;
+    }
+    const restorePromise = (async () => {
+      await new Promise(
+        (resolveReconnect) => setTimeout(resolveReconnect, RECONNECT_LOGIN_DELAY_MS)
+      );
+      if (generation3 !== this.reconnectRestoreGeneration || !this.isConnected() || !this.socket) {
+        debugSocketLog("[SocketClient] skip reconnect login: socket not ready");
+        return;
+      }
+      try {
+        debugSocketLog("[SocketClient] reconnect login start");
+        const res = await restoreSessionAfterReconnect();
+        if (generation3 !== this.reconnectRestoreGeneration) {
+          return;
+        }
+        if (res) {
+          this.restoringSession = false;
+          this.processOperationQueue();
+          this.emitLocalEvent("reconnectLoginSuccess");
+        } else {
+          this.restoringSession = false;
+          clearSessionState();
+          this.rejectQueuedOperations(new Error("restore login failed"), true);
+          this.processOperationQueue();
+          this.emitLocalEvent("reconnectLoginFailed", {
+            message: "restore login failed"
+          });
+        }
+      } catch (err) {
+        if (generation3 !== this.reconnectRestoreGeneration) {
+          return;
+        }
+        console.error("[SocketClient] reconnect login failed:", err);
+        this.restoringSession = false;
+        clearSessionState();
+        this.rejectQueuedOperations(err, true);
+        this.processOperationQueue();
+        this.emitLocalEvent("reconnectLoginFailed", err);
+      }
+    })();
+    const trackedRestorePromise = restorePromise.finally(() => {
+      if (this.reconnectRestorePromise === trackedRestorePromise) {
+        this.reconnectRestorePromise = null;
+      }
+    });
+    this.reconnectRestorePromise = trackedRestorePromise;
+    return this.reconnectRestorePromise;
+  }
   generateId() {
     return Date.now().toString(36) + Math.random().toString(36).slice(2, 9);
   }
+  waitForSocketConnected(timeoutMs) {
+    if (this.isConnected()) {
+      return Promise.resolve();
+    }
+    return new Promise((resolve, reject) => {
+      const cleanup = () => {
+        clearTimeout(timer);
+        this.off("connect", handleConnect);
+        this.off("reconnect_failed", handleReconnectFailed);
+        this.off("disconnect", handleDisconnect);
+      };
+      const handleConnect = () => {
+        cleanup();
+        resolve();
+      };
+      const handleReconnectFailed = () => {
+        cleanup();
+        reject(new Error("reconnect failed"));
+      };
+      const handleDisconnect = (reason) => {
+        if (!this.reconnecting && !this.restoringSession) {
+          cleanup();
+          reject(new Error("disconnected: " + String(reason || "")));
+        }
+      };
+      const timer = setTimeout(() => {
+        cleanup();
+        reject(new Error("connect timeout"));
+      }, timeoutMs);
+      this.on("connect", handleConnect);
+      this.on("reconnect_failed", handleReconnectFailed);
+      this.on("disconnect", handleDisconnect);
+    });
+  }
+  createRequestPromise(path, payload, timeoutMs) {
+    const id = this.generateId();
+    const envelope = { id, path, payload };
+    return new Promise((resolve, reject) => {
+      if (!this.isConnected() || this.restoringSession) {
+        reject(new Error("socket not connected"));
+        return;
+      }
+      const timer = setTimeout(() => {
+        this.pending.delete(id);
+        reject(new Error("request timeout"));
+      }, timeoutMs);
+      this.pending.set(id, { resolve, reject, timer });
+      try {
+        if (!this.socket) {
+          throw new Error("socket not initialized");
+        }
+        this.socket.emit("api:request", envelope);
+      } catch (err) {
+        clearTimeout(timer);
+        this.pending.delete(id);
+        reject(err);
+      }
+    });
+  }
   createEmitPromise(event, payload, timeoutMs) {
+    const id = this.generateId();
     return new Promise((resolve, reject) => {
-      let timedOut = false;
+      if (!this.isConnected()) {
+        reject(new Error("socket not connected"));
+        return;
+      }
       const timer = setTimeout(() => {
-        timedOut = true;
+        this.pendingAcks.delete(id);
         reject(new Error("ack timeout"));
       }, timeoutMs);
+      this.pendingAcks.set(id, { resolve, reject, timer });
       try {
+        if (!this.socket) {
+          throw new Error("socket not initialized");
+        }
         this.socket.emit(event, payload, (response) => {
-          if (timedOut)
+          const entry = this.pendingAcks.get(id);
+          if (!entry)
             return;
-          clearTimeout(timer);
-          if (response?.code !== void 0) {
-            isSuccessCode(response.code) ? resolve(response) : reject(new Error(response.message || `code=${response.code}`));
-          } else {
-            resolve(response);
-          }
+          clearTimeout(entry.timer);
+          this.pendingAcks.delete(id);
+          entry.resolve(response);
         });
       } catch (err) {
         clearTimeout(timer);
+        this.pendingAcks.delete(id);
         reject(err);
       }
     });
   }
-  processEmitQueue() {
-    if (!this.isConnected())
+  queueOperation(execute, kind = "request") {
+    return new Promise((resolve, reject) => {
+      if (this.operationQueue.length >= MAX_OPERATION_QUEUE_SIZE) {
+        reject(new Error("socket operation queue is full"));
+        return;
+      }
+      const operation = {
+        session: captureSession(),
+        execute,
+        resolve,
+        reject,
+        kind
+      };
+      if (kind === "login") {
+        const firstRequestIndex = this.operationQueue.findIndex(
+          (item) => item.kind !== "login"
+        );
+        if (firstRequestIndex < 0) {
+          this.operationQueue.push(operation);
+        } else {
+          this.operationQueue.splice(firstRequestIndex, 0, operation);
+        }
+      } else {
+        this.operationQueue.push(operation);
+      }
+      this.processOperationQueue();
+    });
+  }
+  processOperationQueue() {
+    if (!this.isConnected() || (this.restoringSession || isAuthenticating()) && this.operationQueue[0]?.kind !== "login" || this.operationQueueProcessing) {
       return;
-    while (this.emitQueue.length) {
-      const item = this.emitQueue.shift();
-      this.createEmitPromise(item.event, item.payload, item.timeoutMs).then(item.resolve).catch(item.reject);
     }
+    this.operationQueueProcessing = true;
+    const runId = ++this.operationQueueRunId;
+    const processNext = () => {
+      if (runId !== this.operationQueueRunId) {
+        return;
+      }
+      if (!this.isConnected() || (this.restoringSession || isAuthenticating()) && this.operationQueue[0]?.kind !== "login") {
+        this.operationQueueProcessing = false;
+        return;
+      }
+      const item = this.operationQueue.shift();
+      if (!item) {
+        this.operationQueueProcessing = false;
+        return;
+      }
+      Promise.resolve().then(() => {
+        assertCurrentSession(item.session);
+        return item.execute();
+      }).then(
+        (value) => {
+          item.resolve(value);
+        },
+        (error) => {
+          item.reject(error);
+          if (item.kind === "login" && runId === this.operationQueueRunId) {
+            this.rejectQueuedOperations(error);
+          }
+        }
+      ).finally(processNext);
+    };
+    processNext();
+  }
+  invalidateOperationQueueProcessor() {
+    this.operationQueueRunId += 1;
+    this.operationQueueProcessing = false;
   }
-  cleanupAllPending(reason) {
+  rejectQueuedOperations(reason, preserveLoginOperations = false) {
+    const queue = this.operationQueue.splice(0);
+    const preserved = [];
+    queue.forEach((item) => {
+      if (preserveLoginOperations && item.kind === "login") {
+        preserved.push(item);
+      } else {
+        item.reject(reason);
+      }
+    });
+    this.operationQueue.unshift(...preserved);
+  }
+  cleanupAllPending(reason, clearQueue) {
     for (const [, entry] of this.pending) {
       clearTimeout(entry.timer);
-      entry.reject(new Error(reason));
+      entry.reject(reason);
     }
     this.pending.clear();
-    for (const item of this.emitQueue) {
-      item.reject(new Error(reason));
+    for (const [, entry] of this.pendingAcks) {
+      clearTimeout(entry.timer);
+      entry.reject(reason);
+    }
+    this.pendingAcks.clear();
+    if (clearQueue) {
+      this.rejectQueuedOperations(reason);
     }
-    this.emitQueue = [];
   }
 };
 var socketClient = new SocketClient();
 var client_default = socketClient;
 
+// src/sdk/message/replyResult.ts
+function normalizeReplyResult(result, payload) {
+  const sent = payload.message || {};
+  const original = payload.toOriginalMessage || {};
+  const received = result?.message && typeof result.message === "object" ? result.message : result;
+  const hasReplyIdentity = received?.messageID && (!original.messageID || String(received.messageID) !== String(original.messageID)) && !isSelfReferencingReply(received);
+  const row = hasReplyIdentity ? received : {};
+  const normalize = (row2) => {
+    const reply = {
+      ...sent,
+      ...row2,
+      clientBizId: sent.clientBizId,
+      localMessageID: sent.localMessageID || sent.clientBizId,
+      conversationID: sent.conversationID ?? original.conversationID,
+      conversationType: sent.conversationType ?? original.conversationType,
+      direction: 0,
+      sentStatus: 1,
+      sendState: 1,
+      repliedInfo: {
+        ...sent.repliedInfo,
+        ...row2.repliedInfo,
+        messageInfo: row2.repliedInfo?.messageInfo ?? sent.repliedInfo?.messageInfo
+      }
+    };
+    delete reply.localID;
+    delete reply.errorCode;
+    delete reply.errorMessage;
+    return reply;
+  };
+  if (result?.message && typeof result.message === "object")
+    return { ...result, message: normalize(row) };
+  return normalize(row);
+}
+
+// src/sdk/message/sendResult.ts
+function normalizeSendResult(method, result, payload) {
+  if (method === "replyMessage")
+    return normalizeReplyResult(result, payload);
+  const sent = payload.message || {};
+  const normalize = (row = {}) => {
+    const sendState = messageSendState(row);
+    return {
+      ...row,
+      clientBizId: sent.clientBizId || row.clientBizId,
+      localMessageID: row.localMessageID || sent.localMessageID || sent.clientBizId,
+      sendState,
+      sentStatus: row.sentStatus ?? sendState
+    };
+  };
+  if (result?.message && typeof result.message === "object")
+    return { ...result, message: normalize(result.message) };
+  return normalize(result && typeof result === "object" ? result : {});
+}
+
 // src/plugins/request/index.ts
+var DEFAULT_TIMEOUT_MS = 1e4;
+function getTimeoutMs(config) {
+  return typeof config.timeoutMs === "number" && Number.isFinite(config.timeoutMs) && config.timeoutMs > 0 ? config.timeoutMs : DEFAULT_TIMEOUT_MS;
+}
 async function request(config) {
   if (!config || !config.path) {
-    return Promise.reject(new Error("invalid request config"));
+    throwSdkTransportError(new Error("invalid request config"));
   }
-  const path = config.path;
-  const isSdkApi = path.startsWith("/sdk/") || path.startsWith("sdk/");
-  if (isSdkApi) {
-    const eventName = path.replace(/^\/?sdk\//, "");
-    const timeoutMs2 = typeof config.timeoutMs === "number" ? config.timeoutMs : 1e4;
-    if (!client_default.isConnected()) {
-      return Promise.reject(new Error("socket not connected"));
-    }
-    try {
-      const res = await client_default.emitWithAck(
+  const session = captureSession();
+  const method = config.path.replace(/^\/?sdk\//, "");
+  if (method !== "login" && method !== "logout" && isAuthenticating())
+    await waitForAuthentication(session);
+  const storage = captureStorage();
+  const sending = ["sendMessage", "sendMediaMessage", "replyMessage"].includes(method);
+  if (storage && sending && config.data?.message) {
+    config = { ...config, data: { ...config.data, message: {
+      ...config.data.message,
+      clientBizId: config.data.message.clientBizId || makeClientBizId()
+    } } };
+    await persistOutgoing(storage, config.data);
+  }
+  const startedAt = Date.now();
+  const fetchSequence = storage ? storage.mutationSequence = (storage.mutationSequence || 0) + 1 : 0;
+  try {
+    assertCurrentSession(session);
+    if (storage && !isCurrentStorage(storage))
+      throw new Error("Local storage account changed before request");
+    const { path } = config;
+    const isSdkApi = path.startsWith("/sdk/") || path.startsWith("sdk/");
+    const timeoutMs = getTimeoutMs(config);
+    if (isSdkApi) {
+      const eventName = path.replace(/^\/?sdk\//, "");
+      const response2 = await client_default.emitWithAck(
         eventName,
         config.data,
-        timeoutMs2
+        timeoutMs
       );
-      if (res && typeof res === "object" && typeof res.code === "number") {
-        return res;
+      assertCurrentSession(session);
+      const envelope = hasSdkCode(response2) ? response2 : { code: 0, message: "", data: response2 };
+      const normalizedEnvelope = sending && isSuccessCode(envelope.code) ? { ...envelope, data: normalizeSendResult(method, envelope.data, config.data || {}) } : envelope;
+      if (isSuccessCode(envelope.code)) {
+        await cacheApiResult(storage, method, config.data || {}, normalizedEnvelope.data, startedAt, fetchSequence);
+      } else if (sending) {
+        await markSendError(storage, config.data?.message?.clientBizId, outgoingFallback(config.data || {}, storage), envelope);
       }
-      return { code: 0, message: "", data: res };
-    } catch (err) {
-      return Promise.reject(err);
+      assertCurrentSession(session);
+      return normalizedEnvelope;
     }
+    const response = await client_default.request(path, config.data, timeoutMs);
+    assertCurrentSession(session);
+    return response;
+  } catch (error) {
+    if (sending)
+      await markSendError(storage, config.data?.message?.clientBizId, outgoingFallback(config.data || {}, storage), error);
+    assertCurrentSession(session);
+    if (isSdkRuntimeErrorObject(error)) {
+      throw error;
+    }
+    throwSdkTransportError(error);
   }
-  if (!client_default.isConnected()) {
-    return Promise.reject(new Error("socket not connected"));
+}
+
+// src/sdk/storage/types.ts
+var LocalSyncError = class extends Error {
+  constructor(results, failures) {
+    super(`Local synchronization incomplete: ${failures.length} failure(s)`);
+    this.results = results;
+    this.failures = failures;
+    this.name = "LocalSyncError";
+    this.fullyReconciled = false;
+  }
+  toJSON() {
+    return { name: this.name, message: this.message, results: this.results, failures: this.failures, fullyReconciled: false };
+  }
+};
+
+// src/sdk/storage/sync.ts
+var running = /* @__PURE__ */ new WeakMap();
+async function syncConversationMessages(options) {
+  const ctx = captureStorage();
+  if (!ctx)
+    throw new Error("Local message storage is not enabled");
+  const { conversationID } = options;
+  const conversationType = String(options.conversationType);
+  const key = JSON.stringify([conversationType, conversationID]);
+  let jobs = running.get(ctx);
+  if (!jobs) {
+    jobs = /* @__PURE__ */ new Map();
+    running.set(ctx, jobs);
+  }
+  const existing = jobs.get(key);
+  if (existing)
+    return existing;
+  const job = (async () => {
+    emitStorageEvent("localSyncStateChanged", { state: "syncing", conversationID, conversationType });
+    try {
+      await ctx.ready;
+      const failuresBefore = ctx.failureCount || 0;
+      let nextMessage;
+      let exhausted = false;
+      const cursors = /* @__PURE__ */ new Set();
+      for (let page = 0; page < 100; page++) {
+        if (!isCurrentStorage(ctx))
+          throw new Error("Local storage account changed");
+        const response = await request({ path: "/sdk/queryHistoryMessage", data: {
+          conversationID,
+          conversationType,
+          config: { count: "100", ...nextMessage ? { nextMessage } : {} }
+        } });
+        const data = unwrapSdkData(response);
+        if (!isCurrentStorage(ctx))
+          throw new Error("Local storage account changed");
+        const list = data?.messageList;
+        if (!Array.isArray(list))
+          throw new Error("Invalid history response during local synchronization");
+        if (list.length < 100) {
+          exhausted = true;
+          break;
+        }
+        const last = list[list.length - 1];
+        if (!last.messageID)
+          throw new Error("History cursor is missing messageID");
+        const cursor = String(last.messageID);
+        if (cursors.has(cursor))
+          throw new Error("History pagination cursor did not advance");
+        cursors.add(cursor);
+        nextMessage = { messageID: last.messageID, id: last.id || "", type: String(last.type) };
+      }
+      if (!exhausted)
+        throw new Error("History synchronization page limit reached; synchronization is incomplete");
+      if ((ctx.failureCount || 0) !== failuresBefore)
+        throw new Error("Messages could not be persisted during synchronization");
+      const result = { conversationID, conversationType, syncedAt: Date.now(), fullyReconciled: false };
+      await storageWork(ctx, async (ctx2) => {
+        await ctx2.db.meta.put({ key: `sync:${key}`, ...result });
+      });
+      if ((ctx.failureCount || 0) !== failuresBefore)
+        throw new Error("Synchronization metadata could not be persisted");
+      if (isCurrentStorage(ctx))
+        emitStorageEvent("localSyncStateChanged", { state: "synced", ...result });
+      return result;
+    } catch (error) {
+      if (isCurrentStorage(ctx))
+        emitStorageEvent("localSyncStateChanged", { state: "failed", conversationID, conversationType, message: error instanceof Error ? error.message : String(error), fullyReconciled: false });
+      throw error;
+    }
+  })();
+  jobs.set(key, job);
+  try {
+    return await job;
+  } finally {
+    jobs.delete(key);
+  }
+}
+async function syncLocalMessages() {
+  const ctx = captureStorage();
+  if (!ctx)
+    return [];
+  const conversations = await storageWork(ctx, async (ctx2) => {
+    const keys = await ctx2.db.messages.orderBy("conversationKey").uniqueKeys();
+    return keys.map((key) => {
+      const [conversationType, conversationID] = JSON.parse(String(key));
+      return { conversationType: String(conversationType), conversationID: String(conversationID) };
+    });
+  });
+  const failures = [];
+  if (!conversations)
+    failures.push({ conversationID: "", conversationType: "", message: "Cached conversations could not be read" });
+  const known = new Map((conversations || []).map((row) => [JSON.stringify([String(row.conversationType), row.conversationID]), row]));
+  try {
+    let nextConversation;
+    const seen = /* @__PURE__ */ new Set();
+    let exhausted = false;
+    for (let page = 0; page < 100 && isCurrentStorage(ctx); page++) {
+      const data = unwrapSdkData(await request({ path: "/sdk/queryConversationList", data: { count: 100, ...nextConversation ? { nextConversation } : {} } }));
+      if (!isCurrentStorage(ctx))
+        throw new Error("Local storage account changed");
+      const list = Array.isArray(data) ? data : data?.conversationList;
+      if (!Array.isArray(list))
+        throw new Error("Invalid conversation list during local synchronization");
+      for (const row of list) {
+        const conversation = row.conversation || row;
+        if (conversation.conversationID === void 0 || (conversation.conversationType ?? conversation.type) === void 0)
+          continue;
+        const entry = { conversationID: String(conversation.conversationID), conversationType: String(conversation.conversationType ?? conversation.type) };
+        known.set(JSON.stringify([entry.conversationType, entry.conversationID]), entry);
+      }
+      if (list.length < 100) {
+        exhausted = true;
+        break;
+      }
+      nextConversation = list[list.length - 1].conversation || list[list.length - 1];
+      const key = JSON.stringify([nextConversation.conversationType ?? nextConversation.type, nextConversation.conversationID]);
+      if (seen.has(key))
+        throw new Error("Conversation pagination cursor did not advance");
+      seen.add(key);
+    }
+    if (!exhausted)
+      throw new Error("Conversation synchronization page limit reached; synchronization is incomplete");
+  } catch (error) {
+    failures.push({ conversationID: "", conversationType: "", message: error instanceof Error ? error.message : String(error) });
+    if (isCurrentStorage(ctx))
+      emitStorageEvent("localSyncStateChanged", { state: "failed", conversationID: "", conversationType: "", message: error instanceof Error ? error.message : String(error), fullyReconciled: false });
   }
-  const timeoutMs = typeof config.timeoutMs === "number" ? config.timeoutMs : 1e4;
-  return client_default.request(config.path, config.data, timeoutMs);
+  const results = [];
+  for (const conversation of known.values()) {
+    if (!isCurrentStorage(ctx)) {
+      failures.push({ ...conversation, message: "Local storage account changed" });
+      break;
+    }
+    try {
+      results.push(await syncConversationMessages(conversation));
+    } catch (error) {
+      failures.push({ ...conversation, message: error instanceof Error ? error.message : String(error) });
+    }
+  }
+  if (failures.length)
+    throw new LocalSyncError(results, failures);
+  return results;
 }
 
+// src/sdk/storage/index.ts
+var LocalStorageApis = { queryLocalMessages, queryFailedMessages, clearLocalMessages, getLocalStorageStatus, syncConversationMessages, syncLocalMessages };
+var storage_default = LocalStorageApis;
+
 // src/apis/SdkQueryConversationPostApi.ts
+var postSdkQueryConversationListApiRequest = (data) => {
+  return request({
+    path: "/sdk/queryConversationList",
+    method: "POST",
+    data
+  });
+};
 var postSdkQueryConversationApiRequest = (data) => {
   return request({
     path: "/sdk/queryConversation",
@@ -469,11 +2372,24 @@ var postSdkClearConversationUnreadMessageCountApiRequest = (data) => {
   });
 };
 
-// src/sdk/conversation.ts
-async function queryConversation(payload) {
-  const response = await postSdkQueryConversationApiRequest(payload);
+// src/sdk/conversation/conversation.ts
+function isConversationQueriedResult(value) {
+  return !!value && typeof value === "object" && "conversation" in value;
+}
+async function queryConversationList(payload) {
+  const response = await postSdkQueryConversationListApiRequest(
+    payload
+  );
   return unwrapSdkData(response) ?? [];
 }
+async function queryConversation(conversationID, conversationType) {
+  const response = await postSdkQueryConversationApiRequest({
+    conversationID,
+    conversationType
+  });
+  const data = unwrapSdkData(response);
+  return isConversationQueriedResult(data) ? data : { conversation: data };
+}
 async function deleteAllConversations() {
   const response = await postSdkDeleteAllConversationsApiRequest(
     { config: true }
@@ -500,20 +2416,131 @@ async function clearConversationUnreadMessageCount(conversationID, conversationT
   return unwrapSdkResponse(response);
 }
 
+// src/constants/call/ZIMCall.ts
+var ZIMCallType = /* @__PURE__ */ ((ZIMCallType2) => {
+  ZIMCallType2["Audio"] = "audio";
+  ZIMCallType2["Video"] = "video";
+  return ZIMCallType2;
+})(ZIMCallType || {});
+var ZIMCallMode = /* @__PURE__ */ ((ZIMCallMode2) => {
+  ZIMCallMode2["OneOnOne"] = "one_on_one";
+  ZIMCallMode2["Group"] = "group";
+  return ZIMCallMode2;
+})(ZIMCallMode || {});
+var ZIMCallConversationType = /* @__PURE__ */ ((ZIMCallConversationType2) => {
+  ZIMCallConversationType2[ZIMCallConversationType2["Peer"] = 0] = "Peer";
+  ZIMCallConversationType2[ZIMCallConversationType2["Group"] = 1] = "Group";
+  return ZIMCallConversationType2;
+})(ZIMCallConversationType || {});
+var ZIMCallAction = /* @__PURE__ */ ((ZIMCallAction2) => {
+  ZIMCallAction2["Invite"] = "invite";
+  ZIMCallAction2["Accept"] = "accept";
+  ZIMCallAction2["Reject"] = "reject";
+  ZIMCallAction2["Cancel"] = "cancel";
+  ZIMCallAction2["Hangup"] = "hangup";
+  ZIMCallAction2["Timeout"] = "timeout";
+  ZIMCallAction2["MemberJoined"] = "member_joined";
+  ZIMCallAction2["MemberLeft"] = "member_left";
+  ZIMCallAction2["MediaStateChanged"] = "media_state_changed";
+  return ZIMCallAction2;
+})(ZIMCallAction || {});
+var ZIMCallEventEnum = /* @__PURE__ */ ((ZIMCallEventEnum2) => {
+  ZIMCallEventEnum2["CallInvitationReceived"] = "callInvitationReceived";
+  ZIMCallEventEnum2["CallAccepted"] = "callAccepted";
+  ZIMCallEventEnum2["CallRejected"] = "callRejected";
+  ZIMCallEventEnum2["CallCanceled"] = "callCanceled";
+  ZIMCallEventEnum2["CallEnded"] = "callEnded";
+  ZIMCallEventEnum2["CallTimeout"] = "callTimeout";
+  ZIMCallEventEnum2["CallParticipantJoined"] = "callParticipantJoined";
+  ZIMCallEventEnum2["CallParticipantLeft"] = "callParticipantLeft";
+  ZIMCallEventEnum2["CallMediaStateChanged"] = "callMediaStateChanged";
+  ZIMCallEventEnum2["CallConnectionStateChanged"] = "callConnectionStateChanged";
+  ZIMCallEventEnum2["CallMediaTrackSubscribed"] = "callMediaTrackSubscribed";
+  ZIMCallEventEnum2["CallMediaTrackUnsubscribed"] = "callMediaTrackUnsubscribed";
+  return ZIMCallEventEnum2;
+})(ZIMCallEventEnum || {});
+var ZIM_LOCAL_CALL_EVENTS = /* @__PURE__ */ new Set([
+  "callMediaStateChanged" /* CallMediaStateChanged */,
+  "callConnectionStateChanged" /* CallConnectionStateChanged */,
+  "callMediaTrackSubscribed" /* CallMediaTrackSubscribed */,
+  "callMediaTrackUnsubscribed" /* CallMediaTrackUnsubscribed */
+]);
+
+// src/sdk/call/callEvents.ts
+var listeners3 = /* @__PURE__ */ new Map();
+function onCallEvent(event, handler) {
+  const handlers = listeners3.get(event) || /* @__PURE__ */ new Set();
+  handlers.add(handler);
+  listeners3.set(event, handlers);
+}
+function offCallEvent(event, handler) {
+  if (!handler) {
+    listeners3.delete(event);
+    return;
+  }
+  const handlers = listeners3.get(event);
+  if (!handlers)
+    return;
+  handlers.delete(handler);
+  if (handlers.size === 0) {
+    listeners3.delete(event);
+  }
+}
+function emitCallEvent(event, ...args) {
+  listeners3.get(event)?.forEach((handler) => {
+    try {
+      const result = handler(...args);
+      if (result && typeof result.then === "function")
+        Promise.resolve(result).catch((error) => {
+          console.error("[VanshiSdk] async call event handler failed:", event, error);
+        });
+    } catch (error) {
+      console.error("[VanshiSdk] call event handler failed:", event, error);
+    }
+  });
+}
+
 // src/sdk/initSocket.ts
 async function initSocket() {
   const baseUrl = getSocketUrl();
-  if (!client_default.isConnected()) {
-    await client_default.connect(baseUrl);
+  try {
+    if (!client_default.isConnected()) {
+      await client_default.connect(baseUrl);
+    }
+  } catch (error) {
+    throwSdkTransportError(error, "socket connect failed");
   }
 }
+function disconnectSocket() {
+  client_default.disconnect();
+}
 function isSocketConnected() {
   return client_default.isConnected();
 }
+function resumeQueuedRequestsAfterLogin() {
+  client_default.resumeQueuedRequestsAfterLogin();
+}
+function rejectQueuedRequestsAfterLoginFailure(reason) {
+  client_default.rejectQueuedRequestsAfterLoginFailure(reason);
+}
 function on(event, handler) {
+  if (STORAGE_EVENTS.has(event)) {
+    onStorageEvent(event, handler);
+    return;
+  }
+  if (ZIM_LOCAL_CALL_EVENTS.has(event)) {
+    onCallEvent(event, handler);
+  }
   client_default.on(event, handler);
 }
 function off(event, handler) {
+  if (STORAGE_EVENTS.has(event)) {
+    offStorageEvent(event, handler);
+    return;
+  }
+  if (ZIM_LOCAL_CALL_EVENTS.has(event)) {
+    offCallEvent(event, handler);
+  }
   client_default.off(event, handler);
 }
 
@@ -534,14 +2561,21 @@ var postSdkLogoutApiRequest = (data) => {
 };
 
 // src/sdk/loginCore.ts
-async function performLogin(payload, { requestLogin, setSession = setSdkSession, clearSession = clearSdkSession }) {
+async function performLogin(payload, { requestLogin, setSession = setSdkSession, clearSession = clearSdkSession, isCurrent = () => true }) {
   try {
     const resp = await requestLogin(payload);
-    if (unwrapSdkData(resp)) {
+    if (!isCurrent())
+      return false;
+    const result = unwrapSdkDetailedData(resp);
+    if (!result.success)
+      throw new SdkRuntimeError(result).toObject();
+    if (result.data) {
       setSession(payload.token);
       return true;
     }
   } catch (error) {
+    if (!isCurrent())
+      return false;
     clearSession();
     throw error;
   }
@@ -549,28 +2583,685 @@ async function performLogin(payload, { requestLogin, setSession = setSdkSession,
   return false;
 }
 
+// src/sdk/call/callMedia.ts
+import {
+  Room,
+  RoomEvent,
+  Track,
+  createLocalAudioTrack,
+  createLocalScreenTracks,
+  createLocalVideoTrack
+} from "livekit-client";
+var DEFAULT_JOIN_MEDIA_CONFIG = {
+  audio: true,
+  video: true
+};
+var LiveKitCallMediaAdapter = class {
+  constructor() {
+    this.localTracks = [];
+    this.screenTracks = [];
+    this.generation = 0;
+    this.screenGeneration = 0;
+    this.controls = /* @__PURE__ */ new Map();
+    this.disconnecting = /* @__PURE__ */ new Set();
+  }
+  assertRoom(room, generation3) {
+    if (this.room !== room || this.generation !== generation3)
+      throw new Error("Media operation canceled");
+  }
+  stopTracks(tracks) {
+    for (const track of tracks) {
+      try {
+        track.stop();
+      } catch {
+      }
+      try {
+        track.detach();
+      } catch {
+      }
+    }
+  }
+  async releaseRoom() {
+    const room = this.room;
+    this.room = void 0;
+    this.callID = void 0;
+    this.stopTracks([...this.localTracks, ...this.screenTracks]);
+    this.localTracks = [];
+    this.screenTracks = [];
+    this.controls.clear();
+    if (room) {
+      room.removeAllListeners();
+      const completion = Promise.resolve(room.disconnect());
+      this.disconnecting.add(completion);
+      try {
+        await completion;
+      } finally {
+        this.disconnecting.delete(completion);
+      }
+    }
+    await Promise.all([...this.disconnecting]);
+  }
+  control(key, operation) {
+    const previous = this.controls.get(key) || Promise.resolve();
+    const result = previous.catch(() => {
+    }).then(operation);
+    this.controls.set(key, result);
+    void result.finally(() => {
+      if (this.controls.get(key) === result)
+        this.controls.delete(key);
+    }).catch(() => {
+    });
+    return result;
+  }
+  async joinMedia(config, connectOptions) {
+    const generation3 = ++this.generation;
+    this.screenGeneration++;
+    await this.releaseRoom();
+    if (generation3 !== this.generation)
+      throw new Error("Media operation canceled");
+    const liveKit = normalizeLiveKitInfo(config);
+    if (!liveKit.token) {
+      throwSdkRuntimeError({
+        message: "LiveKit token is required",
+        raw: config
+      });
+    }
+    const liveKitUrl = liveKit.livekitUrl || liveKit.liveKitUrl || config.livekitUrl || config.liveKitUrl;
+    if (!liveKitUrl) {
+      throwSdkRuntimeError({
+        message: "LiveKit URL is required",
+        raw: config
+      });
+    }
+    const room = new Room({
+      adaptiveStream: true,
+      dynacast: true
+    });
+    this.callID = config.callID;
+    this.room = room;
+    this.bindRoomEvents(room);
+    try {
+      await room.connect(liveKitUrl, liveKit.token, connectOptions);
+      this.assertRoom(room, generation3);
+      await this.publishInitialTracks(config, room, generation3);
+      this.assertRoom(room, generation3);
+      return { callID: config.callID, room, localTracks: [...this.localTracks] };
+    } catch (error) {
+      try {
+        if (this.room === room && this.generation === generation3)
+          await this.leaveMedia();
+        else {
+          room.removeAllListeners();
+          await room.disconnect();
+        }
+      } catch {
+      }
+      throw error;
+    }
+  }
+  async leaveMedia() {
+    this.generation++;
+    this.screenGeneration++;
+    await this.releaseRoom();
+  }
+  getRoom() {
+    return this.room;
+  }
+  getLocalTracks() {
+    return [...this.localTracks];
+  }
+  getMediaState() {
+    return {
+      microphoneEnabled: this.localTracks.some((track) => track.kind === Track.Kind.Audio && !track.isMuted),
+      cameraEnabled: this.localTracks.some((track) => track.kind === Track.Kind.Video && track.source !== Track.Source.ScreenShare && !track.isMuted),
+      screenShareEnabled: this.screenTracks.length > 0
+    };
+  }
+  setMicrophoneEnabled(enabled) {
+    return this.setDeviceEnabled("microphone", enabled);
+  }
+  setCameraEnabled(enabled) {
+    return this.setDeviceEnabled("camera", enabled);
+  }
+  setDeviceEnabled(device, enabled) {
+    const room = this.room;
+    const generation3 = this.generation;
+    return this.control(device, async () => {
+      if (!room)
+        throw new Error("LiveKit room is not joined");
+      this.assertRoom(room, generation3);
+      const kind = device === "microphone" ? Track.Kind.Audio : Track.Kind.Video;
+      let track = this.localTracks.find((item) => item.kind === kind && item.source !== Track.Source.ScreenShare);
+      if (!track && enabled) {
+        track = await this.acquireTrack(device === "microphone" ? createLocalAudioTrack : createLocalVideoTrack, room, generation3);
+      }
+      if (track)
+        await setLocalTrackEnabled(track, enabled);
+      this.assertRoom(room, generation3);
+      return this.emitMediaState();
+    });
+  }
+  startScreenShare() {
+    const room = this.room;
+    const generation3 = this.generation;
+    const screenGeneration = this.screenGeneration;
+    return this.control("screen", async () => {
+      if (!room)
+        throw new Error("LiveKit room is not joined");
+      this.assertRoom(room, generation3);
+      if (this.screenTracks.length)
+        return { tracks: [...this.screenTracks] };
+      let tracks = [];
+      const assertActive = () => {
+        this.assertRoom(room, generation3);
+        if (screenGeneration !== this.screenGeneration)
+          throw new Error("Screen share canceled");
+      };
+      try {
+        assertActive();
+        tracks = await createLocalScreenTracks({ audio: true, video: true });
+        assertActive();
+        this.screenTracks = tracks;
+        for (const track of tracks) {
+          await room.localParticipant.publishTrack(track);
+          assertActive();
+        }
+        this.emitMediaState();
+        return { tracks: [...tracks] };
+      } catch (error) {
+        this.stopTracks(tracks);
+        await Promise.allSettled(tracks.map((track) => room.localParticipant.unpublishTrack(track)));
+        if (this.room === room)
+          this.screenTracks = this.screenTracks.filter((track) => !tracks.includes(track));
+        throw error;
+      }
+    });
+  }
+  async stopScreenShare() {
+    this.screenGeneration++;
+    const room = this.room;
+    const tracks = this.screenTracks;
+    this.screenTracks = [];
+    this.stopTracks(tracks);
+    await Promise.all(tracks.map((track) => room?.localParticipant.unpublishTrack(track)));
+    return this.emitMediaState();
+  }
+  bindRoomEvents(room) {
+    room.on(RoomEvent.ConnectionStateChanged, (state) => {
+      emitCallEvent("callConnectionStateChanged" /* CallConnectionStateChanged */, {
+        callID: this.callID,
+        state
+      });
+    }).on(RoomEvent.TrackSubscribed, (track, publication, participant) => {
+      emitCallEvent("callMediaTrackSubscribed" /* CallMediaTrackSubscribed */, {
+        callID: this.callID,
+        track,
+        publication,
+        participantID: participant.identity,
+        participantName: participant.name
+      });
+    }).on(RoomEvent.TrackUnsubscribed, (track, publication, participant) => {
+      emitCallEvent("callMediaTrackUnsubscribed" /* CallMediaTrackUnsubscribed */, {
+        callID: this.callID,
+        track,
+        publication,
+        participantID: participant.identity,
+        participantName: participant.name
+      });
+    });
+  }
+  async publishInitialTracks(config, room, generation3) {
+    const merged = { ...DEFAULT_JOIN_MEDIA_CONFIG, ...config };
+    const ensureTrack = (device) => this.control(device, async () => {
+      this.assertRoom(room, generation3);
+      const kind = device === "microphone" ? Track.Kind.Audio : Track.Kind.Video;
+      if (!this.localTracks.some((track) => track.kind === kind && track.source !== Track.Source.ScreenShare)) {
+        await this.acquireTrack(device === "microphone" ? createLocalAudioTrack : createLocalVideoTrack, room, generation3);
+      }
+    });
+    if (merged.audio)
+      await ensureTrack("microphone");
+    if (merged.video)
+      await ensureTrack("camera");
+    this.assertRoom(room, generation3);
+    this.emitMediaState();
+  }
+  async acquireTrack(create, room, generation3) {
+    this.assertRoom(room, generation3);
+    const track = await create();
+    try {
+      this.assertRoom(room, generation3);
+      this.localTracks.push(track);
+      await room.localParticipant.publishTrack(track);
+      this.assertRoom(room, generation3);
+      return track;
+    } catch (error) {
+      this.stopTracks([track]);
+      this.localTracks = this.localTracks.filter((item) => item !== track);
+      try {
+        await room.localParticipant.unpublishTrack(track);
+      } catch {
+      }
+      throw error;
+    }
+  }
+  emitMediaState() {
+    const state = this.getMediaState();
+    emitCallEvent("callMediaStateChanged" /* CallMediaStateChanged */, {
+      callID: this.callID,
+      ...state
+    });
+    return state;
+  }
+};
+function normalizeLiveKitInfo(config) {
+  return {
+    ...config.liveKit,
+    token: config.token || config.liveKit?.token || "",
+    livekitUrl: config.livekitUrl || config.liveKit?.livekitUrl,
+    liveKitUrl: config.liveKitUrl || config.liveKit?.liveKitUrl,
+    roomName: config.roomName || config.liveKit?.roomName
+  };
+}
+function setLocalTrackEnabled(track, enabled) {
+  return enabled ? track.unmute() : track.mute();
+}
+var liveKitCallMediaAdapter = new LiveKitCallMediaAdapter();
+onSessionInvalidated(() => {
+  void liveKitCallMediaAdapter.leaveMedia().catch((error) => console.error("[VanshiSdk] media cleanup failed:", error));
+});
+
+// src/sdk/call/call.ts
+var CALL_SOCKET_EVENTS = {
+  create: "call/create",
+  inviteMembers: "call/inviteMembers",
+  accept: "call/accept",
+  reject: "call/reject",
+  cancel: "call/cancel",
+  hangup: "call/hangup",
+  members: "call/members",
+  token: "call/token",
+  hasOngoingCall: "call/hasOngoingCall"
+};
+function callInvite(config) {
+  const conversationType = normalizeCallConversationType(
+    config.conversationType
+  );
+  return callRequest(CALL_SOCKET_EVENTS.create, {
+    conversationID: config.conversationID,
+    conversationType,
+    invitees: config.invitees,
+    callType: config.callType,
+    mode: config.mode || (conversationType === 1 /* Group */ ? "group" /* Group */ : "one_on_one" /* OneOnOne */),
+    ...config.timeout !== void 0 ? { timeout: config.timeout } : {},
+    ...config.extendedData !== void 0 ? { extendedData: config.extendedData } : {}
+  });
+}
+function callInviteMembers(params) {
+  return callRequest(CALL_SOCKET_EVENTS.inviteMembers, {
+    ...getCallBasePayload(params),
+    invitees: params.invitees
+  });
+}
+function callAccept(params) {
+  return callRequest(
+    CALL_SOCKET_EVENTS.accept,
+    getCallBasePayload(params)
+  );
+}
+function callReject(params) {
+  return callRequest(
+    CALL_SOCKET_EVENTS.reject,
+    getCallBasePayload(params)
+  );
+}
+function callCancel(params) {
+  return callRequest(
+    CALL_SOCKET_EVENTS.cancel,
+    getCallBasePayload(params)
+  );
+}
+async function callHangup(params) {
+  try {
+    const result = await callRequest(
+      CALL_SOCKET_EVENTS.hangup,
+      getCallBasePayload(params)
+    );
+    await liveKitCallMediaAdapter.leaveMedia();
+    return result;
+  } catch (error) {
+    throwCallTransportError(error, "call hangup failed");
+  }
+}
+function callQueryMembers(params) {
+  return callRequest(
+    CALL_SOCKET_EVENTS.members,
+    getCallBasePayload(params)
+  );
+}
+function callHasOngoingCall(params) {
+  return callRequest(CALL_SOCKET_EVENTS.hasOngoingCall, {
+    groupId: params.groupId
+  });
+}
+function callGetLiveKitToken(params) {
+  return callRequest(CALL_SOCKET_EVENTS.token, {
+    ...getCallBasePayload(params),
+    ...params.roomName !== void 0 ? { roomName: params.roomName } : {}
+  });
+}
+async function callJoinMedia(config, connectOptions) {
+  const session = captureSession();
+  try {
+    const liveKit = hasLiveKitToken(config) ? {
+      ...config.liveKit,
+      token: config.token || config.liveKit?.token || "",
+      livekitUrl: config.livekitUrl || config.liveKit?.livekitUrl,
+      liveKitUrl: config.liveKitUrl || config.liveKit?.liveKitUrl,
+      roomName: config.roomName || config.liveKit?.roomName
+    } : await callGetLiveKitToken(config);
+    assertCurrentSession(session);
+    return await liveKitCallMediaAdapter.joinMedia(
+      { ...config, liveKit },
+      connectOptions
+    );
+  } catch (error) {
+    throwCallTransportError(error, "call media join failed");
+  }
+}
+async function callLeaveMedia() {
+  try {
+    await liveKitCallMediaAdapter.leaveMedia();
+  } catch (error) {
+    throwCallTransportError(error, "call media leave failed");
+  }
+}
+async function callSetMicrophoneEnabled(enabled) {
+  try {
+    return await liveKitCallMediaAdapter.setMicrophoneEnabled(enabled);
+  } catch (error) {
+    throwCallTransportError(error, "microphone state update failed");
+  }
+}
+async function callSetCameraEnabled(enabled) {
+  try {
+    return await liveKitCallMediaAdapter.setCameraEnabled(enabled);
+  } catch (error) {
+    throwCallTransportError(error, "camera state update failed");
+  }
+}
+async function callStartScreenShare() {
+  try {
+    return await liveKitCallMediaAdapter.startScreenShare();
+  } catch (error) {
+    throwCallTransportError(error, "screen share start failed");
+  }
+}
+async function callStopScreenShare() {
+  try {
+    return await liveKitCallMediaAdapter.stopScreenShare();
+  } catch (error) {
+    throwCallTransportError(error, "screen share stop failed");
+  }
+}
+function callGetMediaState() {
+  return liveKitCallMediaAdapter.getMediaState();
+}
+function callGetRoom() {
+  return liveKitCallMediaAdapter.getRoom();
+}
+function hasLiveKitToken(config) {
+  return Boolean(config.liveKit?.token || config.token);
+}
+function normalizeCallConversationType(conversationType) {
+  return Number(conversationType) === 2 ? 1 /* Group */ : Number(conversationType);
+}
+function getCallBasePayload(params) {
+  return {
+    callID: params.callID,
+    ...params.extendedData !== void 0 ? { extendedData: params.extendedData } : {}
+  };
+}
+async function callRequest(event, payload) {
+  try {
+    return unwrapSdkData(
+      await request({
+        path: `/sdk/${event}`,
+        method: "POST",
+        data: payload
+      })
+    );
+  } catch (error) {
+    throwCallTransportError(error);
+  }
+}
+function throwCallTransportError(error, fallbackMessage = "call request failed") {
+  if (isSdkRuntimeErrorObject(error)) {
+    throw error;
+  }
+  throwSdkTransportError(error, fallbackMessage);
+}
+var call_default = {
+  callInvite,
+  callInviteMembers,
+  callAccept,
+  callReject,
+  callCancel,
+  callHangup,
+  callQueryMembers,
+  callHasOngoingCall,
+  callGetLiveKitToken,
+  callJoinMedia,
+  callLeaveMedia,
+  callSetMicrophoneEnabled,
+  callSetCameraEnabled,
+  callStartScreenShare,
+  callStopScreenShare,
+  callGetMediaState,
+  callGetRoom
+};
+
 // src/sdk/login.ts
-async function login(payload) {
+async function loginInternal(payload, session) {
   return performLogin(payload, {
-    requestLogin: postSdkLoginApiRequest
+    requestLogin: postSdkLoginApiRequest,
+    isCurrent: () => isCurrentSession(session),
+    clearSession: () => {
+    }
   });
 }
-registerReconnectLoginHandler((token) => login({ token }));
-async function logout(disconnect = true) {
-  let success = false;
+async function login(payload) {
+  clearSdkSession();
+  const attempt = beginAuthentication();
+  setSdkUserID(payload.userID || payload.userId);
+  if (payload.userId?.trim())
+    beginLoginMessageBuffer(attempt);
   try {
-    const resp = await postSdkLogoutApiRequest(
-      {}
-    );
-    let res = JSON.parse(resp);
-    const result = unwrapSdkData(res);
-    success = Boolean(result) || isSuccessCode(res.code);
-  } catch {
-    success = false;
-  } finally {
+    const success = await loginInternal({ token: payload.token }, attempt);
+    if (!isCurrentSession(attempt))
+      return false;
+    if (!success) {
+      clearSdkSession();
+      rejectQueuedRequestsAfterLoginFailure();
+      return false;
+    }
+    if (payload.userId?.trim()) {
+      await openLocalStorage(payload.userId.trim(), JSON.stringify([getSocketUrl(), getUploadUrl()]));
+      if (!isCurrentSession(attempt))
+        return false;
+      await flushLoginMessageBuffer(attempt);
+    }
+    if (!isCurrentSession(attempt))
+      return false;
+    finishAuthentication(attempt);
+    resumeQueuedRequestsAfterLogin();
+    return true;
+  } catch (error) {
+    if (!isCurrentSession(attempt))
+      return false;
     clearSdkSession();
+    rejectQueuedRequestsAfterLoginFailure(error);
+    throw error;
+  } finally {
+    discardLoginMessageBuffer(attempt);
+    finishAuthentication(attempt);
   }
-  return success;
+}
+registerReconnectLoginHandler((token) => loginInternal({ token }, captureSession()));
+function isLogoutFinalizationError(error) {
+  const message = getSdkErrorMessageFromUnknown(error, "");
+  const code = getSdkErrorCode(error);
+  return code === 3 || code === "3" || code === 4 || code === "4" || code === 303 || code === "303" || /ack timeout|request timeout|socket not connected|socket not initialized|disconnected|client disconnected|connect timeout|reconnect failed|restore login failed|socket operation queue is full|认证失败|token验证失败/i.test(message);
+}
+async function logout(disconnect = false) {
+  clearSdkSession();
+  const attempt = captureSession();
+  try {
+    try {
+      await callLeaveMedia();
+    } catch (error) {
+      console.error("[VanshiSdk] leave media during logout failed:", error);
+    }
+    if (!isCurrentSession(attempt))
+      return false;
+    const response = await postSdkLogoutApiRequest({});
+    if (!isCurrentSession(attempt))
+      return false;
+    const result = unwrapSdkResponse(response);
+    return Boolean(result.data) || isSuccessCode(result.code);
+  } catch (error) {
+    if (!isCurrentSession(attempt))
+      return false;
+    if (isLogoutFinalizationError(error)) {
+      return false;
+    }
+    throw error;
+  } finally {
+    if (isCurrentSession(attempt)) {
+      clearSdkSession();
+      if (disconnect)
+        disconnectSocket();
+    }
+  }
+}
+
+// src/sdk/storage/history.ts
+import Dexie2 from "dexie";
+async function mergeHistoryWithLocalMessages(ctx, query, result) {
+  if (!Array.isArray(result?.messageList))
+    return result;
+  if (!ctx)
+    return filterInvalidReplyMessages(result);
+  if (!isCurrentStorage(ctx))
+    throw new Error("Local storage account changed during history query");
+  await ctx.pending;
+  const merged = await storageWork(ctx, async (ctx2) => {
+    const key = conversationKey(query.conversationID, query.conversationType);
+    return ctx2.db.transaction("r", ctx2.db.messages, async () => {
+      const serverIDs = result.messageList.filter((row) => row.messageID).map((row) => [key, String(row.messageID)]);
+      const clientIDs = result.messageList.filter((row) => row.clientBizId).map((row) => [key, String(row.clientBizId)]);
+      const rowsByID = /* @__PURE__ */ new Map();
+      const include = (rows2) => rows2.forEach((row) => rowsByID.set(row.localID, row));
+      if (serverIDs.length)
+        include(await ctx2.db.messages.where("[conversationKey+messageID]").anyOf(serverIDs).toArray());
+      if (clientIDs.length)
+        include(await ctx2.db.messages.where("[conversationKey+clientBizId]").anyOf(clientIDs).toArray());
+      if (!query.config?.nextMessage) {
+        const timestamps = result.messageList.map((row) => Number(row.timestamp)).filter(Number.isFinite);
+        const oldest = timestamps.reduce((min, value) => Math.min(min, value), Infinity);
+        include(await ctx2.db.messages.where("[conversationKey+timestamp]").between([key, timestamps.length ? oldest : Dexie2.minKey], [key, Dexie2.maxKey], true, true).toArray());
+        include(await ctx2.db.messages.where("[conversationKey+sendState]").anyOf([[key, 0], [key, 2]]).toArray());
+        include(await ctx2.db.messages.where("[conversationKey+hasServerID]").equals([key, 0]).toArray());
+      }
+      const rows = [...rowsByID.values()];
+      const byServer = new Map(rows.filter((row) => row.messageID).map((row) => [String(row.messageID), row]));
+      const byClient = new Map(rows.filter((row) => row.clientBizId).map((row) => [String(row.clientBizId), row]));
+      const included = /* @__PURE__ */ new Set();
+      const messageList = [];
+      const add = (message) => {
+        const identities = [
+          message.localID && `local:${message.localID}`,
+          message.messageID && `server:${message.messageID}`,
+          message.clientBizId && `client:${message.clientBizId}`
+        ].filter(Boolean);
+        if (identities.some((id) => included.has(id)))
+          return;
+        identities.forEach((id) => included.add(id));
+        messageList.push(message);
+      };
+      const first = Number(result.messageList[0]?.timestamp);
+      const last = Number(result.messageList[result.messageList.length - 1]?.timestamp);
+      const descending = Number.isFinite(first) && Number.isFinite(last) && first !== last ? first > last : query.config?.reverse !== false;
+      for (const message of result.messageList) {
+        const client = byClient.get(String(message.clientBizId));
+        const local = byServer.get(String(message.messageID)) || (client && (!message.messageID || !client.messageID || String(message.messageID) === client.messageID) ? client : void 0);
+        if (local?.deleted)
+          continue;
+        if (isSelfReferencingReply(message)) {
+          if (local)
+            add(displayMessage(local));
+          continue;
+        }
+        if (local?.revoked) {
+          add(displayMessage(local));
+          continue;
+        }
+        add(local ? { ...message, ...displayMessage(local) } : message);
+      }
+      if (!query.config?.nextMessage) {
+        const timestamps = result.messageList.map((message) => Number(message.timestamp)).filter(Number.isFinite);
+        const oldest = timestamps.reduce((min, timestamp) => Math.min(min, timestamp), Infinity);
+        for (const row of rows) {
+          if (!row.deleted && (row.sendState !== 1 || !row.messageID || !timestamps.length || row.timestamp >= oldest))
+            add(displayMessage(row));
+        }
+      }
+      messageList.sort((a, b) => {
+        const timeA = Number(a.timestamp) || 0;
+        const timeB = Number(b.timestamp) || 0;
+        const keyA = String(a.localID || a.messageID || a.clientBizId || "");
+        const keyB = String(b.localID || b.messageID || b.clientBizId || "");
+        return (descending ? -1 : 1) * (timeA - timeB || compareOrderKey(a.orderKey, b.orderKey) || keyA.localeCompare(keyB));
+      });
+      return { ...result, messageList };
+    });
+  });
+  if (!isCurrentStorage(ctx))
+    throw new Error("Local storage account changed during history query");
+  return merged || filterInvalidReplyMessages(result);
+}
+function compareOrderKey(a, b) {
+  const validA = /^\d+$/.test(String(a));
+  const validB = /^\d+$/.test(String(b));
+  if (validA !== validB)
+    return validA ? -1 : 1;
+  if (!validA)
+    return 0;
+  const left = String(a).replace(/^0+(?=\d)/, "");
+  const right = String(b).replace(/^0+(?=\d)/, "");
+  return left.length - right.length || (left < right ? -1 : left > right ? 1 : 0);
+}
+function displayMessage(row) {
+  const { _mutationAt, _mutationEpoch, _contentSequence, _receiptSequence, _sendSequence, _sendEpoch, ...message } = row;
+  return {
+    ...restoreMediaPreviews(message),
+    localMessageID: row.localMessageID || row.localID,
+    messageID: row.messageID || "",
+    clientBizId: row.clientBizId || "",
+    message: row.message ?? row.massage ?? "",
+    massage: row.massage ?? row.message ?? "",
+    sentStatus: row.sentStatus ?? row.sendState
+  };
+}
+
+// src/sdk/message/clientBizId.ts
+var sequence = 0;
+function withClientBizId(message) {
+  sequence = (sequence + 1) % 1e6;
+  return {
+    ...message,
+    clientBizId: message.clientBizId || `cbiz_${Date.now()}_${sequence.toString(36)}_${Math.random().toString(36).slice(2, 10)}`
+  };
 }
 
 // src/apis/SdkSendMessagePostApi.ts
@@ -646,7 +3337,6 @@ var getVideoDurationAndFirstFrame = (file) => {
     video.onloadedmetadata = () => {
       canvas.width = video.videoWidth || 640;
       canvas.height = video.videoHeight || 360;
-      window.URL.revokeObjectURL(video.src);
       duration = video?.duration;
       videoWidth = video.videoWidth || 640;
       videoHeight = video.videoHeight || 360;
@@ -707,6 +3397,24 @@ function getAudioDuration(file) {
   });
 }
 
+// src/constants/messages/Message.ts
+var SEDMessageType = /* @__PURE__ */ ((SEDMessageType2) => {
+  SEDMessageType2["Unknown"] = "0";
+  SEDMessageType2["Command"] = "2";
+  SEDMessageType2["Barrage"] = "20";
+  SEDMessageType2["Text"] = "1";
+  SEDMessageType2["Image"] = "11";
+  SEDMessageType2["File"] = "12";
+  SEDMessageType2["Audio"] = "13";
+  SEDMessageType2["Video"] = "14";
+  SEDMessageType2["System"] = "30";
+  SEDMessageType2["Revoke"] = "31";
+  SEDMessageType2["Tips"] = "32";
+  SEDMessageType2["Combine"] = "100";
+  SEDMessageType2["Custom"] = "200";
+  return SEDMessageType2;
+})(SEDMessageType || {});
+
 // src/apis/SdkDeleteAllMessagePostApi.ts
 var postSdkDeleteAllMessageApiRequest = (data) => {
   return request({
@@ -716,28 +3424,78 @@ var postSdkDeleteAllMessageApiRequest = (data) => {
   });
 };
 
-// src/sdk/message.ts
-var clientBizIdSeq = 0;
+// src/sdk/message/message.ts
 var MAX_FILE_NAME_LENGTH = 20;
-function generateClientBizId() {
-  clientBizIdSeq = (clientBizIdSeq + 1) % 1e6;
-  const timestamp = Date.now();
-  const sequence = clientBizIdSeq.toString(36);
-  const random = Math.random().toString(36).slice(2, 10);
-  return `cbiz_${timestamp}_${sequence}_${random}`;
-}
-function withClientBizId(message) {
-  return {
-    ...message,
-    clientBizId: message.clientBizId || generateClientBizId()
-  };
+function sliceChars(value, length) {
+  return Array.from(value).slice(0, length).join("");
 }
 function truncateFileName(fileName) {
-  return fileName.length > MAX_FILE_NAME_LENGTH ? fileName.slice(0, MAX_FILE_NAME_LENGTH) : fileName;
+  const lastDotIndex = fileName.lastIndexOf(".");
+  const hasExtension = lastDotIndex > 0 && lastDotIndex < fileName.length - 1;
+  if (!hasExtension) {
+    return sliceChars(fileName, MAX_FILE_NAME_LENGTH);
+  }
+  const baseName = fileName.slice(0, lastDotIndex);
+  const extension = fileName.slice(lastDotIndex);
+  return `${sliceChars(baseName, MAX_FILE_NAME_LENGTH)}${extension}`;
 }
 function getDisplayFileName(file, fallback = "") {
   return truncateFileName(file?.name || fallback || "");
 }
+function appendUploadFile(formData, file, fileName) {
+  const uploadFileName = getDisplayFileName(file, fileName);
+  if (uploadFileName) {
+    formData.append("file", file, uploadFileName);
+    return;
+  }
+  formData.append("file", file);
+}
+function assertMediaFileHasContent(file, fileName) {
+  if (!file || typeof file.size !== "number" || file.size <= 0) {
+    throwSdkRuntimeError({
+      code: 2,
+      message: "media message file is empty",
+      raw: {
+        fileName: fileName || file?.name || "",
+        fileSize: file?.size ?? 0,
+        fileType: file?.type || ""
+      }
+    });
+  }
+}
+function debugUploadFile(file, fileName) {
+  if (typeof window !== "undefined" && window.__VANSHI_SDK_DEBUG__) {
+    console.debug("[VanshiSdk] uploading media file", {
+      fileName: fileName || file?.name || "",
+      fileSize: file.size,
+      fileType: file.type || ""
+    });
+  }
+}
+async function createUploadBlob(file, fileName) {
+  assertMediaFileHasContent(file, fileName);
+  let bytes;
+  try {
+    bytes = await file.arrayBuffer();
+  } catch (error) {
+    throwSdkTransportError(error, "media message file cannot be read");
+  }
+  if (bytes.byteLength <= 0) {
+    throwSdkRuntimeError({
+      code: 2,
+      message: "media message file is empty",
+      raw: {
+        fileName: fileName || file?.name || "",
+        fileSize: file.size,
+        readSize: bytes.byteLength,
+        fileType: file.type || ""
+      }
+    });
+  }
+  return new Blob([bytes], {
+    type: file.type || "application/octet-stream"
+  });
+}
 function createLocalMediaMessage(message, toConversationID, conversationType) {
   const file = message.file;
   const localPreviewUrl = file && typeof URL !== "undefined" && URL.createObjectURL ? URL.createObjectURL(file) : void 0;
@@ -753,9 +3511,10 @@ function createLocalMediaMessage(message, toConversationID, conversationType) {
     clientBizId: message.clientBizId,
     conversationID: toConversationID,
     conversationType,
-    senderUserID: "",
+    senderUserID: getSdkUserID(),
     direction: 0,
     sentStatus: 0,
+    sendState: 0,
     timestamp: Date.now(),
     receiptStatus: 0,
     isServerMessage: false,
@@ -766,13 +3525,38 @@ function createLocalMediaMessage(message, toConversationID, conversationType) {
     fileName: getDisplayFileName(file, message.fileName),
     fileSize: file ? String(file.size) : message.fileSize || "",
     fileDownloadUrl: message.fileDownloadUrl || localPreviewUrl || "",
-    thumbnailDownloadUrl: message.thumbnailDownloadUrl || localPreviewUrl || "",
+    thumbnailDownloadUrl: message.thumbnailDownloadUrl || (isSameUid(message.type, "11" /* Image */) ? localPreviewUrl : "") || "",
     thumbnailWidth: message.thumbnailWidth || "",
     thumbnailHeight: message.thumbnailHeight || "",
     duration: message.duration || "",
     localPreviewUrl
   };
 }
+function createLocalTextMessage(message, toConversationID, conversationType) {
+  return {
+    massage: message.message,
+    message: message.message,
+    type: message.type,
+    extendedData: message.extendedData,
+    messageID: "",
+    orderKey: "",
+    clientSid: "",
+    localMessageID: message.clientBizId,
+    clientBizId: message.clientBizId,
+    conversationID: toConversationID,
+    conversationType,
+    senderUserID: "",
+    direction: 0,
+    sentStatus: 0,
+    sendState: 0,
+    timestamp: String(Date.now()),
+    receiptStatus: 0,
+    isServerMessage: false,
+    isBroadcastMessage: false,
+    isGroupTargetedMessage: "",
+    id: ""
+  };
+}
 async function getImageSize(file) {
   return new Promise((resolve, reject) => {
     const url = URL.createObjectURL(file);
@@ -792,37 +3576,65 @@ async function getImageSize(file) {
   });
 }
 async function uploadSdkFile(file, fileName) {
+  const session = captureSession();
+  const storage = captureStorage();
+  const uploadFile = await createUploadBlob(file, fileName);
+  const uploadFileName = getDisplayFileName(file, fileName) || "file";
+  debugUploadFile(uploadFile, uploadFileName);
   const formData = new FormData();
-  const uploadFileName = truncateFileName(fileName || file.name || "");
-  if (uploadFileName) {
-    formData.append("file", file, uploadFileName);
-  } else {
-    formData.append("file", file);
-  }
-  const response = await fetch(getUploadUrl(), {
-    method: "POST",
-    headers: {
-      Authorization: getStoredToken()
-    },
-    body: formData
-  });
-  if (!response.ok) {
-    throw new Error(`file upload failed: ${response.status}`);
+  appendUploadFile(formData, uploadFile, uploadFileName);
+  const formDataFile = formData.get("file");
+  if (formDataFile instanceof Blob) {
+    assertMediaFileHasContent(formDataFile, uploadFileName);
   }
-  const payload = await response.json();
-  if (payload.Code !== 0 && payload.Code !== "0") {
-    throw new Error(payload.Message || "file upload failed");
-  }
-  if (!payload.Result) {
-    throw new Error("file upload result is empty");
+  try {
+    assertCurrentSession(session);
+    if (storage && !isCurrentStorage(storage))
+      throw new Error("Local storage account changed before upload");
+    const response = await fetch(getUploadUrl(), {
+      method: "POST",
+      headers: {
+        Authorization: getStoredToken()
+      },
+      body: formData
+    });
+    assertCurrentSession(session);
+    if (!response.ok) {
+      throwSdkRuntimeError({
+        code: response.status,
+        message: `file upload failed: ${response.status}`,
+        raw: response
+      });
+    }
+    const payload = await response.json();
+    assertCurrentSession(session);
+    const result = assertSdkSuccess({
+      code: payload.Code,
+      message: payload.Message,
+      data: payload.Result || payload.data,
+      raw: payload
+    });
+    if (!result.data) {
+      throwSdkRuntimeError({
+        message: "file upload result is empty",
+        raw: payload
+      });
+    }
+    return result.data;
+  } catch (error) {
+    throwSdkTransportError(error, "file upload failed");
   }
-  return payload.Result;
 }
-async function enrichMediaMessage(message) {
+async function enrichMediaMessage(message, onVideoPrepared, assertSession = () => {
+}) {
   const file = message.file;
   if (!file) {
-    throw new Error("media message file is required");
+    throwSdkRuntimeError({
+      message: "media message file is required",
+      raw: message
+    });
   }
+  assertMediaFileHasContent(file, message.fileName);
   const enrichedMessage = {
     ...message,
     fileName: getDisplayFileName(file, message.fileName),
@@ -840,11 +3652,14 @@ async function enrichMediaMessage(message) {
     enrichedMessage.duration = String(res.duration);
     enrichedMessage.thumbnailWidth = String(res.videoWidth);
     enrichedMessage.thumbnailHeight = String(res.videoHeight);
+    await onVideoPrepared?.(res);
+    assertSession();
     enrichedMessage.thumbnailDownloadUrl = await uploadSdkFile(
       res.firstFrameFile,
       res.firstFrameFile.name
     );
   }
+  assertSession();
   const fileDownloadUrl = await uploadSdkFile(file, enrichedMessage.fileName);
   enrichedMessage.fileDownloadUrl = fileDownloadUrl;
   if (isSameUid(message.type, "11" /* Image */)) {
@@ -853,19 +3668,20 @@ async function enrichMediaMessage(message) {
   delete enrichedMessage.file;
   return enrichedMessage;
 }
-async function sendMessage(payload) {
-  const response = await postSdkSendMessageApiRequest({
-    ...payload,
-    message: withClientBizId(payload.message)
-  });
-  return unwrapSdkData(response);
-}
-async function sendMediaMessage(payload, options) {
+async function sendMessage(payload, options) {
+  const session = captureSession();
+  if (isAuthenticating())
+    await waitForAuthentication(session);
+  const storage = captureStorage();
   const messageWithClientBizId = withClientBizId(payload.message);
+  await persistOutgoing(storage, { ...payload, message: messageWithClientBizId });
+  if (storage && !isCurrentStorage(storage))
+    throw new Error("Local storage account changed before sending");
+  assertCurrentSession(session);
   if (options?.onMessageAttached) {
     try {
       options.onMessageAttached(
-        createLocalMediaMessage(
+        createLocalTextMessage(
           messageWithClientBizId,
           payload.toConversationID,
           payload.conversationType
@@ -874,15 +3690,77 @@ async function sendMediaMessage(payload, options) {
     } catch {
     }
   }
-  const response = await postSdkSendMediaMessageApiRequest({
+  assertCurrentSession(session);
+  const response = await postSdkSendMessageApiRequest({
     ...payload,
-    message: await enrichMediaMessage(messageWithClientBizId)
+    message: messageWithClientBizId
   });
-  return unwrapSdkData(response);
+  const result = unwrapSdkData(response);
+  return result ? {
+    ...result,
+    message: result.message || result.massage
+  } : result;
+}
+async function sendMediaMessage(payload, options) {
+  const session = captureSession();
+  if (isAuthenticating())
+    await waitForAuthentication(session);
+  const storage = captureStorage();
+  const messageWithClientBizId = withClientBizId(payload.message);
+  const localMessage = createLocalMediaMessage(messageWithClientBizId, payload.toConversationID, payload.conversationType);
+  await persistOutgoing(storage, { ...payload, message: localMessage });
+  const notify = () => {
+    assertCurrentSession(session);
+    if (storage && !isCurrentStorage(storage))
+      throw new Error("Local storage account changed during media preparation");
+    try {
+      options?.onMessageAttached?.({ ...localMessage });
+    } catch {
+    }
+  };
+  try {
+    notify();
+    const enriched = await enrichMediaMessage(messageWithClientBizId, async (video) => {
+      assertCurrentSession(session);
+      if (storage && !isCurrentStorage(storage))
+        throw new Error("Local storage account changed during media preparation");
+      Object.assign(localMessage, {
+        duration: String(video.duration),
+        thumbnailWidth: String(video.videoWidth),
+        thumbnailHeight: String(video.videoHeight),
+        thumbnailFile: video.firstFrameFile,
+        thumbnailDownloadUrl: URL.createObjectURL(video.firstFrameFile)
+      });
+      await persistOutgoing(storage, { ...payload, message: localMessage });
+      notify();
+    }, () => assertCurrentSession(session));
+    if (storage && !isCurrentStorage(storage))
+      throw new Error("Local storage account changed during media preparation");
+    assertCurrentSession(session);
+    const response = await postSdkSendMediaMessageApiRequest({
+      ...payload,
+      message: enriched
+    });
+    return unwrapSdkData(response);
+  } catch (error) {
+    await markSendError(storage, messageWithClientBizId.clientBizId, outgoingFallback(payload, storage), error);
+    if (isSdkRuntimeErrorObject(error)) {
+      throw error;
+    }
+    throwSdkTransportError(error, "send media message failed");
+  }
 }
 async function queryHistoryMessage(payload) {
+  const session = captureSession();
+  if (isAuthenticating())
+    await waitForAuthentication(session);
+  const storage = captureStorage();
   const response = await postSdkQueryHistoryMessageApiRequest(payload);
-  return unwrapSdkData(response);
+  assertCurrentSession(session);
+  const result = unwrapSdkData(response);
+  const merged = await mergeHistoryWithLocalMessages(storage, payload, result);
+  assertCurrentSession(session);
+  return merged;
 }
 async function deleteAllConversationMessages() {
   const response = await postSdkDeleteAllConversationMessagesApiRequest(
@@ -897,7 +3775,7 @@ async function deleteAllConversationMessages() {
 }
 async function deleteMessages(conversationID, conversationType, messageList) {
   const response = await postSdkDeleteMessagesApiRequest({
-    conversationID: Number(conversationID),
+    conversationID,
     conversationType: conversationType.toString(),
     messageList: messageList.map((msg) => ({
       messageID: msg.messageID,
@@ -912,11 +3790,20 @@ async function revokeMessage(message, config) {
 }
 async function deleteAllMessage(conversationID, conversationType) {
   const response = await postSdkDeleteAllMessageApiRequest({
-    conversationID: Number(conversationID),
+    conversationID,
     conversationType: conversationType.toString()
   });
   return unwrapSdkResponse(response);
 }
+var message_default = {
+  sendMessage,
+  sendMediaMessage,
+  queryHistoryMessage,
+  deleteAllConversationMessages,
+  deleteMessages,
+  revokeMessage,
+  deleteAllMessage
+};
 
 // src/apis/SdkQueryGroupMessageReceiptReadMemberListPostApi.ts
 var postSdkQueryGroupMessageReceiptReadMemberListApiRequest = (data) => {
@@ -954,7 +3841,7 @@ var postSdkSendMessageReceiptsReadApiRequest = (data) => {
   });
 };
 
-// src/sdk/messageReceipts.ts
+// src/sdk/message/messageReceipts.ts
 async function sendMessageReceiptsRead(conversationID, conversationType, messageList) {
   const response = await postSdkSendMessageReceiptsReadApiRequest({
     conversationID,
@@ -965,7 +3852,7 @@ async function sendMessageReceiptsRead(conversationID, conversationType, message
 }
 async function queryMessageReceiptsInfo(conversationID, conversationType, messageList) {
   const response = await postSdkQueryMessageReceiptsInfoApiRequest({
-    conversationID: Number(conversationID),
+    conversationID,
     conversationType: conversationType.toString(),
     messageList
   });
@@ -987,12 +3874,606 @@ async function queryGroupMessageReceiptReadMemberList(groupID, config, message)
   });
   return unwrapSdkResponse(response);
 }
+var messageReceipts_default = {
+  sendMessageReceiptsRead,
+  queryMessageReceiptsInfo,
+  queryGroupMessageReceiptUnreadMemberList,
+  queryGroupMessageReceiptReadMemberList
+};
+
+// src/sdk/message/index.ts
+var MessageIndexApis = {
+  ...message_default,
+  ...messageReceipts_default
+};
+
+// src/sdk/zimApiCore.ts
+function isFileLike(value) {
+  return typeof File !== "undefined" && value instanceof File;
+}
+function isBlobLike(value) {
+  return typeof Blob !== "undefined" && value instanceof Blob;
+}
+function normalizeSdkPayload(value, omitLocalMessageFiles = false) {
+  if (!value || typeof value !== "object") {
+    return value;
+  }
+  if (value instanceof Date || value instanceof ArrayBuffer || ArrayBuffer.isView(value) || isFileLike(value) || isBlobLike(value)) {
+    return value;
+  }
+  if (value instanceof Map) {
+    const entries = Object.fromEntries(value);
+    return omitLocalMessageFiles ? normalizeSdkPayload(entries, true) : entries;
+  }
+  if (Array.isArray(value)) {
+    return value.map((item) => normalizeSdkPayload(item, omitLocalMessageFiles));
+  }
+  const normalized = {};
+  Object.entries(value).forEach(([key, item]) => {
+    if (omitLocalMessageFiles && (["fileLocalPath", "file", "thumbnailFile", "localPreviewUrl", "localID", "conversationKey", "updatedAt", "errorCode", "errorMessage"].includes(key) || key.startsWith("_")))
+      return;
+    if (omitLocalMessageFiles && ["fileDownloadUrl", "thumbnailDownloadUrl"].includes(key) && typeof item === "string" && item.startsWith("blob:"))
+      return;
+    if (typeof item !== "function" && item !== void 0) {
+      normalized[key] = normalizeSdkPayload(item, omitLocalMessageFiles);
+    }
+  });
+  return normalized;
+}
+async function callSdkApi(method, payload = {}) {
+  const response = await request({
+    path: `/sdk/${method}`,
+    method: "POST",
+    data: normalizeSdkPayload(payload, method === "replyMessage")
+  });
+  return unwrapSdkData(response);
+}
+
+// src/sdk/social/blacklist.ts
+function addUsersToBlacklist(userIDs) {
+  return callSdkApi("addUsersToBlacklist", { userIDs });
+}
+function removeUsersFromBlacklist(userIDs) {
+  return callSdkApi("removeUsersFromBlacklist", { userIDs });
+}
+function queryBlacklist(config) {
+  return callSdkApi("queryBlacklist", { config });
+}
+function checkUserIsInBlacklist(userID) {
+  return callSdkApi("checkUserIsInBlacklist", { userID });
+}
+var blacklist_default = {
+  addUsersToBlacklist,
+  removeUsersFromBlacklist,
+  queryBlacklist,
+  checkUserIsInBlacklist
+};
+
+// src/sdk/social/friend.ts
+function sendFriendApplication(userID, config) {
+  return callSdkApi("sendFriendApplication", { userID, config });
+}
+function deleteFriends(userIDs, config) {
+  return callSdkApi("deleteFriends", { userIDs, config });
+}
+function updateFriendAlias(friendAlias, userID) {
+  return callSdkApi("updateFriendAlias", { friendAlias, userID });
+}
+function queryFriendApplicationList(config) {
+  return callSdkApi("queryFriendApplicationList", { config });
+}
+function acceptFriendApplication(userID, config) {
+  return callSdkApi("acceptFriendApplication", { userID, config });
+}
+function rejectFriendApplication(userID, config) {
+  return callSdkApi("rejectFriendApplication", { userID, config });
+}
+function queryFriendList(config) {
+  return callSdkApi("queryFriendList", { config });
+}
+function queryFriendsInfo(userIDs) {
+  return callSdkApi("queryFriendsInfo", { userIDs });
+}
+var friend_default = {
+  sendFriendApplication,
+  deleteFriends,
+  updateFriendAlias,
+  queryFriendApplicationList,
+  acceptFriendApplication,
+  rejectFriendApplication,
+  queryFriendList,
+  queryFriendsInfo
+};
+
+// src/sdk/social/user.ts
+function querySelfUserInfo() {
+  return callSdkApi("querySelfUserInfo");
+}
+async function renewToken(token) {
+  const session = captureSession();
+  const result = await callSdkApi("renewToken", {
+    token
+  });
+  assertCurrentSession(session);
+  setSdkSession(result?.token || token);
+  return result ?? { token };
+}
+function queryUsersInfo(userIDs, config) {
+  return callSdkApi("queryUsersInfo", { userIDs, config });
+}
+function queryUsersStatus(userIDs) {
+  return callSdkApi("queryUsersStatus", { userIDs });
+}
+function subscribeUsersStatus(userIDs, config) {
+  return callSdkApi("subscribeUsersStatus", { userIDs, config });
+}
+function unsubscribeUsersStatus(userIDs) {
+  return callSdkApi("unsubscribeUsersStatus", { userIDs });
+}
+function updateUserName(userName) {
+  return callSdkApi("updateUserName", { userName });
+}
+function updateUserAvatarUrl(userAvatarUrl) {
+  return callSdkApi("updateUserAvatarUrl", { userAvatarUrl });
+}
+var user_default = {
+  querySelfUserInfo,
+  renewToken,
+  queryUsersInfo,
+  queryUsersStatus,
+  subscribeUsersStatus,
+  unsubscribeUsersStatus,
+  updateUserName,
+  updateUserAvatarUrl
+};
+
+// src/sdk/social/index.ts
+var SocialApis = {
+  ...friend_default,
+  ...blacklist_default,
+  ...user_default
+};
+var social_default = SocialApis;
+
+// src/sdk/group/group.ts
+function createGroup(groupInfo, userIDs, config) {
+  return callSdkApi("createGroup", { groupInfo, userIDs, config });
+}
+function joinGroup(groupID) {
+  return callSdkApi("joinGroup", { groupID });
+}
+function leaveGroup(groupID) {
+  return callSdkApi("leaveGroup", { groupID });
+}
+function dismissGroup(groupID) {
+  return callSdkApi("dismissGroup", { groupID });
+}
+function kickGroupMembers(userIDs, groupID) {
+  return callSdkApi("kickGroupMembers", { userIDs, groupID });
+}
+function inviteUsersIntoGroup(userIDs, groupID) {
+  return callSdkApi("inviteUsersIntoGroup", { userIDs, groupID });
+}
+function transferGroupOwner(toUserID, groupID) {
+  return callSdkApi("transferGroupOwner", { toUserID, groupID });
+}
+function updateGroupAlias(groupAlias, groupID) {
+  return callSdkApi("updateGroupAlias", { groupAlias, groupID });
+}
+function updateGroupName(groupName, groupID) {
+  return callSdkApi("updateGroupName", { groupName, groupID });
+}
+function muteGroup(isMute, groupID, config) {
+  return callSdkApi("muteGroup", { isMute, groupID, config });
+}
+function muteGroupMembers(isMute, userIDs, groupID, config) {
+  return callSdkApi("muteGroupMembers", { isMute, userIDs, groupID, config });
+}
+function updateGroupAvatarUrl(groupAvatarUrl, groupID) {
+  return callSdkApi("updateGroupAvatarUrl", { groupAvatarUrl, groupID });
+}
+function updateGroupNotice(groupNotice, groupID) {
+  return callSdkApi("updateGroupNotice", { groupNotice, groupID });
+}
+function updateGroupJoinMode(mode, groupID) {
+  return callSdkApi("updateGroupJoinMode", { mode, groupID });
+}
+function updateGroupInviteMode(mode, groupID) {
+  return callSdkApi("updateGroupInviteMode", { mode, groupID });
+}
+function acceptGroupInviteApplication(inviterUserID, groupID, config) {
+  return callSdkApi("acceptGroupInviteApplication", {
+    inviterUserID,
+    groupID,
+    config
+  });
+}
+function acceptGroupJoinApplication(userID, groupID, config) {
+  return callSdkApi("acceptGroupJoinApplication", { userID, groupID, config });
+}
+function queryGroupApplicationList(config) {
+  return callSdkApi("queryGroupApplicationList", { config });
+}
+function rejectGroupInviteApplication(inviterUserID, groupID, config) {
+  return callSdkApi("rejectGroupInviteApplication", {
+    inviterUserID,
+    groupID,
+    config
+  });
+}
+function rejectGroupJoinApplication(userID, groupID, config) {
+  return callSdkApi("rejectGroupJoinApplication", { userID, groupID, config });
+}
+function sendGroupInviteApplications(userIDs, groupID, config) {
+  return callSdkApi("sendGroupInviteApplications", {
+    userIDs,
+    groupID,
+    config
+  });
+}
+function sendGroupJoinApplication(groupID, config) {
+  return callSdkApi("sendGroupJoinApplication", { groupID, config });
+}
+function updateGroupBeInviteMode(mode, groupID) {
+  return callSdkApi("updateGroupBeInviteMode", { mode, groupID });
+}
+function queryGroupInfo(groupID) {
+  return callSdkApi("queryGroupInfo", { groupID });
+}
+function queryGroupList(count, config) {
+  return callSdkApi("queryGroupList", { count, config });
+}
+function setGroupMemberRole(role, forUserID, groupID) {
+  return callSdkApi("setGroupMemberRole", { role, forUserID, groupID });
+}
+function setGroupMemberNickname(nickname, forUserID, groupID) {
+  return callSdkApi("setGroupMemberNickname", {
+    nickname,
+    forUserID,
+    groupID
+  });
+}
+function queryGroupMemberInfo(userID, groupID) {
+  return callSdkApi("queryGroupMemberInfo", { userID, groupID });
+}
+function queryGroupMemberList(groupID, config) {
+  return callSdkApi("queryGroupMemberList", { groupID, config });
+}
+function queryGroupMemberMutedList(groupID, config) {
+  return callSdkApi("queryGroupMemberMutedList", { groupID, config });
+}
+function queryGroupMemberCount(groupID) {
+  return callSdkApi("queryGroupMemberCount", { groupID });
+}
+var group_default = {
+  createGroup,
+  joinGroup,
+  leaveGroup,
+  dismissGroup,
+  kickGroupMembers,
+  inviteUsersIntoGroup,
+  transferGroupOwner,
+  updateGroupAlias,
+  updateGroupName,
+  muteGroup,
+  muteGroupMembers,
+  updateGroupAvatarUrl,
+  updateGroupNotice,
+  updateGroupJoinMode,
+  updateGroupInviteMode,
+  acceptGroupInviteApplication,
+  acceptGroupJoinApplication,
+  queryGroupApplicationList,
+  rejectGroupInviteApplication,
+  rejectGroupJoinApplication,
+  sendGroupInviteApplications,
+  sendGroupJoinApplication,
+  updateGroupBeInviteMode,
+  queryGroupInfo,
+  queryGroupList,
+  setGroupMemberRole,
+  setGroupMemberNickname,
+  queryGroupMemberInfo,
+  queryGroupMemberList,
+  queryGroupMemberMutedList,
+  queryGroupMemberCount
+};
+
+// src/sdk/conversation/conversationExt.ts
+function queryConversationPinnedList(config) {
+  return callSdkApi("queryConversationPinnedList", { config });
+}
+function queryConversationTotalUnreadMessageCount(config) {
+  return callSdkApi("queryConversationTotalUnreadMessageCount", { config });
+}
+function updateConversationPinnedState(isPinned, conversationID, conversationType) {
+  return callSdkApi("updateConversationPinnedState", {
+    isPinned,
+    conversationID,
+    conversationType
+  });
+}
+function setConversationNotificationStatus(status, conversationID, conversationType) {
+  return callSdkApi("setConversationNotificationStatus", {
+    status,
+    conversationID,
+    conversationType
+  });
+}
+var conversationExt_default = {
+  queryConversationPinnedList,
+  queryConversationTotalUnreadMessageCount,
+  updateConversationPinnedState,
+  setConversationNotificationStatus
+};
+
+// src/sdk/message/messageExt.ts
+function notifyMessageAttached(notification, message) {
+  try {
+    notification?.onMessageAttached?.(message);
+  } catch {
+  }
+}
+function editMessage(message, config, notification) {
+  notifyMessageAttached(notification, message);
+  return callSdkApi("editMessage", { message, config });
+}
+async function replyMessage(message, toOriginalMessage, config, notification) {
+  const session = captureSession();
+  if (isAuthenticating())
+    await waitForAuthentication(session);
+  const storage = captureStorage();
+  const preparedReply = prepareReplyMessage(message, toOriginalMessage);
+  await persistOutgoing(storage, {
+    toOriginalMessage,
+    message: preparedReply
+  });
+  if (storage && !isCurrentStorage(storage))
+    throw new Error("Local storage account changed before sending reply");
+  notifyMessageAttached(notification, { ...preparedReply });
+  assertCurrentSession(session);
+  const result = await callSdkApi("replyMessage", { message: preparedReply, toOriginalMessage, config });
+  if (result?.message && typeof result.message === "object") {
+    return { ...result, message: { ...result.message, clientBizId: preparedReply.clientBizId } };
+  }
+  return result && typeof result === "object" ? { ...result, clientBizId: preparedReply.clientBizId } : result;
+}
+function prepareReplyMessage(message, original) {
+  const candidate = { ...message };
+  delete candidate.messageID;
+  delete candidate.localMessageID;
+  delete candidate.localID;
+  delete candidate.orderKey;
+  delete candidate.messageSeq;
+  delete candidate.conversationSeq;
+  delete candidate.id;
+  delete candidate.c2cSeq;
+  delete candidate.clientSid;
+  delete candidate.errorCode;
+  delete candidate.errorMessage;
+  if (candidate.clientBizId && candidate.clientBizId === original.clientBizId)
+    delete candidate.clientBizId;
+  const prepared = withClientBizId(candidate);
+  return {
+    ...prepared,
+    localMessageID: prepared.clientBizId,
+    conversationID: original.conversationID ?? candidate.conversationID,
+    conversationType: original.conversationType ?? candidate.conversationType,
+    timestamp: Date.now(),
+    direction: 0,
+    sentStatus: 0,
+    sendState: 0,
+    // Build the quote before persistence/notification, independently of the ACK.
+    // Copy display fields only so editing the draft never changes the original.
+    repliedInfo: {
+      state: original.deleted ? 1 : 0,
+      messageID: original.messageID,
+      messageSeq: original.messageSeq ?? original.id ?? original.c2cSeq,
+      senderUserID: original.senderUserID,
+      sentTime: original.timestamp,
+      messageInfo: {
+        type: original.type,
+        message: original.message instanceof Uint8Array ? original.message.slice() : original.message ?? original.massage ?? "",
+        extendedData: original.extendedData,
+        subType: original.subType,
+        fileName: original.fileName
+      }
+    }
+  };
+}
+function queryMessageRepliedList(message, config) {
+  return callSdkApi("queryMessageRepliedList", { message, config });
+}
+function queryCombineMessageDetail(config) {
+  return callSdkApi("queryCombineMessageDetail", {
+    combineID: config.combineID
+  });
+}
+function searchLocalMessages(conversationID, conversationType, config) {
+  if (captureStorage()) {
+    const read = async () => {
+      const result = await queryLocalMessages({
+        conversationID,
+        conversationType,
+        count: config.count,
+        order: config.order === 1 ? "asc" : "desc",
+        keywords: config.keywords,
+        messageTypes: config.messageTypes,
+        senderUserIDs: config.senderUserIDs,
+        startTime: config.startTime,
+        endTime: config.endTime,
+        before: config.nextMessage ? { timestamp: Number(config.nextMessage.timestamp), localID: String(config.nextMessage.localID || config.nextMessage.localMessageID || "") } : void 0
+      });
+      return {
+        conversationID,
+        conversationType,
+        messageList: result.messageList,
+        nextMessage: result.hasMore ? result.messageList[result.messageList.length - 1] : void 0
+      };
+    };
+    return read();
+  }
+  return callSdkApi("searchLocalMessages", {
+    conversationID,
+    conversationType,
+    config
+  });
+}
+function queryMessages(messageIds, conversationID, conversationType) {
+  return callSdkApi("queryMessages", {
+    messageIds,
+    conversationID,
+    conversationType
+  });
+}
+var messageExt_default = {
+  editMessage,
+  replyMessage,
+  queryMessageRepliedList,
+  queryCombineMessageDetail,
+  searchLocalMessages,
+  queryMessages
+};
+
+// src/sdk/zimApis.ts
+var ZimApis = {
+  ...social_default,
+  ...group_default,
+  ...conversationExt_default,
+  ...messageExt_default
+};
+var zimApis_default = ZimApis;
+
+// src/constants/social/ZIMUserExtension.ts
+var ZIMUserRelationType = /* @__PURE__ */ ((ZIMUserRelationType2) => {
+  ZIMUserRelationType2[ZIMUserRelationType2["Unknown"] = -1] = "Unknown";
+  ZIMUserRelationType2[ZIMUserRelationType2["None"] = 0] = "None";
+  ZIMUserRelationType2[ZIMUserRelationType2["Friend"] = 1] = "Friend";
+  return ZIMUserRelationType2;
+})(ZIMUserRelationType || {});
+var ZIMUserOnlineStatus = /* @__PURE__ */ ((ZIMUserOnlineStatus2) => {
+  ZIMUserOnlineStatus2[ZIMUserOnlineStatus2["Online"] = 0] = "Online";
+  ZIMUserOnlineStatus2[ZIMUserOnlineStatus2["Offline"] = 1] = "Offline";
+  ZIMUserOnlineStatus2[ZIMUserOnlineStatus2["Logout"] = 2] = "Logout";
+  ZIMUserOnlineStatus2[ZIMUserOnlineStatus2["Unknown"] = 99] = "Unknown";
+  return ZIMUserOnlineStatus2;
+})(ZIMUserOnlineStatus || {});
+
+// src/constants/social/ZIMFriendExtension.ts
+var ZIMFriendApplicationType = /* @__PURE__ */ ((ZIMFriendApplicationType2) => {
+  ZIMFriendApplicationType2[ZIMFriendApplicationType2["Unknown"] = -1] = "Unknown";
+  ZIMFriendApplicationType2[ZIMFriendApplicationType2["None"] = 0] = "None";
+  ZIMFriendApplicationType2[ZIMFriendApplicationType2["Received"] = 1] = "Received";
+  ZIMFriendApplicationType2[ZIMFriendApplicationType2["Sent"] = 2] = "Sent";
+  ZIMFriendApplicationType2[ZIMFriendApplicationType2["Both"] = 3] = "Both";
+  return ZIMFriendApplicationType2;
+})(ZIMFriendApplicationType || {});
+var ZIMFriendApplicationState = /* @__PURE__ */ ((ZIMFriendApplicationState2) => {
+  ZIMFriendApplicationState2[ZIMFriendApplicationState2["Unknown"] = -1] = "Unknown";
+  ZIMFriendApplicationState2[ZIMFriendApplicationState2["Waiting"] = 1] = "Waiting";
+  ZIMFriendApplicationState2[ZIMFriendApplicationState2["Accepted"] = 2] = "Accepted";
+  ZIMFriendApplicationState2[ZIMFriendApplicationState2["Rejected"] = 3] = "Rejected";
+  ZIMFriendApplicationState2[ZIMFriendApplicationState2["Expired"] = 4] = "Expired";
+  ZIMFriendApplicationState2[ZIMFriendApplicationState2["Disabled"] = 5] = "Disabled";
+  return ZIMFriendApplicationState2;
+})(ZIMFriendApplicationState || {});
+var ZIMFriendDeleteType = /* @__PURE__ */ ((ZIMFriendDeleteType2) => {
+  ZIMFriendDeleteType2[ZIMFriendDeleteType2["Both"] = 0] = "Both";
+  ZIMFriendDeleteType2[ZIMFriendDeleteType2["Single"] = 1] = "Single";
+  return ZIMFriendDeleteType2;
+})(ZIMFriendDeleteType || {});
+
+// src/constants/group/ZIMGroupExtension.ts
+var ZIMGroupMessageNotificationStatus = /* @__PURE__ */ ((ZIMGroupMessageNotificationStatus2) => {
+  ZIMGroupMessageNotificationStatus2[ZIMGroupMessageNotificationStatus2["Notify"] = 1] = "Notify";
+  ZIMGroupMessageNotificationStatus2[ZIMGroupMessageNotificationStatus2["DoNotDisturb"] = 2] = "DoNotDisturb";
+  return ZIMGroupMessageNotificationStatus2;
+})(ZIMGroupMessageNotificationStatus || {});
+var ZIMGroupMuteMode = /* @__PURE__ */ ((ZIMGroupMuteMode2) => {
+  ZIMGroupMuteMode2[ZIMGroupMuteMode2["None"] = 0] = "None";
+  ZIMGroupMuteMode2[ZIMGroupMuteMode2["Normal"] = 1] = "Normal";
+  ZIMGroupMuteMode2[ZIMGroupMuteMode2["All"] = 2] = "All";
+  ZIMGroupMuteMode2[ZIMGroupMuteMode2["Custom"] = 3] = "Custom";
+  return ZIMGroupMuteMode2;
+})(ZIMGroupMuteMode || {});
+var ZIMGroupJoinMode = /* @__PURE__ */ ((ZIMGroupJoinMode2) => {
+  ZIMGroupJoinMode2[ZIMGroupJoinMode2["Any"] = 0] = "Any";
+  ZIMGroupJoinMode2[ZIMGroupJoinMode2["Auth"] = 1] = "Auth";
+  ZIMGroupJoinMode2[ZIMGroupJoinMode2["Forbid"] = 2] = "Forbid";
+  return ZIMGroupJoinMode2;
+})(ZIMGroupJoinMode || {});
+var ZIMGroupInviteMode = /* @__PURE__ */ ((ZIMGroupInviteMode2) => {
+  ZIMGroupInviteMode2[ZIMGroupInviteMode2["Any"] = 0] = "Any";
+  ZIMGroupInviteMode2[ZIMGroupInviteMode2["Admin"] = 1] = "Admin";
+  return ZIMGroupInviteMode2;
+})(ZIMGroupInviteMode || {});
+var ZIMGroupBeInviteMode = /* @__PURE__ */ ((ZIMGroupBeInviteMode2) => {
+  ZIMGroupBeInviteMode2[ZIMGroupBeInviteMode2["None"] = 0] = "None";
+  ZIMGroupBeInviteMode2[ZIMGroupBeInviteMode2["Auth"] = 1] = "Auth";
+  return ZIMGroupBeInviteMode2;
+})(ZIMGroupBeInviteMode || {});
+var ZIMGroupEnterType = /* @__PURE__ */ ((ZIMGroupEnterType2) => {
+  ZIMGroupEnterType2[ZIMGroupEnterType2["Unknown"] = 0] = "Unknown";
+  ZIMGroupEnterType2[ZIMGroupEnterType2["Created"] = 1] = "Created";
+  ZIMGroupEnterType2[ZIMGroupEnterType2["JoinApply"] = 2] = "JoinApply";
+  ZIMGroupEnterType2[ZIMGroupEnterType2["Joined"] = 3] = "Joined";
+  ZIMGroupEnterType2[ZIMGroupEnterType2["Invited"] = 4] = "Invited";
+  ZIMGroupEnterType2[ZIMGroupEnterType2["InviteApply"] = 5] = "InviteApply";
+  return ZIMGroupEnterType2;
+})(ZIMGroupEnterType || {});
+var ZIMGroupApplicationType = /* @__PURE__ */ ((ZIMGroupApplicationType2) => {
+  ZIMGroupApplicationType2[ZIMGroupApplicationType2["Unknown"] = -1] = "Unknown";
+  ZIMGroupApplicationType2[ZIMGroupApplicationType2["None"] = 0] = "None";
+  ZIMGroupApplicationType2[ZIMGroupApplicationType2["Join"] = 1] = "Join";
+  ZIMGroupApplicationType2[ZIMGroupApplicationType2["Invite"] = 2] = "Invite";
+  ZIMGroupApplicationType2[ZIMGroupApplicationType2["BeInvite"] = 3] = "BeInvite";
+  return ZIMGroupApplicationType2;
+})(ZIMGroupApplicationType || {});
+var ZIMGroupApplicationState = /* @__PURE__ */ ((ZIMGroupApplicationState2) => {
+  ZIMGroupApplicationState2[ZIMGroupApplicationState2["Unknown"] = -1] = "Unknown";
+  ZIMGroupApplicationState2[ZIMGroupApplicationState2["Waiting"] = 1] = "Waiting";
+  ZIMGroupApplicationState2[ZIMGroupApplicationState2["Accepted"] = 2] = "Accepted";
+  ZIMGroupApplicationState2[ZIMGroupApplicationState2["Rejected"] = 3] = "Rejected";
+  ZIMGroupApplicationState2[ZIMGroupApplicationState2["Expired"] = 4] = "Expired";
+  ZIMGroupApplicationState2[ZIMGroupApplicationState2["Disabled"] = 5] = "Disabled";
+  return ZIMGroupApplicationState2;
+})(ZIMGroupApplicationState || {});
+
+// src/constants/conversations/ZIMConversationExtension.ts
+var ZIMConversationNotificationStatus = /* @__PURE__ */ ((ZIMConversationNotificationStatus2) => {
+  ZIMConversationNotificationStatus2[ZIMConversationNotificationStatus2["Notify"] = 1] = "Notify";
+  ZIMConversationNotificationStatus2[ZIMConversationNotificationStatus2["DoNotDisturb"] = 2] = "DoNotDisturb";
+  return ZIMConversationNotificationStatus2;
+})(ZIMConversationNotificationStatus || {});
+var ZIMConversationPinnedFilter = /* @__PURE__ */ ((ZIMConversationPinnedFilter2) => {
+  ZIMConversationPinnedFilter2[ZIMConversationPinnedFilter2["All"] = 0] = "All";
+  ZIMConversationPinnedFilter2[ZIMConversationPinnedFilter2["OnlyPinned"] = 1] = "OnlyPinned";
+  ZIMConversationPinnedFilter2[ZIMConversationPinnedFilter2["OnlyUnpinned"] = 2] = "OnlyUnpinned";
+  return ZIMConversationPinnedFilter2;
+})(ZIMConversationPinnedFilter || {});
+
+// src/constants/conversations/ZIMConversationDefines.ts
+var ZIMConversationEvent = /* @__PURE__ */ ((ZIMConversationEvent2) => {
+  ZIMConversationEvent2[ZIMConversationEvent2["Added"] = 0] = "Added";
+  ZIMConversationEvent2[ZIMConversationEvent2["Updated"] = 1] = "Updated";
+  ZIMConversationEvent2[ZIMConversationEvent2["Disabled"] = 2] = "Disabled";
+  ZIMConversationEvent2[ZIMConversationEvent2["Deleted"] = 3] = "Deleted";
+  return ZIMConversationEvent2;
+})(ZIMConversationEvent || {});
+
+// src/constants/messages/ZIMMessageExtension.ts
+var ZIMMessageOrder = /* @__PURE__ */ ((ZIMMessageOrder2) => {
+  ZIMMessageOrder2[ZIMMessageOrder2["Descending"] = 0] = "Descending";
+  ZIMMessageOrder2[ZIMMessageOrder2["Ascending"] = 1] = "Ascending";
+  return ZIMMessageOrder2;
+})(ZIMMessageOrder || {});
 
 // src/sdk/index.ts
 var VanshiSdk = {
+  ...storage_default,
   // 创建 ws 实例
   create: initSocket,
-  // 退出 SDK 登录并断开 ws 连接
+  // 退出 SDK 登录，默认不断开 ws 连接
   logout,
   // 判断当前 ws 是否连接
   isConnected: isSocketConnected,
@@ -1002,8 +4483,12 @@ var VanshiSdk = {
   off,
   // 登录 SDK
   login,
-  // 查询会话列表
+  // 音视频通话
+  ...call_default,
+  // 查询单个会话
   queryConversation,
+  // 查询会话列表
+  queryConversationList,
   // 删除全部会话列表
   deleteAllConversations,
   // 删除单个会话
@@ -1033,31 +4518,148 @@ var VanshiSdk = {
   // 查询群消息未读成员列表。
   queryGroupMessageReceiptUnreadMemberList,
   // 查询群消息已读成员列表。
-  queryGroupMessageReceiptReadMemberList
+  queryGroupMessageReceiptReadMemberList,
+  // 好友、黑名单、用户、群组、会话与消息扩展 API
+  ...zimApis_default
 };
 var sdk_default = VanshiSdk;
 export {
+  LocalSyncError,
+  SEDMessageType,
+  SdkRuntimeError,
+  ZIMCallAction,
+  ZIMCallConversationType,
+  ZIMCallEventEnum,
+  ZIMCallMode,
+  ZIMCallType,
+  ZIMConnectionEvent,
+  ZIMConnectionState,
+  ZIMConversationEvent,
+  ZIMConversationNotificationStatus,
+  ZIMConversationPinnedFilter,
+  ZIMEventEnum,
+  ZIMFriendApplicationState,
+  ZIMFriendApplicationType,
+  ZIMFriendDeleteType,
+  ZIMGroupApplicationState,
+  ZIMGroupApplicationType,
+  ZIMGroupBeInviteMode,
+  ZIMGroupEnterType,
+  ZIMGroupInviteMode,
+  ZIMGroupJoinMode,
+  ZIMGroupMessageNotificationStatus,
+  ZIMGroupMuteMode,
+  ZIMMessageOrder,
+  ZIMUserOnlineStatus,
+  ZIMUserRelationType,
+  ZIM_LOCAL_CALL_EVENTS,
+  acceptFriendApplication,
+  acceptGroupInviteApplication,
+  acceptGroupJoinApplication,
+  addUsersToBlacklist,
+  callAccept,
+  callCancel,
+  callGetLiveKitToken,
+  callGetMediaState,
+  callGetRoom,
+  callHangup,
+  callHasOngoingCall,
+  callInvite,
+  callInviteMembers,
+  callJoinMedia,
+  callLeaveMedia,
+  callQueryMembers,
+  callReject,
+  callSetCameraEnabled,
+  callSetMicrophoneEnabled,
+  callStartScreenShare,
+  callStopScreenShare,
+  checkUserIsInBlacklist,
   clearConversationTotalUnreadMessageCount,
   clearConversationUnreadMessageCount,
+  clearLocalMessages,
   initSocket as create,
+  createGroup,
   sdk_default as default,
   deleteAllConversationMessages,
   deleteAllConversations,
   deleteAllMessage,
   deleteConversation,
+  deleteFriends,
   deleteMessages,
+  dismissGroup,
+  editMessage,
+  getLocalStorageStatus,
+  inviteUsersIntoGroup,
   isSocketConnected as isConnected,
+  isSdkRuntimeErrorObject,
+  joinGroup,
+  kickGroupMembers,
+  leaveGroup,
   login,
   logout,
+  muteGroup,
+  muteGroupMembers,
   off,
   on,
+  queryBlacklist,
+  queryCombineMessageDetail,
   queryConversation,
+  queryConversationList,
+  queryConversationPinnedList,
+  queryConversationTotalUnreadMessageCount,
+  queryFailedMessages,
+  queryFriendApplicationList,
+  queryFriendList,
+  queryFriendsInfo,
+  queryGroupApplicationList,
+  queryGroupInfo,
+  queryGroupList,
+  queryGroupMemberCount,
+  queryGroupMemberInfo,
+  queryGroupMemberList,
+  queryGroupMemberMutedList,
   queryGroupMessageReceiptReadMemberList,
   queryGroupMessageReceiptUnreadMemberList,
   queryHistoryMessage,
+  queryLocalMessages,
   queryMessageReceiptsInfo,
+  queryMessageRepliedList,
+  queryMessages,
+  querySelfUserInfo,
+  queryUsersInfo,
+  queryUsersStatus,
+  rejectFriendApplication,
+  rejectGroupInviteApplication,
+  rejectGroupJoinApplication,
+  removeUsersFromBlacklist,
+  renewToken,
+  replyMessage,
   revokeMessage,
+  searchLocalMessages,
+  sendFriendApplication,
+  sendGroupInviteApplications,
+  sendGroupJoinApplication,
   sendMediaMessage,
   sendMessage,
-  sendMessageReceiptsRead
+  sendMessageReceiptsRead,
+  setConversationNotificationStatus,
+  setGroupMemberNickname,
+  setGroupMemberRole,
+  subscribeUsersStatus,
+  syncConversationMessages,
+  syncLocalMessages,
+  transferGroupOwner,
+  unsubscribeUsersStatus,
+  updateConversationPinnedState,
+  updateFriendAlias,
+  updateGroupAlias,
+  updateGroupAvatarUrl,
+  updateGroupBeInviteMode,
+  updateGroupInviteMode,
+  updateGroupJoinMode,
+  updateGroupName,
+  updateGroupNotice,
+  updateUserAvatarUrl,
+  updateUserName
 };