@laplace.live/ws 7.0.2 → 7.1.0

package/README.md

@@ -8,7 +8,7 @@ This project is based on [bilibili-live-ws](https://github.com/simon300000/bilib
 - Uses web-standard `EventTarget`/`Event` instead of Node.js `EventEmitter` polyfills
 - Uses native `WebSocket` API directly, removing `isomorphic-ws` and `ws` dependencies
 - No `Buffer` polyfills
-- Typed `on<T>()`/`off<T>()` convenience methods
+- Typed `addEventListener` via `LiveEventMap` with [`@laplace.live/internal`](https://github.com/laplace-live/internal) types
 - Conditional `exports` field with `./server`, `./client`, `./browser` sub-path exports
 
 ## Install
@@ -19,16 +19,58 @@ bun add @laplace.live/ws
 
 ## Usage
 
+Known Bilibili events are auto-typed via `LiveEventMap` — no manual generics
+or casting needed:
+
+```typescript
+import { LiveWS } from "@laplace.live/ws";
+
+const live = new LiveWS(25034104, { key: "...", address: "wss://..." });
+
+// Built-in events are typed automatically
+live.addEventListener("open", () => console.log("Connection established"));
+live.addEventListener("live", () => console.log("Room entered"));
+live.addEventListener("heartbeat", ({ data }) => console.log("Online:", data));
+
+// Known Bilibili commands are typed from @laplace.live/internal
+live.addEventListener("DANMU_MSG", ({ data }) => console.log(data.msg_id));
+live.addEventListener("SEND_GIFT", ({ data }) => console.log(data.giftName));
+live.addEventListener("SUPER_CHAT_MESSAGE", ({ data }) =>
+  console.log(data.message),
+);
+
+// Dynamic/unknown events use a generic fallback
+live.addEventListener<{ custom: string }>("NEW_CMD", ({ data }) =>
+  console.log(data.custom),
+);
+```
+
+### Browser
+
 ```typescript
-// Or specifically use @laplace.live/ws/server or @laplace.live/ws/client
-import { LiveWS, LiveTCP, KeepLiveWS, KeepLiveTCP } from "@laplace.live/ws";
+import { LiveWS, KeepLiveWS } from "@laplace.live/ws/browser";
 
-const live = new LiveWS(25034104);
+const live = new LiveWS(25034104, { key: "...", address: "wss://..." });
+live.addEventListener("DANMU_MSG", ({ data }) => console.log(data.msg_id));
+```
+
+### Auto-reconnecting
+
+```typescript
+import { KeepLiveWS } from "@laplace.live/ws";
+
+const keep = new KeepLiveWS(25034104, { key: "...", address: "wss://..." });
+keep.addEventListener("heartbeat", ({ data }) => console.log("Online:", data));
+keep.addEventListener("DANMU_MSG", ({ data }) => console.log(data.msg_id));
+```
+
+### TCP (Node.js / Bun only)
+
+```typescript
+import { LiveTCP } from "@laplace.live/ws";
 
-live.on<T>("open", () => console.log("Connection established"));
-live.on("live", () => {
-  live.on<T>("heartbeat", console.log);
-});
+const live = new LiveTCP(25034104, { key: "..." });
+live.addEventListener("heartbeat", ({ data }) => console.log("Online:", data));
 ```
 
 ## License

package/dist/browser.d.ts

@@ -1,5 +1,6 @@
-import { K as KeepLive, b as LiveWSBase, W as WSOptions } from './ws-D63GKJdI.js';
-export { c as LaplaceRawEvent, a as LiveOptions } from './ws-D63GKJdI.js';
+import { K as KeepLive, b as LiveWSBase, W as WSOptions } from './ws-Cd0ulctk.js';
+export { c as LaplaceRawEvent, d as LiveEventMap, a as LiveOptions } from './ws-Cd0ulctk.js';
+import '@laplace.live/internal';
 
 /**
  * WebSocket client for a Bilibili live room (browser).
@@ -39,7 +40,7 @@ declare class LiveWS extends LiveWSBase {
  * keep.on('DANMU_MSG', (e) => console.log(e.data))
  * ```
  */
-declare class KeepLiveWS extends KeepLive<typeof LiveWSBase> {
+declare class KeepLiveWS extends KeepLive<LiveWSBase> {
     constructor(roomid: number, opts?: WSOptions);
 }
 

package/dist/browser.js

@@ -1798,8 +1798,8 @@ var LaplaceRawEvent = class extends Event {
 
 // src/keep-live.ts
 var KeepLive = class extends EventTarget {
-  /** @internal Stored constructor arguments for reconnection. */
-  params;
+  /** @internal Factory that creates a fresh connection with the original arguments. */
+  createConnection;
   /** `true` after {@link close} has been called; prevents further reconnects. */
   closed;
   /** Delay in milliseconds before attempting a reconnect. */
@@ -1808,16 +1808,13 @@ var KeepLive = class extends EventTarget {
   timeout;
   /** The current underlying connection instance. */
   connection;
-  /** @internal The base class constructor used to create new connections. */
-  Base;
-  constructor(Base, ...params) {
+  constructor(createConnection) {
     super();
-    this.params = params;
+    this.createConnection = createConnection;
     this.closed = false;
     this.interval = 100;
     this.timeout = 45 * 1e3;
-    this.connection = new Base(...this.params);
-    this.Base = Base;
+    this.connection = this.createConnection();
     this.connect(false);
   }
   /**
@@ -1832,14 +1829,14 @@ var KeepLive = class extends EventTarget {
   /**
    * Wire up event forwarding and timeout handling on the current connection.
    * When `reconnect` is `true`, the previous connection is closed and a fresh
-   * one is created from the stored constructor parameters.
+   * one is created via the factory.
    *
    * @param reconnect - Whether to tear down and recreate the connection first.
    */
   connect(reconnect = true) {
     if (reconnect) {
       this.connection.close();
-      this.connection = new this.Base(...this.params);
+      this.connection = this.createConnection();
     }
     const connection = this.connection;
     let timeout = setTimeout(() => {
@@ -1905,28 +1902,6 @@ var KeepLive = class extends EventTarget {
   send(data) {
     return this.connection.send(data);
   }
-  /**
-   * Subscribe to an event type with a typed {@link LaplaceRawEvent} listener.
-   *
-   * @typeParam T - Expected data type carried by the event.
-   * @param type     - Event name (e.g. `"heartbeat"`, `"msg"`, `"DANMU_MSG"`).
-   * @param listener - Callback receiving a {@link LaplaceRawEvent LaplaceRawEvent\<T\>}.
-   * @param options  - Standard `addEventListener` options.
-   */
-  on(type, listener, options) {
-    this.addEventListener(type, listener, options);
-  }
-  /**
-   * Unsubscribe a previously registered listener.
-   *
-   * @typeParam T - Data type matching the original subscription.
-   * @param type     - Event name.
-   * @param listener - The same function reference passed to {@link on}.
-   * @param options  - Standard `removeEventListener` options.
-   */
-  off(type, listener, options) {
-    this.removeEventListener(type, listener, options);
-  }
 };
 
 // src/buffer.ts
@@ -2125,33 +2100,7 @@ var Live = class extends EventTarget {
    */
   getOnline() {
     this.heartbeat();
-    return new Promise(
-      (resolve) => this.addEventListener("heartbeat", (e) => resolve(e.data), { once: true })
-    );
-  }
-  /**
-   * Subscribe to an event type with a typed {@link LaplaceRawEvent} listener.
-   * Convenience wrapper around {@link EventTarget.addEventListener}.
-   *
-   * @typeParam T - Expected data type carried by the event.
-   * @param type     - Event name (e.g. `"heartbeat"`, `"msg"`, `"DANMU_MSG"`).
-   * @param listener - Callback receiving a {@link LaplaceRawEvent LaplaceRawEvent\<T\>}.
-   * @param options  - Standard `addEventListener` options.
-   */
-  on(type, listener, options) {
-    this.addEventListener(type, listener, options);
-  }
-  /**
-   * Unsubscribe a previously registered listener.
-   * Convenience wrapper around {@link EventTarget.removeEventListener}.
-   *
-   * @typeParam T - Data type matching the original subscription.
-   * @param type     - Event name.
-   * @param listener - The same function reference passed to {@link on}.
-   * @param options  - Standard `removeEventListener` options.
-   */
-  off(type, listener, options) {
-    this.removeEventListener(type, listener, options);
+    return new Promise((resolve) => this.addEventListener("heartbeat", (e) => resolve(e.data), { once: true }));
   }
 };
 
@@ -2170,10 +2119,7 @@ var LiveWSBase = class extends Live {
     super(inflates2, roomid, { send, close, ...options });
     ws.binaryType = "arraybuffer";
     ws.addEventListener("open", (e) => this.dispatchEvent(new Event(e.type)));
-    ws.addEventListener(
-      "message",
-      (e) => this.dispatchEvent(new LaplaceRawEvent("message", new Uint8Array(e.data)))
-    );
+    ws.addEventListener("message", (e) => this.dispatchEvent(new LaplaceRawEvent("message", new Uint8Array(e.data))));
     ws.addEventListener("close", (e) => this.dispatchEvent(new Event(e.type)));
     ws.addEventListener("error", () => this.dispatchEvent(new Event("_error")));
     this.ws = ws;
@@ -2188,7 +2134,7 @@ var LiveWS = class extends LiveWSBase {
 };
 var KeepLiveWS = class extends KeepLive {
   constructor(roomid, opts) {
-    super(LiveWSBase, inflates, roomid, opts);
+    super(() => new LiveWSBase(inflates, roomid, opts));
   }
 };
 export {

package/dist/index.d.ts

@@ -1,6 +1,7 @@
-import { L as Live, I as Inflates, a as LiveOptions, K as KeepLive, b as LiveWSBase, W as WSOptions } from './ws-D63GKJdI.js';
-export { c as LaplaceRawEvent } from './ws-D63GKJdI.js';
+import { L as Live, I as Inflates, a as LiveOptions, K as KeepLive, b as LiveWSBase, W as WSOptions } from './ws-Cd0ulctk.js';
+export { c as LaplaceRawEvent, d as LiveEventMap } from './ws-Cd0ulctk.js';
 import { Socket } from 'node:net';
+import { BilibiliInternal } from '@laplace.live/internal';
 
 /**
  * Configuration options for TCP-based live connections.
@@ -42,25 +43,6 @@ declare class LiveTCPBase extends Live {
     splitBuffer(): void;
 }
 
-type GET_DANMU_INFO = {
-    code: number;
-    message: string;
-    ttl: number;
-    data: {
-        business_id: number;
-        group: string;
-        host_list: {
-            host: string;
-            port: number;
-            wss_port: number;
-            ws_port: number;
-        }[];
-        max_delay: number;
-        refresh_rate: number;
-        refresh_row_factor: number;
-        token: string;
-    };
-};
 /**
  * Fetch WebSocket connection configuration for a Bilibili live room directly
  * from the Bilibili API (`getDanmuInfo`).
@@ -82,7 +64,7 @@ declare const getConf: (roomid: number) => Promise<{
     key: string;
     host: string;
     address: string;
-    raw: GET_DANMU_INFO;
+    json: BilibiliInternal.HTTPS.Prod.GetDanmuInfo;
 }>;
 /**
  * Resolve a short (vanity) room ID to its real numeric room ID via the
@@ -154,7 +136,7 @@ declare class LiveTCP extends LiveTCPBase {
  * keep.on('DANMU_MSG', (e) => console.log(e.data))
  * ```
  */
-declare class KeepLiveWS extends KeepLive<typeof LiveWSBase> {
+declare class KeepLiveWS extends KeepLive<LiveWSBase> {
     constructor(roomid: number, opts?: WSOptions);
 }
 /**
@@ -176,7 +158,7 @@ declare class KeepLiveWS extends KeepLive<typeof LiveWSBase> {
  * keep.on('heartbeat', (e) => console.log('online:', e.data))
  * ```
  */
-declare class KeepLiveTCP extends KeepLive<typeof LiveTCPBase> {
+declare class KeepLiveTCP extends KeepLive<LiveTCPBase> {
     constructor(roomid: number, opts?: TCPOptions);
 }
 

package/dist/index.js

@@ -18,8 +18,8 @@ var LaplaceRawEvent = class extends Event {
 
 // src/keep-live.ts
 var KeepLive = class extends EventTarget {
-  /** @internal Stored constructor arguments for reconnection. */
-  params;
+  /** @internal Factory that creates a fresh connection with the original arguments. */
+  createConnection;
   /** `true` after {@link close} has been called; prevents further reconnects. */
   closed;
   /** Delay in milliseconds before attempting a reconnect. */
@@ -28,16 +28,13 @@ var KeepLive = class extends EventTarget {
   timeout;
   /** The current underlying connection instance. */
   connection;
-  /** @internal The base class constructor used to create new connections. */
-  Base;
-  constructor(Base, ...params) {
+  constructor(createConnection) {
     super();
-    this.params = params;
+    this.createConnection = createConnection;
     this.closed = false;
     this.interval = 100;
     this.timeout = 45 * 1e3;
-    this.connection = new Base(...this.params);
-    this.Base = Base;
+    this.connection = this.createConnection();
     this.connect(false);
   }
   /**
@@ -52,14 +49,14 @@ var KeepLive = class extends EventTarget {
   /**
    * Wire up event forwarding and timeout handling on the current connection.
    * When `reconnect` is `true`, the previous connection is closed and a fresh
-   * one is created from the stored constructor parameters.
+   * one is created via the factory.
    *
    * @param reconnect - Whether to tear down and recreate the connection first.
    */
   connect(reconnect = true) {
     if (reconnect) {
       this.connection.close();
-      this.connection = new this.Base(...this.params);
+      this.connection = this.createConnection();
     }
     const connection = this.connection;
     let timeout = setTimeout(() => {
@@ -125,28 +122,6 @@ var KeepLive = class extends EventTarget {
   send(data) {
     return this.connection.send(data);
   }
-  /**
-   * Subscribe to an event type with a typed {@link LaplaceRawEvent} listener.
-   *
-   * @typeParam T - Expected data type carried by the event.
-   * @param type     - Event name (e.g. `"heartbeat"`, `"msg"`, `"DANMU_MSG"`).
-   * @param listener - Callback receiving a {@link LaplaceRawEvent LaplaceRawEvent\<T\>}.
-   * @param options  - Standard `addEventListener` options.
-   */
-  on(type, listener, options) {
-    this.addEventListener(type, listener, options);
-  }
-  /**
-   * Unsubscribe a previously registered listener.
-   *
-   * @typeParam T - Data type matching the original subscription.
-   * @param type     - Event name.
-   * @param listener - The same function reference passed to {@link on}.
-   * @param options  - Standard `removeEventListener` options.
-   */
-  off(type, listener, options) {
-    this.removeEventListener(type, listener, options);
-  }
 };
 
 // src/tcp.ts
@@ -348,33 +323,7 @@ var Live = class extends EventTarget {
    */
   getOnline() {
     this.heartbeat();
-    return new Promise(
-      (resolve) => this.addEventListener("heartbeat", (e) => resolve(e.data), { once: true })
-    );
-  }
-  /**
-   * Subscribe to an event type with a typed {@link LaplaceRawEvent} listener.
-   * Convenience wrapper around {@link EventTarget.addEventListener}.
-   *
-   * @typeParam T - Expected data type carried by the event.
-   * @param type     - Event name (e.g. `"heartbeat"`, `"msg"`, `"DANMU_MSG"`).
-   * @param listener - Callback receiving a {@link LaplaceRawEvent LaplaceRawEvent\<T\>}.
-   * @param options  - Standard `addEventListener` options.
-   */
-  on(type, listener, options) {
-    this.addEventListener(type, listener, options);
-  }
-  /**
-   * Unsubscribe a previously registered listener.
-   * Convenience wrapper around {@link EventTarget.removeEventListener}.
-   *
-   * @typeParam T - Data type matching the original subscription.
-   * @param type     - Event name.
-   * @param listener - The same function reference passed to {@link on}.
-   * @param options  - Standard `removeEventListener` options.
-   */
-  off(type, listener, options) {
-    this.removeEventListener(type, listener, options);
+    return new Promise((resolve) => this.addEventListener("heartbeat", (e) => resolve(e.data), { once: true }));
   }
 };
 
@@ -440,10 +389,7 @@ var LiveWSBase = class extends Live {
     super(inflates2, roomid, { send, close, ...options });
     ws.binaryType = "arraybuffer";
     ws.addEventListener("open", (e) => this.dispatchEvent(new Event(e.type)));
-    ws.addEventListener(
-      "message",
-      (e) => this.dispatchEvent(new LaplaceRawEvent("message", new Uint8Array(e.data)))
-    );
+    ws.addEventListener("message", (e) => this.dispatchEvent(new LaplaceRawEvent("message", new Uint8Array(e.data))));
     ws.addEventListener("close", (e) => this.dispatchEvent(new Event(e.type)));
     ws.addEventListener("error", () => this.dispatchEvent(new Event("_error")));
     this.ws = ws;
@@ -452,20 +398,19 @@ var LiveWSBase = class extends Live {
 
 // src/extra.ts
 var getConf = async (roomid) => {
-  const raw = await fetch(`https://api.live.bilibili.com/xlive/web-room/v1/index/getDanmuInfo?id=${roomid}`).then(
-    (w) => w.json()
-  );
-  if (!raw.data) {
-    throw new Error(`getConf failed for room ${roomid}: ${raw.message || "no data"} (code: ${raw.code})`);
+  const resp = await fetch(`https://api.live.bilibili.com/xlive/web-room/v1/index/getDanmuInfo?id=${roomid}`);
+  const json = await resp.json();
+  if (!json.data) {
+    throw new Error(`getConf failed for room ${roomid}: ${json.message || "no data"} (code: ${json.code})`);
   }
   const {
     data: {
       token: key,
       host_list: [{ host }]
     }
-  } = raw;
+  } = json;
   const address = `wss://${host}/sub`;
-  return { key, host, address, raw };
+  return { key, host, address, json };
 };
 var getRoomid = async (short) => {
   const {
@@ -487,12 +432,12 @@ var LiveTCP = class extends LiveTCPBase {
 };
 var KeepLiveWS = class extends KeepLive {
   constructor(roomid, opts) {
-    super(LiveWSBase, inflates, roomid, opts);
+    super(() => new LiveWSBase(inflates, roomid, opts));
   }
 };
 var KeepLiveTCP = class extends KeepLive {
   constructor(roomid, opts) {
-    super(LiveTCPBase, inflates, roomid, opts);
+    super(() => new LiveTCPBase(inflates, roomid, opts));
   }
 };
 export {

package/dist/ws-Cd0ulctk.d.ts

@@ -0,0 +1,318 @@
+import { BilibiliInternal } from '@laplace.live/internal';
+
+/**
+ * Platform-specific inflate/decompress implementations injected into the
+ * decoder at construction time.
+ *
+ * - **Node / Bun**: backed by `node:zlib` (`inflate` + `brotliDecompress`).
+ * - **Browser**: backed by `pako` (inflate) + a bundled JS Brotli decoder.
+ */
+type Inflates = {
+    inflateAsync: (b: Uint8Array) => Uint8Array | Promise<Uint8Array>;
+    brotliDecompressAsync: (b: Uint8Array) => Uint8Array | Promise<Uint8Array>;
+};
+
+/**
+ * A typed {@link Event} that carries an arbitrary data payload.
+ *
+ * Used throughout the library to deliver structured messages such as
+ * heartbeat counts, danmaku payloads, and other server-pushed data.
+ *
+ * Also used internally with `LaplaceRawEvent<Event>` as a catch-all meta-event
+ * (type `"event"`) to forward all events through {@link KeepLive}.
+ *
+ * @typeParam T - The type of the data payload attached to this event.
+ *
+ * @example
+ * ```ts
+ * live.addEventListener('heartbeat', (e) => {
+ *   console.log('online:', e.data)
+ * })
+ * ```
+ */
+declare class LaplaceRawEvent<T> extends Event {
+    data: T;
+    constructor(type: string, data: T);
+}
+/**
+ * Maps known event names to their event types for typed `addEventListener`.
+ *
+ * - Built-in lifecycle events (`open`, `live`, `close`, etc.) map to plain `Event`.
+ * - `heartbeat` maps to `LaplaceRawEvent<number>` (online viewer count).
+ * - `msg` maps to `LaplaceRawEvent<unknown>` (any server command).
+ * - Bilibili commands map to `LaplaceRawEvent<BilibiliInternal.WebSocket.Prod.*>`.
+ * - Unknown/dynamic events fall through to a generic overload on `addEventListener`.
+ */
+interface LiveEventMap {
+    open: Event;
+    live: Event;
+    close: Event;
+    error: Event;
+    heartbeat: LaplaceRawEvent<number>;
+    msg: LaplaceRawEvent<unknown>;
+    event: LaplaceRawEvent<Event>;
+    DANMU_MSG: LaplaceRawEvent<BilibiliInternal.WebSocket.Prod.DANMU_MSG>;
+    RECALL_DANMU_MSG: LaplaceRawEvent<BilibiliInternal.WebSocket.Prod.RECALL_DANMU_MSG>;
+    INTERACT_WORD: LaplaceRawEvent<BilibiliInternal.WebSocket.Prod.INTERACT_WORD>;
+    ENTRY_EFFECT: LaplaceRawEvent<BilibiliInternal.WebSocket.Prod.ENTRY_EFFECT>;
+    USER_TOAST_MSG: LaplaceRawEvent<BilibiliInternal.WebSocket.Prod.USER_TOAST_MSG>;
+    USER_TOAST_MSG_V2: LaplaceRawEvent<BilibiliInternal.WebSocket.Prod.USER_TOAST_MSG_V2>;
+    SEND_GIFT: LaplaceRawEvent<BilibiliInternal.WebSocket.Prod.SEND_GIFT>;
+    SEND_GIFT_V2: LaplaceRawEvent<BilibiliInternal.WebSocket.Prod.SEND_GIFT_V2>;
+    INTERACT_WORD_V2: LaplaceRawEvent<BilibiliInternal.WebSocket.Prod.INTERACT_WORD_V2>;
+    SUPER_CHAT_MESSAGE: LaplaceRawEvent<BilibiliInternal.WebSocket.Prod.SUPER_CHAT_MESSAGE>;
+    SUPER_CHAT_MESSAGE_DELETE: LaplaceRawEvent<BilibiliInternal.WebSocket.Prod.SUPER_CHAT_MESSAGE_DELETE>;
+    USER_VIRTUAL_MVP: LaplaceRawEvent<BilibiliInternal.WebSocket.Prod.USER_VIRTUAL_MVP>;
+    LIKE_INFO_V3_CLICK: LaplaceRawEvent<BilibiliInternal.WebSocket.Prod.LIKE_INFO_V3_CLICK>;
+    POPULARITY_RED_POCKET_START: LaplaceRawEvent<BilibiliInternal.WebSocket.Prod.POPULARITY_RED_POCKET_START>;
+    POPULARITY_RED_POCKET_V2_START: LaplaceRawEvent<BilibiliInternal.WebSocket.Prod.POPULARITY_RED_POCKET_V2_START>;
+    POPULARITY_RED_POCKET_WINNER_LIST: LaplaceRawEvent<BilibiliInternal.WebSocket.Prod.POPULARITY_RED_POCKET_WINNER_LIST>;
+    POPULARITY_RED_POCKET_V2_WINNER_LIST: LaplaceRawEvent<BilibiliInternal.WebSocket.Prod.POPULARITY_RED_POCKET_V2_WINNER_LIST>;
+    ANCHOR_LOT_START: LaplaceRawEvent<BilibiliInternal.WebSocket.Prod.ANCHOR_LOT_START>;
+    ANCHOR_LOT_AWARD: LaplaceRawEvent<BilibiliInternal.WebSocket.Prod.ANCHOR_LOT_AWARD>;
+    COMMON_NOTICE_DANMAKU: LaplaceRawEvent<BilibiliInternal.WebSocket.Prod.COMMON_NOTICE_DANMAKU>;
+    EFFECT_DANMAKU_MSG: LaplaceRawEvent<BilibiliInternal.WebSocket.Prod.EFFECT_DANMAKU_MSG>;
+    DANMU_ACTIVITY_CONFIG: LaplaceRawEvent<BilibiliInternal.WebSocket.Prod.DANMU_ACTIVITY_CONFIG>;
+    ROOM_CHANGE: LaplaceRawEvent<BilibiliInternal.WebSocket.Prod.ROOM_CHANGE>;
+    ROOM_SILENT_ON: LaplaceRawEvent<BilibiliInternal.WebSocket.Prod.ROOM_SILENT_ON>;
+    ROOM_SILENT_OFF: LaplaceRawEvent<BilibiliInternal.WebSocket.Prod.ROOM_SILENT_OFF>;
+    WATCHED_CHANGE: LaplaceRawEvent<BilibiliInternal.WebSocket.Prod.WATCHED_CHANGE>;
+    LIKE_INFO_V3_UPDATE: LaplaceRawEvent<BilibiliInternal.WebSocket.Prod.LIKE_INFO_V3_UPDATE>;
+    ONLINE_RANK_COUNT: LaplaceRawEvent<BilibiliInternal.WebSocket.Prod.ONLINE_RANK_COUNT>;
+    ONLINE_RANK_V2: LaplaceRawEvent<BilibiliInternal.WebSocket.Prod.ONLINE_RANK_V2>;
+    ONLINE_RANK_V3: LaplaceRawEvent<BilibiliInternal.WebSocket.Prod.ONLINE_RANK_V3>;
+    ROOM_REAL_TIME_MESSAGE_UPDATE: LaplaceRawEvent<BilibiliInternal.WebSocket.Prod.ROOM_REAL_TIME_MESSAGE_UPDATE>;
+    ROOM_REAL_TIME_MESSAGE_UPDATE_V2: LaplaceRawEvent<BilibiliInternal.WebSocket.Prod.ROOM_REAL_TIME_MESSAGE_UPDATE_V2>;
+    LIVE: LaplaceRawEvent<BilibiliInternal.WebSocket.Prod.LIVE>;
+    PREPARING: LaplaceRawEvent<BilibiliInternal.WebSocket.Prod.PREPARING>;
+    WARNING: LaplaceRawEvent<BilibiliInternal.WebSocket.Prod.WARNING>;
+    CUT_OFF: LaplaceRawEvent<BilibiliInternal.WebSocket.Prod.CUT_OFF>;
+    ROOM_BLOCK_MSG: LaplaceRawEvent<BilibiliInternal.WebSocket.Prod.ROOM_BLOCK_MSG>;
+    ROOM_ADMINS: LaplaceRawEvent<BilibiliInternal.WebSocket.Prod.ROOM_ADMINS>;
+    room_admin_entrance: LaplaceRawEvent<BilibiliInternal.WebSocket.Prod.room_admin_entrance>;
+    ROOM_ADMIN_REVOKE: LaplaceRawEvent<BilibiliInternal.WebSocket.Prod.ROOM_ADMIN_REVOKE>;
+    LIVE_OPEN_PLATFORM_DM: LaplaceRawEvent<BilibiliInternal.WebSocket.OpenPlatform.LIVE_OPEN_PLATFORM_DM>;
+    LIVE_OPEN_PLATFORM_SEND_GIFT: LaplaceRawEvent<BilibiliInternal.WebSocket.OpenPlatform.LIVE_OPEN_PLATFORM_SEND_GIFT>;
+    LIVE_OPEN_PLATFORM_SUPER_CHAT: LaplaceRawEvent<BilibiliInternal.WebSocket.OpenPlatform.LIVE_OPEN_PLATFORM_SUPER_CHAT>;
+    LIVE_OPEN_PLATFORM_GUARD: LaplaceRawEvent<BilibiliInternal.WebSocket.OpenPlatform.LIVE_OPEN_PLATFORM_GUARD>;
+    LIVE_OPEN_PLATFORM_LIKE: LaplaceRawEvent<BilibiliInternal.WebSocket.OpenPlatform.LIVE_OPEN_PLATFORM_LIKE>;
+    LIVE_OPEN_PLATFORM_LIVE_ROOM_ENTER: LaplaceRawEvent<BilibiliInternal.WebSocket.OpenPlatform.LIVE_OPEN_PLATFORM_LIVE_ROOM_ENTER>;
+    LIVE_OPEN_PLATFORM_LIVE_START: LaplaceRawEvent<BilibiliInternal.WebSocket.OpenPlatform.LIVE_OPEN_PLATFORM_LIVE_START>;
+    LIVE_OPEN_PLATFORM_LIVE_END: LaplaceRawEvent<BilibiliInternal.WebSocket.OpenPlatform.LIVE_OPEN_PLATFORM_LIVE_END>;
+    LIVE_OPEN_PLATFORM_INTERACTION_END: LaplaceRawEvent<BilibiliInternal.WebSocket.OpenPlatform.LIVE_OPEN_PLATFORM_INTERACTION_END>;
+}
+
+/**
+ * Options for configuring the Bilibili live connection authentication.
+ *
+ * When {@link authBody} is provided it takes precedence over all other
+ * fields and is sent as the join payload verbatim.
+ */
+type LiveOptions = {
+    /** Protocol version. Defaults to `3` (brotli-compressed). */
+    protover?: 1 | 2 | 3;
+    /** Authentication token obtained from the danmaku info API. */
+    key?: string;
+    /**
+     * Pre-built authentication body. When supplied as a `Uint8Array` it is
+     * sent raw; when supplied as an object it is JSON-encoded before sending.
+     * Takes precedence over {@link key}, {@link uid}, and {@link buvid}.
+     */
+    authBody?: Uint8Array | Record<string, unknown>;
+    /** User ID. Defaults to `0` (anonymous). */
+    uid?: number;
+    /** Browser unique visitor ID used for risk-control tracking. */
+    buvid?: string;
+};
+/**
+ * Base class for a single Bilibili live room connection.
+ *
+ * Extends {@link EventTarget} and emits the following events:
+ *
+ * | Event         | Payload            | Description                                      |
+ * |---------------|--------------------|--------------------------------------------------|
+ * | `open`        | —                  | Underlying transport connected.                  |
+ * | `live`        | —                  | Server acknowledged the join (room entered).     |
+ * | `heartbeat`   | `LaplaceRawEvent<number>`| Online viewer count received from server.        |
+ * | `msg`         | `LaplaceRawEvent<any>`   | Any server command message.                      |
+ * | `DANMU_MSG`   | `LaplaceRawEvent<any>`   | Danmaku (chat) message.                          |
+ * | `close`       | —                  | Connection closed.                               |
+ * | `error`       | —                  | Unrecoverable error (connection is closed).      |
+ * | `event`       | `LaplaceRawEvent<Event>` | Meta-event wrapping every dispatched event.      |
+ *
+ * Subclasses ({@link LiveWSBase}, {@link LiveTCPBase}) provide the concrete
+ * transport and supply `send` / `close` callbacks to this constructor.
+ *
+ * @param inflates - Platform-specific inflate + brotli decompressors.
+ * @param roomid   - Numeric Bilibili live room ID.
+ * @param options  - Transport callbacks and authentication options.
+ *
+ * @throws {Error} If `roomid` is not a finite number.
+ */
+declare class Live extends EventTarget {
+    /** The live room ID this instance is connected to. */
+    roomid: number;
+    /** Latest known online viewer count, updated on each heartbeat. */
+    online: number;
+    /** `true` after the server acknowledges the join (`welcome` packet). */
+    live: boolean;
+    /** `true` after {@link close} has been called. */
+    closed: boolean;
+    /** @internal Handle for the heartbeat interval timer. */
+    timeout: ReturnType<typeof setTimeout>;
+    /** Send raw binary data over the underlying transport. */
+    send: (data: Uint8Array) => void;
+    /** Gracefully close the connection and set {@link closed} to `true`. */
+    close: () => void;
+    constructor(inflates: Inflates, roomid: number, { send, close, protover, key, authBody, uid, buvid, }: {
+        send: (data: Uint8Array) => void;
+        close: () => void;
+    } & LiveOptions);
+    /**
+     * Overridden to also dispatch a `LaplaceRawEvent<Event>` with type `"event"`
+     * for every event, enabling catch-all listeners.
+     */
+    dispatchEvent(event: Event): boolean;
+    /** Send a heartbeat packet to the server. */
+    heartbeat(): void;
+    /**
+     * Send a heartbeat and resolve with the online viewer count from the
+     * next heartbeat response.
+     * @returns A promise that resolves with the current online count.
+     */
+    getOnline(): Promise<number>;
+    /**
+     * Typed `addEventListener` that narrows the inherited {@link EventTarget}
+     * signature using {@link LiveEventMap}.
+     *
+     * - Known events (e.g. `"heartbeat"`, `"DANMU_MSG"`) are auto-typed.
+     * - Unknown/dynamic events accept a generic `<T>` for the payload type.
+     *
+     * Uses `declare` to shadow the inherited type without emitting code —
+     * at runtime this is still `EventTarget.prototype.addEventListener`.
+     *
+     * @example
+     * ```ts
+     * live.addEventListener('heartbeat', (e) => console.log(e.data))
+     * live.addEventListener('DANMU_MSG', ({ data }) => console.log(data.msg_id))
+     * live.addEventListener<CustomType>('NEW_CMD', ({ data }) => console.log(data))
+     * ```
+     */
+    addEventListener: {
+        <K extends keyof LiveEventMap>(type: K, listener: (ev: LiveEventMap[K]) => void, options?: boolean | AddEventListenerOptions): void;
+        <T = unknown>(type: string, listener: (ev: LaplaceRawEvent<T>) => void, options?: boolean | AddEventListenerOptions): void;
+    };
+    /**
+     * Typed `removeEventListener` matching {@link addEventListener}.
+     *
+     * Uses `declare` to shadow the inherited type without emitting code.
+     */
+    removeEventListener: {
+        <K extends keyof LiveEventMap>(type: K, listener: (ev: LiveEventMap[K]) => void, options?: boolean | EventListenerOptions): void;
+        (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+    };
+}
+
+/**
+ * Auto-reconnecting wrapper around a {@link Live} subclass.
+ *
+ * `KeepLive` maintains a persistent connection to a Bilibili live room by
+ * automatically re-creating the underlying {@link Live} instance whenever
+ * the connection drops or a heartbeat timeout is reached. All events from
+ * the inner connection are forwarded to this instance.
+ *
+ * @typeParam T - The concrete {@link Live} instance type being managed.
+ *
+ * @example
+ * ```ts
+ * const keep = new KeepLiveWS(12345, { key: '...' })
+ * keep.addEventListener('heartbeat', (e) => console.log('online:', e.data))
+ * keep.addEventListener('DANMU_MSG', ({ data }) => console.log('danmaku:', data.msg_id))
+ * ```
+ */
+declare class KeepLive<T extends Live> extends EventTarget {
+    /** @internal Factory that creates a fresh connection with the original arguments. */
+    private createConnection;
+    /** `true` after {@link close} has been called; prevents further reconnects. */
+    closed: boolean;
+    /** Delay in milliseconds before attempting a reconnect. */
+    interval: number;
+    /** Maximum milliseconds to wait for a heartbeat before forcing a reconnect. */
+    timeout: number;
+    /** The current underlying connection instance. */
+    connection: T;
+    constructor(createConnection: () => T);
+    /**
+     * Overridden to also dispatch a `LaplaceRawEvent<Event>` with type `"event"`
+     * for every event, enabling catch-all listeners.
+     */
+    dispatchEvent(event: Event): boolean;
+    /**
+     * Wire up event forwarding and timeout handling on the current connection.
+     * When `reconnect` is `true`, the previous connection is closed and a fresh
+     * one is created via the factory.
+     *
+     * @param reconnect - Whether to tear down and recreate the connection first.
+     */
+    connect(reconnect?: boolean): void;
+    /** Latest known online viewer count from the underlying connection. */
+    get online(): number;
+    /** The live room ID. */
+    get roomid(): number;
+    /** Permanently close the connection and stop reconnecting. */
+    close(): void;
+    /** Send a heartbeat packet to the server. */
+    heartbeat(): void;
+    /**
+     * Send a heartbeat and resolve with the online viewer count from the
+     * next heartbeat response.
+     * @returns A promise that resolves with the current online count.
+     */
+    getOnline(): Promise<number>;
+    /**
+     * Send raw binary data through the underlying connection.
+     * @param data - The binary packet to send.
+     */
+    send(data: Uint8Array): void;
+    /** {@inheritDoc Live.addEventListener} */
+    addEventListener: {
+        <K extends keyof LiveEventMap>(type: K, listener: (ev: LiveEventMap[K]) => void, options?: boolean | AddEventListenerOptions): void;
+        <T = unknown>(type: string, listener: (ev: LaplaceRawEvent<T>) => void, options?: boolean | AddEventListenerOptions): void;
+    };
+    /** {@inheritDoc Live.removeEventListener} */
+    removeEventListener: {
+        <K extends keyof LiveEventMap>(type: K, listener: (ev: LiveEventMap[K]) => void, options?: boolean | EventListenerOptions): void;
+        (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+    };
+}
+
+/**
+ * Configuration options for WebSocket-based live connections.
+ * Extends {@link LiveOptions} with an optional WebSocket server address.
+ */
+type WSOptions = LiveOptions & {
+    /** WebSocket server URL. Defaults to `wss://broadcastlv.chat.bilibili.com/sub`. */
+    address?: string;
+};
+/**
+ * WebSocket transport for Bilibili live room connections.
+ *
+ * Wraps a native {@link WebSocket}, wiring its lifecycle events (`open`,
+ * `message`, `close`, `error`) into the {@link Live} event system. Binary
+ * frames are forwarded as `LaplaceRawEvent<Uint8Array>` for protocol decoding.
+ *
+ * Not typically instantiated directly — use {@link LiveWS} (server) or the
+ * browser-specific `LiveWS` which inject the appropriate inflate
+ * implementation.
+ *
+ * @param inflates - Platform-specific inflate/brotli decompressors.
+ * @param roomid   - Numeric Bilibili live room ID.
+ * @param options  - WebSocket address and authentication options.
+ */
+declare class LiveWSBase extends Live {
+    /** The underlying native WebSocket instance. */
+    ws: WebSocket;
+    constructor(inflates: Inflates, roomid: number, { address, ...options }?: WSOptions);
+}
+
+export { type Inflates as I, KeepLive as K, Live as L, type WSOptions as W, type LiveOptions as a, LiveWSBase as b, LaplaceRawEvent as c, type LiveEventMap as d };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@laplace.live/ws",
-  "version": "7.0.2",
+  "version": "7.1.0",
   "description": "Bilibili Live WebSocket/TCP API",
   "type": "module",
   "main": "./dist/index.js",
@@ -60,6 +60,7 @@
     "provenance": true
   },
   "dependencies": {
+    "@laplace.live/internal": "^1.3.4",
     "pako": "^2.1.0"
   },
   "devDependencies": {

package/dist/ws-D63GKJdI.d.ts

@@ -1,250 +0,0 @@
-/**
- * Platform-specific inflate/decompress implementations injected into the
- * decoder at construction time.
- *
- * - **Node / Bun**: backed by `node:zlib` (`inflate` + `brotliDecompress`).
- * - **Browser**: backed by `pako` (inflate) + a bundled JS Brotli decoder.
- */
-type Inflates = {
-    inflateAsync: (b: Uint8Array) => Uint8Array | Promise<Uint8Array>;
-    brotliDecompressAsync: (b: Uint8Array) => Uint8Array | Promise<Uint8Array>;
-};
-
-/**
- * A typed {@link Event} that carries an arbitrary data payload.
- *
- * Used throughout the library to deliver structured messages such as
- * heartbeat counts, danmaku payloads, and other server-pushed data.
- *
- * Also used internally with `LaplaceRawEvent<Event>` as a catch-all meta-event
- * (type `"event"`) to forward all events through {@link KeepLive}.
- *
- * @typeParam T - The type of the data payload attached to this event.
- *
- * @example
- * ```ts
- * live.on<number>('heartbeat', (e) => {
- *   console.log('online:', e.data)
- * })
- * ```
- */
-declare class LaplaceRawEvent<T> extends Event {
-    data: T;
-    constructor(type: string, data: T);
-}
-
-/**
- * Options for configuring the Bilibili live connection authentication.
- *
- * When {@link authBody} is provided it takes precedence over all other
- * fields and is sent as the join payload verbatim.
- */
-type LiveOptions = {
-    /** Protocol version. Defaults to `3` (brotli-compressed). */
-    protover?: 1 | 2 | 3;
-    /** Authentication token obtained from the danmaku info API. */
-    key?: string;
-    /**
-     * Pre-built authentication body. When supplied as a `Uint8Array` it is
-     * sent raw; when supplied as an object it is JSON-encoded before sending.
-     * Takes precedence over {@link key}, {@link uid}, and {@link buvid}.
-     */
-    authBody?: Uint8Array | Record<string, unknown>;
-    /** User ID. Defaults to `0` (anonymous). */
-    uid?: number;
-    /** Browser unique visitor ID used for risk-control tracking. */
-    buvid?: string;
-};
-/**
- * Base class for a single Bilibili live room connection.
- *
- * Extends {@link EventTarget} and emits the following events:
- *
- * | Event         | Payload            | Description                                      |
- * |---------------|--------------------|--------------------------------------------------|
- * | `open`        | —                  | Underlying transport connected.                  |
- * | `live`        | —                  | Server acknowledged the join (room entered).     |
- * | `heartbeat`   | `LaplaceRawEvent<number>`| Online viewer count received from server.        |
- * | `msg`         | `LaplaceRawEvent<any>`   | Any server command message.                      |
- * | `DANMU_MSG`   | `LaplaceRawEvent<any>`   | Danmaku (chat) message.                          |
- * | `close`       | —                  | Connection closed.                               |
- * | `error`       | —                  | Unrecoverable error (connection is closed).      |
- * | `event`       | `LaplaceRawEvent<Event>` | Meta-event wrapping every dispatched event.      |
- *
- * Subclasses ({@link LiveWSBase}, {@link LiveTCPBase}) provide the concrete
- * transport and supply `send` / `close` callbacks to this constructor.
- *
- * @param inflates - Platform-specific inflate + brotli decompressors.
- * @param roomid   - Numeric Bilibili live room ID.
- * @param options  - Transport callbacks and authentication options.
- *
- * @throws {Error} If `roomid` is not a finite number.
- */
-declare class Live extends EventTarget {
-    /** The live room ID this instance is connected to. */
-    roomid: number;
-    /** Latest known online viewer count, updated on each heartbeat. */
-    online: number;
-    /** `true` after the server acknowledges the join (`welcome` packet). */
-    live: boolean;
-    /** `true` after {@link close} has been called. */
-    closed: boolean;
-    /** @internal Handle for the heartbeat interval timer. */
-    timeout: ReturnType<typeof setTimeout>;
-    /** Send raw binary data over the underlying transport. */
-    send: (data: Uint8Array) => void;
-    /** Gracefully close the connection and set {@link closed} to `true`. */
-    close: () => void;
-    constructor(inflates: Inflates, roomid: number, { send, close, protover, key, authBody, uid, buvid, }: {
-        send: (data: Uint8Array) => void;
-        close: () => void;
-    } & LiveOptions);
-    /**
-     * Overridden to also dispatch a `LaplaceRawEvent<Event>` with type `"event"`
-     * for every event, enabling catch-all listeners.
-     */
-    dispatchEvent(event: Event): boolean;
-    /** Send a heartbeat packet to the server. */
-    heartbeat(): void;
-    /**
-     * Send a heartbeat and resolve with the online viewer count from the
-     * next heartbeat response.
-     * @returns A promise that resolves with the current online count.
-     */
-    getOnline(): Promise<number>;
-    /**
-     * Subscribe to an event type with a typed {@link LaplaceRawEvent} listener.
-     * Convenience wrapper around {@link EventTarget.addEventListener}.
-     *
-     * @typeParam T - Expected data type carried by the event.
-     * @param type     - Event name (e.g. `"heartbeat"`, `"msg"`, `"DANMU_MSG"`).
-     * @param listener - Callback receiving a {@link LaplaceRawEvent LaplaceRawEvent\<T\>}.
-     * @param options  - Standard `addEventListener` options.
-     */
-    on<T = unknown>(type: string, listener: (event: LaplaceRawEvent<T>) => void, options?: boolean | AddEventListenerOptions): void;
-    /**
-     * Unsubscribe a previously registered listener.
-     * Convenience wrapper around {@link EventTarget.removeEventListener}.
-     *
-     * @typeParam T - Data type matching the original subscription.
-     * @param type     - Event name.
-     * @param listener - The same function reference passed to {@link on}.
-     * @param options  - Standard `removeEventListener` options.
-     */
-    off<T = unknown>(type: string, listener: (event: LaplaceRawEvent<T>) => void, options?: boolean | EventListenerOptions): void;
-}
-
-/**
- * Auto-reconnecting wrapper around a {@link Live} subclass.
- *
- * `KeepLive` maintains a persistent connection to a Bilibili live room by
- * automatically re-creating the underlying {@link Live} instance whenever
- * the connection drops or a heartbeat timeout is reached. All events from
- * the inner connection are forwarded to this instance.
- *
- * @typeParam Base - The concrete {@link Live} subclass to manage
- *                   (e.g. `typeof LiveWSBase` or `typeof LiveTCPBase`).
- *
- * @example
- * ```ts
- * const keep = new KeepLiveWS(12345, { key: '...' })
- * keep.on('heartbeat', (e) => console.log('online:', e.data))
- * keep.on('DANMU_MSG', (e) => console.log('danmaku:', e.data))
- * ```
- */
-declare class KeepLive<Base extends typeof Live> extends EventTarget {
-    /** @internal Stored constructor arguments for reconnection. */
-    params: ConstructorParameters<Base>;
-    /** `true` after {@link close} has been called; prevents further reconnects. */
-    closed: boolean;
-    /** Delay in milliseconds before attempting a reconnect. */
-    interval: number;
-    /** Maximum milliseconds to wait for a heartbeat before forcing a reconnect. */
-    timeout: number;
-    /** The current underlying connection instance. */
-    connection: InstanceType<Base>;
-    /** @internal The base class constructor used to create new connections. */
-    Base: Base;
-    constructor(Base: Base, ...params: ConstructorParameters<Base>);
-    /**
-     * Overridden to also dispatch a `LaplaceRawEvent<Event>` with type `"event"`
-     * for every event, enabling catch-all listeners.
-     */
-    dispatchEvent(event: Event): boolean;
-    /**
-     * Wire up event forwarding and timeout handling on the current connection.
-     * When `reconnect` is `true`, the previous connection is closed and a fresh
-     * one is created from the stored constructor parameters.
-     *
-     * @param reconnect - Whether to tear down and recreate the connection first.
-     */
-    connect(reconnect?: boolean): void;
-    /** Latest known online viewer count from the underlying connection. */
-    get online(): number;
-    /** The live room ID. */
-    get roomid(): number;
-    /** Permanently close the connection and stop reconnecting. */
-    close(): void;
-    /** Send a heartbeat packet to the server. */
-    heartbeat(): void;
-    /**
-     * Send a heartbeat and resolve with the online viewer count from the
-     * next heartbeat response.
-     * @returns A promise that resolves with the current online count.
-     */
-    getOnline(): Promise<number>;
-    /**
-     * Send raw binary data through the underlying connection.
-     * @param data - The binary packet to send.
-     */
-    send(data: Uint8Array): void;
-    /**
-     * Subscribe to an event type with a typed {@link LaplaceRawEvent} listener.
-     *
-     * @typeParam T - Expected data type carried by the event.
-     * @param type     - Event name (e.g. `"heartbeat"`, `"msg"`, `"DANMU_MSG"`).
-     * @param listener - Callback receiving a {@link LaplaceRawEvent LaplaceRawEvent\<T\>}.
-     * @param options  - Standard `addEventListener` options.
-     */
-    on<T = unknown>(type: string, listener: (event: LaplaceRawEvent<T>) => void, options?: boolean | AddEventListenerOptions): void;
-    /**
-     * Unsubscribe a previously registered listener.
-     *
-     * @typeParam T - Data type matching the original subscription.
-     * @param type     - Event name.
-     * @param listener - The same function reference passed to {@link on}.
-     * @param options  - Standard `removeEventListener` options.
-     */
-    off<T = unknown>(type: string, listener: (event: LaplaceRawEvent<T>) => void, options?: boolean | EventListenerOptions): void;
-}
-
-/**
- * Configuration options for WebSocket-based live connections.
- * Extends {@link LiveOptions} with an optional WebSocket server address.
- */
-type WSOptions = LiveOptions & {
-    /** WebSocket server URL. Defaults to `wss://broadcastlv.chat.bilibili.com/sub`. */
-    address?: string;
-};
-/**
- * WebSocket transport for Bilibili live room connections.
- *
- * Wraps a native {@link WebSocket}, wiring its lifecycle events (`open`,
- * `message`, `close`, `error`) into the {@link Live} event system. Binary
- * frames are forwarded as `LaplaceRawEvent<Uint8Array>` for protocol decoding.
- *
- * Not typically instantiated directly — use {@link LiveWS} (server) or the
- * browser-specific `LiveWS` which inject the appropriate inflate
- * implementation.
- *
- * @param inflates - Platform-specific inflate/brotli decompressors.
- * @param roomid   - Numeric Bilibili live room ID.
- * @param options  - WebSocket address and authentication options.
- */
-declare class LiveWSBase extends Live {
-    /** The underlying native WebSocket instance. */
-    ws: WebSocket;
-    constructor(inflates: Inflates, roomid: number, { address, ...options }?: WSOptions);
-}
-
-export { type Inflates as I, KeepLive as K, Live as L, type WSOptions as W, type LiveOptions as a, LiveWSBase as b, LaplaceRawEvent as c };