@pluv/io 0.3.9 → 0.4.0

package/.turbo/turbo-build.log

@@ -1,5 +1,5 @@
 
-> @pluv/io@0.3.9 build /home/runner/work/pluv/pluv/packages/io
+> @pluv/io@0.4.0 build /home/runner/work/pluv/pluv/packages/io
 > tsup src/index.ts --format esm,cjs --dts
 
 CLI Building entry: src/index.ts
@@ -8,10 +8,10 @@
 CLI Target: es6
 ESM Build start
 CJS Build start
-CJS dist/index.js 29.45 KB
-CJS ⚡️ Build success in 105ms
-ESM dist/index.mjs 27.39 KB
-ESM ⚡️ Build success in 107ms
+ESM dist/index.mjs 28.25 KB
+ESM ⚡️ Build success in 154ms
+CJS dist/index.js 30.31 KB
+CJS ⚡️ Build success in 155ms
 DTS Build start
-DTS ⚡️ Build success in 2633ms
-DTS dist/index.d.ts 12.84 KB
+DTS ⚡️ Build success in 4082ms
+DTS dist/index.d.ts 14.78 KB

package/CHANGELOG.md

@@ -1,5 +1,24 @@
 # @pluv/io
 
+## 0.4.0
+
+### Minor Changes
+
+- bb2886b: allow sending multiple output types (broadcast, self, sync) per event
+- ae679a8: updated offline presence to be set when reconnecting to a room
+
+### Patch Changes
+
+- 41943cf: bumped dependencies
+- 0dd847e: updated storage to be synced when reconnected to the room
+- 3518a83: bumped dependencies
+- Updated dependencies [0dd847e]
+- Updated dependencies [bb2886b]
+- Updated dependencies [ae679a8]
+- Updated dependencies [3518a83]
+  - @pluv/crdt-yjs@0.3.7
+  - @pluv/types@0.2.0
+
 ## 0.3.9
 
 ### Patch Changes

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { JsonObject, MaybePromise, IOEventMessage, EventRecord, InputZodLike, Id, IOLike, InferIOOutput, BaseUser, IOAuthorize, BaseIOAuthorize, InferIOInput, Maybe, InferIOAuthorizeUser, InferIOAuthorize, Spread, BaseClientEventRecord, BaseIOEventRecord } from '@pluv/types';
+import { JsonObject, MaybePromise, IOEventMessage, EventRecord, InputZodLike, Id, IOLike, InferIOOutput, BaseUser, IOAuthorize, BaseIOAuthorize, InferIOInput, Maybe, InferIOAuthorizeUser, InferIOAuthorize, Spread, InferIOOutputBroadcast, InferIOOutputSelf, InferIOOutputSync, BaseClientEventRecord, BaseIOEventRecord } from '@pluv/types';
 export { BaseUser, EventMessage, EventRecord, IOEventMessage } from '@pluv/types';
 import { YjsDoc } from '@pluv/crdt-yjs';
 
@@ -79,12 +79,11 @@ declare global {
         log: (...data: any[]) => void;
     };
 }
-interface EventConfig<TContext extends JsonObject = {}, TData extends JsonObject = {}, TResult extends EventRecord<string, any> = {}> {
+interface EventConfig<TContext extends JsonObject = {}, TData extends JsonObject = {}, TResultBroadcast extends EventRecord<string, any> = {}, TResultSelf extends EventRecord<string, any> = {}, TResultSync extends EventRecord<string, any> = {}> {
     input?: InputZodLike<TData>;
-    options?: SendMessageOptions;
-    resolver: EventResolver<TContext, TData, TResult>;
+    resolver: EventResolver<TContext, TData, TResultBroadcast> | EventResolverObject<TContext, TData, TResultBroadcast, TResultSelf, TResultSync>;
 }
-type EventResolver<TContext extends JsonObject = {}, TData extends JsonObject = {}, TResult extends EventRecord<string, any> = {}> = (data: TData, context: EventResolverContext<TContext>) => MaybePromise<TResult | void>;
+type EventResolver<TContext extends JsonObject = {}, TData extends JsonObject = {}, TResultBroadcast extends EventRecord<string, any> = {}> = (data: TData, context: EventResolverContext<TContext>) => MaybePromise<TResultBroadcast | void>;
 interface EventResolverContext<TContext extends JsonObject = {}> {
     context: TContext;
     doc: YjsDoc<any>;
@@ -104,8 +103,13 @@ interface EventResolverContext<TContext extends JsonObject = {}> {
     session: WebSocketSession | null;
     sessions: Map<string, WebSocketSession>;
 }
-type InferEventConfig<TContext extends JsonObject = {}, TInput extends EventRecord<string, any> = {}, TOutput extends EventRecord<string, any> = {}> = {
-    [P in keyof TInput]: P extends string ? Id<EventConfig<TContext, TInput[P], TOutput>> : never;
+type EventResolverObject<TContext extends JsonObject = {}, TData extends JsonObject = {}, TResultBroadcast extends EventRecord<string, any> = {}, TResultSelf extends EventRecord<string, any> = {}, TResultSync extends EventRecord<string, any> = {}> = {
+    broadcast?: EventResolver<TContext, TData, TResultBroadcast>;
+    self?: EventResolver<TContext, TData, TResultSelf>;
+    sync?: EventResolver<TContext, TData, TResultSync>;
+};
+type InferEventConfig<TContext extends JsonObject = {}, TInput extends EventRecord<string, any> = {}, TOutputBroadcast extends EventRecord<string, any> = {}, TOutputSelf extends EventRecord<string, any> = {}, TOutputSync extends EventRecord<string, any> = {}> = {
+    [P in keyof TInput]: P extends string ? Id<EventConfig<TContext, TInput[P], TOutputBroadcast, TOutputSelf, TOutputSync>> : never;
 };
 type SendMessageOptions = {
     type?: "broadcast";
@@ -179,18 +183,18 @@ interface AuthorizeModule {
 interface IORoomListeners {
     onDestroy: (encodedState: string) => void;
 }
-type IORoomConfig<TPlatform extends AbstractPlatform<any> = AbstractPlatform<any>, TAuthorize extends IOAuthorize<any, any> = BaseIOAuthorize, TContext extends JsonObject = {}, TInput extends EventRecord<string, any> = {}, TOutput extends EventRecord<string, any> = {}> = Partial<IORoomListeners> & {
+type IORoomConfig<TPlatform extends AbstractPlatform<any> = AbstractPlatform<any>, TAuthorize extends IOAuthorize<any, any> = BaseIOAuthorize, TContext extends JsonObject = {}, TInput extends EventRecord<string, any> = {}, TOutputBroadcast extends EventRecord<string, any> = {}, TOutputSelf extends EventRecord<string, any> = {}, TOutputSync extends EventRecord<string, any> = {}> = Partial<IORoomListeners> & {
     authorize?: TAuthorize;
     context: TContext;
     debug: boolean;
-    events: InferEventConfig<TContext, TInput, TOutput>;
+    events: InferEventConfig<TContext, TInput, TOutputBroadcast, TOutputSelf, TOutputSync>;
     initialStorage?: () => MaybePromise<Maybe<string>>;
     platform: TPlatform;
 };
 interface WebsocketRegisterOptions {
     token?: string;
 }
-declare class IORoom<TPlatform extends AbstractPlatform<any> = AbstractPlatform<any>, TAuthorize extends IOAuthorize<any, any> = BaseIOAuthorize, TContext extends JsonObject = {}, TInput extends EventRecord<string, any> = {}, TOutput extends EventRecord<string, any> = {}> implements IOLike<TAuthorize, TInput, TOutput> {
+declare class IORoom<TPlatform extends AbstractPlatform<any> = AbstractPlatform<any>, TAuthorize extends IOAuthorize<any, any> = BaseIOAuthorize, TContext extends JsonObject = {}, TInput extends EventRecord<string, any> = {}, TOutputBroadcast extends EventRecord<string, any> = {}, TOutputSelf extends EventRecord<string, any> = {}, TOutputSync extends EventRecord<string, any> = {}> implements IOLike<TAuthorize, TInput, TOutputBroadcast, TOutputSelf, TOutputSync> {
     private readonly _context;
     private readonly _debug;
     private readonly _platform;
@@ -200,23 +204,24 @@ declare class IORoom<TPlatform extends AbstractPlatform<any> = AbstractPlatform<
     private _sessions;
     private _uninitialize;
     readonly _authorize: TAuthorize | null;
-    readonly _events: InferEventConfig<TContext, TInput, TOutput>;
+    readonly _events: InferEventConfig<TContext, TInput, TOutputBroadcast, TOutputSelf, TOutputSync>;
     readonly id: string;
-    constructor(id: string, config: IORoomConfig<TPlatform, TAuthorize, TContext, TInput, TOutput>);
+    constructor(id: string, config: IORoomConfig<TPlatform, TAuthorize, TContext, TInput, TOutputBroadcast, TOutputSelf, TOutputSync>);
     broadcast<TEvent extends keyof InferIOInput<this>>(event: TEvent, data: Id<InferIOInput<this>[TEvent]>): Promise<void>;
     getSize(): number;
     register(webSocket: InferWebSocketType<TPlatform>, options?: WebsocketRegisterOptions): Promise<void>;
     private _broadcast;
     private _emitQuitters;
     private _emitRegistered;
-    private _emitStorageReceived;
-    private _emitUserJoined;
     private _getAuthorizedUser;
     private _getEventConfig;
+    private _getEventInputs;
+    private _getEventResolverObject;
     private _initialize;
     private _logDebug;
+    private _onClose;
+    private _onMessage;
     private _parseMessage;
-    private _resolveMessage;
     private _sendMessage;
     private _sendBroadcastMessage;
     private _sendSelfMessage;
@@ -230,31 +235,31 @@ interface PluvIOListeners {
     onRoomDeleted: (room: string, encodedState: string) => void;
     onStorageUpdated: (room: string, encodedState: string) => void;
 }
-type PluvIOConfig<TPlatform extends AbstractPlatform<any> = AbstractPlatform<any>, TAuthorize extends IOAuthorize<any, any> | null = null, TContext extends JsonObject = {}, TInput extends EventRecord<string, any> = {}, TOutput extends EventRecord<string, any> = {}> = Partial<PluvIOListeners> & {
+type PluvIOConfig<TPlatform extends AbstractPlatform<any> = AbstractPlatform<any>, TAuthorize extends IOAuthorize<any, any> | null = null, TContext extends JsonObject = {}, TInput extends EventRecord<string, any> = {}, TOutputBroadcast extends EventRecord<string, any> = {}, TOutputSelf extends EventRecord<string, any> = {}, TOutputSync extends EventRecord<string, any> = {}> = Partial<PluvIOListeners> & {
     authorize?: TAuthorize;
     context?: TContext;
     debug?: boolean;
-    events?: InferEventConfig<TContext, TInput, TOutput>;
+    events?: InferEventConfig<TContext, TInput, TOutputBroadcast, TOutputSelf, TOutputSync>;
     initialStorage?: (room: string) => MaybePromise<Maybe<string>>;
     platform: TPlatform;
 };
 interface GetRoomOptions {
     debug?: boolean;
 }
-declare class PluvIO<TPlatform extends AbstractPlatform<any> = AbstractPlatform<any>, TAuthorize extends IOAuthorize<any, any> = BaseIOAuthorize, TContext extends JsonObject = {}, TInput extends EventRecord<string, any> = {}, TOutput extends EventRecord<string, any> = {}> implements IOLike<TAuthorize, TInput, TOutput> {
+declare class PluvIO<TPlatform extends AbstractPlatform<any> = AbstractPlatform<any>, TAuthorize extends IOAuthorize<any, any> = BaseIOAuthorize, TContext extends JsonObject = {}, TInput extends EventRecord<string, any> = {}, TOutputBroadcast extends EventRecord<string, any> = {}, TOutputSelf extends EventRecord<string, any> = {}, TOutputSync extends EventRecord<string, any> = {}> implements IOLike<TAuthorize, TInput, TOutputBroadcast, TOutputSelf, TOutputSync> {
     private _context;
     private _initialStorage;
     private _listeners;
     private _rooms;
     readonly _authorize: TAuthorize | null;
     readonly _debug: boolean;
-    readonly _events: InferEventConfig<TContext, TInput, TOutput>;
+    readonly _events: InferEventConfig<TContext, TInput, TOutputBroadcast, TOutputSelf, TOutputSync>;
     readonly _platform: TPlatform;
-    constructor(options: PluvIOConfig<TPlatform, TAuthorize, TContext, TInput, TOutput>);
+    constructor(options: PluvIOConfig<TPlatform, TAuthorize, TContext, TInput, TOutputBroadcast, TOutputSelf, TOutputSync>);
     createToken(params: JWTEncodeParams<InferIOAuthorizeUser<InferIOAuthorize<this>>>): Promise<string>;
-    event<TEvent extends string, TData extends JsonObject = {}, TResult extends EventRecord<string, any> = {}>(event: TEvent, config: EventConfig<TContext, TData, TResult>): PluvIO<TPlatform, TAuthorize, TContext, Spread<[TInput, EventRecord<TEvent, TData>]>, Spread<[TOutput, TResult]>>;
-    getRoom(room: string, options?: GetRoomOptions): IORoom<TPlatform, TAuthorize, TContext, TInput, TOutput>;
-    static merge<TIO1 extends PluvIO, TIO2 extends PluvIO>(first: TIO1, second: TIO2): PluvIO<InferIOPlatform<TIO1>, InferIOAuthorize<TIO1>, InferIOContext<TIO1>, Spread<[InferIOInput<TIO1>, InferIOInput<TIO2>]>, Spread<[InferIOOutput<TIO1>, InferIOOutput<TIO2>]>>;
+    event<TEvent extends string, TData extends JsonObject = {}, TResultBroadcast extends EventRecord<string, any> = {}, TResultSelf extends EventRecord<string, any> = {}, TResultSync extends EventRecord<string, any> = {}>(event: TEvent, config: EventConfig<TContext, TData, TResultBroadcast, TResultSelf, TResultSync>): PluvIO<TPlatform, TAuthorize, TContext, Spread<[TInput, EventRecord<TEvent, TData>]>, Spread<[TOutputBroadcast, TResultBroadcast]>, Spread<[TOutputSelf, TResultSelf]>, Spread<[TOutputSync, TResultSync]>>;
+    getRoom(room: string, options?: GetRoomOptions): IORoom<TPlatform, TAuthorize, TContext, TInput, TOutputBroadcast, TOutputSelf, TOutputSync>;
+    static merge<TIO1 extends PluvIO, TIO2 extends PluvIO>(first: TIO1, second: TIO2): PluvIO<InferIOPlatform<TIO1>, InferIOAuthorize<TIO1>, InferIOContext<TIO1>, Spread<[InferIOInput<TIO1>, InferIOInput<TIO2>]>, Spread<[InferIOOutputBroadcast<TIO1>, InferIOOutputBroadcast<TIO2>]>, Spread<[InferIOOutputSelf<TIO1>, InferIOOutputSelf<TIO2>]>, Spread<[InferIOOutputSync<TIO1>, InferIOOutputSync<TIO2>]>>;
     private _logDebug;
     private _purgeEmptyRooms;
 }
@@ -266,6 +271,6 @@ type CreateIOParams<TPlatform extends AbstractPlatform<any> = AbstractPlatform<a
     initialStorage?: (room: string) => MaybePromise<Maybe<string>>;
     platform: TPlatform;
 };
-declare const createIO: <TPlatform extends AbstractPlatform<any> = AbstractPlatform<any>, TContext extends JsonObject = {}, TAuthorizeUser extends BaseUser = BaseUser, TAuthorizeRequired extends boolean = false>(params: CreateIOParams<TPlatform, TContext, TAuthorizeUser, TAuthorizeRequired>) => PluvIO<TPlatform, IOAuthorize<TAuthorizeUser, TAuthorizeRequired>, TContext, BaseClientEventRecord, BaseIOEventRecord<IOAuthorize<TAuthorizeUser, TAuthorizeRequired>>>;
+declare const createIO: <TPlatform extends AbstractPlatform<any> = AbstractPlatform<any>, TContext extends JsonObject = {}, TAuthorizeUser extends BaseUser = BaseUser, TAuthorizeRequired extends boolean = false>(params: CreateIOParams<TPlatform, TContext, TAuthorizeUser, TAuthorizeRequired>) => PluvIO<TPlatform, IOAuthorize<TAuthorizeUser, TAuthorizeRequired>, TContext, BaseClientEventRecord, BaseIOEventRecord<IOAuthorize<TAuthorizeUser, TAuthorizeRequired>>, {}, {}>;
 
 export { AbstractCloseEvent, AbstractErrorEvent, AbstractEvent, AbstractEventMap, AbstractListener, AbstractMessageEvent, AbstractPersistance, AbstractPlatform, AbstractPubSub, AbstractWebSocket, AbstractWebSocketConfig, AbstractWebSocketHandleErrorParams, AuthorizeModule, AuthorizeParams, ConvertWebSocketConfig, CreateIOParams, GetRoomOptions, IOPubSubEventMessage, IORoom, InferIORoom, InferWebSocketType, JWT, JWTEncodeParams, PluvIO, createIO };

package/dist/index.js

@@ -261,6 +261,10 @@ var AbstractWebSocket = class {
 // src/PluvIO.ts
 var import_kleur2 = __toESM(require("kleur"));
 
+// src/IORoom.ts
+var import_crdt_yjs = require("@pluv/crdt-yjs");
+var import_kleur = __toESM(require("kleur"));
+
 // src/authorize.ts
 var import_hkdf = __toESM(require("@panva/hkdf"));
 var import_jose = require("jose");
@@ -298,8 +302,6 @@ var authorize = (params) => {
 };
 
 // src/IORoom.ts
-var import_crdt_yjs = require("@pluv/crdt-yjs");
-var import_kleur = __toESM(require("kleur"));
 var PING_TIMEOUT_MS = 3e4;
 var IORoom = class {
   constructor(id, config) {
@@ -396,101 +398,12 @@ var IORoom = class {
         sessionId,
         user != null ? user : {}
       );
+      const onClose = this._onClose(session, uninitializeWs).bind(this);
+      const onMessage = this._onMessage(session).bind(this);
+      pluvWs.addEventListener("close", onClose);
+      pluvWs.addEventListener("error", onClose);
+      pluvWs.addEventListener("message", onMessage);
       this._emitRegistered(session);
-      this._emitStorageReceived(session);
-      this._emitUserJoined(session);
-      const context = {
-        context: this._context,
-        doc: this._doc,
-        room: this.id,
-        session,
-        sessions: this._sessions
-      };
-      pluvWs.addEventListener("message", (event) => {
-        if (!this._uninitialize)
-          return;
-        if (session.quit) {
-          session.webSocket.close(1011, "WebSocket broken.");
-          return;
-        }
-        const message = this._parseMessage(event);
-        if (!message)
-          return;
-        const eventConfig = this._getEventConfig(message);
-        if (!eventConfig)
-          return;
-        this._resolveMessage(message, context).then((output) => {
-          var _a2, _b;
-          if (!output)
-            return;
-          const eventType = (_b = (_a2 = eventConfig.options) == null ? void 0 : _a2.type) != null ? _b : "broadcast";
-          switch (eventType) {
-            case "self": {
-              Object.entries(output).forEach(([type, data]) => {
-                this._sendSelfMessage({ data, type }, session);
-              });
-              return;
-            }
-            case "sync": {
-              this._platform.pubSub.publish(this.id, __spreadValues({
-                connectionId: session.id,
-                options: eventConfig.options,
-                room: this.id,
-                user: session.user
-              }, message));
-              Object.entries(output).forEach(([type, data]) => {
-                this._sendSelfMessage({ data, type }, session);
-              });
-              return;
-            }
-            case "broadcast":
-            default: {
-              Object.entries(output).forEach(([type, data]) => {
-                this._broadcast({
-                  message: { data, type },
-                  senderId: session.id
-                });
-              });
-            }
-          }
-        });
-      });
-      const closeHandler = () => {
-        if (!this._uninitialize)
-          return;
-        session.quit = true;
-        this._logDebug(
-          `${import_kleur.default.blue(
-            `(Unregistering connection for room ${this.id}:`
-          )} ${sessionId}`
-        );
-        this._sessions.delete(session.id);
-        this._platform.persistance.deleteUser(this.id, session.id).finally(() => {
-          var _a2;
-          this._broadcast({
-            message: {
-              type: "$EXIT",
-              data: { sessionId: session.id }
-            },
-            senderId: session.id
-          });
-          uninitializeWs();
-          const size2 = this.getSize();
-          this._logDebug(
-            `${import_kleur.default.blue(
-              `Unregistered connection for room ${this.id}:`
-            )} ${sessionId}`
-          );
-          this._logDebug(
-            `${import_kleur.default.blue(`Room ${this.id} size:`)} ${size2}`
-          );
-          if (size2)
-            return;
-          (_a2 = this._uninitialize) == null ? void 0 : _a2.call(this);
-        });
-      };
-      pluvWs.addEventListener("close", closeHandler);
-      pluvWs.addEventListener("error", closeHandler);
       this._logDebug(
         `${import_kleur.default.blue(
           `Registered connection for room ${this.id}:`
@@ -538,34 +451,6 @@ var IORoom = class {
       session
     );
   }
-  _emitStorageReceived(session) {
-    this._platform.persistance.getStorageState(this.id).then((_state) => __async(this, null, function* () {
-      var _a, _b;
-      const state = (_b = _state != null ? _state : yield (_a = this._initialStorage) == null ? void 0 : _a.call(this)) != null ? _b : this._doc.encodeStateAsUpdate();
-      this._sendSelfMessage(
-        {
-          type: "$STORAGE_RECEIVED",
-          data: { state }
-        },
-        session
-      );
-    }));
-  }
-  _emitUserJoined(session) {
-    const user = session.user;
-    if (!user)
-      return;
-    this._broadcast({
-      message: {
-        type: "$USER_JOINED",
-        data: {
-          connectionId: session.id,
-          user
-        }
-      },
-      senderId: session.id
-    });
-  }
   _getAuthorizedUser(token) {
     return __async(this, null, function* () {
       var _a;
@@ -604,6 +489,19 @@ var IORoom = class {
     var _a;
     return (_a = this._events[message.type]) != null ? _a : null;
   }
+  _getEventInputs(message) {
+    const eventConfig = this._getEventConfig(message);
+    if (!eventConfig)
+      return message.data;
+    return eventConfig.input ? eventConfig.input.parse(message.data) : message.data;
+  }
+  _getEventResolverObject(message) {
+    const eventConfig = this._getEventConfig(message);
+    if (!eventConfig)
+      return {};
+    const resolver = eventConfig.resolver;
+    return typeof resolver === "function" ? { broadcast: resolver } : __spreadValues({}, resolver);
+  }
   _initialize() {
     return __async(this, null, function* () {
       this._logDebug(`${import_kleur.default.blue(`Initializing room ${this.id}:`)}`);
@@ -635,6 +533,105 @@ var IORoom = class {
   _logDebug(...data) {
     this._debug && console.log(...data);
   }
+  _onClose(session, callback) {
+    return () => {
+      if (!this._uninitialize)
+        return;
+      session.quit = true;
+      this._logDebug(
+        `${import_kleur.default.blue(
+          `(Unregistering connection for room ${this.id}:`
+        )} ${session.id}`
+      );
+      this._sessions.delete(session.id);
+      this._platform.persistance.deleteUser(this.id, session.id).finally(() => {
+        var _a;
+        this._broadcast({
+          message: {
+            type: "$EXIT",
+            data: { sessionId: session.id }
+          },
+          senderId: session.id
+        });
+        callback == null ? void 0 : callback();
+        const size = this.getSize();
+        this._logDebug(
+          `${import_kleur.default.blue(
+            `Unregistered connection for room ${this.id}:`
+          )} ${session.id}`
+        );
+        this._logDebug(
+          `${import_kleur.default.blue(`Room ${this.id} size:`)} ${size}`
+        );
+        if (size)
+          return;
+        (_a = this._uninitialize) == null ? void 0 : _a.call(this);
+      });
+    };
+  }
+  _onMessage(session) {
+    return (event) => {
+      var _a, _b, _c;
+      const context = {
+        context: this._context,
+        doc: this._doc,
+        room: this.id,
+        session,
+        sessions: this._sessions
+      };
+      if (!this._uninitialize)
+        return;
+      if (session.quit) {
+        session.webSocket.close(1011, "WebSocket broken.");
+        return;
+      }
+      const message = this._parseMessage(event);
+      if (!message)
+        return;
+      const resolver = this._getEventResolverObject(message);
+      let inputs;
+      try {
+        inputs = this._getEventInputs(message);
+      } catch (error) {
+        session == null ? void 0 : session.webSocket.handleError({
+          error,
+          message: "Invalid input",
+          session
+        });
+        return;
+      }
+      Promise.all([
+        (_a = resolver.broadcast) == null ? void 0 : _a.call(resolver, inputs, context),
+        (_b = resolver.self) == null ? void 0 : _b.call(resolver, inputs, context),
+        (_c = resolver.sync) == null ? void 0 : _c.call(resolver, inputs, context)
+      ]).then(([broadcast, self, sync]) => {
+        if (broadcast) {
+          Object.entries(broadcast).forEach(([type, data]) => {
+            this._broadcast({
+              message: { data, type },
+              senderId: session.id
+            });
+          });
+        }
+        if (self) {
+          Object.entries(self).forEach(([type, data]) => {
+            this._sendSelfMessage({ data, type }, session);
+          });
+        }
+        if (sync) {
+          this._platform.pubSub.publish(this.id, __spreadValues({
+            connectionId: session.id,
+            options: { type: "sync" },
+            room: this.id,
+            user: session.user
+          }, message));
+          Object.entries(sync).forEach(([type, data]) => {
+            this._sendSelfMessage({ data, type }, session);
+          });
+        }
+      });
+    };
+  }
   _parseMessage(message) {
     const parsed = this._platform.parseData(message.data);
     try {
@@ -649,29 +646,6 @@ var IORoom = class {
       return null;
     }
   }
-  _resolveMessage(message, context) {
-    return __async(this, null, function* () {
-      const { session } = context;
-      const eventConfig = this._getEventConfig(message);
-      if (!eventConfig)
-        return null;
-      let input;
-      try {
-        input = eventConfig.input ? eventConfig.input.parse(message.data) : message.data;
-      } catch (error) {
-        session == null ? void 0 : session.webSocket.handleError({
-          error,
-          message: "Invalid input",
-          session
-        });
-        return null;
-      }
-      const output = yield eventConfig.resolver(input, context);
-      if (!output)
-        return null;
-      return output;
-    });
-  }
   _sendMessage(message, sender, options = {}) {
     switch (options.type) {
       case "self": {
@@ -721,13 +695,23 @@ var IORoom = class {
     const senderId = sender == null ? void 0 : sender.id;
     if (!senderId)
       return;
-    this._resolveMessage(message, {
+    const context = {
       context: this._context,
       doc: this._doc,
       room: this.id,
       session: null,
       sessions: this._sessions
-    }).then((output) => {
+    };
+    const resolver = this._getEventResolverObject(message).sync;
+    if (!resolver)
+      return;
+    let inputs;
+    try {
+      inputs = this._getEventInputs(message);
+    } catch (e) {
+      return;
+    }
+    Promise.resolve(resolver(inputs, context)).then((output) => {
       if (!output)
         return;
       Object.keys(output).forEach((type) => {
@@ -754,32 +738,70 @@ var PluvIO = class {
     this._rooms = /* @__PURE__ */ new Map();
     this._authorize = null;
     this._events = {
-      $PING: {
-        resolver: (data, { session }) => {
-          if (!session)
-            return {};
-          const currentTime = (/* @__PURE__ */ new Date()).getTime();
-          session.timers.ping = currentTime;
-          return { $PONG: {} };
-        },
-        options: { type: "self" }
-      },
       $GET_OTHERS: {
-        resolver: (data, { room, session, sessions }) => {
-          const others = Array.from(sessions.entries()).filter(([, wsSession]) => wsSession.id !== (session == null ? void 0 : session.id)).reduce(
-            (acc, [connectionId, { presence, user }]) => __spreadProps(__spreadValues({}, acc), {
-              [connectionId]: {
-                connectionId,
-                presence,
-                room,
-                user
+        resolver: {
+          sync: (data, { room, session, sessions }) => {
+            const others = Array.from(sessions.entries()).filter(([, wsSession]) => wsSession.id !== (session == null ? void 0 : session.id)).reduce(
+              (acc, [connectionId, { presence, user }]) => __spreadProps(__spreadValues({}, acc), {
+                [connectionId]: {
+                  connectionId,
+                  presence,
+                  room,
+                  user
+                }
+              }),
+              {}
+            );
+            return { $OTHERS_RECEIVED: { others } };
+          }
+        }
+      },
+      $INITIALIZE_SESSION: {
+        resolver: {
+          broadcast: ({ presence }, { session }) => {
+            if (!session)
+              return {};
+            session.presence = presence;
+            return {
+              $USER_JOINED: {
+                connectionId: session.id,
+                user: session.user,
+                presence
               }
-            }),
-            {}
-          );
-          return { $OTHERS_RECEIVED: { others } };
-        },
-        options: { type: "sync" }
+            };
+          },
+          self: (_0, _1) => __async(this, [_0, _1], function* ({ update }, { doc: doc2, room }) {
+            var _a, _b;
+            const oldState = yield this._platform.persistance.getStorageState(room);
+            const updates = [
+              oldState ? null : yield (_a = this._initialStorage) == null ? void 0 : _a.call(this, room),
+              update
+            ];
+            if (updates.some((_update) => !!_update)) {
+              const state2 = updates.reduce((_doc, _up) => _doc.applyUpdate(_up), doc2).encodeStateAsUpdate();
+              yield this._platform.persistance.setStorageState(
+                room,
+                state2
+              );
+              this._listeners.onStorageUpdated(room, state2);
+            }
+            const state = (_b = yield this._platform.persistance.getStorageState(
+              room
+            )) != null ? _b : doc2.encodeStateAsUpdate();
+            return { $STORAGE_RECEIVED: { state } };
+          })
+        }
+      },
+      $PING: {
+        resolver: {
+          self: (data, { session }) => {
+            if (!session)
+              return {};
+            const currentTime = (/* @__PURE__ */ new Date()).getTime();
+            session.timers.ping = currentTime;
+            return { $PONG: {} };
+          }
+        }
       },
       $UPDATE_PRESENCE: {
         resolver: ({ presence }, { session }) => {