@jgengine/ws 0.19.0 → 0.21.0

package/dist/hostRouter.js

@@ -53,6 +53,13 @@ export function createHostRouter(options) {
     const authenticate = options.authenticate ??
         (allowAnonymous ? ({ userId }) => userId : null);
     const connections = new Set();
+    let closed = false;
+    const work = new Set();
+    const track = (promise) => {
+        work.add(promise);
+        void promise.finally(() => work.delete(promise)).catch(() => { });
+        return promise;
+    };
     const sessionsByUserId = new Map();
     const resumeTokens = new Map();
     const pendingLeaves = new Map();
@@ -77,6 +84,45 @@ export function createHostRouter(options) {
         }
         return false;
     };
+    const scheduleLeave = (connection, userId, serverId) => {
+        clearPendingLeave(userId, serverId);
+        const key = ticketKey(userId, serverId);
+        pendingLeaves.set(key, setTimeout(() => {
+            pendingLeaves.delete(key);
+            void track((async () => {
+                const admissions = [...connections]
+                    .filter(other => other !== connection && other.userId === userId)
+                    .flatMap(other => other.admission === null || (other.admission.serverId !== undefined && other.admission.serverId !== serverId)
+                    ? [] : [other.admission.result]);
+                await Promise.allSettled(admissions);
+                if (closed || heldByOtherConnection(connection, userId, serverId))
+                    return;
+                await host.leaveServer({ userId, serverId });
+            })()).catch(() => { });
+        }, graceMs));
+    };
+    const admit = async (connection, userId, join, role, sessionId, serverId) => {
+        const admission = join().then(result => {
+            if (result === null || closed)
+                return result;
+            if (connection.closed || connection.userId !== userId) {
+                scheduleLeave(connection, userId, result.serverId);
+                return result;
+            }
+            connection.joinedServers.add(result.serverId);
+            connection.roles.set(result.serverId, role ?? "player");
+            if (sessionId !== undefined)
+                getOrCreate(connection.sessions, result.serverId, () => new Set()).add(sessionId);
+            return result;
+        });
+        connection.admission = { serverId, result: admission };
+        try {
+            return await admission;
+        }
+        finally {
+            connection.admission = null;
+        }
+    };
     const subscribers = new Map();
     const subscribersOf = (key) => {
         const set = subscribers.get(key);
@@ -84,6 +130,13 @@ export function createHostRouter(options) {
     };
     const addSubscription = (connection, key) => {
         connection.subscriptions.add(key);
+        const push = connection.subscriptionPushes.get(key);
+        if (push === undefined) {
+            connection.subscriptionPushes.set(key, { generation: 0, pending: false });
+        }
+        else {
+            push.generation += 1;
+        }
         let set = subscribers.get(key);
         if (set === undefined) {
             set = new Set();
@@ -93,6 +146,13 @@ export function createHostRouter(options) {
     };
     const removeSubscription = (connection, key) => {
         connection.subscriptions.delete(key);
+        const push = connection.subscriptionPushes.get(key);
+        if (push !== undefined) {
+            push.generation += 1;
+            push.pending = false;
+            if (push.run === undefined)
+                connection.subscriptionPushes.delete(key);
+        }
         const set = subscribers.get(key);
         if (set === undefined)
             return;
@@ -105,6 +165,8 @@ export function createHostRouter(options) {
     const histories = new Map();
     const historyFor = (serverId) => getOrCreate(histories, serverId, () => createPositionHistory({ historyMs: positionHistoryMs }));
     const send = (connection, message) => {
+        if (closed || connection.closed)
+            return;
         connection.transport.send(encodeWsMessage(message));
     };
     const reply = (connection, id, result) => {
@@ -156,6 +218,8 @@ export function createHostRouter(options) {
             atMs: now(),
             ...args,
         });
+        if (closed || connection.closed)
+            return false;
         if (!decision.allow) {
             replyError(connection, id, decision.reason);
             return false;
@@ -244,32 +308,42 @@ export function createHostRouter(options) {
         reply(connection, message.id, null);
         broadcastChat(message.serverId, message.channelId);
     };
-    const pushSubscription = async (connection, channel, serverId, action) => {
-        if (connection.userId === null)
+    const pushSubscription = async (connection, channel, serverId, action, isCurrent) => {
+        if (connection.userId === null || !isCurrent())
             return;
+        if (host.pullWorld !== undefined) {
+            if (!(await host.isMember({ userId: connection.userId, serverId })) || !isCurrent())
+                return;
+        }
         if (channel === "server") {
             if (host.pullWorld !== undefined) {
                 const sinceRevision = connection.worldRevisions.get(serverId) ?? null;
                 const world = await host.pullWorld({ userId: connection.userId, serverId, sinceRevision, role: connection.roles.get(serverId) });
+                if (!isCurrent())
+                    return;
                 if (world !== null) {
-                    connection.worldRevisions.set(serverId, world.revision);
                     const data = await host.getServerView({ userId: connection.userId, serverId, role: connection.roles.get(serverId) });
-                    if (data !== null) {
+                    if (data !== null && isCurrent()) {
                         send(connection, { v: 1, t: "update", channel, serverId, data: { ...data, serverState: world } });
+                        connection.worldRevisions.set(serverId, world.revision);
                     }
                     return;
                 }
+                return;
             }
             const data = await host.getServerView({ userId: connection.userId, serverId, role: connection.roles.get(serverId) });
-            send(connection, { v: 1, t: "update", channel, serverId, data });
+            if (isCurrent())
+                send(connection, { v: 1, t: "update", channel, serverId, data });
         }
         else if (channel === "player") {
             const data = await host.getPlayerView({ userId: connection.userId, serverId });
-            send(connection, { v: 1, t: "update", channel, serverId, data });
+            if (isCurrent())
+                send(connection, { v: 1, t: "update", channel, serverId, data });
         }
         else if (channel === "feed") {
             const data = await host.getFeed({ userId: connection.userId, serverId, action: action ?? "" });
-            send(connection, { v: 1, t: "update", channel, serverId, action: action ?? "", data });
+            if (isCurrent())
+                send(connection, { v: 1, t: "update", channel, serverId, action: action ?? "", data });
         }
         else if (channel === "chat") {
             const channelId = action ?? "";
@@ -297,18 +371,50 @@ export function createHostRouter(options) {
             send(connection, { v: 1, t: "update", channel, serverId, data: presenceRows(serverId) });
         }
     };
+    const requestSubscriptionPush = (connection, channel, serverId, action) => {
+        const key = subscriptionKey(channel, serverId, action);
+        const push = connection.subscriptionPushes.get(key);
+        if (push === undefined)
+            return Promise.resolve();
+        push.pending = true;
+        if (push.run !== undefined)
+            return push.run;
+        const isActive = () => connections.has(connection) && connection.userId !== null && connection.subscriptions.has(key) && connection.subscriptionPushes.get(key) === push;
+        push.run = track(Promise.resolve().then(async () => {
+            while (push.pending && isActive()) {
+                push.pending = false;
+                const generation = push.generation;
+                try {
+                    await pushSubscription(connection, channel, serverId, action, () => isActive() && push.generation === generation);
+                }
+                catch {
+                    // A failed read leaves the sent revision intact; a later notification retries it.
+                }
+            }
+        }).finally(() => {
+            push.run = undefined;
+            if (!isActive()) {
+                if (connection.subscriptionPushes.get(key) === push)
+                    connection.subscriptionPushes.delete(key);
+            }
+            else if (push.pending) {
+                void requestSubscriptionPush(connection, channel, serverId, action);
+            }
+        }));
+        return push.run;
+    };
     const onHostEvent = (event) => {
         if (event.type === "server") {
             for (const connection of subscribersOf(subscriptionKey("server", event.serverId))) {
                 if (connection.userId === null)
                     continue;
-                void pushSubscription(connection, "server", event.serverId);
+                void requestSubscriptionPush(connection, "server", event.serverId);
             }
         }
         else if (event.type === "player") {
             for (const connection of subscribersOf(subscriptionKey("player", event.serverId))) {
                 if (connection.userId === event.userId) {
-                    void pushSubscription(connection, "player", event.serverId);
+                    void requestSubscriptionPush(connection, "player", event.serverId);
                 }
             }
         }
@@ -316,7 +422,7 @@ export function createHostRouter(options) {
             for (const connection of subscribersOf(subscriptionKey("feed", event.serverId, event.action))) {
                 if (connection.userId === null)
                     continue;
-                void pushSubscription(connection, "feed", event.serverId, event.action);
+                void requestSubscriptionPush(connection, "feed", event.serverId, event.action);
             }
         }
     };
@@ -365,6 +471,8 @@ export function createHostRouter(options) {
         dropUserFrom(presence, userId, (key) => key === serverId, () => broadcastPresence(serverId));
     };
     const handleMessage = async (connection, message) => {
+        if (closed || connection.closed)
+            return;
         if (message.t === "hello") {
             if (connection.userId !== null) {
                 replyError(connection, message.id, "Already authenticated");
@@ -379,6 +487,8 @@ export function createHostRouter(options) {
             const userId = resumeToken !== undefined && message.token === resumeToken
                 ? message.userId
                 : await authenticate({ userId: message.userId, token: message.token });
+            if (closed || connection.closed)
+                return;
             if (userId === null) {
                 replyError(connection, message.id, "Not authenticated");
                 connection.transport.close();
@@ -424,18 +534,18 @@ export function createHostRouter(options) {
                 case "join": {
                     if (!(await gate(connection, message.id, "join", { serverId: message.serverId })))
                         return;
-                    const result = await host.joinServer({
+                    const result = await admit(connection, userId, () => host.joinServer({
                         userId,
                         gameId: message.gameId,
                         serverId: message.serverId,
                         attributes: message.attributes,
                         code: message.code,
                         role: message.role,
-                    });
-                    connection.joinedServers.add(result.serverId);
-                    connection.roles.set(result.serverId, message.role ?? "player");
-                    if (message.sessionId !== undefined)
-                        getOrCreate(connection.sessions, result.serverId, () => new Set()).add(message.sessionId);
+                    }), message.role, message.sessionId, message.serverId);
+                    if (result === null)
+                        return;
+                    if (closed || connection.closed || connection.userId !== userId)
+                        return;
                     reply(connection, message.id, {
                         ...result,
                         resumeTicket: ticketFor(userId, result.serverId),
@@ -445,14 +555,14 @@ export function createHostRouter(options) {
                 case "joinByCode": {
                     if (!(await gate(connection, message.id, "join", {})))
                         return;
-                    const result = await host.joinByCode({
+                    const result = await admit(connection, userId, () => host.joinByCode({
                         userId,
                         gameId: message.gameId,
                         code: message.code,
-                    });
+                    }), message.role);
                     if (result !== null) {
-                        connection.joinedServers.add(result.serverId);
-                        connection.roles.set(result.serverId, message.role ?? "player");
+                        if (closed || connection.closed || connection.userId !== userId)
+                            return;
                     }
                     reply(connection, message.id, result === null
                         ? null
@@ -566,18 +676,20 @@ export function createHostRouter(options) {
                     return;
                 }
                 case "subscribe": {
-                    if ((message.channel === "chat" ||
+                    if ((host.pullWorld !== undefined || message.channel === "chat" ||
                         message.channel === "voice" ||
                         message.channel === "presence") &&
                         !(await host.isMember({ userId, serverId: message.serverId }))) {
                         replyError(connection, message.id, "Not a member of this server");
                         return;
                     }
+                    if (closed || connection.closed)
+                        return;
                     if (message.channel === "server")
                         connection.worldRevisions.set(message.serverId, null);
                     addSubscription(connection, subscriptionKey(message.channel, message.serverId, message.action));
                     reply(connection, message.id, null);
-                    await pushSubscription(connection, message.channel, message.serverId, message.action);
+                    void requestSubscriptionPush(connection, message.channel, message.serverId, message.action);
                     return;
                 }
                 case "unsubscribe": {
@@ -592,26 +704,22 @@ export function createHostRouter(options) {
         }
     };
     const leaveJoinedServers = (connection) => {
-        if (connection.userId === null)
+        if (closed || connection.userId === null)
             return;
         const userId = connection.userId;
         const servers = [...connection.joinedServers];
         connection.joinedServers.clear();
         connection.sessions.clear();
         for (const serverId of servers) {
-            const key = ticketKey(userId, serverId);
-            clearPendingLeave(userId, serverId);
-            pendingLeaves.set(key, setTimeout(() => {
-                pendingLeaves.delete(key);
-                if (heldByOtherConnection(connection, userId, serverId))
-                    return;
-                void host.leaveServer({ userId, serverId }).catch(() => undefined);
-            }, graceMs));
+            scheduleLeave(connection, userId, serverId);
         }
     };
     return {
         connect: (transport) => {
+            if (closed)
+                throw new Error("Host router is closed");
             const connection = {
+                closed: false,
                 transport,
                 userId: null,
                 subscriptions: new Set(),
@@ -621,10 +729,14 @@ export function createHostRouter(options) {
                 queuedMessages: 0,
                 worldRevisions: new Map(),
                 roles: new Map(),
+                subscriptionPushes: new Map(),
+                admission: null,
             };
             connections.add(connection);
             return {
                 handleRaw: (raw) => {
+                    if (closed || connection.closed)
+                        return;
                     const text = typeof raw === "string" ? raw : String(raw);
                     const message = decodeWsClientMessage(text);
                     if (message === null) {
@@ -640,14 +752,17 @@ export function createHostRouter(options) {
                         return;
                     }
                     connection.queuedMessages += 1;
-                    connection.queue = connection.queue
+                    connection.queue = track(connection.queue
                         .then(() => handleMessage(connection, message))
                         .catch(() => undefined)
                         .finally(() => {
                         connection.queuedMessages -= 1;
-                    });
+                    }));
                 },
                 close: () => {
+                    if (connection.closed)
+                        return;
+                    connection.closed = true;
                     if (connection.userId !== null && sessionsByUserId.get(connection.userId) === connection) {
                         sessionsByUserId.delete(connection.userId);
                     }
@@ -674,6 +789,9 @@ export function createHostRouter(options) {
             return positions;
         },
         close: () => {
+            if (closed)
+                return;
+            closed = true;
             unsubscribeHost();
             for (const timer of pendingLeaves.values())
                 clearTimeout(timer);
@@ -681,6 +799,10 @@ export function createHostRouter(options) {
             connections.clear();
             subscribers.clear();
         },
+        async drain() {
+            while (work.size > 0)
+                await Promise.allSettled([...work]);
+        },
     };
 }
 export function loopbackPipe(router) {

package/dist/peer.js

@@ -126,12 +126,19 @@ export function createPeerHost(options) {
             };
             channel.onclose = () => connection.close();
         };
-        await pc.setRemoteDescription({ type: payload.type, sdp: payload.sdp });
-        const answer = await pc.createAnswer();
-        await pc.setLocalDescription(answer);
-        await waitForIceGathering(pc, iceGatherTimeoutMs);
-        const description = localDescriptionOrThrow(pc);
-        return encodePeerSignal({ type: "answer", sdp: description.sdp });
+        try {
+            await pc.setRemoteDescription({ type: payload.type, sdp: payload.sdp });
+            const answer = await pc.createAnswer();
+            await pc.setLocalDescription(answer);
+            await waitForIceGathering(pc, iceGatherTimeoutMs);
+            const description = localDescriptionOrThrow(pc);
+            return encodePeerSignal({ type: "answer", sdp: description.sdp });
+        }
+        catch (error) {
+            peerConnections.delete(pc);
+            pc.close();
+            throw error;
+        }
     };
     return {
         backend,
@@ -190,7 +197,10 @@ export function broadcastChannelSignaling(room) {
     const channel = new BroadcastChannel(room);
     const pendingAnswers = new Map();
     let currentAnswer = null;
+    let closed = false;
     channel.onmessage = (event) => {
+        if (closed)
+            return;
         const envelope = event.data;
         if (!isSignalEnvelope(envelope))
             return;
@@ -199,25 +209,40 @@ export function broadcastChannelSignaling(room) {
             if (answer === null)
                 return;
             void answer(envelope.code).then((answerCode) => {
+                if (closed)
+                    return;
                 channel.postMessage({ t: "answer", id: envelope.id, code: answerCode });
+            }, (error) => {
+                if (!closed)
+                    throw error;
             });
             return;
         }
-        const resolve = pendingAnswers.get(envelope.id);
-        if (resolve === undefined)
+        const pending = pendingAnswers.get(envelope.id);
+        if (pending === undefined)
             return;
         pendingAnswers.delete(envelope.id);
-        resolve(envelope.code);
+        pending.resolve(envelope.code);
     };
     return {
         publishOffer: (offerCode) => {
+            if (closed)
+                return Promise.reject(new Error("Peer signaling is closed"));
             const id = crypto.randomUUID();
-            return new Promise((resolve) => {
-                pendingAnswers.set(id, resolve);
-                channel.postMessage({ t: "offer", id, code: offerCode });
+            return new Promise((resolve, reject) => {
+                pendingAnswers.set(id, { resolve, reject });
+                try {
+                    channel.postMessage({ t: "offer", id, code: offerCode });
+                }
+                catch (error) {
+                    pendingAnswers.delete(id);
+                    reject(error);
+                }
             });
         },
         onOffer: (answer) => {
+            if (closed)
+                throw new Error("Peer signaling is closed");
             currentAnswer = answer;
             return () => {
                 if (currentAnswer === answer)
@@ -225,6 +250,14 @@ export function broadcastChannelSignaling(room) {
             };
         },
         close: () => {
+            if (closed)
+                return;
+            closed = true;
+            currentAnswer = null;
+            channel.onmessage = null;
+            for (const pending of pendingAnswers.values()) {
+                pending.reject(new Error("Peer signaling is closed"));
+            }
             pendingAnswers.clear();
             channel.close();
         },

package/dist/worldHost.d.ts

@@ -4,18 +4,29 @@ import type { GameHost } from "./host.js";
 export interface WorldGameHostOptions {
     /**
      * Resolve (or lazily build) the authoritative {@link HostedWorldSession} for a server — called once per new
-     * `serverId`. Return `null` for an unknown game. Bind the game's definition + content here.
+     * loaded `serverId`, and again after successful unload. Create a fresh session on reload. Return `null` for an
+     * unknown game. Bind the game's definition + content here.
      */
     session(args: {
         gameId: string;
         serverId: string;
     }): HostedWorldSession | Promise<HostedWorldSession | null> | null;
     now?: () => number;
+    /** Maximum active players per world; reconnecting members and spectators do not consume a new slot. */
+    slotsPerServer?: number;
 }
-/** A {@link GameHost} whose worlds run on `HostedWorldSession`s; `tick` advances them and re-broadcasts on change. */
+/** A {@link GameHost} backed by `HostedWorldSession`s; `tick` advances worlds and `unload` explicitly saves and releases idle world references. */
 export interface WorldGameHost extends GameHost {
     /** Advance every live world by `dtSeconds` and emit a `server` change for each whose revision moved. */
     tick(dtSeconds: number): void;
+    /**
+     * Save and release an unoccupied world's host references. Returns `occupied` for admitted players/spectators or
+     * resident members, and `missing` for an unloaded world. Save failure rejects and retains the world for retry.
+     * Later joins resolve a fresh session; external resources remain caller-owned. Closed hosts reject new unloads.
+     */
+    unload(serverId: string): Promise<"unloaded" | "missing" | "occupied">;
+    /** Permanently close admission/ticks, drain accepted world operations, and save. Repeated calls share completion. */
+    stop(): Promise<void>;
 }
 /**
  * The GameContext-loop counterpart of the reducer `createGameHost`: a structural {@link GameHost} that serves each