@pluv/io 0.20.0 → 0.21.1

package/dist/index.js

@@ -216,15 +216,23 @@ var PubSub = class extends AbstractPubSub {
 // src/AbstractPlatform.ts
 var AbstractPlatform = class {
   constructor(config = {}) {
-    const { persistance, pubSub } = config;
+    this._initialized = false;
+    const { context, persistance, pubSub } = config;
+    context && (this._ioContext = context);
+    context && (this._roomContext = context);
     this.persistance = persistance != null ? persistance : new Persistance();
     this.pubSub = pubSub != null ? pubSub : new PubSub();
   }
+  _initialize() {
+    if (this._initialized) throw new Error("Platform is already initialized");
+    this._initialized = true;
+    return this;
+  }
 };
 
 // src/AbstractWebSocket.ts
 var AbstractWebSocket = class {
-  constructor(config) {
+  constructor(webSocket, config) {
     /** The connection is not yet open. */
     this.CONNECTING = 0;
     /** The connection is open and ready to communicate. */
@@ -233,18 +241,36 @@ var AbstractWebSocket = class {
     this.CLOSING = 2;
     /** The connection is closed. */
     this.CLOSED = 3;
-    const { room, sessionId } = config;
+    this._user = null;
+    const { persistance, room } = config;
+    this.persistance = persistance;
     this.room = room;
-    this.sessionId = sessionId;
+    this.webSocket = webSocket;
+  }
+  getSession() {
+    return __async(this, null, function* () {
+      var _a;
+      const sessionId = this.sessionId;
+      const state = this.state;
+      const room = state.room;
+      const user = (_a = this._user) != null ? _a : yield this.persistance.getUser(room, sessionId);
+      this._user = user;
+      return __spreadProps(__spreadValues({}, state), {
+        id: sessionId,
+        user,
+        webSocket: this
+      });
+    });
   }
   handleError(params) {
     var _a, _b, _c;
-    const { error, message = error instanceof Error ? error.message : "Unexpected error", session } = params;
+    const { error, message: _message, room, session } = params;
+    const message = error instanceof Error ? error.message : "Unexpected error";
     const stack = error instanceof Error ? (_a = error.stack) != null ? _a : null : null;
     return this.sendMessage({
       connectionId: (_b = session == null ? void 0 : session.id) != null ? _b : null,
       data: { message, stack },
-      room: this.room,
+      room,
       type: "$ERROR",
       user: (_c = session == null ? void 0 : session.user) != null ? _c : null
     });
@@ -362,8 +388,10 @@ var authorize = (params) => {
   return { decode, encode };
 };
 
-// src/IORoom.ts
+// src/constants.ts
 var PING_TIMEOUT_MS = 3e4;
+
+// src/IORoom.ts
 var IORoom = class {
   constructor(id, config) {
     this._sessions = /* @__PURE__ */ new Map();
@@ -375,12 +403,21 @@ var IORoom = class {
     this._docFactory = crdt.doc(() => ({}));
     this._doc = this._docFactory.getEmpty();
     this._router = router;
-    this._platform = platform;
+    this._platform = platform.initialize({ context });
     this.id = id;
     this._listeners = {
       onDestroy: (event) => onDestroy == null ? void 0 : onDestroy(event)
     };
     if (authorize2) this._authorize = authorize2;
+    const webSockets = this._platform.getWebSockets();
+    if (!webSockets.length) return;
+    webSockets.forEach((webSocket) => {
+      const deserialized = this._platform.getSerializedState(webSocket);
+      const sessionId = this._platform.getSessionId(webSocket);
+      if (!deserialized) return;
+      if (typeof sessionId !== "string") return;
+      this._sessions.set(sessionId, this._platform.convertWebSocket(webSocket, { room: this.id }));
+    });
   }
   get _events() {
     return this._router._events;
@@ -398,111 +435,135 @@ var IORoom = class {
   }
   getSize() {
     const currentTime = (/* @__PURE__ */ new Date()).getTime();
-    return Array.from(this._sessions.values()).reduce((count, session) => {
-      if (session.quit) return count;
-      return currentTime - session.timers.ping > PING_TIMEOUT_MS ? count : count + 1;
+    return Array.from(this._sessions.values()).reduce((count, pluvWs) => {
+      var _a;
+      if (pluvWs.state.quit) return count;
+      const pingTime = (_a = this._platform.getLastPing(pluvWs)) != null ? _a : pluvWs.state.timers.ping;
+      return currentTime - pingTime > PING_TIMEOUT_MS ? count : count + 1;
     }, 0);
   }
-  register(webSocket, options) {
-    return __async(this, null, function* () {
-      var _b;
-      const _a = options, { token } = _a, _platformEventContext = __objRest(_a, ["token"]);
-      const platformEventContext = _platformEventContext;
+  onClose(webSocket) {
+    this._ensureDetached();
+    const wsSession = this._getAbstractWs(webSocket);
+    if (!wsSession) return () => void 0;
+    return this._onClose(wsSession);
+  }
+  onError(webSocket) {
+    this._ensureDetached();
+    const wsSession = this._getAbstractWs(webSocket);
+    if (!wsSession) return () => void 0;
+    return this._onClose(wsSession);
+  }
+  onMessage(webSocket) {
+    this._ensureDetached();
+    const wsSession = this._getAbstractWs(webSocket);
+    if (!wsSession) return () => void 0;
+    return this._onMessage(wsSession);
+  }
+  register(_0) {
+    return __async(this, arguments, function* (webSocket, options = {}) {
+      const { token } = options;
       if (!this._uninitialize) yield this._initialize();
-      const user = yield this._getAuthorizedUser(token, options);
-      const sessionId = this._platform.randomUUID();
-      const pluvWs = this._platform.convertWebSocket(webSocket, {
-        room: this.id,
-        sessionId,
-        userId: (_b = user == null ? void 0 : user.id) != null ? _b : null
-      });
-      this._logDebug(`${import_kleur.default.blue(`Registering connection for room ${this.id}:`)} ${sessionId}`);
-      const uninitializeWs = yield pluvWs.initialize();
-      const ioAuthorize = this._getIOAuthorize(options);
+      const user = yield this._getAuthorizedUser(token);
+      const ioAuthorize = this._getIOAuthorize();
       const isUnauthorized = !!(ioAuthorize == null ? void 0 : ioAuthorize.required) && !user;
-      const isTokenInUse = !!user && Array.from(this._sessions.values()).some((session2) => {
-        var _a2;
-        return ((_a2 = session2.user) == null ? void 0 : _a2.id) === user.id;
-      });
+      const isTokenInUse = !!user && (yield this._getSessions().then((sessions) => sessions.some((session) => {
+        var _a;
+        return ((_a = session.user) == null ? void 0 : _a.id) === user.id;
+      })));
+      const pluvWs = yield this._platform.convertWebSocket(webSocket, { room: this.id });
+      this._logDebug(`${import_kleur.default.blue(`Registering connection for room ${this.id}:`)} ${pluvWs.sessionId}`);
+      yield this._platform.acceptWebSocket(pluvWs);
       if (isUnauthorized || isTokenInUse) {
-        this._logDebug(`${import_kleur.default.blue("Authorization failed for connection:")} ${sessionId}`);
-        pluvWs.handleError({ error: new Error("Not authorized") });
+        this._logDebug(`${import_kleur.default.blue("Authorization failed for connection:")} ${pluvWs.sessionId}`);
+        pluvWs.handleError({ error: new Error("Not authorized"), room: this.id });
         pluvWs.close(3e3, "WebSocket unauthorized.");
         return;
       }
-      const currentTime = (/* @__PURE__ */ new Date()).getTime();
-      const session = {
-        id: sessionId,
-        presence: null,
-        quit: false,
-        room: this.id,
-        timers: {
-          ping: currentTime
-        },
-        webSocket: pluvWs,
-        user
-      };
-      this._sessions.set(session.id, session);
-      yield this._platform.persistance.addUser(this.id, sessionId, user != null ? user : {});
-      const onClose = this._onClose(session, uninitializeWs).bind(this);
-      const onMessage = this._onMessage(session, platformEventContext).bind(this);
-      pluvWs.addEventListener("close", onClose);
-      pluvWs.addEventListener("error", onClose);
-      pluvWs.addEventListener("message", onMessage);
-      this._emitRegistered(session);
-      this._logDebug(`${import_kleur.default.blue(`Registered connection for room ${this.id}:`)} ${sessionId}`);
+      this._sessions.set(pluvWs.sessionId, pluvWs);
+      yield this._platform.persistance.addUser(this.id, pluvWs.sessionId, user != null ? user : {});
+      if (this._platform._registrationMode === "attached") {
+        const onClose = this._onClose(pluvWs).bind(this);
+        const onMessage = this._onMessage(pluvWs).bind(this);
+        pluvWs.addEventListener("close", onClose);
+        pluvWs.addEventListener("error", onClose);
+        pluvWs.addEventListener("message", onMessage);
+      }
+      yield this._emitRegistered(pluvWs);
+      this._logDebug(`${import_kleur.default.blue(`Registered connection for room ${this.id}:`)} ${pluvWs.sessionId}`);
       const size = this.getSize();
       this._logDebug(`${import_kleur.default.blue(`Room ${this.id} size:`)} ${size}`);
     });
   }
   _broadcast(params) {
-    var _a;
-    const { message, senderId } = params;
-    const currentTime = (/* @__PURE__ */ new Date()).getTime();
-    const sender = senderId ? this._sessions.get(senderId) : null;
-    const quitters = Array.from(this._sessions.values()).filter(
-      (session) => session.quit || currentTime - session.timers.ping > PING_TIMEOUT_MS
-    );
-    quitters.forEach((session) => {
-      this._sessions.delete(session.id);
+    return __async(this, null, function* () {
+      var _a, _b, _c;
+      const { message, senderId } = params;
+      const sender = senderId ? (_a = this._sessions.get(senderId)) != null ? _a : null : null;
+      const session = (_b = yield sender == null ? void 0 : sender.getSession()) != null ? _b : null;
+      const user = (_c = session == null ? void 0 : session.user) != null ? _c : null;
+      this._platform.pubSub.publish(this.id, __spreadValues({
+        connectionId: senderId != null ? senderId : null,
+        room: this.id,
+        user
+      }, message));
     });
-    this._emitQuitters(quitters);
-    this._platform.pubSub.publish(this.id, __spreadValues({
-      connectionId: senderId != null ? senderId : null,
-      room: this.id,
-      user: (_a = sender == null ? void 0 : sender.user) != null ? _a : null
-    }, message));
-  }
-  _emitQuitters(quitters) {
-    quitters.forEach((quitter) => {
-      this._broadcast({
-        message: {
-          type: "$EXIT",
-          data: { sessionId: quitter.id }
-        },
-        senderId: quitter.id
+  }
+  _emitQuitters() {
+    return __async(this, null, function* () {
+      const currentTime = (/* @__PURE__ */ new Date()).getTime();
+      const quitters = Array.from(this._sessions.values()).filter(
+        (pluvWs) => pluvWs.state.quit || currentTime - pluvWs.state.timers.ping > PING_TIMEOUT_MS
+      );
+      quitters.forEach((pluvWs) => {
+        this._sessions.delete(pluvWs.sessionId);
       });
+      const promises = quitters.map((quitter) => __async(this, null, function* () {
+        yield this._broadcast({
+          message: {
+            type: "$EXIT",
+            data: { sessionId: quitter.sessionId }
+          },
+          senderId: quitter.sessionId
+        });
+      }));
+      yield Promise.all(promises);
     });
   }
-  _emitRegistered(session) {
-    this._sendSelfMessage(
-      {
-        type: "$REGISTERED",
-        data: { sessionId: session.id }
-      },
-      session
-    );
+  _emitRegistered(pluvWs) {
+    return __async(this, null, function* () {
+      const session = yield pluvWs.getSession();
+      const sessionId = session.id;
+      const user = session.user;
+      yield this._sendSelfMessage({ type: "$REGISTERED", data: { sessionId } }, { sessionId, user });
+    });
   }
-  _getIOAuthorize(context) {
-    if (typeof this._authorize === "function") {
-      return this._authorize(context);
+  _ensureDetached() {
+    if (this._platform._registrationMode === "detached") return;
+    throw new Error("Platform must use detached mode");
+  }
+  _getAbstractWs(webSocket) {
+    var _a, _b;
+    if (webSocket instanceof AbstractWebSocket) return webSocket;
+    const sessionId = this._platform.getSessionId(webSocket);
+    if (typeof sessionId === "string") {
+      const session = (_a = this._sessions.get(sessionId)) != null ? _a : null;
+      if (session) return session;
     }
-    return this._authorize;
+    const sessions = Array.from(this._sessions.values());
+    return (_b = sessions.find((pluvWs) => pluvWs.webSocket === webSocket)) != null ? _b : null;
   }
-  _getAuthorizedUser(token, context) {
+  _getSession(webSocket) {
+    return __async(this, null, function* () {
+      const pluvWs = this._getAbstractWs(webSocket);
+      if (!pluvWs) throw new Error("Session could not be found");
+      return yield pluvWs.getSession();
+    });
+  }
+  _getAuthorizedUser(token) {
     return __async(this, null, function* () {
       var _a;
-      const ioAuthorize = this._getIOAuthorize(context);
+      const ioAuthorize = this._getIOAuthorize();
       if (!ioAuthorize) return null;
       if (!token) return null;
       const payload = yield authorize({
@@ -528,6 +589,12 @@ var IORoom = class {
       }
     });
   }
+  _getIOAuthorize() {
+    if (typeof this._authorize === "function") {
+      return this._authorize(this._context);
+    }
+    return this._authorize;
+  }
   _getProcedure(message) {
     var _a;
     return (_a = this._router._events[message.type]) != null ? _a : null;
@@ -537,6 +604,14 @@ var IORoom = class {
     if (!procedure) return message.data;
     return procedure.config.input ? procedure.config.input.parse(message.data) : message.data;
   }
+  _getSessions() {
+    return __async(this, null, function* () {
+      const promises = Array.from(this._sessions.values()).map((pluvWs) => __async(this, null, function* () {
+        return yield pluvWs.getSession();
+      }));
+      return yield Promise.all(promises);
+    });
+  }
   _initialize() {
     return __async(this, null, function* () {
       this._logDebug(`${import_kleur.default.blue(`Initializing room ${this.id}:`)}`);
@@ -544,14 +619,15 @@ var IORoom = class {
         yield this._uninitialize();
         this._uninitialize = null;
       }
-      const pubSubId = yield this._platform.pubSub.subscribe(this.id, (_a) => {
-        var _b = _a, { options = {} } = _b, message = __objRest(_b, ["options"]);
-        const session = {
-          id: message.connectionId,
-          user: message.user
-        };
-        this._sendMessage(message, session, options);
-      });
+      const pubSubId = yield this._platform.pubSub.subscribe(
+        this.id,
+        (_a) => __async(this, null, function* () {
+          var _b = _a, { options = {} } = _b, message = __objRest(_b, ["options"]);
+          const sessionId = message.connectionId;
+          const user = message.user;
+          yield this._sendMessage(message, { sessionId, user }, options);
+        })
+      );
       this._uninitialize = () => __async(this, null, function* () {
         this._platform.pubSub.unsubscribe(pubSubId);
         const encodedState = this._doc.getEncodedState();
@@ -568,43 +644,48 @@ var IORoom = class {
   _logDebug(...data) {
     this._debug && console.log(...data);
   }
-  _onClose(session, callback) {
+  _onClose(webSocket) {
     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(() => {
+      webSocket.state.quit = true;
+      this._logDebug(`${import_kleur.default.blue(`Unregistering connection for room ${this.id}:`)} ${webSocket.sessionId}`);
+      this._sessions.delete(webSocket.sessionId);
+      this._platform.persistance.deleteUser(this.id, webSocket.sessionId).finally(() => __async(this, null, function* () {
         var _a;
-        this._broadcast({
+        yield this._broadcast({
           message: {
             type: "$EXIT",
-            data: { sessionId: session.id }
+            data: { sessionId: webSocket.sessionId }
           },
-          senderId: session.id
+          senderId: webSocket.sessionId
         });
-        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(`Unregistered connection for room ${this.id}:`)} ${webSocket.sessionId}`);
         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, platformEventContext) {
-    return (event) => {
+  _onMessage(webSocket) {
+    return (event) => __async(this, null, function* () {
       var _a, _b, _c, _d, _e, _f;
+      const pluvWs = this._getAbstractWs(webSocket);
+      if (!pluvWs) throw new Error("Could not get session");
+      const [session, sessions] = yield Promise.all([
+        this._getSession(pluvWs),
+        this._getSessions()
+      ]);
       const baseContext = {
         context: this._context,
         doc: this._doc,
         room: this.id,
         session,
-        sessions: this._sessions
+        sessions
       };
       if (!this._uninitialize) return;
-      if (session.quit) {
-        session.webSocket.close(1011, "WebSocket broken.");
+      if (pluvWs.state.quit) {
+        pluvWs.close(1011, "WebSocket broken.");
         return;
       }
       const message = this._parseMessage(event);
@@ -615,47 +696,52 @@ var IORoom = class {
       try {
         inputs = this._getProcedureInputs(message);
       } catch (error) {
-        session == null ? void 0 : session.webSocket.handleError({
+        pluvWs.handleError({
           error,
           message: "Invalid input",
+          room: this.id,
           session
         });
         return;
       }
-      const extendedContext = __spreadProps(__spreadValues({}, baseContext), {
-        context: __spreadValues(__spreadValues({}, this._context), platformEventContext)
-      });
+      const extendedContext = __spreadProps(__spreadValues({}, baseContext), { context: __spreadValues({}, this._context) });
       Promise.all([
         (_b = (_a = procedure.config).broadcast) == null ? void 0 : _b.call(_a, inputs, extendedContext),
         (_d = (_c = procedure.config).self) == null ? void 0 : _d.call(_c, inputs, extendedContext),
         (_f = (_e = procedure.config).sync) == null ? void 0 : _f.call(_e, inputs, baseContext)
-      ]).then(([broadcast, self, sync]) => {
+      ]).then((_0) => __async(this, [_0], function* ([broadcast, self, sync]) {
+        const sessionId = session.id;
+        const user = session.user;
         if (broadcast) {
           Object.entries(broadcast).forEach(([type, data]) => {
             this._broadcast({
               message: { data, type },
-              senderId: session.id
+              senderId: sessionId
             });
           });
         }
         if (self) {
-          Object.entries(self).forEach(([type, data]) => {
-            this._sendSelfMessage({ data, type }, session);
-          });
+          yield Promise.all(
+            Object.entries(self).map((_02) => __async(this, [_02], function* ([type, data]) {
+              yield this._sendSelfMessage({ data, type }, { sessionId, user });
+            }))
+          );
         }
         if (sync) {
           this._platform.pubSub.publish(this.id, __spreadValues({
             connectionId: session.id,
             options: { type: "sync" },
             room: this.id,
-            user: session.user
+            user
           }, message));
-          Object.entries(sync).forEach(([type, data]) => {
-            this._sendSelfMessage({ data, type }, session);
-          });
+          yield Promise.all(
+            Object.entries(sync).map((_02) => __async(this, [_02], function* ([type, data]) {
+              yield this._sendSelfMessage({ data, type }, { sessionId, user });
+            }))
+          );
         }
-      });
-    };
+      }));
+    });
   }
   _parseMessage(message) {
     try {
@@ -668,80 +754,93 @@ var IORoom = class {
       return null;
     }
   }
-  _sendMessage(message, sender, options = {}) {
-    switch (options.type) {
-      case "self": {
-        this._sendSelfMessage(message, sender);
-        return;
-      }
-      case "sync": {
-        this._sendSyncMessage(message, sender);
-        return;
-      }
-      case "broadcast":
-      default: {
-        const sessionIds = options.sessionIds;
-        this._sendBroadcastMessage(message, sender, sessionIds);
+  _sendMessage(_0, _1) {
+    return __async(this, arguments, function* (message, sender, options = {}) {
+      switch (options.type) {
+        case "self": {
+          yield this._sendSelfMessage(message, sender);
+          return;
+        }
+        case "sync": {
+          yield this._sendSyncMessage(message, sender);
+          return;
+        }
+        case "broadcast":
+        default: {
+          const sessionIds = options.sessionIds;
+          yield this._sendBroadcastMessage(message, sender, sessionIds);
+        }
       }
-    }
+    });
   }
   _sendBroadcastMessage(message, sender, sessionIds) {
-    var _a, _b;
-    const senderId = (_a = sender == null ? void 0 : sender.id) != null ? _a : null;
-    const sessions = (_b = sessionIds == null ? void 0 : sessionIds.reduce((dict, id) => {
-      const _session = this._sessions.get(id);
-      return _session ? dict.set(id, _session) : dict;
-    }, /* @__PURE__ */ new Map())) != null ? _b : this._sessions;
-    Array.from(sessions.values()).forEach((_session) => {
-      _session.webSocket.sendMessage(__spreadValues({
+    return __async(this, null, function* () {
+      var _a, _b;
+      const { data, type } = message;
+      const connectionId = (_a = sender == null ? void 0 : sender.sessionId) != null ? _a : null;
+      const room = this.id;
+      const webSockets = (_b = sessionIds == null ? void 0 : sessionIds.reduce((dict, id) => {
+        const pluvWs = this._sessions.get(id);
+        return pluvWs ? dict.set(id, pluvWs) : dict;
+      }, /* @__PURE__ */ new Map())) != null ? _b : this._sessions;
+      const promises = Array.from(webSockets.values()).map((pluvWs) => __async(this, null, function* () {
+        var _a2;
+        const session = yield pluvWs.getSession();
+        const user = (_a2 = session.user) != null ? _a2 : null;
+        pluvWs.sendMessage({ connectionId, data, room, type, user });
+      }));
+      yield Promise.all(promises);
+    });
+  }
+  _sendSelfMessage(message, sender) {
+    return __async(this, null, function* () {
+      var _a, _b;
+      const senderId = (_a = sender == null ? void 0 : sender.sessionId) != null ? _a : null;
+      if (typeof senderId !== "string") return;
+      const pluvWs = this._sessions.get(senderId);
+      if (!pluvWs) return;
+      if (message.type === "$PONG") yield this._emitQuitters();
+      const session = yield pluvWs.getSession();
+      const user = (_b = session.user) != null ? _b : null;
+      pluvWs.sendMessage(__spreadValues({
         connectionId: senderId,
         room: this.id,
-        user: _session.user
+        user
       }, message));
     });
   }
-  _sendSelfMessage(message, sender) {
-    const senderId = sender == null ? void 0 : sender.id;
-    if (!senderId) return;
-    const session = this._sessions.get(senderId);
-    if (!session) return;
-    session.webSocket.sendMessage(__spreadValues({
-      connectionId: sender.id,
-      room: this.id,
-      user: sender.user
-    }, message));
-  }
   _sendSyncMessage(message, sender) {
-    var _a;
-    const senderId = sender == null ? void 0 : sender.id;
-    if (!senderId) return;
-    const context = {
-      context: this._context,
-      doc: this._doc,
-      room: this.id,
-      session: null,
-      sessions: this._sessions
-    };
-    const resolver = (_a = this._getProcedure(message)) == null ? void 0 : _a.config.sync;
-    if (!resolver) return;
-    let inputs;
-    try {
-      inputs = this._getProcedureInputs(message);
-    } catch (e) {
-      return;
-    }
-    Promise.resolve(resolver(inputs, context)).then((output) => {
-      if (!output) return;
-      Object.keys(output).forEach((type) => {
-        var _a2, _b;
-        const data = (_a2 = output[type]) != null ? _a2 : {};
-        this._platform.pubSub.publish(this.id, {
-          connectionId: senderId,
-          data,
-          options: { type: "self" },
-          room: this.id,
-          type,
-          user: (_b = sender.user) != null ? _b : null
+    return __async(this, null, function* () {
+      var _a;
+      if (!sender) return;
+      const context = {
+        context: this._context,
+        doc: this._doc,
+        room: this.id,
+        session: null,
+        sessions: yield this._getSessions()
+      };
+      const resolver = (_a = this._getProcedure(message)) == null ? void 0 : _a.config.sync;
+      if (!resolver) return;
+      let inputs;
+      try {
+        inputs = this._getProcedureInputs(message);
+      } catch (e) {
+        return;
+      }
+      Promise.resolve(resolver(inputs, context)).then((output) => {
+        if (!output) return;
+        Object.keys(output).forEach((type) => {
+          var _a2, _b;
+          const data = (_a2 = output[type]) != null ? _a2 : {};
+          this._platform.pubSub.publish(this.id, {
+            connectionId: sender.sessionId,
+            data,
+            options: { type: "self" },
+            room: this.id,
+            type,
+            user: (_b = sender.user) != null ? _b : null
+          });
         });
       });
     });
@@ -749,7 +848,7 @@ var IORoom = class {
 };
 
 // src/version.generated.ts
-var version = "0.20.0";
+var version = "0.21.1";
 
 // src/PluvServer.ts
 var PluvServer = class {
@@ -782,6 +881,9 @@ var PluvServer = class {
   get _events() {
     return this._router._events;
   }
+  get _registrationMode() {
+    return this._platform._registrationMode;
+  }
   createToken(params) {
     return __async(this, null, function* () {
       if (!this._authorize) {
@@ -795,9 +897,9 @@ var PluvServer = class {
       }).encode(params);
     });
   }
-  getRoom(room, options) {
-    var _b;
-    const _a = options, { debug } = _a, platformRoomContext = __objRest(_a, ["debug"]);
+  getRoom(room, ...options) {
+    var _a, _c;
+    const _b = (_a = options[0]) != null ? _a : {}, { debug } = _b, platformRoomContext = __objRest(_b, ["debug"]);
     this._purgeEmptyRooms();
     if (!/^[a-z0-9]+[a-z0-9\-_]+[a-z0-9]+$/i.test(room)) {
       throw new Error("Unsupported room name");
@@ -807,24 +909,25 @@ var PluvServer = class {
     if (oldRoom) return oldRoom;
     const roomContext = __spreadValues(__spreadValues({}, this._context), platformRoomContext);
     const newRoom = new IORoom(room, {
-      authorize: (_b = this._authorize) != null ? _b : void 0,
+      authorize: (_c = this._authorize) != null ? _c : void 0,
       context: roomContext,
       crdt: this._crdt,
       debug: debug != null ? debug : this._debug,
-      onDestroy: ({ encodedState, room: room2 }) => {
+      onDestroy: (_0) => __async(this, [_0], function* ({ encodedState, room: room2 }) {
         this._logDebug(`${import_kleur2.default.blue("Deleting empty room:")} ${room2}`);
         const roomContext2 = __spreadValues({
           room: room2,
           encodedState
         }, platformRoomContext);
         this._rooms.delete(room2);
-        this._listeners.onRoomDeleted(roomContext2);
+        yield Promise.resolve(this._listeners.onRoomDeleted(roomContext2));
+        yield this._platform.persistance.deleteStorageState(room2);
         if (this._debug) {
           const rooms = Array.from(this._rooms.keys());
           this._logDebug(`${import_kleur2.default.blue("Deleted room:")} ${room2}`);
           this._logDebug(`${import_kleur2.default.blue("Rooms available:")} ${rooms.join(", ")}`);
         }
-      },
+      }),
       platform,
       router: this._router
     });
@@ -853,10 +956,16 @@ var PluvIO = class {
   constructor(options) {
     this._router = new PluvRouter({
       $GET_OTHERS: this.procedure.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,
+        const currentTime = (/* @__PURE__ */ new Date()).getTime();
+        const others = sessions.filter((wsSession) => {
+          if (wsSession.id === (session == null ? void 0 : session.id)) return false;
+          if (wsSession.quit) return false;
+          if (currentTime - wsSession.timers.ping > PING_TIMEOUT_MS) return false;
+          return true;
+        }).reduce(
+          (acc, { id, presence, user }) => __spreadProps(__spreadValues({}, acc), {
+            [id]: {
+              connectionId: id,
               presence,
               room,
               user
@@ -904,8 +1013,9 @@ var PluvIO = class {
       $UPDATE_PRESENCE: this.procedure.broadcast((data, { session }) => {
         const presence = data == null ? void 0 : data.presence;
         if (!session) return {};
-        session.presence = Object.assign(/* @__PURE__ */ Object.create(null), session.presence, presence);
-        return { $PRESENCE_UPDATED: { presence } };
+        const updated = Object.assign(/* @__PURE__ */ Object.create(null), session.presence, presence);
+        session.webSocket.presence = updated;
+        return { $PRESENCE_UPDATED: { presence: updated } };
       }),
       $UPDATE_STORAGE: this.procedure.broadcast((data, { context, doc, room }) => {
         var _a;
@@ -953,14 +1063,15 @@ var PluvIO = class {
   get _events() {
     return this._router._events;
   }
+  get _registrationMode() {
+    return this._platform._registrationMode;
+  }
   get procedure() {
     return new PluvProcedure();
   }
   createToken(params) {
     return __async(this, null, function* () {
-      if (!this._authorize) {
-        throw new Error("IO does not specify authorize during initialization.");
-      }
+      if (!this._authorize) throw new Error("IO does not specify authorize during initialization.");
       const ioAuthorize = typeof this._authorize === "function" ? this._authorize(params) : this._authorize;
       const secret = ioAuthorize.secret;
       return yield authorize({