@quilibrium/quorum-shared 2.1.0-1

package/dist/index.mjs

@@ -0,0 +1,2678 @@
+// src/types/bookmark.ts
+var BOOKMARKS_CONFIG = {
+  MAX_BOOKMARKS: 200,
+  PREVIEW_SNIPPET_LENGTH: 150
+};
+
+// src/api/errors.ts
+var ApiErrorCode = /* @__PURE__ */ ((ApiErrorCode2) => {
+  ApiErrorCode2["NETWORK_ERROR"] = "NETWORK_ERROR";
+  ApiErrorCode2["TIMEOUT"] = "TIMEOUT";
+  ApiErrorCode2["UNAUTHORIZED"] = "UNAUTHORIZED";
+  ApiErrorCode2["FORBIDDEN"] = "FORBIDDEN";
+  ApiErrorCode2["TOKEN_EXPIRED"] = "TOKEN_EXPIRED";
+  ApiErrorCode2["VALIDATION_ERROR"] = "VALIDATION_ERROR";
+  ApiErrorCode2["BAD_REQUEST"] = "BAD_REQUEST";
+  ApiErrorCode2["NOT_FOUND"] = "NOT_FOUND";
+  ApiErrorCode2["CONFLICT"] = "CONFLICT";
+  ApiErrorCode2["RATE_LIMITED"] = "RATE_LIMITED";
+  ApiErrorCode2["SERVER_ERROR"] = "SERVER_ERROR";
+  ApiErrorCode2["SERVICE_UNAVAILABLE"] = "SERVICE_UNAVAILABLE";
+  ApiErrorCode2["UNKNOWN"] = "UNKNOWN";
+  return ApiErrorCode2;
+})(ApiErrorCode || {});
+var ApiError = class _ApiError extends Error {
+  constructor(details) {
+    super(details.message);
+    this.name = "ApiError";
+    this.code = details.code;
+    this.status = details.status;
+    this.field = details.field;
+    this.retryAfter = details.retryAfter;
+    this.originalError = details.originalError;
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, _ApiError);
+    }
+  }
+  /** Check if error is retryable */
+  get isRetryable() {
+    return [
+      "NETWORK_ERROR" /* NETWORK_ERROR */,
+      "TIMEOUT" /* TIMEOUT */,
+      "RATE_LIMITED" /* RATE_LIMITED */,
+      "SERVER_ERROR" /* SERVER_ERROR */,
+      "SERVICE_UNAVAILABLE" /* SERVICE_UNAVAILABLE */
+    ].includes(this.code);
+  }
+  /** Check if error requires re-authentication */
+  get requiresAuth() {
+    return [
+      "UNAUTHORIZED" /* UNAUTHORIZED */,
+      "TOKEN_EXPIRED" /* TOKEN_EXPIRED */
+    ].includes(this.code);
+  }
+  /** Convert to JSON-serializable object */
+  toJSON() {
+    return {
+      code: this.code,
+      message: this.message,
+      status: this.status,
+      field: this.field,
+      retryAfter: this.retryAfter
+    };
+  }
+};
+function createApiError(status, message, field) {
+  let code;
+  let defaultMessage;
+  switch (status) {
+    case 400:
+      code = "BAD_REQUEST" /* BAD_REQUEST */;
+      defaultMessage = "Invalid request";
+      break;
+    case 401:
+      code = "UNAUTHORIZED" /* UNAUTHORIZED */;
+      defaultMessage = "Authentication required";
+      break;
+    case 403:
+      code = "FORBIDDEN" /* FORBIDDEN */;
+      defaultMessage = "Access denied";
+      break;
+    case 404:
+      code = "NOT_FOUND" /* NOT_FOUND */;
+      defaultMessage = "Resource not found";
+      break;
+    case 409:
+      code = "CONFLICT" /* CONFLICT */;
+      defaultMessage = "Resource conflict";
+      break;
+    case 422:
+      code = "VALIDATION_ERROR" /* VALIDATION_ERROR */;
+      defaultMessage = "Validation failed";
+      break;
+    case 429:
+      code = "RATE_LIMITED" /* RATE_LIMITED */;
+      defaultMessage = "Rate limit exceeded";
+      break;
+    case 500:
+      code = "SERVER_ERROR" /* SERVER_ERROR */;
+      defaultMessage = "Server error";
+      break;
+    case 503:
+      code = "SERVICE_UNAVAILABLE" /* SERVICE_UNAVAILABLE */;
+      defaultMessage = "Service unavailable";
+      break;
+    default:
+      code = "UNKNOWN" /* UNKNOWN */;
+      defaultMessage = "An unexpected error occurred";
+  }
+  return new ApiError({
+    code,
+    message: message || defaultMessage,
+    status,
+    field
+  });
+}
+function createNetworkError(error) {
+  if (error.name === "AbortError") {
+    return new ApiError({
+      code: "TIMEOUT" /* TIMEOUT */,
+      message: "Request timed out",
+      originalError: error
+    });
+  }
+  return new ApiError({
+    code: "NETWORK_ERROR" /* NETWORK_ERROR */,
+    message: "Network error",
+    originalError: error
+  });
+}
+
+// src/api/endpoints.ts
+var endpoints = {
+  // Spaces
+  spaces: {
+    list: () => "/spaces",
+    detail: (spaceId) => `/spaces/${spaceId}`,
+    members: (spaceId) => `/spaces/${spaceId}/members`,
+    join: (spaceId) => `/spaces/${spaceId}/join`,
+    leave: (spaceId) => `/spaces/${spaceId}/leave`
+  },
+  // Channels
+  channels: {
+    list: (spaceId) => `/spaces/${spaceId}/channels`,
+    detail: (spaceId, channelId) => `/spaces/${spaceId}/channels/${channelId}`
+  },
+  // Messages
+  messages: {
+    list: (spaceId, channelId) => `/spaces/${spaceId}/channels/${channelId}/messages`,
+    detail: (spaceId, channelId, messageId) => `/spaces/${spaceId}/channels/${channelId}/messages/${messageId}`,
+    send: (spaceId, channelId) => `/spaces/${spaceId}/channels/${channelId}/messages`,
+    react: (spaceId, channelId, messageId) => `/spaces/${spaceId}/channels/${channelId}/messages/${messageId}/reactions`,
+    pin: (spaceId, channelId, messageId) => `/spaces/${spaceId}/channels/${channelId}/messages/${messageId}/pin`
+  },
+  // Conversations (DMs)
+  conversations: {
+    list: () => "/conversations",
+    detail: (conversationId) => `/conversations/${conversationId}`,
+    messages: (conversationId) => `/conversations/${conversationId}/messages`
+  },
+  // User
+  user: {
+    config: () => "/user/config",
+    profile: () => "/user/profile",
+    notifications: () => "/user/notifications"
+  },
+  // Search
+  search: {
+    messages: (spaceId) => `/spaces/${spaceId}/search/messages`,
+    members: (spaceId) => `/spaces/${spaceId}/search/members`
+  }
+};
+
+// src/hooks/keys.ts
+var queryKeys = {
+  // Spaces
+  spaces: {
+    all: ["spaces"],
+    detail: (spaceId) => ["spaces", spaceId],
+    members: (spaceId) => ["spaces", spaceId, "members"],
+    member: (spaceId, address) => ["spaces", spaceId, "members", address]
+  },
+  // Channels
+  channels: {
+    bySpace: (spaceId) => ["channels", spaceId],
+    detail: (spaceId, channelId) => ["channels", spaceId, channelId]
+  },
+  // Messages
+  messages: {
+    infinite: (spaceId, channelId) => ["messages", "infinite", spaceId, channelId],
+    detail: (spaceId, channelId, messageId) => ["messages", spaceId, channelId, messageId],
+    pinned: (spaceId, channelId) => ["messages", "pinned", spaceId, channelId]
+  },
+  // Conversations (DMs)
+  conversations: {
+    all: (type) => ["conversations", type],
+    detail: (conversationId) => ["conversations", conversationId],
+    messages: (conversationId) => ["conversations", conversationId, "messages"]
+  },
+  // User
+  user: {
+    config: (address) => ["user", "config", address],
+    profile: (address) => ["user", "profile", address]
+  },
+  // Bookmarks
+  bookmarks: {
+    all: ["bookmarks"],
+    bySource: (sourceType) => ["bookmarks", sourceType],
+    bySpace: (spaceId) => ["bookmarks", "space", spaceId],
+    check: (messageId) => ["bookmarks", "check", messageId]
+  }
+};
+
+// src/hooks/useSpaces.ts
+import { useQuery } from "@tanstack/react-query";
+function useSpaces({ storage, enabled = true }) {
+  return useQuery({
+    queryKey: queryKeys.spaces.all,
+    queryFn: async () => {
+      return storage.getSpaces();
+    },
+    enabled,
+    staleTime: 1e3 * 60 * 5
+    // 5 minutes
+  });
+}
+function useSpace({ storage, spaceId, enabled = true }) {
+  return useQuery({
+    queryKey: queryKeys.spaces.detail(spaceId ?? ""),
+    queryFn: async () => {
+      if (!spaceId) return null;
+      return storage.getSpace(spaceId);
+    },
+    enabled: enabled && !!spaceId,
+    staleTime: 1e3 * 60 * 5
+    // 5 minutes
+  });
+}
+function useSpaceMembers({
+  storage,
+  spaceId,
+  enabled = true
+}) {
+  return useQuery({
+    queryKey: queryKeys.spaces.members(spaceId ?? ""),
+    queryFn: async () => {
+      if (!spaceId) return [];
+      return storage.getSpaceMembers(spaceId);
+    },
+    enabled: enabled && !!spaceId,
+    staleTime: 1e3 * 60 * 2
+    // 2 minutes
+  });
+}
+
+// src/hooks/useChannels.ts
+import { useQuery as useQuery2 } from "@tanstack/react-query";
+function useChannels({ storage, spaceId, enabled = true }) {
+  return useQuery2({
+    queryKey: queryKeys.channels.bySpace(spaceId ?? ""),
+    queryFn: async () => {
+      if (!spaceId) return [];
+      return storage.getChannels(spaceId);
+    },
+    enabled: enabled && !!spaceId,
+    staleTime: 1e3 * 60 * 5
+    // 5 minutes
+  });
+}
+function flattenChannels(groups) {
+  return groups.flatMap((group) => group.channels);
+}
+function findChannel(groups, channelId) {
+  for (const group of groups) {
+    const channel = group.channels.find((c) => c.channelId === channelId);
+    if (channel) return channel;
+  }
+  return void 0;
+}
+
+// src/hooks/useMessages.ts
+import { useInfiniteQuery, useQueryClient as useQueryClient2 } from "@tanstack/react-query";
+function useMessages({
+  storage,
+  spaceId,
+  channelId,
+  enabled = true,
+  limit = 50
+}) {
+  return useInfiniteQuery({
+    queryKey: queryKeys.messages.infinite(spaceId ?? "", channelId ?? ""),
+    queryFn: async ({ pageParam }) => {
+      if (!spaceId || !channelId) {
+        return { messages: [], nextCursor: null, prevCursor: null };
+      }
+      return storage.getMessages({
+        spaceId,
+        channelId,
+        cursor: pageParam,
+        direction: "backward",
+        limit
+      });
+    },
+    getNextPageParam: (lastPage) => lastPage.prevCursor,
+    getPreviousPageParam: (firstPage) => firstPage.nextCursor,
+    initialPageParam: void 0,
+    enabled: enabled && !!spaceId && !!channelId,
+    staleTime: 1e3 * 30
+    // 30 seconds
+  });
+}
+function flattenMessages(pages) {
+  if (!pages) return [];
+  return pages.flatMap((page) => page.messages);
+}
+function useInvalidateMessages() {
+  const queryClient = useQueryClient2();
+  return {
+    invalidateChannel: (spaceId, channelId) => {
+      queryClient.invalidateQueries({
+        queryKey: queryKeys.messages.infinite(spaceId, channelId)
+      });
+    },
+    invalidateSpace: (spaceId) => {
+      queryClient.invalidateQueries({
+        queryKey: ["messages", "infinite", spaceId]
+      });
+    }
+  };
+}
+
+// src/hooks/mutations/useSendMessage.ts
+import { useMutation, useQueryClient as useQueryClient3 } from "@tanstack/react-query";
+function useSendMessage({
+  storage,
+  apiClient,
+  currentUserId
+}) {
+  const queryClient = useQueryClient3();
+  return useMutation({
+    mutationFn: async (params) => {
+      return apiClient.sendMessage(params);
+    },
+    onMutate: async (params) => {
+      const key = queryKeys.messages.infinite(params.spaceId, params.channelId);
+      await queryClient.cancelQueries({ queryKey: key });
+      const previousData = queryClient.getQueryData(key);
+      const optimisticMessage = {
+        messageId: `temp-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+        channelId: params.channelId,
+        spaceId: params.spaceId,
+        digestAlgorithm: "",
+        nonce: "",
+        createdDate: Date.now(),
+        modifiedDate: Date.now(),
+        lastModifiedHash: "",
+        content: {
+          type: "post",
+          senderId: currentUserId,
+          text: params.text,
+          repliesToMessageId: params.repliesToMessageId
+        },
+        reactions: [],
+        mentions: { memberIds: [], roleIds: [], channelIds: [] },
+        sendStatus: "sending"
+      };
+      queryClient.setQueryData(key, (old) => {
+        if (!old) return old;
+        return {
+          ...old,
+          pages: old.pages.map((page, index) => {
+            if (index === 0) {
+              return {
+                ...page,
+                messages: [optimisticMessage, ...page.messages]
+              };
+            }
+            return page;
+          })
+        };
+      });
+      return { previousData, optimisticMessage };
+    },
+    onError: (err, params, context) => {
+      if (context?.previousData) {
+        const key = queryKeys.messages.infinite(params.spaceId, params.channelId);
+        queryClient.setQueryData(key, context.previousData);
+      }
+    },
+    onSuccess: async (message, params, context) => {
+      const key = queryKeys.messages.infinite(params.spaceId, params.channelId);
+      queryClient.setQueryData(key, (old) => {
+        if (!old) return old;
+        return {
+          ...old,
+          pages: old.pages.map((page, index) => {
+            if (index === 0) {
+              return {
+                ...page,
+                messages: page.messages.map(
+                  (m) => m.messageId === context?.optimisticMessage.messageId ? message : m
+                )
+              };
+            }
+            return page;
+          })
+        };
+      });
+      await storage.saveMessage(
+        message,
+        message.createdDate,
+        currentUserId,
+        "space",
+        "",
+        ""
+      );
+    },
+    onSettled: (data, err, params) => {
+      queryClient.invalidateQueries({
+        queryKey: queryKeys.messages.infinite(params.spaceId, params.channelId)
+      });
+    }
+  });
+}
+
+// src/hooks/mutations/useReaction.ts
+import { useMutation as useMutation2, useQueryClient as useQueryClient4 } from "@tanstack/react-query";
+function useAddReaction({
+  storage,
+  apiClient,
+  currentUserId
+}) {
+  const queryClient = useQueryClient4();
+  return useMutation2({
+    mutationFn: async (params) => {
+      return apiClient.addReaction(params);
+    },
+    onMutate: async (params) => {
+      const key = queryKeys.messages.infinite(params.spaceId, params.channelId);
+      await queryClient.cancelQueries({ queryKey: key });
+      const previousData = queryClient.getQueryData(key);
+      queryClient.setQueryData(key, (old) => {
+        if (!old) return old;
+        return {
+          ...old,
+          pages: old.pages.map((page) => ({
+            ...page,
+            messages: page.messages.map((message) => {
+              if (message.messageId !== params.messageId) return message;
+              const existingReaction = message.reactions.find(
+                (r) => r.emojiName === params.reaction
+              );
+              if (existingReaction) {
+                return {
+                  ...message,
+                  reactions: message.reactions.map(
+                    (r) => r.emojiName === params.reaction ? {
+                      ...r,
+                      count: r.count + 1,
+                      memberIds: [...r.memberIds, currentUserId]
+                    } : r
+                  )
+                };
+              } else {
+                const newReaction = {
+                  emojiId: params.reaction,
+                  emojiName: params.reaction,
+                  spaceId: params.spaceId,
+                  count: 1,
+                  memberIds: [currentUserId]
+                };
+                return {
+                  ...message,
+                  reactions: [...message.reactions, newReaction]
+                };
+              }
+            })
+          }))
+        };
+      });
+      return { previousData };
+    },
+    onError: (err, params, context) => {
+      if (context?.previousData) {
+        const key = queryKeys.messages.infinite(params.spaceId, params.channelId);
+        queryClient.setQueryData(key, context.previousData);
+      }
+    }
+  });
+}
+function useRemoveReaction({
+  storage,
+  apiClient,
+  currentUserId
+}) {
+  const queryClient = useQueryClient4();
+  return useMutation2({
+    mutationFn: async (params) => {
+      return apiClient.removeReaction(params);
+    },
+    onMutate: async (params) => {
+      const key = queryKeys.messages.infinite(params.spaceId, params.channelId);
+      await queryClient.cancelQueries({ queryKey: key });
+      const previousData = queryClient.getQueryData(key);
+      queryClient.setQueryData(key, (old) => {
+        if (!old) return old;
+        return {
+          ...old,
+          pages: old.pages.map((page) => ({
+            ...page,
+            messages: page.messages.map((message) => {
+              if (message.messageId !== params.messageId) return message;
+              return {
+                ...message,
+                reactions: message.reactions.map((r) => {
+                  if (r.emojiName !== params.reaction) return r;
+                  const newMemberIds = r.memberIds.filter(
+                    (id) => id !== currentUserId
+                  );
+                  if (newMemberIds.length === 0) {
+                    return null;
+                  }
+                  return {
+                    ...r,
+                    count: newMemberIds.length,
+                    memberIds: newMemberIds
+                  };
+                }).filter((r) => r !== null)
+              };
+            })
+          }))
+        };
+      });
+      return { previousData };
+    },
+    onError: (err, params, context) => {
+      if (context?.previousData) {
+        const key = queryKeys.messages.infinite(params.spaceId, params.channelId);
+        queryClient.setQueryData(key, context.previousData);
+      }
+    }
+  });
+}
+
+// src/hooks/mutations/useEditMessage.ts
+import { useMutation as useMutation3, useQueryClient as useQueryClient5 } from "@tanstack/react-query";
+function useEditMessage({ storage, apiClient }) {
+  const queryClient = useQueryClient5();
+  return useMutation3({
+    mutationFn: async (params) => {
+      return apiClient.editMessage(params);
+    },
+    onMutate: async (params) => {
+      const key = queryKeys.messages.infinite(params.spaceId, params.channelId);
+      await queryClient.cancelQueries({ queryKey: key });
+      const previousData = queryClient.getQueryData(key);
+      queryClient.setQueryData(key, (old) => {
+        if (!old) return old;
+        return {
+          ...old,
+          pages: old.pages.map((page) => ({
+            ...page,
+            messages: page.messages.map((message) => {
+              if (message.messageId !== params.messageId) return message;
+              if (message.content.type !== "post") return message;
+              return {
+                ...message,
+                modifiedDate: Date.now(),
+                content: {
+                  ...message.content,
+                  text: params.text
+                }
+              };
+            })
+          }))
+        };
+      });
+      return { previousData };
+    },
+    onError: (err, params, context) => {
+      if (context?.previousData) {
+        const key = queryKeys.messages.infinite(params.spaceId, params.channelId);
+        queryClient.setQueryData(key, context.previousData);
+      }
+    },
+    onSuccess: async (message) => {
+      await storage.saveMessage(
+        message,
+        message.modifiedDate,
+        message.content.senderId,
+        "space",
+        "",
+        ""
+      );
+    },
+    onSettled: (data, err, params) => {
+      queryClient.invalidateQueries({
+        queryKey: queryKeys.messages.infinite(params.spaceId, params.channelId)
+      });
+    }
+  });
+}
+
+// src/hooks/mutations/useDeleteMessage.ts
+import { useMutation as useMutation4, useQueryClient as useQueryClient6 } from "@tanstack/react-query";
+function useDeleteMessage({ storage, apiClient }) {
+  const queryClient = useQueryClient6();
+  return useMutation4({
+    mutationFn: async (params) => {
+      return apiClient.deleteMessage(params);
+    },
+    onMutate: async (params) => {
+      const key = queryKeys.messages.infinite(params.spaceId, params.channelId);
+      await queryClient.cancelQueries({ queryKey: key });
+      const previousData = queryClient.getQueryData(key);
+      queryClient.setQueryData(key, (old) => {
+        if (!old) return old;
+        return {
+          ...old,
+          pages: old.pages.map((page) => ({
+            ...page,
+            messages: page.messages.filter(
+              (message) => message.messageId !== params.messageId
+            )
+          }))
+        };
+      });
+      return { previousData };
+    },
+    onError: (err, params, context) => {
+      if (context?.previousData) {
+        const key = queryKeys.messages.infinite(params.spaceId, params.channelId);
+        queryClient.setQueryData(key, context.previousData);
+      }
+    },
+    onSuccess: async (_, params) => {
+      await storage.deleteMessage(params.messageId);
+    },
+    onSettled: (data, err, params) => {
+      queryClient.invalidateQueries({
+        queryKey: queryKeys.messages.infinite(params.spaceId, params.channelId)
+      });
+    }
+  });
+}
+
+// src/utils/validation.ts
+var MAX_MESSAGE_LENGTH = 4e3;
+var MAX_MENTIONS = 50;
+function validateMessageContent(content) {
+  const errors = [];
+  if (!content || content.trim().length === 0) {
+    errors.push("Message cannot be empty");
+  }
+  if (content.length > MAX_MESSAGE_LENGTH) {
+    errors.push(`Message exceeds maximum length of ${MAX_MESSAGE_LENGTH} characters`);
+  }
+  return {
+    valid: errors.length === 0,
+    errors
+  };
+}
+function validateMessage(message) {
+  const errors = [];
+  if (!message.messageId) {
+    errors.push("Message ID is required");
+  }
+  if (!message.channelId) {
+    errors.push("Channel ID is required");
+  }
+  if (!message.spaceId) {
+    errors.push("Space ID is required");
+  }
+  if (!message.content) {
+    errors.push("Message content is required");
+  }
+  if (message.content?.type === "post") {
+    const postContent = message.content;
+    const text = Array.isArray(postContent.text) ? postContent.text.join("") : postContent.text;
+    if (text.length > MAX_MESSAGE_LENGTH) {
+      errors.push(`Message exceeds maximum length of ${MAX_MESSAGE_LENGTH} characters`);
+    }
+  }
+  return {
+    valid: errors.length === 0,
+    errors
+  };
+}
+function sanitizeContent(content) {
+  return content.replace(/[\x00-\x08\x0B\x0C\x0E-\x1F\x7F]/g, "");
+}
+
+// src/utils/mentions.ts
+var MENTION_PATTERNS = {
+  user: /<@([a-zA-Z0-9]+)>/g,
+  role: /<@&([a-zA-Z0-9]+)>/g,
+  channel: /<#([a-zA-Z0-9]+)>/g,
+  everyone: /@everyone/g,
+  here: /@here/g
+};
+function parseMentions(text) {
+  const mentions = [];
+  let match;
+  const userRegex = new RegExp(MENTION_PATTERNS.user.source, "g");
+  while ((match = userRegex.exec(text)) !== null) {
+    mentions.push({
+      type: "user",
+      id: match[1],
+      raw: match[0],
+      start: match.index,
+      end: match.index + match[0].length
+    });
+  }
+  const roleRegex = new RegExp(MENTION_PATTERNS.role.source, "g");
+  while ((match = roleRegex.exec(text)) !== null) {
+    mentions.push({
+      type: "role",
+      id: match[1],
+      raw: match[0],
+      start: match.index,
+      end: match.index + match[0].length
+    });
+  }
+  const channelRegex = new RegExp(MENTION_PATTERNS.channel.source, "g");
+  while ((match = channelRegex.exec(text)) !== null) {
+    mentions.push({
+      type: "channel",
+      id: match[1],
+      raw: match[0],
+      start: match.index,
+      end: match.index + match[0].length
+    });
+  }
+  const everyoneRegex = new RegExp(MENTION_PATTERNS.everyone.source, "g");
+  while ((match = everyoneRegex.exec(text)) !== null) {
+    mentions.push({
+      type: "everyone",
+      raw: match[0],
+      start: match.index,
+      end: match.index + match[0].length
+    });
+  }
+  const hereRegex = new RegExp(MENTION_PATTERNS.here.source, "g");
+  while ((match = hereRegex.exec(text)) !== null) {
+    mentions.push({
+      type: "here",
+      raw: match[0],
+      start: match.index,
+      end: match.index + match[0].length
+    });
+  }
+  return mentions.sort((a, b) => a.start - b.start);
+}
+function extractMentions(text) {
+  const parsed = parseMentions(text);
+  const memberIds = parsed.filter((m) => m.type === "user" && m.id).map((m) => m.id);
+  const roleIds = parsed.filter((m) => m.type === "role" && m.id).map((m) => m.id);
+  const channelIds = parsed.filter((m) => m.type === "channel" && m.id).map((m) => m.id);
+  const everyone = parsed.some((m) => m.type === "everyone" || m.type === "here");
+  return {
+    memberIds: [...new Set(memberIds)],
+    roleIds: [...new Set(roleIds)],
+    channelIds: [...new Set(channelIds)],
+    everyone,
+    totalMentionCount: memberIds.length + roleIds.length + channelIds.length
+  };
+}
+function formatMention(type, id) {
+  switch (type) {
+    case "user":
+      return `<@${id}>`;
+    case "role":
+      return `<@&${id}>`;
+    case "channel":
+      return `<#${id}>`;
+  }
+}
+
+// src/utils/formatting.ts
+function formatTime(timestamp) {
+  const date = new Date(timestamp);
+  return date.toLocaleTimeString([], { hour: "numeric", minute: "2-digit" });
+}
+function formatDate(timestamp) {
+  const date = new Date(timestamp);
+  return date.toLocaleDateString([], {
+    month: "short",
+    day: "numeric",
+    year: "numeric"
+  });
+}
+function formatDateTime(timestamp) {
+  const date = new Date(timestamp);
+  return date.toLocaleString([], {
+    month: "short",
+    day: "numeric",
+    year: "numeric",
+    hour: "numeric",
+    minute: "2-digit"
+  });
+}
+function formatRelativeTime(timestamp) {
+  const now = Date.now();
+  const diff = now - timestamp;
+  const seconds = Math.floor(diff / 1e3);
+  const minutes = Math.floor(seconds / 60);
+  const hours = Math.floor(minutes / 60);
+  const days = Math.floor(hours / 24);
+  if (seconds < 60) {
+    return "Just now";
+  }
+  if (minutes < 60) {
+    return `${minutes} minute${minutes === 1 ? "" : "s"} ago`;
+  }
+  if (hours < 24) {
+    return `${hours} hour${hours === 1 ? "" : "s"} ago`;
+  }
+  if (days === 1) {
+    return "Yesterday";
+  }
+  if (days < 7) {
+    return `${days} days ago`;
+  }
+  return formatDate(timestamp);
+}
+function formatMessageDate(timestamp) {
+  const date = new Date(timestamp);
+  const today = /* @__PURE__ */ new Date();
+  const yesterday = new Date(today);
+  yesterday.setDate(yesterday.getDate() - 1);
+  if (isSameDay(date, today)) {
+    return "Today";
+  }
+  if (isSameDay(date, yesterday)) {
+    return "Yesterday";
+  }
+  return date.toLocaleDateString([], {
+    weekday: "long",
+    month: "long",
+    day: "numeric",
+    year: date.getFullYear() !== today.getFullYear() ? "numeric" : void 0
+  });
+}
+function isSameDay(d1, d2) {
+  return d1.getFullYear() === d2.getFullYear() && d1.getMonth() === d2.getMonth() && d1.getDate() === d2.getDate();
+}
+function truncateText(text, maxLength) {
+  if (text.length <= maxLength) {
+    return text;
+  }
+  return text.slice(0, maxLength - 1) + "\u2026";
+}
+function formatFileSize(bytes) {
+  if (bytes === 0) return "0 B";
+  const k = 1024;
+  const sizes = ["B", "KB", "MB", "GB", "TB"];
+  const i = Math.floor(Math.log(bytes) / Math.log(k));
+  return parseFloat((bytes / Math.pow(k, i)).toFixed(1)) + " " + sizes[i];
+}
+function formatMemberCount(count) {
+  if (count < 1e3) {
+    return `${count} member${count === 1 ? "" : "s"}`;
+  }
+  if (count < 1e6) {
+    return `${(count / 1e3).toFixed(1)}K members`;
+  }
+  return `${(count / 1e6).toFixed(1)}M members`;
+}
+
+// src/utils/encoding.ts
+function hexToBytes(hex) {
+  const cleanHex = hex.startsWith("0x") ? hex.slice(2) : hex;
+  const bytes = [];
+  for (let i = 0; i < cleanHex.length; i += 2) {
+    bytes.push(parseInt(cleanHex.substr(i, 2), 16));
+  }
+  return bytes;
+}
+function bytesToHex(bytes) {
+  return Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+function base64ToBytes(base64) {
+  if (typeof atob === "function") {
+    const binaryString = atob(base64);
+    const bytes = new Uint8Array(binaryString.length);
+    for (let i = 0; i < binaryString.length; i++) {
+      bytes[i] = binaryString.charCodeAt(i);
+    }
+    return bytes;
+  } else {
+    return new Uint8Array(Buffer.from(base64, "base64"));
+  }
+}
+function bytesToBase64(bytes) {
+  if (typeof btoa === "function") {
+    const binaryString = Array.from(bytes).map((b) => String.fromCharCode(b)).join("");
+    return btoa(binaryString);
+  } else {
+    return Buffer.from(bytes).toString("base64");
+  }
+}
+function stringToBytes(str) {
+  const encoder = new TextEncoder();
+  return Array.from(encoder.encode(str));
+}
+function bytesToString(bytes) {
+  const decoder = new TextDecoder();
+  return decoder.decode(new Uint8Array(bytes));
+}
+function int64ToBytes(num) {
+  const arr = new Uint8Array(8);
+  const view = new DataView(arr.buffer);
+  view.setBigInt64(0, BigInt(num), false);
+  return arr;
+}
+
+// src/utils/logger.ts
+var LOG_LEVELS = {
+  debug: 0,
+  log: 1,
+  info: 2,
+  warn: 3,
+  error: 4
+};
+var config = {
+  enabled: true,
+  // Will be set based on environment
+  minLevel: "log"
+};
+function detectEnvironment() {
+  if (typeof __DEV__ !== "undefined") {
+    return __DEV__;
+  }
+  if (typeof process !== "undefined" && process.env) {
+    return process.env.NODE_ENV !== "production";
+  }
+  if (typeof window !== "undefined") {
+    return window.location?.hostname === "localhost";
+  }
+  return true;
+}
+config.enabled = detectEnvironment();
+function shouldLog(level) {
+  if (!config.enabled) return false;
+  return LOG_LEVELS[level] >= LOG_LEVELS[config.minLevel];
+}
+function createLogMethod(level) {
+  return (...args) => {
+    if (shouldLog(level)) {
+      console[level](...args);
+    }
+  };
+}
+var logger = {
+  /**
+   * Configure the logger
+   */
+  configure(newConfig) {
+    config = { ...config, ...newConfig };
+  },
+  /**
+   * Check if logging is enabled
+   */
+  isEnabled() {
+    return config.enabled;
+  },
+  /**
+   * Enable logging (useful for debugging production issues)
+   */
+  enable() {
+    config.enabled = true;
+  },
+  /**
+   * Disable logging
+   */
+  disable() {
+    config.enabled = false;
+  },
+  /**
+   * Log at debug level
+   */
+  debug: createLogMethod("debug"),
+  /**
+   * Log at default level
+   */
+  log: createLogMethod("log"),
+  /**
+   * Log at info level
+   */
+  info: createLogMethod("info"),
+  /**
+   * Log at warn level
+   */
+  warn: createLogMethod("warn"),
+  /**
+   * Log at error level (always logs unless explicitly disabled)
+   */
+  error: createLogMethod("error"),
+  /**
+   * Create a scoped logger with a prefix
+   */
+  scope(prefix) {
+    return {
+      debug: (...args) => logger.debug(prefix, ...args),
+      log: (...args) => logger.log(prefix, ...args),
+      info: (...args) => logger.info(prefix, ...args),
+      warn: (...args) => logger.warn(prefix, ...args),
+      error: (...args) => logger.error(prefix, ...args)
+    };
+  }
+};
+
+// src/crypto/encryption-state.ts
+var ENCRYPTION_STORAGE_KEYS = {
+  /** enc_state:{conversationId}:{inboxId} */
+  ENCRYPTION_STATE: "enc_state:",
+  /** inbox_map:{inboxId} */
+  INBOX_MAPPING: "inbox_map:",
+  /** latest:{conversationId} */
+  LATEST_STATE: "latest:",
+  /** conv_inboxes:{conversationId} -> inboxId[] */
+  CONVERSATION_INBOXES: "conv_inboxes:",
+  /** conv_inbox_key:{conversationId} -> ConversationInboxKeypair */
+  CONVERSATION_INBOX_KEY: "conv_inbox_key:"
+};
+
+// src/crypto/wasm-provider.ts
+function parseWasmResult(result) {
+  if (result.startsWith("invalid") || result.startsWith("error") || result.includes("failed") || result.includes("Error")) {
+    throw new Error(result);
+  }
+  try {
+    return JSON.parse(result);
+  } catch {
+    if (result.startsWith('"') && result.endsWith('"')) {
+      return result.slice(1, -1);
+    }
+    throw new Error(`Failed to parse WASM result: ${result}`);
+  }
+}
+var WasmCryptoProvider = class {
+  constructor(wasmModule) {
+    this.wasm = wasmModule;
+  }
+  // ============ Key Generation ============
+  async generateX448() {
+    const result = this.wasm.js_generate_x448();
+    const keypair = parseWasmResult(result);
+    return {
+      type: "x448",
+      public_key: keypair.public_key,
+      private_key: keypair.private_key
+    };
+  }
+  async generateEd448() {
+    const result = this.wasm.js_generate_ed448();
+    const keypair = parseWasmResult(result);
+    return {
+      type: "ed448",
+      public_key: keypair.public_key,
+      private_key: keypair.private_key
+    };
+  }
+  async getPublicKeyX448(privateKey) {
+    const result = this.wasm.js_get_pubkey_x448(privateKey);
+    return parseWasmResult(result);
+  }
+  async getPublicKeyEd448(privateKey) {
+    const result = this.wasm.js_get_pubkey_ed448(privateKey);
+    return parseWasmResult(result);
+  }
+  // ============ X3DH Key Agreement ============
+  async senderX3DH(params) {
+    const input = JSON.stringify({
+      sending_identity_private_key: params.sending_identity_private_key,
+      sending_ephemeral_private_key: params.sending_ephemeral_private_key,
+      receiving_identity_key: params.receiving_identity_key,
+      receiving_signed_pre_key: params.receiving_signed_pre_key,
+      session_key_length: params.session_key_length
+    });
+    const result = this.wasm.js_sender_x3dh(input);
+    if (result.startsWith("invalid") || result.includes("error")) {
+      throw new Error(result);
+    }
+    return result;
+  }
+  async receiverX3DH(params) {
+    const input = JSON.stringify({
+      sending_identity_private_key: params.sending_identity_private_key,
+      sending_signed_private_key: params.sending_signed_private_key,
+      receiving_identity_key: params.receiving_identity_key,
+      receiving_ephemeral_key: params.receiving_ephemeral_key,
+      session_key_length: params.session_key_length
+    });
+    const result = this.wasm.js_receiver_x3dh(input);
+    if (result.startsWith("invalid") || result.includes("error")) {
+      throw new Error(result);
+    }
+    return result;
+  }
+  // ============ Double Ratchet ============
+  async newDoubleRatchet(params) {
+    const input = JSON.stringify({
+      session_key: params.session_key,
+      sending_header_key: params.sending_header_key,
+      next_receiving_header_key: params.next_receiving_header_key,
+      is_sender: params.is_sender,
+      sending_ephemeral_private_key: params.sending_ephemeral_private_key,
+      receiving_ephemeral_key: params.receiving_ephemeral_key
+    });
+    const result = this.wasm.js_new_double_ratchet(input);
+    if (result.startsWith("invalid") || result.includes("error")) {
+      throw new Error(result);
+    }
+    return result;
+  }
+  async doubleRatchetEncrypt(stateAndMessage) {
+    const input = JSON.stringify({
+      ratchet_state: stateAndMessage.ratchet_state,
+      message: stateAndMessage.message
+    });
+    const result = this.wasm.js_double_ratchet_encrypt(input);
+    return parseWasmResult(result);
+  }
+  async doubleRatchetDecrypt(stateAndEnvelope) {
+    const input = JSON.stringify({
+      ratchet_state: stateAndEnvelope.ratchet_state,
+      envelope: stateAndEnvelope.envelope
+    });
+    const result = this.wasm.js_double_ratchet_decrypt(input);
+    return parseWasmResult(result);
+  }
+  // ============ Triple Ratchet ============
+  async newTripleRatchet(params) {
+    const input = JSON.stringify({
+      peers: params.peers,
+      peer_key: params.peer_key,
+      identity_key: params.identity_key,
+      signed_pre_key: params.signed_pre_key,
+      threshold: params.threshold,
+      async_dkg_ratchet: params.async_dkg_ratchet
+    });
+    const result = this.wasm.js_new_triple_ratchet(input);
+    return parseWasmResult(result);
+  }
+  async tripleRatchetInitRound1(state) {
+    const input = JSON.stringify(state);
+    const result = this.wasm.js_triple_ratchet_init_round_1(input);
+    return parseWasmResult(result);
+  }
+  async tripleRatchetInitRound2(state) {
+    const input = JSON.stringify(state);
+    const result = this.wasm.js_triple_ratchet_init_round_2(input);
+    return parseWasmResult(result);
+  }
+  async tripleRatchetInitRound3(state) {
+    const input = JSON.stringify(state);
+    const result = this.wasm.js_triple_ratchet_init_round_3(input);
+    return parseWasmResult(result);
+  }
+  async tripleRatchetInitRound4(state) {
+    const input = JSON.stringify(state);
+    const result = this.wasm.js_triple_ratchet_init_round_4(input);
+    return parseWasmResult(result);
+  }
+  async tripleRatchetEncrypt(stateAndMessage) {
+    const input = JSON.stringify({
+      ratchet_state: stateAndMessage.ratchet_state,
+      message: stateAndMessage.message
+    });
+    const result = this.wasm.js_triple_ratchet_encrypt(input);
+    return parseWasmResult(result);
+  }
+  async tripleRatchetDecrypt(stateAndEnvelope) {
+    const input = JSON.stringify({
+      ratchet_state: stateAndEnvelope.ratchet_state,
+      envelope: stateAndEnvelope.envelope
+    });
+    const result = this.wasm.js_triple_ratchet_decrypt(input);
+    return parseWasmResult(result);
+  }
+  async tripleRatchetResize(state) {
+    const input = JSON.stringify(state);
+    const result = this.wasm.js_triple_ratchet_resize(input);
+    return parseWasmResult(result);
+  }
+  // ============ Inbox Message Encryption ============
+  async encryptInboxMessage(request) {
+    const input = JSON.stringify({
+      inbox_public_key: request.inbox_public_key,
+      ephemeral_private_key: request.ephemeral_private_key,
+      plaintext: request.plaintext
+    });
+    const result = this.wasm.js_encrypt_inbox_message(input);
+    if (result.startsWith("invalid") || result.includes("error")) {
+      throw new Error(result);
+    }
+    return result;
+  }
+  async decryptInboxMessage(request) {
+    const input = JSON.stringify({
+      inbox_private_key: request.inbox_private_key,
+      ephemeral_public_key: request.ephemeral_public_key,
+      ciphertext: request.ciphertext
+    });
+    const result = this.wasm.js_decrypt_inbox_message(input);
+    return parseWasmResult(result);
+  }
+};
+
+// src/signing/types.ts
+async function verifySignedMessage(provider, message) {
+  const payload = `${message.content}:${message.timestamp}`;
+  const payloadBase64 = btoa(payload);
+  return provider.verifyEd448(message.publicKey, payloadBase64, message.signature);
+}
+async function createSignedMessage(provider, privateKey, publicKey, content) {
+  const timestamp = Date.now();
+  const payload = `${content}:${timestamp}`;
+  const payloadBase64 = btoa(payload);
+  const signature = await provider.signEd448(privateKey, payloadBase64);
+  return {
+    content,
+    signature,
+    publicKey,
+    timestamp
+  };
+}
+
+// src/signing/wasm-provider.ts
+function parseVerifyResult(result) {
+  const normalized = result.toLowerCase().trim();
+  if (normalized === "true" || normalized === "valid") {
+    return true;
+  }
+  if (normalized === "false" || normalized === "invalid") {
+    return false;
+  }
+  if (result.startsWith("invalid") || result.startsWith("error") || result.includes("failed") || result.includes("Error")) {
+    throw new Error(result);
+  }
+  try {
+    return JSON.parse(result);
+  } catch {
+    throw new Error(`Unexpected verification result: ${result}`);
+  }
+}
+var WasmSigningProvider = class {
+  constructor(wasmModule) {
+    this.wasm = wasmModule;
+  }
+  async signEd448(privateKey, message) {
+    const result = this.wasm.js_sign_ed448(privateKey, message);
+    if (result.startsWith("invalid") || result.startsWith("error") || result.includes("failed") || result.includes("Error")) {
+      throw new Error(result);
+    }
+    if (result.startsWith('"') && result.endsWith('"')) {
+      return result.slice(1, -1);
+    }
+    return result;
+  }
+  async verifyEd448(publicKey, message, signature) {
+    const result = this.wasm.js_verify_ed448(publicKey, message, signature);
+    return parseVerifyResult(result);
+  }
+};
+
+// src/transport/browser-websocket.ts
+var BrowserWebSocketClient = class {
+  constructor(options) {
+    this.ws = null;
+    this._state = "disconnected";
+    this.reconnectAttempts = 0;
+    this.shouldReconnect = true;
+    // Queue system
+    this.inboundQueue = [];
+    this.outboundQueue = [];
+    this.isProcessing = false;
+    this.processIntervalId = null;
+    // Handlers
+    this.messageHandler = null;
+    this.resubscribeHandler = null;
+    this.stateChangeHandlers = /* @__PURE__ */ new Set();
+    this.errorHandlers = /* @__PURE__ */ new Set();
+    this.url = options.url;
+    this.reconnectInterval = options.reconnectInterval ?? 1e3;
+    this.maxReconnectAttempts = options.maxReconnectAttempts ?? Infinity;
+    this.queueProcessInterval = options.queueProcessInterval ?? 1e3;
+  }
+  get state() {
+    return this._state;
+  }
+  get isConnected() {
+    return this._state === "connected";
+  }
+  setState(newState) {
+    if (this._state !== newState) {
+      this._state = newState;
+      this.stateChangeHandlers.forEach((handler) => {
+        try {
+          handler(newState);
+        } catch (error) {
+          console.error("Error in state change handler:", error);
+        }
+      });
+    }
+  }
+  emitError(error) {
+    this.errorHandlers.forEach((handler) => {
+      try {
+        handler(error);
+      } catch (e) {
+        console.error("Error in error handler:", e);
+      }
+    });
+  }
+  async connect() {
+    if (this._state === "connected" || this._state === "connecting") {
+      return;
+    }
+    this.shouldReconnect = true;
+    return this.doConnect();
+  }
+  doConnect() {
+    return new Promise((resolve, reject) => {
+      this.setState("connecting");
+      try {
+        this.ws = new WebSocket(this.url);
+        this.ws.onopen = () => {
+          this.reconnectAttempts = 0;
+          this.setState("connected");
+          this.startQueueProcessing();
+          if (this.resubscribeHandler) {
+            this.resubscribeHandler().catch((error) => {
+              console.error("Error in resubscribe handler:", error);
+            });
+          }
+          this.processQueues();
+          resolve();
+        };
+        this.ws.onclose = () => {
+          this.setState("disconnected");
+          this.stopQueueProcessing();
+          if (this.shouldReconnect && this.reconnectAttempts < this.maxReconnectAttempts) {
+            this.reconnectAttempts++;
+            this.setState("reconnecting");
+            setTimeout(() => this.doConnect(), this.reconnectInterval);
+          }
+        };
+        this.ws.onerror = (event) => {
+          const error = new Error("WebSocket error");
+          this.emitError(error);
+          reject(error);
+        };
+        this.ws.onmessage = (event) => {
+          try {
+            const message = JSON.parse(event.data);
+            this.inboundQueue.push(message);
+            this.processQueues();
+          } catch (error) {
+            console.error("Failed to parse WebSocket message:", error);
+          }
+        };
+      } catch (error) {
+        this.setState("disconnected");
+        reject(error);
+      }
+    });
+  }
+  disconnect() {
+    this.shouldReconnect = false;
+    this.stopQueueProcessing();
+    if (this.ws) {
+      this.ws.close();
+      this.ws = null;
+    }
+    this.setState("disconnected");
+  }
+  async send(message) {
+    if (this.ws?.readyState === WebSocket.OPEN) {
+      this.ws.send(message);
+    } else {
+      this.outboundQueue.push(async () => [message]);
+    }
+  }
+  enqueueOutbound(prepareMessage) {
+    this.outboundQueue.push(prepareMessage);
+    this.processQueues();
+  }
+  async subscribe(inboxAddresses) {
+    const message = JSON.stringify({
+      type: "listen",
+      inbox_addresses: inboxAddresses
+    });
+    await this.send(message);
+  }
+  async unsubscribe(inboxAddresses) {
+    const message = JSON.stringify({
+      type: "unlisten",
+      inbox_addresses: inboxAddresses
+    });
+    await this.send(message);
+  }
+  setMessageHandler(handler) {
+    this.messageHandler = handler;
+    this.processQueues();
+  }
+  setResubscribeHandler(handler) {
+    this.resubscribeHandler = handler;
+  }
+  onStateChange(handler) {
+    this.stateChangeHandlers.add(handler);
+    return () => {
+      this.stateChangeHandlers.delete(handler);
+    };
+  }
+  onError(handler) {
+    this.errorHandlers.add(handler);
+    return () => {
+      this.errorHandlers.delete(handler);
+    };
+  }
+  startQueueProcessing() {
+    if (this.processIntervalId === null) {
+      this.processIntervalId = setInterval(() => {
+        this.processQueues();
+      }, this.queueProcessInterval);
+    }
+  }
+  stopQueueProcessing() {
+    if (this.processIntervalId !== null) {
+      clearInterval(this.processIntervalId);
+      this.processIntervalId = null;
+    }
+  }
+  async processQueues() {
+    if (this.isProcessing) {
+      return;
+    }
+    this.isProcessing = true;
+    try {
+      if (this.messageHandler) {
+        const inboxMap = /* @__PURE__ */ new Map();
+        while (this.inboundQueue.length > 0) {
+          const message = this.inboundQueue.shift();
+          const existing = inboxMap.get(message.inboxAddress) || [];
+          existing.push(message);
+          inboxMap.set(message.inboxAddress, existing);
+        }
+        const promises = [];
+        for (const [_, messages] of inboxMap) {
+          promises.push(
+            (async () => {
+              for (const message of messages) {
+                try {
+                  await this.messageHandler(message);
+                } catch (error) {
+                  console.error("Error processing inbound message:", error);
+                }
+              }
+            })()
+          );
+        }
+        await Promise.allSettled(promises);
+      }
+      if (this.ws?.readyState === WebSocket.OPEN) {
+        while (this.outboundQueue.length > 0) {
+          const prepareMessage = this.outboundQueue.shift();
+          try {
+            const messages = await prepareMessage();
+            for (const m of messages) {
+              this.ws.send(m);
+            }
+          } catch (error) {
+            console.error("Error processing outbound message:", error);
+          }
+        }
+      }
+    } finally {
+      this.isProcessing = false;
+    }
+  }
+};
+function createBrowserWebSocketClient(options) {
+  return new BrowserWebSocketClient(options);
+}
+
+// src/transport/rn-websocket.ts
+var RNWebSocketClient = class {
+  constructor(options) {
+    this.ws = null;
+    this._state = "disconnected";
+    this.reconnectAttempts = 0;
+    this.shouldReconnect = true;
+    // Queue system
+    this.inboundQueue = [];
+    this.outboundQueue = [];
+    this.isProcessing = false;
+    this.processIntervalId = null;
+    // Handlers
+    this.messageHandler = null;
+    this.resubscribeHandler = null;
+    this.stateChangeHandlers = /* @__PURE__ */ new Set();
+    this.errorHandlers = /* @__PURE__ */ new Set();
+    this.url = options.url;
+    this.reconnectInterval = options.reconnectInterval ?? 1e3;
+    this.maxReconnectAttempts = options.maxReconnectAttempts ?? Infinity;
+    this.queueProcessInterval = options.queueProcessInterval ?? 1e3;
+  }
+  get state() {
+    return this._state;
+  }
+  get isConnected() {
+    return this._state === "connected";
+  }
+  setState(newState) {
+    if (this._state !== newState) {
+      this._state = newState;
+      this.stateChangeHandlers.forEach((handler) => {
+        try {
+          handler(newState);
+        } catch (error) {
+          console.error("Error in state change handler:", error);
+        }
+      });
+    }
+  }
+  emitError(error) {
+    this.errorHandlers.forEach((handler) => {
+      try {
+        handler(error);
+      } catch (e) {
+        console.error("Error in error handler:", e);
+      }
+    });
+  }
+  async connect() {
+    if (this._state === "connected" || this._state === "connecting") {
+      return;
+    }
+    this.shouldReconnect = true;
+    return this.doConnect();
+  }
+  doConnect() {
+    return new Promise((resolve, reject) => {
+      this.setState("connecting");
+      try {
+        this.ws = new WebSocket(this.url);
+        this.ws.onopen = () => {
+          this.reconnectAttempts = 0;
+          this.setState("connected");
+          this.startQueueProcessing();
+          if (this.resubscribeHandler) {
+            this.resubscribeHandler().catch((error) => {
+              console.error("Error in resubscribe handler:", error);
+            });
+          }
+          this.processQueues();
+          resolve();
+        };
+        this.ws.onclose = () => {
+          this.setState("disconnected");
+          this.stopQueueProcessing();
+          if (this.shouldReconnect && this.reconnectAttempts < this.maxReconnectAttempts) {
+            this.reconnectAttempts++;
+            this.setState("reconnecting");
+            setTimeout(() => this.doConnect(), this.reconnectInterval);
+          }
+        };
+        this.ws.onerror = () => {
+          const error = new Error("WebSocket error");
+          this.emitError(error);
+          reject(error);
+        };
+        this.ws.onmessage = (event) => {
+          try {
+            logger.debug("[WS-RN] Raw message received:", event.data?.substring(0, 200));
+            if (!event.data || !event.data.startsWith("{")) {
+              logger.debug("[WS-RN] Ignoring non-JSON message");
+              return;
+            }
+            const message = JSON.parse(event.data);
+            if (!message.inboxAddress && !message.encryptedContent) {
+              logger.debug("[WS-RN] Ignoring message without expected fields:", Object.keys(message));
+              return;
+            }
+            this.inboundQueue.push(message);
+            this.processQueues();
+          } catch (error) {
+            console.error("Failed to parse WebSocket message:", error, "raw:", event.data?.substring(0, 100));
+          }
+        };
+      } catch (error) {
+        this.setState("disconnected");
+        reject(error);
+      }
+    });
+  }
+  disconnect() {
+    this.shouldReconnect = false;
+    this.stopQueueProcessing();
+    if (this.ws) {
+      this.ws.close();
+      this.ws = null;
+    }
+    this.setState("disconnected");
+  }
+  async send(message) {
+    if (this.ws?.readyState === WebSocket.OPEN) {
+      this.ws.send(message);
+    } else {
+      this.outboundQueue.push(async () => [message]);
+    }
+  }
+  enqueueOutbound(prepareMessage) {
+    this.outboundQueue.push(prepareMessage);
+    this.processQueues();
+  }
+  async subscribe(inboxAddresses) {
+    const message = JSON.stringify({
+      type: "listen",
+      inbox_addresses: inboxAddresses
+    });
+    await this.send(message);
+  }
+  async unsubscribe(inboxAddresses) {
+    const message = JSON.stringify({
+      type: "unlisten",
+      inbox_addresses: inboxAddresses
+    });
+    await this.send(message);
+  }
+  setMessageHandler(handler) {
+    this.messageHandler = handler;
+    this.processQueues();
+  }
+  setResubscribeHandler(handler) {
+    this.resubscribeHandler = handler;
+  }
+  onStateChange(handler) {
+    this.stateChangeHandlers.add(handler);
+    return () => {
+      this.stateChangeHandlers.delete(handler);
+    };
+  }
+  onError(handler) {
+    this.errorHandlers.add(handler);
+    return () => {
+      this.errorHandlers.delete(handler);
+    };
+  }
+  startQueueProcessing() {
+    if (this.processIntervalId === null) {
+      this.processIntervalId = setInterval(() => {
+        this.processQueues();
+      }, this.queueProcessInterval);
+    }
+  }
+  stopQueueProcessing() {
+    if (this.processIntervalId !== null) {
+      clearInterval(this.processIntervalId);
+      this.processIntervalId = null;
+    }
+  }
+  async processQueues() {
+    if (this.isProcessing) {
+      return;
+    }
+    this.isProcessing = true;
+    try {
+      if (this.messageHandler) {
+        const inboxMap = /* @__PURE__ */ new Map();
+        while (this.inboundQueue.length > 0) {
+          const message = this.inboundQueue.shift();
+          const existing = inboxMap.get(message.inboxAddress) || [];
+          existing.push(message);
+          inboxMap.set(message.inboxAddress, existing);
+        }
+        const promises = [];
+        for (const [_, messages] of inboxMap) {
+          promises.push(
+            (async () => {
+              for (const message of messages) {
+                try {
+                  await this.messageHandler(message);
+                } catch (error) {
+                  console.error("Error processing inbound message:", error);
+                }
+              }
+            })()
+          );
+        }
+        await Promise.allSettled(promises);
+      }
+      if (this.ws?.readyState === WebSocket.OPEN) {
+        while (this.outboundQueue.length > 0) {
+          const prepareMessage = this.outboundQueue.shift();
+          try {
+            const messages = await prepareMessage();
+            for (const m of messages) {
+              this.ws.send(m);
+            }
+          } catch (error) {
+            console.error("Error processing outbound message:", error);
+          }
+        }
+      }
+    } finally {
+      this.isProcessing = false;
+    }
+  }
+};
+function createRNWebSocketClient(options) {
+  return new RNWebSocketClient(options);
+}
+
+// src/sync/types.ts
+function isSyncRequest(payload) {
+  return payload.type === "sync-request";
+}
+function isSyncInfo(payload) {
+  return payload.type === "sync-info";
+}
+function isSyncInitiate(payload) {
+  return payload.type === "sync-initiate";
+}
+function isSyncManifest(payload) {
+  return payload.type === "sync-manifest";
+}
+function isSyncDelta(payload) {
+  return payload.type === "sync-delta";
+}
+
+// src/sync/utils.ts
+import { sha256 } from "@noble/hashes/sha2";
+var MAX_CHUNK_SIZE = 5 * 1024 * 1024;
+var DEFAULT_SYNC_EXPIRY_MS = 3e4;
+var AGGRESSIVE_SYNC_TIMEOUT_MS = 1e3;
+function computeHash(data) {
+  const hash = sha256(new TextEncoder().encode(data));
+  return bytesToHex(hash);
+}
+function computeContentHash(message) {
+  const content = message.content;
+  let canonical = `${content.senderId}:${content.type}`;
+  switch (content.type) {
+    case "post":
+      canonical += `:${Array.isArray(content.text) ? content.text.join("\n") : content.text}`;
+      if (content.repliesToMessageId) {
+        canonical += `:reply:${content.repliesToMessageId}`;
+      }
+      break;
+    case "embed":
+      canonical += `:${content.imageUrl || ""}:${content.videoUrl || ""}`;
+      if (content.repliesToMessageId) {
+        canonical += `:reply:${content.repliesToMessageId}`;
+      }
+      break;
+    case "sticker":
+      canonical += `:${content.stickerId}`;
+      if (content.repliesToMessageId) {
+        canonical += `:reply:${content.repliesToMessageId}`;
+      }
+      break;
+    case "edit-message":
+      canonical += `:${content.originalMessageId}:${Array.isArray(content.editedText) ? content.editedText.join("\n") : content.editedText}:${content.editedAt}`;
+      break;
+    case "remove-message":
+      canonical += `:${content.removeMessageId}`;
+      break;
+    case "join":
+    case "leave":
+    case "kick":
+      break;
+    case "event":
+      canonical += `:${content.text}`;
+      break;
+    case "update-profile":
+      canonical += `:${content.displayName}:${content.userIcon}`;
+      break;
+    case "mute":
+      canonical += `:${content.targetUserId}:${content.action}:${content.muteId}`;
+      break;
+    case "pin":
+      canonical += `:${content.targetMessageId}:${content.action}`;
+      break;
+    case "reaction":
+    case "remove-reaction":
+      canonical += `:${content.messageId}:${content.reaction}`;
+      break;
+    case "delete-conversation":
+      break;
+  }
+  return computeHash(canonical);
+}
+function computeReactionHash(reactions) {
+  if (!reactions || reactions.length === 0) {
+    return computeHash("");
+  }
+  const sorted = [...reactions].sort((a, b) => a.emojiId.localeCompare(b.emojiId));
+  const canonical = sorted.map((r) => {
+    const sortedMembers = [...r.memberIds].sort();
+    return `${r.emojiId}:${sortedMembers.join(",")}`;
+  }).join("|");
+  return computeHash(canonical);
+}
+function computeMemberHash(member) {
+  const displayNameHash = computeHash(member.display_name || "");
+  const iconHash = computeHash(member.profile_image || "");
+  return { displayNameHash, iconHash };
+}
+function computeManifestHash(digests) {
+  if (digests.length === 0) {
+    return computeHash("");
+  }
+  const sorted = [...digests].sort((a, b) => a.messageId.localeCompare(b.messageId));
+  const ids = sorted.map((d) => d.messageId).join(":");
+  return computeHash(ids);
+}
+function createMessageDigest(message) {
+  return {
+    messageId: message.messageId,
+    createdDate: message.createdDate,
+    contentHash: computeContentHash(message),
+    modifiedDate: message.modifiedDate !== message.createdDate ? message.modifiedDate : void 0
+  };
+}
+function createReactionDigest(messageId, reactions) {
+  if (!reactions || reactions.length === 0) {
+    return [];
+  }
+  return reactions.map((r) => ({
+    messageId,
+    emojiId: r.emojiId,
+    count: r.count,
+    membersHash: computeHash([...r.memberIds].sort().join(","))
+  }));
+}
+function createManifest(spaceId, channelId, messages) {
+  const sorted = [...messages].sort((a, b) => a.createdDate - b.createdDate);
+  const digests = sorted.map(createMessageDigest);
+  const reactionDigests = [];
+  for (const msg of sorted) {
+    if (msg.reactions && msg.reactions.length > 0) {
+      reactionDigests.push(...createReactionDigest(msg.messageId, msg.reactions));
+    }
+  }
+  return {
+    spaceId,
+    channelId,
+    messageCount: messages.length,
+    oldestTimestamp: sorted[0]?.createdDate || 0,
+    newestTimestamp: sorted[sorted.length - 1]?.createdDate || 0,
+    digests,
+    reactionDigests
+  };
+}
+function createMemberDigest(member) {
+  const { displayNameHash, iconHash } = computeMemberHash(member);
+  return {
+    address: member.address,
+    inboxAddress: member.inbox_address || "",
+    displayNameHash,
+    iconHash
+  };
+}
+function computeMessageDiff(ourManifest, theirManifest) {
+  const ourDigests = new Map(ourManifest.digests.map((d) => [d.messageId, d]));
+  const theirDigests = new Map(theirManifest.digests.map((d) => [d.messageId, d]));
+  const missingIds = [];
+  const outdatedIds = [];
+  const extraIds = [];
+  for (const [id, theirDigest] of theirDigests) {
+    const ourDigest = ourDigests.get(id);
+    if (!ourDigest) {
+      missingIds.push(id);
+    } else if (ourDigest.contentHash !== theirDigest.contentHash) {
+      const theirModified = theirDigest.modifiedDate || theirDigest.createdDate;
+      const ourModified = ourDigest.modifiedDate || ourDigest.createdDate;
+      if (theirModified > ourModified) {
+        outdatedIds.push(id);
+      }
+    }
+  }
+  for (const [id] of ourDigests) {
+    if (!theirDigests.has(id)) {
+      extraIds.push(id);
+    }
+  }
+  return { missingIds, outdatedIds, extraIds };
+}
+function computeReactionDiff(ourReactions, theirDigests) {
+  const toAdd = [];
+  const toRemove = [];
+  const theirByMessage = /* @__PURE__ */ new Map();
+  for (const digest of theirDigests) {
+    const existing = theirByMessage.get(digest.messageId) || [];
+    existing.push(digest);
+    theirByMessage.set(digest.messageId, existing);
+  }
+  for (const [messageId, theirMsgDigests] of theirByMessage) {
+    const ourMsgReactions = ourReactions.get(messageId) || [];
+    const ourByEmoji = new Map(ourMsgReactions.map((r) => [r.emojiId, r]));
+    for (const theirDigest of theirMsgDigests) {
+      const ourReaction = ourByEmoji.get(theirDigest.emojiId);
+      if (!ourReaction) {
+        continue;
+      }
+      const ourMembersHash = computeHash([...ourReaction.memberIds].sort().join(","));
+      if (ourMembersHash !== theirDigest.membersHash) {
+      }
+    }
+  }
+  return { toAdd, toRemove };
+}
+function computeMemberDiff(ourDigests, theirDigests) {
+  const ourMap = new Map(ourDigests.map((d) => [d.address, d]));
+  const theirMap = new Map(theirDigests.map((d) => [d.address, d]));
+  const missingAddresses = [];
+  const outdatedAddresses = [];
+  const extraAddresses = [];
+  for (const [address, theirDigest] of theirMap) {
+    const ourDigest = ourMap.get(address);
+    if (!ourDigest) {
+      missingAddresses.push(address);
+    } else if (ourDigest.displayNameHash !== theirDigest.displayNameHash || ourDigest.iconHash !== theirDigest.iconHash) {
+      outdatedAddresses.push(address);
+    }
+  }
+  for (const [address] of ourMap) {
+    if (!theirMap.has(address)) {
+      extraAddresses.push(address);
+    }
+  }
+  return { missingAddresses, outdatedAddresses, extraAddresses };
+}
+function computePeerDiff(ourPeerIds, theirPeerIds) {
+  const ourSet = new Set(ourPeerIds);
+  const theirSet = new Set(theirPeerIds);
+  const missingPeerIds = theirPeerIds.filter((id) => !ourSet.has(id));
+  const extraPeerIds = ourPeerIds.filter((id) => !theirSet.has(id));
+  return { missingPeerIds, extraPeerIds };
+}
+function buildMessageDelta(spaceId, channelId, diff, messageMap, tombstones) {
+  const newMessages = diff.extraIds.map((id) => messageMap.get(id)).filter((m) => m !== void 0);
+  const updatedMessages = diff.outdatedIds.map((id) => messageMap.get(id)).filter((m) => m !== void 0);
+  const deletedMessageIds = tombstones.filter((t) => t.spaceId === spaceId && t.channelId === channelId).map((t) => t.messageId);
+  return {
+    spaceId,
+    channelId,
+    newMessages,
+    updatedMessages,
+    deletedMessageIds
+  };
+}
+function buildReactionDelta(spaceId, channelId, messageMap, messageIds) {
+  const added = [];
+  for (const messageId of messageIds) {
+    const message = messageMap.get(messageId);
+    if (message?.reactions) {
+      for (const reaction of message.reactions) {
+        added.push({
+          messageId,
+          emojiId: reaction.emojiId,
+          memberIds: reaction.memberIds
+        });
+      }
+    }
+  }
+  return {
+    spaceId,
+    channelId,
+    added,
+    removed: []
+    // Removed reactions are harder to track without explicit tombstones
+  };
+}
+function buildMemberDelta(spaceId, diff, memberMap) {
+  const addresses = [...diff.missingAddresses, ...diff.outdatedAddresses];
+  const members = addresses.map((addr) => memberMap.get(addr)).filter((m) => m !== void 0);
+  return {
+    spaceId,
+    members,
+    removedAddresses: []
+    // Would need explicit tracking
+  };
+}
+function chunkMessages(messages) {
+  const chunks = [];
+  let currentChunk = [];
+  let currentSize = 0;
+  for (const msg of messages) {
+    const msgSize = JSON.stringify(msg).length;
+    if (msgSize > MAX_CHUNK_SIZE) {
+      if (currentChunk.length > 0) {
+        chunks.push(currentChunk);
+        currentChunk = [];
+        currentSize = 0;
+      }
+      chunks.push([msg]);
+      continue;
+    }
+    if (currentSize + msgSize > MAX_CHUNK_SIZE && currentChunk.length > 0) {
+      chunks.push(currentChunk);
+      currentChunk = [];
+      currentSize = 0;
+    }
+    currentChunk.push(msg);
+    currentSize += msgSize;
+  }
+  if (currentChunk.length > 0) {
+    chunks.push(currentChunk);
+  }
+  return chunks;
+}
+function chunkMembers(members) {
+  const chunks = [];
+  let currentChunk = [];
+  let currentSize = 0;
+  for (const member of members) {
+    const memberSize = JSON.stringify(member).length;
+    if (currentSize + memberSize > MAX_CHUNK_SIZE && currentChunk.length > 0) {
+      chunks.push(currentChunk);
+      currentChunk = [];
+      currentSize = 0;
+    }
+    currentChunk.push(member);
+    currentSize += memberSize;
+  }
+  if (currentChunk.length > 0) {
+    chunks.push(currentChunk);
+  }
+  return chunks;
+}
+function createSyncSummary(messages, memberCount) {
+  const digests = messages.map(createMessageDigest);
+  const sorted = [...messages].sort((a, b) => a.createdDate - b.createdDate);
+  return {
+    memberCount,
+    messageCount: messages.length,
+    newestMessageTimestamp: sorted[sorted.length - 1]?.createdDate || 0,
+    oldestMessageTimestamp: sorted[0]?.createdDate || 0,
+    manifestHash: computeManifestHash(digests)
+  };
+}
+
+// src/sync/service.ts
+var SyncService = class {
+  constructor(config2) {
+    /** Active sync sessions by spaceId */
+    this.sessions = /* @__PURE__ */ new Map();
+    /** Deleted message tombstones (caller must persist these) */
+    this.tombstones = [];
+    /** Pre-computed sync payload cache per space:channel - always ready to use */
+    this.payloadCache = /* @__PURE__ */ new Map();
+    this.storage = config2.storage;
+    this.maxMessages = config2.maxMessages ?? 1e3;
+    this.requestExpiry = config2.requestExpiry ?? DEFAULT_SYNC_EXPIRY_MS;
+    this.onInitiateSync = config2.onInitiateSync;
+  }
+  // ============ Payload Cache Management ============
+  /**
+   * Get cache key for space/channel
+   */
+  getCacheKey(spaceId, channelId) {
+    return `${spaceId}:${channelId}`;
+  }
+  /**
+   * Get or initialize the payload cache for a space/channel.
+   * If not cached, loads from storage and builds the payload once.
+   */
+  async getPayloadCache(spaceId, channelId) {
+    const key = this.getCacheKey(spaceId, channelId);
+    const cached = this.payloadCache.get(key);
+    if (cached) {
+      logger.log(`[SyncService] Using cached payload for ${spaceId.substring(0, 12)}:${channelId.substring(0, 12)}`);
+      return cached;
+    }
+    logger.log(`[SyncService] Building initial payload cache for ${spaceId.substring(0, 12)}:${channelId.substring(0, 12)}`);
+    const messages = await this.getChannelMessages(spaceId, channelId);
+    const members = await this.storage.getSpaceMembers(spaceId);
+    const payload = this.buildPayloadCache(spaceId, channelId, messages, members);
+    this.payloadCache.set(key, payload);
+    return payload;
+  }
+  /**
+   * Build the payload cache from messages and members
+   */
+  buildPayloadCache(spaceId, channelId, messages, members) {
+    const messageMap = new Map(messages.map((m) => [m.messageId, m]));
+    const memberMap = new Map(members.map((m) => [m.address, m]));
+    const manifest = createManifest(spaceId, channelId, messages);
+    const memberDigests = members.map(createMemberDigest);
+    const summary = createSyncSummary(messages, members.length);
+    return { manifest, memberDigests, summary, messageMap, memberMap };
+  }
+  /**
+   * Rebuild derived fields (manifest, digests, summary) from the maps
+   */
+  rebuildPayloadCache(spaceId, channelId, cache) {
+    const messages = [...cache.messageMap.values()];
+    const members = [...cache.memberMap.values()];
+    cache.manifest = createManifest(spaceId, channelId, messages);
+    cache.memberDigests = members.map(createMemberDigest);
+    cache.summary = createSyncSummary(messages, members.length);
+  }
+  /**
+   * Invalidate cache for a space/channel (forces reload from storage on next access)
+   */
+  invalidateCache(spaceId, channelId) {
+    if (channelId) {
+      const key = this.getCacheKey(spaceId, channelId);
+      this.payloadCache.delete(key);
+      logger.log(`[SyncService] Invalidated cache for ${spaceId.substring(0, 12)}:${channelId.substring(0, 12)}`);
+    } else {
+      for (const key of this.payloadCache.keys()) {
+        if (key.startsWith(`${spaceId}:`)) {
+          this.payloadCache.delete(key);
+        }
+      }
+      logger.log(`[SyncService] Invalidated all caches for space ${spaceId.substring(0, 12)}`);
+    }
+  }
+  /**
+   * Update cache with a new/updated message (incremental update - no storage query)
+   */
+  updateCacheWithMessage(spaceId, channelId, message) {
+    const key = this.getCacheKey(spaceId, channelId);
+    const cached = this.payloadCache.get(key);
+    if (cached) {
+      cached.messageMap.set(message.messageId, message);
+      this.rebuildPayloadCache(spaceId, channelId, cached);
+      logger.log(`[SyncService] Updated cache with message ${message.messageId.substring(0, 12)}`);
+    }
+  }
+  /**
+   * Remove a message from cache (incremental update - no storage query)
+   */
+  removeCacheMessage(spaceId, channelId, messageId) {
+    const key = this.getCacheKey(spaceId, channelId);
+    const cached = this.payloadCache.get(key);
+    if (cached) {
+      cached.messageMap.delete(messageId);
+      this.rebuildPayloadCache(spaceId, channelId, cached);
+      logger.log(`[SyncService] Removed message ${messageId.substring(0, 12)} from cache`);
+    }
+  }
+  /**
+   * Update cache with a new/updated member (incremental update - no storage query)
+   */
+  updateCacheWithMember(spaceId, channelId, member) {
+    const key = this.getCacheKey(spaceId, channelId);
+    const cached = this.payloadCache.get(key);
+    if (cached) {
+      cached.memberMap.set(member.address, member);
+      this.rebuildPayloadCache(spaceId, channelId, cached);
+      logger.log(`[SyncService] Updated cache with member ${member.address.substring(0, 12)}`);
+    }
+  }
+  /**
+   * Check if cache exists for a space/channel
+   */
+  hasCachedPayload(spaceId, channelId) {
+    return this.payloadCache.has(this.getCacheKey(spaceId, channelId));
+  }
+  // ============ Session Management ============
+  /**
+   * Check if a sync session is active for a space
+   */
+  hasActiveSession(spaceId) {
+    const session = this.sessions.get(spaceId);
+    if (!session) return false;
+    if (Date.now() > session.expiry) {
+      this.sessions.delete(spaceId);
+      return false;
+    }
+    return true;
+  }
+  /**
+   * Check if sync is in progress for a space
+   */
+  isSyncInProgress(spaceId) {
+    const session = this.sessions.get(spaceId);
+    return session?.inProgress ?? false;
+  }
+  /**
+   * Mark sync as in progress
+   */
+  setSyncInProgress(spaceId, inProgress) {
+    const session = this.sessions.get(spaceId);
+    if (session) {
+      session.inProgress = inProgress;
+    }
+  }
+  /**
+   * Set the sync target (who we're syncing with)
+   */
+  setSyncTarget(spaceId, targetInbox) {
+    const session = this.sessions.get(spaceId);
+    if (session) {
+      session.syncTarget = targetInbox;
+    }
+  }
+  /**
+   * Get the sync target for a space
+   */
+  getSyncTarget(spaceId) {
+    const session = this.sessions.get(spaceId);
+    return session?.syncTarget;
+  }
+  // ============ Step 1: Sync Request ============
+  /**
+   * Build sync-request payload to broadcast via hub
+   */
+  async buildSyncRequest(spaceId, channelId, inboxAddress) {
+    const cache = await this.getPayloadCache(spaceId, channelId);
+    const expiry = Date.now() + this.requestExpiry;
+    this.sessions.set(spaceId, {
+      spaceId,
+      channelId,
+      expiry,
+      candidates: [],
+      inProgress: false
+    });
+    return {
+      type: "sync-request",
+      inboxAddress,
+      expiry,
+      summary: cache.summary
+    };
+  }
+  /**
+   * Schedule sync initiation after timeout
+   */
+  scheduleSyncInitiation(spaceId, callback, timeoutMs = this.requestExpiry) {
+    const session = this.sessions.get(spaceId);
+    if (!session) return;
+    if (session.timeout) {
+      clearTimeout(session.timeout);
+    }
+    session.timeout = setTimeout(() => {
+      callback();
+    }, timeoutMs);
+  }
+  // ============ Step 2: Sync Info ============
+  /**
+   * Build sync-info response if we have useful data.
+   * Returns null if we have nothing to offer or are already in sync.
+   */
+  async buildSyncInfo(spaceId, channelId, inboxAddress, theirSummary) {
+    logger.log(`[SyncService] buildSyncInfo called for space=${spaceId.substring(0, 12)}, channel=${channelId.substring(0, 12)}`);
+    const cache = await this.getPayloadCache(spaceId, channelId);
+    const ourSummary = cache.summary;
+    logger.log(`[SyncService] buildSyncInfo: our data - ${cache.messageMap.size} messages, ${cache.memberMap.size} members`);
+    logger.log(`[SyncService] buildSyncInfo: their summary:`, theirSummary);
+    if (cache.messageMap.size === 0 && cache.memberMap.size === 0) {
+      logger.log(`[SyncService] buildSyncInfo: returning null - we have no data`);
+      return null;
+    }
+    logger.log(`[SyncService] buildSyncInfo: our summary:`, ourSummary);
+    if (ourSummary.manifestHash === theirSummary.manifestHash && ourSummary.memberCount === theirSummary.memberCount) {
+      logger.log(`[SyncService] buildSyncInfo: returning null - hashes and member counts match`);
+      return null;
+    }
+    const hasMoreMessages = ourSummary.messageCount > theirSummary.messageCount;
+    const hasMoreMembers = ourSummary.memberCount > theirSummary.memberCount;
+    const hasNewerMessages = ourSummary.newestMessageTimestamp > theirSummary.newestMessageTimestamp;
+    const hasOlderMessages = ourSummary.oldestMessageTimestamp < theirSummary.oldestMessageTimestamp;
+    const hasDifferentMessages = ourSummary.manifestHash !== theirSummary.manifestHash;
+    logger.log(`[SyncService] buildSyncInfo: comparison - hasMoreMessages=${hasMoreMessages}, hasMoreMembers=${hasMoreMembers}, hasNewerMessages=${hasNewerMessages}, hasOlderMessages=${hasOlderMessages}, hasDifferentMessages=${hasDifferentMessages}`);
+    if (!hasMoreMessages && !hasMoreMembers && !hasNewerMessages && !hasOlderMessages && !hasDifferentMessages) {
+      logger.log(`[SyncService] buildSyncInfo: returning null - they have same or more data`);
+      return null;
+    }
+    logger.log(`[SyncService] buildSyncInfo: returning sync-info response - we have data they don't`);
+    return {
+      type: "sync-info",
+      inboxAddress,
+      summary: ourSummary
+    };
+  }
+  /**
+   * Add candidate from sync-info response
+   */
+  addCandidate(spaceId, candidate) {
+    logger.log(`[SyncService] addCandidate called for space ${spaceId.substring(0, 12)}, candidate inbox: ${candidate.inboxAddress?.substring(0, 12)}`);
+    const session = this.sessions.get(spaceId);
+    if (!session) {
+      logger.log(`[SyncService] addCandidate: No session found for space`);
+      return;
+    }
+    if (Date.now() > session.expiry) {
+      logger.log(`[SyncService] addCandidate: Session expired`);
+      return;
+    }
+    session.candidates.push(candidate);
+    logger.log(`[SyncService] addCandidate: Now have ${session.candidates.length} candidates`);
+    if (session.candidates.length === 1 && this.onInitiateSync) {
+      logger.log(`[SyncService] addCandidate: Scheduling sync initiation in ${AGGRESSIVE_SYNC_TIMEOUT_MS}ms`);
+      this.scheduleSyncInitiation(
+        spaceId,
+        () => {
+          const best = this.selectBestCandidate(spaceId);
+          logger.log(`[SyncService] addCandidate: Timeout triggered, best candidate: ${best?.inboxAddress?.substring(0, 12) || "none"}`);
+          if (best?.inboxAddress) {
+            this.onInitiateSync(spaceId, best.inboxAddress);
+          } else {
+            logger.log(`[SyncService] addCandidate: No valid candidate to sync with`);
+          }
+        },
+        AGGRESSIVE_SYNC_TIMEOUT_MS
+      );
+    }
+  }
+  /**
+   * Select best candidate based on data availability
+   */
+  selectBestCandidate(spaceId) {
+    const session = this.sessions.get(spaceId);
+    if (!session || session.candidates.length === 0) return null;
+    const sorted = [...session.candidates].sort((a, b) => {
+      const msgDiff = b.summary.messageCount - a.summary.messageCount;
+      if (msgDiff !== 0) return msgDiff;
+      return b.summary.memberCount - a.summary.memberCount;
+    });
+    return sorted[0];
+  }
+  // ============ Step 3: Sync Initiate ============
+  /**
+   * Build sync-initiate payload for selected peer
+   */
+  async buildSyncInitiate(spaceId, channelId, inboxAddress, peerIds) {
+    const candidate = this.selectBestCandidate(spaceId);
+    if (!candidate) {
+      this.sessions.delete(spaceId);
+      return null;
+    }
+    const cache = await this.getPayloadCache(spaceId, channelId);
+    this.setSyncInProgress(spaceId, true);
+    this.setSyncTarget(spaceId, candidate.inboxAddress);
+    return {
+      target: candidate.inboxAddress,
+      payload: {
+        type: "sync-initiate",
+        inboxAddress,
+        manifest: cache.manifest,
+        memberDigests: cache.memberDigests,
+        peerIds
+      }
+    };
+  }
+  // ============ Step 4: Sync Manifest ============
+  /**
+   * Build sync-manifest response to sync-initiate
+   */
+  async buildSyncManifest(spaceId, channelId, peerIds, inboxAddress) {
+    const cache = await this.getPayloadCache(spaceId, channelId);
+    return {
+      type: "sync-manifest",
+      inboxAddress,
+      manifest: cache.manifest,
+      memberDigests: cache.memberDigests,
+      peerIds
+    };
+  }
+  // ============ Step 5: Sync Delta ============
+  /**
+   * Build sync-delta payloads based on manifest comparison.
+   * May return multiple payloads for chunking.
+   */
+  async buildSyncDelta(spaceId, channelId, theirManifest, theirMemberDigests, theirPeerIds, ourPeerEntries) {
+    const cache = await this.getPayloadCache(spaceId, channelId);
+    const ourPeerIds = [...ourPeerEntries.keys()];
+    const messageDiff = computeMessageDiff(cache.manifest, theirManifest);
+    const memberDiff = computeMemberDiff(theirMemberDigests, cache.memberDigests);
+    const peerDiff = computePeerDiff(theirPeerIds, ourPeerIds);
+    const messageDelta = buildMessageDelta(
+      spaceId,
+      channelId,
+      messageDiff,
+      cache.messageMap,
+      this.tombstones
+    );
+    const reactionMessageIds = [...messageDiff.extraIds, ...messageDiff.outdatedIds];
+    const reactionDelta = buildReactionDelta(spaceId, channelId, cache.messageMap, reactionMessageIds);
+    const memberDelta = buildMemberDelta(spaceId, memberDiff, cache.memberMap);
+    const peerMapDelta = {
+      spaceId,
+      added: peerDiff.extraPeerIds.map((id) => ourPeerEntries.get(id)).filter((e) => e !== void 0),
+      updated: [],
+      removed: []
+    };
+    const payloads = [];
+    const allMessages = [...messageDelta.newMessages, ...messageDelta.updatedMessages];
+    if (allMessages.length > 0) {
+      const chunks = chunkMessages(allMessages);
+      for (let i = 0; i < chunks.length; i++) {
+        const chunk = chunks[i];
+        const isLast = i === chunks.length - 1;
+        const chunkDelta = {
+          spaceId,
+          channelId,
+          newMessages: chunk.filter(
+            (m) => messageDiff.extraIds.includes(m.messageId)
+          ),
+          updatedMessages: chunk.filter(
+            (m) => messageDiff.outdatedIds.includes(m.messageId)
+          ),
+          deletedMessageIds: isLast ? messageDelta.deletedMessageIds : []
+        };
+        payloads.push({
+          type: "sync-delta",
+          messageDelta: chunkDelta,
+          // Include reaction delta only in last chunk
+          reactionDelta: isLast && reactionDelta.added.length > 0 ? reactionDelta : void 0,
+          isFinal: false
+        });
+      }
+    }
+    if (memberDelta.members.length > 0 || peerMapDelta.added.length > 0 || allMessages.length === 0) {
+      payloads.push({
+        type: "sync-delta",
+        memberDelta: memberDelta.members.length > 0 ? memberDelta : void 0,
+        peerMapDelta: peerMapDelta.added.length > 0 ? peerMapDelta : void 0,
+        isFinal: true
+      });
+    } else if (payloads.length > 0) {
+      payloads[payloads.length - 1].isFinal = true;
+    }
+    if (payloads.length === 0) {
+      payloads.push({
+        type: "sync-delta",
+        isFinal: true
+      });
+    }
+    return payloads;
+  }
+  // ============ Delta Application ============
+  /**
+   * Apply received message delta to local storage
+   */
+  async applyMessageDelta(delta) {
+    for (const msg of delta.newMessages) {
+      await this.storage.saveMessage(msg, msg.createdDate, "", "", "", "");
+    }
+    for (const msg of delta.updatedMessages) {
+      await this.storage.saveMessage(msg, msg.createdDate, "", "", "", "");
+    }
+    for (const id of delta.deletedMessageIds) {
+      await this.storage.deleteMessage(id);
+    }
+  }
+  /**
+   * Apply received reaction delta to local storage.
+   * This updates the reactions on existing messages.
+   */
+  async applyReactionDelta(delta) {
+    for (const addition of delta.added) {
+      const message = await this.storage.getMessage({
+        spaceId: delta.spaceId,
+        channelId: delta.channelId,
+        messageId: addition.messageId
+      });
+      if (message) {
+        const reactions = message.reactions || [];
+        const existing = reactions.find((r) => r.emojiId === addition.emojiId);
+        if (existing) {
+          const allMembers = /* @__PURE__ */ new Set([...existing.memberIds, ...addition.memberIds]);
+          existing.memberIds = [...allMembers];
+          existing.count = existing.memberIds.length;
+        } else {
+          reactions.push({
+            emojiId: addition.emojiId,
+            emojiName: addition.emojiId,
+            spaceId: delta.spaceId,
+            count: addition.memberIds.length,
+            memberIds: addition.memberIds
+          });
+        }
+        message.reactions = reactions;
+        await this.storage.saveMessage(message, message.createdDate, "", "", "", "");
+      }
+    }
+    for (const removal of delta.removed) {
+      const message = await this.storage.getMessage({
+        spaceId: delta.spaceId,
+        channelId: delta.channelId,
+        messageId: removal.messageId
+      });
+      if (message) {
+        const reactions = message.reactions || [];
+        const existing = reactions.find((r) => r.emojiId === removal.emojiId);
+        if (existing) {
+          existing.memberIds = existing.memberIds.filter(
+            (id) => !removal.memberIds.includes(id)
+          );
+          existing.count = existing.memberIds.length;
+          if (existing.memberIds.length === 0) {
+            message.reactions = reactions.filter((r) => r.emojiId !== removal.emojiId);
+          }
+        }
+        await this.storage.saveMessage(message, message.createdDate, "", "", "", "");
+      }
+    }
+  }
+  /**
+   * Apply received member delta to local storage
+   */
+  async applyMemberDelta(delta) {
+    for (const member of delta.members) {
+      await this.storage.saveSpaceMember(delta.spaceId, member);
+    }
+  }
+  /**
+   * Apply full sync delta
+   */
+  async applySyncDelta(delta) {
+    if (delta.messageDelta) {
+      await this.applyMessageDelta(delta.messageDelta);
+    }
+    if (delta.reactionDelta) {
+      await this.applyReactionDelta(delta.reactionDelta);
+    }
+    if (delta.memberDelta) {
+      await this.applyMemberDelta(delta.memberDelta);
+    }
+    if (delta.isFinal) {
+      const spaceId = delta.messageDelta?.spaceId || delta.memberDelta?.spaceId;
+      if (spaceId) {
+        this.sessions.delete(spaceId);
+      }
+    }
+  }
+  // ============ Tombstone Management ============
+  /**
+   * Record a deleted message tombstone
+   */
+  addTombstone(tombstone) {
+    this.tombstones.push(tombstone);
+  }
+  /**
+   * Get all tombstones (for persistence by caller)
+   */
+  getTombstones() {
+    return [...this.tombstones];
+  }
+  /**
+   * Load tombstones (from caller's persistence)
+   */
+  loadTombstones(tombstones) {
+    this.tombstones = [...tombstones];
+  }
+  /**
+   * Clean up old tombstones (older than 30 days)
+   */
+  cleanupTombstones(maxAgeMs = 30 * 24 * 60 * 60 * 1e3) {
+    const cutoff = Date.now() - maxAgeMs;
+    this.tombstones = this.tombstones.filter((t) => t.deletedAt > cutoff);
+  }
+  // ============ Helpers ============
+  async getChannelMessages(spaceId, channelId) {
+    const result = await this.storage.getMessages({
+      spaceId,
+      channelId,
+      limit: this.maxMessages
+    });
+    return result.messages;
+  }
+  /**
+   * Clean up expired sessions
+   */
+  cleanupSessions() {
+    const now = Date.now();
+    for (const [spaceId, session] of this.sessions) {
+      if (now > session.expiry) {
+        if (session.timeout) {
+          clearTimeout(session.timeout);
+        }
+        this.sessions.delete(spaceId);
+      }
+    }
+  }
+  /**
+   * Cancel active sync for a space
+   */
+  cancelSync(spaceId) {
+    const session = this.sessions.get(spaceId);
+    if (session?.timeout) {
+      clearTimeout(session.timeout);
+    }
+    this.sessions.delete(spaceId);
+  }
+};
+export {
+  AGGRESSIVE_SYNC_TIMEOUT_MS,
+  ApiError,
+  ApiErrorCode,
+  BOOKMARKS_CONFIG,
+  BrowserWebSocketClient,
+  DEFAULT_SYNC_EXPIRY_MS,
+  ENCRYPTION_STORAGE_KEYS,
+  MAX_CHUNK_SIZE,
+  MAX_MENTIONS,
+  MAX_MESSAGE_LENGTH,
+  MENTION_PATTERNS,
+  RNWebSocketClient,
+  SyncService,
+  WasmCryptoProvider,
+  WasmSigningProvider,
+  base64ToBytes,
+  buildMemberDelta,
+  buildMessageDelta,
+  buildReactionDelta,
+  bytesToBase64,
+  bytesToHex,
+  bytesToString,
+  chunkMembers,
+  chunkMessages,
+  computeContentHash,
+  computeHash,
+  computeManifestHash,
+  computeMemberDiff,
+  computeMemberHash,
+  computeMessageDiff,
+  computePeerDiff,
+  computeReactionDiff,
+  computeReactionHash,
+  createApiError,
+  createBrowserWebSocketClient,
+  createManifest,
+  createMemberDigest,
+  createMessageDigest,
+  createNetworkError,
+  createRNWebSocketClient,
+  createReactionDigest,
+  createSignedMessage,
+  createSyncSummary,
+  endpoints,
+  extractMentions,
+  findChannel,
+  flattenChannels,
+  flattenMessages,
+  formatDate,
+  formatDateTime,
+  formatFileSize,
+  formatMemberCount,
+  formatMention,
+  formatMessageDate,
+  formatRelativeTime,
+  formatTime,
+  hexToBytes,
+  int64ToBytes,
+  isSameDay,
+  isSyncDelta,
+  isSyncInfo,
+  isSyncInitiate,
+  isSyncManifest,
+  isSyncRequest,
+  logger,
+  parseMentions,
+  queryKeys,
+  sanitizeContent,
+  stringToBytes,
+  truncateText,
+  useAddReaction,
+  useChannels,
+  useDeleteMessage,
+  useEditMessage,
+  useInvalidateMessages,
+  useMessages,
+  useRemoveReaction,
+  useSendMessage,
+  useSpace,
+  useSpaceMembers,
+  useSpaces,
+  validateMessage,
+  validateMessageContent,
+  verifySignedMessage
+};