@pluv/client 0.26.0 → 0.28.0

package/dist/index.d.ts

@@ -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 };

package/dist/index.js

@@ -81,6 +81,41 @@ var AbstractStorageStore = class {
   }
 };
 
+// src/PluvProcedure.ts
+var PluvProcedure = class _PluvProcedure {
+  constructor(config = {}) {
+    this._broadcast = null;
+    this._input = null;
+    const { broadcast, input } = config;
+    this._broadcast = broadcast != null ? broadcast : null;
+    this._input = input != null ? input : null;
+  }
+  get config() {
+    var _a, _b, _c;
+    return {
+      broadcast: (_b = (_a = this._broadcast) == null ? void 0 : _a.bind(this)) != null ? _b : null,
+      input: (_c = this._input) != null ? _c : null,
+      resolver: this._resolver()
+    };
+  }
+  broadcast(resolver) {
+    const { broadcast } = this.config;
+    if (!!broadcast) throw new Error("Broadcast was already defined for this procedure");
+    return new _PluvProcedure(__spreadProps(__spreadValues({}, this.config), {
+      broadcast: resolver
+    }));
+  }
+  input(input) {
+    return new _PluvProcedure({ input });
+  }
+  _resolver() {
+    return (data, context) => {
+      var _a;
+      return (_a = this._broadcast) == null ? void 0 : _a.call(this, data, context);
+    };
+  }
+};
+
 // src/CrdtManager.ts
 var import_crdt = require("@pluv/crdt");
 var CrdtManager = class {
@@ -208,6 +243,21 @@ var OtherNotifier = class {
   }
 };
 
+// src/PluvRouter.ts
+var PluvRouter = class _PluvRouter {
+  constructor(events) {
+    this._defs = { events: {} };
+    this._defs = { events };
+  }
+  static merge(...routers) {
+    const events = Object.assign(/* @__PURE__ */ Object.create(null), ...routers.map((router) => router._defs.events));
+    if (Object.keys(events).some((key) => key.startsWith("$"))) {
+      throw new Error('Procedures may not start with "$"');
+    }
+    return new _PluvRouter(events);
+  }
+};
+
 // src/StateNotifier.ts
 var import_wonka4 = require("wonka");
 var StateNotifier = class {
@@ -346,7 +396,7 @@ var UsersManager = class {
   }
 };
 
-// src/types.ts
+// src/enums.ts
 var ConnectionState = /* @__PURE__ */ ((ConnectionState2) => {
   ConnectionState2["Closed"] = "Closed";
   ConnectionState2["Connecting"] = "Connecting";
@@ -396,6 +446,7 @@ var PluvRoom = class extends AbstractRoom {
       metadata,
       onAuthorizationFail,
       presence,
+      router,
       wsEndpoint
     } = options;
     super(room);
@@ -429,17 +480,37 @@ var PluvRoom = class extends AbstractRoom {
     this._windowListeners = null;
     this._wsListeners = null;
     this.broadcast = new Proxy(
-      (event, data) => {
+      (event, data) => __async(this, null, function* () {
         if (!this._state.webSocket) return;
         if (this._state.connection.state !== "Open" /* Open */) return;
         const type = event.toString();
-        this._sendMessage({ data, type });
-      },
+        const procedure = this._router._defs.events[type];
+        if (!(procedure == null ? void 0 : procedure.config.broadcast)) {
+          this._sendMessage({ data, type });
+          return;
+        }
+        const myself = this._usersManager.myself;
+        if (!myself) return;
+        const parsed = procedure.config.input ? procedure.config.input.parse(data) : data;
+        const context = {
+          doc: this._crdtManager.doc,
+          others: this._usersManager.getOthers(),
+          room: this.id,
+          user: myself
+        };
+        const output = yield procedure.config.broadcast(
+          parsed,
+          context
+        );
+        Object.entries(output).forEach(([_type, _data]) => {
+          this._sendMessage({ data: _data, type: _type });
+        });
+      }),
       {
         get(fn, prop) {
-          return (data) => {
-            return fn(prop, data);
-          };
+          return (data) => __async(this, null, function* () {
+            return yield fn(prop, data);
+          });
         }
       }
     );
@@ -514,7 +585,10 @@ var PluvRoom = class extends AbstractRoom {
       const myself = (_a = this._usersManager.myself) != null ? _a : null;
       this._stateNotifier.subjects["my-presence"].next(myPresence);
       !!myself && this._stateNotifier.subjects["myself"].next(myself);
-      this.broadcast("$UPDATE_PRESENCE", { presence: newPresence });
+      this.broadcast(
+        "$UPDATE_PRESENCE",
+        { presence: newPresence }
+      );
     };
     this._flattenStorageStore = debounce(
       () => __async(this, null, function* () {
@@ -546,6 +620,7 @@ var PluvRoom = class extends AbstractRoom {
         onAuthorizationFail == null ? void 0 : onAuthorizationFail(error);
       }
     };
+    this._router = router != null ? router : new PluvRouter({});
     this._usersManager = new UsersManager({ initialPresence, presence });
     this._crdtManager = new CrdtManager({ initialStorage });
   }
@@ -1114,9 +1189,11 @@ var PluvClient = class {
         authEndpoint: this._authEndpoint,
         debug: options.debug,
         initialPresence: options.initialPresence,
-        initialStorage: options.initialStorage,
+        initialStorage: this._initialStorage,
         metadata: options.metadata,
         onAuthorizationFail: options.onAuthorizationFail,
+        presence: this._presence,
+        router: options.router,
         wsEndpoint: this._wsEndpoint
       });
       this._rooms.set(room, newRoom);
@@ -1145,11 +1222,24 @@ var PluvClient = class {
       this._rooms.delete(toLeave.id);
       this._logDebug(`Left and deleted room: ${room}`);
     });
-    const { authEndpoint, debug = false, wsEndpoint } = options;
+    const { authEndpoint, debug = false, initialStorage, presence, wsEndpoint } = options;
     this._authEndpoint = authEndpoint;
     this._debug = debug;
+    this._initialStorage = initialStorage;
+    this._presence = presence;
     this._wsEndpoint = wsEndpoint;
   }
+  get _defs() {
+    return {
+      initialStorage: this._initialStorage
+    };
+  }
+  get procedure() {
+    return new PluvProcedure();
+  }
+  router(events) {
+    return new PluvRouter(events);
+  }
   _logDebug(...data) {
     var _a;
     if (((_a = process == null ? void 0 : process.env) == null ? void 0 : _a.NODE_ENV) === "production") return;
@@ -1165,7 +1255,7 @@ var createClient = (options) => {
 // src/MockedRoom.ts
 var MockedRoom = class extends AbstractRoom {
   constructor(room, options) {
-    const { events, initialPresence, initialStorage, presence } = options;
+    const { events, initialPresence, initialStorage, presence, router } = options;
     super(room);
     this._crdtNotifier = new CrdtNotifier();
     this._eventNotifier = new EventNotifier();
@@ -1186,15 +1276,55 @@ var MockedRoom = class extends AbstractRoom {
     this._subscriptions = {
       observeCrdt: null
     };
+    this.broadcast = new Proxy(
+      (event, data) => __async(this, null, function* () {
+        if (!this._state.webSocket) return;
+        if (this._state.connection.state !== "Open" /* Open */) return;
+        const type = event.toString();
+        const procedure = this._router._defs.events[type];
+        if (!(procedure == null ? void 0 : procedure.config.broadcast)) {
+          this._simulateEvent(type, data);
+          return;
+        }
+        const myself = this._usersManager.myself;
+        if (!myself) return;
+        const parsed = procedure.config.input ? procedure.config.input.parse(data) : data;
+        const context = {
+          doc: this._crdtManager.doc,
+          others: this._usersManager.getOthers(),
+          room: this.id,
+          user: myself
+        };
+        const output = yield procedure.config.broadcast(
+          parsed,
+          context
+        );
+        Object.entries(output).forEach(([_type, _data]) => {
+          this._simulateEvent(_type, _data);
+        });
+      }),
+      {
+        get(fn, prop) {
+          return (data) => __async(this, null, function* () {
+            return yield fn(prop, data);
+          });
+        }
+      }
+    );
     this.canRedo = () => {
       return !!this._crdtManager.doc.canRedo();
     };
     this.canUndo = () => {
       return !!this._crdtManager.doc.canUndo();
     };
-    this.event = (event, callback) => {
-      return this._eventNotifier.subscribe(event, callback);
-    };
+    this.event = new Proxy(
+      (event, callback) => this._eventNotifier.subscribe(event, callback),
+      {
+        get(fn, prop) {
+          return (callback) => fn(prop, callback);
+        }
+      }
+    );
     this.getConnection = () => {
       return Object.freeze(JSON.parse(JSON.stringify(this._state.connection)));
     };
@@ -1253,6 +1383,7 @@ var MockedRoom = class extends AbstractRoom {
       !!myself && this._stateNotifier.subjects["myself"].next(myself);
     };
     this._events = events;
+    this._router = router != null ? router : new PluvRouter({});
     this._usersManager = new UsersManager({
       initialPresence,
       presence
@@ -1265,18 +1396,6 @@ var MockedRoom = class extends AbstractRoom {
   get storageLoaded() {
     return true;
   }
-  broadcast(event, data) {
-    if (!this._events) return;
-    const resolver = this._events[event];
-    if (!resolver) return;
-    const result = resolver(data);
-    Object.keys(result).forEach((type) => {
-      const _type = type.toString();
-      const data2 = result[_type];
-      if (!data2) return;
-      this._eventNotifier.subject(_type).next(data2);
-    });
-  }
   getDoc() {
     return this._crdtManager.doc;
   }
@@ -1308,6 +1427,19 @@ var MockedRoom = class extends AbstractRoom {
     });
     this._subscriptions.observeCrdt = unsubscribe;
   }
+  _simulateEvent(event, data) {
+    if (!this._events) return;
+    const type = event.toString();
+    const resolver = this._events[type];
+    if (!resolver) return;
+    const result = resolver(data);
+    Object.keys(result).forEach((type2) => {
+      const _type = type2.toString();
+      const data2 = result[_type];
+      if (!data2) return;
+      this._eventNotifier.subject(_type).next(data2);
+    });
+  }
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {