@rpgjs/client 5.0.0-alpha.3 → 5.0.0-alpha.30

package/dist/{index20.js → node_modules/.pnpm/@signe_room@2.8.2/node_modules/@signe/room/dist/index.js}

@@ -1,7 +1,7 @@
-import { dset } from './index33.js';
-import z from './index34.js';
-import { syncClass, generateShortUUID as generateShortUUID$1, createStatesSnapshot, id, sync, persist, load, getByPath, DELETE_TOKEN } from './index17.js';
-import { signal } from './index27.js';
+import { dset } from '../../../../../dset@3.1.4/node_modules/dset/dist/index.js';
+import z from '../../../../../zod@3.24.2/node_modules/zod/lib/index.js';
+import { createStatesSnapshotDeep, syncClass, generateShortUUID as generateShortUUID$1, load, id, sync, persist, getByPath, createStatesSnapshot, DELETE_TOKEN } from '../../../../../@signe_sync@2.8.2/node_modules/@signe/sync/dist/index.js';
+import { signal } from '../../../../../@signe_reactive@2.8.2/node_modules/@signe/reactive/dist/index.js';
 
 var __defProp = Object.defineProperty;
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
@@ -521,6 +521,11 @@ var Server = class {
       this.subRoom = await this.createRoom();
     }
   }
+  async runGarbageCollector() {
+    await this.garbageCollector({
+      sessionExpiryTime: -1
+    });
+  }
   async garbageCollector(options) {
     const subRoom = await this.getSubRoom();
     if (!subRoom) return;
@@ -606,12 +611,104 @@ var Server = class {
       load(instance, tmpObject, true);
     }, "loadMemory");
     instance.$memoryAll = {};
+    instance.$autoSync = instance["autoSync"] !== false;
+    instance.$pendingSync = /* @__PURE__ */ new Map();
+    instance.$pendingInitialSync = /* @__PURE__ */ new Map();
     instance.$send = (conn, obj) => {
       return this.send(conn, obj, instance);
     };
     instance.$broadcast = (obj) => {
       return this.broadcast(obj, instance);
     };
+    instance.$applySync = () => {
+      let packet;
+      if (instance.$pendingSync.size > 0) {
+        if (options.getMemoryAll) {
+          buildObject(instance.$pendingSync, instance.$memoryAll);
+        }
+        packet = buildObject(instance.$pendingSync, instance.$memoryAll);
+        instance.$pendingSync.clear();
+      } else {
+        packet = instance.$memoryAll;
+      }
+      const pendingConnections = new Set(instance.$pendingInitialSync.keys());
+      for (const [conn, publicId] of instance.$pendingInitialSync) {
+        this.send(conn, {
+          type: "sync",
+          value: {
+            pId: publicId,
+            ...packet
+          }
+        }, instance);
+      }
+      instance.$pendingInitialSync.clear();
+      for (const conn of this.room.getConnections()) {
+        if (!pendingConnections.has(conn)) {
+          this.send(conn, {
+            type: "sync",
+            value: packet
+          }, instance);
+        }
+      }
+    };
+    instance.$sessionTransfer = async (conn, targetRoomId) => {
+      let user;
+      const signal2 = this.getUsersProperty(instance);
+      if (!signal2) {
+        console.error("[sessionTransfer] `users` property not defined in the room.");
+        return null;
+      }
+      const { publicId } = conn.state;
+      user = signal2()[publicId];
+      if (!user) {
+        console.error(`[sessionTransfer] User with publicId ${publicId} not found.`);
+        return null;
+      }
+      const sessions = await this.room.storage.list();
+      let userSession = null;
+      let privateId = null;
+      for (const [key, session] of sessions) {
+        if (key.startsWith("session:") && session.publicId === publicId) {
+          userSession = session;
+          privateId = key.replace("session:", "");
+          break;
+        }
+      }
+      if (!userSession || !privateId) {
+        console.error(`[sessionTransfer] Session for publicId ${publicId} not found.`);
+        return null;
+      }
+      const usersPropName = this.getUsersPropName(instance);
+      if (!usersPropName) {
+        console.error("[sessionTransfer] `users` property not defined in the room.");
+        return null;
+      }
+      const userSnapshot = createStatesSnapshotDeep(user);
+      const transferData = {
+        privateId,
+        userSnapshot,
+        sessionState: userSession.state,
+        publicId
+      };
+      try {
+        const targetRoomParty = await this.room.context.parties.main.get(targetRoomId);
+        const response2 = await targetRoomParty.fetch("/session-transfer", {
+          method: "POST",
+          body: JSON.stringify(transferData),
+          headers: {
+            "Content-Type": "application/json"
+          }
+        });
+        if (!response2.ok) {
+          throw new Error(`Transfer request failed: ${await response2.text()}`);
+        }
+        const { transferToken } = await response2.json();
+        return transferToken;
+      } catch (error) {
+        console.error(`[sessionTransfer] Failed to transfer session to room ${targetRoomId}:`, error);
+        return null;
+      }
+    };
     const syncCb = /* @__PURE__ */ __name((values) => {
       if (options.getMemoryAll) {
         buildObject(values, instance.$memoryAll);
@@ -620,6 +717,13 @@ var Server = class {
         init = false;
         return;
       }
+      if (!instance.$autoSync) {
+        for (const [path, value] of values) {
+          instance.$pendingSync.set(path, value);
+        }
+        values.clear();
+        return;
+      }
       const packet = buildObject(values, instance.$memoryAll);
       this.broadcast({
         type: "sync",
@@ -644,11 +748,12 @@ var Server = class {
       values.clear();
     }, "persistCb");
     syncClass(instance, {
-      onSync: throttle(syncCb, instance["throttleSync"] ?? 500),
-      onPersist: throttle(persistCb, instance["throttleStorage"] ?? 2e3)
+      onSync: instance["throttleSync"] ? throttle(syncCb, instance["throttleSync"]) : syncCb,
+      onPersist: instance["throttleStorage"] ? throttle(persistCb, instance["throttleStorage"]) : persistCb
     });
     await loadMemory();
     initPersist = false;
+    init = false;
     return instance;
   }
   /**
@@ -802,29 +907,46 @@ var Server = class {
     });
     const roomGuards = subRoom.constructor["_roomGuards"] || [];
     for (const guard of roomGuards) {
-      const isAuthorized = await guard(conn, ctx);
+      const isAuthorized = await guard(conn, ctx, this.room);
       if (!isAuthorized) {
         conn.close();
         return;
       }
     }
+    let transferToken = null;
+    if (ctx.request?.url) {
+      const url = new URL(ctx.request.url);
+      transferToken = url.searchParams.get("transferToken");
+    }
+    let transferData = null;
+    if (transferToken) {
+      transferData = await this.room.storage.get(`transfer:${transferToken}`);
+      if (transferData) {
+        await this.room.storage.delete(`transfer:${transferToken}`);
+      }
+    }
     const existingSession = await this.getSession(conn.id);
-    const publicId = existingSession?.publicId || generateShortUUID$1();
+    const publicId = existingSession?.publicId || transferData?.publicId || generateShortUUID$1();
     let user = null;
     const signal2 = this.getUsersProperty(subRoom);
     const usersPropName = this.getUsersPropName(subRoom);
     if (signal2) {
       const { classType } = signal2.options;
       if (!existingSession?.publicId) {
-        user = isClass(classType) ? new classType() : classType(conn, ctx);
-        signal2()[publicId] = user;
-        const snapshot = createStatesSnapshot(user);
-        this.room.storage.put(`${usersPropName}.${publicId}`, snapshot);
+        if (transferData?.restored && signal2()[publicId]) {
+          user = signal2()[publicId];
+        } else {
+          user = isClass(classType) ? new classType() : classType(conn, ctx);
+          signal2()[publicId] = user;
+          const snapshot = createStatesSnapshotDeep(user);
+          this.room.storage.put(`${usersPropName}.${publicId}`, snapshot);
+        }
       } else {
         user = signal2()[existingSession.publicId];
       }
       if (!existingSession) {
-        await this.saveSession(conn.id, {
+        const sessionPrivateId = transferData?.privateId || conn.id;
+        await this.saveSession(sessionPrivateId, {
           publicId
         });
       } else {
@@ -832,18 +954,22 @@ var Server = class {
       }
     }
     this.updateUserConnectionStatus(user, true);
-    await awaitReturn(subRoom["onJoin"]?.(user, conn, ctx));
     conn.setState({
       ...conn.state,
       publicId
     });
-    this.send(conn, {
-      type: "sync",
-      value: {
-        pId: publicId,
-        ...subRoom.$memoryAll
-      }
-    }, subRoom);
+    await awaitReturn(subRoom["onJoin"]?.(user, conn, ctx));
+    if (subRoom.$autoSync) {
+      this.send(conn, {
+        type: "sync",
+        value: {
+          pId: publicId,
+          ...subRoom.$memoryAll
+        }
+      }, subRoom);
+    } else {
+      subRoom.$pendingInitialSync.set(conn, publicId);
+    }
   }
   /**
   * @method onConnect
@@ -1112,7 +1238,7 @@ var Server = class {
   * @method onClose
   * @async
   * @param {Party.Connection} conn - The connection object of the disconnecting user.
-  * @description Handles user disconnection, removing them from the room and triggering the onLeave event.
+  * @description Handles user disconnection, removing them from the room and triggering the onLeave event..
   * @returns {Promise<void>}
   * 
   * @example
@@ -1128,6 +1254,9 @@ var Server = class {
     if (!subRoom) {
       return;
     }
+    if (subRoom.$pendingInitialSync) {
+      subRoom.$pendingInitialSync.delete(conn);
+    }
     const signal2 = this.getUsersProperty(subRoom);
     if (!conn.state) {
       return;
@@ -1178,6 +1307,66 @@ var Server = class {
     return this.handleDirectRequest(req, res);
   }
   /**
+  * @method handleSessionRestore
+  * @private
+  * @async
+  * @param {Party.Request} req - The HTTP request for session restore
+  * @param {ServerResponse} res - The response object
+  * @description Handles session restoration from transfer data, creates session from privateId
+  * @returns {Promise<Response>} The response to return to the client
+  */
+  async handleSessionRestore(req, res) {
+    try {
+      const transferData = await req.json();
+      const { privateId, userSnapshot, sessionState, publicId } = transferData;
+      if (!privateId || !publicId) {
+        return res.badRequest("Missing privateId or publicId in transfer data");
+      }
+      const subRoom = await this.getSubRoom();
+      if (!subRoom) {
+        return res.serverError("Room not available");
+      }
+      await this.saveSession(privateId, {
+        publicId,
+        state: sessionState,
+        created: Date.now(),
+        connected: false
+        // Will be set to true when user connects
+      });
+      if (userSnapshot) {
+        const signal2 = this.getUsersProperty(subRoom);
+        const usersPropName = this.getUsersPropName(subRoom);
+        if (signal2 && usersPropName) {
+          const { classType } = signal2.options;
+          const user = isClass(classType) ? new classType() : classType();
+          const hydratedSnapshot = await awaitReturn(subRoom["onSessionRestore"]?.({
+            userSnapshot,
+            user,
+            publicId,
+            privateId,
+            sessionState,
+            room: this.room
+          })) ?? userSnapshot;
+          load(user, hydratedSnapshot, true);
+          signal2()[publicId] = user;
+          await this.room.storage.put(`${usersPropName}.${publicId}`, hydratedSnapshot);
+        }
+      }
+      const transferToken = generateShortUUID$1();
+      await this.room.storage.put(`transfer:${transferToken}`, {
+        privateId,
+        publicId,
+        restored: true
+      });
+      return res.success({
+        transferToken
+      });
+    } catch (error) {
+      console.error("Error restoring session:", error);
+      return res.serverError("Failed to restore session");
+    }
+  }
+  /**
   * @method handleDirectRequest
   * @private
   * @async
@@ -1190,6 +1379,10 @@ var Server = class {
     if (!subRoom) {
       return res.notFound();
     }
+    const url = new URL(req.url);
+    if (url.pathname.endsWith("/session-transfer") && req.method === "POST") {
+      return this.handleSessionRestore(req, res);
+    }
     const response2 = await this.tryMatchRequestHandler(req, res, subRoom);
     if (response2) {
       return response2;
@@ -1288,7 +1481,7 @@ var Server = class {
   */
   pathMatches(requestPath, handlerPath) {
     const pathRegexString = handlerPath.replace(/\//g, "\\/").replace(/:([^\/]+)/g, "([^/]+)");
-    const pathRegex = new RegExp(`^${pathRegexString}$`);
+    const pathRegex = new RegExp(`^${pathRegexString}`);
     return pathRegex.test(requestPath);
   }
   /**
@@ -1308,7 +1501,7 @@ var Server = class {
       }
     });
     const pathRegexString = handlerPath.replace(/\//g, "\\/").replace(/:([^\/]+)/g, "([^/]+)");
-    const pathRegex = new RegExp(`^${pathRegexString}$`);
+    const pathRegex = new RegExp(`^${pathRegexString}`);
     const matches = requestPath.match(pathRegex);
     if (matches && matches.length > 1) {
       for (let i = 0; i < paramNames.length; i++) {
@@ -1584,10 +1777,14 @@ async function testRoom(Room3, options = {}) {
   const isShard = options.shard || false;
   const io = new ServerIo(Room3.path, isShard ? {
     parties: {
-      game: createServer
+      game: createServer,
+      ...options.parties || {}
     },
+    partyFn: options.partyFn,
     env: options.env
   } : {
+    parties: options.parties,
+    partyFn: options.partyFn,
     env: options.env
   });
   Room3.prototype.throttleSync = 0;
@@ -1598,20 +1795,34 @@ async function testRoom(Room3, options = {}) {
     const shardServer = new Shard(io);
     shardServer.subRoom = null;
     server = shardServer;
-    for (const lobby of io.context.parties.main.values()) {
-      await lobby.server.onStart();
+    if (io.context.parties.main instanceof Map) {
+      for (const lobby of io.context.parties.main.values()) {
+        await lobby.server.onStart();
+      }
     }
   } else {
     server = await createServer(io);
+    if (io.context.parties.main instanceof Map) {
+      for (const lobby of io.context.parties.main.values()) {
+        if (lobby.server && lobby.server !== server) {
+          await lobby.server.onStart();
+        }
+      }
+    }
   }
   await server.onStart();
   return {
     server,
     room: server.subRoom,
-    createClient: /* @__PURE__ */ __name(async (id2) => {
-      const client = await io.connection(server, id2);
+    createClient: /* @__PURE__ */ __name(async (id2, opts) => {
+      const client = await io.connection(server, id2, opts);
       return client;
-    }, "createClient")
+    }, "createClient"),
+    getServerUser: /* @__PURE__ */ __name(async (client, prop = "users") => {
+      const privateId = client.conn.id;
+      const session = await server.getSession(privateId);
+      return server.subRoom[prop]()[session?.publicId];
+    }, "getServerUser")
   };
 }
 __name(testRoom, "testRoom");
@@ -1624,6 +1835,10 @@ async function request(room, path, options = {
   return response2;
 }
 __name(request, "request");
+function tick(ms = 0) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+__name(tick, "tick");
 
 // src/mock.ts
 var MockPartyClient = class {
@@ -1674,14 +1889,22 @@ var MockLobby = class MockLobby2 {
     __name(this, "MockLobby");
   }
   server;
-  constructor(server) {
+  lobbyId;
+  constructor(server, lobbyId) {
     this.server = server;
+    this.lobbyId = lobbyId;
   }
-  socket() {
+  socket(_init) {
     return new MockPartyClient(this.server);
   }
+  async connection(idOrOptions, maybeOptions) {
+    const id2 = typeof idOrOptions === "string" ? idOrOptions : idOrOptions?.id;
+    const options = (typeof idOrOptions === "string" ? maybeOptions : idOrOptions) || {};
+    return this.server.room.connection(this.server, id2, options);
+  }
   fetch(url, options) {
-    return request(this.server, url, options);
+    const baseUrl = url.includes("shard") ? "" : "/parties/main/" + this.lobbyId;
+    return request(this.server, baseUrl + url, options);
   }
 };
 var MockContext = class MockContext2 {
@@ -1696,8 +1919,22 @@ var MockContext = class MockContext2 {
       main: /* @__PURE__ */ new Map()
     };
     const parties = options.parties || {};
-    for (let lobbyId in parties) {
-      this.parties.main.set(lobbyId, new MockLobby(parties[lobbyId](room)));
+    if (options.partyFn) {
+      const serverCache = /* @__PURE__ */ new Map();
+      this.parties.main = {
+        get: /* @__PURE__ */ __name(async (lobbyId) => {
+          if (!serverCache.has(lobbyId)) {
+            const server = await options.partyFn(lobbyId);
+            serverCache.set(lobbyId, new MockLobby(server, lobbyId));
+          }
+          return serverCache.get(lobbyId);
+        }, "get")
+      };
+    } else {
+      for (let lobbyId in parties) {
+        const server = parties[lobbyId](room);
+        this.parties.main.set(lobbyId, new MockLobby(server, lobbyId));
+      }
     }
   }
 };
@@ -1717,17 +1954,24 @@ var MockPartyRoom = class MockPartyRoom2 {
     this.env = {};
     this.id = id2 || generateShortUUID();
     this.context = new MockContext(this, {
-      parties: options.parties || {}
+      parties: options.parties,
+      partyFn: options.partyFn
     });
     this.env = options.env || {};
   }
-  async connection(server, id2) {
+  async connection(server, id2, opts) {
     const socket = new MockPartyClient(server, id2);
     const url = new URL("http://localhost");
+    if (opts?.query) {
+      for (const [key, value] of Object.entries(opts.query)) {
+        url.searchParams.set(key, String(value));
+      }
+    }
     const request2 = new Request(url.toString(), {
       method: "GET",
       headers: {
-        "Content-Type": "application/json"
+        "Content-Type": "application/json",
+        ...opts?.headers || {}
       }
     });
     await server.onConnect(socket.conn, {
@@ -2417,5 +2661,29 @@ WorldRoom = _ts_decorate([
   ])
 ], WorldRoom);
 
-export { Action, ClientIo, Guard, MockConnection, Request2 as Request, Room, RoomGuard, Server, ServerIo, ServerResponse, Shard, WorldRoom, request, testRoom };
-//# sourceMappingURL=index20.js.map
+// src/session.guard.ts
+function createRequireSessionGuard(storage) {
+  return async (sender, value) => {
+    if (!sender || !sender.id) {
+      return false;
+    }
+    try {
+      const session = await storage.get(`session:${sender.id}`);
+      if (!session) {
+        return false;
+      }
+      const typedSession = session;
+      if (!typedSession.publicId) {
+        return false;
+      }
+      return true;
+    } catch (error) {
+      console.error("Error checking session in requireSession guard:", error);
+      return false;
+    }
+  };
+}
+__name(createRequireSessionGuard, "createRequireSessionGuard");
+
+export { Action, ClientIo, Guard, MockConnection, Request2 as Request, Room, RoomGuard, Server, ServerIo, ServerResponse, Shard, WorldRoom, createRequireSessionGuard, request, testRoom, tick };
+//# sourceMappingURL=index.js.map