angelia.io 5.0.1 → 5.0.2

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "angelia.io",
-	"version": "5.0.1",
+	"version": "5.0.2",
 	"description": "WebSockets Server and Client API for node.js and the browser, with rooms support.",
 	"author": "@titoBouzout @boredofnames",
 	"license": "GPL",
@@ -43,7 +43,8 @@
 		"demo": "node tests/demo/server.js",
 		"bench:worker": "node bench/browser/run.js",
 		"bench:server": "node bench/node-receive.js",
-		"bench:fanout": "node bench/fanout.js"
+		"bench:fanout": "node bench/fanout.js",
+		"bench:message": "node bench/message.js"
 	},
 	"homepage": "https://github.com/titoBouzout/angelia.io",
 	"repository": {

package/readme.md

@@ -129,7 +129,10 @@ them with the exported class: `import { Server } from
 | `on(Class)`                           | Function | attaches all methods of a `Class` as listeners                                         |
 | `emit(key, [value])`                  | Function | emits to all connected sockets                                                         |
 | `broadcast(sender, key, [value])`     | Function | emits to all connected sockets except sender                                           |
+| `send(message)`                       | Function | sends a `Message` to all connected sockets                                             |
+| `sendExcept(sender, message)`         | Function | sends a `Message` to all connected sockets except sender                               |
 | `sockets`                             | Set      | every currently connected socket                                                       |
+| `SocketClass`                         | Class    | class of the sockets it creates, `Socket` unless set before `listen`                   |
 | `reloadCerts()`                       | Function | re-read `cert`/`privKey` from disk and swap them in. Open connections are untouched. Safe to call manually (e.g. on `SIGHUP`); the watcher uses it internally |
 | `stop()`                              | Function | stops listening and drops every connection; `await using server = new Server()` calls it when the scope ends |
 
@@ -156,8 +159,53 @@ The `socket` object is given to you by a listener
 | `rooms`                        | Set      | the rooms this socket is in                                                                                                                                                                                                       |
 | `request(key, [value])`        | Function | emits and returns a promise for the client's reply, rejected with an Error whose message starts with `disconnected:` if the socket closes first; without a value the listener gets `null` |
 | `emit(key, [value, callback])` | Function | emits to client; with a callback, returns a promise for its result, rejected with an Error whose message starts with `disconnected:` if the socket closes first                                                                                                                                                                                                              |
+| `send(message)` | Function | sends a `Message` to the client |
 | `disconnect([noReconnect, reason])` | Function | closes the WebSocket, pass `true` to prevent re-connections; `reason` (up to 123 bytes) is sent to the client                                                                                                              |
 
+### `Message`
+
+`emit` encodes once per fan-out, in the tick it sends. A `Message` is
+encoded once as it is made, and keeps its encoding for as long as you keep
+it, for a payload sent to sockets one at a time or again later, as a list
+sent to whoever arrives.
+
+```js
+import { Message } from 'angelia.io/server'
+
+const rooms = new Message('rooms', list)
+
+socket.send(rooms)
+room.send(rooms)
+room.sendExcept(socket, rooms)
+
+// equal text means an equal message
+if (rooms.json !== last.json) Server.send(rooms)
+```
+
+Later changes to the value never reach the wire, and `toJSON` runs as it
+is made rather than as it sends. A message carries no reply callback, as
+one belongs to a single socket: use `socket.emit` or `socket.request`.
+
+### Your own `Socket`
+
+Set `Server.SocketClass` before `listen` and each connection is your subclass, so what belongs to a user lives on the socket itself. `toJSON` says what sending a socket sends; by default it sends nothing of it.
+
+```js
+import Server, { Socket } from 'angelia.io/server'
+
+class User extends Socket {
+	username = ''
+	toJSON() {
+		return { username: this.username }
+	}
+}
+
+Server.SocketClass = User
+await Server.listen()
+```
+
+Listeners, hooks and every `sockets` then give you `User`s. Its constructor gets what `Socket`'s does, so pass them on with `super(...args)` if it has one.
+
 ### Server Listeners
 
 Listen to an event by creating a class with any name, and give to
@@ -236,7 +284,7 @@ the right one by name.
 | `timeout(socket, delay)`     | when we are about to disconnect a timedout socket, gives the delay in milliseconds                                                                |
 | `garbage(socket, data)`      | when the client sends a message with no listener, a malformed one, or one named after a predefined event                                         |
 | `incoming(socket, messages)` | for debugging: ref to array of incoming messages received before dispatching to listeners                                                         |
-| `outgoing(socket, messages)` | for debugging: ref to array of outgoing messages before sending to socket                                                                         |
+| `outgoing(socket, messages)` | for debugging: ref to array of outgoing messages before sending to socket; changing a `Message`'s tuple here never changes what is sent           |
 
 ## Client API (Browser)
 
@@ -409,10 +457,13 @@ await Server.listen()
 | `get(id)`                             | method | gets room with such an `id`                    |
 | `join(socket, [id])`                  | method | adds socket to room `id`                       |
 | `leave(socket, [id])`                 | method | removes socket from room `id`                  |
+| `of(socket)`                          | method | iterates the rooms of this list `socket` is in, walking the socket's rooms, not the list's |
 | `sockets`                             | Set    | sockets across every room in this list, each once |
 | `rooms`                               | Map    | every room in this list, by id                 |
 | `emit(key, [value])`                  | method | emits to all sockets in this room list         |
 | `broadcast(socket, key, [value])`     | method | emits to other sockets in this room list       |
+| `send(message)`                       | method | sends a `Message` to all sockets in this room list |
+| `sendExcept(socket, message)`         | method | sends a `Message` to other sockets in this room list |
 
 ### Via a `Room`
 
@@ -462,9 +513,31 @@ await Server.listen()
 | `sockets`                             | Set     | sockets in the room                              |
 | `emit(key, [value])`                  | method  | emits to all sockets in the room                 |
 | `broadcast(socket, key, [value])`     | method  | emits to other sockets in the room               |
+| `send(message)`                       | method  | sends a `Message` to all sockets in the room     |
+| `sendExcept(socket, message)`         | method  | sends a `Message` to other sockets in the room   |
 | `id`                                  | any     | the room id                                      |
 | `join(socket)`                        | method  | adds a socket to the room                        |
-| `leave(socket)`                       | method  | removes a socket from the room                   |
+| `leave(socket)`                       | method  | removes a socket from the room; in a `Rooms` list, an emptied room is deleted unless `persistent` |
+
+### Your own `Emitter`
+
+`Server`, `Room` and `Rooms` send through `Emitter`, which only reads a
+`sockets` field. Extend it for something that sends to sockets it doesn't
+own, as what a room is doing right now:
+
+```js
+import { Emitter } from 'angelia.io/server'
+
+class Match extends Emitter {
+	constructor(room) {
+		super()
+		this.room = room
+	}
+	get sockets() {
+		return this.room.sockets
+	}
+}
+```
 
 ### `sockets` in `Server`, `Room` and `Rooms`
 

package/server/Emitter.js

@@ -1,19 +1,41 @@
 /** @import { ClientEvents, EventKey, EventValue } from './index.js' */
+/** @import { Message } from './Message.js' */
 /** @import { Socket } from './Socket.js' */
 
 /**
  * @typedef {{
  * 	sockets: Iterable<Socket>
- * 	broadcast(me: Socket | undefined, k: any, v?: any): void
  * }} HasSockets
  */
 
+/**
+ * @param {Iterable<Socket>} sockets
+ * @param {any[]} tuple
+ */
+function queueAll(sockets, tuple) {
+	for (const socket of sockets) {
+		socket.queue(tuple)
+	}
+}
+
+/**
+ * @param {Iterable<Socket>} sockets
+ * @param {Socket | undefined} me
+ * @param {any[]} tuple
+ */
+function queueExcept(sockets, me, tuple) {
+	for (const socket of sockets) {
+		if (me !== socket) {
+			socket.queue(tuple)
+		}
+	}
+}
+
 /**
  * Common emit / broadcast logic. Subclasses own the `sockets` field
- * (a Set on Server, Room and Rooms). Each fan-out builds the wire tuple
- * **once** and passes the same reference to every recipient —
- * `Server.cacheMessages` keys the encoded form by message identity, so
- * all sockets share a single encoding.
+ * (a Set on Server, Room and Rooms). Each fan-out queues **one** wire
+ * tuple on every recipient, and `Server.cacheMessages` keeps the encoded
+ * form on it, so all sockets share a single encoding.
  */
 export class Emitter {
 	/**
@@ -25,7 +47,7 @@ export class Emitter {
 	 * @param {EventValue<ClientEvents, K>} v
 	 */
 	emit(k, v) {
-		this.broadcast(undefined, k, v)
+		queueAll(this.sockets, [k, v])
 	}
 
 	/**
@@ -38,12 +60,27 @@ export class Emitter {
 	 * @param {EventValue<ClientEvents, K>} v
 	 */
 	broadcast(me, k, v) {
-		/** @type {[string, any]} */
-		const d = [k, v]
-		for (const socket of this.sockets) {
-			if (me !== socket) {
-				socket.queue(d)
-			}
-		}
+		queueExcept(this.sockets, me, [k, v])
+	}
+
+	/**
+	 * Send an encoded message to every socket in scope.
+	 *
+	 * @this {HasSockets}
+	 * @param {Message<any>} message
+	 */
+	send(message) {
+		queueAll(this.sockets, message.tuple)
+	}
+
+	/**
+	 * Send an encoded message to every socket in scope except `me`.
+	 *
+	 * @this {HasSockets}
+	 * @param {Socket | undefined} me
+	 * @param {Message<any>} message
+	 */
+	sendExcept(me, message) {
+		queueExcept(this.sockets, me, message.tuple)
 	}
 }

package/server/Message.js

@@ -0,0 +1,27 @@
+import { encoded } from './constants.js'
+import { stringify } from './utils.js'
+
+/** @import { ClientEvents, EventKey, EventValue } from './index.js' */
+
+/**
+ * A message encoded once, here, to send to any socket at any time with
+ * `send` / `sendExcept`. Later changes to `v` don't reach the wire.
+ *
+ * @template {EventKey<ClientEvents>} K
+ */
+export class Message {
+	/**
+	 * @param {K} k
+	 * @param {EventValue<ClientEvents, K>} v
+	 */
+	constructor(k, v) {
+		/**
+		 * @internal The wire tuple every send queues.
+		 * @type {any[]}
+		 */
+		this.tuple = [k, v]
+		/** The encoded text; equal text means an equal message. */
+		this.json = stringify(this.tuple)
+		this.tuple[encoded] = this.json
+	}
+}

package/server/Room.js

@@ -7,14 +7,20 @@ import { parent } from './constants.js'
 /** A group of sockets to emit to; subclass it to hook its lifecycle. */
 export class Room extends Emitter {
 	/** @type {Set<Socket>} */
-	sockets = new Set()
+	#sockets = new Set()
 	/** @type {any} Set by `Rooms` for its rooms; yours to set otherwise. */
 	id
-	/** Keep the room in its `Rooms` list when its last socket leaves. */
-	persistent = false
 	/** @type {Rooms<any> | undefined} The list the room belongs to, if any. */
 	;[parent]
 
+	/**
+	 * Off the room's own fields, as a subclass may spread its fields into
+	 * what it sends.
+	 */
+	get sockets() {
+		return this.#sockets
+	}
+
 	/**
 	 * Called when a `Rooms` list creates the room for `socket`.
 	 *
@@ -41,16 +47,30 @@ export class Room extends Emitter {
 		this[parent]?.sockets.add(socket)
 		this.onJoin(socket)
 	}
-	/** @param {Socket} socket */
+	/**
+	 * Leave the room; a room in a `Rooms` list that this empties is deleted
+	 * unless it's `persistent`.
+	 *
+	 * @param {Socket} socket
+	 */
 	leave(socket) {
 		if (!this.sockets.delete(socket)) return
 		socket.rooms.delete(this)
 		const list = this[parent]
 		if (list && !inList(socket, list)) list.sockets.delete(socket)
 		this.onLeave(socket)
+		if (list && !this.persistent && this.sockets.size === 0) {
+			list.rooms.delete(this.id)
+			this.onDelete(socket)
+			// Joins through a kept reference no longer reach this list.
+			this[parent] = undefined
+		}
 	}
 }
 
+/** Keep the room in its `Rooms` list when its last socket leaves. */
+Room.prototype.persistent = false
+
 /**
  * Whether `socket` is still in another room of `list`. Walks the
  * socket's own rooms, which stay few, not the list's members.

package/server/Rooms.js

@@ -51,7 +51,14 @@ export class Rooms extends Emitter {
 			room.id = id
 			this.rooms.set(id, room)
 
-			room.onCreate(socket)
+			// In the list while it runs, for it to find itself; a failed one is no room.
+			try {
+				room.onCreate(socket)
+			} catch (error) {
+				this.rooms.delete(id)
+				room[parent] = undefined
+				throw error
+			}
 		}
 		room.join(socket)
 	}
@@ -64,15 +71,19 @@ export class Rooms extends Emitter {
 	 * @param {any} [id]
 	 */
 	leave(socket, id) {
-		const room = this.rooms.get(id)
-		if (room) {
-			room.leave(socket)
-			if (!room.persistent && room.sockets.size === 0) {
-				this.rooms.delete(id)
-				room.onDelete(socket)
-				// Joins through a kept reference no longer reach this list.
-				room[parent] = undefined
-			}
+		this.rooms.get(id)?.leave(socket)
+	}
+
+	/**
+	 * The rooms of this list `socket` is in. Walks the socket's own rooms,
+	 * which stay few, not the list's. Leaving one while iterating is fine.
+	 *
+	 * @param {Socket} socket
+	 * @returns {Generator<R>}
+	 */
+	*of(socket) {
+		for (const room of socket.rooms) {
+			if (room[parent] === this) yield /** @type {R} */ (room)
 		}
 	}
 

package/server/Server.js

@@ -14,6 +14,8 @@ import {
 	DEFAULT_PORT,
 	LIFECYCLE_EVENTS,
 	MAX_PORT,
+	encoded,
+	framed,
 } from './constants.js'
 import {
 	DEFAULT_PATH,
@@ -156,6 +158,13 @@ export class Server extends Emitter {
 	 * @type {Socket[]}
 	 */
 	drained = []
+	/**
+	 * Class of the sockets it creates; set it before `listen` to have each
+	 * connection be a subclass of `Socket`.
+	 *
+	 * @type {typeof Socket}
+	 */
+	SocketClass = Socket
 	/** @internal */
 	cacheSymbol = Symbol('cache')
 	/** @internal */
@@ -479,7 +488,7 @@ export class Server extends Emitter {
 	#onconnection = (io, request) => {
 		// URL-packed messages come off the params before `connect` sees them.
 		const [query, m] = params(request.url, PACKED_PARAM)
-		const socket = new Socket(io, request, this, query)
+		const socket = new this.SocketClass(io, request, this, query)
 
 		socket.listen()
 
@@ -539,33 +548,40 @@ export class Server extends Emitter {
 	}
 
 	/**
-	 * Cache the framed form of `messages` keyed by message identity, so a
-	 * fan-out stringifies and frames once per tick. Byte counters are
-	 * bumped in `Socket.write`.
+	 * The frame of `messages`. Each message stringifies once however many
+	 * batches it lands in, and a batch frames once per tick. Byte counters
+	 * are bumped in `Socket.write`.
 	 *
 	 * @internal Called from Socket.processQueue.
 	 * @param {any[]} messages
 	 * @returns {Buffer[]}
 	 */
 	cacheMessages(messages) {
-		// A fan-out is usually one message: key on it and skip the string.
-		let key = messages.length === 1 ? messages[0] : ''
-		if (key === '') {
-			for (const m of messages) {
-				if (!m[this.cacheSymbol]) {
-					m[this.cacheSymbol] = this.cached++
-				}
-				key += m[this.cacheSymbol] + ','
+		// A fan-out is usually one message: its frame lives on it, for as long as it does.
+		if (messages.length === 1) {
+			const m = messages[0]
+			if (m[framed]) {
+				this.messagesSentCacheHit++
+			} else {
+				m[framed] = frame(`[${m[encoded] ??= stringify(m)}]`)
+			}
+			return m[framed]
+		}
+		let key = ''
+		for (const m of messages) {
+			if (!m[this.cacheSymbol]) {
+				m[this.cacheSymbol] = this.cached++
 			}
+			key += m[this.cacheSymbol] + ','
 		}
-		let framed = this.cache.get(key)
-		if (framed) {
+		let batch = this.cache.get(key)
+		if (batch) {
 			this.messagesSentCacheHit++
 		} else {
-			framed = frame(stringify(messages))
-			this.cache.set(key, framed)
+			batch = frame(`[${messages.map(m => (m[encoded] ??= stringify(m))).join()}]`)
+			this.cache.set(key, batch)
 		}
-		return framed
+		return batch
 	}
 
 	#updateNow = () => {

package/server/Socket.js

@@ -1,4 +1,3 @@
-import { parent } from './constants.js'
 import {
 	NO_RECONNECT,
 	PROTOCOL_KEY,
@@ -16,6 +15,7 @@ import {
 import { WebSocket } from 'ws'
 
 /** @import { ClientEvents, ClientReplies, EventKey, EventValue } from './index.js' */
+/** @import { Message } from './Message.js' */
 /** @import { Room } from './Room.js' */
 /** @import { Server } from './Server.js' */
 
@@ -120,6 +120,15 @@ export class Socket {
 		this.queue([k, v])
 	}
 
+	/**
+	 * Queue an encoded message for the next batch.
+	 *
+	 * @param {Message<any>} message
+	 */
+	send(message) {
+		this.queue(message.tuple)
+	}
+
 	/**
 	 * @internal Queue a wire tuple; fan-outs pass one tuple to every
 	 * recipient so `Server.cacheMessages` encodes it once.
@@ -224,9 +233,7 @@ export class Socket {
 
 		// Leaving deletes the room from this.rooms; Set iteration allows that.
 		for (const room of this.rooms) {
-			room[parent]
-				? room[parent].leave(this, room.id)
-				: room.leave(this)
+			room.leave(this)
 		}
 
 		this.server.hooks.disconnect?.(this, code, reason.toString())
@@ -376,6 +383,7 @@ export class Socket {
 		this.io._sender.sendFrame(chunks)
 	}
 
+	/** @returns {any} What sending a socket sends; a subclass says what. */
 	toJSON() {
 		return '[content of socket object omitted for toJSON]'
 	}

package/server/constants.js

@@ -1,4 +1,7 @@
 export const parent = Symbol('parent')
+// A wire tuple's JSON, and its frame as a batch of one.
+export const encoded = Symbol('encoded')
+export const framed = Symbol('framed')
 
 // Server events fired by the library itself; clients can't trigger them.
 export const LIFECYCLE_EVENTS = new Set([

package/server/index.js

@@ -1,3 +1,6 @@
 export { default, Server } from './Server.js'
+export { Emitter } from './Emitter.js'
+export { Message } from './Message.js'
 export { Room } from './Room.js'
 export { Rooms } from './Rooms.js'
+export { Socket } from './Socket.js'

package/types/server/Emitter.d.ts

@@ -1,23 +1,17 @@
 /** @import { ClientEvents, EventKey, EventValue } from './index.js' */
+/** @import { Message } from './Message.js' */
 /** @import { Socket } from './Socket.js' */
 import type { ClientEvents, EventKey, EventValue } from './index.js';
+import type { Message } from './Message.js';
 import type { Socket } from './Socket.js';
 export type HasSockets = {
     sockets: Iterable<Socket>;
-    broadcast(me: Socket | undefined, k: any, v?: any): void;
 };
-/**
- * @typedef {{
- * 	sockets: Iterable<Socket>
- * 	broadcast(me: Socket | undefined, k: any, v?: any): void
- * }} HasSockets
- */
 /**
  * Common emit / broadcast logic. Subclasses own the `sockets` field
- * (a Set on Server, Room and Rooms). Each fan-out builds the wire tuple
- * **once** and passes the same reference to every recipient —
- * `Server.cacheMessages` keys the encoded form by message identity, so
- * all sockets share a single encoding.
+ * (a Set on Server, Room and Rooms). Each fan-out queues **one** wire
+ * tuple on every recipient, and `Server.cacheMessages` keeps the encoded
+ * form on it, so all sockets share a single encoding.
  */
 export declare class Emitter {
     /**
@@ -39,4 +33,19 @@ export declare class Emitter {
      * @param {EventValue<ClientEvents, K>} v
      */
     broadcast<K extends EventKey<ClientEvents>>(this: HasSockets, me: Socket | undefined, k: K, v: EventValue<ClientEvents, K>): void;
+    /**
+     * Send an encoded message to every socket in scope.
+     *
+     * @this {HasSockets}
+     * @param {Message<any>} message
+     */
+    send(this: HasSockets, message: Message<any>): void;
+    /**
+     * Send an encoded message to every socket in scope except `me`.
+     *
+     * @this {HasSockets}
+     * @param {Socket | undefined} me
+     * @param {Message<any>} message
+     */
+    sendExcept(this: HasSockets, me: Socket | undefined, message: Message<any>): void;
 }

package/types/server/Message.d.ts

@@ -0,0 +1,22 @@
+import type { ClientEvents, EventKey, EventValue } from './index.js';
+/** @import { ClientEvents, EventKey, EventValue } from './index.js' */
+/**
+ * A message encoded once, here, to send to any socket at any time with
+ * `send` / `sendExcept`. Later changes to `v` don't reach the wire.
+ *
+ * @template {EventKey<ClientEvents>} K
+ */
+export declare class Message<K extends EventKey<ClientEvents>> {
+    /**
+     * @internal The wire tuple every send queues.
+     * @type {any[]}
+     */
+    tuple: any[];
+    /** The encoded text; equal text means an equal message. */
+    json: string;
+    /**
+     * @param {K} k
+     * @param {EventValue<ClientEvents, K>} v
+     */
+    constructor(k: K, v: EventValue<ClientEvents, K>);
+}

package/types/server/Room.d.ts

@@ -5,13 +5,15 @@ import type { Socket } from './Socket.js';
 /** @import { Rooms } from './Rooms.js' */
 /** A group of sockets to emit to; subclass it to hook its lifecycle. */
 export declare class Room extends Emitter {
-    /** @type {Set<Socket>} */
-    sockets: Set<Socket>;
+    #private;
     /** @type {any} Set by `Rooms` for its rooms; yours to set otherwise. */
     id: any;
-    /** Keep the room in its `Rooms` list when its last socket leaves. */
-    persistent: boolean;
     [parent]: any;
+    /**
+     * Off the room's own fields, as a subclass may spread its fields into
+     * what it sends.
+     */
+    get sockets(): Set<Socket>;
     /**
      * Called when a `Rooms` list creates the room for `socket`.
      *
@@ -30,6 +32,11 @@ export declare class Room extends Emitter {
     onLeave(socket: Socket): void;
     /** @param {Socket} socket */
     join(socket: Socket): void;
-    /** @param {Socket} socket */
+    /**
+     * Leave the room; a room in a `Rooms` list that this empties is deleted
+     * unless it's `persistent`.
+     *
+     * @param {Socket} socket
+     */
     leave(socket: Socket): void;
 }

package/types/server/Rooms.d.ts

@@ -42,6 +42,14 @@ export declare class Rooms<R extends Room = Room> extends Emitter {
      * @param {any} [id]
      */
     leave(socket: Socket, id?: any): void;
+    /**
+     * The rooms of this list `socket` is in. Walks the socket's own rooms,
+     * which stay few, not the list's. Leaving one while iterating is fine.
+     *
+     * @param {Socket} socket
+     * @returns {Generator<R>}
+     */
+    of(socket: Socket): Generator<R>;
     /** @returns {R[]} */
     toJSON(): R[];
 }

package/types/server/Server.d.ts

@@ -115,6 +115,13 @@ export declare class Server extends Emitter {
     io: WebSocketServer | null;
     /** @type {import('node:http').Server | null} */
     httpServer: import('node:http').Server | null;
+    /**
+     * Class of the sockets it creates; set it before `listen` to have each
+     * connection be a subclass of `Socket`.
+     *
+     * @type {typeof Socket}
+     */
+    SocketClass: typeof Socket;
     constructor();
     /**
      * Start listening for WebSocket connections. Serves `wss://` when

package/types/server/Socket.d.ts

@@ -1,6 +1,7 @@
 import { inspect } from './utils.js';
 import { WebSocket } from 'ws';
 import type { ClientEvents, ClientReplies, EventKey, EventValue } from './index.js';
+import type { Message } from './Message.js';
 import type { Room } from './Room.js';
 import type { Server } from './Server.js';
 /** One client connection, handed to every event handler and hook. */
@@ -78,6 +79,12 @@ export declare class Socket {
      * @returns {Promise<any> | void}
      */
     emit<K extends EventKey<ClientEvents>, R>(k: K, v: EventValue<ClientEvents, K>, callback: (reply: EventValue<ClientReplies, K>) => R): Promise<R>;
+    /**
+     * Queue an encoded message for the next batch.
+     *
+     * @param {Message<any>} message
+     */
+    send(message: Message<any>): void;
     /**
      * Emit and resolve with the client's reply; rejected with
      * a `disconnected:` Error if the socket closes first.
@@ -131,7 +138,8 @@ export declare class Socket {
      *   123 bytes; longer throws a `RangeError` before anything closes.
      */
     disconnect(noReconnect?: boolean, reason?: string): void;
-    toJSON(): string;
+    /** @returns {any} What sending a socket sends; a subclass says what. */
+    toJSON(): any;
     /**
      * `console.log(socket)` shows who it is and how it's doing, not internals.
      *

package/types/server/constants.d.ts

@@ -1,4 +1,6 @@
 export declare const parent: unique symbol;
+export declare const encoded: unique symbol;
+export declare const framed: unique symbol;
 export declare const LIFECYCLE_EVENTS: Set<string>;
 export declare const DEFAULT_PORT = 3001;
 export declare const DEFAULT_MAX_MESSAGE_SIZE_MB = 5;

package/types/server/index.d.ts

@@ -1,7 +1,16 @@
 export { default, Server } from './Server.js'
+export { Emitter } from './Emitter.js'
+export { Message } from './Message.js'
 export { Room } from './Room.js'
 export { Rooms } from './Rooms.js'
-export type { Socket } from './Socket.js'
+export { Socket } from './Socket.js'
+
+declare module './Room.js' {
+	interface Room {
+		/** Keep the room in its `Rooms` list when its last socket leaves. */
+		persistent: boolean
+	}
+}
 
 /**
  * Event-map interfaces. Augment these from your app to get end-to-end