@noverachat/sdk-react 0.3.0

package/dist/index.js

@@ -0,0 +1,1154 @@
+// src/index.ts
+export * from "@noverachat/sdk-web";
+
+// src/chat-message.ts
+function fileInlineFromWire(w) {
+  return {
+    id: w.id,
+    kind: w.kind,
+    mime: w.mime,
+    size: w.size,
+    name: w.name ?? null,
+    width: w.width ?? null,
+    height: w.height ?? null,
+    durationSec: w.duration_sec ?? null,
+    thumbnailStatus: w.thumbnail_status,
+    forwardBlocked: Boolean(w.forward_blocked)
+  };
+}
+function chatMessageFromHistory(m) {
+  return {
+    id: m.messageId,
+    senderId: m.senderId ?? null,
+    content: m.content ?? null,
+    createdAtMs: m.createdAtMs,
+    status: "sent",
+    messageType: m.messageType,
+    sender: m.sender ?? null,
+    customType: m.customType ?? null,
+    fileId: m.fileId ?? null,
+    file: m.file ?? null,
+    files: m.files ?? null,
+    replyToId: m.replyToId ?? null,
+    reactions: m.reactions ?? [],
+    customMeta: m.customMeta ?? null,
+    editedCount: m.editedCount ?? 0,
+    uploadProgress: null,
+    tempId: null,
+    isDeleted: m.deletedAt != null
+  };
+}
+function chatMessageFromLive(f) {
+  const data = f.data ?? null;
+  const customMeta = data && typeof data === "object" && "_customMeta" in data ? data._customMeta : null;
+  return {
+    id: f.message_id,
+    senderId: f.sender_id,
+    content: f.content ?? null,
+    createdAtMs: f.created_at,
+    status: "sent",
+    messageType: f.message_type,
+    sender: null,
+    customType: f.custom_type ?? null,
+    fileId: f.file_id ?? null,
+    file: f.file ? fileInlineFromWire(f.file) : null,
+    files: f.files ? f.files.map(fileInlineFromWire) : null,
+    replyToId: f.reply_to_id ?? null,
+    reactions: [],
+    customMeta,
+    editedCount: 0,
+    uploadProgress: null,
+    tempId: null,
+    isDeleted: false
+  };
+}
+function pendingChatMessage(p) {
+  return {
+    id: p.tempId,
+    senderId: null,
+    content: p.content,
+    createdAtMs: Date.now(),
+    status: "sending",
+    messageType: "TEXT",
+    sender: null,
+    customType: p.customType ?? null,
+    fileId: null,
+    file: null,
+    files: null,
+    replyToId: p.replyToId ?? null,
+    reactions: [],
+    customMeta: p.customMeta ?? null,
+    editedCount: 0,
+    uploadProgress: null,
+    tempId: p.tempId,
+    isDeleted: false
+  };
+}
+function pendingFileChatMessage(p) {
+  const mime = p.mime ?? "application/octet-stream";
+  return {
+    id: p.tempId,
+    senderId: null,
+    content: null,
+    createdAtMs: Date.now(),
+    status: "sending",
+    messageType: "FILE",
+    sender: null,
+    customType: null,
+    fileId: null,
+    file: {
+      id: "",
+      kind: mime.startsWith("image/") ? "image" : mime.startsWith("video/") ? "video" : "file",
+      mime,
+      size: p.size ?? 0,
+      name: p.name,
+      thumbnailStatus: "pending",
+      forwardBlocked: false
+    },
+    files: null,
+    replyToId: null,
+    reactions: [],
+    customMeta: null,
+    editedCount: 0,
+    uploadProgress: 0,
+    tempId: p.tempId,
+    isDeleted: false
+  };
+}
+
+// src/context.tsx
+import {
+  createContext,
+  useContext,
+  useEffect,
+  useState
+} from "react";
+import { NoveraChat } from "@noverachat/sdk-web";
+import { jsx } from "react/jsx-runtime";
+var NoveraChatContext = createContext(null);
+function NoveraChatProvider(props) {
+  const [chat] = useState(() => new NoveraChat(props.options));
+  useEffect(() => {
+    void chat.connect();
+    return () => chat.disconnect();
+  }, [chat]);
+  return /* @__PURE__ */ jsx(NoveraChatContext.Provider, { value: chat, children: props.children });
+}
+function useNoveraChat() {
+  const chat = useContext(NoveraChatContext);
+  if (!chat) {
+    throw new Error(
+      "useNoveraChat() called with no NoveraChatProvider in the tree."
+    );
+  }
+  return chat;
+}
+
+// src/member-list-store.ts
+var MemberListStore = class {
+  chat;
+  roomId;
+  listeners = /* @__PURE__ */ new Set();
+  members = [];
+  unsubs = [];
+  reloadTimer = null;
+  snapshot = {
+    members: [],
+    operators: [],
+    activeMemberIds: []
+  };
+  attached = false;
+  constructor(chat, roomId) {
+    this.chat = chat;
+    this.roomId = roomId;
+  }
+  attach() {
+    if (this.attached) return;
+    this.attached = true;
+    this.unsubs.push(
+      this.chat.on("roomEvent", (e) => {
+        if (e.room_id === this.roomId) this.scheduleReload();
+      }),
+      this.chat.on("presence", (f) => this.onPresence(f))
+    );
+  }
+  dispose() {
+    if (!this.attached) return;
+    this.attached = false;
+    if (this.reloadTimer) clearTimeout(this.reloadTimer);
+    this.reloadTimer = null;
+    for (const u of this.unsubs.splice(0)) u();
+  }
+  // ── external-store contract ─────────────────────────────────────
+  subscribe = (fn) => {
+    this.listeners.add(fn);
+    return () => this.listeners.delete(fn);
+  };
+  getSnapshot = () => this.snapshot;
+  emit() {
+    this.snapshot = {
+      members: [...this.members],
+      operators: this.members.filter((m) => m.role === "OPERATOR"),
+      activeMemberIds: this.members.filter((m) => m.role !== "KICKED").map((m) => m.userId)
+    };
+    for (const fn of this.listeners) fn();
+  }
+  /** Whether `userId` is an OPERATOR of this room. */
+  isOperator(userId) {
+    return this.members.some(
+      (m) => m.userId === userId && m.role === "OPERATOR"
+    );
+  }
+  /** Fetch the member list. Also called automatically on membership
+   *  events. */
+  async load() {
+    const list = await this.chat.room(this.roomId).listMembers();
+    if (!this.attached) return;
+    this.members = list;
+    this.emit();
+  }
+  // ── internals ───────────────────────────────────────────────────
+  onPresence(f) {
+    const i = this.members.findIndex((m) => m.userId === f.user_id);
+    if (i === -1) return;
+    this.members[i] = { ...this.members[i], isOnline: f.online };
+    this.emit();
+  }
+  scheduleReload() {
+    if (this.reloadTimer) clearTimeout(this.reloadTimer);
+    this.reloadTimer = setTimeout(() => {
+      this.reloadTimer = null;
+      if (this.attached) void this.load();
+    }, 300);
+  }
+};
+
+// src/room-files-store.ts
+var RoomFilesStore = class {
+  chat;
+  roomId;
+  /** Page size for both `refresh` and `loadMore`. */
+  pageSize;
+  listeners = /* @__PURE__ */ new Set();
+  items = [];
+  cursor = null;
+  hasMore = false;
+  loading = false;
+  attached = false;
+  snapshot = {
+    items: [],
+    media: [],
+    hasMore: false,
+    isLoading: false
+  };
+  constructor(chat, roomId, pageSize = 50) {
+    this.chat = chat;
+    this.roomId = roomId;
+    this.pageSize = pageSize;
+  }
+  /** No realtime subscriptions — kept for lifecycle symmetry with the
+   *  other stores (guards in-flight results after unmount). */
+  attach() {
+    this.attached = true;
+  }
+  dispose() {
+    this.attached = false;
+  }
+  // ── external-store contract ─────────────────────────────────────
+  subscribe = (fn) => {
+    this.listeners.add(fn);
+    return () => this.listeners.delete(fn);
+  };
+  getSnapshot = () => this.snapshot;
+  emit() {
+    this.snapshot = {
+      items: [...this.items],
+      media: this.items.filter(
+        (it) => it.file.kind === "image" || it.file.kind === "video"
+      ),
+      hasMore: this.hasMore,
+      isLoading: this.loading
+    };
+    for (const fn of this.listeners) fn();
+  }
+  // ── actions ─────────────────────────────────────────────────────
+  /** Reload from the newest page (clears what was loaded). */
+  async refresh() {
+    if (this.loading) return;
+    this.loading = true;
+    this.emit();
+    try {
+      const page = await this.chat.room(this.roomId).listFiles({ limit: this.pageSize });
+      if (!this.attached) return;
+      this.items = page.items;
+      this.cursor = page.nextCursor;
+      this.hasMore = page.hasMore;
+    } finally {
+      this.loading = false;
+      if (this.attached) this.emit();
+    }
+  }
+  /** Fetch the next older page and append it. No-op while loading or when
+   *  `hasMore` is false. Returns the number of entries added. */
+  async loadMore() {
+    const cursor = this.cursor;
+    if (this.loading || !this.hasMore || cursor == null) return 0;
+    this.loading = true;
+    this.emit();
+    try {
+      const page = await this.chat.room(this.roomId).listFiles({ limit: this.pageSize, before: cursor });
+      if (!this.attached) return 0;
+      this.items = [...this.items, ...page.items];
+      this.cursor = page.nextCursor;
+      this.hasMore = page.hasMore;
+      return page.items.length;
+    } finally {
+      this.loading = false;
+      if (this.attached) this.emit();
+    }
+  }
+};
+
+// src/room-list-store.ts
+function itemFromUnread(r) {
+  const members = r.membersPreview ?? [];
+  return {
+    roomId: r.roomId,
+    name: r.name,
+    roomType: r.roomType ?? null,
+    unreadCount: r.unreadCount,
+    lastMessageId: r.lastMessageId ?? null,
+    lastMessagePreview: r.lastMessagePreview ?? null,
+    memberCount: r.memberCount ?? 0,
+    members,
+    lastMessageAtMs: null,
+    anyMemberOnline: members.some((m) => m.isOnline === true)
+  };
+}
+var RoomListStore = class {
+  chat;
+  opts;
+  listeners = /* @__PURE__ */ new Set();
+  rooms = [];
+  index = /* @__PURE__ */ new Map();
+  // roomId → rooms position
+  roomSubs = [];
+  clientSub = null;
+  reloadTimer = null;
+  snapshot = { rooms: [], totalUnread: 0 };
+  attached = false;
+  constructor(chat, opts = {}) {
+    this.chat = chat;
+    this.opts = opts;
+  }
+  /** Subscribe to client-level room events. Idempotent. */
+  attach() {
+    if (this.attached) return;
+    this.attached = true;
+    this.clientSub = this.chat.on("roomEvent", () => this.scheduleReload());
+  }
+  /** Unsubscribe everything (list state is kept for a later `attach`). */
+  dispose() {
+    if (!this.attached) return;
+    this.attached = false;
+    if (this.reloadTimer) clearTimeout(this.reloadTimer);
+    this.reloadTimer = null;
+    for (const u of this.roomSubs.splice(0)) u();
+    this.clientSub?.();
+    this.clientSub = null;
+  }
+  // ── external-store contract ─────────────────────────────────────
+  subscribe = (fn) => {
+    this.listeners.add(fn);
+    return () => this.listeners.delete(fn);
+  };
+  getSnapshot = () => this.snapshot;
+  emit() {
+    this.snapshot = {
+      rooms: [...this.rooms],
+      totalUnread: this.rooms.reduce((n, r) => n + r.unreadCount, 0)
+    };
+    for (const fn of this.listeners) fn();
+  }
+  // ── actions ─────────────────────────────────────────────────────
+  /** Reload the room list and re-hook the realtime subscriptions. */
+  async load() {
+    const summary = await this.chat.unreadSummary();
+    if (!this.attached) return;
+    this.rooms = summary.rooms.map(itemFromUnread);
+    this.reindex();
+    this.resubscribe();
+    this.emit();
+  }
+  /** Hide a room (카톡 "숨기기") — optimistically remove it from the list
+   *  and send `hide` to the server. On failure the next `load` brings it
+   *  back; new activity may re-surface it per server policy (arrives via
+   *  roomEvent → reload). */
+  async hideRoom(roomId) {
+    const i = this.index.get(roomId);
+    if (i !== void 0) {
+      this.rooms.splice(i, 1);
+      this.reindex();
+      this.emit();
+    }
+    await this.chat.room(roomId).hide();
+  }
+  /** Undo `hideRoom` — send `unhide` and reload the list. */
+  async unhideRoom(roomId) {
+    await this.chat.room(roomId).unhide();
+    await this.load();
+  }
+  /** Mark a room read — drop its badge to 0 and advance the client's
+   *  last-seen watermark. */
+  markRead(roomId) {
+    const i = this.index.get(roomId);
+    if (i === void 0) return;
+    const item = this.rooms[i];
+    if (item.lastMessageId) this.chat.setLastSeen(roomId, item.lastMessageId);
+    if (item.unreadCount !== 0) {
+      this.rooms[i] = { ...item, unreadCount: 0 };
+      this.emit();
+    }
+  }
+  // ── internals ───────────────────────────────────────────────────
+  reindex() {
+    this.index = new Map(this.rooms.map((r, i) => [r.roomId, i]));
+  }
+  resubscribe() {
+    for (const u of this.roomSubs.splice(0)) u();
+    for (const item of this.rooms) {
+      const room = this.chat.room(item.roomId);
+      this.roomSubs.push(
+        room.on("message", (m) => this.onIncoming(item.roomId, m)),
+        room.on("syncTick", () => this.scheduleReload()),
+        room.on("messagesCleared", () => this.scheduleReload())
+      );
+    }
+  }
+  onIncoming(roomId, m) {
+    const i = this.index.get(roomId);
+    if (i === void 0) return;
+    const cur = this.rooms[i];
+    const visible = this.opts.isRoomVisible?.(roomId) ?? false;
+    const preview = this.opts.previewBuilder?.(m) ?? m.content ?? (m.file_id || m.file || m.files && m.files.length > 0 ? "\u{1F4CE}" : "");
+    const updated = {
+      ...cur,
+      unreadCount: visible ? cur.unreadCount : cur.unreadCount + 1,
+      lastMessageId: m.message_id,
+      lastMessagePreview: preview,
+      lastMessageAtMs: m.created_at
+    };
+    this.rooms.splice(i, 1);
+    this.rooms.unshift(updated);
+    this.reindex();
+    this.emit();
+  }
+  scheduleReload() {
+    if (this.reloadTimer) clearTimeout(this.reloadTimer);
+    this.reloadTimer = setTimeout(() => {
+      this.reloadTimer = null;
+      if (this.attached) void this.load();
+    }, 500);
+  }
+};
+
+// src/room-settings-store.ts
+var RoomSettingsStore = class {
+  chat;
+  roomId;
+  listeners = /* @__PURE__ */ new Set();
+  invites = [];
+  joinRequests = [];
+  attached = false;
+  snapshot = { invites: [], joinRequests: [] };
+  constructor(chat, roomId) {
+    this.chat = chat;
+    this.roomId = roomId;
+  }
+  get room() {
+    return this.chat.room(this.roomId);
+  }
+  /** No realtime subscriptions — kept for lifecycle symmetry with the
+   *  other stores (guards in-flight results after unmount). */
+  attach() {
+    this.attached = true;
+  }
+  dispose() {
+    this.attached = false;
+  }
+  // ── external-store contract ─────────────────────────────────────
+  subscribe = (fn) => {
+    this.listeners.add(fn);
+    return () => this.listeners.delete(fn);
+  };
+  getSnapshot = () => this.snapshot;
+  emit() {
+    this.snapshot = {
+      invites: [...this.invites],
+      joinRequests: [...this.joinRequests]
+    };
+    for (const fn of this.listeners) fn();
+  }
+  // ── notifications ───────────────────────────────────────────────
+  /** Convenience mute toggle: `true` → `OFF`, `false` → `ALL`. */
+  setMuted(muted) {
+    return this.room.setPushTrigger(muted ? "OFF" : "ALL");
+  }
+  /** Fine-grained per-room push trigger: `ALL` | `MENTION_ONLY` | `OFF`. */
+  setPushTrigger(trigger) {
+    return this.room.setPushTrigger(trigger);
+  }
+  // ── invite links ────────────────────────────────────────────────
+  /** Fetch the invite list (operator-only server-side). */
+  async loadInvites() {
+    const list = await this.room.listInvites();
+    if (!this.attached) return;
+    this.invites = list;
+    this.emit();
+  }
+  /** Mint a new invite link and prepend it to `invites`. */
+  async createInvite(opts) {
+    const token = await this.room.createInvite(opts);
+    if (this.attached) {
+      this.invites = [token, ...this.invites];
+      this.emit();
+    }
+    return token;
+  }
+  /** Revoke a token and drop it from `invites`. */
+  async revokeInvite(token) {
+    await this.room.revokeInvite(token);
+    if (this.attached) {
+      this.invites = this.invites.filter((t) => t.token !== token);
+      this.emit();
+    }
+  }
+  // ── join requests (operator inbox) ──────────────────────────────
+  /** Fetch pending join requests (operator-only server-side). */
+  async loadJoinRequests() {
+    const page = await this.room.listJoinRequests();
+    if (!this.attached) return;
+    this.joinRequests = page.items;
+    this.emit();
+  }
+  /** Approve a pending request and drop it from `joinRequests`. */
+  async approveJoinRequest(userId, reason) {
+    await this.room.approveJoinRequest(userId, reason);
+    if (this.attached) {
+      this.joinRequests = this.joinRequests.filter((r) => r.userId !== userId);
+      this.emit();
+    }
+  }
+  /** Reject a pending request and drop it from `joinRequests`. */
+  async rejectJoinRequest(userId, reason) {
+    await this.room.rejectJoinRequest(userId, reason);
+    if (this.attached) {
+      this.joinRequests = this.joinRequests.filter((r) => r.userId !== userId);
+      this.emit();
+    }
+  }
+  // ── history / membership ────────────────────────────────────────
+  /** Per-user "clear chat" — hides existing messages for the caller only. */
+  clearHistory() {
+    return this.room.clearHistory();
+  }
+  /** Leave the room. `deleteMessages`: `"none"` (default) | `"mine"` |
+   *  `"all"` — see `Room.leave`. */
+  leave(options) {
+    return this.room.leave(options);
+  }
+  /** Delete every message the caller sent (without leaving). Returns the
+   *  cleared count. */
+  async deleteMyMessages() {
+    const r = await this.room.deleteMyMessages();
+    return r.cleared;
+  }
+  // ── operator moderation ─────────────────────────────────────────
+  /** **Destructive, operator-only** — wipe every message in the room. */
+  deleteAllMessages() {
+    return this.room.deleteAllMessages();
+  }
+  /** Operator: block non-operator sends (`ROOM_FROZEN` server-side). */
+  freeze() {
+    return this.room.freeze();
+  }
+  /** Operator: reopen the room to sends. */
+  unfreeze() {
+    return this.room.unfreeze();
+  }
+  /** Operator: toggle open-chat visibility. */
+  setPublic(isPublic) {
+    return this.room.setPublic(isPublic);
+  }
+  /** Operator: mute a member (`durationMinutes` null → indefinite). */
+  muteMember(userId, durationMinutes) {
+    return this.room.muteMember(userId, durationMinutes);
+  }
+  /** Operator: clear a member's mute. */
+  unmuteMember(userId) {
+    return this.room.unmuteMember(userId);
+  }
+};
+
+// src/internal/compare-id.ts
+function idGreater(a, b) {
+  if (!a || a === "0") return false;
+  if (!b || b === "0") return true;
+  try {
+    return BigInt(a) > BigInt(b);
+  } catch {
+    return a > b;
+  }
+}
+
+// src/room-store.ts
+var uploadSeq = 0;
+var RoomStore = class {
+  chat;
+  roomId;
+  listeners = /* @__PURE__ */ new Set();
+  unsubs = [];
+  messages = [];
+  readWatermarks = {};
+  hasMore = false;
+  oldestCursor = null;
+  loadingMore = false;
+  historyRequested = false;
+  snapshot;
+  attached = false;
+  onPageHide = () => this.room.flushMarkRead();
+  constructor(chat, roomId) {
+    this.chat = chat;
+    this.roomId = roomId;
+    this.snapshot = {
+      messages: [],
+      hasMore: false,
+      readWatermarks: {}
+    };
+  }
+  /** The live `Room` facade — resolved from the client on every access
+   *  (get-or-create in a map, cheap) so we never act on an orphan. */
+  get room() {
+    return this.chat.room(this.roomId);
+  }
+  /** Subscribe to WS events + page lifecycle. Safe to call repeatedly
+   *  (no-op while attached) — matches React 18/19 StrictMode's
+   *  mount → cleanup → mount effect cycle. */
+  attach() {
+    if (this.attached) return;
+    this.attached = true;
+    const room = this.room;
+    this.unsubs.push(
+      room.on("message", (f) => this.onIncoming(f)),
+      room.on("messageUpdated", (f) => this.onUpdated(f)),
+      room.on("messageDeleted", (f) => this.onDeleted(f)),
+      room.on("messagesCleared", (f) => this.onCleared(f)),
+      room.on("reactionAdded", (f) => this.onReactionAdded(f)),
+      room.on("reactionRemoved", (f) => this.onReactionRemoved(f)),
+      room.on("syncTick", (f) => this.onSyncTick(f))
+    );
+    if (typeof document !== "undefined") {
+      document.addEventListener("visibilitychange", this.onVisibilityChange);
+    }
+    if (typeof window !== "undefined") {
+      window.addEventListener("pagehide", this.onPageHide);
+    }
+  }
+  /** Unsubscribe everything and flush the pending read watermark. The store
+   *  keeps its message state, so a later `attach()` resumes cleanly. */
+  dispose() {
+    if (!this.attached) return;
+    this.attached = false;
+    this.room.flushMarkRead();
+    for (const u of this.unsubs.splice(0)) u();
+    if (typeof document !== "undefined") {
+      document.removeEventListener("visibilitychange", this.onVisibilityChange);
+    }
+    if (typeof window !== "undefined") {
+      window.removeEventListener("pagehide", this.onPageHide);
+    }
+  }
+  // ── external-store contract ─────────────────────────────────────
+  /** `useSyncExternalStore`-compatible subscribe. Returns an unsubscribe fn. */
+  subscribe = (fn) => {
+    this.listeners.add(fn);
+    return () => this.listeners.delete(fn);
+  };
+  getSnapshot = () => this.snapshot;
+  emit() {
+    this.snapshot = {
+      messages: [...this.messages],
+      hasMore: this.hasMore,
+      readWatermarks: { ...this.readWatermarks }
+    };
+    for (const fn of this.listeners) fn();
+  }
+  // ── read receipts ───────────────────────────────────────────────
+  /** Whether `userId` has read `messageId` according to the latest watermark. */
+  isReadBy(userId, messageId) {
+    const w = this.readWatermarks[userId];
+    if (!w) return false;
+    return !idGreater(messageId, w);
+  }
+  /** How many of the given users have read `messageId`. Pass the room's
+   *  member ids (minus the sender) to get a KakaoTalk-style unread count:
+   *  `members.length - readCount(...)`. */
+  readCount(messageId, userIds) {
+    let n = 0;
+    for (const u of userIds) if (this.isReadBy(u, messageId)) n++;
+    return n;
+  }
+  // ── history ─────────────────────────────────────────────────────
+  /** Load the most recent page of history and prepend it. No-op after the
+   *  first call (StrictMode double-mount safe) — use `loadMore` for
+   *  scrollback. */
+  async loadHistory(limit = 50) {
+    if (this.historyRequested) return;
+    this.historyRequested = true;
+    const page = await this.room.listRecent(limit);
+    this.messages.unshift(...page.items.map(chatMessageFromHistory));
+    this.oldestCursor = page.nextCursor;
+    this.hasMore = page.hasMore;
+    this.emit();
+  }
+  /** Scrollback: load the page of messages older than what's on screen and
+   *  prepend it. No-op while a previous call is in flight or when `hasMore`
+   *  is false. Returns the number of messages added. */
+  async loadMore(limit = 50) {
+    const cursor = this.oldestCursor;
+    if (this.loadingMore || !this.hasMore || cursor == null) return 0;
+    this.loadingMore = true;
+    try {
+      const page = await this.room.listBefore(cursor, limit);
+      this.messages.unshift(...page.items.map(chatMessageFromHistory));
+      this.oldestCursor = page.nextCursor;
+      this.hasMore = page.hasMore;
+      this.emit();
+      return page.items.length;
+    } finally {
+      this.loadingMore = false;
+    }
+  }
+  // ── outgoing ────────────────────────────────────────────────────
+  /** Send `text` optimistically: a `sending` bubble appears immediately,
+   *  then flips to `sent` (with the real id) on ack, or `failed` on error.
+   *
+   *  Optional extras ride along: `replyToId` for replies, `customType` /
+   *  `customMeta` for app-defined conventions (e.g. message priority). */
+  send(text, opts) {
+    void (async () => {
+      let tempId;
+      let ackPromise;
+      try {
+        const sent = await this.room.send({
+          content: text,
+          ...opts?.replyToId ? { replyToId: opts.replyToId } : {},
+          ...opts?.customType ? { customType: opts.customType } : {},
+          ...opts?.customMeta ? { customMeta: opts.customMeta } : {}
+        });
+        tempId = sent.tempId;
+        ackPromise = sent.messageId;
+      } catch {
+        const localId = `failed_${Date.now()}_${uploadSeq++}`;
+        this.messages.push({
+          ...pendingChatMessage({ tempId: localId, content: text, ...opts }),
+          status: "failed"
+        });
+        this.emit();
+        return;
+      }
+      this.messages.push(
+        pendingChatMessage({ tempId, content: text, ...opts })
+      );
+      this.emit();
+      this.bindAck(tempId, ackPromise);
+    })();
+  }
+  /** Send a file optimistically. A FILE bubble with `uploadProgress`
+   *  appears immediately; progress advances during the S3 upload, then the
+   *  bubble flips to `sent` on ack (or `failed`). */
+  async sendFile(file, opts) {
+    const localId = `upload_${Date.now()}_${uploadSeq++}`;
+    this.messages.push(
+      pendingFileChatMessage({
+        tempId: localId,
+        name: opts?.name ?? file.name,
+        mime: file.type,
+        size: file.size
+      })
+    );
+    this.emit();
+    try {
+      const sent = await this.room.sendFile(file, {
+        ...opts ?? {},
+        onProgress: (p) => {
+          this.mutateByTempId(localId, (m) => ({
+            ...m,
+            uploadProgress: p.ratio
+          }));
+          opts?.onProgress?.(p);
+        }
+      });
+      this.mutateByTempId(localId, (m) => ({
+        ...m,
+        fileId: sent.fileId,
+        file: m.file ? { ...m.file, id: sent.fileId } : m.file,
+        uploadProgress: null
+      }));
+      const realId = await sent.messageId;
+      this.mutateByTempId(localId, (m) => ({
+        ...m,
+        id: realId,
+        status: "sent"
+      }));
+    } catch {
+      this.mutateByTempId(localId, (m) => ({
+        ...m,
+        status: "failed",
+        uploadProgress: null
+      }));
+    }
+  }
+  /** Edit a message's content (server-side; peers get `message_updated`).
+   *  The local copy updates optimistically. */
+  async edit(messageId, content) {
+    await this.room.edit(messageId, { content });
+    this.mutateById(messageId, (m) => ({
+      ...m,
+      content,
+      editedCount: m.editedCount + 1
+    }));
+  }
+  /** Delete a message. `scope: "ALL"` (default) removes it for everyone;
+   *  `"MY"` hides it only for the caller. Local copy flips to deleted. */
+  async delete(messageId, scope = "ALL") {
+    await this.room.delete(messageId, scope);
+    this.mutateById(messageId, (m) => ({ ...m, isDeleted: true }));
+  }
+  /** Add/remove the caller's reaction. Pass `myUserId` so the toggle can
+   *  tell whether the caller already reacted with `key`. The authoritative
+   *  state arrives back via the reaction WS events. */
+  async toggleReaction(messageId, key, myUserId) {
+    const m = this.messages.find((x) => x.id === messageId);
+    const mine = m?.reactions.some(
+      (r) => r.key === key && r.userIds.includes(myUserId)
+    ) ?? false;
+    if (mine) {
+      await this.room.unreact(messageId, key);
+    } else {
+      await this.room.react(messageId, key);
+    }
+  }
+  /** Search this room's messages (server-side, content substring match).
+   *  Returns view models without touching the message list. */
+  async search(q, limit = 30) {
+    const page = await this.room.search(q, { limit });
+    return page.items.map(chatMessageFromHistory);
+  }
+  /** Mark `messageId` read (debounced inside the SDK). */
+  markRead(messageId) {
+    this.room.markRead(messageId);
+  }
+  // ── event handlers ──────────────────────────────────────────────
+  onIncoming(f) {
+    this.messages.push(chatMessageFromLive(f));
+    this.emit();
+  }
+  onUpdated(f) {
+    this.mutateById(f.message_id, (m) => ({
+      ...m,
+      content: f.content ?? m.content,
+      editedCount: m.editedCount + 1
+    }));
+  }
+  onDeleted(f) {
+    this.mutateById(f.message_id, (m) => ({ ...m, isDeleted: true }));
+  }
+  onCleared(f) {
+    const upTo = f.up_to_message_id;
+    let changed = false;
+    this.messages = this.messages.map((m) => {
+      if (!m.isDeleted && (upTo == null || !idGreater(m.id, upTo))) {
+        changed = true;
+        return { ...m, isDeleted: true };
+      }
+      return m;
+    });
+    if (changed) this.emit();
+  }
+  onReactionAdded(f) {
+    this.mutateById(f.message_id, (m) => {
+      const next = m.reactions.map(
+        (r) => r.key === f.reaction_key ? {
+          key: r.key,
+          userIds: [.../* @__PURE__ */ new Set([...r.userIds, f.user_id])],
+          updatedAt: f.updated_at
+        } : r
+      );
+      if (!next.some((r) => r.key === f.reaction_key)) {
+        next.push({
+          key: f.reaction_key,
+          userIds: [f.user_id],
+          updatedAt: f.updated_at
+        });
+      }
+      return { ...m, reactions: next };
+    });
+  }
+  onReactionRemoved(f) {
+    this.mutateById(f.message_id, (m) => {
+      const next = [];
+      for (const r of m.reactions) {
+        if (r.key !== f.reaction_key) {
+          next.push(r);
+          continue;
+        }
+        const users = r.userIds.filter((u) => u !== f.user_id);
+        if (users.length > 0) {
+          next.push({ key: r.key, userIds: users, updatedAt: f.updated_at });
+        }
+      }
+      return { ...m, reactions: next };
+    });
+  }
+  onSyncTick(f) {
+    let changed = false;
+    for (const [userId, mid] of Object.entries(f.read_states)) {
+      const cur = this.readWatermarks[userId];
+      if (!cur || idGreater(mid, cur)) {
+        this.readWatermarks[userId] = mid;
+        changed = true;
+      }
+    }
+    if (changed) this.emit();
+  }
+  onVisibilityChange = () => {
+    if (typeof document !== "undefined" && document.visibilityState === "hidden") {
+      this.room.flushMarkRead();
+    }
+  };
+  // ── helpers ─────────────────────────────────────────────────────
+  bindAck(tempId, messageId) {
+    messageId.then((realId) => {
+      this.mutateByTempId(tempId, (m) => ({
+        ...m,
+        id: realId,
+        status: "sent"
+      }));
+    }).catch(() => {
+      this.mutateByTempId(tempId, (m) => ({ ...m, status: "failed" }));
+    });
+  }
+  mutateById(id, f) {
+    const i = this.messages.findIndex((m) => m.id === id);
+    if (i === -1) return;
+    this.messages[i] = f(this.messages[i]);
+    this.emit();
+  }
+  mutateByTempId(tempId, f) {
+    const i = this.messages.findIndex((m) => m.tempId === tempId);
+    if (i === -1) return;
+    this.messages[i] = f(this.messages[i]);
+    this.emit();
+  }
+};
+
+// src/use-messages.ts
+import { useEffect as useEffect2, useMemo, useSyncExternalStore } from "react";
+function useMessages(roomId, opts) {
+  const chat = useNoveraChat();
+  const historyLimit = opts?.historyLimit ?? 50;
+  const store = useMemo(() => new RoomStore(chat, roomId), [chat, roomId]);
+  useEffect2(() => {
+    store.attach();
+    void store.loadHistory(historyLimit);
+    return () => store.dispose();
+  }, [store]);
+  const snapshot = useSyncExternalStore(
+    store.subscribe,
+    store.getSnapshot,
+    store.getSnapshot
+  );
+  return { ...snapshot, store };
+}
+
+// src/use-member-list.ts
+import { useEffect as useEffect3, useMemo as useMemo2, useSyncExternalStore as useSyncExternalStore2 } from "react";
+function useMemberList(roomId) {
+  const chat = useNoveraChat();
+  const store = useMemo2(
+    () => new MemberListStore(chat, roomId),
+    [chat, roomId]
+  );
+  useEffect3(() => {
+    store.attach();
+    void store.load();
+    return () => store.dispose();
+  }, [store]);
+  const snapshot = useSyncExternalStore2(
+    store.subscribe,
+    store.getSnapshot,
+    store.getSnapshot
+  );
+  return { ...snapshot, store };
+}
+
+// src/use-room.ts
+function useRoom(roomId) {
+  return useNoveraChat().room(roomId);
+}
+
+// src/use-room-files.ts
+import { useEffect as useEffect4, useMemo as useMemo3, useSyncExternalStore as useSyncExternalStore3 } from "react";
+function useRoomFiles(roomId, opts) {
+  const chat = useNoveraChat();
+  const pageSize = opts?.pageSize ?? 50;
+  const store = useMemo3(
+    () => new RoomFilesStore(chat, roomId, pageSize),
+    [chat, roomId, pageSize]
+  );
+  useEffect4(() => {
+    store.attach();
+    void store.refresh();
+    return () => store.dispose();
+  }, [store]);
+  const snapshot = useSyncExternalStore3(
+    store.subscribe,
+    store.getSnapshot,
+    store.getSnapshot
+  );
+  return { ...snapshot, store };
+}
+
+// src/use-room-list.ts
+import { useEffect as useEffect5, useMemo as useMemo4, useRef, useSyncExternalStore as useSyncExternalStore4 } from "react";
+function useRoomList(opts) {
+  const chat = useNoveraChat();
+  const optsRef = useRef(opts);
+  const store = useMemo4(
+    () => new RoomListStore(chat, optsRef.current ?? {}),
+    [chat]
+  );
+  useEffect5(() => {
+    store.attach();
+    void store.load();
+    return () => store.dispose();
+  }, [store]);
+  const snapshot = useSyncExternalStore4(
+    store.subscribe,
+    store.getSnapshot,
+    store.getSnapshot
+  );
+  return { ...snapshot, store };
+}
+
+// src/use-room-settings.ts
+import { useEffect as useEffect6, useMemo as useMemo5, useSyncExternalStore as useSyncExternalStore5 } from "react";
+function useRoomSettings(roomId) {
+  const chat = useNoveraChat();
+  const store = useMemo5(
+    () => new RoomSettingsStore(chat, roomId),
+    [chat, roomId]
+  );
+  useEffect6(() => {
+    store.attach();
+    return () => store.dispose();
+  }, [store]);
+  const snapshot = useSyncExternalStore5(
+    store.subscribe,
+    store.getSnapshot,
+    store.getSnapshot
+  );
+  return { ...snapshot, store };
+}
+
+// src/use-typing.ts
+import { useEffect as useEffect7, useRef as useRef2, useState as useState2 } from "react";
+function useTyping(roomId, opts) {
+  const chat = useNoveraChat();
+  const timeoutMs = opts?.timeoutMs ?? 5e3;
+  const [typingUserIds, setTypingUserIds] = useState2([]);
+  const timers = useRef2(/* @__PURE__ */ new Map());
+  useEffect7(() => {
+    const room = chat.room(roomId);
+    const timerMap = timers.current;
+    const stop = (userId) => {
+      const t = timerMap.get(userId);
+      if (t) clearTimeout(t);
+      timerMap.delete(userId);
+      setTypingUserIds(
+        (cur) => cur.includes(userId) ? cur.filter((u) => u !== userId) : cur
+      );
+    };
+    const start = (userId) => {
+      const t = timerMap.get(userId);
+      if (t) clearTimeout(t);
+      timerMap.set(userId, setTimeout(() => stop(userId), timeoutMs));
+      setTypingUserIds(
+        (cur) => cur.includes(userId) ? cur : [...cur, userId]
+      );
+    };
+    const unsub = room.on("typing", (f) => {
+      if (f.is_typing) start(f.user_id);
+      else stop(f.user_id);
+    });
+    return () => {
+      unsub();
+      for (const t of timerMap.values()) clearTimeout(t);
+      timerMap.clear();
+      setTypingUserIds([]);
+    };
+  }, [chat, roomId, timeoutMs]);
+  return {
+    typingUserIds,
+    isAnyoneTyping: typingUserIds.length > 0,
+    setTyping: (isTyping) => chat.room(roomId).setTyping(isTyping)
+  };
+}
+
+// src/use-unread.ts
+import { useCallback, useEffect as useEffect8, useState as useState3 } from "react";
+function useUnread(opts) {
+  const chat = useNoveraChat();
+  const refreshIntervalMs = opts?.refreshIntervalMs;
+  const [summary, setSummary] = useState3(null);
+  const refresh = useCallback(async () => {
+    setSummary(await chat.unreadSummary());
+  }, [chat]);
+  useEffect8(() => {
+    let alive = true;
+    const tick = async () => {
+      try {
+        const s = await chat.unreadSummary();
+        if (alive) setSummary(s);
+      } catch {
+      }
+    };
+    void tick();
+    const timer = refreshIntervalMs != null && refreshIntervalMs > 0 ? setInterval(() => void tick(), refreshIntervalMs) : null;
+    return () => {
+      alive = false;
+      if (timer) clearInterval(timer);
+    };
+  }, [chat, refreshIntervalMs]);
+  return { total: summary?.total ?? 0, summary, refresh };
+}
+export {
+  MemberListStore,
+  NoveraChatProvider,
+  RoomFilesStore,
+  RoomListStore,
+  RoomSettingsStore,
+  RoomStore,
+  chatMessageFromHistory,
+  chatMessageFromLive,
+  useMemberList,
+  useMessages,
+  useNoveraChat,
+  useRoom,
+  useRoomFiles,
+  useRoomList,
+  useRoomSettings,
+  useTyping,
+  useUnread
+};