@colyseus/core 0.16.23 → 0.17.0

package/build/Room.js

@@ -1,8 +1,7 @@
-var __create = Object.create;
+"use strict";
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -16,53 +15,52 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var Room_exports = {};
 __export(Room_exports, {
   DEFAULT_SEAT_RESERVATION_TIME: () => DEFAULT_SEAT_RESERVATION_TIME,
   Room: () => Room,
-  RoomInternalState: () => RoomInternalState
+  RoomInternalState: () => RoomInternalState,
+  room: () => room,
+  validate: () => validate
 });
 module.exports = __toCommonJS(Room_exports);
 var import_msgpackr = require("@colyseus/msgpackr");
 var import_schema = require("@colyseus/schema");
-var import_timer = __toESM(require("@colyseus/timer"));
+var import_timer = require("@colyseus/timer");
 var import_events = require("events");
-var import_Logger = require("./Logger.js");
-var import_NoneSerializer = require("./serializer/NoneSerializer.js");
-var import_SchemaSerializer = require("./serializer/SchemaSerializer.js");
-var import_Protocol = require("./Protocol.js");
-var import_Utils = require("./utils/Utils.js");
-var import_DevMode = require("./utils/DevMode.js");
-var import_Debug = require("./Debug.js");
-var import_ServerError = require("./errors/ServerError.js");
-var import_Transport = require("./Transport.js");
-var import_RoomExceptions = require("./errors/RoomExceptions.js");
+var import_Logger = require("./Logger.ts");
+var import_NoneSerializer = require("./serializer/NoneSerializer.ts");
+var import_SchemaSerializer = require("./serializer/SchemaSerializer.ts");
+var import_Protocol = require("./Protocol.ts");
+var import_Utils = require("./utils/Utils.ts");
+var import_nanoevents = require("./utils/nanoevents.ts");
+var import_DevMode = require("./utils/DevMode.ts");
+var import_Debug = require("./Debug.ts");
+var import_ServerError = require("./errors/ServerError.ts");
+var import_Transport = require("./Transport.ts");
+var import_RoomExceptions = require("./errors/RoomExceptions.ts");
+var import_StandardSchema = require("./utils/StandardSchema.ts");
+var import_core = require("@colyseus/core");
 const DEFAULT_PATCH_RATE = 1e3 / 20;
 const DEFAULT_SIMULATION_INTERVAL = 1e3 / 60;
 const noneSerializer = new import_NoneSerializer.NoneSerializer();
 const DEFAULT_SEAT_RESERVATION_TIME = Number(process.env.COLYSEUS_SEAT_RESERVATION_TIME || 15);
-var RoomInternalState = /* @__PURE__ */ ((RoomInternalState2) => {
-  RoomInternalState2[RoomInternalState2["CREATING"] = 0] = "CREATING";
-  RoomInternalState2[RoomInternalState2["CREATED"] = 1] = "CREATED";
-  RoomInternalState2[RoomInternalState2["DISPOSING"] = 2] = "DISPOSING";
-  return RoomInternalState2;
-})(RoomInternalState || {});
+function validate(format, handler) {
+  return { format, handler };
+}
+const RoomInternalState = {
+  CREATING: 0,
+  CREATED: 1,
+  DISPOSING: 2
+};
 class Room {
   constructor() {
     /**
      * Timing events tied to the room instance.
      * Intervals and timeouts are cleared when the room is disposed.
      */
-    this.clock = new import_timer.default();
+    this.clock = new import_timer.ClockTimer();
     this.#_onLeaveConcurrent = 0;
     // number of onLeave calls in progress
     /**
@@ -84,40 +82,52 @@ class Room {
      * @default 50ms (20fps)
      */
     this.patchRate = DEFAULT_PATCH_RATE;
+    /**
+     * Maximum number of messages a client can send to the server per second.
+     * If a client sends more messages than this, it will be disconnected.
+     *
+     * @default 60
+     */
+    this.maxMessagesPerSecond = 60;
     /**
      * The array of connected clients.
      *
-     * @see {@link https://docs.colyseus.io/colyseus/server/room/#client|Client instance}
+     * @see [Client instance](https://docs.colyseus.io/room#client)
      */
     this.clients = new import_Transport.ClientArray();
-    /** @internal */
+    /**
+     * Set the number of seconds a room can wait for a client to effectively join the room.
+     * You should consider how long your `onAuth()` will have to wait for setting a different seat reservation time.
+     * The default value is 15 seconds. You may set the `COLYSEUS_SEAT_RESERVATION_TIME`
+     * environment variable if you'd like to change the seat reservation time globally.
+     *
+     * @default 15 seconds
+     */
+    this.seatReservationTimeout = DEFAULT_SEAT_RESERVATION_TIME;
     this._events = new import_events.EventEmitter();
-    // seat reservation & reconnection
-    this.seatReservationTime = DEFAULT_SEAT_RESERVATION_TIME;
-    this.reservedSeats = {};
-    this.reservedSeatTimeouts = {};
+    this._reservedSeats = {};
+    this._reservedSeatTimeouts = {};
     this._reconnections = {};
-    this._reconnectingSessionId = /* @__PURE__ */ new Map();
-    this.onMessageHandlers = {
-      "__no_message_handler": {
-        callback: (client, messageType, _) => {
-          const errorMessage = `room onMessage for "${messageType}" not registered.`;
-          (0, import_Debug.debugAndPrintError)(`${errorMessage} (roomId: ${this.roomId})`);
-          if (import_DevMode.isDevMode) {
-            client.error(import_Protocol.ErrorCode.INVALID_PAYLOAD, errorMessage);
-          } else {
-            client.leave(import_Protocol.Protocol.WS_CLOSE_WITH_ERROR, errorMessage);
-          }
+    this.onMessageEvents = (0, import_nanoevents.createNanoEvents)();
+    this.onMessageValidators = {};
+    this.onMessageFallbacks = {
+      "__no_message_handler": (client, messageType, _) => {
+        const errorMessage = `room onMessage for "${messageType}" not registered.`;
+        (0, import_Debug.debugMessage)(`${errorMessage} (roomId: ${this.roomId})`);
+        if (import_DevMode.isDevMode) {
+          client.error(import_Protocol.ErrorCode.INVALID_PAYLOAD, errorMessage);
+        } else {
+          client.leave(import_Protocol.CloseCode.WITH_ERROR, errorMessage);
         }
       }
     };
     this._serializer = noneSerializer;
     this._afterNextPatchQueue = [];
-    this._internalState = 0 /* CREATING */;
+    this._internalState = RoomInternalState.CREATING;
     this._lockedExplicitly = false;
     this.#_locked = false;
     this._events.once("dispose", () => {
-      this._dispose().catch((e) => (0, import_Debug.debugAndPrintError)(`onDispose error: ${e && e.stack || e.message || e || "promise rejected"} (roomId: ${this.roomId})`)).finally(() => this._events.emit("disconnect"));
+      this.#_dispose().catch((e) => (0, import_Debug.debugAndPrintError)(`onDispose error: ${e && e.stack || e.message || e || "promise rejected"} (roomId: ${this.roomId})`)).finally(() => this._events.emit("disconnect"));
     });
     if (this.onUncaughtException !== void 0) {
       this.#registerUncaughtExceptionHandlers();
@@ -133,8 +143,31 @@ class Room {
   get locked() {
     return this.#_locked;
   }
+  /**
+   * Get the room's matchmaking metadata.
+   */
   get metadata() {
-    return this.listing.metadata;
+    return this._listing.metadata;
+  }
+  /**
+   * Set the room's matchmaking metadata.
+   *
+   * **Note**: This setter does NOT automatically persist. Use `setMatchmaking()` for automatic persistence.
+   *
+   * @example
+   * ```typescript
+   * class MyRoom extends Room<{ metadata: { difficulty: string; rating: number } }> {
+   *   async onCreate() {
+   *     this.metadata = { difficulty: "hard", rating: 1500 };
+   *   }
+   * }
+   * ```
+   */
+  set metadata(meta) {
+    if (this._internalState !== RoomInternalState.CREATING) {
+      throw new import_ServerError.ServerError(import_Protocol.ErrorCode.APPLICATION_ERROR, "'metadata' can only be manually set during onCreate(). Use setMatchmaking() instead.");
+    }
+    this._listing.metadata = meta;
   }
   #_roomId;
   #_roomName;
@@ -175,29 +208,14 @@ class Room {
         enumerable: true,
         get: () => this.#_maxClients,
         set: (value) => {
-          this.#_maxClients = value;
-          if (this._internalState === 1 /* CREATED */) {
-            const hasReachedMaxClients = this.hasReachedMaxClients();
-            if (!this._lockedExplicitly && this.#_maxClientsReached && !hasReachedMaxClients) {
-              this.#_maxClientsReached = false;
-              this.#_locked = false;
-              this.listing.locked = false;
-            }
-            if (hasReachedMaxClients) {
-              this.#_maxClientsReached = true;
-              this.#_locked = true;
-              this.listing.locked = true;
-            }
-            this.listing.maxClients = value;
-            this.listing.save();
-          }
+          this.setMatchmaking({ maxClients: value });
         }
       },
       autoDispose: {
         enumerable: true,
         get: () => this.#_autoDispose,
         set: (value) => {
-          if (value !== this.#_autoDispose && this._internalState !== 2 /* DISPOSING */) {
+          if (value !== this.#_autoDispose && this._internalState !== RoomInternalState.DISPOSING) {
             this.#_autoDispose = value;
             this.resetAutoDisposeTimeout();
           }
@@ -214,6 +232,8 @@ class Room {
           }
           if (milliseconds !== null && milliseconds !== 0) {
             this.#_patchInterval = setInterval(() => this.broadcastPatch(), milliseconds);
+          } else if (!this._simulationInterval) {
+            this.#_patchInterval = setInterval(() => this.clock.tick(), DEFAULT_SIMULATION_INTERVAL);
           }
         }
       }
@@ -222,7 +242,16 @@ class Room {
     if (this.#_state) {
       this.state = this.#_state;
     }
-    this.resetAutoDisposeTimeout(this.seatReservationTime);
+    if (this.messages !== void 0) {
+      Object.entries(this.messages).forEach(([messageType, callback]) => {
+        if (typeof callback === "function") {
+          this.onMessage(messageType, callback.bind(this));
+        } else {
+          this.onMessage(messageType, callback.format, callback.handler.bind(this));
+        }
+      });
+    }
+    this.resetAutoDisposeTimeout(this.seatReservationTimeout);
     this.clock.start();
   }
   /**
@@ -260,11 +289,27 @@ class Room {
    * @returns roomId string
    */
   set roomId(roomId) {
-    if (this._internalState !== 0 /* CREATING */ && !import_DevMode.isDevMode) {
+    if (this._internalState !== RoomInternalState.CREATING && !import_DevMode.isDevMode) {
       throw new import_ServerError.ServerError(import_Protocol.ErrorCode.APPLICATION_ERROR, "'roomId' can only be overridden upon room creation.");
     }
     this.#_roomId = roomId;
   }
+  /**
+   * This method is called before onJoin() - this is where you should authenticate the client
+   * @param client - The client that is authenticating.
+   * @param options - The options passed to the client when it is authenticating.
+   * @param context - The authentication context, including the token and the client's IP address.
+   * @returns The authentication result.
+   *
+   * @example
+   * ```typescript
+   * return {
+   *   userId: 123,
+   *   username: "John Doe",
+   *   email: "john.doe@example.com",
+   * };
+   * ```
+   */
   onAuth(client, options, context) {
     return true;
   }
@@ -279,7 +324,7 @@ class Room {
    */
   onBeforeShutdown() {
     this.disconnect(
-      import_DevMode.isDevMode ? import_Protocol.Protocol.WS_CLOSE_DEVMODE_RESTART : import_Protocol.Protocol.WS_CLOSE_CONSENTED
+      import_DevMode.isDevMode ? import_Protocol.CloseCode.DEVMODE_RESTART : import_Protocol.CloseCode.SERVER_SHUTDOWN
     );
   }
   /**
@@ -288,39 +333,31 @@ class Room {
    * @returns boolean
    */
   hasReachedMaxClients() {
-    return this.clients.length + Object.keys(this.reservedSeats).length >= this.maxClients || this._internalState === 2 /* DISPOSING */;
+    return this.clients.length + Object.keys(this._reservedSeats).length >= this.#_maxClients || this._internalState === RoomInternalState.DISPOSING;
   }
   /**
-   * Set the number of seconds a room can wait for a client to effectively join the room.
-   * You should consider how long your `onAuth()` will have to wait for setting a different seat reservation time.
-   * The default value is 15 seconds. You may set the `COLYSEUS_SEAT_RESERVATION_TIME`
-   * environment variable if you'd like to change the seat reservation time globally.
-   *
-   * @default 15 seconds
-   *
-   * @param seconds - number of seconds.
-   * @returns The modified Room object.
+   * @deprecated Use `seatReservationTimeout=` instead.
    */
   setSeatReservationTime(seconds) {
-    this.seatReservationTime = seconds;
+    console.warn(`DEPRECATED: .setSeatReservationTime(${seconds}) is deprecated. Assign a .seatReservationTimeout property value instead.`);
+    this.seatReservationTimeout = seconds;
     return this;
   }
   hasReservedSeat(sessionId, reconnectionToken) {
-    const reservedSeat = this.reservedSeats[sessionId];
+    const reservedSeat = this._reservedSeats[sessionId];
     if (reservedSeat === void 0) {
       return false;
     }
     if (reservedSeat[3]) {
-      return reconnectionToken && this._reconnections[reconnectionToken]?.[0] === sessionId && this._reconnectingSessionId.has(sessionId);
+      return reconnectionToken && this._reconnections[reconnectionToken]?.[0] === sessionId;
     } else {
       return reservedSeat[2] === false;
     }
   }
   checkReconnectionToken(reconnectionToken) {
     const sessionId = this._reconnections[reconnectionToken]?.[0];
-    const reservedSeat = this.reservedSeats[sessionId];
+    const reservedSeat = this._reservedSeats[sessionId];
     if (reservedSeat && reservedSeat[3]) {
-      this._reconnectingSessionId.set(sessionId, reconnectionToken);
       return sessionId;
     } else {
       return void 0;
@@ -365,34 +402,125 @@ class Room {
   setSerializer(serializer) {
     this._serializer = serializer;
   }
-  async setMetadata(meta) {
-    if (!this.listing.metadata) {
-      this.listing.metadata = meta;
+  async setMetadata(meta, persist = true) {
+    if (!this._listing.metadata) {
+      this._listing.metadata = meta;
     } else {
       for (const field in meta) {
         if (!meta.hasOwnProperty(field)) {
           continue;
         }
-        this.listing.metadata[field] = meta[field];
+        this._listing.metadata[field] = meta[field];
       }
-      if ("markModified" in this.listing) {
-        this.listing.markModified("metadata");
+      if ("markModified" in this._listing) {
+        this._listing.markModified("metadata");
       }
     }
-    if (this._internalState === 1 /* CREATED */) {
-      await this.listing.save();
+    if (persist && this._internalState === RoomInternalState.CREATED) {
+      await import_core.matchMaker.driver.persist(this._listing);
+      this._events.emit("metadata-change");
     }
   }
-  async setPrivate(bool = true) {
-    if (this.listing.private === bool) return;
-    this.listing.private = bool;
-    if (this._internalState === 1 /* CREATED */) {
-      await this.listing.save();
+  async setPrivate(bool = true, persist = true) {
+    if (this._listing.private === bool) return;
+    this._listing.private = bool;
+    if (persist && this._internalState === RoomInternalState.CREATED) {
+      await import_core.matchMaker.driver.persist(this._listing);
     }
     this._events.emit("visibility-change", bool);
   }
   /**
-   * Locking the room will remove it from the pool of available rooms for new clients to connect to.
+   * Update multiple matchmaking/listing properties at once with a single persist operation.
+   * This is the recommended way to update room listing properties.
+   *
+   * @param updates - Object containing the properties to update
+   *
+   * @example
+   * ```typescript
+   * // Update multiple properties at once
+   * await this.setMatchmaking({
+   *   metadata: { difficulty: "hard", rating: 1500 },
+   *   private: true,
+   *   locked: true,
+   *   maxClients: 10
+   * });
+   * ```
+   *
+   * @example
+   * ```typescript
+   * // Update only metadata
+   * await this.setMatchmaking({
+   *   metadata: { status: "in_progress" }
+   * });
+   * ```
+   *
+   * @example
+   * ```typescript
+   * // Partial metadata update (merges with existing)
+   * await this.setMatchmaking({
+   *   metadata: { ...this.metadata, round: this.metadata.round + 1 }
+   * });
+   * ```
+   */
+  async setMatchmaking(updates) {
+    for (const key in updates) {
+      if (!updates.hasOwnProperty(key)) {
+        continue;
+      }
+      switch (key) {
+        case "metadata": {
+          this.setMetadata(updates.metadata, false);
+          break;
+        }
+        case "private": {
+          this.setPrivate(updates.private, false);
+          break;
+        }
+        case "locked": {
+          if (updates[key]) {
+            this.lock.call(this, true);
+            this._lockedExplicitly = true;
+          } else {
+            this.unlock.call(this, true);
+            this._lockedExplicitly = false;
+          }
+          break;
+        }
+        case "maxClients": {
+          this.#_maxClients = updates.maxClients;
+          this._listing.maxClients = updates.maxClients;
+          const hasReachedMaxClients = this.hasReachedMaxClients();
+          if (!this._lockedExplicitly && this.#_maxClientsReached && !hasReachedMaxClients) {
+            this.#_maxClientsReached = false;
+            this.#_locked = false;
+            this._listing.locked = false;
+            updates.locked = false;
+          }
+          if (hasReachedMaxClients) {
+            this.#_maxClientsReached = true;
+            this.#_locked = true;
+            this._listing.locked = true;
+            updates.locked = true;
+          }
+          break;
+        }
+        case "clients": {
+          console.warn("setMatchmaking() does not allow updating 'clients' property.");
+          break;
+        }
+        default: {
+          this._listing[key] = updates[key];
+          break;
+        }
+      }
+    }
+    if (this._internalState === RoomInternalState.CREATED) {
+      await import_core.matchMaker.driver.update(this._listing, { $set: updates });
+      this._events.emit("metadata-change");
+    }
+  }
+  /**
+   * Lock the room. This prevents new clients from joining this room.
    */
   async lock() {
     this._lockedExplicitly = arguments[0] === void 0;
@@ -400,13 +528,15 @@ class Room {
       return;
     }
     this.#_locked = true;
-    await this.listing.updateOne({
-      $set: { locked: this.#_locked }
-    });
+    if (this._lockedExplicitly) {
+      await import_core.matchMaker.driver.update(this._listing, {
+        $set: { locked: this.#_locked }
+      });
+    }
     this._events.emit("lock");
   }
   /**
-   * Unlocking the room returns it to the pool of available rooms for new clients to connect to.
+   * Unlock the room. This allows new clients to join this room, if maxClients is not reached.
    */
   async unlock() {
     if (arguments[0] === void 0) {
@@ -416,19 +546,33 @@ class Room {
       return;
     }
     this.#_locked = false;
-    await this.listing.updateOne({
-      $set: { locked: this.#_locked }
-    });
+    if (arguments[0] === void 0) {
+      await import_core.matchMaker.driver.update(this._listing, {
+        $set: { locked: this.#_locked }
+      });
+    }
     this._events.emit("unlock");
   }
   send(client, messageOrType, messageOrOptions, options) {
     import_Logger.logger.warn("DEPRECATION WARNING: use client.send(...) instead of this.send(client, ...)");
     client.send(messageOrType, messageOrOptions, options);
   }
-  broadcast(type, message, options) {
+  /**
+   * Broadcast a message to all connected clients.
+   * @param type - The type of the message.
+   * @param message - The message to broadcast.
+   * @param options - The options for the broadcast.
+   *
+   * @example
+   * ```typescript
+   * this.broadcast('message', { message: 'Hello, world!' });
+   * ```
+   */
+  broadcast(type, ...args) {
+    const [message, options] = args;
     if (options && options.afterNextPatch) {
       delete options.afterNextPatch;
-      this._afterNextPatchQueue.push(["broadcast", arguments]);
+      this._afterNextPatchQueue.push(["broadcast", [type, ...args]]);
       return;
     }
     this.broadcastMessageType(type, message, options);
@@ -461,9 +605,30 @@ class Room {
     this._dequeueAfterPatchMessages();
     return hasChanges;
   }
-  onMessage(messageType, callback, validate) {
-    this.onMessageHandlers[messageType] = this.onUncaughtException !== void 0 ? { validate, callback: (0, import_Utils.wrapTryCatch)(callback, this.onUncaughtException.bind(this), import_RoomExceptions.OnMessageException, "onMessage", false, messageType) } : { validate, callback };
-    return () => delete this.onMessageHandlers[messageType];
+  onMessage(_messageType, _validationSchema, _callback) {
+    const messageType = _messageType.toString();
+    const validationSchema = typeof _callback === "function" ? _validationSchema : void 0;
+    const callback = validationSchema === void 0 ? _validationSchema : _callback;
+    const removeListener = this.onMessageEvents.on(messageType, this.onUncaughtException !== void 0 ? (0, import_Utils.wrapTryCatch)(callback, this.onUncaughtException.bind(this), import_RoomExceptions.OnMessageException, "onMessage", false, _messageType) : callback);
+    if (validationSchema !== void 0) {
+      this.onMessageValidators[messageType] = validationSchema;
+    }
+    return () => {
+      removeListener();
+      if (this.onMessageEvents.events[messageType].length === 0) {
+        delete this.onMessageValidators[messageType];
+      }
+    };
+  }
+  onMessageBytes(_messageType, _validationSchema, _callback) {
+    const messageType = `_$b${_messageType}`;
+    const validationSchema = typeof _callback === "function" ? _validationSchema : void 0;
+    const callback = validationSchema === void 0 ? _validationSchema : _callback;
+    if (validationSchema !== void 0) {
+      return this.onMessage(messageType, validationSchema, callback);
+    } else {
+      return this.onMessage(messageType, callback);
+    }
   }
   /**
    * Disconnect all connected clients, and then dispose the room.
@@ -471,14 +636,14 @@ class Room {
    * @param closeCode WebSocket close code (default = 4000, which is a "consented leave")
    * @returns Promise<void>
    */
-  disconnect(closeCode = import_Protocol.Protocol.WS_CLOSE_CONSENTED) {
-    if (this._internalState === 2 /* DISPOSING */) {
+  disconnect(closeCode = import_Protocol.CloseCode.CONSENTED) {
+    if (this._internalState === RoomInternalState.DISPOSING) {
       return Promise.resolve(`disconnect() ignored: room (${this.roomId}) is already disposing.`);
-    } else if (this._internalState === 0 /* CREATING */) {
+    } else if (this._internalState === RoomInternalState.CREATING) {
       throw new Error("cannot disconnect during onCreate()");
     }
-    this._internalState = 2 /* DISPOSING */;
-    this.listing.remove();
+    this._internalState = RoomInternalState.DISPOSING;
+    import_core.matchMaker.driver.remove(this._listing.roomId);
     this.#_autoDispose = true;
     const delayedDisconnection = new Promise((resolve) => this._events.once("disconnect", () => resolve()));
     for (const [_, reconnection] of Object.values(this._reconnections)) {
@@ -487,38 +652,41 @@ class Room {
     let numClients = this.clients.length;
     if (numClients > 0) {
       while (numClients--) {
-        this._forciblyCloseClient(this.clients[numClients], closeCode);
+        this.#_forciblyCloseClient(this.clients[numClients], closeCode);
       }
     } else {
       this._events.emit("dispose");
     }
     return delayedDisconnection;
   }
-  async ["_onJoin"](client, authContext) {
+  async _onJoin(client, authContext, connectionOptions) {
     const sessionId = client.sessionId;
     client.reconnectionToken = (0, import_Utils.generateId)();
-    if (this.reservedSeatTimeouts[sessionId]) {
-      clearTimeout(this.reservedSeatTimeouts[sessionId]);
-      delete this.reservedSeatTimeouts[sessionId];
+    if (this._reservedSeatTimeouts[sessionId]) {
+      clearTimeout(this._reservedSeatTimeouts[sessionId]);
+      delete this._reservedSeatTimeouts[sessionId];
     }
     if (this._autoDisposeTimeout) {
       clearTimeout(this._autoDisposeTimeout);
       this._autoDisposeTimeout = void 0;
     }
-    const [joinOptions, authData, isConsumed, isWaitingReconnection] = this.reservedSeats[sessionId];
+    const [joinOptions, authData, isConsumed, isWaitingReconnection] = this._reservedSeats[sessionId];
     if (isConsumed) {
       throw new import_ServerError.ServerError(import_Protocol.ErrorCode.MATCHMAKE_EXPIRED, "already consumed");
     }
-    this.reservedSeats[sessionId][2] = true;
+    this._reservedSeats[sessionId][2] = true;
     (0, import_Debug.debugMatchMaking)("consuming seat reservation, sessionId: '%s' (roomId: %s)", client.sessionId, this.roomId);
     client._afterNextPatchQueue = this._afterNextPatchQueue;
     client.ref["onleave"] = (_) => client.state = import_Transport.ClientState.LEAVING;
     client.ref.once("close", client.ref["onleave"]);
     if (isWaitingReconnection) {
-      const previousReconnectionToken = this._reconnectingSessionId.get(sessionId);
-      if (previousReconnectionToken) {
+      const reconnectionToken = connectionOptions?.reconnectionToken;
+      if (reconnectionToken && this._reconnections[reconnectionToken]?.[0] === sessionId) {
         this.clients.push(client);
-        await this._reconnections[previousReconnectionToken]?.[1].resolve(client);
+        await this._reconnections[reconnectionToken]?.[1].resolve(client);
+        if (this.onReconnect) {
+          await this.onReconnect(client);
+        }
       } else {
         const errorMessage = process.env.NODE_ENV === "production" ? "already consumed" : "bad reconnection token";
         throw new import_ServerError.ServerError(import_Protocol.ErrorCode.MATCHMAKE_EXPIRED, errorMessage);
@@ -534,31 +702,31 @@ class Room {
               throw new import_ServerError.ServerError(import_Protocol.ErrorCode.AUTH_FAILED, "onAuth failed");
             }
           } catch (e) {
-            delete this.reservedSeats[sessionId];
-            await this._decrementClientCount();
+            delete this._reservedSeats[sessionId];
+            await this.#_decrementClientCount();
             throw e;
           }
         }
         if (client.state === import_Transport.ClientState.LEAVING) {
-          throw new import_ServerError.ServerError(import_Protocol.Protocol.WS_CLOSE_GOING_AWAY, "already disconnected");
+          throw new import_ServerError.ServerError(import_Protocol.CloseCode.WITH_ERROR, "already disconnected");
         }
         this.clients.push(client);
-        Object.defineProperty(this.reservedSeats, sessionId, {
-          value: this.reservedSeats[sessionId],
+        Object.defineProperty(this._reservedSeats, sessionId, {
+          value: this._reservedSeats[sessionId],
           enumerable: false
         });
         if (this.onJoin) {
-          await this.onJoin(client, joinOptions, client.auth);
+          await this.onJoin(client, joinOptions);
         }
         if (client.state === import_Transport.ClientState.LEAVING) {
-          throw new Error("early_leave");
+          throw new import_ServerError.ServerError(import_Protocol.ErrorCode.MATCHMAKE_UNHANDLED, "early_leave");
         } else {
-          delete this.reservedSeats[sessionId];
+          delete this._reservedSeats[sessionId];
           this._events.emit("join", client);
         }
       } catch (e) {
-        await this._onLeave(client, import_Protocol.Protocol.WS_CLOSE_GOING_AWAY);
-        delete this.reservedSeats[sessionId];
+        await this._onLeave(client, import_Protocol.CloseCode.WITH_ERROR);
+        delete this._reservedSeats[sessionId];
         if (!e.code) {
           e.code = import_Protocol.ErrorCode.APPLICATION_ERROR;
         }
@@ -573,7 +741,11 @@ class Room {
       client.raw(import_Protocol.getMessageBytes[import_Protocol.Protocol.JOIN_ROOM](
         client.reconnectionToken,
         this._serializer.id,
-        this._serializer.handshake && this._serializer.handshake()
+        /**
+         * if skipHandshake is true, we don't need to send the handshake
+         * (in case client already has handshake data)
+         */
+        connectionOptions?.skipHandshake ? void 0 : this._serializer.handshake && this._serializer.handshake()
       ));
     }
   }
@@ -581,11 +753,19 @@ class Room {
    * Allow the specified client to reconnect into the room. Must be used inside `onLeave()` method.
    * If seconds is provided, the reconnection is going to be cancelled after the provided amount of seconds.
    *
-   * @param previousClient - The client which is to be waiting until re-connection happens.
-   * @param seconds - Timeout period on re-connection in seconds.
+   * @param client - The client that is allowed to reconnect into the room.
+   * @param seconds - The time in seconds that the client is allowed to reconnect into the room.
    *
    * @returns Deferred<Client> - The differed is a promise like type.
    *  This type can forcibly reject the promise by calling `.reject()`.
+   *
+   * @example
+   * ```typescript
+   * onDrop(client: Client, code: CloseCode) {
+   *   // Allow the client to reconnect into the room with a 15 seconds timeout.
+   *   this.allowReconnection(client, 15);
+   * }
+   * ```
    */
   allowReconnection(previousClient, seconds) {
     if (previousClient._enqueuedMessages !== void 0) {
@@ -598,7 +778,7 @@ class Room {
     if (seconds === "manual") {
       seconds = Infinity;
     }
-    if (this._internalState === 2 /* DISPOSING */) {
+    if (this._internalState === RoomInternalState.DISPOSING) {
       return Promise.reject(new Error("disposing"));
     }
     const sessionId = previousClient.sessionId;
@@ -607,13 +787,12 @@ class Room {
     const reconnection = new import_Utils.Deferred();
     this._reconnections[reconnectionToken] = [sessionId, reconnection];
     if (seconds !== Infinity) {
-      this.reservedSeatTimeouts[sessionId] = setTimeout(() => reconnection.reject(false), seconds * 1e3);
+      this._reservedSeatTimeouts[sessionId] = setTimeout(() => reconnection.reject(false), seconds * 1e3);
     }
     const cleanup = () => {
       delete this._reconnections[reconnectionToken];
-      delete this.reservedSeats[sessionId];
-      delete this.reservedSeatTimeouts[sessionId];
-      this._reconnectingSessionId.delete(sessionId);
+      delete this._reservedSeats[sessionId];
+      delete this._reservedSeatTimeouts[sessionId];
     };
     reconnection.then((newClient) => {
       newClient.auth = previousClient.auth;
@@ -622,11 +801,11 @@ class Room {
       previousClient.state = import_Transport.ClientState.RECONNECTED;
       previousClient.ref = newClient.ref;
       previousClient.reconnectionToken = newClient.reconnectionToken;
-      clearTimeout(this.reservedSeatTimeouts[sessionId]);
-      cleanup();
-    }).catch(() => {
-      cleanup();
+      clearTimeout(this._reservedSeatTimeouts[sessionId]);
+    }, () => {
       this.resetAutoDisposeTimeout();
+    }).finally(() => {
+      cleanup();
     });
     return reconnection;
   }
@@ -637,7 +816,7 @@ class Room {
     }
     this._autoDisposeTimeout = setTimeout(() => {
       this._autoDisposeTimeout = void 0;
-      this._disposeIfEmpty();
+      this.#_disposeIfEmpty();
     }, timeoutInSeconds * 1e3);
   }
   broadcastMessageType(type, message, options = {}) {
@@ -669,36 +848,52 @@ class Room {
       this._afterNextPatchQueue.splice(0, length);
     }
   }
-  async _reserveSeat(sessionId, joinOptions = true, authData = void 0, seconds = this.seatReservationTime, allowReconnection = false, devModeReconnection) {
+  async _reserveSeat(sessionId, joinOptions = true, authData = void 0, seconds = this.seatReservationTimeout, allowReconnection = false, devModeReconnectionToken) {
     if (!allowReconnection && this.hasReachedMaxClients()) {
       return false;
     }
-    this.reservedSeats[sessionId] = [joinOptions, authData, false, allowReconnection];
+    (0, import_Debug.debugMatchMaking)(
+      "reserving seat. sessionId: '%s', roomId: '%s', processId: '%s'",
+      sessionId,
+      this.roomId,
+      import_core.matchMaker.processId
+    );
+    this._reservedSeats[sessionId] = [joinOptions, authData, false, allowReconnection];
     if (!allowReconnection) {
-      await this._incrementClientCount();
-      this.reservedSeatTimeouts[sessionId] = setTimeout(async () => {
-        delete this.reservedSeats[sessionId];
-        delete this.reservedSeatTimeouts[sessionId];
-        await this._decrementClientCount();
+      await this.#_incrementClientCount();
+      this._reservedSeatTimeouts[sessionId] = setTimeout(async () => {
+        delete this._reservedSeats[sessionId];
+        delete this._reservedSeatTimeouts[sessionId];
+        await this.#_decrementClientCount();
       }, seconds * 1e3);
       this.resetAutoDisposeTimeout(seconds);
     }
-    if (devModeReconnection) {
-      this._reconnectingSessionId.set(sessionId, sessionId);
+    if (devModeReconnectionToken) {
+      const reconnection = new import_Utils.Deferred();
+      this._reconnections[devModeReconnectionToken] = [sessionId, reconnection];
     }
     return true;
   }
-  _disposeIfEmpty() {
+  async _reserveMultipleSeats(multipleSessionIds, multipleJoinOptions = true, multipleAuthData = void 0, seconds = this.seatReservationTimeout) {
+    let promises = [];
+    for (let i = 0; i < multipleSessionIds.length; i++) {
+      promises.push(this._reserveSeat(multipleSessionIds[i], multipleJoinOptions[i], multipleAuthData[i], seconds));
+    }
+    return await Promise.all(promises);
+  }
+  #_disposeIfEmpty() {
     const willDispose = this.#_onLeaveConcurrent === 0 && // no "onLeave" calls in progress
-    this.#_autoDispose && this._autoDisposeTimeout === void 0 && this.clients.length === 0 && Object.keys(this.reservedSeats).length === 0;
+    this.#_autoDispose && this._autoDisposeTimeout === void 0 && this.clients.length === 0 && Object.keys(this._reservedSeats).length === 0;
     if (willDispose) {
       this._events.emit("dispose");
     }
     return willDispose;
   }
-  async _dispose() {
-    this._internalState = 2 /* DISPOSING */;
-    this.listing.remove();
+  async #_dispose() {
+    this._internalState = RoomInternalState.DISPOSING;
+    if (this._listing?.roomId !== void 0) {
+      await import_core.matchMaker.driver.remove(this._listing.roomId);
+    }
     let userReturnData;
     if (this.onDispose) {
       userReturnData = this.onDispose();
@@ -723,44 +918,59 @@ class Room {
     if (client.state === import_Transport.ClientState.LEAVING) {
       return;
     }
-    const it = { offset: 1 };
-    const code = buffer[0];
     if (!buffer) {
       (0, import_Debug.debugAndPrintError)(`${this.roomName} (roomId: ${this.roomId}), couldn't decode message: ${buffer}`);
       return;
     }
+    if (this.clock.currentTime - client._lastMessageTime >= 1e3) {
+      client._numMessagesLastSecond = 0;
+      client._lastMessageTime = this.clock.currentTime;
+    } else if (++client._numMessagesLastSecond > this.maxMessagesPerSecond) {
+      return this.#_forciblyCloseClient(client, import_Protocol.CloseCode.WITH_ERROR);
+    }
+    const it = { offset: 1 };
+    const code = buffer[0];
     if (code === import_Protocol.Protocol.ROOM_DATA) {
       const messageType = import_schema.decode.stringCheck(buffer, it) ? import_schema.decode.string(buffer, it) : import_schema.decode.number(buffer, it);
-      const messageTypeHandler = this.onMessageHandlers[messageType];
       let message;
       try {
         message = buffer.byteLength > it.offset ? (0, import_msgpackr.unpack)(buffer.subarray(it.offset, buffer.byteLength)) : void 0;
         (0, import_Debug.debugMessage)("received: '%s' -> %j (roomId: %s)", messageType, message, this.roomId);
-        if (messageTypeHandler?.validate !== void 0) {
-          message = messageTypeHandler.validate(message);
+        if (this.onMessageValidators[messageType] !== void 0) {
+          message = (0, import_StandardSchema.standardValidate)(this.onMessageValidators[messageType], message);
         }
       } catch (e) {
         (0, import_Debug.debugAndPrintError)(e);
-        client.leave(import_Protocol.Protocol.WS_CLOSE_WITH_ERROR);
+        client.leave(import_Protocol.CloseCode.WITH_ERROR);
         return;
       }
-      if (messageTypeHandler) {
-        messageTypeHandler.callback(client, message);
+      if (this.onMessageEvents.events[messageType]) {
+        this.onMessageEvents.emit(messageType, client, message);
+      } else if (this.onMessageEvents.events["*"]) {
+        this.onMessageEvents.emit("*", client, messageType, message);
       } else {
-        (this.onMessageHandlers["*"] || this.onMessageHandlers["__no_message_handler"]).callback(client, messageType, message);
+        this.onMessageFallbacks["__no_message_handler"](client, messageType, message);
       }
     } else if (code === import_Protocol.Protocol.ROOM_DATA_BYTES) {
       const messageType = import_schema.decode.stringCheck(buffer, it) ? import_schema.decode.string(buffer, it) : import_schema.decode.number(buffer, it);
-      const messageTypeHandler = this.onMessageHandlers[messageType];
       let message = buffer.subarray(it.offset, buffer.byteLength);
       (0, import_Debug.debugMessage)("received: '%s' -> %j (roomId: %s)", messageType, message, this.roomId);
-      if (messageTypeHandler?.validate !== void 0) {
-        message = messageTypeHandler.validate(message);
+      const bytesMessageType = `_$b${messageType}`;
+      try {
+        if (this.onMessageValidators[bytesMessageType] !== void 0) {
+          message = (0, import_StandardSchema.standardValidate)(this.onMessageValidators[bytesMessageType], message);
+        }
+      } catch (e) {
+        (0, import_Debug.debugAndPrintError)(e);
+        client.leave(import_Protocol.CloseCode.WITH_ERROR);
+        return;
       }
-      if (messageTypeHandler) {
-        messageTypeHandler.callback(client, message);
+      if (this.onMessageEvents.events[bytesMessageType]) {
+        this.onMessageEvents.emit(bytesMessageType, client, message);
+      } else if (this.onMessageEvents.events["*"]) {
+        this.onMessageEvents.emit("*", client, messageType, message);
       } else {
-        (this.onMessageHandlers["*"] || this.onMessageHandlers["__no_message_handler"]).callback(client, messageType, message);
+        this.onMessageFallbacks["__no_message_handler"](client, messageType, message);
       }
     } else if (code === import_Protocol.Protocol.JOIN_ROOM && client.state === import_Transport.ClientState.JOINING) {
       client.state = import_Transport.ClientState.JOINED;
@@ -772,58 +982,64 @@ class Room {
         client._enqueuedMessages.forEach((enqueued) => client.raw(enqueued));
       }
       delete client._enqueuedMessages;
+    } else if (code === import_Protocol.Protocol.PING) {
+      client.raw(import_Protocol.getMessageBytes[import_Protocol.Protocol.PING]());
     } else if (code === import_Protocol.Protocol.LEAVE_ROOM) {
-      this._forciblyCloseClient(client, import_Protocol.Protocol.WS_CLOSE_CONSENTED);
+      this.#_forciblyCloseClient(client, import_Protocol.CloseCode.CONSENTED);
     }
   }
-  _forciblyCloseClient(client, closeCode) {
+  #_forciblyCloseClient(client, closeCode) {
     client.ref.removeAllListeners("message");
     client.ref.removeListener("close", client.ref["onleave"]);
     this._onLeave(client, closeCode).then(() => client.leave(closeCode));
   }
   async _onLeave(client, code) {
-    (0, import_Debug.debugMatchMaking)("onLeave, sessionId: '%s' (close code: %d, roomId: %s)", client.sessionId, code, this.roomId);
     client.state = import_Transport.ClientState.LEAVING;
     if (!this.clients.delete(client)) {
       return;
     }
-    if (this.onLeave) {
+    const method = code === import_Protocol.CloseCode.CONSENTED ? this.onLeave : this.onDrop || this.onLeave;
+    if (method) {
+      (0, import_Debug.debugMatchMaking)(`${method.name}, sessionId: '%s' (close code: %d, roomId: %s)`, client.sessionId, code, this.roomId);
       try {
         this.#_onLeaveConcurrent++;
-        await this.onLeave(client, code === import_Protocol.Protocol.WS_CLOSE_CONSENTED);
+        await method.call(this, client, code);
       } catch (e) {
-        (0, import_Debug.debugAndPrintError)(`onLeave error: ${e && e.message || e || "promise rejected"} (roomId: ${this.roomId})`);
+        (0, import_Debug.debugAndPrintError)(`${method.name} error: ${e && e.message || e || "promise rejected"} (roomId: ${this.roomId})`);
       } finally {
         this.#_onLeaveConcurrent--;
       }
     }
     if (this._reconnections[client.reconnectionToken]) {
       this._reconnections[client.reconnectionToken][1].catch(async () => {
-        await this._onAfterLeave(client);
+        await this.#_onAfterLeave(client, code, method === this.onDrop);
       });
     } else if (client.state !== import_Transport.ClientState.RECONNECTED) {
-      await this._onAfterLeave(client);
+      await this.#_onAfterLeave(client, code, method === this.onDrop);
     }
   }
-  async _onAfterLeave(client) {
-    const willDispose = await this._decrementClientCount();
-    if (this.reservedSeats[client.sessionId] === void 0) {
+  async #_onAfterLeave(client, code, isDrop = false) {
+    if (isDrop && this.onLeave) {
+      await this.onLeave(client, code);
+    }
+    const willDispose = await this.#_decrementClientCount();
+    if (this._reservedSeats[client.sessionId] === void 0) {
       this._events.emit("leave", client, willDispose);
     }
   }
-  async _incrementClientCount() {
+  async #_incrementClientCount() {
     if (!this.#_locked && this.hasReachedMaxClients()) {
       this.#_maxClientsReached = true;
       this.lock.call(this, true);
     }
-    await this.listing.updateOne({
+    await import_core.matchMaker.driver.update(this._listing, {
       $inc: { clients: 1 },
       $set: { locked: this.#_locked }
     });
   }
-  async _decrementClientCount() {
-    const willDispose = this._disposeIfEmpty();
-    if (this._internalState === 2 /* DISPOSING */) {
+  async #_decrementClientCount() {
+    const willDispose = this.#_disposeIfEmpty();
+    if (this._internalState === RoomInternalState.DISPOSING) {
       return true;
     }
     if (!willDispose) {
@@ -831,7 +1047,7 @@ class Room {
         this.#_maxClientsReached = false;
         this.unlock.call(this, true);
       }
-      await this.listing.updateOne({
+      await import_core.matchMaker.driver.update(this._listing, {
         $inc: { clients: -1 },
         $set: { locked: this.#_locked }
       });
@@ -865,9 +1081,28 @@ class Room {
     }
   }
 }
+function room(options) {
+  class _ extends Room {
+    constructor() {
+      super();
+      this.messages = options.messages;
+      if (options.state && typeof options.state === "function") {
+        this.state = options.state();
+      }
+    }
+  }
+  for (const key in options) {
+    if (typeof options[key] === "function") {
+      _.prototype[key] = options[key];
+    }
+  }
+  return _;
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   DEFAULT_SEAT_RESERVATION_TIME,
   Room,
-  RoomInternalState
+  RoomInternalState,
+  room,
+  validate
 });