@pluv/client 0.26.0 → 0.28.0

package/.turbo/turbo-build.log

@@ -1,18 +1,18 @@
 
-> @pluv/client@0.26.0 build /home/runner/work/pluv/pluv/packages/client
+> @pluv/client@0.28.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
-ESM dist/index.mjs 42.38 KB
-ESM ⚡️ Build success in 133ms
-CJS dist/index.js 43.65 KB
-CJS ⚡️ Build success in 134ms
+ESM dist/index.mjs 46.50 KB
+ESM ⚡️ Build success in 141ms
+CJS dist/index.js 47.76 KB
+CJS ⚡️ Build success in 141ms
 DTS Build start
-DTS ⚡️ Build success in 3009ms
-DTS dist/index.d.mts 15.43 KB
-DTS dist/index.d.ts  15.43 KB
+DTS ⚡️ Build success in 3500ms
+DTS dist/index.d.mts 22.06 KB
+DTS dist/index.d.ts  22.06 KB

package/CHANGELOG.md

@@ -1,5 +1,137 @@
 # @pluv/client
 
+## 0.28.0
+
+### Patch Changes
+
+- @pluv/crdt@0.28.0
+- @pluv/types@0.28.0
+
+## 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

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;
@@ -132,17 +180,17 @@ type PluvRoomDebug<TIO extends IOLike> = Id<{
     output: readonly (keyof InferIOOutput<TIO>)[];
     input: readonly (keyof InferIOInput<TIO>)[];
 }>;
-type PluvRoomOptions<TIO extends IOLike, TMetadata extends JsonObject = {}, TPresence extends JsonObject = {}, TStorage extends Record<string, CrdtType<any, any>> = {}> = {
+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> & (keyof TMetadata extends never ? {
+    router?: PluvRouter<TIO, TPresence, TStorage, TEvents>;
+} & RoomEndpoints<TIO, TMetadata> & Pick<CrdtManagerOptions<TStorage>, "initialStorage"> & UsersManagerConfig<TPresence> & (keyof TMetadata extends never ? {
     metadata?: undefined;
 } : {
     metadata: TMetadata;
-});
-type RoomConfig<TIO extends IOLike, TMetadata extends JsonObject = {}, TPresence extends JsonObject = {}, TStorage extends Record<string, CrdtType<any, any>> = {}> = RoomEndpoints<TIO, TMetadata> & PluvRoomOptions<TIO, TMetadata, TPresence, TStorage>;
-declare class PluvRoom<TIO extends IOLike, TMetadata extends JsonObject = {}, TPresence extends JsonObject = {}, TStorage extends Record<string, CrdtType<any, any>> = {}> extends AbstractRoom<TIO, TPresence, TStorage> {
+})>;
+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;
@@ -152,6 +200,7 @@ declare class PluvRoom<TIO extends IOLike, TMetadata extends JsonObject = {}, TP
     private _listeners;
     private _metadata;
     private _otherNotifier;
+    private _router;
     private _state;
     private _stateNotifier;
     private _storageStore;
@@ -160,15 +209,15 @@ declare class PluvRoom<TIO extends IOLike, TMetadata extends JsonObject = {}, TP
     private _windowListeners;
     private _wsListeners;
     private _usersManager;
-    constructor(room: string, options: RoomConfig<TIO, TMetadata, 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;
@@ -237,47 +286,77 @@ declare class PluvRoom<TIO extends IOLike, TMetadata extends JsonObject = {}, TP
     private _updateState;
 }
 
-type PluvClientOptions<TIO extends IOLike, TMetadata extends JsonObject> = RoomEndpoints<TIO, TMetadata> & {
+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, TMetadata extends JsonObject = {}> {
+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, TMetadata>);
-    createRoom: <TPresence extends JsonObject = {}, TStorage extends Record<string, CrdtType<any, any>> = {}>(room: string, options: PluvRoomOptions<TIO, TMetadata, TPresence, TStorage>) => PluvRoom<TIO, TMetadata, TPresence, TStorage>;
-    enter: (room: string | PluvRoom<TIO, any, any, any>) => Promise<PluvRoom<TIO, TMetadata, JsonObject, any>>;
-    getRoom: <TPresence extends JsonObject = {}, TStorage extends Record<string, CrdtType<any, any>> = {}>(room: string) => PluvRoom<TIO, TMetadata, TPresence, TStorage> | null;
-    getRooms: () => readonly PluvRoom<TIO, TMetadata, JsonObject, any>[];
+    get _defs(): {
+        initialStorage: AbstractCrdtDocFactory<TStorage> | undefined;
+    };
+    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>, {}>, TMetadata extends JsonObject = {}>(options: PluvClientOptions<TIO, TMetadata>) => PluvClient<TIO, TMetadata>;
+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>> = {}> = {
-    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> {
+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>);
+    constructor(room: string, options: MockedRoomConfig<TIO, TPresence, TStorage, TEvents>);
     get storageLoaded(): boolean;
-    broadcast<TEvent extends keyof InferIOInput<TIO>>(event: TEvent, data: Id<InferIOInput<TIO>[TEvent]>): 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;
-    event: <TEvent extends keyof InferIOOutput<TIO>>(event: TEvent, callback: EventNotifierSubscriptionCallback<TIO, TEvent>) => (() => 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;
@@ -296,6 +375,7 @@ declare class MockedRoom<TIO extends IOLike, TPresence extends JsonObject = {},
     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 PluvRoomOptions, 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 };