@pluv/client 0.44.2 → 1.0.1

package/src/CrdtManager.ts

@@ -2,7 +2,6 @@ import type { AbstractCrdtDoc, AbstractCrdtDocFactory, CrdtType } from "@pluv/cr
 import { noop } from "@pluv/crdt";
 
 export type CrdtManagerOptions<TStorage extends Record<string, CrdtType<any, any>> = {}> = {
-    encodedState?: string | Uint8Array | null;
     initialStorage?: AbstractCrdtDocFactory<TStorage>;
 };
 
@@ -19,13 +18,10 @@ export class CrdtManager<TStorage extends Record<string, CrdtType<any, any>>> {
     private readonly _docFactory: AbstractCrdtDocFactory<TStorage>;
 
     constructor(options: CrdtManagerOptions<TStorage>) {
-        const { encodedState, initialStorage = noop.doc({}) as AbstractCrdtDocFactory<TStorage> } = options;
+        const { initialStorage = noop.doc({}) as AbstractCrdtDocFactory<TStorage> } = options;
 
         this._docFactory = initialStorage;
-
-        this.doc = encodedState
-            ? initialStorage.getFresh().applyEncodedState({ update: encodedState })
-            : initialStorage.getFresh();
+        this.doc = initialStorage.getEmpty();
     }
 
     /**
@@ -52,35 +48,51 @@ export class CrdtManager<TStorage extends Record<string, CrdtType<any, any>>> {
         return this.doc.get(key);
     }
 
+    public getInitialState(): string {
+        return this._docFactory.getInitialized().getEncodedState();
+    }
+
     public initialize(params: CrdtManagerInitializeParams): this {
         const { onInitialized, origin, update } = params;
 
-        const updates = typeof update === "string" ? [update] : update;
-
-        if (!updates.length) return this;
-
+        /**
+         * !HACK
+         * @description If the doc was already initialized, we don't want to re-initialize
+         * the doc and overwrite what's already there. Skip the initialization and log a
+         * warning.
+         * @date May 7, 2025
+         */
         if (this.initialized) {
-            this.doc = this._applyDocUpdates(this.doc, updates, origin).track();
-
+            console.warn("Attempted to initialize storage multiple times");
             return this;
         }
 
-        const onEmpty = this._applyDocUpdates(this._docFactory.getEmpty(), updates, origin);
-
-        if (!onEmpty.isEmpty()) {
-            onEmpty.destroy();
+        /**
+         * !HACK
+         * @description If the doc is already populated, somehow we're attempting to overwrite
+         * a doc that was presumably initialized but not identified as initialized. Skip the
+         * initialization and log a warning.
+         * @date May 7, 2025
+         */
+        if (!this.doc.isEmpty()) {
+            console.warn("Attempted to initialize over a non-empty storage");
+            return this;
+        }
 
-            this.doc = this._applyDocUpdates(this._docFactory.getFresh(), updates, origin).track();
-            this.initialized = true;
+        const updates = typeof update === "string" ? [update] : update;
 
-            onInitialized?.(this.doc.getEncodedState());
+        if (!updates.length) return this;
 
-            return this;
-        }
+        const initialized = this._docFactory.getInitialized();
+        const reference = initialized.get();
 
-        onEmpty.destroy();
-        this.doc = this._docFactory.getInitialized().track();
+        this.doc = this._applyDocUpdates(
+            this._docFactory.getEmpty(),
+            updates,
+            origin,
+        ).rebuildStorage(reference);
         this.initialized = true;
+        initialized.destroy();
 
         onInitialized?.(this.doc.getEncodedState());
 

package/src/CrdtNotifier.ts

@@ -7,7 +7,10 @@ export class CrdtNotifier<TStorage extends Record<string, CrdtType<any, any>>> {
         [P in keyof TStorage]: InferCrdtJson<TStorage[P]>;
     }>();
 
-    public subjects = new Map<keyof TStorage, Subject<InferCrdtJson<TStorage[keyof TStorage]>> | null>();
+    public subjects = new Map<
+        keyof TStorage,
+        Subject<InferCrdtJson<TStorage[keyof TStorage]>> | null
+    >();
 
     public subject<TKey extends keyof TStorage>(key: TKey): Subject<InferCrdtJson<TStorage[TKey]>> {
         const subject = this.subjects.get(key);

package/src/EventNotifier.ts

@@ -2,14 +2,20 @@ import type { Id, InferIOOutput, IOEventMessage, IOLike } from "@pluv/types";
 import type { Subject } from "wonka";
 import { makeSubject, subscribe } from "wonka";
 
-export type EventNotifierSubscriptionCallback<TIO extends IOLike<any, any>, TEvent extends keyof InferIOOutput<TIO>> = (
-    value: Id<IOEventMessage<TIO, TEvent>>,
-) => void;
+export type EventNotifierSubscriptionCallback<
+    TIO extends IOLike<any, any>,
+    TEvent extends keyof InferIOOutput<TIO>,
+> = (value: Id<IOEventMessage<TIO, TEvent>>) => void;
 
 export class EventNotifier<TIO extends IOLike> {
-    public subjects = new Map<keyof InferIOOutput<TIO>, Subject<Id<IOEventMessage<TIO, keyof InferIOOutput<TIO>>>>>();
+    public subjects = new Map<
+        keyof InferIOOutput<TIO>,
+        Subject<Id<IOEventMessage<TIO, keyof InferIOOutput<TIO>>>>
+    >();
 
-    public subject<TEvent extends keyof InferIOOutput<TIO>>(name: TEvent): Subject<Id<IOEventMessage<TIO, TEvent>>> {
+    public subject<TEvent extends keyof InferIOOutput<TIO>>(
+        name: TEvent,
+    ): Subject<Id<IOEventMessage<TIO, TEvent>>> {
         const subject = this.subjects.get(name);
 
         if (subject) return subject;

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;
 
@@ -377,8 +389,8 @@ export class PluvRoom<
             return oldState;
         });
 
-        await this._storageStore.initialize();
-        await this._applyStorageStore();
+        // await this._storageStore.initialize();
+        // await this._applyStorageStore();
 
         const wsEndpoint = this._getWsEndpoint(this.id, params);
         const url = new URL(wsEndpoint);
@@ -453,8 +465,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 +513,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 +589,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);
 
@@ -743,7 +759,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 +786,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 +820,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:
@@ -926,6 +950,12 @@ export class PluvRoom<
         if (!this._state.webSocket) throw new Error("Could not find WebSocket");
 
         const data = message.data as BaseIOEventRecord<InferIOAuthorize<TIO>>["$registered"];
+        /**
+         * TODO
+         * @description Maybe we can use this to resolve storage initialization more efficiently
+         * @date May 7, 2025
+         */
+        const state = data.state;
 
         this._updateState((oldState) => {
             oldState.connection.count += 1;
@@ -948,7 +978,7 @@ 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 = this._crdtManager.getInitialState();
 
         this._sendMessage({
             type: "$initializeSession",
@@ -964,17 +994,17 @@ export class PluvRoom<
         if (!this._state.webSocket) throw new Error("Could not find WebSocket");
 
         const data = message.data as BaseIOEventRecord<InferIOAuthorize<TIO>>["$storageReceived"];
+        const state = data.state;
 
         this._crdtManager.initialize({
             onInitialized: async (update) => {
-                this._addToStorageStore(update);
+                await this._addToStorageStore(update);
                 this._emitSharedTypes();
-
                 this._observeCrdt();
                 this._stateNotifier.subjects["storage-loaded"].next(true);
             },
             origin: ORIGIN_INITIALIZED,
-            update: data.state,
+            update: state,
         });
 
         const encodedState = this._crdtManager.doc.getEncodedState();
@@ -998,9 +1028,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 +1041,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 +1066,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 +1110,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,8 +1132,6 @@ 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;
 
@@ -1193,7 +1224,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 +1279,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 +1286,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 +1360,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 +1383,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 +1432,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 {
@@ -1404,11 +1451,9 @@ export class PluvRoom<
         };
 
         const newState = updater(oldState);
-
-        this._logDebug("WebSocket new state: ", newState);
-
         this._state = newState;
 
+        this._logDebug("WebSocket new state: ", newState);
         this._stateNotifier.subjects.connection.next(newState);
 
         return newState;

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,