@kispi/chat 0.2.0 → 0.2.2

package/dist/index.d.cts

@@ -14,6 +14,28 @@ declare class Emitter<Events extends Record<string, unknown>> {
     clear(): void;
 }
 
+/**
+ * Every failure this SDK raises, with the server's own code on it.
+ *
+ * The code matters more than the message. A consumer branches on
+ * `rate_limited` versus `moderation_denied` versus `unauthorized`, and a
+ * bare `Error` carrying prose forces them to match on strings the server
+ * is free to reword.
+ */
+declare class ChatError extends Error {
+    readonly code: string;
+    /** Present on rate limits, in milliseconds. */
+    readonly retryAfterMs?: number;
+    /** The consumer's own code, when a before_publish hook denied this. */
+    readonly appCode?: string;
+    /** The HTTP status, when this came from a REST call. */
+    status?: number;
+    constructor(code: string, message: string, extra?: {
+        retryAfterMs?: number;
+        appCode?: string;
+    });
+}
+
 /**
  * The wire shapes this SDK reads and writes.
  *
@@ -120,6 +142,16 @@ type Message = {
         emoji: string;
         count: number;
     }[];
+    /**
+     * The emoji this client's user has on the message.
+     *
+     * Filled by history reads and kept in step by the SDK afterwards: a
+     * `reaction.*` event whose `userId` is `chat.user.id`, and the ack of
+     * this client's own `react()`/`unreact()`, update it. Absent on a row
+     * the server rendered without a viewer (a live `message.created` has
+     * none yet, which is the same as empty).
+     */
+    myReactions?: string[];
     thread?: {
         count: number;
         lastSeq?: number;
@@ -166,11 +198,11 @@ type RoomEvents = {
      * socket's read loop where there is no caller to throw to -- and
      * swallowing it is what leaves a hole nothing ever fills.
      *
-     * The retry to offer is **`room.subscribe()`**. A room that emitted
-     * this is left not-subscribed on purpose, precisely so that call does
-     * something: it re-subscribes and reloads. Marking it subscribed and
-     * telling the consumer to retry would be advice that returns
-     * immediately having done nothing, which is worse than no advice.
+     * The room repairs itself: it re-subscribes with backoff (1 s doubling,
+     * up to five tries while connected), and every reconnect tries again.
+     * `room.subscribe()` is still the retry to offer a person pressing a
+     * button -- a room that emitted this is left not-subscribed on purpose,
+     * precisely so that call does something.
      */
     error: Error;
     /**
@@ -252,10 +284,22 @@ declare class Room extends Emitter<RoomEvents> {
      */
     private wanted;
     private subscribing;
+    /** Self-repair: the armed retry, and how many have run since the last success. */
+    private repairTimer;
+    private repairs;
     constructor(chat: ChatClient, rest: Rest, address: {
         id?: string;
         key?: string;
     });
+    /**
+     * 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(): boolean;
     /** Everything this client knows about the room, in seq order. A new array whenever it changes. */
     get messages(): Message[];
     /**
@@ -323,8 +367,14 @@ declare class Room extends Emitter<RoomEvents> {
             thread: string;
         };
     }): Promise<Message[]>;
-    /** Adds a reaction. Idempotent, like the frame. */
+    /**
+     * Adds a reaction. Idempotent, like the frame.
+     *
+     * The ack updates the row's `myReactions` (not its count -- see below),
+     * so the "I reacted" state is right even if the broadcast is missed.
+     */
     react(messageId: string, emoji: string): Promise<void>;
+    /** Removes a reaction. Idempotent; the ack clears it from `myReactions`. */
     unreact(messageId: string, emoji: string): Promise<void>;
     /**
      * Moves this user's read cursor.
@@ -387,7 +437,17 @@ declare class Room extends Emitter<RoomEvents> {
      * transient 500 takes a room out of the live feed for the life of the
      * page.
      */
-    resume(): Promise<void>;
+    resume(restart?: boolean): Promise<void>;
+    /**
+     * Reports a failure no caller was waiting for, and repairs.
+     *
+     * 백그라운드 실패(재접속 뒤 다시 구독, 구멍 메우기)에는 거절을 받을 호출자가
+     * 없다. 이벤트만 내고 두면 방은 다음 재접속이나 탭 복귀까지 구멍을 안고 —
+     * 구독 프레임부터 실패했다면 라이브 피드 밖에서 — 머문다. 그래서 스스로 다시
+     * 구독한다. 횟수를 묶는 것은 고칠 수 없는 실패(권한, 없어진 방)가 서버를
+     * 계속 두드리지 않게 하려는 것이고, 그 뒤는 재접속과 `subscribe()`의 몫이다.
+     */
+    failed(err: unknown): void;
     /**
      * Sends `subscribe` and recovers from the one error it has an answer
      * for.
@@ -474,7 +534,9 @@ type ChatClientOptions = {
      * Called again on every connect, and again when a REST call is
      * answered 401 (the call is then retried once), so an expired token is
      * replaced rather than reused. A throw here is retried with backoff
-     * like a dropped socket; only `close()` stops that.
+     * like a dropped socket -- **unless it throws a `ChatError`**, which
+     * means "do not retry" (a ban, a session that ended): the client goes
+     * to `closed` and emits it as `error`.
      *
      * **Never sign these in the browser** -- signing needs the `sk_`, and
      * a `sk_` in a browser is the whole app.
@@ -497,6 +559,15 @@ type ChatClientEvents = {
      * SDK learns about it.
      */
     frame: Frame;
+    /**
+     * 클라이언트가 스스로 `closed`로 멈췄고, 이게 그 이유다.
+     *
+     * 멈추는 길은 셋이다: `close()`, 서버의 인증 거절, `token()`이 던진
+     * `ChatError`. 첫 connect라면 거절로도 알 수 있지만 재접속 중이나 REST의
+     * 토큰 갱신 중에는 받을 호출자가 없어서, 이것 없이는 `state`가 `closed`로
+     * 바뀌는 것만 보이고 왜인지는 사라진다. `close()`로 닫을 때는 내지 않는다.
+     */
+    error: ChatError;
 };
 declare class ChatClient extends Emitter<ChatClientEvents> {
     state: ConnectionState;
@@ -509,8 +580,11 @@ declare class ChatClient extends Emitter<ChatClientEvents> {
     private heartbeat;
     private retryTimer;
     private attempt;
-    /** Set by close(), and the only thing that stops the reconnect loop. */
-    private closedByCaller;
+    /**
+     * The reconnect loop is off: set by close(), and by a failure that
+     * retrying cannot fix (see `stop`). Cleared by connect().
+     */
+    private stopped;
     private nextFrameId;
     private opening;
     private readonly rest;
@@ -637,14 +711,59 @@ declare class ChatClient extends Emitter<ChatClientEvents> {
     registerRoomId(roomId: string, room: Room): void;
     /** Opens the connection and resolves when `hello` arrives. */
     connect(): Promise<void>;
+    /**
+     * 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()`.
+     */
+    reconnect(): Promise<void>;
+    /** Sockets `reconnect()` replaced: their late events are not this client's any more. */
+    private readonly retired;
     /**
      * Closes for good.
      *
      * The distinction from a dropped socket is the whole point of the state
-     * machine: this is the only path that reaches `closed`, and a consumer
-     * showing "disconnected, retrying" versus "disconnected" needs it.
+     * machine: `closed` means nothing is coming back, and a consumer showing
+     * "disconnected, retrying" versus "disconnected" needs it. The other
+     * ways to reach it are refusals retrying cannot fix -- see `stop`.
      */
     close(): Promise<void>;
+    /**
+     * Stops for a reason retrying cannot fix, and says which.
+     *
+     * `close()` without the teardown of the page listeners -- a consumer
+     * that logs back in calls `connect()` on the same client -- and with an
+     * `error` event, because on a reconnect there is no caller to reject.
+     */
+    private stop;
+    /**
+     * Resolves once the connection is open. Used by `Room.subscribe`.
+     *
+     * 연결 전에 부른 `subscribe()`를 `closed`로 거절하면 소비자는 "언제 다시
+     * 부를지"를 스스로 알아내야 하고, 첫 connect가 실패했다면 그 때는 영영 오지
+     * 않는다. 붙을 때까지 기다리면 그 신호가 필요 없다. 멈춘 클라이언트(close,
+     * 인증 거절)는 붙을 일이 없으니 거절한다.
+     */
+    whenOpen(): Promise<void>;
+    private openWaiters;
+    private settleOpenWaiters;
     /** Sends a frame and resolves with its ack, or rejects with its error. */
     send(type: string, data?: unknown, timeoutMs?: number): Promise<unknown>;
     /**
@@ -700,28 +819,6 @@ declare class ChatClient extends Emitter<ChatClientEvents> {
 }
 declare function createChatClient(options: ChatClientOptions): ChatClient;
 
-/**
- * Every failure this SDK raises, with the server's own code on it.
- *
- * The code matters more than the message. A consumer branches on
- * `rate_limited` versus `moderation_denied` versus `unauthorized`, and a
- * bare `Error` carrying prose forces them to match on strings the server
- * is free to reword.
- */
-declare class ChatError extends Error {
-    readonly code: string;
-    /** Present on rate limits, in milliseconds. */
-    readonly retryAfterMs?: number;
-    /** The consumer's own code, when a before_publish hook denied this. */
-    readonly appCode?: string;
-    /** The HTTP status, when this came from a REST call. */
-    status?: number;
-    constructor(code: string, message: string, extra?: {
-        retryAfterMs?: number;
-        appCode?: string;
-    });
-}
-
 /**
  * The message list, in `seq` order, with its holes filled.
  *
@@ -793,9 +890,27 @@ declare class Timeline {
     private shared;
     /** The `loadOlder` in flight, so a scroll handler firing twice asks once. */
     private 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.
+     */
+    private floor;
+    /** A `loadOlder` came back short: the top of what the server keeps was reached. */
+    private exhausted;
     constructor(options: TimelineOptions);
     /** A new array whenever the list changes; never mutated once returned. */
     get messages(): Message[];
+    /**
+     * Whether `loadOlder()` would find anything, answered without asking.
+     *
+     * `loadOlder()`의 `hasMore`와 같은 판정이다: 맨 위 행이 방의 보존 하한
+     * (`minSeq`, seq는 1부터 구멍 없이 붙는다)보다 위에 있고, 앞선 `loadOlder`가
+     * 덜 찬 페이지로 끝을 알린 적이 없으면 더 있다. 첫 `loadOlder()` 전에 "이전
+     * 메시지 더 보기"를 그릴지 정할 수 있게 한다. 목록이 비었으면 false다.
+     */
+    get hasOlder(): boolean;
+    /** Records the room's retention floor (`minSeq`). */
+    setFloor(minSeq: number): void;
     /** The highest seq this timeline holds, hole or no hole. */
     get highestSeq(): number;
     /**
@@ -870,9 +985,11 @@ declare class Timeline {
      *
      * 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).
      */
-    reaction(messageId: string, emoji: string, count: number): void;
+    reaction(messageId: string, emoji: string, count: number | undefined, mine?: boolean): void;
     /** Applies a `thread.updated` to the root message's aggregate. */
     thread(rootId: string, count: number, lastSeq?: number): void;
     /** Applies a `message.deleted`, remembering it if the row is not here. */

package/dist/index.d.ts

@@ -14,6 +14,28 @@ declare class Emitter<Events extends Record<string, unknown>> {
     clear(): void;
 }
 
+/**
+ * Every failure this SDK raises, with the server's own code on it.
+ *
+ * The code matters more than the message. A consumer branches on
+ * `rate_limited` versus `moderation_denied` versus `unauthorized`, and a
+ * bare `Error` carrying prose forces them to match on strings the server
+ * is free to reword.
+ */
+declare class ChatError extends Error {
+    readonly code: string;
+    /** Present on rate limits, in milliseconds. */
+    readonly retryAfterMs?: number;
+    /** The consumer's own code, when a before_publish hook denied this. */
+    readonly appCode?: string;
+    /** The HTTP status, when this came from a REST call. */
+    status?: number;
+    constructor(code: string, message: string, extra?: {
+        retryAfterMs?: number;
+        appCode?: string;
+    });
+}
+
 /**
  * The wire shapes this SDK reads and writes.
  *
@@ -120,6 +142,16 @@ type Message = {
         emoji: string;
         count: number;
     }[];
+    /**
+     * The emoji this client's user has on the message.
+     *
+     * Filled by history reads and kept in step by the SDK afterwards: a
+     * `reaction.*` event whose `userId` is `chat.user.id`, and the ack of
+     * this client's own `react()`/`unreact()`, update it. Absent on a row
+     * the server rendered without a viewer (a live `message.created` has
+     * none yet, which is the same as empty).
+     */
+    myReactions?: string[];
     thread?: {
         count: number;
         lastSeq?: number;
@@ -166,11 +198,11 @@ type RoomEvents = {
      * socket's read loop where there is no caller to throw to -- and
      * swallowing it is what leaves a hole nothing ever fills.
      *
-     * The retry to offer is **`room.subscribe()`**. A room that emitted
-     * this is left not-subscribed on purpose, precisely so that call does
-     * something: it re-subscribes and reloads. Marking it subscribed and
-     * telling the consumer to retry would be advice that returns
-     * immediately having done nothing, which is worse than no advice.
+     * The room repairs itself: it re-subscribes with backoff (1 s doubling,
+     * up to five tries while connected), and every reconnect tries again.
+     * `room.subscribe()` is still the retry to offer a person pressing a
+     * button -- a room that emitted this is left not-subscribed on purpose,
+     * precisely so that call does something.
      */
     error: Error;
     /**
@@ -252,10 +284,22 @@ declare class Room extends Emitter<RoomEvents> {
      */
     private wanted;
     private subscribing;
+    /** Self-repair: the armed retry, and how many have run since the last success. */
+    private repairTimer;
+    private repairs;
     constructor(chat: ChatClient, rest: Rest, address: {
         id?: string;
         key?: string;
     });
+    /**
+     * 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(): boolean;
     /** Everything this client knows about the room, in seq order. A new array whenever it changes. */
     get messages(): Message[];
     /**
@@ -323,8 +367,14 @@ declare class Room extends Emitter<RoomEvents> {
             thread: string;
         };
     }): Promise<Message[]>;
-    /** Adds a reaction. Idempotent, like the frame. */
+    /**
+     * Adds a reaction. Idempotent, like the frame.
+     *
+     * The ack updates the row's `myReactions` (not its count -- see below),
+     * so the "I reacted" state is right even if the broadcast is missed.
+     */
     react(messageId: string, emoji: string): Promise<void>;
+    /** Removes a reaction. Idempotent; the ack clears it from `myReactions`. */
     unreact(messageId: string, emoji: string): Promise<void>;
     /**
      * Moves this user's read cursor.
@@ -387,7 +437,17 @@ declare class Room extends Emitter<RoomEvents> {
      * transient 500 takes a room out of the live feed for the life of the
      * page.
      */
-    resume(): Promise<void>;
+    resume(restart?: boolean): Promise<void>;
+    /**
+     * Reports a failure no caller was waiting for, and repairs.
+     *
+     * 백그라운드 실패(재접속 뒤 다시 구독, 구멍 메우기)에는 거절을 받을 호출자가
+     * 없다. 이벤트만 내고 두면 방은 다음 재접속이나 탭 복귀까지 구멍을 안고 —
+     * 구독 프레임부터 실패했다면 라이브 피드 밖에서 — 머문다. 그래서 스스로 다시
+     * 구독한다. 횟수를 묶는 것은 고칠 수 없는 실패(권한, 없어진 방)가 서버를
+     * 계속 두드리지 않게 하려는 것이고, 그 뒤는 재접속과 `subscribe()`의 몫이다.
+     */
+    failed(err: unknown): void;
     /**
      * Sends `subscribe` and recovers from the one error it has an answer
      * for.
@@ -474,7 +534,9 @@ type ChatClientOptions = {
      * Called again on every connect, and again when a REST call is
      * answered 401 (the call is then retried once), so an expired token is
      * replaced rather than reused. A throw here is retried with backoff
-     * like a dropped socket; only `close()` stops that.
+     * like a dropped socket -- **unless it throws a `ChatError`**, which
+     * means "do not retry" (a ban, a session that ended): the client goes
+     * to `closed` and emits it as `error`.
      *
      * **Never sign these in the browser** -- signing needs the `sk_`, and
      * a `sk_` in a browser is the whole app.
@@ -497,6 +559,15 @@ type ChatClientEvents = {
      * SDK learns about it.
      */
     frame: Frame;
+    /**
+     * 클라이언트가 스스로 `closed`로 멈췄고, 이게 그 이유다.
+     *
+     * 멈추는 길은 셋이다: `close()`, 서버의 인증 거절, `token()`이 던진
+     * `ChatError`. 첫 connect라면 거절로도 알 수 있지만 재접속 중이나 REST의
+     * 토큰 갱신 중에는 받을 호출자가 없어서, 이것 없이는 `state`가 `closed`로
+     * 바뀌는 것만 보이고 왜인지는 사라진다. `close()`로 닫을 때는 내지 않는다.
+     */
+    error: ChatError;
 };
 declare class ChatClient extends Emitter<ChatClientEvents> {
     state: ConnectionState;
@@ -509,8 +580,11 @@ declare class ChatClient extends Emitter<ChatClientEvents> {
     private heartbeat;
     private retryTimer;
     private attempt;
-    /** Set by close(), and the only thing that stops the reconnect loop. */
-    private closedByCaller;
+    /**
+     * The reconnect loop is off: set by close(), and by a failure that
+     * retrying cannot fix (see `stop`). Cleared by connect().
+     */
+    private stopped;
     private nextFrameId;
     private opening;
     private readonly rest;
@@ -637,14 +711,59 @@ declare class ChatClient extends Emitter<ChatClientEvents> {
     registerRoomId(roomId: string, room: Room): void;
     /** Opens the connection and resolves when `hello` arrives. */
     connect(): Promise<void>;
+    /**
+     * 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()`.
+     */
+    reconnect(): Promise<void>;
+    /** Sockets `reconnect()` replaced: their late events are not this client's any more. */
+    private readonly retired;
     /**
      * Closes for good.
      *
      * The distinction from a dropped socket is the whole point of the state
-     * machine: this is the only path that reaches `closed`, and a consumer
-     * showing "disconnected, retrying" versus "disconnected" needs it.
+     * machine: `closed` means nothing is coming back, and a consumer showing
+     * "disconnected, retrying" versus "disconnected" needs it. The other
+     * ways to reach it are refusals retrying cannot fix -- see `stop`.
      */
     close(): Promise<void>;
+    /**
+     * Stops for a reason retrying cannot fix, and says which.
+     *
+     * `close()` without the teardown of the page listeners -- a consumer
+     * that logs back in calls `connect()` on the same client -- and with an
+     * `error` event, because on a reconnect there is no caller to reject.
+     */
+    private stop;
+    /**
+     * Resolves once the connection is open. Used by `Room.subscribe`.
+     *
+     * 연결 전에 부른 `subscribe()`를 `closed`로 거절하면 소비자는 "언제 다시
+     * 부를지"를 스스로 알아내야 하고, 첫 connect가 실패했다면 그 때는 영영 오지
+     * 않는다. 붙을 때까지 기다리면 그 신호가 필요 없다. 멈춘 클라이언트(close,
+     * 인증 거절)는 붙을 일이 없으니 거절한다.
+     */
+    whenOpen(): Promise<void>;
+    private openWaiters;
+    private settleOpenWaiters;
     /** Sends a frame and resolves with its ack, or rejects with its error. */
     send(type: string, data?: unknown, timeoutMs?: number): Promise<unknown>;
     /**
@@ -700,28 +819,6 @@ declare class ChatClient extends Emitter<ChatClientEvents> {
 }
 declare function createChatClient(options: ChatClientOptions): ChatClient;
 
-/**
- * Every failure this SDK raises, with the server's own code on it.
- *
- * The code matters more than the message. A consumer branches on
- * `rate_limited` versus `moderation_denied` versus `unauthorized`, and a
- * bare `Error` carrying prose forces them to match on strings the server
- * is free to reword.
- */
-declare class ChatError extends Error {
-    readonly code: string;
-    /** Present on rate limits, in milliseconds. */
-    readonly retryAfterMs?: number;
-    /** The consumer's own code, when a before_publish hook denied this. */
-    readonly appCode?: string;
-    /** The HTTP status, when this came from a REST call. */
-    status?: number;
-    constructor(code: string, message: string, extra?: {
-        retryAfterMs?: number;
-        appCode?: string;
-    });
-}
-
 /**
  * The message list, in `seq` order, with its holes filled.
  *
@@ -793,9 +890,27 @@ declare class Timeline {
     private shared;
     /** The `loadOlder` in flight, so a scroll handler firing twice asks once. */
     private 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.
+     */
+    private floor;
+    /** A `loadOlder` came back short: the top of what the server keeps was reached. */
+    private exhausted;
     constructor(options: TimelineOptions);
     /** A new array whenever the list changes; never mutated once returned. */
     get messages(): Message[];
+    /**
+     * Whether `loadOlder()` would find anything, answered without asking.
+     *
+     * `loadOlder()`의 `hasMore`와 같은 판정이다: 맨 위 행이 방의 보존 하한
+     * (`minSeq`, seq는 1부터 구멍 없이 붙는다)보다 위에 있고, 앞선 `loadOlder`가
+     * 덜 찬 페이지로 끝을 알린 적이 없으면 더 있다. 첫 `loadOlder()` 전에 "이전
+     * 메시지 더 보기"를 그릴지 정할 수 있게 한다. 목록이 비었으면 false다.
+     */
+    get hasOlder(): boolean;
+    /** Records the room's retention floor (`minSeq`). */
+    setFloor(minSeq: number): void;
     /** The highest seq this timeline holds, hole or no hole. */
     get highestSeq(): number;
     /**
@@ -870,9 +985,11 @@ declare class Timeline {
      *
      * 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).
      */
-    reaction(messageId: string, emoji: string, count: number): void;
+    reaction(messageId: string, emoji: string, count: number | undefined, mine?: boolean): void;
     /** Applies a `thread.updated` to the root message's aggregate. */
     thread(rootId: string, count: number, lastSeq?: number): void;
     /** Applies a `message.deleted`, remembering it if the row is not here. */