@pluv/client 0.25.4 → 0.27.0

package/.turbo/turbo-build.log

@@ -1,18 +1,18 @@
 
-> @pluv/client@0.25.4 build /home/runner/work/pluv/pluv/packages/client
+> @pluv/client@0.27.0 build /home/runner/work/pluv/pluv/packages/client
 > tsup src/index.ts --format esm,cjs --dts
 
 CLI Building entry: src/index.ts
 CLI Using tsconfig: tsconfig.json
-CLI tsup v8.2.4
+CLI tsup v8.3.0
 CLI Target: es6
 ESM Build start
 CJS Build start
-CJS dist/index.js 43.49 KB
-CJS ⚡️ Build success in 146ms
-ESM dist/index.mjs 42.22 KB
-ESM ⚡️ Build success in 146ms
+CJS dist/index.js 47.68 KB
+CJS ⚡️ Build success in 129ms
+ESM dist/index.mjs 46.42 KB
+ESM ⚡️ Build success in 130ms
 DTS Build start
-DTS ⚡️ Build success in 3137ms
-DTS dist/index.d.mts 14.60 KB
-DTS dist/index.d.ts  14.60 KB
+DTS ⚡️ Build success in 3681ms
+DTS dist/index.d.mts 21.97 KB
+DTS dist/index.d.ts  21.97 KB

package/CHANGELOG.md

@@ -1,5 +1,184 @@
 # @pluv/client
 
+## 0.27.0
+
+### Minor Changes
+
+- 19ed36c: **BREAKNG**
+
+  Updated `createClient` and `PluvClient.createRoom` object params to better support automatic type inference.
+
+  ```ts
+  // Before
+  import { createClient } from "@pluv/client";
+  import { yjs } from "@pluv/crdt-yjs";
+  import { z } from "zod";
+  import type { ioServer } from "./server/ioServer";
+
+  const client = createClient<typeof ioServer>({
+    authEndpoint: ({ room }) => "MY_AUTH_URL",
+    wsEndpoint: ({ room }) => "MY_WEBSOCKET_URL",
+  });
+
+  client.createRoom("my-example-room", {
+    presence: z.object({
+      selectionId: z.string().nullish(),
+    }),
+    initialPresence: {
+      selectionId: null,
+    },
+    initialStorage: yjs.doc(() => ({
+      messages: yjs.array<string>([]),
+    })),
+  });
+
+  // After
+  const client = createClient({
+    authEndpoint: ({ room }) => "MY_AUTH_URL",
+    wsEndpoint: ({ room }) => "MY_WEBSOCKET_URL",
+    /**
+     * @description The ioServer type now needs to be inferred on this property
+     * instead of within the generic on `createClient`. This is because of
+     * limitations with TypeScript not yet supporting partial type-inference
+     * for generics. Ensure to no-loonger include any generics on `createClient`
+     */
+    infer: (i) => ({ io: i<typeof ioServer> }),
+    // Now moved to `createClient` from `PluvClient.createRoom`
+    presence: z.object({
+      selectionId: z.string().nullish(),
+    }),
+    /**
+     * @description Now added to `createClient` to specify defaults for all
+     * rooms, and to infer types for storage. This value will be overwritten by
+     * `PluvClient.createRoom`.
+     */
+    initialStorage: yjs.doc(() => ({
+      messages: yjs.array<string>([]),
+    })),
+  });
+
+  const room = client.createRoom("my-example-room", {
+    initialPresence: {
+      selectionId: null,
+    },
+    initialStorage: yjs.doc(() => ({
+      messages: yjs.array<string>([]),
+    })),
+  });
+  ```
+
+### Patch Changes
+
+- 19ed36c: Added client-side event router. This more-or-less mirrors the server-side event router. You can use both the server-side and client-side router simultaneously, but you should generally prefer only using one or the other.
+
+  ```ts
+  // Backend Server
+  import { createIO } from "@pluv/io";
+
+  const io = createIO({
+    /* ... */
+  });
+  const ioServer = io.server({
+    router: io.router({
+      multiply2: io.procedure
+        .input(z.object({ value: z.number() }))
+        .broadcast(({ value }) => ({
+          multiplied2: { value: value * 2 },
+        })),
+    }),
+  });
+
+  // Frontend Client
+  import { createClient } from "@pluv/client";
+
+  const io = createClient({
+    /* ... */
+  });
+
+  const room = io.createRoom("my-example-room", {
+    // ...
+    router: io.router({
+      add5: io.procedure
+        .input(z.object({ value: z.number() }))
+        .broadcast(({ value }) => ({
+          /**
+           * @description Because `ioServer` does not specify `added5`,
+           * this will be forwarded to connected peers.
+           */
+          added5: { value: value + 5 },
+        })),
+      /**
+       * @description This is possible, but not recommended to do. Because
+       * `multiply2` is a procedure on `ioServer`, this will trigger the
+       * `multiply2` procedure on `ioServer`. Connected peers will not
+       * receive `multiply2`, but rather `multipled2`.
+       */
+      subtract5Multiply2: io.procedure
+        .input(z.object({ value: z.number() }))
+        .broadcast(({ value }) => ({
+          multiply2: { value: value - 5 },
+        })),
+    }),
+  });
+  ```
+
+  - @pluv/crdt@0.27.0
+  - @pluv/types@0.27.0
+
+## 0.26.0
+
+### Minor Changes
+
+- 19e5dda: **BREAKING**
+  Update `authEndpoint` and `wsEndpoint` to now use a parameterized object that passes through additional data via a `metadata` property.
+
+  ```tsx
+  // Before
+
+  import { env } from "./env";
+  import type { ioServer } from "./server";
+
+  const client = createClient<typeof ioServer>({
+      authEndpoint: (room: string) => `${env.API_URL}}/room/${room}`,
+      wsEndpoint: (room: string) => `${env.WS_URL}/room/${room}`,
+  });
+
+  // After
+
+  const client = createClient<
+      typeof ioServer,
+      // Optional: You can specify types for metadata here. This is useful for Cloudflare Pages
+      { apiUrl: string; wsUrl: string }
+  >({
+      authEndpoint: ({ metadata, room }) => `${metadata.apiUrl}}/room/${room}`,
+      wsEndpoint: ({ metadata, room }) => `${{ metadata.wsUrl }}/room/${room}`,
+  });
+
+  client.createRoom("my-room", {
+      // This property exists when the `metadata` generic type is defined above
+      metadata: {
+          apiUrl: "https://example.com/api",
+          wsUrl: "wss://example.com/api",
+      },
+      // ...
+  });
+
+  <PluvRoomProvider
+      // This property exists when the `metadata` generic type is defined above
+      metadata={{
+          apiUrl: "https://example.com/api",
+          wsUrl: "wss://example.com/api",
+      }}
+  >
+      {/* ... */}
+  </PluvRoomProvider>
+  ```
+
+### Patch Changes
+
+- @pluv/crdt@0.26.0
+- @pluv/types@0.26.0
+
 ## 0.25.4
 
 ### Patch Changes

package/dist/index.d.mts

@@ -1,16 +1,12 @@
 import { CrdtType, AbstractCrdtDoc, InferCrdtJson, AbstractCrdtDocFactory } from '@pluv/crdt';
 export { CrdtType, InferCrdtJson } from '@pluv/crdt';
 import * as _pluv_types from '@pluv/types';
-import { IOLike, InferIOOutput, Id, IOEventMessage, JsonObject, InferIOAuthorizeUser, InferIOAuthorize, InferIOInput, InputZodLike, InferIOAuthorizeRequired } from '@pluv/types';
+import { IOLike, InferIOOutput, Id, IOEventMessage, JsonObject, InferIOAuthorizeUser, InferIOAuthorize, EventRecord, MaybePromise, InputZodLike, ProcedureLike, IORouterLike, InferIOInput, InferIOAuthorizeRequired } from '@pluv/types';
 export { BaseUser, EventMessage, EventRecord, IOEventMessage } from '@pluv/types';
 import { Subject } from 'wonka';
 
 type EventNotifierSubscriptionCallback<TIO extends IOLike, TEvent extends keyof InferIOOutput<TIO>> = (value: Id<IOEventMessage<TIO, TEvent>>) => void;
 
-interface AuthorizationState<TIO extends IOLike> {
-    token: string | null;
-    user: InferIOAuthorizeUser<InferIOAuthorize<TIO>> | null;
-}
 declare enum ConnectionState {
     Closed = "Closed",
     Connecting = "Connecting",
@@ -18,6 +14,24 @@ declare enum ConnectionState {
     Unavailable = "Unavailable",
     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>;
 type UpdateMyPresenceAction<TPresence extends JsonObject> = Partial<TPresence> | ((oldPresence: TPresence | null) => Partial<TPresence>);
 interface UserInfo<TIO extends IOLike, TPresence extends JsonObject = {}> {
     connectionId: string;
@@ -37,6 +51,40 @@ interface WebSocketState<TIO extends IOLike> {
 
 type OtherNotifierSubscriptionCallback<TIO extends IOLike> = (value: Id<UserInfo<TIO>> | null) => void;
 
+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;
+    input?: InputZodLike<TInput>;
+}
+declare class PluvProcedure<TIO extends IOLike = IOLike, TInput extends JsonObject = {}, TOutput extends EventRecord<string, any> = {}, TPresence extends JsonObject = {}, TStorage extends Record<string, CrdtType<any, any>> = {}, TFilled extends "input" | "broadcast" | "" = ""> {
+    private _broadcast;
+    private _input;
+    get config(): ProcedureLike<TInput, TOutput>["config"];
+    constructor(config?: PluvProcedureConfig<TIO, TInput, TOutput, TPresence, TStorage>);
+    broadcast<TResult extends EventRecord<string, any> = {}>(resolver: EventResolver<TIO, TInput, TResult, TPresence, TStorage>): Omit<PluvProcedure<TIO, TInput, MergeEventRecords<[TOutput, TResult]>, TPresence, TStorage, TFilled | "input" | "broadcast">, TFilled | "input" | "broadcast">;
+    input<TData extends JsonObject>(input: InputZodLike<TData>): Omit<PluvProcedure<TIO, TData, {}, TPresence, TStorage, TFilled | "input">, TFilled | "input">;
+    private _resolver;
+}
+
+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">;
+};
+type MergedRouter<TRouters extends PluvRouter<TIO, TPresence, TStorage, any>[] = [], TIO extends IOLike = IOLike, TPresence extends JsonObject = {}, TStorage extends Record<string, CrdtType<any, any>> = {}, TRoot extends TRouters[0]["_defs"]["events"] = {}> = TRouters extends [
+    infer IHead extends PluvRouter<TIO, TPresence, TStorage, any>,
+    ...infer ITail extends PluvRouter<TIO, TPresence, TStorage, any>[]
+] ? MergedRouter<ITail, TIO, TPresence, TStorage, TRoot & IHead["_defs"]["events"]> : PluvRouter<TIO, TPresence, TStorage, TRoot>;
+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;
+declare class PluvRouter<TIO extends IOLike = IOLike, TPresence extends JsonObject = {}, TStorage extends Record<string, CrdtType<any, any>> = {}, TEvents extends PluvRouterEventConfig<TIO, TPresence, TStorage> = {}> implements IORouterLike<TEvents> {
+    readonly _defs: {
+        events: TEvents;
+    };
+    constructor(events: TEvents);
+    static merge<TRouters extends PluvRouter<any, any, any, any>[]>(...routers: TRouters): MergedRouter<TRouters>;
+}
+
 interface StateNotifierSubjects<TIO extends IOLike, TPresence extends JsonObject> {
     connection: Subject<Id<WebSocketState<TIO>>>;
     "my-presence": Subject<TPresence | null>;
@@ -47,15 +95,15 @@ 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>> = {}> {
+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<TIO>>(event: TEvent, data: Id<InferIOInput<TIO>[TEvent]>): void;
+    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<TIO>>(event: TEvent, callback: EventNotifierSubscriptionCallback<TIO, TEvent>): () => void;
+    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;
@@ -97,48 +145,6 @@ type UsersManagerConfig<TPresence extends JsonObject = {}> = {
     presence?: InputZodLike<TPresence>;
 };
 
-type MockedRoomEvents<TIO extends IOLike> = Partial<{
-    [P in keyof InferIOInput<TIO>]: (data: Id<InferIOInput<TIO>[P]>) => Partial<InferIOOutput<TIO>>;
-}>;
-type MockedRoomConfig<TIO extends IOLike, TPresence extends JsonObject = {}, TStorage extends Record<string, CrdtType<any, any>> = {}> = {
-    events?: MockedRoomEvents<TIO>;
-} & Omit<CrdtManagerOptions<TStorage>, "encodedState"> & UsersManagerConfig<TPresence>;
-declare class MockedRoom<TIO extends IOLike, TPresence extends JsonObject = {}, TStorage extends Record<string, CrdtType<any, any>> = {}> extends AbstractRoom<TIO, TPresence, TStorage> {
-    private _crdtManager;
-    private _crdtNotifier;
-    private _eventNotifier;
-    private _events?;
-    private _otherNotifier;
-    private _state;
-    private _stateNotifier;
-    private _subscriptions;
-    private _usersManager;
-    constructor(room: string, options: MockedRoomConfig<TIO, TPresence, TStorage>);
-    get storageLoaded(): boolean;
-    broadcast<TEvent extends keyof InferIOInput<TIO>>(event: TEvent, data: Id<InferIOInput<TIO>[TEvent]>): void;
-    canRedo: () => boolean;
-    canUndo: () => boolean;
-    event: <TEvent extends keyof InferIOOutput<TIO>>(event: TEvent, callback: EventNotifierSubscriptionCallback<TIO, TEvent>) => (() => void);
-    getConnection: () => WebSocketConnection;
-    getDoc(): AbstractCrdtDoc<TStorage>;
-    getMyPresence: () => TPresence;
-    getMyself: () => Id<UserInfo<TIO, TPresence>> | null;
-    getOther: (connectionId: string) => Id<UserInfo<TIO, TPresence>> | null;
-    getOthers: () => readonly Id<UserInfo<TIO, TPresence>>[];
-    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>) => (() => void);
-    redo: () => void;
-    storage: <TKey extends keyof TStorage>(key: TKey, fn: (value: InferCrdtJson<TStorage[TKey]>) => void) => (() => void);
-    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);
-    transact: (fn: (storage: TStorage) => void, origin?: string) => void;
-    undo: () => void;
-    updateMyPresence: (presence: UpdateMyPresenceAction<TPresence>) => void;
-    private _observeCrdt;
-}
-
 declare global {
     var process: {
         env: {
@@ -146,22 +152,26 @@ declare global {
         };
     };
 }
-type AuthEndpoint = string | ((room: string) => string | FetchOptions) | true;
-type WsEndpoint = string | ((room: string) => string);
+interface EndpointParams<TMetadata extends JsonObject> {
+    metadata: TMetadata;
+    room: string;
+}
+type AuthEndpoint<TMetadata extends JsonObject> = string | ((params: EndpointParams<TMetadata>) => string | FetchOptions) | true;
+type WsEndpoint<TMetadata extends JsonObject> = string | ((params: EndpointParams<TMetadata>) => string);
 type FetchOptions = {
     url: string;
     options?: RequestInit;
 };
-type RoomEndpoints<TIO extends IOLike> = {
-    wsEndpoint?: WsEndpoint;
+type RoomEndpoints<TIO extends IOLike, TMetadata extends JsonObject> = {
+    wsEndpoint?: WsEndpoint<TMetadata>;
 } & (InferIOAuthorizeRequired<InferIOAuthorize<TIO>> extends true ? {
-    authEndpoint: AuthEndpoint;
+    authEndpoint: AuthEndpoint<TMetadata>;
 } : {
     authEndpoint?: undefined;
 });
-type PluvRoomAddon<TIO extends IOLike = IOLike, TPresence extends JsonObject = {}, TStorage extends Record<string, CrdtType<any, any>> = {}> = (input: PluvRoomAddonInput<TIO, TPresence, TStorage>) => Partial<PluvRoomAddonResult>;
-interface PluvRoomAddonInput<TIO extends IOLike = IOLike, TPresence extends JsonObject = {}, TStorage extends Record<string, CrdtType<any, any>> = {}> {
-    room: PluvRoom<TIO, TPresence, TStorage>;
+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>;
+interface PluvRoomAddonInput<TIO extends IOLike = IOLike, TMetadata extends JsonObject = {}, TPresence extends JsonObject = {}, TStorage extends Record<string, CrdtType<any, any>> = {}> {
+    room: PluvRoom<TIO, TMetadata, TPresence, TStorage>;
 }
 interface PluvRoomAddonResult {
     storage: AbstractStorageStore;
@@ -170,21 +180,27 @@ type PluvRoomDebug<TIO extends IOLike> = Id<{
     output: readonly (keyof InferIOOutput<TIO>)[];
     input: readonly (keyof InferIOInput<TIO>)[];
 }>;
-type PluvRoomOptions<TIO extends IOLike, TPresence extends JsonObject = {}, TStorage extends Record<string, CrdtType<any, any>> = {}> = {
-    addons?: readonly PluvRoomAddon<TIO, TPresence, TStorage>[];
+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;
-} & Omit<CrdtManagerOptions<TStorage>, "encodedState"> & UsersManagerConfig<TPresence>;
-type RoomConfig<TIO extends IOLike, TPresence extends JsonObject = {}, TStorage extends Record<string, CrdtType<any, any>> = {}> = RoomEndpoints<TIO> & PluvRoomOptions<TIO, TPresence, TStorage>;
-declare class PluvRoom<TIO extends IOLike, TPresence extends JsonObject = {}, TStorage extends Record<string, CrdtType<any, any>> = {}> extends AbstractRoom<TIO, TPresence, TStorage> {
-    readonly _endpoints: RoomEndpoints<TIO>;
+    router?: PluvRouter<TIO, TPresence, TStorage, TEvents>;
+} & RoomEndpoints<TIO, TMetadata> & Pick<CrdtManagerOptions<TStorage>, "initialStorage"> & UsersManagerConfig<TPresence> & (keyof TMetadata extends never ? {
+    metadata?: undefined;
+} : {
+    metadata: TMetadata;
+})>;
+declare class PluvRoom<TIO extends IOLike, 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>;
     private _crdtManager;
     private _crdtNotifier;
     private _debug;
     private _eventNotifier;
     private _intervals;
     private _listeners;
+    private _metadata;
     private _otherNotifier;
+    private _router;
     private _state;
     private _stateNotifier;
     private _storageStore;
@@ -193,15 +209,15 @@ declare class PluvRoom<TIO extends IOLike, TPresence extends JsonObject = {}, TS
     private _windowListeners;
     private _wsListeners;
     private _usersManager;
-    constructor(room: string, options: RoomConfig<TIO, TPresence, TStorage>);
+    constructor(room: string, options: RoomConfig<TIO, TMetadata, TPresence, TStorage, TEvents>);
     get storageLoaded(): boolean;
     get webSocket(): WebSocket | null;
-    broadcast: (<TEvent extends keyof InferIOInput<TIO>>(event: TEvent, data: Id<InferIOInput<TIO>[TEvent]>) => void) & { [event in keyof InferIOInput<TIO>]: (data: Id<InferIOInput<TIO>[event]>) => void; };
+    broadcast: (<TEvent extends keyof InferIOInput<MergeEvents<TEvents, TIO>>>(event: TEvent, data: Id<InferIOInput<MergeEvents<TEvents, TIO>>[TEvent]>) => Promise<void>) & { [event in keyof InferIOInput<TIO>]: (data: Id<InferIOInput<TIO>[event]>) => Promise<void>; };
     canRedo: () => boolean;
     canUndo: () => boolean;
     connect(): Promise<void>;
     disconnect(): Promise<void>;
-    event: (<TEvent extends keyof InferIOOutput<TIO>>(event: TEvent, callback: EventNotifierSubscriptionCallback<TIO, TEvent>) => () => void) & { [event in keyof InferIOOutput<TIO>]: (callback: EventNotifierSubscriptionCallback<TIO, event>) => () => void; };
+    event: (<TEvent extends keyof InferIOOutput<MergeEvents<TEvents, TIO>>>(event: TEvent, callback: EventNotifierSubscriptionCallback<MergeEvents<TEvents, TIO>, TEvent>) => () => void) & { [event in keyof InferIOOutput<MergeEvents<TEvents, TIO>>]: (callback: EventNotifierSubscriptionCallback<MergeEvents<TEvents, TIO>, any>) => () => void; };
     getConnection: () => WebSocketConnection;
     getDoc: () => AbstractCrdtDoc<TStorage>;
     getMyPresence: () => TPresence;
@@ -270,23 +286,93 @@ declare class PluvRoom<TIO extends IOLike, TPresence extends JsonObject = {}, TS
     private _updateState;
 }
 
-type PluvClientOptions<TIO extends IOLike> = RoomEndpoints<TIO> & {
+declare const identity: <T extends unknown>(x: T) => T;
+
+type InferCallback<TIO extends IOLike> = (i: typeof identity) => {
+    io: (io: TIO) => TIO;
+};
+type PluvClientOptions<TIO extends IOLike, TPresence extends JsonObject, TStorage extends Record<string, CrdtType<any, any>>, TMetadata extends JsonObject> = RoomEndpoints<TIO, TMetadata> & {
     debug?: boolean;
+    infer: InferCallback<TIO>;
+    initialStorage?: AbstractCrdtDocFactory<TStorage>;
+    metadata?: InputZodLike<TMetadata>;
+    presence?: InputZodLike<TPresence>;
 };
-declare class PluvClient<TIO extends IOLike = IOLike> {
+type CreateRoomOptions<TIO extends IOLike, TPresence extends JsonObject, TStorage extends Record<string, CrdtType<any, any>>, TMetadata extends JsonObject, TEvents extends PluvRouterEventConfig<TIO, TPresence, TStorage> = {}> = {
+    addons?: readonly PluvRoomAddon<TIO, TMetadata, TPresence, TStorage>[];
+    debug?: boolean | PluvRoomDebug<TIO>;
+    initialPresence?: TPresence;
+    initialStorage?: AbstractCrdtDocFactory<TStorage>;
+    onAuthorizationFail?: (error: Error) => void;
+    router?: PluvRouter<TIO, TPresence, TStorage, TEvents>;
+} & (keyof TMetadata extends never ? {
+    metadata?: undefined;
+} : {
+    metadata: TMetadata;
+});
+declare class PluvClient<TIO extends IOLike = IOLike, TPresence extends JsonObject = {}, TStorage extends Record<string, CrdtType<any, any>> = {}, TMetadata extends JsonObject = {}> {
     private _authEndpoint;
     private _debug;
+    private _initialStorage?;
+    private _presence?;
     private _wsEndpoint;
     private _rooms;
-    constructor(options: PluvClientOptions<TIO>);
-    createRoom: <TPresence extends JsonObject = {}, TStorage extends Record<string, CrdtType<any, any>> = {}>(room: string, options: PluvRoomOptions<TIO, TPresence, TStorage>) => PluvRoom<TIO, TPresence, TStorage>;
-    enter: (room: string | PluvRoom<TIO, any, any>) => Promise<PluvRoom<TIO, JsonObject, any>>;
-    getRoom: <TPresence extends JsonObject = {}, TStorage extends Record<string, CrdtType<any, any>> = {}>(room: string) => PluvRoom<TIO, TPresence, TStorage> | null;
-    getRooms: () => readonly PluvRoom<TIO, JsonObject, any>[];
-    leave: (room: string | PluvRoom<TIO, any, any>) => Promise<void>;
+    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>;
+    enter: (room: string | PluvRoom<TIO, any, any, any>) => 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>;
+    router<TEvents extends PluvRouterEventConfig<TIO, TPresence, TStorage> = {}>(events: TEvents): PluvRouter<TIO, TPresence, TStorage, TEvents>;
     private _logDebug;
 }
 
-declare const createClient: <TIO extends IOLike = IOLike<_pluv_types.IOAuthorize<any, any, any>, {}>>(options: PluvClientOptions<TIO>) => PluvClient<TIO>;
+declare const createClient: <TIO extends IOLike = IOLike<_pluv_types.IOAuthorize<any, 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<{
+    [P in keyof InferIOInput<TIO>]: (data: Id<InferIOInput<TIO>[P]>) => Partial<InferIOOutput<TIO>>;
+}>;
+type MockedRoomConfig<TIO extends IOLike, TPresence extends JsonObject = {}, TStorage extends Record<string, CrdtType<any, any>> = {}, TEvents extends PluvRouterEventConfig<TIO, TPresence, TStorage> = {}> = {
+    events?: MockedRoomEvents<MergeEvents<TEvents, TIO>>;
+    router?: PluvRouter<TIO, TPresence, TStorage, TEvents>;
+} & Pick<CrdtManagerOptions<TStorage>, "initialStorage"> & UsersManagerConfig<TPresence>;
+declare class MockedRoom<TIO extends IOLike, TPresence extends JsonObject = {}, TStorage extends Record<string, CrdtType<any, any>> = {}, TEvents extends PluvRouterEventConfig<TIO, TPresence, TStorage> = {}> extends AbstractRoom<TIO, TPresence, TStorage> {
+    private _crdtManager;
+    private _crdtNotifier;
+    private _eventNotifier;
+    private _events?;
+    private _otherNotifier;
+    private _router;
+    private _state;
+    private _stateNotifier;
+    private _subscriptions;
+    private _usersManager;
+    constructor(room: string, options: MockedRoomConfig<TIO, TPresence, TStorage, TEvents>);
+    get storageLoaded(): boolean;
+    broadcast: (<TEvent extends keyof InferIOInput<MergeEvents<TEvents, TIO>>>(event: TEvent, data: Id<InferIOInput<MergeEvents<TEvents, TIO>>[TEvent]>) => Promise<void>) & { [event in keyof InferIOInput<TIO>]: (data: Id<InferIOInput<TIO>[event]>) => Promise<void>; };
+    canRedo: () => boolean;
+    canUndo: () => boolean;
+    event: (<TEvent extends keyof InferIOOutput<MergeEvents<TEvents, TIO>>>(event: TEvent, callback: EventNotifierSubscriptionCallback<MergeEvents<TEvents, TIO>, TEvent>) => () => void) & { [event in keyof InferIOOutput<MergeEvents<TEvents, TIO>>]: (callback: EventNotifierSubscriptionCallback<MergeEvents<TEvents, TIO>, any>) => () => void; };
+    getConnection: () => WebSocketConnection;
+    getDoc(): AbstractCrdtDoc<TStorage>;
+    getMyPresence: () => TPresence;
+    getMyself: () => Id<UserInfo<TIO, TPresence>> | null;
+    getOther: (connectionId: string) => Id<UserInfo<TIO, TPresence>> | null;
+    getOthers: () => readonly Id<UserInfo<TIO, TPresence>>[];
+    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>) => (() => void);
+    redo: () => void;
+    storage: <TKey extends keyof TStorage>(key: TKey, fn: (value: InferCrdtJson<TStorage[TKey]>) => void) => (() => void);
+    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);
+    transact: (fn: (storage: TStorage) => void, origin?: string) => void;
+    undo: () => void;
+    updateMyPresence: (presence: UpdateMyPresenceAction<TPresence>) => void;
+    private _observeCrdt;
+    private _simulateEvent;
+}
 
-export { AbstractRoom, AbstractStorageStore, ConnectionState, MockedRoom, type MockedRoomConfig, type MockedRoomEvents, PluvClient, type PluvClientOptions, PluvRoom, type PluvRoomAddon, type PluvRoomAddonInput, type PluvRoomAddonResult, type PluvRoomDebug, type UserInfo, type WebSocketConnection, type WebSocketState, createClient };
+export { AbstractRoom, AbstractStorageStore, ConnectionState, type CreateRoomOptions, 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 UserInfo, type WebSocketConnection, type WebSocketState, createClient };