@pluv/client 1.0.0 → 1.0.2

package/src/MockedRoom.ts

@@ -86,8 +86,13 @@ export class MockedRoom<
             presenceMaxSize: MAX_PRESENCE_SIZE_BYTES,
             ...limits,
         };
-        this._router = router ?? (new PluvRouter({}) as PluvRouter<TIO, TPresence, TStorage, TEvents>);
-        this._usersManager = new UsersManager<TIO, TPresence>({ initialPresence, limits: this._limits, presence });
+        this._router =
+            router ?? (new PluvRouter({}) as PluvRouter<TIO, TPresence, TStorage, TEvents>);
+        this._usersManager = new UsersManager<TIO, TPresence>({
+            initialPresence,
+            limits: this._limits,
+            presence,
+        });
 
         this._crdtManager = new CrdtManager<TStorage>({
             initialStorage,
@@ -136,10 +141,9 @@ export class MockedRoom<
                 user: myself,
             };
 
-            const output = await (procedure.config.broadcast as EventResolver<TIO, any, any, TPresence, TStorage>)(
-                parsed,
-                context,
-            );
+            const output = await (
+                procedure.config.broadcast as EventResolver<TIO, any, any, TPresence, TStorage>
+            )(parsed, context);
 
             Object.entries(output).forEach(([_type, _data]) => {
                 this._simulateEvent(_type as TEvent, _data as any);
@@ -147,7 +151,9 @@ export class MockedRoom<
         },
         {
             get(fn, prop) {
-                return async (data: Id<InferIOInput<MergeEvents<TEvents, TIO>>[any]>): Promise<void> => {
+                return async (
+                    data: Id<InferIOInput<MergeEvents<TEvents, TIO>>[any]>,
+                ): Promise<void> => {
                     return await fn(prop, data);
                 };
             },
@@ -174,8 +180,9 @@ export class MockedRoom<
         ): (() => void) => this._eventNotifier.subscribe(event, callback),
         {
             get(fn, prop) {
-                return (callback: EventNotifierSubscriptionCallback<MergeEvents<TEvents, TIO>, any>): (() => void) =>
-                    fn(prop as any, callback);
+                return (
+                    callback: EventNotifierSubscriptionCallback<MergeEvents<TEvents, TIO>, any>,
+                ): (() => void) => fn(prop as any, callback);
             },
         },
     ) as (<TEvent extends keyof InferIOOutput<MergeEvents<TEvents, TIO>>>(
@@ -221,7 +228,9 @@ export class MockedRoom<
     };
 
     public getStorageJson(): InferCrdtJson<TStorage> | null;
-    public getStorageJson<TKey extends keyof TStorage>(type: TKey): InferCrdtJson<TStorage[TKey]> | null;
+    public getStorageJson<TKey extends keyof TStorage>(
+        type: TKey,
+    ): InferCrdtJson<TStorage[TKey]> | null;
     public getStorageJson<TKey extends keyof TStorage>(type?: TKey) {
         if (this._state.connection.id === null) return null;
 
@@ -293,7 +302,8 @@ export class MockedRoom<
     };
 
     public updateMyPresence = (presence: UpdateMyPresenceAction<TPresence>): void => {
-        const newPresence = typeof presence === "function" ? presence(this.getMyPresence()) : presence;
+        const newPresence =
+            typeof presence === "function" ? presence(this.getMyPresence()) : presence;
 
         this._usersManager.updateMyPresence(newPresence);
 

package/src/OtherNotifier.ts

@@ -8,7 +8,10 @@ export type OtherNotifierSubscriptionCallback<TIO extends IOLike, TPresence exte
 ) => void;
 
 export class OtherNotifier<TIO extends IOLike, TPresence extends JsonObject = {}> {
-    private _subjects = new Map<[clientId: string][0], Subject<Id<UserInfo<TIO, TPresence>> | null>>();
+    private _subjects = new Map<
+        [clientId: string][0],
+        Subject<Id<UserInfo<TIO, TPresence>> | null>
+    >();
 
     public clear(): void {
         this._subjects.forEach((subject) => {
@@ -35,7 +38,10 @@ export class OtherNotifier<TIO extends IOLike, TPresence extends JsonObject = {}
         return newSubject;
     }
 
-    public subscribe(clientId: string, callback: OtherNotifierSubscriptionCallback<TIO, TPresence>): () => void {
+    public subscribe(
+        clientId: string,
+        callback: OtherNotifierSubscriptionCallback<TIO, TPresence>,
+    ): () => void {
         const source = this.subject(clientId).source;
 
         return subscribe(callback)(source).unsubscribe;

package/src/PluvClient.ts

@@ -158,7 +158,9 @@ export class PluvClient<
     };
 
     public getRoom = (room: string): PluvRoom<TIO, TMetadata, TPresence, TStorage, any> | null => {
-        const found = this._rooms.get(room) as PluvRoom<TIO, TMetadata, TPresence, TStorage, any> | undefined;
+        const found = this._rooms.get(room) as
+            | PluvRoom<TIO, TMetadata, TPresence, TStorage, any>
+            | undefined;
 
         return found ?? null;
     };

package/src/PluvProcedure.ts

@@ -21,7 +21,8 @@ export class PluvProcedure<
     TStorage extends Record<string, CrdtType<any, any>> = {},
     TFilled extends "input" | "broadcast" | "" = "",
 > {
-    private _broadcast: EventResolver<TIO, TInput, Partial<TOutput>, TPresence, TStorage> | null = null;
+    private _broadcast: EventResolver<TIO, TInput, Partial<TOutput>, TPresence, TStorage> | null =
+        null;
     private _input: InputZodLike<TInput> | null = null;
 
     public get config(): ProcedureLike<TInput, TOutput>["config"] {
@@ -71,7 +72,10 @@ export class PluvProcedure<
 
     public input<TData extends JsonObject>(
         input: InputZodLike<TData>,
-    ): Omit<PluvProcedure<TIO, TData, {}, TPresence, TStorage, TFilled | "input">, TFilled | "input"> {
+    ): Omit<
+        PluvProcedure<TIO, TData, {}, TPresence, TStorage, TFilled | "input">,
+        TFilled | "input"
+    > {
         return new PluvProcedure<TIO, TData, {}, TPresence, TStorage, TFilled | "input">({ input });
     }
 

package/src/PluvRoom.ts

@@ -109,7 +109,9 @@ export type AuthEndpoint<TMetadata extends JsonObject> =
     | string
     | ((params: EndpointParams<TMetadata>) => string | FetchOptions)
     | true;
-export type WsEndpoint<TMetadata extends JsonObject> = string | ((params: EndpointParams<TMetadata>) => string);
+export type WsEndpoint<TMetadata extends JsonObject> =
+    | string
+    | ((params: EndpointParams<TMetadata>) => string);
 
 type FetchOptions = { url: string; options?: RequestInit };
 
@@ -128,7 +130,9 @@ export type PluvRoomAddon<
     TMetadata extends JsonObject = {},
     TPresence extends JsonObject = {},
     TStorage extends Record<string, CrdtType<any, any>> = {},
-> = (input: PluvRoomAddonInput<TIO, TMetadata, TPresence, TStorage>) => Partial<PluvRoomAddonResult>;
+> = (
+    input: PluvRoomAddonInput<TIO, TMetadata, TPresence, TStorage>,
+) => Partial<PluvRoomAddonResult>;
 
 export interface PluvRoomAddonInput<
     TIO extends IOLike = IOLike,
@@ -276,8 +280,13 @@ export class PluvRoom<
             },
         };
 
-        this._router = router ?? (new PluvRouter({}) as PluvRouter<TIO, TPresence, TStorage, TEvents>);
-        this._usersManager = new UsersManager<TIO, TPresence>({ initialPresence, limits: this._limits, presence });
+        this._router =
+            router ?? (new PluvRouter({}) as PluvRouter<TIO, TPresence, TStorage, TEvents>);
+        this._usersManager = new UsersManager<TIO, TPresence>({
+            initialPresence,
+            limits: this._limits,
+            presence,
+        });
         this._crdtManager = new CrdtManager<TStorage>({ initialStorage });
     }
 
@@ -325,10 +334,9 @@ export class PluvRoom<
                 user: myself,
             };
 
-            const output = await (procedure.config.broadcast as EventResolver<TIO, any, any, TPresence, TStorage>)(
-                parsed,
-                context,
-            );
+            const output = await (
+                procedure.config.broadcast as EventResolver<TIO, any, any, TPresence, TStorage>
+            )(parsed, context);
 
             Object.entries(output).forEach(([_type, _data]) => {
                 this._sendMessage({ data: _data, type: _type });
@@ -336,7 +344,9 @@ export class PluvRoom<
         },
         {
             get(fn, prop) {
-                return async (data: Id<InferIOInput<MergeEvents<TEvents, TIO>>[any]>): Promise<void> => {
+                return async (
+                    data: Id<InferIOInput<MergeEvents<TEvents, TIO>>[any]>,
+                ): Promise<void> => {
                     return await fn(prop, data);
                 };
             },
@@ -364,9 +374,11 @@ export class PluvRoom<
 
         this._setMetadata(metadata);
 
-        const canConnect = [ConnectionState.Closed, ConnectionState.Unavailable, ConnectionState.Untouched].some(
-            (state) => this._state.connection.state === state,
-        );
+        const canConnect = [
+            ConnectionState.Closed,
+            ConnectionState.Unavailable,
+            ConnectionState.Untouched,
+        ].some((state) => this._state.connection.state === state);
 
         if (!canConnect) return;
 
@@ -378,7 +390,6 @@ export class PluvRoom<
         });
 
         await this._storageStore.initialize();
-        await this._applyStorageStore();
 
         const wsEndpoint = this._getWsEndpoint(this.id, params);
         const url = new URL(wsEndpoint);
@@ -453,8 +464,9 @@ export class PluvRoom<
         ): (() => void) => this._eventNotifier.subscribe(event, callback),
         {
             get(fn, prop) {
-                return (callback: EventNotifierSubscriptionCallback<MergeEvents<TEvents, TIO>, any>): (() => void) =>
-                    fn(prop as any, callback);
+                return (
+                    callback: EventNotifierSubscriptionCallback<MergeEvents<TEvents, TIO>, any>,
+                ): (() => void) => fn(prop as any, callback);
             },
         },
     ) as (<TEvent extends keyof InferIOOutput<MergeEvents<TEvents, TIO>>>(
@@ -500,7 +512,9 @@ export class PluvRoom<
     };
 
     public getStorageJson(): InferCrdtJson<TStorage> | null;
-    public getStorageJson<TKey extends keyof TStorage>(type: TKey): InferCrdtJson<TStorage[TKey]> | null;
+    public getStorageJson<TKey extends keyof TStorage>(
+        type: TKey,
+    ): InferCrdtJson<TStorage[TKey]> | null;
     public getStorageJson<TKey extends keyof TStorage>(type?: TKey) {
         if (this._state.connection.id === null) return null;
 
@@ -574,7 +588,8 @@ export class PluvRoom<
     };
 
     public updateMyPresence = (presence: UpdateMyPresenceAction<TPresence>): void => {
-        const newPresence = typeof presence === "function" ? presence(this.getMyPresence()) : presence;
+        const newPresence =
+            typeof presence === "function" ? presence(this.getMyPresence()) : presence;
 
         this._usersManager.updateMyPresence(newPresence);
 
@@ -596,22 +611,6 @@ export class PluvRoom<
         this._flattenStorageStore();
     }
 
-    private async _applyStorageStore(): Promise<void> {
-        const updates = await this._storageStore.getUpdates();
-
-        this._crdtManager.initialize({
-            onInitialized: () => {
-                this._stateNotifier.subjects["storage-loaded"].next(true);
-
-                this._observeCrdt();
-            },
-            origin: ORIGIN_INITIALIZED,
-            update: updates,
-        });
-
-        this._emitSharedTypes();
-    }
-
     private _attachWindowListeners(): void {
         if (typeof window === "undefined") return;
         if (typeof document === "undefined") return;
@@ -722,7 +721,7 @@ export class PluvRoom<
 
             const updates = await this._storageStore.getUpdates();
 
-            this._crdtManager.applyUpdate(updates, this);
+            this._crdtManager.applyUpdate({ update: updates, origin: this });
 
             const encodedState = this._crdtManager.doc.getEncodedState();
 
@@ -743,7 +742,10 @@ export class PluvRoom<
         );
     };
 
-    private _getAuthFetchOptions(room: string, params: GetAuthEndpointParams<TMetadata>): FetchOptions | null {
+    private _getAuthFetchOptions(
+        room: string,
+        params: GetAuthEndpointParams<TMetadata>,
+    ): FetchOptions | null {
         const metadata = params.metadata as TMetadata;
 
         if (typeof this._endpoints.authEndpoint === "undefined") return null;
@@ -767,7 +769,10 @@ export class PluvRoom<
         return typeof result === "string" ? { url: result, options: {} } : result;
     }
 
-    private async _getAuthorization(room: string, params: GetAuthEndpointParams<TMetadata>): Promise<string | null> {
+    private async _getAuthorization(
+        room: string,
+        params: GetAuthEndpointParams<TMetadata>,
+    ): Promise<string | null> {
         const fetchOptions = this._getAuthFetchOptions(room, params);
 
         if (!fetchOptions) return null;
@@ -798,7 +803,9 @@ export class PluvRoom<
 
         switch (typeof this._endpoints.wsEndpoint) {
             case "undefined":
-                return !!this._getPublicKey(params) ? `wss://rooms.pluv.io/api/room/${room}` : `/api/pluv/room/${room}`;
+                return !!this._getPublicKey(params)
+                    ? `wss://rooms.pluv.io/api/room/${room}`
+                    : `/api/pluv/room/${room}`;
             case "string":
                 return this._endpoints.wsEndpoint;
             default:
@@ -917,7 +924,7 @@ export class PluvRoom<
         this._stateNotifier.subjects.others.next(others);
     }
 
-    private _handleRegisteredMessage(message: IOEventMessage<TIO>): void {
+    private async _handleRegisteredMessage(message: IOEventMessage<TIO>): Promise<void> {
         const { connectionId } = message;
         const user = message.user as Id<InferIOAuthorizeUser<InferIOAuthorize<TIO>>>;
 
@@ -926,6 +933,7 @@ export class PluvRoom<
         if (!this._state.webSocket) throw new Error("Could not find WebSocket");
 
         const data = message.data as BaseIOEventRecord<InferIOAuthorize<TIO>>["$registered"];
+        const state = data.state;
 
         this._updateState((oldState) => {
             oldState.connection.count += 1;
@@ -948,7 +956,10 @@ export class PluvRoom<
         this._stateNotifier.subjects["my-presence"].next(presence);
         this._stateNotifier.subjects.myself.next(myself);
 
-        const update = this._state.connection.count > 1 ? (this._crdtManager.doc.getEncodedState() ?? null) : null;
+        const update = !state
+            ? (this._crdtManager.resolveEncodedState(await this._storageStore.getUpdates()) ??
+              this._crdtManager.getInitialState())
+            : this._crdtManager.getInitialState();
 
         this._sendMessage({
             type: "$initializeSession",
@@ -964,30 +975,45 @@ export class PluvRoom<
         if (!this._state.webSocket) throw new Error("Could not find WebSocket");
 
         const data = message.data as BaseIOEventRecord<InferIOAuthorize<TIO>>["$storageReceived"];
+        const changeKind = data.changeKind;
+        const state = data.state;
 
-        this._crdtManager.initialize({
-            onInitialized: async (update) => {
-                this._addToStorageStore(update);
-                this._emitSharedTypes();
+        const updates = await this._storageStore.getUpdates();
+        const origin = ORIGIN_INITIALIZED;
 
-                this._observeCrdt();
-                this._stateNotifier.subjects["storage-loaded"].next(true);
-            },
-            origin: ORIGIN_INITIALIZED,
-            update: data.state,
-        });
+        const updateStorage = (update: string | readonly string[]) => {
+            return this._crdtManager.initialized
+                ? this._crdtManager.applyUpdate({ update, origin })
+                : this._crdtManager.initialize({ update, origin });
+        };
 
-        const encodedState = this._crdtManager.doc.getEncodedState();
+        if (changeKind === "empty") {
+            this._crdtManager.destroy();
+            this._crdtManager.initialize({ origin, update: updates });
+        } else if (changeKind === "initialized") {
+            if (!!updates.length) updateStorage(updates);
+            else {
+                const encodedState = updateStorage(state).doc.getEncodedState();
 
-        await this._storageStore.addUpdate(encodedState);
+                this._addToStorageStore(encodedState);
+            }
+        } else {
+            const encodedState = updateStorage(state).doc.getEncodedState();
 
-        this._emitSharedTypes();
+            if (!!updates.length) this._crdtManager.applyUpdate({ update: updates, origin });
 
-        const update = this._crdtManager.doc.getEncodedState();
+            await this._addToStorageStore(encodedState);
+        }
+
+        const encodedState = this._crdtManager.doc.getEncodedState();
+
+        this._emitSharedTypes();
+        this._observeCrdt();
+        this._stateNotifier.subjects["storage-loaded"].next(true);
 
         this._sendMessage({
             type: "$updateStorage",
-            data: { origin: ORIGIN_INITIALIZED, update },
+            data: { origin, update: encodedState },
         });
     }
 
@@ -998,9 +1024,9 @@ export class PluvRoom<
         // Should not reach here
         if (!this._state.webSocket) throw new Error("Could not find WebSocket");
 
-        const data = message.data as BaseIOEventRecord<InferIOAuthorize<TIO>>[typeof ORIGIN_STORAGE_UPDATED];
-
-        if (!this._crdtManager) return;
+        const data = message.data as BaseIOEventRecord<
+            InferIOAuthorize<TIO>
+        >[typeof ORIGIN_STORAGE_UPDATED];
 
         this._crdtManager.doc.applyEncodedState({
             origin: ORIGIN_STORAGE_UPDATED,
@@ -1011,8 +1037,6 @@ export class PluvRoom<
 
         const storageRoot = Object.keys(sharedTypes).reduce(
             (acc, prop) => {
-                if (!this._crdtManager) return acc;
-
                 const serialized = this._crdtManager.doc.toJson(prop);
 
                 this._crdtNotifier.subject(prop).next(serialized);
@@ -1038,7 +1062,9 @@ export class PluvRoom<
         const data = message.data as BaseIOEventRecord<InferIOAuthorize<TIO>>["$syncStateReceived"];
         const active = new Set(data?.connectionIds ?? []);
 
-        const quitters = this._usersManager.getOthers().filter((other) => !active.has(other.connectionId));
+        const quitters = this._usersManager
+            .getOthers()
+            .filter((other) => !active.has(other.connectionId));
 
         quitters.forEach((quitter) => {
             this._usersManager.deleteConnection(quitter.connectionId);
@@ -1080,7 +1106,10 @@ export class PluvRoom<
 
     private _heartbeat(): void {
         this._clearTimeout(this._timeouts.pong);
-        this._timeouts.pong = setTimeout(this._reconnect.bind(this), PONG_TIMEOUT_MS) as unknown as number;
+        this._timeouts.pong = setTimeout(
+            this._reconnect.bind(this),
+            PONG_TIMEOUT_MS,
+        ) as unknown as number;
 
         /**
          * !HACK
@@ -1099,18 +1128,17 @@ export class PluvRoom<
     private _observeCrdt(): void {
         this._subscriptions.observeCrdt?.();
 
-        if (!this._crdtManager) return;
-
         const unsubscribe = this._crdtManager.doc.subscribe((event) => {
             const origin = event.origin ?? null;
 
-            this._addToStorageStore(event.update);
             this._emitSharedTypes();
 
             if (origin === ORIGIN_INITIALIZED || origin === ORIGIN_STORAGE_UPDATED) {
                 return;
             }
 
+            this._addToStorageStore(event.update);
+
             if (!this._state.webSocket) return;
             if (!this._state.connection.id) return;
             if (this._state.webSocket.readyState !== WebSocket.OPEN) return;
@@ -1193,7 +1221,9 @@ export class PluvRoom<
         if (!message) return;
 
         const shouldLog =
-            typeof this._debug === "boolean" ? this._debug : this._debug.output.find((value) => value === message.type);
+            typeof this._debug === "boolean"
+                ? this._debug
+                : this._debug.output.find((value) => value === message.type);
 
         if (shouldLog) {
             this._logDebug("WebSocket event received: ", message.type, message);
@@ -1246,7 +1276,6 @@ export class PluvRoom<
         if (this._state.connection.state !== ConnectionState.Connecting) return;
 
         this._logDebug("WebSocket connected");
-
         this._updateState((oldState) => {
             oldState.connection.state = ConnectionState.Open;
 
@@ -1254,7 +1283,10 @@ export class PluvRoom<
         });
 
         this._clearInterval(this._intervals.heartbeat);
-        this._intervals.heartbeat = setInterval(this._heartbeat.bind(this), HEARTBEAT_INTERVAL_MS) as unknown as number;
+        this._intervals.heartbeat = setInterval(
+            this._heartbeat.bind(this),
+            HEARTBEAT_INTERVAL_MS,
+        ) as unknown as number;
     }
 
     private async _onNavigatorOffline(): Promise<void> {
@@ -1325,9 +1357,15 @@ export class PluvRoom<
             typeof this._reconnectTimeoutMs === "number"
                 ? this._reconnectTimeoutMs
                 : this._reconnectTimeoutMs({ attempts: this._state.connection.attempts });
-        const clampedMs = Math.max(Math.min(MIN_RECONNECT_TIMEOUT_MS, timeoutMs), MAX_RECONNECT_TIMEOUT_MS);
+        const clampedMs = Math.max(
+            Math.min(MIN_RECONNECT_TIMEOUT_MS, timeoutMs),
+            MAX_RECONNECT_TIMEOUT_MS,
+        );
 
-        this._timeouts.reconnect = setTimeout(this._reconnect.bind(this), clampedMs) as unknown as number;
+        this._timeouts.reconnect = setTimeout(
+            this._reconnect.bind(this),
+            clampedMs,
+        ) as unknown as number;
     }
 
     private async _reconnect(): Promise<void> {
@@ -1342,13 +1380,17 @@ export class PluvRoom<
         if (this._state.connection.state === ConnectionState.Closed) return;
 
         const metadata = this._lastMetadata;
-        const params = (typeof metadata === "undefined" ? [] : [{ metadata }]) as RoomConnectParams<TMetadata>;
+        const params = (
+            typeof metadata === "undefined" ? [] : [{ metadata }]
+        ) as RoomConnectParams<TMetadata>;
 
         await this.connect(...params);
     }
 
     private _sendMessage(data: string): void;
-    private _sendMessage<TMessage extends EventMessage<string, any> = EventMessage<string, any>>(data: TMessage): void;
+    private _sendMessage<TMessage extends EventMessage<string, any> = EventMessage<string, any>>(
+        data: TMessage,
+    ): void;
     private _sendMessage(data: any): void {
         const webSocket = this._state.webSocket;
 
@@ -1387,7 +1429,9 @@ export class PluvRoom<
         return parsed;
     }
 
-    private _updateState(updater: (oldState: WebSocketState<TIO>) => WebSocketState<TIO>): WebSocketState<TIO> {
+    private _updateState(
+        updater: (oldState: WebSocketState<TIO>) => WebSocketState<TIO>,
+    ): WebSocketState<TIO> {
         let authorization: AuthorizationState<TIO>;
 
         try {

package/src/PluvRouter.ts

@@ -67,7 +67,10 @@ export class PluvRouter<
     public static merge<TRouters extends PluvRouter<any, any, any, any>[]>(
         ...routers: TRouters
     ): MergedRouter<TRouters> {
-        const events = Object.assign(Object.create(null), ...routers.map((router) => router._defs.events));
+        const events = Object.assign(
+            Object.create(null),
+            ...routers.map((router) => router._defs.events),
+        );
 
         if (Object.keys(events).some((key) => key.startsWith("$"))) {
             throw new Error('Procedures may not start with "$"');

package/src/StateNotifier.ts

@@ -15,7 +15,10 @@ type InferSubjectValue<
     TIO extends IOLike,
     TPresence extends JsonObject,
     TSubject extends keyof StateNotifierSubjects<TIO, TPresence>,
-> = StateNotifierSubjects<TIO, TPresence>[TSubject] extends Subject<infer IValue> ? Id<IValue> : never;
+> =
+    StateNotifierSubjects<TIO, TPresence>[TSubject] extends Subject<infer IValue>
+        ? Id<IValue>
+        : never;
 
 export type SubscriptionCallback<
     TIO extends IOLike,

package/src/UsersManager.ts

@@ -129,7 +129,11 @@ export class UsersManager<TIO extends IOLike, TPresence extends JsonObject = {}>
         if (!userInfo) return null;
 
         const remaining = this._getConnectionIds(clientId)?.size ?? 0;
-        const result: DeleteConnectionResult<TIO, TPresence> = { clientId, remaining, data: userInfo };
+        const result: DeleteConnectionResult<TIO, TPresence> = {
+            clientId,
+            remaining,
+            data: userInfo,
+        };
 
         /**
          * @description A user may have multiple websocket connections open. If one connection is
@@ -195,8 +199,15 @@ export class UsersManager<TIO extends IOLike, TPresence extends JsonObject = {}>
         if (!other) return null;
 
         const cleanedPatch = pickBy(patch ?? {}, (value) => typeof value !== "undefined");
-        const cleanedPresence = pickBy(other.presence ?? {}, (value) => typeof value !== "undefined");
-        const presence = { ...this.initialPresence, ...cleanedPresence, ...cleanedPatch } as TPresence;
+        const cleanedPresence = pickBy(
+            other.presence ?? {},
+            (value) => typeof value !== "undefined",
+        );
+        const presence = {
+            ...this.initialPresence,
+            ...cleanedPresence,
+            ...cleanedPatch,
+        } as TPresence;
         const validated = this._presence ? this._presence.parse(presence) : presence;
 
         this._others.set(clientId, { ...other, presence: validated });
@@ -255,7 +266,11 @@ export class UsersManager<TIO extends IOLike, TPresence extends JsonObject = {}>
     public updateMyPresence(patch: Partial<TPresence>): TPresence {
         const cleanedPatch = pickBy(patch, (value) => typeof value !== "undefined");
         const cleanedPresence = pickBy(this._myPresence, (value) => typeof value !== "undefined");
-        const updated = { ...this.initialPresence, ...cleanedPresence, ...cleanedPatch } as TPresence;
+        const updated = {
+            ...this.initialPresence,
+            ...cleanedPresence,
+            ...cleanedPatch,
+        } as TPresence;
         const bytes = new TextEncoder().encode(JSON.stringify(updated)).length;
 
         if (!!this._limits.presenceMaxSize && bytes > this._limits.presenceMaxSize) {
@@ -297,7 +312,10 @@ export class UsersManager<TIO extends IOLike, TPresence extends JsonObject = {}>
         return set ?? null;
     }
 
-    private _setConnectionId(connectionId: string, clientId: string): Set<[connectionId: string][0]> {
+    private _setConnectionId(
+        connectionId: string,
+        clientId: string,
+    ): Set<[connectionId: string][0]> {
         const set = this._idMap.fromClientId.get(clientId) ?? new Set<string>();
         const updated = set.add(connectionId);
 

package/src/index.ts

@@ -23,4 +23,11 @@ export type {
 export type { MergeEvents, PluvRouter, PluvRouterEventConfig } from "./PluvRouter";
 export { register } from "./register";
 export type { RegisterParams } from "./register";
-export type { InferMetadata, PublicKey, PublicKeyParams, UserInfo, WebSocketConnection, WebSocketState } from "./types";
+export type {
+    InferMetadata,
+    PublicKey,
+    PublicKeyParams,
+    UserInfo,
+    WebSocketConnection,
+    WebSocketState,
+} from "./types";

package/src/infer.ts

@@ -5,4 +5,6 @@ export type InferCallback<TIO extends IOLike<any, any>> = (i: typeof identity) =
     io: (io: TIO) => TIO;
 };
 
-export const infer = <TIO extends IOLike<any, any>>(callback: InferCallback<TIO>): InferCallback<TIO> => callback;
+export const infer = <TIO extends IOLike<any, any>>(
+    callback: InferCallback<TIO>,
+): InferCallback<TIO> => callback;

package/src/register.ts

@@ -9,7 +9,8 @@ export interface RegisterParams<TMetadata extends JsonObject> {
 export const register = <TMetadata extends JsonObject>(params: RegisterParams<TMetadata>) => {
     const { authEndpoint, publicKey } = params;
 
-    const wsEndpoint: WsEndpoint<TMetadata> = ({ room }) => `wss://connect.pluv.io/api/room?room=${room}`;
+    const wsEndpoint: WsEndpoint<TMetadata> = ({ room }) =>
+        `wss://connect.pluv.io/api/room?room=${room}`;
 
     return {
         authEndpoint,