@pluv/client 0.38.14 → 0.39.1

package/.turbo/turbo-build.log

@@ -1,5 +1,5 @@
 
-> @pluv/client@0.38.14 build /home/runner/work/pluv/pluv/packages/client
+> @pluv/client@0.39.1 build /home/runner/work/pluv/pluv/packages/client
 > tsup src/index.ts --format esm,cjs --dts
 
 CLI Building entry: src/index.ts
@@ -8,11 +8,11 @@
 CLI Target: es6
 ESM Build start
 CJS Build start
-CJS dist/index.js 49.20 KB
-CJS ⚡️ Build success in 128ms
-ESM dist/index.mjs 47.88 KB
-ESM ⚡️ Build success in 134ms
+ESM dist/index.mjs 49.44 KB
+ESM ⚡️ Build success in 100ms
+CJS dist/index.js 50.76 KB
+CJS ⚡️ Build success in 123ms
 DTS Build start
-DTS ⚡️ Build success in 3169ms
-DTS dist/index.d.mts 23.23 KB
-DTS dist/index.d.ts  23.23 KB
+DTS ⚡️ Build success in 3307ms
+DTS dist/index.d.mts 24.50 KB
+DTS dist/index.d.ts  24.50 KB

package/CHANGELOG.md

@@ -1,5 +1,80 @@
 # @pluv/client
 
+## 0.39.1
+
+### Patch Changes
+
+- @pluv/crdt@0.39.1
+- @pluv/types@0.39.1
+
+## 0.39.0
+
+### Minor Changes
+
+- e6ddddc: **BREAKING** Moved the `metadata` parameter from the constructor of `PluvRoom` to `PluvClient.connect`. The `metadata` parameter from the constructor of `PluvRoom` is now the validation schema for `metadata` passed through from `PluvClient`.
+
+  This should not be breaking for most users, as the recommended way to enter a room has always been via `PluvClient.enter(room)` (i.e. these are mostly internal-only changes).
+
+  ```ts
+  // Before
+  const room = new Room("my-room", { metadata: { hello: "world" } });
+
+  await room.connect();
+
+  // After
+  const room = new Room("my-room", {
+    metadata: z.object({ hello: z.string() }),
+  });
+
+  await room.connect({ metadata: { hello: "world" } });
+  ```
+
+- e6ddddc: **BREAKING** Moved the `metadata` parameter from `PluvClient.createRoom` to `PluvClient.enter`.
+
+  ```ts
+  // Before
+  const room = client.createRoom({
+    // ...
+    metadata: { hello: "world" },
+    // ...
+  });
+
+  client.enter(room);
+
+  // After
+  const room = client.createRoom({
+    // ...
+  });
+
+  client.enter(room, { metadata });
+  ```
+
+### Patch Changes
+
+- e6ddddc: Improved handling of polling-reconnects to `PluvRoom` after the websocket closes (depending on the close event's code).
+- 2cfb68d: Add the ability to configure the reconnect timeout (in milliseconds) for a `PluvRoom`, and lowered the default reconnect timeout from 30s to 5s. Values will be automatically clamped to between 1s and 60s.
+
+  ```ts
+  // Both of these are valid
+  const room = client.createRoom("my-room", {
+    // Set timeout to a fixed 10s
+    reconnectTimeoutMs: 10_000,
+  });
+
+  const room = client.createRoom("my-room", {
+    /**
+     * `attempts` is the count of failed reconnect attempts, starting from 0 on the first attempt.
+     * The returned value will be how long until the next attempt.
+     */
+    reconnectTimeoutMs: ({ attempts }) => {
+      return 10_000 + 1_000 * Math.pow(2, attempts);
+    },
+  });
+  ```
+
+  - @pluv/crdt@0.39.0
+  - @pluv/types@0.39.0
+
 ## 0.38.14
 
 ### Patch Changes

package/dist/index.d.mts

@@ -1,6 +1,6 @@
-import { CrdtType, AbstractCrdtDoc, InferCrdtJson, AbstractCrdtDocFactory } from '@pluv/crdt';
+import { CrdtType, AbstractCrdtDocFactory, AbstractCrdtDoc, InferCrdtJson } from '@pluv/crdt';
 export { CrdtType, InferCrdtJson } from '@pluv/crdt';
-import { IOLike, InferIOOutput, Id, IOEventMessage, JsonObject, EventRecord, InferIOAuthorizeUser, InferIOAuthorize, MaybePromise, ProcedureLike, InputZodLike, IORouterLike, InferIOInput, BaseUser } from '@pluv/types';
+import { IOLike, InferIOOutput, Id, IOEventMessage, JsonObject, EventRecord, ProcedureLike, InputZodLike, IORouterLike, InferIOAuthorizeUser, InferIOAuthorize, BaseUser, InferIOInput, MaybePromise } from '@pluv/types';
 export { BaseUser, EventMessage, EventRecord, IOEventMessage } from '@pluv/types';
 import { Subject } from 'wonka';
 
@@ -14,45 +14,12 @@ declare enum ConnectionState {
     Untouched = "Untouched"
 }
 
-interface AuthorizationState<TIO extends IOLike> {
-    token: string | null;
-    user: InferIOAuthorizeUser<InferIOAuthorize<TIO>> | null;
-}
-type EventResolver<TIO extends IOLike = IOLike, TInput extends JsonObject = {}, TOutput extends EventRecord<string, any> = {}, TPresence extends JsonObject = {}, TStorage extends Record<string, CrdtType<any, any>> = {}> = (data: TInput, context: EventResolverContext<TIO, TPresence, TStorage>) => MaybePromise<TOutput | void>;
-interface EventResolverContext<TIO extends IOLike = IOLike, TPresence extends JsonObject = {}, TStorage extends Record<string, CrdtType<any, any>> = {}> {
-    doc: AbstractCrdtDoc<TStorage>;
-    others: readonly UserInfo<TIO, TPresence>[];
-    room: string;
-    user: UserInfo<TIO, TPresence>;
-}
-type MergeEventRecords<TEventRecords extends EventRecord<string, any>[], TRoot extends EventRecord<string, any> = {}> = TEventRecords extends [
-    infer IHead extends EventRecord<string, any>,
-    ...infer ITail extends EventRecord<string, any>[]
-] ? MergeEventRecords<ITail, Omit<TRoot, keyof IHead> & {
-    [P in keyof IHead]: TRoot extends Record<P, any> ? TRoot[P] | IHead[P] : IHead[P];
-}> : Id<TRoot>;
-interface PublicKeyParams<TMetadata extends JsonObject> {
-    metadata: TMetadata;
-}
-type PublicKey<TMetadata extends JsonObject> = string | ((params: PublicKeyParams<TMetadata>) => string);
-type UpdateMyPresenceAction<TPresence extends JsonObject> = Partial<TPresence> | ((oldPresence: TPresence | null) => Partial<TPresence>);
-interface UserInfo<TIO extends IOLike, TPresence extends JsonObject = {}> {
-    connectionId: string;
-    presence: TPresence;
-    user: Id<InferIOAuthorizeUser<InferIOAuthorize<TIO>>>;
-}
-interface WebSocketConnection {
-    count: number;
-    id: string | null;
-    state: ConnectionState;
-}
-interface WebSocketState<TIO extends IOLike> {
-    authorization: AuthorizationState<TIO>;
-    connection: WebSocketConnection;
-    webSocket: WebSocket | null;
-}
+declare const identity: <T extends unknown>(x: T) => T;
 
-type OtherNotifierSubscriptionCallback<TIO extends IOLike> = (value: Id<UserInfo<TIO>> | null) => void;
+type InferCallback<TIO extends IOLike<any, any>> = (i: typeof identity) => {
+    io: (io: TIO) => TIO;
+};
+declare const infer: <TIO extends IOLike<any, any>>(callback: InferCallback<TIO>) => InferCallback<TIO>;
 
 interface PluvProcedureConfig<TIO extends IOLike = IOLike, TInput extends JsonObject = {}, TOutput extends EventRecord<string, any> = {}, TPresence extends JsonObject = {}, TStorage extends Record<string, CrdtType<any, any>> = {}> {
     broadcast?: EventResolver<TIO, TInput, TOutput, TPresence, TStorage> | null;
@@ -68,6 +35,22 @@ declare class PluvProcedure<TIO extends IOLike = IOLike, TInput extends JsonObje
     private _resolver;
 }
 
+declare abstract class AbstractStorageStore {
+    room: string;
+    constructor(room: string);
+    abstract addUpdate(update: string): Promise<void>;
+    abstract destroy(): Promise<void>;
+    abstract flatten(encodedState: string): Promise<void>;
+    abstract getShouldFlatten(): Promise<boolean>;
+    abstract getUpdates(start?: number): Promise<readonly string[]>;
+    abstract initialize(): Promise<void>;
+}
+
+type CrdtManagerOptions<TStorage extends Record<string, CrdtType<any, any>> = {}> = {
+    encodedState?: string | Uint8Array | null;
+    initialStorage?: AbstractCrdtDocFactory<TStorage>;
+};
+
 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">;
 };
@@ -99,58 +82,6 @@ interface StateNotifierSubjects<TIO extends IOLike, TPresence extends JsonObject
 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;
 type SubscriptionCallback<TIO extends IOLike, TPresence extends JsonObject, TSubject extends keyof StateNotifierSubjects<TIO, TPresence>> = (value: InferSubjectValue<TIO, TPresence, TSubject>) => void;
 
-declare abstract class AbstractRoom<TIO extends IOLike, TPresence extends JsonObject = {}, TStorage extends Record<string, CrdtType<any, any>> = {}, TEvents extends PluvRouterEventConfig<TIO, TPresence, TStorage> = {}> {
-    readonly id: string;
-    constructor(room: string);
-    abstract storageLoaded: boolean;
-    abstract broadcast<TEvent extends keyof InferIOInput<MergeEvents<TEvents, TIO>>>(event: TEvent, data: Id<InferIOInput<MergeEvents<TEvents, TIO>>[TEvent]>): void;
-    abstract canRedo(): boolean;
-    abstract canUndo(): boolean;
-    abstract getDoc(): AbstractCrdtDoc<TStorage>;
-    abstract event<TEvent extends keyof InferIOOutput<MergeEvents<TEvents, TIO>>>(event: TEvent, callback: EventNotifierSubscriptionCallback<MergeEvents<TEvents, TIO>, TEvent>): () => void;
-    abstract getConnection(): WebSocketConnection;
-    abstract getMyPresence(): TPresence;
-    abstract getMyself(): Id<UserInfo<TIO, TPresence>> | null;
-    abstract getOther(connectionId: string): Id<UserInfo<TIO, TPresence>> | null;
-    abstract getOthers(): readonly Id<UserInfo<TIO, TPresence>>[];
-    abstract getStorage<TKey extends keyof TStorage>(type: TKey): TStorage[TKey] | null;
-    abstract getStorageJson(): InferCrdtJson<TStorage> | null;
-    abstract getStorageJson<TKey extends keyof TStorage>(type: TKey): InferCrdtJson<TStorage[TKey]> | null;
-    abstract other(connectionId: string, callback: OtherNotifierSubscriptionCallback<TIO>): () => void;
-    abstract redo(): void;
-    abstract storage<TKey extends keyof TStorage>(key: TKey, fn: (value: InferCrdtJson<TStorage[TKey]>) => void): () => void;
-    abstract storageRoot(fn: (value: {
-        [P in keyof TStorage]: InferCrdtJson<TStorage[P]>;
-    }) => void): () => void;
-    abstract subscribe<TSubject extends keyof StateNotifierSubjects<TIO, TPresence>>(name: TSubject, callback: SubscriptionCallback<TIO, TPresence, TSubject>): () => void;
-    abstract transact(fn: (storage: TStorage) => void, origin?: string): void;
-    abstract undo(): void;
-    abstract updateMyPresence(presence: UpdateMyPresenceAction<TPresence>): void;
-}
-
-declare abstract class AbstractStorageStore {
-    room: string;
-    constructor(room: string);
-    abstract addUpdate(update: string): Promise<void>;
-    abstract destroy(): Promise<void>;
-    abstract flatten(encodedState: string): Promise<void>;
-    abstract getShouldFlatten(): Promise<boolean>;
-    abstract getUpdates(start?: number): Promise<readonly string[]>;
-    abstract initialize(): Promise<void>;
-}
-
-declare const identity: <T extends unknown>(x: T) => T;
-
-type InferCallback<TIO extends IOLike<any, any>> = (i: typeof identity) => {
-    io: (io: TIO) => TIO;
-};
-declare const infer: <TIO extends IOLike<any, any>>(callback: InferCallback<TIO>) => InferCallback<TIO>;
-
-type CrdtManagerOptions<TStorage extends Record<string, CrdtType<any, any>> = {}> = {
-    encodedState?: string | Uint8Array | null;
-    initialStorage?: AbstractCrdtDocFactory<TStorage>;
-};
-
 type UsersManagerConfig<TPresence extends JsonObject = {}> = {
     initialPresence?: TPresence;
     presence?: InputZodLike<TPresence>;
@@ -191,34 +122,39 @@ type PluvRoomDebug<TIO extends IOLike> = Id<{
     output: readonly (keyof InferIOOutput<TIO>)[];
     input: readonly (keyof InferIOInput<TIO>)[];
 }>;
+type RoomConnectParams<TMetadata extends JsonObject = {}> = keyof TMetadata extends never ? [] : [WithMetadata<TMetadata>];
+interface ReconnectTimeoutMsParams {
+    attempts: number;
+}
+type ReconnectTimeoutMs = number | ((params: ReconnectTimeoutMsParams) => number);
 type RoomConfig<TIO extends IOLike, TMetadata extends JsonObject = {}, TPresence extends JsonObject = {}, TStorage extends Record<string, CrdtType<any, any>> = {}, TEvents extends PluvRouterEventConfig<TIO, TPresence, TStorage> = {}> = Id<{
     addons?: readonly PluvRoomAddon<TIO, TMetadata, TPresence, TStorage>[];
     debug?: boolean | PluvRoomDebug<TIO>;
     onAuthorizationFail?: (error: Error) => void;
+    metadata?: InputZodLike<TMetadata>;
     publicKey?: PublicKey<TMetadata>;
+    reconnectTimeoutMs?: ReconnectTimeoutMs;
     router?: PluvRouter<TIO, TPresence, TStorage, TEvents>;
-} & RoomEndpoints<TIO, TMetadata> & Pick<CrdtManagerOptions<TStorage>, "initialStorage"> & UsersManagerConfig<TPresence> & (keyof TMetadata extends never ? {
-    metadata?: undefined;
-} : {
-    metadata: TMetadata;
-})>;
+} & RoomEndpoints<TIO, TMetadata> & Pick<CrdtManagerOptions<TStorage>, "initialStorage"> & UsersManagerConfig<TPresence>>;
 declare 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> {
     readonly _endpoints: RoomEndpoints<TIO, TMetadata>;
+    readonly metadata?: InputZodLike<TMetadata>;
     private readonly _crdtManager;
     private readonly _crdtNotifier;
     private readonly _debug;
     private readonly _eventNotifier;
     private readonly _intervals;
     private readonly _listeners;
-    private readonly _metadata;
     private readonly _otherNotifier;
     private readonly _publicKey;
+    private readonly _reconnectTimeoutMs;
     private readonly _router;
     private readonly _stateNotifier;
     private readonly _storageStore;
     private readonly _subscriptions;
     private readonly _timeouts;
     private readonly _usersManager;
+    private _lastMetadata;
     private _state;
     private _windowListeners;
     private _wsListeners;
@@ -228,7 +164,7 @@ declare class PluvRoom<TIO extends IOLike<any, any>, TMetadata extends JsonObjec
     broadcast: (<TEvent extends keyof InferIOInput<MergeEvents<TEvents, TIO>>>(event: TEvent, data: Id<InferIOInput<MergeEvents<TEvents, TIO>>[TEvent]>) => Promise<void>) & { [PEvent in keyof InferIOInput<MergeEvents<TEvents, TIO>>]: (data: Id<InferIOInput<MergeEvents<TEvents, TIO>>[PEvent]>) => Promise<void>; };
     canRedo: () => boolean;
     canUndo: () => boolean;
-    connect(): Promise<void>;
+    connect(...args: RoomConnectParams<TMetadata>): Promise<void>;
     disconnect(): Promise<void>;
     event: (<TEvent extends keyof InferIOOutput<MergeEvents<TEvents, TIO>>>(event: TEvent, callback: EventNotifierSubscriptionCallback<MergeEvents<TEvents, TIO>, TEvent>) => () => void) & { [PEvent in keyof InferIOOutput<MergeEvents<TEvents, TIO>>]: (callback: EventNotifierSubscriptionCallback<MergeEvents<TEvents, TIO>, PEvent>) => () => void; };
     getConnection: () => WebSocketConnection;
@@ -275,28 +211,23 @@ declare class PluvRoom<TIO extends IOLike<any, any>, TMetadata extends JsonObjec
     private _logDebug;
     private _observeCrdt;
     private _onAuthorizationFail;
-    /**
-     * TODO
-     * @description Determine if ws was closed with a code for closing without retries.
-     * Otherwise, attempt to retry again with incremental backoff
-     * @author leedavidcs
-     * @date August 19, 2022
-     */
     private _onClose;
     /**
      * TODO
      * @description Handle websocket errors in a meaningful way, should they occur
-     * @author leedavidcs
      * @date August 19, 2022
      */
     private _onError;
     private _onMessage;
     private _onOpen;
+    private _onNavigatorOffline;
     private _onNavigatorOnline;
     private _onVisibilityChange;
     private _parseMessage;
+    private _pollReconnect;
     private _reconnect;
     private _sendMessage;
+    private _setMetadata;
     private _updateState;
 }
 
@@ -314,17 +245,15 @@ type CreateRoomOptions<TIO extends IOLike<any, any>, TPresence extends JsonObjec
     initialPresence?: TPresence;
     initialStorage?: AbstractCrdtDocFactory<TStorage>;
     onAuthorizationFail?: (error: Error) => void;
+    reconnectTimeoutMs?: ReconnectTimeoutMs;
     router?: PluvRouter<TIO, TPresence, TStorage, TEvents>;
-} & (keyof TMetadata extends never ? {
-    metadata?: undefined;
-} : {
-    metadata: TMetadata;
-});
+};
+type EnterRoomParams<TMetadata extends JsonObject = {}> = keyof TMetadata extends never ? [] : [WithMetadata<TMetadata>];
 declare class PluvClient<TIO extends IOLike<any, any>, TPresence extends JsonObject = {}, TStorage extends Record<string, CrdtType<any, any>> = {}, TMetadata extends JsonObject = {}> {
+    readonly metadata?: InputZodLike<TMetadata>;
     private readonly _authEndpoint;
     private readonly _debug;
     private readonly _initialStorage?;
-    private readonly _metadata?;
     private readonly _presence?;
     private readonly _publicKey;
     private readonly _rooms;
@@ -335,7 +264,7 @@ declare class PluvClient<TIO extends IOLike<any, any>, TPresence extends JsonObj
     get procedure(): PluvProcedure<TIO, {}, {}, TPresence, TStorage>;
     constructor(options: PluvClientOptions<TIO, TPresence, TStorage, TMetadata>);
     createRoom: <TEvents extends PluvRouterEventConfig<TIO, TPresence, TStorage> = {}>(room: string, options: CreateRoomOptions<TIO, TPresence, TStorage, TMetadata, TEvents>) => PluvRoom<TIO, TMetadata, TPresence, TStorage, TEvents>;
-    enter: (room: string | PluvRoom<TIO, any, any, any>) => Promise<PluvRoom<TIO, TMetadata, TPresence, TStorage, any>>;
+    enter: (room: string | PluvRoom<TIO, TMetadata, any, any, any>, ...args: EnterRoomParams<TMetadata>) => Promise<PluvRoom<TIO, TMetadata, TPresence, TStorage, any>>;
     getRoom: (room: string) => PluvRoom<TIO, TMetadata, TPresence, TStorage, any> | null;
     getRooms: () => readonly PluvRoom<TIO, TMetadata, TPresence, TStorage, any>[];
     leave: (room: string | PluvRoom<TIO, any, any, any>) => Promise<void>;
@@ -343,6 +272,94 @@ declare class PluvClient<TIO extends IOLike<any, any>, TPresence extends JsonObj
     private _logDebug;
 }
 
+interface AuthorizationState<TIO extends IOLike> {
+    token: string | null;
+    user: InferIOAuthorizeUser<InferIOAuthorize<TIO>> | null;
+}
+type EventResolver<TIO extends IOLike = IOLike, TInput extends JsonObject = {}, TOutput extends EventRecord<string, any> = {}, TPresence extends JsonObject = {}, TStorage extends Record<string, CrdtType<any, any>> = {}> = (data: TInput, context: EventResolverContext<TIO, TPresence, TStorage>) => MaybePromise<TOutput | void>;
+interface EventResolverContext<TIO extends IOLike = IOLike, TPresence extends JsonObject = {}, TStorage extends Record<string, CrdtType<any, any>> = {}> {
+    doc: AbstractCrdtDoc<TStorage>;
+    others: readonly UserInfo<TIO, TPresence>[];
+    room: string;
+    user: UserInfo<TIO, TPresence>;
+}
+type InferMetadata<TClient extends PluvClient<any, any, any, any>> = TClient extends PluvClient<any, any, any, infer IMetadata> ? IMetadata : never;
+type MergeEventRecords<TEventRecords extends EventRecord<string, any>[], TRoot extends EventRecord<string, any> = {}> = TEventRecords extends [
+    infer IHead extends EventRecord<string, any>,
+    ...infer ITail extends EventRecord<string, any>[]
+] ? MergeEventRecords<ITail, Omit<TRoot, keyof IHead> & {
+    [P in keyof IHead]: TRoot extends Record<P, any> ? TRoot[P] | IHead[P] : IHead[P];
+}> : Id<TRoot>;
+interface PublicKeyParams<TMetadata extends JsonObject> {
+    metadata: TMetadata;
+}
+type PublicKey<TMetadata extends JsonObject> = string | ((params: PublicKeyParams<TMetadata>) => string);
+type UpdateMyPresenceAction<TPresence extends JsonObject> = Partial<TPresence> | ((oldPresence: TPresence | null) => Partial<TPresence>);
+interface UserInfo<TIO extends IOLike, TPresence extends JsonObject = {}> {
+    connectionId: string;
+    presence: TPresence;
+    user: Id<InferIOAuthorizeUser<InferIOAuthorize<TIO>>>;
+}
+interface WebSocketConnection {
+    /**
+     * @description How many times a connection attempt was made. This will increment upon each
+     * unsuccessful attempt, and will reset upon a successful connection.
+     * @date April 13, 2025
+     */
+    attempts: number;
+    /**
+     * @description How many times the user has connected to the room. This can be more than 1 in
+     * the case of reconnects. This is tracked because on the very first connection (i.e. when
+     * count is 0) we don't want to send the storage state as an update to the room and overwrite
+     * the upstream state.
+     * @date April 13, 2025
+     */
+    count: number;
+    id: string | null;
+    state: ConnectionState;
+}
+interface WebSocketState<TIO extends IOLike> {
+    authorization: AuthorizationState<TIO>;
+    connection: WebSocketConnection;
+    webSocket: WebSocket | null;
+}
+type WithMetadata<TMetadata extends JsonObject = {}> = keyof TMetadata extends never ? {
+    metadata?: undefined;
+} : {
+    metadata: TMetadata;
+};
+
+type OtherNotifierSubscriptionCallback<TIO extends IOLike> = (value: Id<UserInfo<TIO>> | null) => void;
+
+declare abstract class AbstractRoom<TIO extends IOLike, TPresence extends JsonObject = {}, TStorage extends Record<string, CrdtType<any, any>> = {}, TEvents extends PluvRouterEventConfig<TIO, TPresence, TStorage> = {}> {
+    readonly id: string;
+    constructor(room: string);
+    abstract storageLoaded: boolean;
+    abstract broadcast<TEvent extends keyof InferIOInput<MergeEvents<TEvents, TIO>>>(event: TEvent, data: Id<InferIOInput<MergeEvents<TEvents, TIO>>[TEvent]>): void;
+    abstract canRedo(): boolean;
+    abstract canUndo(): boolean;
+    abstract getDoc(): AbstractCrdtDoc<TStorage>;
+    abstract event<TEvent extends keyof InferIOOutput<MergeEvents<TEvents, TIO>>>(event: TEvent, callback: EventNotifierSubscriptionCallback<MergeEvents<TEvents, TIO>, TEvent>): () => void;
+    abstract getConnection(): WebSocketConnection;
+    abstract getMyPresence(): TPresence;
+    abstract getMyself(): Id<UserInfo<TIO, TPresence>> | null;
+    abstract getOther(connectionId: string): Id<UserInfo<TIO, TPresence>> | null;
+    abstract getOthers(): readonly Id<UserInfo<TIO, TPresence>>[];
+    abstract getStorage<TKey extends keyof TStorage>(type: TKey): TStorage[TKey] | null;
+    abstract getStorageJson(): InferCrdtJson<TStorage> | null;
+    abstract getStorageJson<TKey extends keyof TStorage>(type: TKey): InferCrdtJson<TStorage[TKey]> | null;
+    abstract other(connectionId: string, callback: OtherNotifierSubscriptionCallback<TIO>): () => void;
+    abstract redo(): void;
+    abstract storage<TKey extends keyof TStorage>(key: TKey, fn: (value: InferCrdtJson<TStorage[TKey]>) => void): () => void;
+    abstract storageRoot(fn: (value: {
+        [P in keyof TStorage]: InferCrdtJson<TStorage[P]>;
+    }) => void): () => void;
+    abstract subscribe<TSubject extends keyof StateNotifierSubjects<TIO, TPresence>>(name: TSubject, callback: SubscriptionCallback<TIO, TPresence, TSubject>): () => void;
+    abstract transact(fn: (storage: TStorage) => void, origin?: string): void;
+    abstract undo(): void;
+    abstract updateMyPresence(presence: UpdateMyPresenceAction<TPresence>): void;
+}
+
 declare const createClient: <TIO extends IOLike<any, any>, TPresence extends JsonObject = {}, TStorage extends Record<string, CrdtType<any, any>> = {}, TMetadata extends JsonObject = {}>(options: PluvClientOptions<TIO, TPresence, TStorage, TMetadata>) => PluvClient<TIO, TPresence, TStorage, TMetadata>;
 
 type MockedRoomEvents<TIO extends IOLike> = Partial<{
@@ -400,4 +417,4 @@ declare const register: <TMetadata extends JsonObject>(params: RegisterParams<TM
     wsEndpoint: (params: EndpointParams<TMetadata>) => string;
 };
 
-export { AbstractRoom, AbstractStorageStore, ConnectionState, type CreateRoomOptions, type InferCallback, type MergeEvents, MockedRoom, type MockedRoomConfig, type MockedRoomEvents, PluvClient, type PluvClientOptions, type PluvProcedureConfig, PluvRoom, type PluvRoomAddon, type PluvRoomAddonInput, type PluvRoomAddonResult, type PluvRoomDebug, PluvRouter, type PluvRouterEventConfig, type PublicKey, type PublicKeyParams, type RegisterParams, type RoomEndpoints, type UserInfo, type WebSocketConnection, type WebSocketState, createClient, infer, register };
+export { AbstractRoom, AbstractStorageStore, ConnectionState, type CreateRoomOptions, type EnterRoomParams, type InferCallback, type InferMetadata, type MergeEvents, MockedRoom, type MockedRoomConfig, type MockedRoomEvents, PluvClient, type PluvClientOptions, type PluvProcedureConfig, PluvRoom, type PluvRoomAddon, type PluvRoomAddonInput, type PluvRoomAddonResult, type PluvRoomDebug, PluvRouter, type PluvRouterEventConfig, type PublicKey, type PublicKeyParams, type RegisterParams, type RoomConnectParams, type RoomEndpoints, type UserInfo, type WebSocketConnection, type WebSocketState, createClient, infer, register };