@colyseus/core 0.18.18 → 0.18.20

package/src/Room.ts

@@ -451,13 +451,6 @@ export class Room<T extends RoomOptions = RoomOptions> {
         .catch((e) => debugAndPrintError(`onDispose error: ${(e && e.stack || e.message || e || 'promise rejected')} (roomId: ${this.roomId})`))
         .finally(() => this._events.emit('disconnect'));
     });
-
-    /**
-     * If `onUncaughtException` is defined, it will automatically catch exceptions
-     */
-    if (this.onUncaughtException !== undefined) {
-      this.#registerUncaughtExceptionHandlers();
-    }
   }
 
   /**
@@ -592,6 +585,12 @@ export class Room<T extends RoomOptions = RoomOptions> {
       setupRoomPlugins(this);
     }
 
+    // After setupRoomPlugins(), so the try/catch covers plugin hooks too.
+    // Not in the constructor: subclass fields aren't assigned until it returns.
+    if (this.onUncaughtException !== undefined) {
+      this.#registerUncaughtExceptionHandlers();
+    }
+
     // Bind messages to the room
     if (this.messages !== undefined) {
 
@@ -2487,7 +2486,8 @@ export class Room<T extends RoomOptions = RoomOptions> {
       this.onCreate = wrapTryCatch(this.onCreate.bind(this), onUncaughtException, OnCreateException, 'onCreate', true);
     }
 
-    if (this.onAuth !== undefined) {
+    // _onJoin skips onAuth only while it's still Room's default
+    if (this.onAuth !== Room.prototype.onAuth) {
       this.onAuth = wrapTryCatch(this.onAuth.bind(this), onUncaughtException, OnAuthException, 'onAuth', true);
     }
 

package/src/RoomPlugin.ts

@@ -435,31 +435,52 @@ export function installPluginHookWrappers(
   for (const hook of PLUGIN_LIFECYCLE_KEYS) {
     const { before, after } = layout.hooks[hook];
     if (before.length === 0 && after.length === 0) { continue; }
+    proto[hook] = composePluginHook(hook, before, after, proto[hook]);
+  }
+}
 
-    const original = proto[hook] as Function | undefined;
-    proto[hook] = async function (
-      this: { plugins?: Record<string, RoomPlugin>; _autoPlugins?: Record<string, RoomPlugin> },
-      ...args: any[]
-    ) {
-      // User plugins live on `this.plugins`, auto-deps (sentinel-keyed)
-      // on `this._autoPlugins` — kept separate so user types stay clean.
-      const lookup = (k: string): RoomPlugin =>
-        (k.startsWith(DEP_KEY_PREFIX) ? this._autoPlugins![k] : this.plugins![k]);
-      for (const k of before) {
-        const p = lookup(k);
-        await (p[hook] as Function).call(p, ...args);
-      }
-      let result: unknown;
-      if (original) { result = await original.apply(this, args); }
-      for (const k of after) {
-        const p = lookup(k);
-        await (p[hook] as Function).call(p, ...args);
-      }
-      return result;
-    };
+/**
+ * Hooks declared as class fields (`onJoin = () => {}`) are own properties
+ * that shadow the prototype wrapper, so wrap them per instance.
+ */
+function wrapOwnHooks(room: RoomPluginHost, layout: PluginLayout): void {
+  for (const hook of PLUGIN_LIFECYCLE_KEYS) {
+    const { before, after } = layout.hooks[hook];
+    if (before.length === 0 && after.length === 0) { continue; }
+    if (!Object.hasOwn(room, hook)) { continue; }
+    (room as any)[hook] = composePluginHook(hook, before, after, (room as any)[hook]);
   }
 }
 
+/** Run the `before` plugins, then `original`, then the `after` plugins. */
+function composePluginHook(
+  hook: PluginLifecycleKey,
+  before: string[],
+  after: string[],
+  original: Function | undefined,
+) {
+  return async function (
+    this: { plugins?: Record<string, RoomPlugin>; _autoPlugins?: Record<string, RoomPlugin> },
+    ...args: any[]
+  ) {
+    // User plugins live on `this.plugins`, auto-deps (sentinel-keyed)
+    // on `this._autoPlugins` — kept separate so user types stay clean.
+    const lookup = (k: string): RoomPlugin =>
+      (k.startsWith(DEP_KEY_PREFIX) ? this._autoPlugins![k] : this.plugins![k]);
+    for (const k of before) {
+      const p = lookup(k);
+      await (p[hook] as Function).call(p, ...args);
+    }
+    let result: unknown;
+    if (original) { result = await original.apply(this, args); }
+    for (const k of after) {
+      const p = lookup(k);
+      await (p[hook] as Function).call(p, ...args);
+    }
+    return result;
+  };
+}
+
 /** Structural shape used by `setupRoomPlugins` — avoids a Room import
  *  so the dependency graph stays one-way (Room → RoomPlugin). */
 interface RoomPluginHost {
@@ -483,6 +504,10 @@ export function setupRoomPlugins(room: RoomPluginHost): void {
 
   attachRoomReference(room, plugins);
 
+  if (layout) {
+    wrapOwnHooks(room, layout);
+  }
+
   if (layout && layout.autoDeps.length > 0) {
     room._autoPlugins = instantiateAutoDeps(room, layout);
   }

package/src/Transport.ts

@@ -252,7 +252,18 @@ export interface Client<T extends { userData?: any, auth?: any, messages?: Recor
   reconnectionToken: string;
 
   // TODO: move these to ClientPrivate
+  /**
+   * Send raw bytes over the transport's reliable channel.
+   *
+   * The transport owns `data` from this call on: it may write it later (a
+   * socket with backpressure, permessage-deflate), so callers never mutate it
+   * afterwards. The same `data` may be handed to several clients.
+   */
   raw(data: Uint8Array | Buffer, options?: ISendOptions, cb?: (err?: Error) => void): void;
+  /**
+   * {@link raw}, or held until the client finishes joining (or until after the
+   * next patch, with `afterNextPatch`). Owns `data` the same way {@link raw} does.
+   */
   enqueueRaw(data: Uint8Array | Buffer, options?: ISendOptions): void;
 
   /**
@@ -262,6 +273,10 @@ export interface Client<T extends { userData?: any, auth?: any, messages?: Recor
    * Absent on transports with no datagram channel (every WebSocket transport).
    * Its presence IS the capability check — callers feature-detect rather than
    * reading a separate flag, and skip clients that can't receive.
+   *
+   * Unlike {@link raw}, `data` is only valid during this call: the caller
+   * reuses its bytes afterwards, so a transport that sends it later copies it
+   * first.
    */
   rawUnreliable?(data: Uint8Array | Buffer, options?: ISendOptions, cb?: (err?: Error) => void): void;
 

package/src/serializer/SchemaSerializer.ts

@@ -81,6 +81,18 @@ function sendClientFrame(client: Client, encodedBody: Uint8Array, timing?: Patch
   }
 }
 
+/**
+ * Detach an untimed patch from the encoder's shared buffer: the transport may
+ * still hold it when the next encode reuses that buffer (see {@link Client.raw}).
+ * Timed frames skip this — {@link buildTimedFrame} already copies per client.
+ */
+function ownedPatch(encoded: Uint8Array, timing?: PatchTimingContext): Uint8Array {
+  return timing ? encoded : Buffer.from(encoded);
+}
+
+/** Empty quiet-tick patch body; sent only timed, so sharing it is safe. */
+const HEARTBEAT_BODY = new Uint8Array([Protocol.ROOM_STATE_PATCH]);
+
 /**
  * Size of the {@link ProtocolModifier.UNRELIABLE} header that follows the
  * protocol byte: `[uint16 seq]`. See {@link ProtocolModifier.UNRELIABLE} for
@@ -126,10 +138,7 @@ export class SchemaSerializer<T extends Schema> implements Serializer<T> {
   // flag to avoid re-encoding full state if no changes were made
   protected needFullEncode: boolean = true;
 
-  // TODO: make this optional. allocating a new buffer for each room may not be always necessary.
-  protected fullEncodeBuffer: Uint8Array = new Uint8Array(Encoder.BUFFER_SIZE);
   protected fullEncodeCache: Uint8Array;
-  protected sharedOffsetCache: Iterator = { offset: 0 };
 
   protected encodedViews: Map<StateView | typeof SHARED_VIEW, Uint8Array>;
 
@@ -150,8 +159,7 @@ export class SchemaSerializer<T extends Schema> implements Serializer<T> {
     this.hasFilters = this.encoder.context.hasFilters;
     this.hasUnreliableFields = stateHasUnreliableFields(this.encoder.context);
 
-    // cache ROOM_STATE byte as part of the encoded buffer
-    this.fullEncodeBuffer[0] = Protocol.ROOM_STATE;
+    this.needFullEncode = true; // the cached full state belongs to the previous encoder
 
     if (this.hasFilters) {
       this.encodedViews = new Map();
@@ -166,19 +174,17 @@ export class SchemaSerializer<T extends Schema> implements Serializer<T> {
 
   public getFullState(client?: Client, timing?: PatchTimingContext) {
     if (this.needFullEncode || this.encoder.root.changes.next !== undefined) {
-      this.sharedOffsetCache = { offset: 1 };
-      this.fullEncodeCache = this.encoder.encodeAll(this.sharedOffsetCache, this.fullEncodeBuffer);
+      this.encoder.sharedBuffer[0] = Protocol.ROOM_STATE;
+      // copy: the next encode reuses the shared buffer (slice(): a pooled Buffer would pin 8KB)
+      this.fullEncodeCache = this.encoder.encodeAll({ offset: 1 }).slice();
       this.needFullEncode = false;
     }
 
-    const body = (this.hasFilters && client?.view)
-      ? this.encoder.encodeAllView(
-          client.view,
-          this.sharedOffsetCache.offset,
-          { ...this.sharedOffsetCache },
-          this.fullEncodeBuffer
-        )
-      : this.fullEncodeCache;
+    let body = this.fullEncodeCache;
+    if (this.hasFilters && client?.view) {
+      this.encoder.sharedBuffer.set(body); // patches since the full encode may have overwritten it
+      body = this.encoder.encodeAllView(client.view, body.byteLength, { offset: body.byteLength });
+    }
 
     if (timing && client) {
       return buildTimedFrame(body, timing.sNow, clientProcessedInputSeq(client));
@@ -232,11 +238,10 @@ export class SchemaSerializer<T extends Schema> implements Serializer<T> {
       // body — 1 byte protocol + 8 bytes prefix.
       // No-op for rooms without `defineInput()` (timing is undefined).
       if (timing) {
-        const heartbeatBody = Buffer.from([Protocol.ROOM_STATE_PATCH]);
         for (let i = 0; i < clients.length; i++) {
           const client = clients[i];
           if (client.state !== ClientState.JOINED) continue;
-          sendClientFrame(client, heartbeatBody, timing);
+          sendClientFrame(client, HEARTBEAT_BODY, timing);
         }
       }
 
@@ -262,6 +267,8 @@ export class SchemaSerializer<T extends Schema> implements Serializer<T> {
     const encodedChanges = this.encoder.encode(it);
 
     if (!this.hasFilters) {
+      const frame = ownedPatch(encodedChanges, timing);
+
       while (numClients--) {
         const client = clients[numClients];
 
@@ -272,7 +279,7 @@ export class SchemaSerializer<T extends Schema> implements Serializer<T> {
           continue;
         }
 
-        sendClientFrame(client, encodedChanges, timing);
+        sendClientFrame(client, frame, timing);
       }
 
     } else {
@@ -297,7 +304,7 @@ export class SchemaSerializer<T extends Schema> implements Serializer<T> {
         // allow to pass the same encoded view for multiple clients
         if (encodedView === undefined) {
           encodedView = (view === SHARED_VIEW)
-            ? encodedChanges
+            ? ownedPatch(encodedChanges, timing) // encodeView already returns a copy
             : this.encoder.encodeView(client.view, sharedOffset, it);
           this.encodedViews.set(view, encodedView);
         }