@kispi/chat 0.2.0 → 0.2.1

package/dist/index.cjs

@@ -481,6 +481,8 @@ function createTimeline(options) {
 
 // src/room.ts
 var HistoryPageSize = 100;
+var MaxRepairs = 5;
+var RepairBaseMs = 1e3;
 var Room = class extends Emitter {
   /** Resolved on subscribe when the room was addressed by key. */
   id;
@@ -518,6 +520,9 @@ var Room = class extends Emitter {
    */
   wanted = false;
   subscribing;
+  /** Self-repair: the armed retry, and how many have run since the last success. */
+  repairTimer;
+  repairs = 0;
   constructor(chat, rest, address) {
     super();
     this.chat = chat;
@@ -584,7 +589,12 @@ var Room = class extends Emitter {
     this.wanted = true;
     if (this.subscribing !== void 0) return this.subscribing;
     if (this.subscribed) return;
-    const attempt = this.doSubscribe().finally(() => {
+    const attempt = this.doSubscribe().then(() => {
+      const successor = this.subscribing;
+      if (successor !== void 0 && successor !== attempt) return successor;
+      if (this.subscribed) this.repairs = 0;
+      return void 0;
+    }).finally(() => {
       if (this.subscribing === attempt) this.subscribing = void 0;
     });
     this.subscribing = attempt;
@@ -593,6 +603,10 @@ var Room = class extends Emitter {
   async doSubscribe() {
     const gen = this.generation;
     const current = () => gen === this.generation;
+    if (this.chat.state !== "open") {
+      await this.chat.whenOpen();
+      if (!current()) return;
+    }
     const data = this.id !== void 0 ? { roomId: this.id } : { key: this.key };
     const since = this.timeline.contiguousSeq;
     if (since > 0) data["since"] = since;
@@ -722,13 +736,33 @@ var Room = class extends Emitter {
    * transient 500 takes a room out of the live feed for the life of the
    * page.
    */
-  async resume() {
+  async resume(restart = true) {
     if (!this.wanted) return;
+    if (!restart) return this.subscribe();
     this.generation++;
     this.subscribing = void 0;
     this.subscribed = false;
     await this.subscribe();
   }
+  /**
+   * Reports a failure no caller was waiting for, and repairs.
+   *
+   * 백그라운드 실패(재접속 뒤 다시 구독, 구멍 메우기)에는 거절을 받을 호출자가
+   * 없다. 이벤트만 내고 두면 방은 다음 재접속이나 탭 복귀까지 구멍을 안고 —
+   * 구독 프레임부터 실패했다면 라이브 피드 밖에서 — 머문다. 그래서 스스로 다시
+   * 구독한다. 횟수를 묶는 것은 고칠 수 없는 실패(권한, 없어진 방)가 서버를
+   * 계속 두드리지 않게 하려는 것이고, 그 뒤는 재접속과 `subscribe()`의 몫이다.
+   */
+  failed(err) {
+    this.emit("error", err instanceof Error ? err : new Error(String(err)));
+    if (this.repairTimer !== void 0 || this.repairs >= MaxRepairs) return;
+    const delay = RepairBaseMs * 2 ** this.repairs++;
+    this.repairTimer = setTimeout(() => {
+      this.repairTimer = void 0;
+      if (!this.wanted || this.subscribed || this.chat.state !== "open") return;
+      this.subscribe().catch((e) => this.failed(e));
+    }, delay);
+  }
   /**
    * Sends `subscribe` and recovers from the one error it has an answer
    * for.
@@ -810,7 +844,7 @@ var Room = class extends Emitter {
         if (data.seq > this.lastSeq) this.lastSeq = data.seq;
         this.timeline.add(data).catch((err) => {
           this.subscribed = false;
-          this.emit("error", err instanceof Error ? err : new Error(String(err)));
+          this.failed(err);
         });
         break;
       case "message.updated":
@@ -879,8 +913,11 @@ var ChatClient = class extends Emitter {
   heartbeat;
   retryTimer;
   attempt = 0;
-  /** Set by close(), and the only thing that stops the reconnect loop. */
-  closedByCaller = false;
+  /**
+   * The reconnect loop is off: set by close(), and by a failure that
+   * retrying cannot fix (see `stop`). Cleared by connect().
+   */
+  stopped = false;
   nextFrameId = 0;
   opening;
   rest;
@@ -958,7 +995,7 @@ var ChatClient = class extends Emitter {
    *   gap-filled via REST.
    */
   async resume() {
-    if (this.closedByCaller) return;
+    if (this.stopped) return;
     if (this.state !== "open" || this.socket === void 0) {
       this.clearTimers();
       return this.connect();
@@ -970,9 +1007,7 @@ var ChatClient = class extends Emitter {
       return this.connect();
     }
     for (const room of this.handles.values()) {
-      void room.resume().catch((err) => {
-        room.emit("error", err instanceof Error ? err : new Error(String(err)));
-      });
+      void room.resume().catch((err) => room.failed(err));
     }
   }
   /** The account-level routes: the rooms this user is in, and unread. */
@@ -1064,7 +1099,7 @@ var ChatClient = class extends Emitter {
   }
   /** Opens the connection and resolves when `hello` arrives. */
   async connect() {
-    this.closedByCaller = false;
+    this.stopped = false;
     if (this.opening !== void 0) return this.opening;
     if (this.state === "open" && this.socket !== void 0) return;
     this.clearTimers();
@@ -1077,11 +1112,12 @@ var ChatClient = class extends Emitter {
    * 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`.
    */
   async close() {
-    this.closedByCaller = true;
+    this.stopped = true;
     this.teardowns.forEach((t) => {
       try {
         t();
@@ -1098,7 +1134,53 @@ var ChatClient = class extends Emitter {
       } catch {
       }
     }
+    this.settleOpenWaiters(new ChatError("closed", "the connection is closed"));
+    this.setState("closed");
+  }
+  /**
+   * 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.
+   */
+  stop(err) {
+    this.stopped = true;
+    this.clearTimers();
+    const socket = this.socket;
+    this.socket = void 0;
+    if (socket !== void 0) {
+      try {
+        socket.close(1e3, "client stopped");
+      } catch {
+      }
+    }
+    this.failPending(err);
+    this.settleOpenWaiters(new ChatError("closed", "the connection is closed"));
     this.setState("closed");
+    this.emit("error", err);
+  }
+  /**
+   * Resolves once the connection is open. Used by `Room.subscribe`.
+   *
+   * 연결 전에 부른 `subscribe()`를 `closed`로 거절하면 소비자는 "언제 다시
+   * 부를지"를 스스로 알아내야 하고, 첫 connect가 실패했다면 그 때는 영영 오지
+   * 않는다. 붙을 때까지 기다리면 그 신호가 필요 없다. 멈춘 클라이언트(close,
+   * 인증 거절)는 붙을 일이 없으니 거절한다.
+   */
+  whenOpen() {
+    if (this.state === "open" && this.socket !== void 0) return Promise.resolve();
+    if (this.stopped) return Promise.reject(new ChatError("closed", "the connection is closed"));
+    return new Promise((resolve, reject) => void this.openWaiters.push({ resolve, reject }));
+  }
+  openWaiters = [];
+  settleOpenWaiters(err) {
+    const waiters = this.openWaiters;
+    this.openWaiters = [];
+    for (const w of waiters) {
+      if (err === void 0) w.resolve();
+      else w.reject(err);
+    }
   }
   /** Sends a frame and resolves with its ack, or rejects with its error. */
   send(type, data, timeoutMs = 15e3) {
@@ -1145,10 +1227,14 @@ var ChatClient = class extends Emitter {
     try {
       authData = await this.authData();
     } catch (err) {
+      if (isChatError(err)) {
+        this.stop(err);
+        throw err;
+      }
       this.scheduleReconnect();
       throw err;
     }
-    if (this.closedByCaller) {
+    if (this.stopped) {
       throw new ChatError("closed", "the client was closed while connecting");
     }
     const socket = new this.makeSocket(`${this.options.url}/v1/ws?v=1`);
@@ -1169,9 +1255,14 @@ var ChatClient = class extends Emitter {
           return;
         }
         if (frame.type === "error" && !settled) {
-          this.closedByCaller = true;
-          this.setState("closed");
-          finish(errorFrom(frame.data));
+          const err = errorFrom(frame.data);
+          if (err.code === "rate_limited" || err.code === "internal") {
+            if (err.retryAfterMs !== void 0 && err.retryAfterMs > 0) this.plannedDelayMs = err.retryAfterMs;
+            finish(err);
+            return;
+          }
+          finish(err);
+          this.stop(err);
           return;
         }
         this.onFrame(frame);
@@ -1204,12 +1295,11 @@ var ChatClient = class extends Emitter {
     const reconnected = this.everOpened;
     this.everOpened = true;
     this.setState("open");
-    if (reconnected) {
-      for (const room of this.handles.values()) {
-        void room.resume().catch((err) => {
-          room.emit("error", err instanceof Error ? err : new Error(String(err)));
-        });
-      }
+    this.settleOpenWaiters();
+    for (const room of this.handles.values()) {
+      void room.resume(reconnected).catch((err) => {
+        room.failed(err);
+      });
     }
   }
   onFrame(frame) {
@@ -1279,7 +1369,7 @@ var ChatClient = class extends Emitter {
     }, Math.max(1e3, intervalMs));
   }
   scheduleReconnect() {
-    if (this.closedByCaller) return;
+    if (this.stopped) return;
     this.setState("reconnecting");
     const delay = this.nextDelay();
     this.retryTimer = setTimeout(() => {
@@ -1331,6 +1421,9 @@ var ChatClient = class extends Emitter {
         const token = await this.options.token();
         this.lastToken = token;
         return token;
+      } catch (err) {
+        if (isChatError(err)) this.stop(err);
+        throw err;
       } finally {
         this.refreshing = void 0;
       }
@@ -1352,6 +1445,9 @@ var ChatClient = class extends Emitter {
     this.retryTimer = void 0;
   }
 };
+function isChatError(err) {
+  return err instanceof ChatError || err instanceof Error && err.name === "ChatError";
+}
 function createChatClient(options) {
   return new ChatClient(options);
 }

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.
  *
@@ -166,11 +188,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,6 +274,9 @@ 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;
@@ -387,7 +412,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 +509,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 +534,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 +555,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;
@@ -641,10 +690,30 @@ declare class ChatClient extends Emitter<ChatClientEvents> {
      * 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 +769,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.
  *

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.
  *
@@ -166,11 +188,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,6 +274,9 @@ 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;
@@ -387,7 +412,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 +509,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 +534,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 +555,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;
@@ -641,10 +690,30 @@ declare class ChatClient extends Emitter<ChatClientEvents> {
      * 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 +769,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.
  *