@jgengine/ws 0.18.1 → 0.21.0

package/dist/createWsBackend.js

@@ -42,6 +42,7 @@ export function createWsBackend(options) {
     let wantConnection = false;
     let nextId = 1;
     let nextOpId = 1;
+    const operationSession = crypto.randomUUID();
     let reconnectAttempt = 0;
     let reconnectTimer = null;
     const pending = new Map();
@@ -49,6 +50,7 @@ export function createWsBackend(options) {
     const resumeTickets = new Map();
     const joinedGames = new Map();
     const joinedRoles = new Map();
+    const joinedSessions = new Map();
     const rtt = { sampleMs: 0, smoothedMs: 0 };
     let pingTimer = null;
     const schedulePing = () => {
@@ -119,7 +121,10 @@ export function createWsBackend(options) {
     };
     const rejoinServers = () => {
         for (const [serverId, gameId] of joinedGames) {
-            rawSend({ v: 1, t: "join", id: nextId++, gameId, serverId, role: joinedRoles.get(serverId) });
+            const sessions = [...(joinedSessions.get(serverId) ?? [])];
+            for (const sessionId of sessions.length > 0 ? sessions : [undefined]) {
+                rawSend({ v: 1, t: "join", id: nextId++, gameId, serverId, role: joinedRoles.get(serverId), ...(sessionId === undefined ? {} : { sessionId }) });
+            }
         }
     };
     const helloToken = () => resumeTickets.values().next().value?.token ?? options.token;
@@ -315,10 +320,16 @@ export function createWsBackend(options) {
                     gameId: args.gameId,
                     serverId: args.serverId,
                     role: args.role,
+                    ...(args.sessionId === undefined ? {} : { sessionId: args.sessionId }),
                 }));
                 const joined = result;
                 joinedGames.set(joined.serverId, args.gameId);
                 joinedRoles.set(joined.serverId, args.role ?? "player");
+                if (args.sessionId !== undefined) {
+                    const sessions = joinedSessions.get(joined.serverId) ?? new Set();
+                    sessions.add(args.sessionId);
+                    joinedSessions.set(joined.serverId, sessions);
+                }
                 if (joined.resumeTicket !== undefined)
                     resumeTickets.set(joined.serverId, joined.resumeTicket);
                 return { ...joined, ok: true };
@@ -335,14 +346,23 @@ export function createWsBackend(options) {
             }
         },
         async leaveServer(args) {
+            const sessions = joinedSessions.get(args.serverId);
+            const partial = args.sessionId !== undefined && sessions !== undefined && sessions.size > 0 &&
+                (!sessions.has(args.sessionId) || sessions.size > 1);
+            if (partial) {
+                await request((id) => ({ v: 1, t: "leave", id, serverId: args.serverId, sessionId: args.sessionId }));
+                sessions.delete(args.sessionId);
+                return;
+            }
             poseGates.delete(args.serverId);
-            await request((id) => ({ v: 1, t: "leave", id, serverId: args.serverId }));
+            await request((id) => ({ v: 1, t: "leave", id, serverId: args.serverId, ...(args.sessionId === undefined ? {} : { sessionId: args.sessionId }) }));
+            joinedSessions.delete(args.serverId);
             joinedGames.delete(args.serverId);
             joinedRoles.delete(args.serverId);
             resumeTickets.delete(args.serverId);
         },
         async runCommand(args) {
-            const opId = String(nextOpId++);
+            const opId = `${operationSession}:${nextOpId++}`;
             try {
                 const result = await request((id) => ({
                     v: 1,

package/dist/host.d.ts

@@ -55,6 +55,8 @@ export type GameHost = {
         serverId: string;
         command: string;
         input: unknown;
+        /** Set only from host code: runs commands marked `access: "server"`, which client messages cannot. */
+        trusted?: boolean;
     }) => Promise<TransportRunCommandResult>;
     isMember: (args: {
         userId: string;

package/dist/host.js

@@ -1,9 +1,11 @@
 import { createGameRuntime } from "@jgengine/core/runtime/gameRuntime";
+import { SERVER_ONLY_COMMAND_REASON } from "@jgengine/core/runtime/commandRunner";
 import { applyLeaderboardRows, buildHydratePlayers, planServerPersist, profileLeaderboardStats, shouldAutoSave, topLeaderboardRows, toOpenServerListings, toServerListing, trimFeedEntries, } from "@jgengine/core/runtime/hostPersistence";
 import { isListablePublicly, isPrivateJoinBlocked, isServerFull, isServerMember, statusAfterLeave, withJoinedMember, withoutMember, } from "@jgengine/core/runtime/hostPolicy";
 import { browseSessions, findByJoinCode } from "@jgengine/core/multiplayer/matchmaking";
 import { createFeedWriteGate, validateFeedWrite, } from "@jgengine/core/multiplayer/feedWriteGate";
 import { clearDirtyFlags, createEmptyServerRow, splitProfilePlayer } from "@jgengine/core/runtime/snapshot";
+import { unwrapOpEnvelope } from "@jgengine/core/runtime/hostedWorldSession";
 const builtinCommands = {
     "engine.ping": {
         validate: () => null,
@@ -12,17 +14,6 @@ const builtinCommands = {
 };
 /** Max recently-applied `runCommand` op IDs retained per (serverId, userId), oldest evicted first. */
 export const OP_LEDGER_LIMIT = 64;
-const WS_OP_ID_FIELD = "__jgWsOpId";
-function unwrapOpEnvelope(input) {
-    if (typeof input !== "object" || input === null || Array.isArray(input))
-        return null;
-    const record = input;
-    const opId = record[WS_OP_ID_FIELD];
-    if (typeof opId !== "string")
-        return null;
-    const { [WS_OP_ID_FIELD]: _opId, ...rest } = record;
-    return { opId, input: rest };
-}
 function opLedgerKey(serverId, userId) {
     return `${serverId}|${userId}`;
 }
@@ -330,6 +321,9 @@ export function createGameHost(options) {
             }
             const commandInput = envelope !== null ? envelope.input : args.input;
             const runtime = resolveRuntime(entry.record.gameId);
+            if (args.trusted !== true && runtime.commandAccess(args.command) === "server") {
+                return { ok: false, reason: SERVER_ONLY_COMMAND_REASON };
+            }
             const result = runtime.runCommand(entry.snapshot, args.userId, args.command, commandInput, now());
             const outcome = result.ok
                 ? { ok: true }

package/dist/hostRouter.d.ts

@@ -49,6 +49,8 @@ export type HostRouter = {
         atMs: number;
     }) => RewoundPosition[];
     close: () => void;
+    /** Wait for accepted message handlers and subscription reads to settle. Close first to prevent new work. */
+    drain: () => Promise<void>;
 };
 export declare const DEFAULT_POSE_RULES: PoseSyncRules;
 /** Cap on frames queued behind a connection's in-flight message; beyond this a flood gets rejected instead of piling up unbounded promises. */

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();
@@ -70,6 +77,52 @@ export function createHostRouter(options) {
         clearTimeout(timer);
         pendingLeaves.delete(key);
     };
+    const heldByOtherConnection = (self, userId, serverId) => {
+        for (const other of connections) {
+            if (other !== self && other.userId === userId && other.joinedServers.has(serverId))
+                return true;
+        }
+        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);
@@ -77,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();
@@ -86,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;
@@ -98,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) => {
@@ -149,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;
@@ -237,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 ?? "";
@@ -290,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);
                 }
             }
         }
@@ -309,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);
             }
         }
     };
@@ -358,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");
@@ -372,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();
@@ -417,16 +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");
+                    }), 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),
@@ -436,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
@@ -462,12 +581,23 @@ export function createHostRouter(options) {
                     return;
                 }
                 case "leave": {
-                    await host.leaveServer({ userId, serverId: message.serverId });
-                    clearPendingLeave(userId, message.serverId);
+                    const sessions = connection.sessions.get(message.serverId);
+                    // A leave for a session that is not live (a disposed join) must not end the sessions that are.
+                    if (message.sessionId !== undefined && sessions !== undefined && sessions.size > 0) {
+                        if (!sessions.delete(message.sessionId) || sessions.size > 0) {
+                            reply(connection, message.id, null);
+                            return;
+                        }
+                    }
+                    connection.sessions.delete(message.serverId);
                     connection.joinedServers.delete(message.serverId);
                     connection.roles.delete(message.serverId);
-                    dropPresenceForServer(userId, message.serverId);
-                    dropVoiceForServer(userId, message.serverId);
+                    if (!heldByOtherConnection(connection, userId, message.serverId)) {
+                        await host.leaveServer({ userId, serverId: message.serverId });
+                        clearPendingLeave(userId, message.serverId);
+                        dropPresenceForServer(userId, message.serverId);
+                        dropVoiceForServer(userId, message.serverId);
+                    }
                     reply(connection, message.id, null);
                     return;
                 }
@@ -546,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": {
@@ -572,35 +704,39 @@ 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);
-                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(),
                 joinedServers: new Set(),
+                sessions: new Map(),
                 queue: Promise.resolve(),
                 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) {
@@ -616,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);
                     }
@@ -650,6 +789,9 @@ export function createHostRouter(options) {
             return positions;
         },
         close: () => {
+            if (closed)
+                return;
+            closed = true;
             unsubscribeHost();
             for (const timer of pendingLeaves.values())
                 clearTimeout(timer);
@@ -657,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/protocol.d.ts

@@ -5,6 +5,8 @@ import type { MatchFilter, SessionListing } from "@jgengine/core/multiplayer/mat
 export declare const WS_PROTOCOL_VERSION = 1;
 /** Max length of a `runCommand` command name, in UTF-16 code units. */
 export declare const MAX_COMMAND_LENGTH = 4096;
+/** Max length of a join/leave `sessionId`, in UTF-16 code units. */
+export declare const MAX_SESSION_ID_LENGTH = 128;
 /** Max length of a `pushFeed` action name, in UTF-16 code units. */
 export declare const MAX_FEED_ACTION_LENGTH = 256;
 /** Max serialized size of a `pushFeed` entry payload, in bytes. */
@@ -53,6 +55,8 @@ export type WsClientMessage = {
     attributes?: SessionAttributes;
     code?: string;
     role?: "player" | "spectator";
+    /** Client session holding this join; see `GameRuntimeTransport.joinServer`. */
+    sessionId?: string;
 } | {
     v: 1;
     t: "joinByCode";
@@ -72,6 +76,7 @@ export type WsClientMessage = {
     t: "leave";
     id: number;
     serverId: string;
+    sessionId?: string;
 } | {
     v: 1;
     t: "runCommand";