@colyseus/core 0.18.17 → 0.18.18

package/build/Room.mjs

@@ -40,6 +40,7 @@ var NOOP = () => {
 };
 var noneSerializer = new NoneSerializer();
 var AFTER_PATCH_OPTS = Object.freeze({ afterNextPatch: true });
+var ROOM_ACCESSORS = ["state", "maxClients", "autoDispose", "patchRate", "unreliablePatchRate"];
 var DEFAULT_SEAT_RESERVATION_TIME = Number(process.env.COLYSEUS_SEAT_RESERVATION_TIME || 15);
 function validate(format, handler) {
   return { format, handler };
@@ -57,53 +58,10 @@ var Room = class _Room {
      */
     this.clock = new Clock();
     this.#_onLeaveConcurrent = 0;
-    // number of onLeave calls in progress
-    /**
-     * Maximum number of clients allowed to connect into the room. When room reaches this limit,
-     * it is locked automatically. Unless the room was explicitly locked by you via `lock()` method,
-     * the room will be unlocked as soon as a client disconnects from it.
-     */
-    this.maxClients = Infinity;
     this.#_maxClientsReached = false;
-    /**
-     * Automatically dispose the room when last client disconnects.
-     *
-     * @default true
-     */
-    this.autoDispose = true;
-    /**
-     * Frequency to send the room state to connected clients, in milliseconds.
-     *
-     * @default 50ms (20fps)
-     */
-    this.patchRate = DEFAULT_PATCH_RATE;
-    /**
-     * Frequency to flush `@unreliable` state fields, in milliseconds.
-     *
-     * Those fields never ride a state patch — they go out over the transport's
-     * unreliable channel (a WebTransport datagram), so a dropped frame costs one
-     * stale value instead of stalling the reliable stream behind a retransmit.
-     * Setting this decouples them from {@link patchRate}, which is the point:
-     * 60Hz movement over a 20Hz structural patch.
-     *
-     * KNOWN COST of a rate faster than {@link patchRate}: an entity's ADD travels
-     * the reliable channel, so datagrams sent between patches can reference a
-     * refId the client hasn't been told about yet. Those frames are skipped by the
-     * client's decoder — safe (the ref graph can't desync, since `@unreliable` is
-     * primitives-only) but each one logs `"refId" not found`, and that entity's
-     * first value lands one mutation later. Measured at `patchRate/this` reports
-     * per mid-session spawn. Leave this unset and the flush rides
-     * {@link broadcastPatch}, which ships the ADD first and avoids it entirely.
-     *
-     * Requires a transport with a datagram channel — today only
-     * `@colyseus/h3-transport` (WebTransport), which is **experimental**. Every
-     * WebSocket transport lacks one, and those clients are skipped entirely (the
-     * room warns once), so `@unreliable` fields keep their join-time value there.
-     *
-     * @default null — flush alongside every {@link broadcastPatch}, and only when
-     * the state actually declares an `@unreliable` field.
-     */
-    this.unreliablePatchRate = null;
+    this.#_maxClients = Infinity;
+    this.#_autoDispose = true;
+    this.#_patchRate = DEFAULT_PATCH_RATE;
     this.#_unreliablePatchRate = null;
     /**
      * The unreliable flush, called unconditionally at the end of every
@@ -120,6 +78,8 @@ var Room = class _Room {
      * @default Infinity
      */
     this.maxMessagesPerSecond = Infinity;
+    /** Until `__init()`, the prototype accessor setters only store the value. */
+    this.#_ready = false;
     /**
      * The array of connected clients.
      *
@@ -210,6 +170,7 @@ var Room = class _Room {
   #_unreliablePatchRate;
   #_unreliablePatchInterval;
   #_state;
+  #_ready;
   #_messages;
   // Re-expose the registry for @colyseus/playground introspection and
   // @colyseus/testing handler-swapping (both reach in via bracket access).
@@ -222,21 +183,19 @@ var Room = class _Room {
   #pendingFrameClients;
   #afterPatchBroadcasts;
   #_locked;
-  /**
-   * This method is called by the MatchMaker before onCreate()
-   * @internal
-   */
-  __init() {
-    this.#_state = this.state;
-    this.#_autoDispose = this.autoDispose;
-    this.#_patchRate = this.patchRate;
-    this.#_unreliablePatchRate = this.unreliablePatchRate;
-    this.#_maxClients = this.maxClients;
-    Object.defineProperties(this, {
+  static {
+    Object.defineProperties(this.prototype, {
       state: {
         enumerable: true,
-        get: () => this.#_state,
-        set: (newState) => {
+        configurable: true,
+        get() {
+          return this.#_state;
+        },
+        set(newState) {
+          if (!this.#_ready) {
+            this.#_state = newState;
+            return;
+          }
           if (newState?.constructor[Symbol.metadata] !== void 0 || newState[$changes] !== void 0) {
             this.setSerializer(new SchemaSerializer());
           } else if ("_definition" in newState) {
@@ -251,15 +210,29 @@ var Room = class _Room {
       },
       maxClients: {
         enumerable: true,
-        get: () => this.#_maxClients,
-        set: (value) => {
+        configurable: true,
+        get() {
+          return this.#_maxClients;
+        },
+        set(value) {
+          if (!this.#_ready) {
+            this.#_maxClients = value;
+            return;
+          }
           this.setMatchmaking({ maxClients: value });
         }
       },
       autoDispose: {
         enumerable: true,
-        get: () => this.#_autoDispose,
-        set: (value) => {
+        configurable: true,
+        get() {
+          return this.#_autoDispose;
+        },
+        set(value) {
+          if (!this.#_ready) {
+            this.#_autoDispose = value;
+            return;
+          }
           if (value !== this.#_autoDispose && this._internalState !== RoomInternalState.DISPOSING) {
             this.#_autoDispose = value;
             this.resetAutoDisposeTimeout();
@@ -268,9 +241,15 @@ var Room = class _Room {
       },
       patchRate: {
         enumerable: true,
-        get: () => this.#_patchRate,
-        set: (milliseconds) => {
+        configurable: true,
+        get() {
+          return this.#_patchRate;
+        },
+        set(milliseconds) {
           this.#_patchRate = milliseconds;
+          if (!this.#_ready) {
+            return;
+          }
           if (this.#_patchInterval) {
             clearInterval(this.#_patchInterval);
             this.#_patchInterval = void 0;
@@ -284,13 +263,35 @@ var Room = class _Room {
       },
       unreliablePatchRate: {
         enumerable: true,
-        get: () => this.#_unreliablePatchRate,
-        set: (milliseconds) => {
+        configurable: true,
+        get() {
+          return this.#_unreliablePatchRate;
+        },
+        set(milliseconds) {
           this.#_unreliablePatchRate = milliseconds;
+          if (!this.#_ready) {
+            return;
+          }
           this._armUnreliablePatches();
         }
       }
     });
+  }
+  /**
+   * This method is called by the MatchMaker before onCreate()
+   * @internal
+   */
+  __init() {
+    for (let i = 0; i < ROOM_ACCESSORS.length; i++) {
+      const key = ROOM_ACCESSORS[i];
+      if (!Object.hasOwn(this, key)) {
+        continue;
+      }
+      const value = this[key];
+      Object.defineProperty(this, key, Object.getOwnPropertyDescriptor(_Room.prototype, key));
+      this[key] = value;
+    }
+    this.#_ready = true;
     this.patchRate = this.#_patchRate;
     if (this.#_state) {
       this.state = this.#_state;
@@ -1424,7 +1425,7 @@ var Room = class _Room {
       if (client._enqueuedMessages.length > 0) {
         client._enqueuedMessages.forEach((enqueued) => client.raw(enqueued));
       }
-      delete client._enqueuedMessages;
+      client._enqueuedMessages = void 0;
     } else if (code === Protocol.PING) {
       client.raw(getMessageBytes[Protocol.PING]());
     } else if (code === Protocol.LEAVE_ROOM) {