@pluv/client 1.0.1 → 2.0.0

package/src/PluvRoom.ts

@@ -1,8 +1,16 @@
-import type { AbstractCrdtDoc, CrdtType, InferCrdtJson } from "@pluv/crdt";
+import type {
+    AbstractCrdtDocFactory,
+    CrdtType,
+    InferCrdtJson,
+    InferStorage,
+    NoopCrdtDocFactory,
+} from "@pluv/crdt";
 import type {
     BaseIOEventRecord,
     BaseUser,
+    CrdtDocLike,
     EventMessage,
+    EventNotifierSubscriptionCallback,
     IOEventMessage,
     IOLike,
     Id,
@@ -12,26 +20,27 @@ import type {
     InferIOOutput,
     InputZodLike,
     JsonObject,
+    MergeEvents,
     OptionalProps,
+    OtherNotifierSubscriptionCallback,
+    RoomLike,
+    UpdateMyPresenceAction,
+    UserInfo,
+    WebSocketState,
 } from "@pluv/types";
-import { AbstractRoom } from "./AbstractRoom";
+import { ConnectionState } from "@pluv/types";
 import type { AbstractStorageStore } from "./AbstractStorageStore";
 import type { CrdtManagerOptions } from "./CrdtManager";
 import { CrdtManager } from "./CrdtManager";
 import { CrdtNotifier } from "./CrdtNotifier";
-import type { EventNotifierSubscriptionCallback } from "./EventNotifier";
 import { EventNotifier } from "./EventNotifier";
-import type { OtherNotifierSubscriptionCallback } from "./OtherNotifier";
 import { OtherNotifier } from "./OtherNotifier";
 import { PluvProcedure } from "./PluvProcedure";
-import type { MergeEvents, PluvRouterEventConfig } from "./PluvRouter";
+import type { PluvRouterEventConfig } from "./PluvRouter";
 import { PluvRouter } from "./PluvRouter";
 import type { StateNotifierSubjects, SubscriptionCallback } from "./StateNotifier";
 import { StateNotifier } from "./StateNotifier";
 import { StorageStore } from "./StorageStore";
-import type { UsersManagerConfig } from "./UsersManager";
-import { UsersManager } from "./UsersManager";
-import { ConnectionState } from "./enums";
 import type {
     AuthorizationState,
     EventResolver,
@@ -39,12 +48,11 @@ import type {
     InternalSubscriptions,
     PluvClientLimits,
     PublicKey,
-    UpdateMyPresenceAction,
-    UserInfo,
     WebSocketConnection,
-    WebSocketState,
     WithMetadata,
 } from "./types";
+import type { UsersManagerConfig } from "./UsersManager";
+import { UsersManager } from "./UsersManager";
 import { debounce } from "./utils";
 
 const ADD_TO_STORAGE_STATE_DEBOUNCE_MS = 1_000;
@@ -68,12 +76,12 @@ declare global {
 }
 
 export const DEFAULT_PLUV_CLIENT_ADDON = <
-    TIO extends IOLike = IOLike,
-    TMetadata extends JsonObject = {},
-    TPresence extends JsonObject = {},
-    TStorage extends Record<string, CrdtType<any, any>> = {},
+    TIO extends IOLike,
+    TMetadata extends JsonObject,
+    TPresence extends JsonObject,
+    TCrdt extends AbstractCrdtDocFactory<any>,
 >(
-    input: PluvRoomAddonInput<TIO, TMetadata, TPresence, TStorage>,
+    input: PluvRoomAddonInput<TIO, TMetadata, TPresence, TCrdt>,
 ): PluvRoomAddonResult => ({
     storage: new StorageStore(input.room.id),
 });
@@ -126,21 +134,19 @@ interface InternalListeners {
 }
 
 export type PluvRoomAddon<
-    TIO extends IOLike = IOLike,
-    TMetadata extends JsonObject = {},
-    TPresence extends JsonObject = {},
-    TStorage extends Record<string, CrdtType<any, any>> = {},
-> = (
-    input: PluvRoomAddonInput<TIO, TMetadata, TPresence, TStorage>,
-) => Partial<PluvRoomAddonResult>;
+    TIO extends IOLike,
+    TMetadata extends JsonObject,
+    TPresence extends JsonObject,
+    TCrdt extends AbstractCrdtDocFactory<any>,
+> = (input: PluvRoomAddonInput<TIO, TMetadata, TPresence, TCrdt>) => Partial<PluvRoomAddonResult>;
 
 export interface PluvRoomAddonInput<
-    TIO extends IOLike = IOLike,
-    TMetadata extends JsonObject = {},
-    TPresence extends JsonObject = {},
-    TStorage extends Record<string, CrdtType<any, any>> = {},
+    TIO extends IOLike,
+    TMetadata extends JsonObject,
+    TPresence extends JsonObject,
+    TCrdt extends AbstractCrdtDocFactory<any>,
 > {
-    room: PluvRoom<TIO, TMetadata, TPresence, TStorage>;
+    room: PluvRoom<TIO, TMetadata, TPresence, TCrdt>;
 }
 
 export interface PluvRoomAddonResult {
@@ -167,22 +173,22 @@ export type ReconnectTimeoutMs = number | ((params: ReconnectTimeoutMsParams) =>
 
 export type RoomConfig<
     TIO extends IOLike,
-    TMetadata extends JsonObject = {},
-    TPresence extends JsonObject = {},
-    TStorage extends Record<string, CrdtType<any, any>> = {},
-    TEvents extends PluvRouterEventConfig<TIO, TPresence, TStorage> = {},
+    TMetadata extends JsonObject,
+    TPresence extends JsonObject,
+    TCrdt extends AbstractCrdtDocFactory<any>,
+    TEvents extends PluvRouterEventConfig<TIO, TPresence, InferStorage<TCrdt>>,
 > = Id<
     {
-        addons?: readonly PluvRoomAddon<TIO, TMetadata, TPresence, TStorage>[];
+        addons?: readonly PluvRoomAddon<TIO, TMetadata, TPresence, TCrdt>[];
         debug?: boolean | PluvRoomDebug<TIO>;
         limits: PluvClientLimits;
         onAuthorizationFail?: (error: Error) => void;
         metadata?: InputZodLike<TMetadata>;
         publicKey?: PublicKey<TMetadata>;
         reconnectTimeoutMs?: ReconnectTimeoutMs;
-        router?: PluvRouter<TIO, TPresence, TStorage, TEvents>;
+        router?: PluvRouter<TIO, TPresence, InferStorage<TCrdt>, TEvents>;
     } & RoomEndpoints<TIO, TMetadata> &
-        Pick<CrdtManagerOptions<TStorage>, "initialStorage"> &
+        Pick<CrdtManagerOptions<TCrdt>, "initialStorage"> &
         UsersManagerConfig<TPresence>
 >;
 
@@ -190,15 +196,17 @@ export class PluvRoom<
     TIO extends IOLike<any, any>,
     TMetadata extends JsonObject = {},
     TPresence extends JsonObject = {},
-    TStorage extends Record<string, CrdtType<any, any>> = {},
-    TEvents extends PluvRouterEventConfig<TIO, TPresence, TStorage> = {},
-> extends AbstractRoom<TIO, TPresence, TStorage> {
+    TCrdt extends AbstractCrdtDocFactory<any> = NoopCrdtDocFactory,
+    TEvents extends PluvRouterEventConfig<TIO, TPresence, InferStorage<TCrdt>> = {},
+> implements RoomLike<TIO, TPresence, InferStorage<TCrdt>>
+{
     readonly _endpoints: RoomEndpoints<TIO, TMetadata>;
 
+    public readonly id: string;
     public readonly metadata?: InputZodLike<TMetadata>;
 
-    private readonly _crdtManager: CrdtManager<TStorage>;
-    private readonly _crdtNotifier = new CrdtNotifier<TStorage>();
+    private readonly _crdtManager: CrdtManager<TCrdt>;
+    private readonly _crdtNotifier = new CrdtNotifier<InferStorage<TCrdt>>();
     private readonly _debug: boolean | PluvRoomDebug<TIO>;
     private readonly _eventNotifier = new EventNotifier<MergeEvents<TEvents, TIO>>();
     private readonly _intervals: IntervalIds = {
@@ -209,7 +217,7 @@ export class PluvRoom<
     private readonly _otherNotifier = new OtherNotifier<TIO, TPresence>();
     private readonly _publicKey: PublicKey<TMetadata> | null = null;
     private readonly _reconnectTimeoutMs: ReconnectTimeoutMs;
-    private readonly _router: PluvRouter<TIO, TPresence, TStorage, TEvents>;
+    private readonly _router: PluvRouter<TIO, TPresence, InferStorage<TCrdt>, TEvents>;
     private readonly _stateNotifier = new StateNotifier<TIO, TPresence>();
     private readonly _storageStore: AbstractStorageStore;
     private readonly _subscriptions: InternalSubscriptions = {
@@ -238,7 +246,7 @@ export class PluvRoom<
     private _windowListeners: WindowListeners | null = null;
     private _wsListeners: WebSocketListeners | null = null;
 
-    constructor(room: string, options: RoomConfig<TIO, TMetadata, TPresence, TStorage, TEvents>) {
+    constructor(room: string, options: RoomConfig<TIO, TMetadata, TPresence, TCrdt, TEvents>) {
         const {
             addons = [],
             authEndpoint,
@@ -255,22 +263,20 @@ export class PluvRoom<
             wsEndpoint,
         } = options;
 
-        super(room);
+        this.id = room;
+        this.metadata = metadata;
 
         const addon = this._getAddon(addons);
-
         const { storage } = {
             ...DEFAULT_PLUV_CLIENT_ADDON({ room: this }),
             ...addon({ room: this }),
         };
-
-        this.metadata = metadata;
+        this._storageStore = storage;
 
         this._debug = debug;
         this._endpoints = { authEndpoint, wsEndpoint } as RoomEndpoints<TIO, TMetadata>;
         this._limits = limits;
         this._reconnectTimeoutMs = reconnectTimeoutMs;
-        this._storageStore = storage;
 
         if (!!publicKey) this._publicKey = publicKey;
 
@@ -281,13 +287,14 @@ export class PluvRoom<
         };
 
         this._router =
-            router ?? (new PluvRouter({}) as PluvRouter<TIO, TPresence, TStorage, TEvents>);
+            router ??
+            (new PluvRouter({}) as PluvRouter<TIO, TPresence, InferStorage<TCrdt>, TEvents>);
         this._usersManager = new UsersManager<TIO, TPresence>({
             initialPresence,
             limits: this._limits,
             presence,
         });
-        this._crdtManager = new CrdtManager<TStorage>({ initialStorage });
+        this._crdtManager = new CrdtManager<TCrdt>({ initialStorage });
     }
 
     public get storageLoaded(): boolean {
@@ -313,7 +320,7 @@ export class PluvRoom<
                 any,
                 any,
                 TPresence,
-                TStorage
+                InferStorage<TCrdt>
             > | null;
 
             if (!procedure?.config.broadcast) {
@@ -327,7 +334,7 @@ export class PluvRoom<
             if (!myself) return;
 
             const parsed = procedure.config.input ? procedure.config.input.parse(data) : data;
-            const context: EventResolverContext<TIO, TPresence, TStorage> = {
+            const context: EventResolverContext<TIO, TPresence, InferStorage<TCrdt>> = {
                 doc: this._crdtManager.doc,
                 others: this._usersManager.getOthers(),
                 room: this.id,
@@ -335,7 +342,13 @@ export class PluvRoom<
             };
 
             const output = await (
-                procedure.config.broadcast as EventResolver<TIO, any, any, TPresence, TStorage>
+                procedure.config.broadcast as EventResolver<
+                    TIO,
+                    any,
+                    any,
+                    TPresence,
+                    InferStorage<TCrdt>
+                >
             )(parsed, context);
 
             Object.entries(output).forEach(([_type, _data]) => {
@@ -389,8 +402,7 @@ export class PluvRoom<
             return oldState;
         });
 
-        // await this._storageStore.initialize();
-        // await this._applyStorageStore();
+        await this._storageStore.initialize();
 
         const wsEndpoint = this._getWsEndpoint(this.id, params);
         const url = new URL(wsEndpoint);
@@ -484,7 +496,7 @@ export class PluvRoom<
         return Object.freeze(JSON.parse(JSON.stringify(this._state.connection)));
     };
 
-    public getDoc = (): AbstractCrdtDoc<TStorage> => {
+    public getDoc = (): CrdtDocLike<InferStorage<TCrdt>> => {
         return this._crdtManager.doc;
     };
 
@@ -504,7 +516,9 @@ export class PluvRoom<
         return this._usersManager.getOthers();
     };
 
-    public getStorage = <TKey extends keyof TStorage>(type: TKey): TStorage[TKey] | null => {
+    public getStorage = <TKey extends keyof InferStorage<TCrdt>>(
+        type: TKey,
+    ): InferStorage<TCrdt>[TKey] | null => {
         const sharedType = this._crdtManager.get(type);
 
         if (typeof sharedType === "undefined") return null;
@@ -512,11 +526,11 @@ export class PluvRoom<
         return sharedType;
     };
 
-    public getStorageJson(): InferCrdtJson<TStorage> | null;
-    public getStorageJson<TKey extends keyof TStorage>(
+    public getStorageJson(): InferCrdtJson<InferStorage<TCrdt>> | null;
+    public getStorageJson<TKey extends keyof InferStorage<TCrdt>>(
         type: TKey,
-    ): InferCrdtJson<TStorage[TKey]> | null;
-    public getStorageJson<TKey extends keyof TStorage>(type?: TKey) {
+    ): 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();
@@ -543,16 +557,16 @@ export class PluvRoom<
         this._crdtManager.doc.redo();
     };
 
-    public storage = <TKey extends keyof TStorage>(
+    public storage = <TKey extends keyof InferStorage<TCrdt>>(
         key: TKey,
-        fn: (value: InferCrdtJson<TStorage[TKey]>) => void,
+        fn: (value: InferCrdtJson<InferStorage<TCrdt>[TKey]>) => void,
     ): (() => void) => {
         return this._crdtNotifier.subscribe(key, fn);
     };
 
     public storageRoot = (
         fn: (value: {
-            [P in keyof TStorage]: InferCrdtJson<TStorage[P]>;
+            [P in keyof InferStorage<TCrdt>]: InferCrdtJson<InferStorage<TCrdt>[P]>;
         }) => void,
     ): (() => void) => {
         return this._crdtNotifier.subcribeRoot(fn);
@@ -565,7 +579,7 @@ export class PluvRoom<
         return this._stateNotifier.subscribe(name, callback);
     };
 
-    public transact = (fn: (storage: TStorage) => void, origin?: string): void => {
+    public transact = (fn: (storage: InferStorage<TCrdt>) => void, origin?: string): void => {
         const _origin = origin ?? this._state.connection.id;
 
         /**
@@ -612,22 +626,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;
@@ -724,7 +722,7 @@ export class PluvRoom<
 
                 return { ...acc, [prop]: serialized };
             },
-            {} as { [P in keyof TStorage]: InferCrdtJson<TStorage[P]> },
+            {} as { [P in keyof InferStorage<TCrdt>]: InferCrdtJson<InferStorage<TCrdt>[P]> },
         );
 
         this._crdtNotifier.rootSubject.next(storageRoot);
@@ -738,7 +736,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();
 
@@ -748,9 +746,9 @@ export class PluvRoom<
     );
 
     private _getAddon = (
-        addons: readonly PluvRoomAddon<TIO, TMetadata, TPresence, TStorage>[],
-    ): PluvRoomAddon<TIO, TMetadata, TPresence, TStorage> => {
-        return addons.reduce<PluvRoomAddon<TIO, TMetadata, TPresence, TStorage>>(
+        addons: readonly PluvRoomAddon<TIO, TMetadata, TPresence, TCrdt>[],
+    ): PluvRoomAddon<TIO, TMetadata, TPresence, TCrdt> => {
+        return addons.reduce<PluvRoomAddon<TIO, TMetadata, TPresence, TCrdt>>(
             (acc, addon) => () => ({
                 ...acc({ room: this }),
                 ...addon({ room: this }),
@@ -941,7 +939,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>>>;
 
@@ -950,11 +948,6 @@ 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) => {
@@ -978,7 +971,10 @@ export class PluvRoom<
         this._stateNotifier.subjects["my-presence"].next(presence);
         this._stateNotifier.subjects.myself.next(myself);
 
-        const update = this._crdtManager.getInitialState();
+        const update = !state
+            ? (this._crdtManager.resolveEncodedState(await this._storageStore.getUpdates()) ??
+              this._crdtManager.getInitialState())
+            : this._crdtManager.getInitialState();
 
         this._sendMessage({
             type: "$initializeSession",
@@ -994,30 +990,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) => {
-                await this._addToStorageStore(update);
-                this._emitSharedTypes();
-                this._observeCrdt();
-                this._stateNotifier.subjects["storage-loaded"].next(true);
-            },
-            origin: ORIGIN_INITIALIZED,
-            update: state,
-        });
+        const updates = await this._storageStore.getUpdates();
+        const origin = ORIGIN_INITIALIZED;
 
-        const encodedState = this._crdtManager.doc.getEncodedState();
+        const updateStorage = (update: string | readonly string[]) => {
+            return this._crdtManager.initialized
+                ? this._crdtManager.applyUpdate({ update, origin })
+                : this._crdtManager.initialize({ update, origin });
+        };
 
-        await this._storageStore.addUpdate(encodedState);
+        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();
 
-        this._emitSharedTypes();
+                this._addToStorageStore(encodedState);
+            }
+        } else {
+            const encodedState = updateStorage(state).doc.getEncodedState();
+
+            if (!!updates.length) this._crdtManager.applyUpdate({ update: updates, origin });
+
+            await this._addToStorageStore(encodedState);
+        }
+
+        const encodedState = this._crdtManager.doc.getEncodedState();
 
-        const update = 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 },
         });
     }
 
@@ -1048,7 +1059,7 @@ export class PluvRoom<
                 return { ...acc, [prop]: serialized };
             },
             {} as {
-                [P in keyof TStorage]: InferCrdtJson<TStorage[P]>;
+                [P in keyof InferStorage<TCrdt>]: InferCrdtJson<InferStorage<TCrdt>[P]>;
             },
         );
 
@@ -1125,7 +1136,8 @@ export class PluvRoom<
     }
 
     private _logDebug(...data: any[]): void {
-        if ((process as unknown as any)?.env?.NODE_ENV === "production") return;
+        if (typeof process === "undefined") return;
+        if (process.env?.NODE_ENV === "production") return;
         if (this._debug) console.log(...data);
     }
 
@@ -1135,13 +1147,14 @@ export class PluvRoom<
         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;

package/src/PluvRouter.ts

@@ -1,5 +1,5 @@
 import type { CrdtType } from "@pluv/crdt";
-import type { Id, IOLike, IORouterLike, JsonObject, ProcedureLike } from "@pluv/types";
+import type { IOLike, IORouterLike, JsonObject } from "@pluv/types";
 import type { PluvProcedure } from "./PluvProcedure";
 
 export type PluvRouterEventConfig<
@@ -21,28 +21,6 @@ export type MergedRouter<
     ? MergedRouter<ITail, TIO, TPresence, TStorage, TRoot & IHead["_defs"]["events"]>
     : PluvRouter<TIO, TPresence, TStorage, TRoot>;
 
-export type MergeEvents<
-    TClientEvents extends PluvRouterEventConfig<any, any, any>,
-    TServerIO extends IOLike<any, any>,
-> =
-    TServerIO extends IOLike<infer IAuthorize, infer IServerEvents>
-        ? IOLike<
-              IAuthorize,
-              {
-                  [P in keyof TClientEvents]: TClientEvents[P] extends ProcedureLike<
-                      infer IClientInput,
-                      infer IClientOutput
-                  >
-                      ? {
-                            [K in keyof IClientOutput]: K extends keyof IServerEvents
-                                ? IServerEvents[K]
-                                : ProcedureLike<IClientInput, Id<Pick<IClientOutput, K>>>;
-                        }[keyof IClientOutput]
-                      : never;
-              } & IServerEvents
-          >
-        : never;
-
 export class PluvRouter<
     TIO extends IOLike = IOLike,
     TPresence extends JsonObject = {},

package/src/StateNotifier.ts

@@ -1,7 +1,6 @@
-import type { Id, IOLike, JsonObject } from "@pluv/types";
+import type { Id, IOLike, JsonObject, UserInfo, WebSocketState } from "@pluv/types";
 import type { Subject } from "wonka";
 import { makeSubject, subscribe } from "wonka";
-import type { UserInfo, WebSocketState } from "./types";
 
 export interface StateNotifierSubjects<TIO extends IOLike, TPresence extends JsonObject> {
     connection: Subject<Id<WebSocketState<TIO>>>;

package/src/UsersManager.ts

@@ -1,5 +1,5 @@
-import type { InputZodLike, IOLike, JsonObject, OptionalProps } from "@pluv/types";
-import type { PluvClientLimits, UserInfo } from "./types";
+import type { InputZodLike, IOLike, JsonObject, OptionalProps, UserInfo } from "@pluv/types";
+import type { PluvClientLimits } from "./types";
 import { pickBy } from "./utils";
 
 export type Presence = Record<string, unknown>;

package/src/createClient.ts

@@ -1,4 +1,4 @@
-import type { CrdtType } from "@pluv/crdt";
+import type { AbstractCrdtDocFactory, NoopCrdtDocFactory } from "@pluv/crdt";
 import type { IOLike, JsonObject } from "@pluv/types";
 import type { PluvClientOptions } from "./PluvClient";
 import { PluvClient } from "./PluvClient";
@@ -6,10 +6,10 @@ import { PluvClient } from "./PluvClient";
 export const createClient = <
     TIO extends IOLike<any, any>,
     TPresence extends JsonObject = {},
-    TStorage extends Record<string, CrdtType<any, any>> = {},
+    TCrdt extends AbstractCrdtDocFactory<any> = NoopCrdtDocFactory,
     TMetadata extends JsonObject = {},
 >(
-    options: PluvClientOptions<TIO, TPresence, TStorage, TMetadata>,
-): PluvClient<TIO, TPresence, TStorage, TMetadata> => {
-    return new PluvClient<TIO, TPresence, TStorage, TMetadata>(options);
+    options: PluvClientOptions<TIO, TPresence, TCrdt, TMetadata>,
+): PluvClient<TIO, TPresence, TCrdt, TMetadata> => {
+    return new PluvClient<TIO, TPresence, TCrdt, TMetadata>(options);
 };

package/src/index.ts

@@ -1,9 +1,18 @@
 export type { CrdtType, InferCrdtJson } from "@pluv/crdt";
-export type { BaseUser, EventMessage, EventRecord, IOEventMessage } from "@pluv/types";
-export { AbstractRoom } from "./AbstractRoom";
+export type {
+    BaseUser,
+    ConnectionState,
+    EventMessage,
+    EventNotifierSubscriptionCallback,
+    EventRecord,
+    IOEventMessage,
+    MergeEvents,
+    RoomLike,
+    UserInfo,
+    WebSocketState,
+} from "@pluv/types";
 export { AbstractStorageStore } from "./AbstractStorageStore";
 export { createClient } from "./createClient";
-export { ConnectionState } from "./enums";
 export { infer } from "./infer";
 export type { InferCallback } from "./infer";
 export { MockedRoom } from "./MockedRoom";
@@ -20,14 +29,7 @@ export type {
     RoomConnectParams,
     RoomEndpoints,
 } from "./PluvRoom";
-export type { MergeEvents, PluvRouter, PluvRouterEventConfig } from "./PluvRouter";
+export type { 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, WebSocketConnection } from "./types";