@kispi/chat 0.2.1 → 0.2.3

package/dist/index.js

@@ -147,6 +147,25 @@ var Timeline = class {
   shared = false;
   /** The `loadOlder` in flight, so a scroll handler firing twice asks once. */
   older;
+  /**
+   * The lowest seq the room still keeps (`minSeq` from the subscribe ack;
+   * 1 until told). Below it there is nothing to read, whatever seq says.
+   */
+  floor = 1;
+  /** A `loadOlder` came back short: the top of what the server keeps was reached. */
+  exhausted = false;
+  /**
+   * Presses this client has made and the server has not answered yet, one
+   * entry per (message, emoji) pair, each remembering the last value the
+   * **server** gave for that pair.
+   *
+   * 되돌릴 자리로 "누르기 직전 화면값"을 쓰면 안 된다. 눌렀다 곧바로 취소하고
+   * 두 거절이 차례로 오면, 두 번째 거절이 첫 번째의 낙관값 — 서버가 한 번도
+   * 가진 적 없는 값 — 을 화면에 되살린다. 마지막으로 서버가 말한 값만이
+   * 되돌릴 자리다.
+   */
+  presses = /* @__PURE__ */ new Map();
+  pressSeq = 0;
   constructor(options) {
     this.options = options;
   }
@@ -155,6 +174,22 @@ var Timeline = class {
     this.shared = true;
     return this.items;
   }
+  /**
+   * Whether `loadOlder()` would find anything, answered without asking.
+   *
+   * `loadOlder()`의 `hasMore`와 같은 판정이다: 맨 위 행이 방의 보존 하한
+   * (`minSeq`, seq는 1부터 구멍 없이 붙는다)보다 위에 있고, 앞선 `loadOlder`가
+   * 덜 찬 페이지로 끝을 알린 적이 없으면 더 있다. 첫 `loadOlder()` 전에 "이전
+   * 메시지 더 보기"를 그릴지 정할 수 있게 한다. 목록이 비었으면 false다.
+   */
+  get hasOlder() {
+    const first = this.items[0];
+    return !this.exhausted && first !== void 0 && first.seq > this.floor;
+  }
+  /** Records the room's retention floor (`minSeq`). */
+  setFloor(minSeq) {
+    this.floor = Math.max(1, minSeq);
+  }
   /** The highest seq this timeline holds, hole or no hole. */
   get highestSeq() {
     return this.items.at(-1)?.seq ?? 0;
@@ -198,7 +233,9 @@ var Timeline = class {
     this.epoch++;
     this.fills.clear();
     this.pendingDeletes.clear();
+    this.presses.clear();
     this.items = [];
+    this.exhausted = false;
     this.shared = false;
     this.changed();
   }
@@ -224,8 +261,10 @@ var Timeline = class {
     this.epoch++;
     this.fills.clear();
     const page = [...messages].sort((a, b) => a.seq - b.seq);
+    for (const m of page) this.serverRendered(m.id);
     const top = page.at(-1)?.seq ?? 0;
     this.items = [...page, ...this.items.filter((m) => m.seq > top)];
+    this.exhausted = false;
     this.shared = false;
     for (const m of this.items) {
       if (this.pendingDeletes.has(m.id)) this.applyDelete(m.id);
@@ -276,20 +315,84 @@ var Timeline = class {
    *
    * The server sends the new `count` with the event, so this is a
    * replacement rather than an increment: two clients reacting at once
-   * cannot drift the way `+1`/`-1` would.
+   * cannot drift the way `+1`/`-1` would. `count` undefined leaves the
+   * aggregate alone (the react ack path); `mine` undefined leaves
+   * `myReactions` alone (somebody else's event).
+   *
+   * This is the **authoritative** entry point: a value the server sent.
+   * So a press still waiting on an answer for the same pair is finished
+   * here -- a refusal landing afterwards must not push this value back
+   * to the older one it was going to restore.
+   */
+  reaction(messageId, emoji, count, mine) {
+    if (mine !== void 0) this.presses.delete(pairKey(messageId, emoji));
+    this.applyReaction(messageId, emoji, count, mine);
+  }
+  /**
+   * Applies this client's own react/unreact to `myReactions` **before the
+   * frame goes out**, and returns the press so its answer can settle it.
+   *
+   * 누른 값은 (사용자, 이모지)로 로컬에서 정해지고 엔진은 멱등이므로, 미리
+   * 적용해도 ack가 새로 알려 줄 것이 없다. `count`는 일부러 건드리지 않는다 —
+   * 그 사이 남이 같은 이모지를 누르면 로컬 +1/-1은 서버가 보낼 수와 다르고,
+   * 그 차이를 고칠 이벤트는 이미 지나갔다.
+   *
+   * Undefined when the row is not held: there is nothing to show now and
+   * nothing to put back later.
+   */
+  pressReaction(messageId, emoji, mine) {
+    const at = this.items.findIndex((m) => m.id === messageId);
+    if (at === -1) return void 0;
+    const key = pairKey(messageId, emoji);
+    const base = this.presses.get(key)?.base ?? (this.items[at].myReactions ?? []).includes(emoji);
+    const press = { messageId, emoji, mine, seq: ++this.pressSeq };
+    this.presses.set(key, { seq: press.seq, base });
+    this.applyReaction(messageId, emoji, void 0, mine);
+    return press;
+  }
+  /**
+   * Settles a press with what the server said.
+   *
+   * `accepted` re-asserts the value the press asked for; a refusal puts
+   * the last server-given value back. Either way it does nothing once
+   * this press no longer owns the pair -- a newer press took it over
+   * (and that one's answer decides), or something authoritative already
+   * landed on it (a `reaction.*` event carrying this user's id, a
+   * `reload()`, a reconnect's catch-up page). Reverting there would
+   * resurrect a value older than what is on screen.
    */
-  reaction(messageId, emoji, count) {
+  settleReaction(press, accepted) {
+    const key = pairKey(press.messageId, press.emoji);
+    const held = this.presses.get(key);
+    if (held === void 0 || held.seq !== press.seq) return;
+    this.presses.delete(key);
+    this.applyReaction(press.messageId, press.emoji, void 0, accepted ? press.mine : held.base);
+  }
+  applyReaction(messageId, emoji, count, mine) {
     const at = this.items.findIndex((m) => m.id === messageId);
     if (at === -1) return;
     const current = this.items[at];
-    const existing = current.reactions ?? [];
-    const slot = existing.findIndex((r) => r.emoji === emoji);
-    let next;
-    if (count <= 0) next = existing.filter((r) => r.emoji !== emoji);
-    else if (slot === -1) next = [...existing, { emoji, count }];
-    else next = existing.map((r, i) => i === slot ? { emoji, count } : r);
+    let reactions = current.reactions;
+    if (count !== void 0) {
+      const existing = current.reactions ?? [];
+      const slot = existing.findIndex((r) => r.emoji === emoji);
+      if (count <= 0) reactions = existing.filter((r) => r.emoji !== emoji);
+      else if (slot === -1) reactions = [...existing, { emoji, count }];
+      else reactions = existing.map((r, i) => i === slot ? { emoji, count } : r);
+    }
+    let myReactions = current.myReactions;
+    if (mine !== void 0) {
+      const held = current.myReactions ?? [];
+      const has = held.includes(emoji);
+      if (mine && !has) myReactions = [...held, emoji];
+      else if (!mine && has) myReactions = held.filter((e) => e !== emoji);
+    }
+    if (reactions === current.reactions && myReactions === current.myReactions) return;
+    const next = { ...current };
+    if (reactions !== void 0) next.reactions = reactions;
+    if (myReactions !== void 0) next.myReactions = myReactions;
     this.own();
-    this.items[at] = { ...current, reactions: next };
+    this.items[at] = next;
     this.changed();
   }
   /** Applies a `thread.updated` to the root message's aggregate. */
@@ -326,14 +429,16 @@ var Timeline = class {
   }
   async readOlder(limit) {
     const first = this.items[0];
-    if (first === void 0 || first.seq <= 1) return { messages: [], hasMore: false };
+    if (first === void 0 || first.seq <= this.floor) return { messages: [], hasMore: false };
     const epoch = this.epoch;
     const page = await this.options.fetchRange({ after: 0, before: first.seq, limit });
     if (this.epoch !== epoch) return { messages: [], hasMore: true };
     for (const m of page) this.insert(m, false);
     if (page.length > 0) this.changed();
     const top = page[0];
-    return { messages: page, hasMore: page.length >= limit && top !== void 0 && top.seq > 1 };
+    const hasMore = page.length >= limit && top !== void 0 && top.seq > this.floor;
+    this.exhausted = !hasMore;
+    return { messages: page, hasMore };
   }
   /**
    * Fetches everything between what we have and `upTo`.
@@ -380,6 +485,7 @@ var Timeline = class {
   }
   /** Inserts at the seq position, replacing an existing row with that seq. */
   insert(message, notify = true) {
+    this.serverRendered(message.id);
     const pending = this.pendingDeletes.has(message.id);
     if (pending) this.pendingDeletes.delete(message.id);
     const withDelete = pending ? emptied(message) : message;
@@ -404,6 +510,21 @@ var Timeline = class {
     this.changed();
     return true;
   }
+  /**
+   * Forgets the presses on a row the server has just re-rendered.
+   *
+   * 히스토리 응답의 행은 뷰어별 `myReactions`를 싣고 오므로 그 값이 서버의
+   * 값이다. 누름을 남겨 두면 그 뒤에 온 거절이 더 새로운 진실 위에 옛 값을
+   * 덮어쓴다. 행 전체 단위인 것은 페이지가 그 행의 이모지 전부를 다시 그려
+   * 주기 때문이다.
+   */
+  serverRendered(messageId) {
+    if (this.presses.size === 0) return;
+    const prefix = `${messageId}\0`;
+    for (const key of this.presses.keys()) {
+      if (key.startsWith(prefix)) this.presses.delete(key);
+    }
+  }
   /** Makes `items` safe to mutate: a copy, if the current one was handed out. */
   own() {
     if (!this.shared) return;
@@ -418,6 +539,9 @@ var Timeline = class {
 function emptied(message) {
   return { ...message, body: {}, deletedAt: message.deletedAt ?? Date.now() };
 }
+function pairKey(messageId, emoji) {
+  return `${messageId}\0${emoji}`;
+}
 function createTimeline(options) {
   return new Timeline(options);
 }
@@ -481,6 +605,17 @@ var Room = class extends Emitter {
       onChange: (messages) => this.emit("messages", messages)
     });
   }
+  /**
+   * Whether older history exists above the first message held -- what
+   * `loadOlder()` would report as `hasMore`, known before calling it.
+   *
+   * Derived from the first row's seq against the room's retention floor
+   * (the subscribe ack's `minSeq`), and false once a `loadOlder()` came
+   * back short. False while nothing is loaded. Re-read it on `messages`.
+   */
+  get hasOlder() {
+    return this.timeline.hasOlder;
+  }
   /** Everything this client knows about the room, in seq order. A new array whenever it changes. */
   get messages() {
     return this.timeline.messages;
@@ -559,6 +694,7 @@ var Room = class extends Emitter {
     this.id = ack.roomId;
     this.chat.registerRoomId(ack.roomId, this);
     this.lastSeq = ack.lastSeq;
+    if (typeof ack.minSeq === "number") this.timeline.setFloor(ack.minSeq);
     if (ack.presence !== void 0) this.presence = ack.presence;
     if (attempt.wasReset) {
       await this.loadRecent(current);
@@ -602,12 +738,52 @@ var Room = class extends Emitter {
     });
     return page.messages;
   }
-  /** Adds a reaction. Idempotent, like the frame. */
+  /**
+   * Adds a reaction. Idempotent, like the frame.
+   *
+   * The row's `myReactions` moves **before the frame goes out** and rolls
+   * back if the server refuses; its count stays the server's. See
+   * `toggleReaction`.
+   */
   async react(messageId, emoji) {
-    await this.chat.send("react", { roomId: await this.resolveId("reacting"), messageId, emoji, op: "add" });
+    await this.toggleReaction(messageId, emoji, true);
   }
+  /** Removes a reaction. Idempotent, and optimistic the same way `react` is. */
   async unreact(messageId, emoji) {
-    await this.chat.send("react", { roomId: await this.resolveId("reacting"), messageId, emoji, op: "remove" });
+    await this.toggleReaction(messageId, emoji, false);
+  }
+  /**
+   * Moves `myReactions` now, sends the frame after.
+   *
+   * 누른 값은 (사용자, 이모지)로 로컬에서 정해지고 엔진은 멱등이므로 ack를
+   * 기다릴 이유가 없다 — 기다리면 누른 느낌이 왕복 시간만큼 늦는다. 소비자가
+   * 자기 낙관 계층을 덧대면 이 필드의 주인이 둘이 되므로, SDK가 한다.
+   * **발행은 다르다**: `before_publish` 훅이 본문을 바꿀 수 있어 미리 그릴 값이
+   * 로컬에 없다. 그래서 `send()`는 낙관적이지 않다.
+   *
+   * 개수는 옮기지 않는다. ack가 오기 전에 남이 같은 이모지를 누르면 로컬
+   * +1/-1은 서버가 보낸 수와 다른 값이 되고, 그것을 고칠 이벤트는 이미
+   * 지나갔다. 또 ack와 방 프레임은 다른 길로 와 순서가 없으므로, 늦게 온 내
+   * ack(count 1)가 앞서 온 남의 이벤트(count 2)를 되돌린다.
+   *
+   * 거절·타임아웃·끊김이면 되돌리지만, 그 사이 더 새로운 값이 자리를 차지했다면
+   * 두고 나온다(`Timeline.settleReaction`).
+   */
+  async toggleReaction(messageId, emoji, mine) {
+    const press = this.timeline.pressReaction(messageId, emoji, mine);
+    try {
+      await this.chat.send("react", {
+        roomId: await this.resolveId("reacting"),
+        messageId,
+        emoji,
+        op: mine ? "add" : "remove"
+      });
+    } catch (err) {
+      if (press !== void 0) this.timeline.settleReaction(press, false);
+      throw err;
+    }
+    if (press !== void 0) this.timeline.settleReaction(press, true);
+    else this.timeline.reaction(messageId, emoji, void 0, mine);
   }
   /**
    * Moves this user's read cursor.
@@ -802,7 +978,9 @@ var Room = class extends Emitter {
       case "reaction.added":
       case "reaction.removed": {
         const r = data;
-        this.timeline.reaction(r.messageId, r.emoji, r.count);
+        const me = this.chat.user?.id;
+        const mine = me !== void 0 && r.userId === me ? type === "reaction.added" : void 0;
+        this.timeline.reaction(r.messageId, r.emoji, r.count, mine);
         break;
       }
       case "thread.updated": {
@@ -1051,6 +1229,48 @@ var ChatClient = class extends Emitter {
     });
     return this.opening;
   }
+  /**
+   * Re-authenticates: calls `token()` again and replaces the socket, keeping
+   * every room handle and every subscription.
+   *
+   * For when the identity the server holds has to change mid-session --
+   * a nickname change, a new avatar, fresh claims. The server reads the
+   * token once, at `auth`, so `sender.name` on the next message is the old
+   * one until the connection is re-authenticated. `close()` + `connect()`
+   * does that too, but passes through `closed` (a consumer's "you are
+   * offline" screen) and tears down the page listeners.
+   *
+   * States: `open` → `reconnecting` → `open`, never `closed`. Rooms
+   * resubscribe from what they hold and catch up the gap, as after any
+   * drop; `messages` is kept. Frames awaiting an ack on the old socket are
+   * rejected with `closed`. `chat.user` is the new identity once this
+   * resolves. If `token()` fails the client keeps retrying in the
+   * background like any reconnect (and this rejects); a `ChatError` from
+   * `token()` stops it at `closed`, as on connect.
+   *
+   * On a client that is not connected (never connected, or `close()`d) it
+   * is `connect()`.
+   */
+  async reconnect() {
+    if (this.opening !== void 0) await this.opening.catch(() => {
+    });
+    const socket = this.socket;
+    if (socket === void 0 || this.state !== "open") return this.connect();
+    this.clearTimers();
+    this.retired.add(socket);
+    this.socket = void 0;
+    this.failPending(new ChatError("closed", "the connection was replaced by reconnect()"));
+    try {
+      socket.close(1e3, "client reconnecting");
+    } catch {
+    }
+    this.opening = this.openOnce("reconnecting").finally(() => {
+      this.opening = void 0;
+    });
+    return this.opening;
+  }
+  /** Sockets `reconnect()` replaced: their late events are not this client's any more. */
+  retired = /* @__PURE__ */ new WeakSet();
   /**
    * Closes for good.
    *
@@ -1164,8 +1384,8 @@ var ChatClient = class extends Emitter {
     this.state = next;
     this.emit("state", next);
   }
-  async openOnce() {
-    this.setState(this.attempt === 0 ? "connecting" : "reconnecting");
+  async openOnce(state = this.attempt === 0 ? "connecting" : "reconnecting") {
+    this.setState(state);
     let authData;
     try {
       authData = await this.authData();
@@ -1191,6 +1411,7 @@ var ChatClient = class extends Emitter {
         else reject(err);
       };
       socket.addEventListener("message", (ev) => {
+        if (this.retired.has(socket)) return;
         const frame = JSON.parse(String(ev.data));
         if (frame.type === "hello") {
           this.onHello(frame.data);
@@ -1211,6 +1432,7 @@ var ChatClient = class extends Emitter {
         this.onFrame(frame);
       });
       socket.addEventListener("close", () => {
+        if (this.retired.has(socket)) return;
         if (this.socket !== void 0 && this.socket !== socket) return;
         this.clearTimers();
         this.socket = void 0;

package/dist/server/index.cjs

@@ -274,6 +274,7 @@ function createChatServer(options) {
       custom: async (roomId, payload) => {
         await rest.call("POST", `/v1/rooms/${roomId}/custom`, { payload });
       },
+      presence: (roomId, o) => rest.call("GET", `/v1/rooms/${roomId}/presence${rest.query({ full: o?.full ? "true" : void 0 })}`),
       members: {
         list: (roomId, o) => rest.call("GET", `/v1/rooms/${roomId}/members${rest.query({ cursor: o?.cursor, limit: o?.limit })}`),
         add: async (roomId, userId, role) => {
@@ -320,6 +321,7 @@ function createChatServer(options) {
       // the messages left standing. Nothing failed; the caller was told
       // it had worked.
       delete: (userId, o) => rest.call("DELETE", `/v1/users/${userId}${rest.query({ purge_messages: o?.purgeMessages ? "true" : void 0 })}`),
+      purgeMessages: (userId) => rest.call("DELETE", `/v1/users/${userId}/messages`),
       revokeTokens: async (userId) => {
         await rest.call("POST", `/v1/users/${userId}/revoke-tokens`);
       },

package/dist/server/index.d.cts

@@ -109,6 +109,25 @@ type ServerSendInput = {
     replyTo?: string;
     threadId?: string;
 };
+type RoomPresence = {
+    count: number;
+    /** Only with `full: true`. */
+    users?: {
+        id: string;
+        name: string;
+        avatar?: string;
+        meta?: Record<string, unknown>;
+    }[];
+    capped?: boolean;
+};
+/** What `users.purgeMessages` and the withdrawal purge report. */
+type PurgeMessagesResult = {
+    userId: string;
+    /** Messages this call turned into tombstones. 0 on a repeat call after a finished one. */
+    purgedMessages: number;
+    /** The per-call cap was hit: **call again** until this is false. */
+    purgeCapped: boolean;
+};
 type GuestInput = Omit<TokenInput, 'userId'> & {
     /** What `guest()` returned last time, as the browser kept it. Missing or invalid means a new guest. */
     credential?: string | null;
@@ -169,6 +188,14 @@ type ChatServer = {
          * in one frame). `sk_` only, like every other route on this object.
          */
         custom: (roomId: string, payload: Record<string, unknown>) => Promise<void>;
+        /**
+         * Who is in the room right now. `{count}` by default; `full: true` adds
+         * `users` (at most 1000, `capped: true` when cut). An empty room is
+         * `{count: 0}`, not a 404.
+         */
+        presence: (roomId: string, options?: {
+            full?: boolean;
+        }) => Promise<RoomPresence>;
         members: {
             list: (roomId: string, options?: {
                 cursor?: string;
@@ -216,6 +243,17 @@ type ChatServer = {
             avatar?: string;
             meta?: Record<string, unknown>;
         }) => Promise<unknown>;
+        /**
+         * Moderation: deletes every live message this user sent in the app
+         * (tombstones -- seq stays gap-free, clients get `message.deleted`),
+         * **without** withdrawing them. The name stays on the tombstones.
+         *
+         * Ban first (`ban`), then call this: a message posted while it runs is
+         * not in its listing. Bounded per call -- loop while `purgeCapped`.
+         * A withdrawn user is 404; their messages go with
+         * `delete(userId, { purgeMessages: true })`.
+         */
+        purgeMessages: (userId: string) => Promise<PurgeMessagesResult>;
         /** Withdrawal: anonymises rather than deleting rows. */
         delete: (userId: string, options?: {
             purgeMessages?: boolean;
@@ -256,4 +294,4 @@ type ChatServer = {
 };
 declare function createChatServer(options: ChatServerOptions): ChatServer;
 
-export { type ChatServer, type ChatServerOptions, DefaultTokenTtlSeconds, type EnsureRoomInput, GuestIdPrefix, type GuestIdentity, type GuestInput, MaxTokenTtlSeconds, type ServerSendInput, SignatureToleranceMs, type TokenInput, type VerifiedDelivery, type VerifyOptions, createChatServer };
+export { type ChatServer, type ChatServerOptions, DefaultTokenTtlSeconds, type EnsureRoomInput, GuestIdPrefix, type GuestIdentity, type GuestInput, MaxTokenTtlSeconds, type PurgeMessagesResult, type RoomPresence, type ServerSendInput, SignatureToleranceMs, type TokenInput, type VerifiedDelivery, type VerifyOptions, createChatServer };

package/dist/server/index.d.ts

@@ -109,6 +109,25 @@ type ServerSendInput = {
     replyTo?: string;
     threadId?: string;
 };
+type RoomPresence = {
+    count: number;
+    /** Only with `full: true`. */
+    users?: {
+        id: string;
+        name: string;
+        avatar?: string;
+        meta?: Record<string, unknown>;
+    }[];
+    capped?: boolean;
+};
+/** What `users.purgeMessages` and the withdrawal purge report. */
+type PurgeMessagesResult = {
+    userId: string;
+    /** Messages this call turned into tombstones. 0 on a repeat call after a finished one. */
+    purgedMessages: number;
+    /** The per-call cap was hit: **call again** until this is false. */
+    purgeCapped: boolean;
+};
 type GuestInput = Omit<TokenInput, 'userId'> & {
     /** What `guest()` returned last time, as the browser kept it. Missing or invalid means a new guest. */
     credential?: string | null;
@@ -169,6 +188,14 @@ type ChatServer = {
          * in one frame). `sk_` only, like every other route on this object.
          */
         custom: (roomId: string, payload: Record<string, unknown>) => Promise<void>;
+        /**
+         * Who is in the room right now. `{count}` by default; `full: true` adds
+         * `users` (at most 1000, `capped: true` when cut). An empty room is
+         * `{count: 0}`, not a 404.
+         */
+        presence: (roomId: string, options?: {
+            full?: boolean;
+        }) => Promise<RoomPresence>;
         members: {
             list: (roomId: string, options?: {
                 cursor?: string;
@@ -216,6 +243,17 @@ type ChatServer = {
             avatar?: string;
             meta?: Record<string, unknown>;
         }) => Promise<unknown>;
+        /**
+         * Moderation: deletes every live message this user sent in the app
+         * (tombstones -- seq stays gap-free, clients get `message.deleted`),
+         * **without** withdrawing them. The name stays on the tombstones.
+         *
+         * Ban first (`ban`), then call this: a message posted while it runs is
+         * not in its listing. Bounded per call -- loop while `purgeCapped`.
+         * A withdrawn user is 404; their messages go with
+         * `delete(userId, { purgeMessages: true })`.
+         */
+        purgeMessages: (userId: string) => Promise<PurgeMessagesResult>;
         /** Withdrawal: anonymises rather than deleting rows. */
         delete: (userId: string, options?: {
             purgeMessages?: boolean;
@@ -256,4 +294,4 @@ type ChatServer = {
 };
 declare function createChatServer(options: ChatServerOptions): ChatServer;
 
-export { type ChatServer, type ChatServerOptions, DefaultTokenTtlSeconds, type EnsureRoomInput, GuestIdPrefix, type GuestIdentity, type GuestInput, MaxTokenTtlSeconds, type ServerSendInput, SignatureToleranceMs, type TokenInput, type VerifiedDelivery, type VerifyOptions, createChatServer };
+export { type ChatServer, type ChatServerOptions, DefaultTokenTtlSeconds, type EnsureRoomInput, GuestIdPrefix, type GuestIdentity, type GuestInput, MaxTokenTtlSeconds, type PurgeMessagesResult, type RoomPresence, type ServerSendInput, SignatureToleranceMs, type TokenInput, type VerifiedDelivery, type VerifyOptions, createChatServer };

package/dist/server/index.js

@@ -217,6 +217,7 @@ function createChatServer(options) {
       custom: async (roomId, payload) => {
         await rest.call("POST", `/v1/rooms/${roomId}/custom`, { payload });
       },
+      presence: (roomId, o) => rest.call("GET", `/v1/rooms/${roomId}/presence${rest.query({ full: o?.full ? "true" : void 0 })}`),
       members: {
         list: (roomId, o) => rest.call("GET", `/v1/rooms/${roomId}/members${rest.query({ cursor: o?.cursor, limit: o?.limit })}`),
         add: async (roomId, userId, role) => {
@@ -263,6 +264,7 @@ function createChatServer(options) {
       // the messages left standing. Nothing failed; the caller was told
       // it had worked.
       delete: (userId, o) => rest.call("DELETE", `/v1/users/${userId}${rest.query({ purge_messages: o?.purgeMessages ? "true" : void 0 })}`),
+      purgeMessages: (userId) => rest.call("DELETE", `/v1/users/${userId}/messages`),
       revokeTokens: async (userId) => {
         await rest.call("POST", `/v1/users/${userId}/revoke-tokens`);
       },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kispi/chat",
-  "version": "0.2.1",
+  "version": "0.2.3",
   "description": "Client SDK for the chat server: one WebSocket, many rooms, ordered history.",
   "license": "MIT",
   "type": "module",