@colyseus/core 0.16.23 → 0.17.0

package/build/src/matchmaker/routes.d.ts

@@ -0,0 +1,92 @@
+export declare const postMatchmakeMethod: import("@colyseus/better-call").StrictEndpoint<"/matchmake/:method/:roomName", {
+    method: "POST";
+}, any>;
+export declare function getDefaultRouter(): {
+    handler: (request: Request) => Promise<Response>;
+    endpoints: {
+        postMatchmakeMethod: import("@colyseus/better-call").StrictEndpoint<"/matchmake/:method/:roomName", {
+            method: "POST";
+        }, any>;
+    };
+    extend: <NE extends Record<string, import("@colyseus/better-call").Endpoint>>(newEndpoints: NE) => {
+        handler: (request: Request) => Promise<Response>;
+        endpoints: {
+            postMatchmakeMethod: import("@colyseus/better-call").StrictEndpoint<"/matchmake/:method/:roomName", {
+                method: "POST";
+            }, any>;
+        } & NE;
+        extend: <NE_1 extends Record<string, import("@colyseus/better-call").Endpoint>>(newEndpoints: NE_1) => {
+            handler: (request: Request) => Promise<Response>;
+            endpoints: {
+                postMatchmakeMethod: import("@colyseus/better-call").StrictEndpoint<"/matchmake/:method/:roomName", {
+                    method: "POST";
+                }, any>;
+            } & NE & NE_1;
+            extend: <NE_2 extends Record<string, import("@colyseus/better-call").Endpoint>>(newEndpoints: NE_2) => {
+                handler: (request: Request) => Promise<Response>;
+                endpoints: {
+                    postMatchmakeMethod: import("@colyseus/better-call").StrictEndpoint<"/matchmake/:method/:roomName", {
+                        method: "POST";
+                    }, any>;
+                } & NE & NE_1 & NE_2;
+                extend: <NE_3 extends Record<string, import("@colyseus/better-call").Endpoint>>(newEndpoints: NE_3) => {
+                    handler: (request: Request) => Promise<Response>;
+                    endpoints: {
+                        postMatchmakeMethod: import("@colyseus/better-call").StrictEndpoint<"/matchmake/:method/:roomName", {
+                            method: "POST";
+                        }, any>;
+                    } & NE & NE_1 & NE_2 & NE_3;
+                    extend: <NE_4 extends Record<string, import("@colyseus/better-call").Endpoint>>(newEndpoints: NE_4) => {
+                        handler: (request: Request) => Promise<Response>;
+                        endpoints: {
+                            postMatchmakeMethod: import("@colyseus/better-call").StrictEndpoint<"/matchmake/:method/:roomName", {
+                                method: "POST";
+                            }, any>;
+                        } & NE & NE_1 & NE_2 & NE_3 & NE_4;
+                        extend: <NE_5 extends Record<string, import("@colyseus/better-call").Endpoint>>(newEndpoints: NE_5) => {
+                            handler: (request: Request) => Promise<Response>;
+                            endpoints: {
+                                postMatchmakeMethod: import("@colyseus/better-call").StrictEndpoint<"/matchmake/:method/:roomName", {
+                                    method: "POST";
+                                }, any>;
+                            } & NE & NE_1 & NE_2 & NE_3 & NE_4 & NE_5;
+                            extend: <NE_6 extends Record<string, import("@colyseus/better-call").Endpoint>>(newEndpoints: NE_6) => {
+                                handler: (request: Request) => Promise<Response>;
+                                endpoints: {
+                                    postMatchmakeMethod: import("@colyseus/better-call").StrictEndpoint<"/matchmake/:method/:roomName", {
+                                        method: "POST";
+                                    }, any>;
+                                } & NE & NE_1 & NE_2 & NE_3 & NE_4 & NE_5 & NE_6;
+                                extend: <NE_7 extends Record<string, import("@colyseus/better-call").Endpoint>>(newEndpoints: NE_7) => {
+                                    handler: (request: Request) => Promise<Response>;
+                                    endpoints: {
+                                        postMatchmakeMethod: import("@colyseus/better-call").StrictEndpoint<"/matchmake/:method/:roomName", {
+                                            method: "POST";
+                                        }, any>;
+                                    } & NE & NE_1 & NE_2 & NE_3 & NE_4 & NE_5 & NE_6 & NE_7;
+                                    extend: <NE_8 extends Record<string, import("@colyseus/better-call").Endpoint>>(newEndpoints: NE_8) => {
+                                        handler: (request: Request) => Promise<Response>;
+                                        endpoints: {
+                                            postMatchmakeMethod: import("@colyseus/better-call").StrictEndpoint<"/matchmake/:method/:roomName", {
+                                                method: "POST";
+                                            }, any>;
+                                        } & NE & NE_1 & NE_2 & NE_3 & NE_4 & NE_5 & NE_6 & NE_7 & NE_8;
+                                        extend: <NE_9 extends Record<string, import("@colyseus/better-call").Endpoint>>(newEndpoints: NE_9) => {
+                                            handler: (request: Request) => Promise<Response>;
+                                            endpoints: {
+                                                postMatchmakeMethod: import("@colyseus/better-call").StrictEndpoint<"/matchmake/:method/:roomName", {
+                                                    method: "POST";
+                                                }, any>;
+                                            } & NE & NE_1 & NE_2 & NE_3 & NE_4 & NE_5 & NE_6 & NE_7 & NE_8 & NE_9;
+                                            extend: <NE_10 extends Record<string, import("@colyseus/better-call").Endpoint>>(newEndpoints: NE_10) => any;
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                };
+            };
+        };
+    };
+};

package/build/{presence → src/presence}/LocalPresence.d.ts

@@ -1,5 +1,5 @@
 import { EventEmitter } from 'events';
-import { Presence } from './Presence.js';
+import type { Presence } from './Presence.ts';
 type Callback = (...args: any[]) => void;
 export declare class LocalPresence implements Presence {
     subscriptions: EventEmitter<[never]>;

package/build/{presence → src/presence}/Presence.d.ts

@@ -1,3 +1,4 @@
+import type { Room } from "../Room.ts";
 /**
  * When you need to scale your server on multiple processes and/or machines, you'd need to provide
  * the Presence option to the Server. The purpose of Presence is to allow communicating and
@@ -193,3 +194,4 @@ export interface Presence {
     setMaxListeners(number: number): void;
     shutdown(): void;
 }
+export declare function createScopedPresence(room: Room, presence: Presence): Presence;

package/build/{rooms → src/rooms}/LobbyRoom.d.ts

@@ -1,6 +1,6 @@
-import { IRoomCache } from '../matchmaker/driver/local/LocalDriver.js';
-import { Room } from '../Room.js';
-import { Client } from '../Transport.js';
+import type { IRoomCache } from '../matchmaker/LocalDriver/LocalDriver.ts';
+import type { Client } from '../Transport.ts';
+import { Room } from '../Room.ts';
 export interface FilterInput {
     name?: string;
     metadata?: any;
@@ -18,6 +18,6 @@ export declare class LobbyRoom extends Room {
     onJoin(client: Client, options: LobbyOptions): void;
     onLeave(client: Client): void;
     onDispose(): void;
-    protected filterItemsForClient(options: LobbyOptions): IRoomCache[];
+    protected filterItemsForClient(options: LobbyOptions): IRoomCache<any>[];
     protected filterItemForClient(room: IRoomCache, filter?: LobbyOptions['filter']): boolean;
 }

package/build/src/rooms/RankedQueueRoom.d.ts

@@ -0,0 +1,125 @@
+import { Room, type Client, type IRoomCache } from "@colyseus/core";
+export interface RankedQueueOptions {
+    /**
+     * number of players on each match
+     */
+    maxPlayers?: number;
+    /**
+     * name of the room to create
+     */
+    matchRoomName: string;
+    /**
+     * after these cycles, create a match with a bot
+     */
+    maxWaitingCycles?: number;
+    /**
+     * after this time, try to fit this client with a not-so-compatible group
+     */
+    maxWaitingCyclesForPriority?: number;
+    /**
+     * If set, teams must have the same size to be matched together
+     */
+    maxTeamSize?: number;
+    /**
+     * If `allowIncompleteGroups` is true, players inside an unmatched group (that
+     * did not reached `maxPlayers`, and `maxWaitingCycles` has been
+     * reached) will be matched together. Your room should fill the remaining
+     * spots with "bots" on this case.
+     */
+    allowIncompleteGroups?: boolean;
+    /**
+     * Comparison function for matching clients to groups
+     * Returns true if the client is compatible with the group
+     */
+    compare?: (client: ClientQueueData, matchGroup: MatchGroup) => boolean;
+    /**
+     *
+     * When onGroupReady is set, the "roomNameToCreate" option is ignored.
+     */
+    onGroupReady?: (this: RankedQueueRoom, group: MatchGroup) => Promise<IRoomCache>;
+}
+export interface MatchGroup {
+    averageRank: number;
+    clients: Array<Client<{
+        userData: ClientQueueData;
+    }>>;
+    ready?: boolean;
+    confirmed?: number;
+}
+export interface MatchTeam {
+    averageRank: number;
+    clients: Array<Client<{
+        userData: ClientQueueData;
+    }>>;
+    teamId: string | symbol;
+}
+export interface ClientQueueData {
+    /**
+     * Rank of the client
+     */
+    rank: number;
+    /**
+     * Timestamp of when the client entered the queue
+     */
+    currentCycle?: number;
+    /**
+     * Optional: if matching with a team, the team ID
+     */
+    teamId?: string;
+    /**
+     * Additional options passed by the client when joining the room
+     */
+    options?: any;
+    /**
+     * Match group the client is currently in
+     */
+    group?: MatchGroup;
+    /**
+     * Whether the client has confirmed the connection to the room
+     */
+    confirmed?: boolean;
+    /**
+     * Whether the client should be prioritized in the queue
+     * (e.g. for players that are waiting for a long time)
+     */
+    highPriority?: boolean;
+    /**
+     * The last number of clients in the queue sent to the client
+     */
+    lastQueueClientCount?: number;
+}
+export declare class RankedQueueRoom extends Room {
+    maxPlayers: number;
+    maxTeamSize: number;
+    allowIncompleteGroups: boolean;
+    maxWaitingCycles: number;
+    maxWaitingCyclesForPriority?: number;
+    /**
+     * Evaluate groups for each client at interval
+     */
+    cycleTickInterval: number;
+    /**
+     * Groups of players per iteration
+     */
+    groups: MatchGroup[];
+    highPriorityGroups: MatchGroup[];
+    matchRoomName: string;
+    protected compare: (client: ClientQueueData, matchGroup: MatchGroup) => boolean;
+    protected onGroupReady: (group: MatchGroup) => Promise<IRoomCache<any>>;
+    messages: {
+        confirm: (client: Client, _: unknown) => void;
+    };
+    onCreate(options: RankedQueueOptions): void;
+    onJoin(client: Client, options: any, auth?: unknown): void;
+    addToQueue(client: Client, queueData: ClientQueueData): void;
+    createMatchGroup(): MatchGroup;
+    reassignMatchGroups(): void;
+    redistributeTeams(sortedClients: Client<{
+        userData: ClientQueueData;
+    }>[]): void;
+    redistributeClients(sortedClients: Client<{
+        userData: ClientQueueData;
+    }>[], currentGroup?: MatchGroup, totalRank?: number): MatchGroup;
+    evaluateHighPriorityGroups(): void;
+    processGroupsReady(): void;
+}

package/build/{rooms → src/rooms}/RelayRoom.d.ts

@@ -1,6 +1,6 @@
 import { MapSchema, Schema } from '@colyseus/schema';
-import { Room } from '../Room.js';
-import { Client } from '../Transport.js';
+import { Room } from '../Room.ts';
+import type { Client } from '../Transport.ts';
 declare class Player extends Schema {
     connected: boolean;
     name: string;
@@ -15,7 +15,8 @@ declare class State extends Schema {
  *   allowReconnectionTime: 20
  * });
  */
-export declare class RelayRoom extends Room<State> {
+export declare class RelayRoom extends Room {
+    state: State;
     allowReconnectionTime: number;
     onCreate(options: Partial<{
         maxClients: number;
@@ -23,6 +24,6 @@ export declare class RelayRoom extends Room<State> {
         metadata: any;
     }>): void;
     onJoin(client: Client, options?: any): void;
-    onLeave(client: Client, consented: boolean): Promise<void>;
+    onLeave(client: Client, code: number): Promise<void>;
 }
 export {};

package/build/src/rooms/createRoom.d.ts

@@ -0,0 +1,65 @@
+/**
+ * Exploration: defineRoom() factory function
+ *
+ * Goal: Allow users to define rooms without explicit generic parameters,
+ * while still getting full type inference for broadcast() and client.send()
+ */
+import { Room, type Client } from "@colyseus/core";
+/**
+ * Helper type for cleaner Client typing with messages.
+ * Reduces boilerplate from `Client<{ messages: M }>` to `MessageClient<M>`.
+ *
+ * @example
+ * ```typescript
+ * type MyClient = MessageClient<{
+ *   chat: { text: string };
+ *   move: { x: number; y: number };
+ * }>;
+ * ```
+ */
+export type MessageClient<Messages extends Record<string, any>> = Client<{
+    messages: Messages;
+}>;
+/**
+ * Options for createRoom factory function.
+ */
+interface DefineRoomOptions<TClient extends Client = Client, State extends object = any, JoinOptions = any> {
+    state?: State | (() => State);
+    onCreate?(this: Room<State, any, TClient>, options: any): void | Promise<void>;
+    onJoin?(this: Room<State, any, TClient>, client: TClient, options: JoinOptions): void | Promise<void>;
+    onLeave?(this: Room<State, any, TClient>, client: TClient, code?: number): void | Promise<void>;
+    onDispose?(this: Room<State, any, TClient>): void | Promise<void>;
+}
+/**
+ * Create a Room class from an options object.
+ * Provides Vue-style object configuration with full type inference.
+ *
+ * @example
+ * ```typescript
+ * type MyClient = Client<{
+ *   userData: { rank: number };
+ *   auth: { odToken: string };
+ *   messages: {
+ *     chat: { text: string };
+ *     move: { x: number; y: number };
+ *   };
+ * }>;
+ *
+ * const MyRoom = createRoom<MyClient, MyState>({
+ *   state: () => new MyState(),
+ *
+ *   onCreate() {
+ *     console.log("Room created");
+ *   },
+ *
+ *   onJoin(client, options) {
+ *     client.send("chat", { text: "Welcome!" });  // ✅ typed!
+ *     this.broadcast("move", { x: 0, y: 0 });     // ✅ typed!
+ *     client.userData.rank;                       // ✅ typed!
+ *     client.auth.odToken;                        // ✅ typed!
+ *   }
+ * });
+ * ```
+ */
+export declare function createRoom<TClient extends Client = Client, State extends object = any, JoinOptions = any>(options: DefineRoomOptions<TClient, State, JoinOptions>): typeof Room<State, any, TClient>;
+export {};

package/build/src/router/default_routes.d.ts

@@ -0,0 +1,103 @@
+export declare const postMatchmakeMethod: import("@colyseus/better-call").StrictEndpoint<"/matchmake/:method/:roomName", {
+    method: "POST";
+}, any>;
+export declare function getDefaultRouter(): {
+    handler: (request: Request) => Promise<Response>;
+    endpoints: {
+        postMatchmakeMethod: import("@colyseus/better-call").StrictEndpoint<"/matchmake/:method/:roomName", {
+            method: "POST";
+        }, any>;
+    };
+    addEndpoint: (endpoint: import("@colyseus/better-call").Endpoint) => void;
+    extend: <NE extends Record<string, import("@colyseus/better-call").Endpoint>>(newEndpoints: NE) => {
+        handler: (request: Request) => Promise<Response>;
+        endpoints: {
+            postMatchmakeMethod: import("@colyseus/better-call").StrictEndpoint<"/matchmake/:method/:roomName", {
+                method: "POST";
+            }, any>;
+        } & NE;
+        addEndpoint: (endpoint: import("@colyseus/better-call").Endpoint) => void;
+        extend: <NE_1 extends Record<string, import("@colyseus/better-call").Endpoint>>(newEndpoints: NE_1) => {
+            handler: (request: Request) => Promise<Response>;
+            endpoints: {
+                postMatchmakeMethod: import("@colyseus/better-call").StrictEndpoint<"/matchmake/:method/:roomName", {
+                    method: "POST";
+                }, any>;
+            } & NE & NE_1;
+            addEndpoint: (endpoint: import("@colyseus/better-call").Endpoint) => void;
+            extend: <NE_2 extends Record<string, import("@colyseus/better-call").Endpoint>>(newEndpoints: NE_2) => {
+                handler: (request: Request) => Promise<Response>;
+                endpoints: {
+                    postMatchmakeMethod: import("@colyseus/better-call").StrictEndpoint<"/matchmake/:method/:roomName", {
+                        method: "POST";
+                    }, any>;
+                } & NE & NE_1 & NE_2;
+                addEndpoint: (endpoint: import("@colyseus/better-call").Endpoint) => void;
+                extend: <NE_3 extends Record<string, import("@colyseus/better-call").Endpoint>>(newEndpoints: NE_3) => {
+                    handler: (request: Request) => Promise<Response>;
+                    endpoints: {
+                        postMatchmakeMethod: import("@colyseus/better-call").StrictEndpoint<"/matchmake/:method/:roomName", {
+                            method: "POST";
+                        }, any>;
+                    } & NE & NE_1 & NE_2 & NE_3;
+                    addEndpoint: (endpoint: import("@colyseus/better-call").Endpoint) => void;
+                    extend: <NE_4 extends Record<string, import("@colyseus/better-call").Endpoint>>(newEndpoints: NE_4) => {
+                        handler: (request: Request) => Promise<Response>;
+                        endpoints: {
+                            postMatchmakeMethod: import("@colyseus/better-call").StrictEndpoint<"/matchmake/:method/:roomName", {
+                                method: "POST";
+                            }, any>;
+                        } & NE & NE_1 & NE_2 & NE_3 & NE_4;
+                        addEndpoint: (endpoint: import("@colyseus/better-call").Endpoint) => void;
+                        extend: <NE_5 extends Record<string, import("@colyseus/better-call").Endpoint>>(newEndpoints: NE_5) => {
+                            handler: (request: Request) => Promise<Response>;
+                            endpoints: {
+                                postMatchmakeMethod: import("@colyseus/better-call").StrictEndpoint<"/matchmake/:method/:roomName", {
+                                    method: "POST";
+                                }, any>;
+                            } & NE & NE_1 & NE_2 & NE_3 & NE_4 & NE_5;
+                            addEndpoint: (endpoint: import("@colyseus/better-call").Endpoint) => void;
+                            extend: <NE_6 extends Record<string, import("@colyseus/better-call").Endpoint>>(newEndpoints: NE_6) => {
+                                handler: (request: Request) => Promise<Response>;
+                                endpoints: {
+                                    postMatchmakeMethod: import("@colyseus/better-call").StrictEndpoint<"/matchmake/:method/:roomName", {
+                                        method: "POST";
+                                    }, any>;
+                                } & NE & NE_1 & NE_2 & NE_3 & NE_4 & NE_5 & NE_6;
+                                addEndpoint: (endpoint: import("@colyseus/better-call").Endpoint) => void;
+                                extend: <NE_7 extends Record<string, import("@colyseus/better-call").Endpoint>>(newEndpoints: NE_7) => {
+                                    handler: (request: Request) => Promise<Response>;
+                                    endpoints: {
+                                        postMatchmakeMethod: import("@colyseus/better-call").StrictEndpoint<"/matchmake/:method/:roomName", {
+                                            method: "POST";
+                                        }, any>;
+                                    } & NE & NE_1 & NE_2 & NE_3 & NE_4 & NE_5 & NE_6 & NE_7;
+                                    addEndpoint: (endpoint: import("@colyseus/better-call").Endpoint) => void;
+                                    extend: <NE_8 extends Record<string, import("@colyseus/better-call").Endpoint>>(newEndpoints: NE_8) => {
+                                        handler: (request: Request) => Promise<Response>;
+                                        endpoints: {
+                                            postMatchmakeMethod: import("@colyseus/better-call").StrictEndpoint<"/matchmake/:method/:roomName", {
+                                                method: "POST";
+                                            }, any>;
+                                        } & NE & NE_1 & NE_2 & NE_3 & NE_4 & NE_5 & NE_6 & NE_7 & NE_8;
+                                        addEndpoint: (endpoint: import("@colyseus/better-call").Endpoint) => void;
+                                        extend: <NE_9 extends Record<string, import("@colyseus/better-call").Endpoint>>(newEndpoints: NE_9) => {
+                                            handler: (request: Request) => Promise<Response>;
+                                            endpoints: {
+                                                postMatchmakeMethod: import("@colyseus/better-call").StrictEndpoint<"/matchmake/:method/:roomName", {
+                                                    method: "POST";
+                                                }, any>;
+                                            } & NE & NE_1 & NE_2 & NE_3 & NE_4 & NE_5 & NE_6 & NE_7 & NE_8 & NE_9;
+                                            addEndpoint: (endpoint: import("@colyseus/better-call").Endpoint) => void;
+                                            extend: <NE_10 extends Record<string, import("@colyseus/better-call").Endpoint>>(newEndpoints: NE_10) => any;
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                };
+            };
+        };
+    };
+};

package/build/src/router/index.d.ts

@@ -0,0 +1,68 @@
+import type { Server } from "http";
+import { type Endpoint, type Router, type RouterConfig } from "@colyseus/better-call";
+import { toNodeHandler } from "@colyseus/better-call/node";
+export { createEndpoint, createMiddleware, createInternalContext, } from "@colyseus/better-call";
+export { type Router, toNodeHandler };
+export declare function bindRouterToServer(server: Server, router: Router): void;
+/**
+ * Do not use this directly. This is used internally by `@colyseus/playground`.
+ * TODO: refactor. Avoid using globals.
+ * @internal
+ */
+export declare let __globalEndpoints: Record<string, Endpoint>;
+export declare function createRouter<E extends Record<string, Endpoint>, Config extends RouterConfig>(endpoints: E, config?: Config): {
+    handler: (request: Request) => Promise<Response>;
+    endpoints: E;
+    addEndpoint: (endpoint: Endpoint) => void;
+    extend: <NE extends Record<string, Endpoint>>(newEndpoints: NE) => {
+        handler: (request: Request) => Promise<Response>;
+        endpoints: E & NE;
+        addEndpoint: (endpoint: Endpoint) => void;
+        extend: <NE_1 extends Record<string, Endpoint>>(newEndpoints: NE_1) => {
+            handler: (request: Request) => Promise<Response>;
+            endpoints: E & NE & NE_1;
+            addEndpoint: (endpoint: Endpoint) => void;
+            extend: <NE_2 extends Record<string, Endpoint>>(newEndpoints: NE_2) => {
+                handler: (request: Request) => Promise<Response>;
+                endpoints: E & NE & NE_1 & NE_2;
+                addEndpoint: (endpoint: Endpoint) => void;
+                extend: <NE_3 extends Record<string, Endpoint>>(newEndpoints: NE_3) => {
+                    handler: (request: Request) => Promise<Response>;
+                    endpoints: E & NE & NE_1 & NE_2 & NE_3;
+                    addEndpoint: (endpoint: Endpoint) => void;
+                    extend: <NE_4 extends Record<string, Endpoint>>(newEndpoints: NE_4) => {
+                        handler: (request: Request) => Promise<Response>;
+                        endpoints: E & NE & NE_1 & NE_2 & NE_3 & NE_4;
+                        addEndpoint: (endpoint: Endpoint) => void;
+                        extend: <NE_5 extends Record<string, Endpoint>>(newEndpoints: NE_5) => {
+                            handler: (request: Request) => Promise<Response>;
+                            endpoints: E & NE & NE_1 & NE_2 & NE_3 & NE_4 & NE_5;
+                            addEndpoint: (endpoint: Endpoint) => void;
+                            extend: <NE_6 extends Record<string, Endpoint>>(newEndpoints: NE_6) => {
+                                handler: (request: Request) => Promise<Response>;
+                                endpoints: E & NE & NE_1 & NE_2 & NE_3 & NE_4 & NE_5 & NE_6;
+                                addEndpoint: (endpoint: Endpoint) => void;
+                                extend: <NE_7 extends Record<string, Endpoint>>(newEndpoints: NE_7) => {
+                                    handler: (request: Request) => Promise<Response>;
+                                    endpoints: E & NE & NE_1 & NE_2 & NE_3 & NE_4 & NE_5 & NE_6 & NE_7;
+                                    addEndpoint: (endpoint: Endpoint) => void;
+                                    extend: <NE_8 extends Record<string, Endpoint>>(newEndpoints: NE_8) => {
+                                        handler: (request: Request) => Promise<Response>;
+                                        endpoints: E & NE & NE_1 & NE_2 & NE_3 & NE_4 & NE_5 & NE_6 & NE_7 & NE_8;
+                                        addEndpoint: (endpoint: Endpoint) => void;
+                                        extend: <NE_9 extends Record<string, Endpoint>>(newEndpoints: NE_9) => {
+                                            handler: (request: Request) => Promise<Response>;
+                                            endpoints: E & NE & NE_1 & NE_2 & NE_3 & NE_4 & NE_5 & NE_6 & NE_7 & NE_8 & NE_9;
+                                            addEndpoint: (endpoint: Endpoint) => void;
+                                            extend: <NE_10 extends Record<string, Endpoint>>(newEndpoints: NE_10) => any;
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                };
+            };
+        };
+    };
+};

package/build/{serializer → src/serializer}/NoneSerializer.d.ts

@@ -1,5 +1,5 @@
-import { Client } from '../Transport.js';
-import { Serializer } from './Serializer.js';
+import type { Client } from '../Transport.ts';
+import type { Serializer } from './Serializer.ts';
 export declare class NoneSerializer<T = any> implements Serializer<T> {
     id: string;
     reset(data: any): void;

package/build/{serializer → src/serializer}/SchemaSerializer.d.ts

@@ -1,20 +1,20 @@
-import { Serializer } from './Serializer.js';
-import { Encoder, Schema, Iterator, StateView } from '@colyseus/schema';
-import { Client } from '../Transport.js';
+import type { Serializer } from './Serializer.ts';
+import { type Client } from '../Transport.ts';
+import { type Iterator, Encoder, Schema, StateView } from '@colyseus/schema';
 declare const SHARED_VIEW: {};
 export declare class SchemaSerializer<T extends Schema> implements Serializer<T> {
     id: string;
     protected encoder: Encoder<T>;
     protected hasFilters: boolean;
-    protected handshakeCache: Buffer;
+    protected handshakeCache: Uint8Array;
     protected needFullEncode: boolean;
-    protected fullEncodeBuffer: Buffer;
-    protected fullEncodeCache: Buffer;
+    protected fullEncodeBuffer: Uint8Array;
+    protected fullEncodeCache: Uint8Array;
     protected sharedOffsetCache: Iterator;
-    protected encodedViews: Map<StateView | typeof SHARED_VIEW, Buffer>;
+    protected encodedViews: Map<StateView | typeof SHARED_VIEW, Uint8Array>;
     reset(newState: T & Schema): void;
-    getFullState(client?: Client): Buffer<ArrayBufferLike>;
+    getFullState(client?: Client): Uint8Array<ArrayBufferLike>;
     applyPatches(clients: Client[]): boolean;
-    handshake(): Buffer<ArrayBufferLike>;
+    handshake(): Uint8Array<ArrayBufferLike>;
 }
 export {};

package/build/{serializer → src/serializer}/Serializer.d.ts

@@ -1,8 +1,8 @@
-import { Client } from '../Transport.js';
+import type { Client } from '../Transport.ts';
 export interface Serializer<T> {
     id: string;
     reset(data: any): void;
-    getFullState(client?: Client): Buffer;
+    getFullState(client?: Client): Uint8Array;
     applyPatches(clients: Client[], state: T): boolean;
-    handshake?(): Buffer;
+    handshake?(): Uint8Array;
 }

package/build/{utils → src/utils}/DevMode.d.ts

@@ -1,12 +1,13 @@
-import debug from 'debug';
-import type { Room } from '../Room.js';
-export declare const debugDevMode: debug.IDebugger;
+import type { Room } from '../Room.ts';
 export declare let isDevMode: boolean;
+export declare function hasDevModeCache(): boolean;
+export declare function getDevModeCache(): any;
+export declare function writeDevModeCache(cache: any): void;
 export declare function setDevMode(bool: boolean): void;
 export declare function reloadFromCache(): Promise<void>;
 export declare function cacheRoomHistory(rooms: {
     [roomId: string]: Room;
 }): Promise<void>;
-export declare function getPreviousProcessId(hostname: any): Promise<string>;
+export declare function getPreviousProcessId(hostname?: string): Promise<string>;
 export declare function getRoomRestoreListKey(): string;
 export declare function getProcessRestoreKey(): string;

package/build/{utils → src/utils}/StandardSchema.d.ts

@@ -1,3 +1,3 @@
-import { StandardSchemaV1 } from '@standard-schema/spec';
+import type { StandardSchemaV1 } from '@standard-schema/spec';
 export type { StandardSchemaV1 };
 export declare function standardValidate<T extends StandardSchemaV1>(schema: T, input: StandardSchemaV1.InferInput<T>): StandardSchemaV1.InferOutput<T>;

package/build/{utils → src/utils}/Utils.d.ts

@@ -1,6 +1,17 @@
 import { EventEmitter } from "events";
-import { RoomException } from '../errors/RoomExceptions.js';
-import { Type } from './types.js';
+import { type RoomException, type RoomMethodName } from '../errors/RoomExceptions.ts';
+export type Type<T> = new (...args: any[]) => T;
+export type MethodName<T> = string & {
+    [K in keyof T]: T[K] extends (...args: any[]) => any ? K : never;
+}[keyof T];
+/**
+ * Utility type that extracts the return type of a method or the type of a property
+ * from a given class/object type.
+ *
+ * - If the key is a method, returns the awaited return type of that method
+ * - If the key is a property, returns the type of that property
+ */
+export type ExtractMethodOrPropertyType<TClass, TKey extends keyof TClass> = TClass[TKey] extends (...args: any[]) => infer R ? Awaited<R> : TClass[TKey];
 export declare const REMOTE_ROOM_SHORT_TIMEOUT: number;
 export declare const MAX_CONCURRENT_CREATE_ROOM_WAIT_TIME: number;
 export declare function generateId(length?: number): string;
@@ -13,12 +24,12 @@ export declare class Deferred<T = any> {
     resolve: Function;
     reject: Function;
     constructor(promise?: Promise<T>);
-    then(func: (value: T) => any): any;
+    then(onFulfilled?: (value: T) => any, onRejected?: (reason: any) => any): Promise<any>;
     catch(func: (value: any) => any): Promise<any>;
     static reject(reason?: any): Deferred<never>;
     static resolve<T = any>(value?: T): Deferred<T>;
 }
 export declare function merge(a: any, ...objs: any[]): any;
-export declare function wrapTryCatch(method: Function, onError: (error: RoomException, methodName: string) => void, exceptionClass: Type<RoomException>, methodName: string, rethrow?: boolean, ...additionalErrorArgs: any[]): (...args: any[]) => any;
+export declare function wrapTryCatch(method: Function, onError: (error: RoomException, methodName: RoomMethodName) => void, exceptionClass: Type<RoomException>, methodName: RoomMethodName, rethrow?: boolean, ...additionalErrorArgs: any[]): (...args: any[]) => any;
 export declare class HttpServerMock extends EventEmitter {
 }