@pluv/client 2.1.0 → 2.2.0

package/src/PluvProcedure.ts

@@ -1,29 +1,34 @@
-import type { CrdtType } from "@pluv/crdt";
+import type { AbstractCrdtDocFactory, InferDocLike } from "@pluv/crdt";
 import type { EventRecord, IOLike, InputZodLike, JsonObject, ProcedureLike } from "@pluv/types";
 import type { EventResolver, MergeEventRecords } from "./types";
 
 export interface PluvProcedureConfig<
-    TIO extends IOLike = IOLike,
-    TInput extends JsonObject = {},
-    TOutput extends EventRecord<string, any> = {},
-    TPresence extends JsonObject = {},
-    TStorage extends Record<string, CrdtType<any, any>> = {},
+    TIO extends IOLike,
+    TInput extends JsonObject,
+    TOutput extends EventRecord<string, any>,
+    TPresence extends Record<string, any>,
+    TCrdt extends AbstractCrdtDocFactory<any, any>,
 > {
-    broadcast?: EventResolver<TIO, TInput, TOutput, TPresence, TStorage> | null;
+    broadcast?: EventResolver<TIO, TInput, TOutput, TPresence, InferDocLike<TCrdt>> | null;
     input?: InputZodLike<TInput>;
 }
 
 export class PluvProcedure<
-    TIO extends IOLike = IOLike,
-    TInput extends JsonObject = {},
-    TOutput extends EventRecord<string, any> = {},
-    TPresence extends JsonObject = {},
-    TStorage extends Record<string, CrdtType<any, any>> = {},
-    TFilled extends "input" | "broadcast" | "" = "",
+    TIO extends IOLike,
+    TInput extends JsonObject,
+    TOutput extends EventRecord<string, any>,
+    TPresence extends Record<string, any>,
+    TCrdt extends AbstractCrdtDocFactory<any, any>,
+    TFilled extends "input" | "broadcast" | "",
 > implements ProcedureLike<TInput, TOutput>
 {
-    private _broadcast: EventResolver<TIO, TInput, Partial<TOutput>, TPresence, TStorage> | null =
-        null;
+    private _broadcast: EventResolver<
+        TIO,
+        TInput,
+        Partial<TOutput>,
+        TPresence,
+        InferDocLike<TCrdt>
+    > | null = null;
     private _input: InputZodLike<TInput> | null = null;
 
     public get config(): ProcedureLike<TInput, TOutput>["config"] {
@@ -34,7 +39,7 @@ export class PluvProcedure<
         } as ProcedureLike<TInput, TOutput>["config"];
     }
 
-    constructor(config: PluvProcedureConfig<TIO, TInput, TOutput, TPresence, TStorage> = {}) {
+    constructor(config: PluvProcedureConfig<TIO, TInput, TOutput, TPresence, TCrdt> = {}) {
         const { broadcast, input } = config;
 
         this._broadcast = broadcast ?? null;
@@ -42,14 +47,14 @@ export class PluvProcedure<
     }
 
     public broadcast<TResult extends EventRecord<string, any> = {}>(
-        resolver: EventResolver<TIO, TInput, TResult, TPresence, TStorage>,
+        resolver: EventResolver<TIO, TInput, TResult, TPresence, InferDocLike<TCrdt>>,
     ): Omit<
         PluvProcedure<
             TIO,
             TInput,
             MergeEventRecords<[TOutput, TResult]>,
             TPresence,
-            TStorage,
+            TCrdt,
             TFilled | "input" | "broadcast"
         >,
         TFilled | "input" | "broadcast"
@@ -63,7 +68,7 @@ export class PluvProcedure<
             TInput,
             MergeEventRecords<[TOutput, TResult]>,
             TPresence,
-            TStorage,
+            TCrdt,
             TFilled | "input" | "broadcast"
         >({
             ...(this.config as any),
@@ -73,14 +78,11 @@ export class PluvProcedure<
 
     public input<TData extends JsonObject>(
         input: InputZodLike<TData>,
-    ): Omit<
-        PluvProcedure<TIO, TData, {}, TPresence, TStorage, TFilled | "input">,
-        TFilled | "input"
-    > {
-        return new PluvProcedure<TIO, TData, {}, TPresence, TStorage, TFilled | "input">({ input });
+    ): Omit<PluvProcedure<TIO, TData, {}, TPresence, TCrdt, TFilled | "input">, TFilled | "input"> {
+        return new PluvProcedure<TIO, TData, {}, TPresence, TCrdt, TFilled | "input">({ input });
     }
 
-    private _resolver(): EventResolver<TIO, TInput, TOutput, TPresence, TStorage> {
+    private _resolver(): EventResolver<TIO, TInput, TOutput, TPresence, InferDocLike<TCrdt>> {
         return (data, context) => this._broadcast?.(data, context) as TOutput;
     }
 }

package/src/PluvRoom.ts

@@ -1,6 +1,8 @@
 import type {
     AbstractCrdtDocFactory,
     InferCrdtJson,
+    InferDoc,
+    InferDocLike,
     InferStorage,
     NoopCrdtDocFactory,
 } from "@pluv/crdt";
@@ -25,6 +27,7 @@ import type {
     OptionalProps,
     OtherSubscriptionCallback,
     OthersSubscriptionCallback,
+    RoomEventListenerMap,
     RoomLike,
     StateNotifierSubjects,
     StorageProxy,
@@ -34,14 +37,16 @@ import type {
     SubscriptionCallback,
     UpdateMyPresenceAction,
     UserInfo,
+    WebSocketConnection,
     WebSocketState,
 } from "@pluv/types";
-import { ConnectionState } from "@pluv/types";
+import { ConnectionState, StorageState } from "@pluv/types";
 import type { AbstractStorageStore } from "./AbstractStorageStore";
 import type { CrdtManagerOptions } from "./CrdtManager";
 import { CrdtManager } from "./CrdtManager";
 import { CrdtNotifier } from "./CrdtNotifier";
 import { EventNotifier } from "./EventNotifier";
+import { ListenerManager } from "./ListenerManager";
 import { PluvProcedure } from "./PluvProcedure";
 import type { PluvRouterEventConfig } from "./PluvRouter";
 import { PluvRouter } from "./PluvRouter";
@@ -54,7 +59,6 @@ import type {
     InternalSubscriptions,
     PluvClientLimits,
     PublicKey,
-    WebSocketConnection,
     WithMetadata,
 } from "./types";
 import type { UsersManagerConfig } from "./UsersManager";
@@ -85,8 +89,8 @@ declare global {
 export const DEFAULT_PLUV_CLIENT_ADDON = <
     TIO extends IOLike,
     TMetadata extends JsonObject,
-    TPresence extends JsonObject,
-    TCrdt extends AbstractCrdtDocFactory<any>,
+    TPresence extends Record<string, any>,
+    TCrdt extends AbstractCrdtDocFactory<any, any>,
 >(
     input: PluvRoomAddonInput<TIO, TMetadata, TPresence, TCrdt>,
 ): PluvRoomAddonResult => ({
@@ -102,9 +106,9 @@ interface WindowListeners {
 
 interface WebSocketListeners {
     onClose: (event: CloseEvent) => void;
-    onError: () => void;
+    onError: (event: Event) => void;
     onMessage: (message: MessageEvent<string>) => void;
-    onOpen: () => void;
+    onOpen: (event: Event) => void;
 }
 
 interface IntervalIds {
@@ -143,15 +147,15 @@ interface InternalListeners {
 export type PluvRoomAddon<
     TIO extends IOLike,
     TMetadata extends JsonObject,
-    TPresence extends JsonObject,
-    TCrdt extends AbstractCrdtDocFactory<any>,
+    TPresence extends Record<string, any>,
+    TCrdt extends AbstractCrdtDocFactory<any, any>,
 > = (input: PluvRoomAddonInput<TIO, TMetadata, TPresence, TCrdt>) => Partial<PluvRoomAddonResult>;
 
 export interface PluvRoomAddonInput<
     TIO extends IOLike,
     TMetadata extends JsonObject,
-    TPresence extends JsonObject,
-    TCrdt extends AbstractCrdtDocFactory<any>,
+    TPresence extends Record<string, any>,
+    TCrdt extends AbstractCrdtDocFactory<any, any>,
 > {
     room: PluvRoom<TIO, TMetadata, TPresence, TCrdt>;
 }
@@ -181,8 +185,8 @@ export type ReconnectTimeoutMs = number | ((params: ReconnectTimeoutMsParams) =>
 export type RoomConfig<
     TIO extends IOLike,
     TMetadata extends JsonObject,
-    TPresence extends JsonObject,
-    TCrdt extends AbstractCrdtDocFactory<any>,
+    TPresence extends Record<string, any>,
+    TCrdt extends AbstractCrdtDocFactory<any, any>,
     TEvents extends PluvRouterEventConfig<TIO, TPresence, InferStorage<TCrdt>>,
 > = Id<
     {
@@ -202,10 +206,10 @@ export type RoomConfig<
 export class PluvRoom<
     TIO extends IOLike<any, any>,
     TMetadata extends JsonObject = {},
-    TPresence extends JsonObject = {},
-    TCrdt extends AbstractCrdtDocFactory<any> = NoopCrdtDocFactory,
+    TPresence extends Record<string, any> = {},
+    TCrdt extends AbstractCrdtDocFactory<any, any> = NoopCrdtDocFactory,
     TEvents extends PluvRouterEventConfig<TIO, TPresence, InferStorage<TCrdt>> = {},
-> implements RoomLike<TIO, TPresence, InferStorage<TCrdt>>
+> implements RoomLike<TIO, InferDoc<TCrdt>, TPresence, InferStorage<TCrdt>>
 {
     readonly _endpoints: RoomEndpoints<TIO, TMetadata>;
 
@@ -220,6 +224,7 @@ export class PluvRoom<
         heartbeat: null,
     };
     private readonly _limits: PluvClientLimits;
+    private readonly _listenerManager = new ListenerManager();
     private readonly _listeners: InternalListeners;
     private readonly _publicKey: PublicKey<TMetadata> | null = null;
     private readonly _reconnectTimeoutMs: ReconnectTimeoutMs;
@@ -244,10 +249,12 @@ export class PluvRoom<
         },
         connection: {
             attempts: 0,
-            count: 0,
             id: null,
             state: ConnectionState.Untouched,
         },
+        storage: {
+            state: StorageState.Unavailable,
+        },
         webSocket: null,
     };
     private _windowListeners: WindowListeners | null = null;
@@ -304,14 +311,24 @@ export class PluvRoom<
         this._crdtManager = new CrdtManager<TCrdt>({ initialStorage });
     }
 
+    /**
+     * @deprecated To be removed in v3. Use `getStorageLoaded` instead.
+     */
     public get storageLoaded(): boolean {
-        return this._crdtManager.initialized;
+        return this.getStorageLoaded();
     }
 
     public get webSocket(): WebSocket | null {
         return this._state.webSocket;
     }
 
+    public addEventListener<TKind extends keyof RoomEventListenerMap>(
+        kind: TKind,
+        handler: RoomEventListenerMap[TKind],
+    ): () => void {
+        return this._listenerManager.subscribe(kind, handler as any);
+    }
+
     public broadcast = new Proxy(
         async <TEvent extends keyof InferIOInput<MergeEvents<TEvents, TIO>>>(
             event: TEvent,
@@ -327,7 +344,8 @@ export class PluvRoom<
                 any,
                 any,
                 TPresence,
-                InferStorage<TCrdt>
+                TCrdt,
+                ""
             > | null;
 
             if (!procedure?.config.broadcast) {
@@ -341,7 +359,7 @@ export class PluvRoom<
             if (!myself) return;
 
             const parsed = procedure.config.input ? procedure.config.input.parse(data) : data;
-            const context: EventResolverContext<TIO, TPresence, InferStorage<TCrdt>> = {
+            const context: EventResolverContext<TIO, TPresence, InferDocLike<TCrdt>> = {
                 doc: this._crdtManager.doc,
                 others: this._usersManager.getOthers(),
                 room: this.id,
@@ -436,6 +454,7 @@ export class PluvRoom<
         this._updateState((oldState) => {
             oldState.connection.attempts = 0;
             oldState.authorization.token = authToken;
+            oldState.storage.state = StorageState.Loading;
             oldState.webSocket = webSocket;
 
             return oldState;
@@ -460,6 +479,10 @@ export class PluvRoom<
         this._updateState((oldState) => {
             oldState.authorization.token = null;
             oldState.connection.state = ConnectionState.Closed;
+            oldState.storage.state =
+                oldState.storage.state === StorageState.Synced
+                    ? StorageState.Offline
+                    : StorageState.Unavailable;
             oldState.webSocket = null;
 
             return oldState;
@@ -492,7 +515,7 @@ export class PluvRoom<
         return Object.freeze(JSON.parse(JSON.stringify(this._state.connection)));
     };
 
-    public getDoc = (): CrdtDocLike<InferStorage<TCrdt>> => {
+    public getDoc = (): CrdtDocLike<InferDoc<TCrdt>, InferStorage<TCrdt>> => {
         return this._crdtManager.doc;
     };
 
@@ -528,7 +551,6 @@ export class PluvRoom<
     ): InferCrdtJson<InferStorage<TCrdt>[TKey]> | null;
     public getStorageJson<TKey extends keyof InferStorage<TCrdt>>(type?: TKey) {
         if (this._state.connection.id === null) return null;
-
         if (typeof type === "undefined") return this._crdtManager.doc.toJson();
 
         const sharedType = this._crdtManager.get(type);
@@ -538,6 +560,13 @@ export class PluvRoom<
         return this._crdtManager.doc.toJson(type);
     }
 
+    public getStorageLoaded = (): boolean => {
+        return (
+            this._state.storage.state === StorageState.Offline ||
+            this._state.storage.state === StorageState.Synced
+        );
+    };
+
     /**
      * @deprecated To be removed in v3. Use PluvRoom.subscribe.other instead
      */
@@ -557,7 +586,7 @@ export class PluvRoom<
     };
 
     /**
-     * @deprecated To be removed in v3. To be removed in v3. Use PluvRoom.subscribe.storage instead
+     * @deprecated To be removed in v3. Use PluvRoom.subscribe.storage instead
      */
     public storage = new Proxy(
         <TKey extends keyof InferStorage<TCrdt>>(
@@ -1041,7 +1070,6 @@ export class PluvRoom<
         const state = data.state;
 
         this._updateState((oldState) => {
-            oldState.connection.count += 1;
             oldState.connection.id = connectionId;
             oldState.authorization.user = user ?? null;
 
@@ -1114,6 +1142,11 @@ export class PluvRoom<
 
         this._emitSharedTypes();
         this._observeCrdt();
+        this._updateState((oldState) => {
+            oldState.storage.state = StorageState.Synced;
+
+            return oldState;
+        });
         this._stateNotifier.subjects["storage-loaded"].next(true);
 
         this._sendMessage({
@@ -1277,12 +1310,15 @@ export class PluvRoom<
 
         this._updateState((oldState) => {
             oldState.connection.state = ConnectionState.Unavailable;
+            oldState.storage.state = StorageState.Unavailable;
 
             return oldState;
         });
     }
 
     private async _onClose(event: CloseEvent): Promise<void> {
+        this._listenerManager.subjects.close.next(event);
+
         this._logDebug("WebSocket closed");
         if (!!event.reason) this._logDebug(event.reason);
 
@@ -1312,6 +1348,10 @@ export class PluvRoom<
                    * @date April 28, 2025
                    */
                   ConnectionState.Closed;
+            oldState.storage.state =
+                oldState.storage.state === StorageState.Synced
+                    ? StorageState.Offline
+                    : StorageState.Unavailable;
             oldState.webSocket = null;
 
             return oldState;
@@ -1331,9 +1371,13 @@ export class PluvRoom<
      * @description Handle websocket errors in a meaningful way, should they occur
      * @date August 19, 2022
      */
-    private _onError(): void {}
+    private _onError(event: Event): void {
+        this._listenerManager.subjects.error.next(event);
+    }
 
     private _onMessage(event: MessageEvent<string>): void {
+        this._listenerManager.subjects.message.next(event);
+
         const message = this._parseMessage(event);
 
         if (!message) return;
@@ -1390,7 +1434,9 @@ export class PluvRoom<
         }
     }
 
-    private _onOpen(): void {
+    private _onOpen(event: Event): void {
+        this._listenerManager.subjects.open.next(event);
+
         if (this._state.connection.state !== ConnectionState.Connecting) return;
 
         this._logDebug("WebSocket connected");
@@ -1412,6 +1458,10 @@ export class PluvRoom<
 
         this._updateState((oldState) => {
             oldState.connection.state = ConnectionState.Unavailable;
+            oldState.storage.state =
+                oldState.storage.state === StorageState.Synced
+                    ? StorageState.Offline
+                    : StorageState.Unavailable;
 
             return oldState;
         });
@@ -1562,6 +1612,7 @@ export class PluvRoom<
             ...this._state,
             authorization,
             connection: JSON.parse(JSON.stringify(this._state.connection)),
+            storage: JSON.parse(JSON.stringify(this._state.storage)),
             webSocket: this._state.webSocket,
         };
 

package/src/PluvRouter.ts

@@ -1,31 +1,31 @@
-import type { CrdtType } from "@pluv/crdt";
+import type { AbstractCrdtDocFactory } from "@pluv/crdt";
 import type { IOLike, IORouterLike, JsonObject } from "@pluv/types";
 import type { PluvProcedure } from "./PluvProcedure";
 
 export type PluvRouterEventConfig<
-    TIO extends IOLike = IOLike,
-    TPresence extends JsonObject = {},
-    TStorage extends Record<string, CrdtType<any, any>> = {},
-> = { [P: string]: Pick<PluvProcedure<TIO, any, any, TPresence, TStorage>, "config"> };
+    TIO extends IOLike,
+    TPresence extends Record<string, any>,
+    TCrdt extends AbstractCrdtDocFactory<any, any>,
+> = { [P: string]: Pick<PluvProcedure<TIO, any, any, TPresence, TCrdt, "">, "config"> };
 
 export type MergedRouter<
-    TRouters extends PluvRouter<TIO, TPresence, TStorage, any>[] = [],
-    TIO extends IOLike = IOLike,
-    TPresence extends JsonObject = {},
-    TStorage extends Record<string, CrdtType<any, any>> = {},
-    TRoot extends TRouters[0]["_defs"]["events"] = {},
+    TRouters extends PluvRouter<TIO, TPresence, TCrdt, any>[],
+    TIO extends IOLike,
+    TPresence extends Record<string, any>,
+    TCrdt extends AbstractCrdtDocFactory<any, any>,
+    TRoot extends TRouters[0]["_defs"]["events"],
 > = TRouters extends [
-    infer IHead extends PluvRouter<TIO, TPresence, TStorage, any>,
-    ...infer ITail extends PluvRouter<TIO, TPresence, TStorage, any>[],
+    infer IHead extends PluvRouter<TIO, TPresence, TCrdt, any>,
+    ...infer ITail extends PluvRouter<TIO, TPresence, TCrdt, any>[],
 ]
-    ? MergedRouter<ITail, TIO, TPresence, TStorage, TRoot & IHead["_defs"]["events"]>
-    : PluvRouter<TIO, TPresence, TStorage, TRoot>;
+    ? MergedRouter<ITail, TIO, TPresence, TCrdt, TRoot & IHead["_defs"]["events"]>
+    : PluvRouter<TIO, TPresence, TCrdt, TRoot>;
 
 export class PluvRouter<
-    TIO extends IOLike = IOLike,
-    TPresence extends JsonObject = {},
-    TStorage extends Record<string, CrdtType<any, any>> = {},
-    TEvents extends PluvRouterEventConfig<TIO, TPresence, TStorage> = {},
+    TIO extends IOLike,
+    TPresence extends Record<string, any>,
+    TCrdt extends AbstractCrdtDocFactory<any, any>,
+    TEvents extends PluvRouterEventConfig<TIO, TPresence, TCrdt> = {},
 > implements IORouterLike<TEvents>
 {
     readonly _defs: { events: TEvents } = { events: {} as TEvents };
@@ -42,9 +42,12 @@ export class PluvRouter<
         this._defs = { events };
     }
 
-    public static merge<TRouters extends PluvRouter<any, any, any, any>[]>(
-        ...routers: TRouters
-    ): MergedRouter<TRouters> {
+    public static merge<
+        TRouters extends PluvRouter<TIO, TPresence, TCrdt, any>[],
+        TIO extends IOLike,
+        TPresence extends Record<string, any>,
+        TCrdt extends AbstractCrdtDocFactory<any, any>,
+    >(...routers: TRouters): MergedRouter<TRouters, TIO, TPresence, TCrdt, {}> {
         const events = Object.assign(
             Object.create(null),
             ...routers.map((router) => router._defs.events),
@@ -54,7 +57,13 @@ export class PluvRouter<
             throw new Error('Procedures may not start with "$"');
         }
 
-        return new PluvRouter<any, any, any, any>(events) as MergedRouter<TRouters>;
+        return new PluvRouter<any, any, any, any>(events) as MergedRouter<
+            TRouters,
+            TIO,
+            TPresence,
+            TCrdt,
+            {}
+        >;
     }
 
     private _isValidEventName(name: string): boolean {

package/src/StateNotifier.ts

@@ -12,14 +12,14 @@ import { makeSubject, subscribe } from "wonka";
 
 type InferSubjectValue<
     TIO extends IOLike,
-    TPresence extends JsonObject,
+    TPresence extends Record<string, any>,
     TSubject extends keyof StateNotifierSubjects<TIO, TPresence>,
 > =
     StateNotifierSubjects<TIO, TPresence>[TSubject] extends Subject<infer IValue>
         ? Id<IValue>
         : never;
 
-export class StateNotifier<TIO extends IOLike, TPresence extends JsonObject = {}> {
+export class StateNotifier<TIO extends IOLike, TPresence extends Record<string, any> = {}> {
     public subjects: StateNotifierSubjects<TIO, TPresence> = {
         connection: makeSubject<Id<WebSocketState<TIO>>>(),
         "my-presence": makeSubject<TPresence>(),

package/src/UsersManager.ts

@@ -1,29 +1,33 @@
 import type { InputZodLike, IOLike, JsonObject, OptionalProps, UserInfo } from "@pluv/types";
+import { PLUV_PRESENCE_META_KEY } from "./constants";
 import type { PluvClientLimits } from "./types";
 import { pickBy } from "./utils";
 
 export type Presence = Record<string, unknown>;
 
-export type UsersManagerConfig<TPresence extends JsonObject = {}> = {
+export type UsersManagerConfig<TPresence extends Record<string, any> = {}> = {
     initialPresence?: TPresence;
     limits: PluvClientLimits;
     presence?: InputZodLike<TPresence>;
 };
 
-export type AddConnectionResult<TIO extends IOLike, TPresence extends JsonObject = {}> = {
+export type AddConnectionResult<TIO extends IOLike, TPresence extends Record<string, any> = {}> = {
     clientId: string;
     data: UserInfo<TIO, TPresence>;
     isMyself: boolean;
     remaining: number;
 };
 
-export type DeleteConnectionResult<TIO extends IOLike, TPresence extends JsonObject = {}> = {
+export type DeleteConnectionResult<
+    TIO extends IOLike,
+    TPresence extends Record<string, any> = {},
+> = {
     clientId: string;
     data: UserInfo<TIO, TPresence>;
     remaining: number;
 };
 
-export class UsersManager<TIO extends IOLike, TPresence extends JsonObject = {}> {
+export class UsersManager<TIO extends IOLike, TPresence extends Record<string, any> = {}> {
     public readonly initialPresence: TPresence;
 
     private readonly _idMap = {
@@ -210,6 +214,16 @@ export class UsersManager<TIO extends IOLike, TPresence extends JsonObject = {}>
         } as TPresence;
         const validated = this._presence ? this._presence.parse(presence) : presence;
 
+        /**
+         * !HACK
+         * @description We're patching internal metadata back into the presence field so it doesn't
+         * get stripped from validation
+         * @date May 13, 2025
+         */
+        if (!!presence[PLUV_PRESENCE_META_KEY]) {
+            (validated as any)[PLUV_PRESENCE_META_KEY] = presence[PLUV_PRESENCE_META_KEY];
+        }
+
         this._others.set(clientId, { ...other, presence: validated });
 
         return validated;

package/src/UsersNotifier.ts

@@ -10,7 +10,7 @@ import type {
 import type { Subject } from "wonka";
 import { makeSubject, subscribe, TypeOfSource } from "wonka";
 
-export class UsersNotifier<TIO extends IOLike, TPresence extends JsonObject = {}> {
+export class UsersNotifier<TIO extends IOLike, TPresence extends Record<string, any> = {}> {
     public readonly others = makeSubject<{
         others: readonly Id<UserInfo<TIO, TPresence>>[];
         event: OthersSubscriptionEvent<TIO, TPresence>;

package/src/constants.ts

@@ -1 +1,2 @@
 export const MAX_PRESENCE_SIZE_BYTES = 512;
+export const PLUV_PRESENCE_META_KEY = "__pluv";

package/src/createClient.ts

@@ -5,8 +5,8 @@ import { PluvClient } from "./PluvClient";
 
 export const createClient = <
     TIO extends IOLike<any, any>,
-    TPresence extends JsonObject = {},
-    TCrdt extends AbstractCrdtDocFactory<any> = NoopCrdtDocFactory,
+    TPresence extends Record<string, any> = {},
+    TCrdt extends AbstractCrdtDocFactory<any, any> = NoopCrdtDocFactory,
     TMetadata extends JsonObject = {},
 >(
     options: PluvClientOptions<TIO, TPresence, TCrdt, TMetadata>,

package/src/index.ts

@@ -9,6 +9,7 @@ export type {
     MergeEvents,
     RoomLike,
     UserInfo,
+    WebSocketConnection,
     WebSocketState,
 } from "@pluv/types";
 export { AbstractStorageStore } from "./AbstractStorageStore";
@@ -32,4 +33,4 @@ export type {
 export type { PluvRouter, PluvRouterEventConfig } from "./PluvRouter";
 export { register } from "./register";
 export type { RegisterParams } from "./register";
-export type { InferMetadata, PublicKey, PublicKeyParams, WebSocketConnection } from "./types";
+export type { InferMetadata, PublicKey, PublicKeyParams } from "./types";