@pluv/types 2.0.2 → 2.2.0

package/.turbo/turbo-build.log

@@ -1,5 +1,5 @@
 
-> @pluv/types@2.0.2 build /home/runner/work/pluv/pluv/packages/types
+> @pluv/types@2.2.0 build /home/runner/work/pluv/pluv/packages/types
 > 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 1.21 KB
+ESM dist/index.mjs 330.00 B
+ESM ⚡️ Build success in 33ms
+CJS dist/index.js 1.37 KB
 CJS ⚡️ Build success in 33ms
-ESM dist/index.mjs 197.00 B
-ESM ⚡️ Build success in 34ms
 DTS Build start
-DTS ⚡️ Build success in 1191ms
-DTS dist/index.d.mts 14.71 KB
-DTS dist/index.d.ts  14.71 KB
+DTS ⚡️ Build success in 1278ms
+DTS dist/index.d.mts 18.73 KB
+DTS dist/index.d.ts  18.73 KB

package/CHANGELOG.md

@@ -1,5 +1,9 @@
 # @pluv/types
 
+## 2.2.0
+
+## 2.1.0
+
 ## 2.0.2
 
 ## 2.0.1

package/dist/index.d.mts

@@ -56,13 +56,14 @@ interface DocBatchApplyEncodedStateParams {
     origin?: string;
     updates?: Maybe<readonly Maybe<string | Uint8Array>[]>;
 }
-interface DocSubscribeCallbackParams<TStorage extends Record<string, CrdtType<any, any>>> {
-    doc: CrdtDocLike<TStorage>;
+interface DocSubscribeCallbackParams<TDoc extends any, TStorage extends Record<string, CrdtType<any, any>>> {
+    doc: CrdtDocLike<TDoc, TStorage>;
     local: boolean;
     origin?: string | null;
     update: string;
 }
-interface CrdtDocLike<TStorage extends Record<string, CrdtType<any, any>>> {
+interface CrdtDocLike<TDoc extends any, TStorage extends Record<string, CrdtType<any, any>>> {
+    value: TDoc;
     applyEncodedState(params: DocApplyEncodedStateParams): this;
     batchApplyEncodedState(params: DocBatchApplyEncodedStateParams): this;
     canRedo(): boolean;
@@ -74,7 +75,7 @@ interface CrdtDocLike<TStorage extends Record<string, CrdtType<any, any>>> {
     isEmpty(): boolean;
     rebuildStorage(reference: TStorage): this;
     redo(): this;
-    subscribe(listener: (params: DocSubscribeCallbackParams<TStorage>) => void): () => void;
+    subscribe(listener: (params: DocSubscribeCallbackParams<TDoc, TStorage>) => void): () => void;
     toJson(): InferCrdtJson<TStorage>;
     toJson<TKey extends keyof TStorage>(type: TKey): InferCrdtJson<TStorage[TKey]>;
     track(): this;
@@ -83,13 +84,20 @@ interface CrdtDocLike<TStorage extends Record<string, CrdtType<any, any>>> {
 }
 
 declare const ConnectionState: {
-    readonly Closed: "Closed";
-    readonly Connecting: "Connecting";
-    readonly Open: "Open";
-    readonly Unavailable: "Unavailable";
-    readonly Untouched: "Untouched";
+    readonly Closed: "closed";
+    readonly Connecting: "connecting";
+    readonly Open: "open";
+    readonly Unavailable: "unavailable";
+    readonly Untouched: "untouched";
 };
 type ConnectionState = (typeof ConnectionState)[keyof typeof ConnectionState];
+declare const StorageState: {
+    Loading: string;
+    Offline: string;
+    Synced: string;
+    Unavailable: string;
+};
+type StorageState = (typeof StorageState)[keyof typeof StorageState];
 
 type BaseUser = {
     id: string;
@@ -242,19 +250,36 @@ interface AuthorizationState<TIO extends IOLike> {
     token: string | null;
     user: Id<InferIOAuthorizeUser<InferIOAuthorize<TIO>>> | null;
 }
-type EventNotifierSubscriptionCallback<TIO extends IOLike<any, any>, TEvent extends keyof InferIOOutput<TIO>> = (value: Id<IOEventMessage<TIO, TEvent>>) => void;
-type OtherNotifierSubscriptionCallback<TIO extends IOLike, TPresence extends JsonObject> = (value: Id<UserInfo<TIO, TPresence>> | null) => void;
-interface StateNotifierSubjects<TIO extends IOLike, TPresence extends JsonObject> {
+type OtherSubscriptionCallback<TIO extends IOLike, TPresence extends Record<string, any>> = (value: Id<UserInfo<TIO, TPresence>> | null) => void;
+type OtherSubscriptionFn<TIO extends IOLike, TPresence extends Record<string, any>> = (connectionId: string, callback: OtherSubscriptionCallback<TIO, TPresence>) => () => void;
+type OthersSubscriptionEvent<TIO extends IOLike, TPresence extends Record<string, any>> = {
+    kind: "clear";
+} | {
+    kind: "enter";
+    user: Id<UserInfo<TIO, TPresence>>;
+} | {
+    kind: "leave";
+    user: Id<UserInfo<TIO, TPresence>>;
+} | {
+    kind: "sync";
+    users: readonly Id<UserInfo<TIO, TPresence>>[];
+} | {
+    kind: "update";
+    user: Id<UserInfo<TIO, TPresence>>;
+};
+type OthersSubscriptionCallback<TIO extends IOLike, TPresence extends Record<string, any>> = (value: readonly Id<UserInfo<TIO, TPresence>>[], event: OthersSubscriptionEvent<TIO, TPresence>) => void;
+type OthersSubscriptionFn<TIO extends IOLike, TPresence extends Record<string, any>> = (callback: OthersSubscriptionCallback<TIO, TPresence>) => () => void;
+interface StateNotifierSubjects<TIO extends IOLike, TPresence extends Record<string, any>> {
     connection: Subject<Id<WebSocketState<TIO>>>;
     "my-presence": Subject<TPresence | null>;
-    myself: Subject<Readonly<Id<UserInfo<TIO>>> | null>;
-    others: Subject<readonly Id<UserInfo<TIO>>[]>;
+    myself: Subject<Readonly<Id<UserInfo<TIO, TPresence>>> | null>;
+    others: Subject<readonly Id<UserInfo<TIO, TPresence>>[]>;
     "storage-loaded": Subject<boolean>;
 }
-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;
-type UpdateMyPresenceAction<TPresence extends JsonObject> = Partial<TPresence> | ((oldPresence: TPresence | null) => Partial<TPresence>);
-interface UserInfo<TIO extends IOLike, TPresence extends JsonObject = {}> {
+type InferSubjectValue<TIO extends IOLike, TPresence extends Record<string, any>, TSubject extends keyof StateNotifierSubjects<TIO, TPresence>> = StateNotifierSubjects<TIO, TPresence>[TSubject] extends Subject<infer IValue> ? Id<IValue> : never;
+type SubscriptionCallback<TIO extends IOLike, TPresence extends Record<string, any>, TSubject extends keyof StateNotifierSubjects<TIO, TPresence>> = (value: InferSubjectValue<TIO, TPresence, TSubject>) => void;
+type UpdateMyPresenceAction<TPresence extends Record<string, any>> = Partial<TPresence> | ((oldPresence: TPresence | null) => Partial<TPresence>);
+interface UserInfo<TIO extends IOLike, TPresence extends Record<string, any> = {}> {
     connectionId: string;
     presence: TPresence;
     user: Id<InferIOAuthorizeUser<InferIOAuthorize<TIO>>>;
@@ -266,30 +291,64 @@ interface WebSocketConnection {
      * @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 StorageInfo {
+    state: StorageState;
+}
 interface WebSocketState<TIO extends IOLike> {
     authorization: AuthorizationState<TIO>;
     connection: WebSocketConnection;
+    storage: StorageInfo;
     webSocket: WebSocket | null;
 }
-interface RoomLike<TIO extends IOLike, TPresence extends JsonObject = {}, TStorage extends Record<string, CrdtType<any, any>> = {}, TEvents extends PluvRouterEventConfig = {}> {
+type BroadcastProxy<TIO extends IOLike, TEvents extends PluvRouterEventConfig> = (<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>;
+};
+type EventNotifierSubscriptionCallback<TIO extends IOLike<any, any>, TEvent extends keyof InferIOOutput<TIO>> = (value: Id<IOEventMessage<TIO, TEvent>>) => void;
+type EventSubscriptionFn<TIO extends IOLike, TEvents extends PluvRouterEventConfig> = <TEvent extends keyof InferIOOutput<MergeEvents<TEvents, TIO>>>(event: TEvent, callback: EventNotifierSubscriptionCallback<MergeEvents<TEvents, TIO>, TEvent>) => () => void;
+type EventProxy<TIO extends IOLike, TEvents extends PluvRouterEventConfig> = EventSubscriptionFn<TIO, TEvents> & {
+    [PEvent in keyof InferIOOutput<MergeEvents<TEvents, TIO>>]: (callback: EventNotifierSubscriptionCallback<MergeEvents<TEvents, TIO>, PEvent>) => () => void;
+};
+type StorageSubscriptionCallback<TStorage extends Record<string, CrdtType<any, any>>, TKey extends keyof TStorage> = (value: InferCrdtJson<TStorage[TKey]>) => void;
+type StorageSubscriptionFn<TStorage extends Record<string, CrdtType<any, any>>> = <TKey extends keyof TStorage>(key: TKey, fn: StorageSubscriptionCallback<TStorage, TKey>) => () => void;
+type StorageRootSubscriptionCallback<TStorage extends Record<string, CrdtType<any, any>>> = (value: {
+    [P in keyof TStorage]: InferCrdtJson<TStorage[P]>;
+}) => void;
+type StorageRootSubscriptionFn<TStorage extends Record<string, CrdtType<any, any>>> = (callback: StorageRootSubscriptionCallback<TStorage>) => () => void;
+type StorageProxy<TStorage extends Record<string, CrdtType<any, any>>> = StorageSubscriptionFn<TStorage> & StorageRootSubscriptionFn<TStorage> & {
+    [PKey in keyof TStorage]: (callback: StorageSubscriptionCallback<TStorage, PKey>) => () => void;
+};
+type SubscribeFn<TValue extends unknown> = (callback: (value: TValue) => void) => () => void;
+type SubscribeProxy<TIO extends IOLike, TPresence extends Record<string, any>, TStorage extends Record<string, CrdtType<any, any>>, TEvents extends PluvRouterEventConfig> = (<TSubject extends keyof StateNotifierSubjects<TIO, TPresence>>(name: TSubject, callback: SubscriptionCallback<TIO, TPresence, TSubject>) => () => void) & {
+    connection: SubscribeFn<Id<WebSocketState<TIO>>>;
+    event: EventProxy<TIO, TEvents>;
+    myPresence: SubscribeFn<TPresence | null>;
+    myself: SubscribeFn<Id<UserInfo<TIO>> | null>;
+    other: OtherSubscriptionFn<TIO, TPresence>;
+    others: OthersSubscriptionFn<TIO, TPresence>;
+    storage: StorageProxy<TStorage>;
+    storageLoaded: SubscribeFn<boolean>;
+};
+interface RoomEventListenerMap {
+    close: (event: CloseEvent | null) => void;
+    error: (event: Event) => void;
+    message: (event: MessageEvent<any>) => void;
+    open: (event: Event) => void;
+}
+interface RoomLike<TIO extends IOLike, TDoc extends any, TPresence extends Record<string, any> = {}, TStorage extends Record<string, CrdtType<any, any>> = {}, TEvents extends PluvRouterEventConfig = {}> {
     id: string;
+    broadcast: BroadcastProxy<TIO, TEvents>;
+    /**
+     * @deprecated To be removed in v3. Use getStorageLoaded instead.
+     */
     storageLoaded: boolean;
-    broadcast<TEvent extends keyof InferIOInput<MergeEvents<TEvents, TIO>>>(event: TEvent, data: Id<InferIOInput<MergeEvents<TEvents, TIO>>[TEvent]>): void;
+    addEventListener<TKind extends keyof RoomEventListenerMap>(kind: TKind, handler: RoomEventListenerMap[TKind]): () => void;
     canRedo(): boolean;
     canUndo(): boolean;
-    getDoc(): CrdtDocLike<TStorage>;
-    event<TEvent extends keyof InferIOOutput<MergeEvents<TEvents, TIO>>>(event: TEvent, callback: EventNotifierSubscriptionCallback<MergeEvents<TEvents, TIO>, TEvent>): () => void;
+    getDoc(): CrdtDocLike<TDoc, TStorage>;
+    event: EventProxy<TIO, TEvents>;
     getConnection(): WebSocketConnection;
     getMyPresence(): TPresence;
     getMyself(): Id<UserInfo<TIO, TPresence>> | null;
@@ -298,16 +357,17 @@ interface RoomLike<TIO extends IOLike, TPresence extends JsonObject = {}, TStora
     getStorage<TKey extends keyof TStorage>(type: TKey): TStorage[TKey] | null;
     getStorageJson(): InferCrdtJson<TStorage> | null;
     getStorageJson<TKey extends keyof TStorage>(type: TKey): InferCrdtJson<TStorage[TKey]> | null;
-    other(connectionId: string, callback: OtherNotifierSubscriptionCallback<TIO, TPresence>): () => void;
+    getStorageLoaded: () => boolean;
+    other(connectionId: string, callback: OtherSubscriptionCallback<TIO, TPresence>): () => void;
     redo(): void;
-    storage<TKey extends keyof TStorage>(key: TKey, fn: (value: InferCrdtJson<TStorage[TKey]>) => void): () => void;
+    storage: StorageProxy<TStorage>;
     storageRoot(fn: (value: {
         [P in keyof TStorage]: InferCrdtJson<TStorage[P]>;
     }) => void): () => void;
-    subscribe<TSubject extends keyof StateNotifierSubjects<TIO, TPresence>>(name: TSubject, callback: SubscriptionCallback<TIO, TPresence, TSubject>): () => void;
+    subscribe: SubscribeProxy<TIO, TPresence, TStorage, TEvents>;
     transact(fn: (storage: TStorage) => void, origin?: string): void;
     undo(): void;
     updateMyPresence(presence: UpdateMyPresenceAction<TPresence>): void;
 }
 
-export { type BaseClientEventRecord, type BaseClientMessage, type BaseIOEventRecord, type BaseUser, ConnectionState, type Constructable, type CrdtDocLike, type CrdtType, type DeepPartial, type DeepWriteable, type DocApplyEncodedStateParams, type DocBatchApplyEncodedStateParams, type DocSubscribeCallbackParams, type EventMessage, type EventNotifierSubscriptionCallback, type EventRecord, type GetEventMessage, type IOAuthorize, type IOAuthorizeEventMessage, type IOEventMessage, type IOLike, type IORouterLike, type Id, type InferEventMessage, type InferEventsInput, type InferEventsOutput, type InferIOAuthorize, type InferIOAuthorizeUser, type InferIOInput, type InferIOOutput, type InputZodLike, type Json, type JsonObject, type JsonPrimitive, type Maybe, type MaybePromise, type MaybeReadonlyArray, type MergeEvents, type NonNilProps, type OptionalProps, type OtherNotifierSubscriptionCallback, type ProcedureLike, type RoomLike, type Spread, type SpreadProperties, type UndefinedProps, type UpdateMyPresenceAction, type UserInfo, type WebSocketConnection, type WebSocketState };
+export { type BaseClientEventRecord, type BaseClientMessage, type BaseIOEventRecord, type BaseUser, type BroadcastProxy, ConnectionState, type Constructable, type CrdtDocLike, type CrdtType, type DeepPartial, type DeepWriteable, type DocApplyEncodedStateParams, type DocBatchApplyEncodedStateParams, type DocSubscribeCallbackParams, type EventMessage, type EventNotifierSubscriptionCallback, type EventProxy, type EventRecord, type GetEventMessage, type IOAuthorize, type IOAuthorizeEventMessage, type IOEventMessage, type IOLike, type IORouterLike, type Id, type InferCrdtJson, type InferEventMessage, type InferEventsInput, type InferEventsOutput, type InferIOAuthorize, type InferIOAuthorizeUser, type InferIOInput, type InferIOOutput, type InputZodLike, type Json, type JsonObject, type JsonPrimitive, type Maybe, type MaybePromise, type MaybeReadonlyArray, type MergeEvents, type NonNilProps, type OptionalProps, type OtherSubscriptionCallback, type OtherSubscriptionFn, type OthersSubscriptionCallback, type OthersSubscriptionEvent, type OthersSubscriptionFn, type PluvRouterEventConfig, type ProcedureLike, type RoomEventListenerMap, type RoomLike, type Spread, type SpreadProperties, type StateNotifierSubjects, type StorageInfo, type StorageProxy, type StorageRootSubscriptionCallback, type StorageRootSubscriptionFn, StorageState, type StorageSubscriptionCallback, type StorageSubscriptionFn, type SubscribeFn, type SubscribeProxy, type SubscriptionCallback, type UndefinedProps, type UpdateMyPresenceAction, type UserInfo, type WebSocketConnection, type WebSocketState };

package/dist/index.d.ts

@@ -56,13 +56,14 @@ interface DocBatchApplyEncodedStateParams {
     origin?: string;
     updates?: Maybe<readonly Maybe<string | Uint8Array>[]>;
 }
-interface DocSubscribeCallbackParams<TStorage extends Record<string, CrdtType<any, any>>> {
-    doc: CrdtDocLike<TStorage>;
+interface DocSubscribeCallbackParams<TDoc extends any, TStorage extends Record<string, CrdtType<any, any>>> {
+    doc: CrdtDocLike<TDoc, TStorage>;
     local: boolean;
     origin?: string | null;
     update: string;
 }
-interface CrdtDocLike<TStorage extends Record<string, CrdtType<any, any>>> {
+interface CrdtDocLike<TDoc extends any, TStorage extends Record<string, CrdtType<any, any>>> {
+    value: TDoc;
     applyEncodedState(params: DocApplyEncodedStateParams): this;
     batchApplyEncodedState(params: DocBatchApplyEncodedStateParams): this;
     canRedo(): boolean;
@@ -74,7 +75,7 @@ interface CrdtDocLike<TStorage extends Record<string, CrdtType<any, any>>> {
     isEmpty(): boolean;
     rebuildStorage(reference: TStorage): this;
     redo(): this;
-    subscribe(listener: (params: DocSubscribeCallbackParams<TStorage>) => void): () => void;
+    subscribe(listener: (params: DocSubscribeCallbackParams<TDoc, TStorage>) => void): () => void;
     toJson(): InferCrdtJson<TStorage>;
     toJson<TKey extends keyof TStorage>(type: TKey): InferCrdtJson<TStorage[TKey]>;
     track(): this;
@@ -83,13 +84,20 @@ interface CrdtDocLike<TStorage extends Record<string, CrdtType<any, any>>> {
 }
 
 declare const ConnectionState: {
-    readonly Closed: "Closed";
-    readonly Connecting: "Connecting";
-    readonly Open: "Open";
-    readonly Unavailable: "Unavailable";
-    readonly Untouched: "Untouched";
+    readonly Closed: "closed";
+    readonly Connecting: "connecting";
+    readonly Open: "open";
+    readonly Unavailable: "unavailable";
+    readonly Untouched: "untouched";
 };
 type ConnectionState = (typeof ConnectionState)[keyof typeof ConnectionState];
+declare const StorageState: {
+    Loading: string;
+    Offline: string;
+    Synced: string;
+    Unavailable: string;
+};
+type StorageState = (typeof StorageState)[keyof typeof StorageState];
 
 type BaseUser = {
     id: string;
@@ -242,19 +250,36 @@ interface AuthorizationState<TIO extends IOLike> {
     token: string | null;
     user: Id<InferIOAuthorizeUser<InferIOAuthorize<TIO>>> | null;
 }
-type EventNotifierSubscriptionCallback<TIO extends IOLike<any, any>, TEvent extends keyof InferIOOutput<TIO>> = (value: Id<IOEventMessage<TIO, TEvent>>) => void;
-type OtherNotifierSubscriptionCallback<TIO extends IOLike, TPresence extends JsonObject> = (value: Id<UserInfo<TIO, TPresence>> | null) => void;
-interface StateNotifierSubjects<TIO extends IOLike, TPresence extends JsonObject> {
+type OtherSubscriptionCallback<TIO extends IOLike, TPresence extends Record<string, any>> = (value: Id<UserInfo<TIO, TPresence>> | null) => void;
+type OtherSubscriptionFn<TIO extends IOLike, TPresence extends Record<string, any>> = (connectionId: string, callback: OtherSubscriptionCallback<TIO, TPresence>) => () => void;
+type OthersSubscriptionEvent<TIO extends IOLike, TPresence extends Record<string, any>> = {
+    kind: "clear";
+} | {
+    kind: "enter";
+    user: Id<UserInfo<TIO, TPresence>>;
+} | {
+    kind: "leave";
+    user: Id<UserInfo<TIO, TPresence>>;
+} | {
+    kind: "sync";
+    users: readonly Id<UserInfo<TIO, TPresence>>[];
+} | {
+    kind: "update";
+    user: Id<UserInfo<TIO, TPresence>>;
+};
+type OthersSubscriptionCallback<TIO extends IOLike, TPresence extends Record<string, any>> = (value: readonly Id<UserInfo<TIO, TPresence>>[], event: OthersSubscriptionEvent<TIO, TPresence>) => void;
+type OthersSubscriptionFn<TIO extends IOLike, TPresence extends Record<string, any>> = (callback: OthersSubscriptionCallback<TIO, TPresence>) => () => void;
+interface StateNotifierSubjects<TIO extends IOLike, TPresence extends Record<string, any>> {
     connection: Subject<Id<WebSocketState<TIO>>>;
     "my-presence": Subject<TPresence | null>;
-    myself: Subject<Readonly<Id<UserInfo<TIO>>> | null>;
-    others: Subject<readonly Id<UserInfo<TIO>>[]>;
+    myself: Subject<Readonly<Id<UserInfo<TIO, TPresence>>> | null>;
+    others: Subject<readonly Id<UserInfo<TIO, TPresence>>[]>;
     "storage-loaded": Subject<boolean>;
 }
-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;
-type UpdateMyPresenceAction<TPresence extends JsonObject> = Partial<TPresence> | ((oldPresence: TPresence | null) => Partial<TPresence>);
-interface UserInfo<TIO extends IOLike, TPresence extends JsonObject = {}> {
+type InferSubjectValue<TIO extends IOLike, TPresence extends Record<string, any>, TSubject extends keyof StateNotifierSubjects<TIO, TPresence>> = StateNotifierSubjects<TIO, TPresence>[TSubject] extends Subject<infer IValue> ? Id<IValue> : never;
+type SubscriptionCallback<TIO extends IOLike, TPresence extends Record<string, any>, TSubject extends keyof StateNotifierSubjects<TIO, TPresence>> = (value: InferSubjectValue<TIO, TPresence, TSubject>) => void;
+type UpdateMyPresenceAction<TPresence extends Record<string, any>> = Partial<TPresence> | ((oldPresence: TPresence | null) => Partial<TPresence>);
+interface UserInfo<TIO extends IOLike, TPresence extends Record<string, any> = {}> {
     connectionId: string;
     presence: TPresence;
     user: Id<InferIOAuthorizeUser<InferIOAuthorize<TIO>>>;
@@ -266,30 +291,64 @@ interface WebSocketConnection {
      * @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 StorageInfo {
+    state: StorageState;
+}
 interface WebSocketState<TIO extends IOLike> {
     authorization: AuthorizationState<TIO>;
     connection: WebSocketConnection;
+    storage: StorageInfo;
     webSocket: WebSocket | null;
 }
-interface RoomLike<TIO extends IOLike, TPresence extends JsonObject = {}, TStorage extends Record<string, CrdtType<any, any>> = {}, TEvents extends PluvRouterEventConfig = {}> {
+type BroadcastProxy<TIO extends IOLike, TEvents extends PluvRouterEventConfig> = (<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>;
+};
+type EventNotifierSubscriptionCallback<TIO extends IOLike<any, any>, TEvent extends keyof InferIOOutput<TIO>> = (value: Id<IOEventMessage<TIO, TEvent>>) => void;
+type EventSubscriptionFn<TIO extends IOLike, TEvents extends PluvRouterEventConfig> = <TEvent extends keyof InferIOOutput<MergeEvents<TEvents, TIO>>>(event: TEvent, callback: EventNotifierSubscriptionCallback<MergeEvents<TEvents, TIO>, TEvent>) => () => void;
+type EventProxy<TIO extends IOLike, TEvents extends PluvRouterEventConfig> = EventSubscriptionFn<TIO, TEvents> & {
+    [PEvent in keyof InferIOOutput<MergeEvents<TEvents, TIO>>]: (callback: EventNotifierSubscriptionCallback<MergeEvents<TEvents, TIO>, PEvent>) => () => void;
+};
+type StorageSubscriptionCallback<TStorage extends Record<string, CrdtType<any, any>>, TKey extends keyof TStorage> = (value: InferCrdtJson<TStorage[TKey]>) => void;
+type StorageSubscriptionFn<TStorage extends Record<string, CrdtType<any, any>>> = <TKey extends keyof TStorage>(key: TKey, fn: StorageSubscriptionCallback<TStorage, TKey>) => () => void;
+type StorageRootSubscriptionCallback<TStorage extends Record<string, CrdtType<any, any>>> = (value: {
+    [P in keyof TStorage]: InferCrdtJson<TStorage[P]>;
+}) => void;
+type StorageRootSubscriptionFn<TStorage extends Record<string, CrdtType<any, any>>> = (callback: StorageRootSubscriptionCallback<TStorage>) => () => void;
+type StorageProxy<TStorage extends Record<string, CrdtType<any, any>>> = StorageSubscriptionFn<TStorage> & StorageRootSubscriptionFn<TStorage> & {
+    [PKey in keyof TStorage]: (callback: StorageSubscriptionCallback<TStorage, PKey>) => () => void;
+};
+type SubscribeFn<TValue extends unknown> = (callback: (value: TValue) => void) => () => void;
+type SubscribeProxy<TIO extends IOLike, TPresence extends Record<string, any>, TStorage extends Record<string, CrdtType<any, any>>, TEvents extends PluvRouterEventConfig> = (<TSubject extends keyof StateNotifierSubjects<TIO, TPresence>>(name: TSubject, callback: SubscriptionCallback<TIO, TPresence, TSubject>) => () => void) & {
+    connection: SubscribeFn<Id<WebSocketState<TIO>>>;
+    event: EventProxy<TIO, TEvents>;
+    myPresence: SubscribeFn<TPresence | null>;
+    myself: SubscribeFn<Id<UserInfo<TIO>> | null>;
+    other: OtherSubscriptionFn<TIO, TPresence>;
+    others: OthersSubscriptionFn<TIO, TPresence>;
+    storage: StorageProxy<TStorage>;
+    storageLoaded: SubscribeFn<boolean>;
+};
+interface RoomEventListenerMap {
+    close: (event: CloseEvent | null) => void;
+    error: (event: Event) => void;
+    message: (event: MessageEvent<any>) => void;
+    open: (event: Event) => void;
+}
+interface RoomLike<TIO extends IOLike, TDoc extends any, TPresence extends Record<string, any> = {}, TStorage extends Record<string, CrdtType<any, any>> = {}, TEvents extends PluvRouterEventConfig = {}> {
     id: string;
+    broadcast: BroadcastProxy<TIO, TEvents>;
+    /**
+     * @deprecated To be removed in v3. Use getStorageLoaded instead.
+     */
     storageLoaded: boolean;
-    broadcast<TEvent extends keyof InferIOInput<MergeEvents<TEvents, TIO>>>(event: TEvent, data: Id<InferIOInput<MergeEvents<TEvents, TIO>>[TEvent]>): void;
+    addEventListener<TKind extends keyof RoomEventListenerMap>(kind: TKind, handler: RoomEventListenerMap[TKind]): () => void;
     canRedo(): boolean;
     canUndo(): boolean;
-    getDoc(): CrdtDocLike<TStorage>;
-    event<TEvent extends keyof InferIOOutput<MergeEvents<TEvents, TIO>>>(event: TEvent, callback: EventNotifierSubscriptionCallback<MergeEvents<TEvents, TIO>, TEvent>): () => void;
+    getDoc(): CrdtDocLike<TDoc, TStorage>;
+    event: EventProxy<TIO, TEvents>;
     getConnection(): WebSocketConnection;
     getMyPresence(): TPresence;
     getMyself(): Id<UserInfo<TIO, TPresence>> | null;
@@ -298,16 +357,17 @@ interface RoomLike<TIO extends IOLike, TPresence extends JsonObject = {}, TStora
     getStorage<TKey extends keyof TStorage>(type: TKey): TStorage[TKey] | null;
     getStorageJson(): InferCrdtJson<TStorage> | null;
     getStorageJson<TKey extends keyof TStorage>(type: TKey): InferCrdtJson<TStorage[TKey]> | null;
-    other(connectionId: string, callback: OtherNotifierSubscriptionCallback<TIO, TPresence>): () => void;
+    getStorageLoaded: () => boolean;
+    other(connectionId: string, callback: OtherSubscriptionCallback<TIO, TPresence>): () => void;
     redo(): void;
-    storage<TKey extends keyof TStorage>(key: TKey, fn: (value: InferCrdtJson<TStorage[TKey]>) => void): () => void;
+    storage: StorageProxy<TStorage>;
     storageRoot(fn: (value: {
         [P in keyof TStorage]: InferCrdtJson<TStorage[P]>;
     }) => void): () => void;
-    subscribe<TSubject extends keyof StateNotifierSubjects<TIO, TPresence>>(name: TSubject, callback: SubscriptionCallback<TIO, TPresence, TSubject>): () => void;
+    subscribe: SubscribeProxy<TIO, TPresence, TStorage, TEvents>;
     transact(fn: (storage: TStorage) => void, origin?: string): void;
     undo(): void;
     updateMyPresence(presence: UpdateMyPresenceAction<TPresence>): void;
 }
 
-export { type BaseClientEventRecord, type BaseClientMessage, type BaseIOEventRecord, type BaseUser, ConnectionState, type Constructable, type CrdtDocLike, type CrdtType, type DeepPartial, type DeepWriteable, type DocApplyEncodedStateParams, type DocBatchApplyEncodedStateParams, type DocSubscribeCallbackParams, type EventMessage, type EventNotifierSubscriptionCallback, type EventRecord, type GetEventMessage, type IOAuthorize, type IOAuthorizeEventMessage, type IOEventMessage, type IOLike, type IORouterLike, type Id, type InferEventMessage, type InferEventsInput, type InferEventsOutput, type InferIOAuthorize, type InferIOAuthorizeUser, type InferIOInput, type InferIOOutput, type InputZodLike, type Json, type JsonObject, type JsonPrimitive, type Maybe, type MaybePromise, type MaybeReadonlyArray, type MergeEvents, type NonNilProps, type OptionalProps, type OtherNotifierSubscriptionCallback, type ProcedureLike, type RoomLike, type Spread, type SpreadProperties, type UndefinedProps, type UpdateMyPresenceAction, type UserInfo, type WebSocketConnection, type WebSocketState };
+export { type BaseClientEventRecord, type BaseClientMessage, type BaseIOEventRecord, type BaseUser, type BroadcastProxy, ConnectionState, type Constructable, type CrdtDocLike, type CrdtType, type DeepPartial, type DeepWriteable, type DocApplyEncodedStateParams, type DocBatchApplyEncodedStateParams, type DocSubscribeCallbackParams, type EventMessage, type EventNotifierSubscriptionCallback, type EventProxy, type EventRecord, type GetEventMessage, type IOAuthorize, type IOAuthorizeEventMessage, type IOEventMessage, type IOLike, type IORouterLike, type Id, type InferCrdtJson, type InferEventMessage, type InferEventsInput, type InferEventsOutput, type InferIOAuthorize, type InferIOAuthorizeUser, type InferIOInput, type InferIOOutput, type InputZodLike, type Json, type JsonObject, type JsonPrimitive, type Maybe, type MaybePromise, type MaybeReadonlyArray, type MergeEvents, type NonNilProps, type OptionalProps, type OtherSubscriptionCallback, type OtherSubscriptionFn, type OthersSubscriptionCallback, type OthersSubscriptionEvent, type OthersSubscriptionFn, type PluvRouterEventConfig, type ProcedureLike, type RoomEventListenerMap, type RoomLike, type Spread, type SpreadProperties, type StateNotifierSubjects, type StorageInfo, type StorageProxy, type StorageRootSubscriptionCallback, type StorageRootSubscriptionFn, StorageState, type StorageSubscriptionCallback, type StorageSubscriptionFn, type SubscribeFn, type SubscribeProxy, type SubscriptionCallback, type UndefinedProps, type UpdateMyPresenceAction, type UserInfo, type WebSocketConnection, type WebSocketState };

package/dist/index.js

@@ -20,19 +20,27 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
-  ConnectionState: () => ConnectionState
+  ConnectionState: () => ConnectionState,
+  StorageState: () => StorageState
 });
 module.exports = __toCommonJS(index_exports);
 
 // src/pluv/enums.ts
 var ConnectionState = {
-  Closed: "Closed",
-  Connecting: "Connecting",
-  Open: "Open",
-  Unavailable: "Unavailable",
-  Untouched: "Untouched"
+  Closed: "closed",
+  Connecting: "connecting",
+  Open: "open",
+  Unavailable: "unavailable",
+  Untouched: "untouched"
+};
+var StorageState = {
+  Loading: "loading",
+  Offline: "offline",
+  Synced: "synced",
+  Unavailable: "unavailable"
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  ConnectionState
+  ConnectionState,
+  StorageState
 });

package/dist/index.mjs

@@ -1,11 +1,18 @@
 // src/pluv/enums.ts
 var ConnectionState = {
-  Closed: "Closed",
-  Connecting: "Connecting",
-  Open: "Open",
-  Unavailable: "Unavailable",
-  Untouched: "Untouched"
+  Closed: "closed",
+  Connecting: "connecting",
+  Open: "open",
+  Unavailable: "unavailable",
+  Untouched: "untouched"
+};
+var StorageState = {
+  Loading: "loading",
+  Offline: "offline",
+  Synced: "synced",
+  Unavailable: "unavailable"
 };
 export {
-  ConnectionState
+  ConnectionState,
+  StorageState
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pluv/types",
-  "version": "2.0.2",
+  "version": "2.2.0",
   "description": "@pluv/io shared types",
   "author": "leedavidcs",
   "license": "MIT",
@@ -19,8 +19,8 @@
     "eslint": "^9.26.0",
     "tsup": "^8.4.0",
     "typescript": "^5.8.3",
-    "@pluv/tsconfig": "^2.0.2",
-    "eslint-config-pluv": "^2.0.2"
+    "@pluv/tsconfig": "^2.2.0",
+    "eslint-config-pluv": "^2.2.0"
   },
   "dependencies": {
     "wonka": "^6.3.5"

package/src/index.ts

@@ -15,12 +15,13 @@ export type {
     SpreadProperties,
     UndefinedProps,
 } from "./general";
-export { ConnectionState } from "./pluv";
+export { ConnectionState, StorageState } from "./pluv";
 export type {
     BaseClientEventRecord,
     BaseClientMessage,
     BaseIOEventRecord,
     BaseUser,
+    BroadcastProxy,
     CrdtDocLike,
     CrdtType,
     DocApplyEncodedStateParams,
@@ -28,8 +29,10 @@ export type {
     DocSubscribeCallbackParams,
     EventMessage,
     EventNotifierSubscriptionCallback,
+    EventProxy,
     EventRecord,
     GetEventMessage,
+    InferCrdtJson,
     InferEventMessage,
     InferEventsInput,
     InferEventsOutput,
@@ -44,9 +47,25 @@ export type {
     IOLike,
     IORouterLike,
     MergeEvents,
-    OtherNotifierSubscriptionCallback,
+    OthersSubscriptionCallback,
+    OthersSubscriptionEvent,
+    OthersSubscriptionFn,
+    OtherSubscriptionCallback,
+    OtherSubscriptionFn,
+    PluvRouterEventConfig,
     ProcedureLike,
+    RoomEventListenerMap,
     RoomLike,
+    StateNotifierSubjects,
+    StorageInfo,
+    StorageProxy,
+    StorageRootSubscriptionCallback,
+    StorageRootSubscriptionFn,
+    StorageSubscriptionCallback,
+    StorageSubscriptionFn,
+    SubscribeFn,
+    SubscribeProxy,
+    SubscriptionCallback,
     UpdateMyPresenceAction,
     UserInfo,
     WebSocketConnection,

package/src/pluv/crdt.ts

@@ -30,14 +30,22 @@ export interface DocBatchApplyEncodedStateParams {
     updates?: Maybe<readonly Maybe<string | Uint8Array>[]>;
 }
 
-export interface DocSubscribeCallbackParams<TStorage extends Record<string, CrdtType<any, any>>> {
-    doc: CrdtDocLike<TStorage>;
+export interface DocSubscribeCallbackParams<
+    TDoc extends any,
+    TStorage extends Record<string, CrdtType<any, any>>,
+> {
+    doc: CrdtDocLike<TDoc, TStorage>;
     local: boolean;
     origin?: string | null;
     update: string;
 }
 
-export interface CrdtDocLike<TStorage extends Record<string, CrdtType<any, any>>> {
+export interface CrdtDocLike<
+    TDoc extends any,
+    TStorage extends Record<string, CrdtType<any, any>>,
+> {
+    value: TDoc;
+
     applyEncodedState(params: DocApplyEncodedStateParams): this;
     batchApplyEncodedState(params: DocBatchApplyEncodedStateParams): this;
     canRedo(): boolean;
@@ -49,7 +57,7 @@ export interface CrdtDocLike<TStorage extends Record<string, CrdtType<any, any>>
     isEmpty(): boolean;
     rebuildStorage(reference: TStorage): this;
     redo(): this;
-    subscribe(listener: (params: DocSubscribeCallbackParams<TStorage>) => void): () => void;
+    subscribe(listener: (params: DocSubscribeCallbackParams<TDoc, TStorage>) => void): () => void;
     toJson(): InferCrdtJson<TStorage>;
     toJson<TKey extends keyof TStorage>(type: TKey): InferCrdtJson<TStorage[TKey]>;
     track(): this;

package/src/pluv/enums.ts

@@ -1,9 +1,18 @@
 export const ConnectionState = {
-    Closed: "Closed",
-    Connecting: "Connecting",
-    Open: "Open",
-    Unavailable: "Unavailable",
-    Untouched: "Untouched",
+    Closed: "closed",
+    Connecting: "connecting",
+    Open: "open",
+    Unavailable: "unavailable",
+    Untouched: "untouched",
 } as const;
 
 export type ConnectionState = (typeof ConnectionState)[keyof typeof ConnectionState];
+
+export const StorageState = {
+    Loading: "loading",
+    Offline: "offline",
+    Synced: "synced",
+    Unavailable: "unavailable",
+};
+
+export type StorageState = (typeof StorageState)[keyof typeof StorageState];

package/src/pluv/room.ts

@@ -1,7 +1,7 @@
 import type { Subject } from "wonka";
-import type { ConnectionState } from "./enums";
 import type { Id, JsonObject } from "../general";
 import type { CrdtDocLike, CrdtType, InferCrdtJson } from "./crdt";
+import type { ConnectionState, StorageState } from "./enums";
 import type {
     InferIOAuthorize,
     InferIOAuthorizeUser,
@@ -18,26 +18,45 @@ export interface AuthorizationState<TIO extends IOLike> {
     user: Id<InferIOAuthorizeUser<InferIOAuthorize<TIO>>> | null;
 }
 
-export type EventNotifierSubscriptionCallback<
-    TIO extends IOLike<any, any>,
-    TEvent extends keyof InferIOOutput<TIO>,
-> = (value: Id<IOEventMessage<TIO, TEvent>>) => void;
-
-export type OtherNotifierSubscriptionCallback<TIO extends IOLike, TPresence extends JsonObject> = (
+export type OtherSubscriptionCallback<TIO extends IOLike, TPresence extends Record<string, any>> = (
     value: Id<UserInfo<TIO, TPresence>> | null,
 ) => void;
 
-export interface StateNotifierSubjects<TIO extends IOLike, TPresence extends JsonObject> {
+export type OtherSubscriptionFn<TIO extends IOLike, TPresence extends Record<string, any>> = (
+    connectionId: string,
+    callback: OtherSubscriptionCallback<TIO, TPresence>,
+) => () => void;
+
+export type OthersSubscriptionEvent<TIO extends IOLike, TPresence extends Record<string, any>> =
+    | { kind: "clear" }
+    | { kind: "enter"; user: Id<UserInfo<TIO, TPresence>> }
+    | { kind: "leave"; user: Id<UserInfo<TIO, TPresence>> }
+    | { kind: "sync"; users: readonly Id<UserInfo<TIO, TPresence>>[] }
+    | { kind: "update"; user: Id<UserInfo<TIO, TPresence>> };
+
+export type OthersSubscriptionCallback<
+    TIO extends IOLike,
+    TPresence extends Record<string, any>,
+> = (
+    value: readonly Id<UserInfo<TIO, TPresence>>[],
+    event: OthersSubscriptionEvent<TIO, TPresence>,
+) => void;
+
+export type OthersSubscriptionFn<TIO extends IOLike, TPresence extends Record<string, any>> = (
+    callback: OthersSubscriptionCallback<TIO, TPresence>,
+) => () => void;
+
+export interface StateNotifierSubjects<TIO extends IOLike, TPresence extends Record<string, any>> {
     connection: Subject<Id<WebSocketState<TIO>>>;
     "my-presence": Subject<TPresence | null>;
-    myself: Subject<Readonly<Id<UserInfo<TIO>>> | null>;
-    others: Subject<readonly Id<UserInfo<TIO>>[]>;
+    myself: Subject<Readonly<Id<UserInfo<TIO, TPresence>>> | null>;
+    others: Subject<readonly Id<UserInfo<TIO, TPresence>>[]>;
     "storage-loaded": Subject<boolean>;
 }
 
 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>
@@ -46,15 +65,15 @@ type InferSubjectValue<
 
 export type SubscriptionCallback<
     TIO extends IOLike,
-    TPresence extends JsonObject,
+    TPresence extends Record<string, any>,
     TSubject extends keyof StateNotifierSubjects<TIO, TPresence>,
 > = (value: InferSubjectValue<TIO, TPresence, TSubject>) => void;
 
-export type UpdateMyPresenceAction<TPresence extends JsonObject> =
+export type UpdateMyPresenceAction<TPresence extends Record<string, any>> =
     | Partial<TPresence>
     | ((oldPresence: TPresence | null) => Partial<TPresence>);
 
-export interface UserInfo<TIO extends IOLike, TPresence extends JsonObject = {}> {
+export interface UserInfo<TIO extends IOLike, TPresence extends Record<string, any> = {}> {
     connectionId: string;
     presence: TPresence;
     user: Id<InferIOAuthorizeUser<InferIOAuthorize<TIO>>>;
@@ -67,48 +86,134 @@ export interface WebSocketConnection {
      * @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;
 }
 
+export interface StorageInfo {
+    state: StorageState;
+}
+
 export interface WebSocketState<TIO extends IOLike> {
     authorization: AuthorizationState<TIO>;
     connection: WebSocketConnection;
+    storage: StorageInfo;
     webSocket: WebSocket | null;
 }
 
+export type BroadcastProxy<TIO extends IOLike, TEvents extends PluvRouterEventConfig> = (<
+    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>;
+};
+
+export type EventNotifierSubscriptionCallback<
+    TIO extends IOLike<any, any>,
+    TEvent extends keyof InferIOOutput<TIO>,
+> = (value: Id<IOEventMessage<TIO, TEvent>>) => void;
+
+export type EventSubscriptionFn<TIO extends IOLike, TEvents extends PluvRouterEventConfig> = <
+    TEvent extends keyof InferIOOutput<MergeEvents<TEvents, TIO>>,
+>(
+    event: TEvent,
+    callback: EventNotifierSubscriptionCallback<MergeEvents<TEvents, TIO>, TEvent>,
+) => () => void;
+
+export type EventProxy<
+    TIO extends IOLike,
+    TEvents extends PluvRouterEventConfig,
+> = EventSubscriptionFn<TIO, TEvents> & {
+    [PEvent in keyof InferIOOutput<MergeEvents<TEvents, TIO>>]: (
+        callback: EventNotifierSubscriptionCallback<MergeEvents<TEvents, TIO>, PEvent>,
+    ) => () => void;
+};
+
+export type StorageSubscriptionCallback<
+    TStorage extends Record<string, CrdtType<any, any>>,
+    TKey extends keyof TStorage,
+> = (value: InferCrdtJson<TStorage[TKey]>) => void;
+
+export type StorageSubscriptionFn<TStorage extends Record<string, CrdtType<any, any>>> = <
+    TKey extends keyof TStorage,
+>(
+    key: TKey,
+    fn: StorageSubscriptionCallback<TStorage, TKey>,
+) => () => void;
+
+export type StorageRootSubscriptionCallback<TStorage extends Record<string, CrdtType<any, any>>> =
+    (value: { [P in keyof TStorage]: InferCrdtJson<TStorage[P]> }) => void;
+
+export type StorageRootSubscriptionFn<TStorage extends Record<string, CrdtType<any, any>>> = (
+    callback: StorageRootSubscriptionCallback<TStorage>,
+) => () => void;
+
+export type StorageProxy<TStorage extends Record<string, CrdtType<any, any>>> =
+    StorageSubscriptionFn<TStorage> &
+        StorageRootSubscriptionFn<TStorage> & {
+            [PKey in keyof TStorage]: (
+                callback: StorageSubscriptionCallback<TStorage, PKey>,
+            ) => () => void;
+        };
+
+export type SubscribeFn<TValue extends unknown> = (callback: (value: TValue) => void) => () => void;
+
+export type SubscribeProxy<
+    TIO extends IOLike,
+    TPresence extends Record<string, any>,
+    TStorage extends Record<string, CrdtType<any, any>>,
+    TEvents extends PluvRouterEventConfig,
+> = (<TSubject extends keyof StateNotifierSubjects<TIO, TPresence>>(
+    name: TSubject,
+    callback: SubscriptionCallback<TIO, TPresence, TSubject>,
+) => () => void) & {
+    connection: SubscribeFn<Id<WebSocketState<TIO>>>;
+    event: EventProxy<TIO, TEvents>;
+    myPresence: SubscribeFn<TPresence | null>;
+    myself: SubscribeFn<Id<UserInfo<TIO>> | null>;
+    other: OtherSubscriptionFn<TIO, TPresence>;
+    others: OthersSubscriptionFn<TIO, TPresence>;
+    storage: StorageProxy<TStorage>;
+    storageLoaded: SubscribeFn<boolean>;
+};
+
+export interface RoomEventListenerMap {
+    close: (event: CloseEvent | null) => void;
+    error: (event: Event) => void;
+    message: (event: MessageEvent<any>) => void;
+    open: (event: Event) => void;
+}
+
 export interface RoomLike<
     TIO extends IOLike,
-    TPresence extends JsonObject = {},
+    TDoc extends any,
+    TPresence extends Record<string, any> = {},
     TStorage extends Record<string, CrdtType<any, any>> = {},
     TEvents extends PluvRouterEventConfig = {},
 > {
     id: string;
+    broadcast: BroadcastProxy<TIO, TEvents>;
+    /**
+     * @deprecated To be removed in v3. Use getStorageLoaded instead.
+     */
     storageLoaded: boolean;
 
-    broadcast<TEvent extends keyof InferIOInput<MergeEvents<TEvents, TIO>>>(
-        event: TEvent,
-        data: Id<InferIOInput<MergeEvents<TEvents, TIO>>[TEvent]>,
-    ): void;
+    addEventListener<TKind extends keyof RoomEventListenerMap>(
+        kind: TKind,
+        handler: RoomEventListenerMap[TKind],
+    ): () => void;
 
     canRedo(): boolean;
 
     canUndo(): boolean;
 
-    getDoc(): CrdtDocLike<TStorage>;
+    getDoc(): CrdtDocLike<TDoc, TStorage>;
 
-    event<TEvent extends keyof InferIOOutput<MergeEvents<TEvents, TIO>>>(
-        event: TEvent,
-        callback: EventNotifierSubscriptionCallback<MergeEvents<TEvents, TIO>, TEvent>,
-    ): () => void;
+    event: EventProxy<TIO, TEvents>;
 
     getConnection(): WebSocketConnection;
 
@@ -125,17 +230,13 @@ export interface RoomLike<
     getStorageJson(): InferCrdtJson<TStorage> | null;
     getStorageJson<TKey extends keyof TStorage>(type: TKey): InferCrdtJson<TStorage[TKey]> | null;
 
-    other(
-        connectionId: string,
-        callback: OtherNotifierSubscriptionCallback<TIO, TPresence>,
-    ): () => void;
+    getStorageLoaded: () => boolean;
+
+    other(connectionId: string, callback: OtherSubscriptionCallback<TIO, TPresence>): () => void;
 
     redo(): void;
 
-    storage<TKey extends keyof TStorage>(
-        key: TKey,
-        fn: (value: InferCrdtJson<TStorage[TKey]>) => void,
-    ): () => void;
+    storage: StorageProxy<TStorage>;
 
     storageRoot(
         fn: (value: {
@@ -143,10 +244,7 @@ export interface RoomLike<
         }) => void,
     ): () => void;
 
-    subscribe<TSubject extends keyof StateNotifierSubjects<TIO, TPresence>>(
-        name: TSubject,
-        callback: SubscriptionCallback<TIO, TPresence, TSubject>,
-    ): () => void;
+    subscribe: SubscribeProxy<TIO, TPresence, TStorage, TEvents>;
 
     transact(fn: (storage: TStorage) => void, origin?: string): void;