@jgengine/ws 0.10.0 → 0.12.0

package/dist/hostRouter.js

@@ -1,14 +1,11 @@
-import { decidePoseSync, spawnPresenceState } from "@jgengine/core/multiplayer/presenceModel";
+import { DEFAULT_POSE_SYNC_RULES, decidePoseSync, spawnPresenceState, } from "@jgengine/core/multiplayer/presenceModel";
 import { createPositionHistory } from "@jgengine/core/multiplayer/lagCompensation";
 import { createChatRateLimiter, DEFAULT_CHAT_BODY_LENGTH, DEFAULT_CHAT_HISTORY_LIMIT, DEFAULT_CHAT_RATE_LIMIT, } from "@jgengine/core/game/chat";
+import { createCommandMiddleware, } from "./commandMiddleware.js";
 import { decodeWsClientMessage, encodeWsMessage, inspectWsDecodeFailure, subscriptionKey, } from "./protocol.js";
-export const DEFAULT_POSE_RULES = {
-    maxSpeed: 12,
-    maxVerticalOffset: 3,
-    minElapsedSec: 0.05,
-    maxElapsedSec: 0.5,
-    keepAliveRefreshMs: 10_000,
-};
+export const DEFAULT_POSE_RULES = DEFAULT_POSE_SYNC_RULES;
+/** Cap on frames queued behind a connection's in-flight message; beyond this a flood gets rejected instead of piling up unbounded promises. */
+export const MAX_QUEUED_MESSAGES = 64;
 function appearanceEqual(a, b) {
     if (a === b)
         return true;
@@ -20,6 +17,29 @@ function appearanceEqual(a, b) {
         return false;
     return aKeys.every((key) => a[key] === b[key]);
 }
+function getOrCreate(map, key, factory) {
+    let value = map.get(key);
+    if (value === undefined) {
+        value = factory();
+        map.set(key, value);
+    }
+    return value;
+}
+/**
+ * Remove `userId` from every visited `server|scope` bucket, drop buckets that empty out, and notify
+ * per changed key. Backs both the disconnect-wide and per-server drops for presence and voice.
+ */
+function dropUserFrom(store, userId, shouldVisit, onChanged) {
+    for (const [key, inner] of store) {
+        if (!shouldVisit(key))
+            continue;
+        if (!inner.delete(userId))
+            continue;
+        if (inner.size === 0)
+            store.delete(key);
+        onChanged(key);
+    }
+}
 export function createHostRouter(options) {
     const host = options.host;
     const now = options.now ?? Date.now;
@@ -30,17 +50,33 @@ export function createHostRouter(options) {
         (allowAnonymous ? ({ userId }) => userId : null);
     const connections = new Set();
     const sessionsByUserId = new Map();
+    const subscribers = new Map();
+    const subscribersOf = (key) => {
+        const set = subscribers.get(key);
+        return set === undefined ? [] : [...set];
+    };
+    const addSubscription = (connection, key) => {
+        connection.subscriptions.add(key);
+        let set = subscribers.get(key);
+        if (set === undefined) {
+            set = new Set();
+            subscribers.set(key, set);
+        }
+        set.add(connection);
+    };
+    const removeSubscription = (connection, key) => {
+        connection.subscriptions.delete(key);
+        const set = subscribers.get(key);
+        if (set === undefined)
+            return;
+        set.delete(connection);
+        if (set.size === 0)
+            subscribers.delete(key);
+    };
     const presence = new Map();
     const positionHistoryMs = options.positionHistoryMs ?? 1_000;
     const histories = new Map();
-    const historyFor = (serverId) => {
-        let history = histories.get(serverId);
-        if (history === undefined) {
-            history = createPositionHistory({ historyMs: positionHistoryMs });
-            histories.set(serverId, history);
-        }
-        return history;
-    };
+    const historyFor = (serverId) => getOrCreate(histories, serverId, () => createPositionHistory({ historyMs: positionHistoryMs }));
     const send = (connection, message) => {
         connection.transport.send(encodeWsMessage(message));
     };
@@ -63,81 +99,78 @@ export function createHostRouter(options) {
             appearance: pose.appearance,
         }));
     };
-    const broadcastPresence = (serverId) => {
-        const key = subscriptionKey("presence", serverId);
-        const data = presenceRows(serverId);
-        for (const connection of connections) {
-            if (!connection.subscriptions.has(key))
-                continue;
-            send(connection, { v: 1, t: "update", channel: "presence", serverId, data });
+    const broadcast = (key, build) => {
+        const targets = subscribersOf(key);
+        if (targets.length === 0)
+            return;
+        const message = build();
+        for (const connection of targets)
+            send(connection, message);
+    };
+    const broadcastPresence = (serverId) => broadcast(subscriptionKey("presence", serverId), () => ({
+        v: 1,
+        t: "update",
+        channel: "presence",
+        serverId,
+        data: presenceRows(serverId),
+    }));
+    const commandMiddleware = createCommandMiddleware({
+        limits: options.limits,
+        authorize: options.authorize,
+        validate: options.validate,
+    });
+    const gate = async (connection, id, op, args = {}) => {
+        if (connection.userId === null)
+            return true;
+        const decision = await commandMiddleware.check({
+            connection,
+            userId: connection.userId,
+            op,
+            atMs: now(),
+            ...args,
+        });
+        if (!decision.allow) {
+            replyError(connection, id, decision.reason);
+            return false;
         }
+        return true;
     };
     const chatRings = new Map();
     const chatLimiter = createChatRateLimiter(options.chatRateLimit ?? DEFAULT_CHAT_RATE_LIMIT);
     const chatHistoryLimit = options.chatHistoryLimit ?? DEFAULT_CHAT_HISTORY_LIMIT;
     const chatMaxBodyLength = options.chatMaxBodyLength ?? DEFAULT_CHAT_BODY_LENGTH;
     let chatCounter = 0;
-    const chatRing = (serverId, channelId) => {
-        const key = `${serverId}|${channelId}`;
-        let ring = chatRings.get(key);
-        if (ring === undefined) {
-            ring = [];
-            chatRings.set(key, ring);
-        }
-        return ring;
-    };
-    const broadcastChat = (serverId, channelId) => {
-        const key = subscriptionKey("chat", serverId, channelId);
-        const data = chatRing(serverId, channelId).slice();
-        for (const connection of connections) {
-            if (!connection.subscriptions.has(key))
-                continue;
-            send(connection, { v: 1, t: "update", channel: "chat", serverId, action: channelId, data });
-        }
-    };
+    const chatRing = (serverId, channelId) => getOrCreate(chatRings, `${serverId}|${channelId}`, () => []);
+    const broadcastChat = (serverId, channelId) => broadcast(subscriptionKey("chat", serverId, channelId), () => ({
+        v: 1,
+        t: "update",
+        channel: "chat",
+        serverId,
+        action: channelId,
+        data: chatRing(serverId, channelId).slice(),
+    }));
     const voiceRosters = new Map();
-    const voiceRoster = (serverId, channelId) => {
-        const key = `${serverId}|${channelId}`;
-        let roster = voiceRosters.get(key);
-        if (roster === undefined) {
-            roster = new Map();
-            voiceRosters.set(key, roster);
-        }
-        return roster;
-    };
+    const voiceRoster = (serverId, channelId) => getOrCreate(voiceRosters, `${serverId}|${channelId}`, () => new Map());
     const voiceParticipants = (serverId, channelId) => [...voiceRoster(serverId, channelId).values()].map((participant) => ({ ...participant }));
-    const broadcastVoice = (serverId, channelId) => {
-        const key = subscriptionKey("voice", serverId, channelId);
-        const data = voiceParticipants(serverId, channelId);
-        for (const connection of connections) {
-            if (!connection.subscriptions.has(key))
-                continue;
-            send(connection, { v: 1, t: "update", channel: "voice", serverId, action: channelId, data });
-        }
-    };
+    const broadcastVoice = (serverId, channelId) => broadcast(subscriptionKey("voice", serverId, channelId), () => ({
+        v: 1,
+        t: "update",
+        channel: "voice",
+        serverId,
+        action: channelId,
+        data: voiceParticipants(serverId, channelId),
+    }));
     const dropVoice = (connection) => {
         if (connection.userId === null)
             return;
-        for (const [key, roster] of voiceRosters) {
-            if (!roster.delete(connection.userId))
-                continue;
-            if (roster.size === 0)
-                voiceRosters.delete(key);
+        dropUserFrom(voiceRosters, connection.userId, () => true, (key) => {
             const [serverId, channelId] = key.split("|");
             broadcastVoice(serverId, channelId);
-        }
+        });
     };
     const dropVoiceForServer = (userId, serverId) => {
         const prefix = `${serverId}|`;
-        for (const [key, roster] of voiceRosters) {
-            if (!key.startsWith(prefix))
-                continue;
-            if (!roster.delete(userId))
-                continue;
-            if (roster.size === 0)
-                voiceRosters.delete(key);
-            broadcastVoice(serverId, key.slice(prefix.length));
-        }
+        dropUserFrom(voiceRosters, userId, (key) => key.startsWith(prefix), (key) => broadcastVoice(serverId, key.slice(prefix.length)));
     };
     const requireMembership = async (connection, id, serverId) => {
         const userId = connection.userId;
@@ -226,24 +259,25 @@ export function createHostRouter(options) {
         }
     };
     const onHostEvent = (event) => {
-        for (const connection of connections) {
-            if (connection.userId === null)
-                continue;
-            if (event.type === "server") {
-                if (connection.subscriptions.has(subscriptionKey("server", event.serverId))) {
-                    void pushSubscription(connection, "server", event.serverId);
-                }
+        if (event.type === "server") {
+            for (const connection of subscribersOf(subscriptionKey("server", event.serverId))) {
+                if (connection.userId === null)
+                    continue;
+                void pushSubscription(connection, "server", event.serverId);
             }
-            else if (event.type === "player") {
-                if (connection.userId === event.userId &&
-                    connection.subscriptions.has(subscriptionKey("player", 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);
                 }
             }
-            else {
-                if (connection.subscriptions.has(subscriptionKey("feed", event.serverId, event.action))) {
-                    void pushSubscription(connection, "feed", event.serverId, event.action);
-                }
+        }
+        else {
+            for (const connection of subscribersOf(subscriptionKey("feed", event.serverId, event.action))) {
+                if (connection.userId === null)
+                    continue;
+                void pushSubscription(connection, "feed", event.serverId, event.action);
             }
         }
     };
@@ -251,6 +285,15 @@ export function createHostRouter(options) {
     const handlePose = async (connection, serverId, pose) => {
         if (connection.userId === null)
             return;
+        const gateDecision = await commandMiddleware.check({
+            connection,
+            userId: connection.userId,
+            op: "pose",
+            atMs: now(),
+            serverId,
+        });
+        if (!gateDecision.allow)
+            return;
         if (!(await host.isMember({ userId: connection.userId, serverId })))
             return;
         const rows = presence.get(serverId) ?? new Map();
@@ -277,21 +320,10 @@ export function createHostRouter(options) {
     const dropPresence = (connection) => {
         if (connection.userId === null)
             return;
-        for (const [serverId, rows] of presence) {
-            if (rows.delete(connection.userId)) {
-                if (rows.size === 0)
-                    presence.delete(serverId);
-                broadcastPresence(serverId);
-            }
-        }
+        dropUserFrom(presence, connection.userId, () => true, (serverId) => broadcastPresence(serverId));
     };
     const dropPresenceForServer = (userId, serverId) => {
-        const rows = presence.get(serverId);
-        if (rows === undefined || !rows.delete(userId))
-            return;
-        if (rows.size === 0)
-            presence.delete(serverId);
-        broadcastPresence(serverId);
+        dropUserFrom(presence, userId, (key) => key === serverId, () => broadcastPresence(serverId));
     };
     const handleMessage = async (connection, message) => {
         if (message.t === "hello") {
@@ -335,17 +367,22 @@ export function createHostRouter(options) {
         try {
             switch (message.t) {
                 case "join": {
+                    if (!(await gate(connection, message.id, "join", { serverId: message.serverId })))
+                        return;
                     const result = await host.joinServer({
                         userId,
                         gameId: message.gameId,
                         serverId: message.serverId,
                         attributes: message.attributes,
+                        code: message.code,
                     });
                     connection.joinedServers.add(result.serverId);
                     reply(connection, message.id, result);
                     return;
                 }
                 case "joinByCode": {
+                    if (!(await gate(connection, message.id, "join", {})))
+                        return;
                     const result = await host.joinByCode({
                         userId,
                         gameId: message.gameId,
@@ -357,6 +394,8 @@ export function createHostRouter(options) {
                     return;
                 }
                 case "browse": {
+                    if (!(await gate(connection, message.id, "browse", {})))
+                        return;
                     const result = await host.browseServers({
                         gameId: message.gameId,
                         filter: message.filter,
@@ -374,6 +413,12 @@ export function createHostRouter(options) {
                     return;
                 }
                 case "runCommand": {
+                    if (!(await gate(connection, message.id, "runCommand", {
+                        serverId: message.serverId,
+                        command: message.command,
+                        input: message.input,
+                    })))
+                        return;
                     const result = await host.runCommand({
                         userId,
                         serverId: message.serverId,
@@ -398,6 +443,8 @@ export function createHostRouter(options) {
                     return;
                 }
                 case "voiceJoin": {
+                    if (!(await gate(connection, message.id, "voice", { serverId: message.serverId })))
+                        return;
                     if ((await requireMembership(connection, message.id, message.serverId)) === null)
                         return;
                     const participant = { userId };
@@ -409,6 +456,8 @@ export function createHostRouter(options) {
                     return;
                 }
                 case "voiceLeave": {
+                    if (!(await gate(connection, message.id, "voice", { serverId: message.serverId })))
+                        return;
                     if ((await requireMembership(connection, message.id, message.serverId)) === null)
                         return;
                     const roster = voiceRoster(message.serverId, message.channelId);
@@ -419,6 +468,8 @@ export function createHostRouter(options) {
                     return;
                 }
                 case "voicePublish": {
+                    if (!(await gate(connection, message.id, "voice", { serverId: message.serverId })))
+                        return;
                     if ((await requireMembership(connection, message.id, message.serverId)) === null)
                         return;
                     const participant = voiceRoster(message.serverId, message.channelId).get(userId);
@@ -439,13 +490,13 @@ export function createHostRouter(options) {
                         replyError(connection, message.id, "Not a member of this server");
                         return;
                     }
-                    connection.subscriptions.add(subscriptionKey(message.channel, message.serverId, message.action));
+                    addSubscription(connection, subscriptionKey(message.channel, message.serverId, message.action));
                     reply(connection, message.id, null);
                     await pushSubscription(connection, message.channel, message.serverId, message.action);
                     return;
                 }
                 case "unsubscribe": {
-                    connection.subscriptions.delete(subscriptionKey(message.channel, message.serverId, message.action));
+                    removeSubscription(connection, subscriptionKey(message.channel, message.serverId, message.action));
                     reply(connection, message.id, null);
                     return;
                 }
@@ -473,30 +524,40 @@ export function createHostRouter(options) {
                 subscriptions: new Set(),
                 joinedServers: new Set(),
                 queue: Promise.resolve(),
+                queuedMessages: 0,
             };
             connections.add(connection);
             return {
                 handleRaw: (raw) => {
-                    connection.queue = connection.queue
-                        .then(async () => {
-                        const text = typeof raw === "string" ? raw : String(raw);
-                        const message = decodeWsClientMessage(text);
-                        if (message === null) {
-                            const failure = inspectWsDecodeFailure(text);
-                            if (failure.id !== undefined) {
-                                replyError(connection, failure.id, failure.reason);
-                            }
-                            return;
+                    const text = typeof raw === "string" ? raw : String(raw);
+                    const message = decodeWsClientMessage(text);
+                    if (message === null) {
+                        const failure = inspectWsDecodeFailure(text);
+                        if (failure.id !== undefined) {
+                            replyError(connection, failure.id, failure.reason);
                         }
-                        await handleMessage(connection, message);
-                    })
-                        .catch(() => undefined);
+                        return;
+                    }
+                    if (connection.queuedMessages >= MAX_QUEUED_MESSAGES) {
+                        if ("id" in message)
+                            replyError(connection, message.id, "Too many pending requests");
+                        return;
+                    }
+                    connection.queuedMessages += 1;
+                    connection.queue = connection.queue
+                        .then(() => handleMessage(connection, message))
+                        .catch(() => undefined)
+                        .finally(() => {
+                        connection.queuedMessages -= 1;
+                    });
                 },
                 close: () => {
                     if (connection.userId !== null && sessionsByUserId.get(connection.userId) === connection) {
                         sessionsByUserId.delete(connection.userId);
                     }
                     connections.delete(connection);
+                    for (const key of [...connection.subscriptions])
+                        removeSubscription(connection, key);
                     leaveJoinedServers(connection);
                     dropPresence(connection);
                     dropVoice(connection);
@@ -519,6 +580,7 @@ export function createHostRouter(options) {
         close: () => {
             unsubscribeHost();
             connections.clear();
+            subscribers.clear();
         },
     };
 }

package/dist/index.d.ts

@@ -1,3 +1,4 @@
+export * from "./commandMiddleware.js";
 export * from "./createWsBackend.js";
 export * from "./host.js";
 export * from "./hostRouter.js";

package/dist/index.js

@@ -1,3 +1,4 @@
+export * from "./commandMiddleware.js";
 export * from "./createWsBackend.js";
 export * from "./host.js";
 export * from "./hostRouter.js";

package/dist/pipe.js

@@ -1,3 +1,4 @@
+const OPEN = 1;
 export function webSocketPipe(url, webSocketFactory = (target) => new WebSocket(target)) {
     return (handlers) => {
         const socket = webSocketFactory(url);
@@ -6,7 +7,7 @@ export function webSocketPipe(url, webSocketFactory = (target) => new WebSocket(
         socket.onclose = () => handlers.onClose();
         return {
             send: (data) => {
-                if (socket.readyState !== 1)
+                if (socket.readyState !== OPEN)
                     return;
                 socket.send(data);
             },

package/dist/protocol.d.ts

@@ -3,6 +3,16 @@ import type { PlayerPose } from "@jgengine/core/multiplayer/poseSyncGate";
 import type { SessionAttributes } from "@jgengine/core/runtime/hostPersistence";
 import type { MatchFilter, SessionListing } from "@jgengine/core/multiplayer/matchmaking";
 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 `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. */
+export declare const MAX_FEED_ENTRY_BYTES = 65536;
+/** Max number of keys in a pose `appearance` tag map. */
+export declare const MAX_APPEARANCE_ENTRIES = 32;
+/** Max length of a single `appearance` tag string value, in UTF-16 code units. */
+export declare const MAX_APPEARANCE_VALUE_LENGTH = 256;
 export type WsChannel = "server" | "player" | "feed" | "presence" | "chat" | "voice";
 /** Client-set cosmetic/state tags carried alongside a pose (skin, mount, emote, ...). Primitive values only. */
 export type WsAppearance = Record<string, string | number | boolean>;
@@ -36,6 +46,7 @@ export type WsClientMessage = {
     gameId: string;
     serverId?: string;
     attributes?: SessionAttributes;
+    code?: string;
 } | {
     v: 1;
     t: "joinByCode";
@@ -172,12 +183,17 @@ export type WsJoinResult = JoinServerResult;
 export type WsRunCommandResult = TransportRunCommandResult;
 export type WsBrowseResult = SessionListing[];
 export type WsJoinByCodeResult = JoinServerResult | null;
+/** @internal */
 export declare function encodeWsMessage(message: WsClientMessage | WsServerMessage): string;
 export type WsDecodeFailure = {
     reason: string;
     id?: number;
 };
+/** @internal */
 export declare function inspectWsDecodeFailure(raw: unknown): WsDecodeFailure;
+/** @internal */
 export declare function decodeWsClientMessage(raw: unknown): WsClientMessage | null;
+/** @internal */
 export declare function decodeWsServerMessage(raw: unknown): WsServerMessage | null;
+/** @internal */
 export declare function subscriptionKey(channel: WsChannel, serverId: string, action?: string): string;

package/dist/protocol.js

@@ -1,4 +1,15 @@
 export const WS_PROTOCOL_VERSION = 1;
+/** Max length of a `runCommand` command name, in UTF-16 code units. */
+export const MAX_COMMAND_LENGTH = 4_096;
+/** Max length of a `pushFeed` action name, in UTF-16 code units. */
+export const MAX_FEED_ACTION_LENGTH = 256;
+/** Max serialized size of a `pushFeed` entry payload, in bytes. */
+export const MAX_FEED_ENTRY_BYTES = 65_536;
+/** Max number of keys in a pose `appearance` tag map. */
+export const MAX_APPEARANCE_ENTRIES = 32;
+/** Max length of a single `appearance` tag string value, in UTF-16 code units. */
+export const MAX_APPEARANCE_VALUE_LENGTH = 256;
+/** @internal */
 export function encodeWsMessage(message) {
     return JSON.stringify(message);
 }
@@ -32,8 +43,17 @@ function isWsChannel(value) {
         value === "voice");
 }
 function isAppearance(value) {
-    return (isRecord(value) &&
-        Object.values(value).every((v) => typeof v === "string" || typeof v === "number" || typeof v === "boolean"));
+    if (!isRecord(value))
+        return false;
+    const entries = Object.values(value);
+    if (entries.length > MAX_APPEARANCE_ENTRIES)
+        return false;
+    return entries.every((v) => (typeof v === "string" && v.length <= MAX_APPEARANCE_VALUE_LENGTH) ||
+        typeof v === "number" ||
+        typeof v === "boolean");
+}
+function withinFeedEntryBudget(entry) {
+    return new TextEncoder().encode(JSON.stringify(entry)).length <= MAX_FEED_ENTRY_BYTES;
 }
 function isFiniteNumber(value) {
     return typeof value === "number" && Number.isFinite(value);
@@ -47,6 +67,7 @@ function isPose(value) {
         isFiniteNumber(value.rotationPitch) &&
         (value.appearance === undefined || isAppearance(value.appearance)));
 }
+/** @internal */
 export function inspectWsDecodeFailure(raw) {
     if (typeof raw !== "string")
         return { reason: "Invalid message framing" };
@@ -66,8 +87,27 @@ export function inspectWsDecodeFailure(raw) {
     if (typeof parsed.t !== "string") {
         return { reason: "Invalid message type", id };
     }
+    if (parsed.t === "runCommand" && typeof parsed.command === "string" && parsed.command.length > MAX_COMMAND_LENGTH) {
+        return { reason: "Command exceeds max length", id };
+    }
+    if (parsed.t === "pushFeed" && typeof parsed.action === "string" && parsed.action.length > MAX_FEED_ACTION_LENGTH) {
+        return { reason: "Feed action exceeds max length", id };
+    }
+    if (parsed.t === "pushFeed" && "entry" in parsed && !withinFeedEntryBudget(parsed.entry)) {
+        return { reason: "Feed entry exceeds max size", id };
+    }
+    if (parsed.t === "pose" && isRecord(parsed.pose) && isRecord(parsed.pose.appearance)) {
+        const values = Object.values(parsed.pose.appearance);
+        if (values.length > MAX_APPEARANCE_ENTRIES) {
+            return { reason: "Appearance exceeds max entries", id };
+        }
+        if (values.some((v) => typeof v === "string" && v.length > MAX_APPEARANCE_VALUE_LENGTH)) {
+            return { reason: "Appearance value exceeds max length", id };
+        }
+    }
     return { reason: "Malformed message", id };
 }
+/** @internal */
 export function decodeWsClientMessage(raw) {
     const message = parseVersioned(raw);
     if (message === null)
@@ -82,7 +122,8 @@ export function decodeWsClientMessage(raw) {
         case "join":
             return typeof message.id === "number" &&
                 typeof message.gameId === "string" &&
-                (message.serverId === undefined || typeof message.serverId === "string")
+                (message.serverId === undefined || typeof message.serverId === "string") &&
+                (message.code === undefined || typeof message.code === "string")
                 ? message
                 : null;
         case "joinByCode":
@@ -102,13 +143,16 @@ export function decodeWsClientMessage(raw) {
         case "runCommand":
             return typeof message.id === "number" &&
                 typeof message.serverId === "string" &&
-                typeof message.command === "string"
+                typeof message.command === "string" &&
+                message.command.length <= MAX_COMMAND_LENGTH
                 ? message
                 : null;
         case "pushFeed":
             return typeof message.id === "number" &&
                 typeof message.serverId === "string" &&
-                typeof message.action === "string"
+                typeof message.action === "string" &&
+                message.action.length <= MAX_FEED_ACTION_LENGTH &&
+                withinFeedEntryBudget(message.entry)
                 ? message
                 : null;
         case "subscribe":
@@ -154,6 +198,7 @@ export function decodeWsClientMessage(raw) {
             return null;
     }
 }
+/** @internal */
 export function decodeWsServerMessage(raw) {
     const message = parseVersioned(raw);
     if (message === null)
@@ -176,6 +221,7 @@ export function decodeWsServerMessage(raw) {
             return null;
     }
 }
+/** @internal */
 export function subscriptionKey(channel, serverId, action) {
     return `${channel}|${serverId}|${action ?? ""}`;
 }

package/dist/readsHandler.js

@@ -41,7 +41,8 @@ export function createReadsHandler(options) {
                 return json(await options.listOpenServers({ gameId, limit }));
             }
             const records = await (await getPersistence()).listServers(gameId);
-            return json(toOpenServerListings(records.map((record) => toServerListing(record)), limit));
+            const publicRecords = records.filter((record) => (record.visibility ?? "public") !== "private");
+            return json(toOpenServerListings(publicRecords.map((record) => toServerListing(record)), limit));
         }
         if (head === "leaderboard" && tail !== undefined && segments.length === 2) {
             const scope = url.searchParams.get("scope") ?? "global";

package/dist/worldHost.js

@@ -72,7 +72,7 @@ export function createWorldGameHost(options) {
         async isMember({ userId, serverId }) {
             return live.get(serverId)?.session.members().includes(userId) ?? false;
         },
-        async getServerView({ serverId }) {
+        async getServerView({ userId, serverId }) {
             const entry = live.get(serverId);
             if (entry === undefined)
                 return null;
@@ -81,7 +81,7 @@ export function createWorldGameHost(options) {
                 gameId: entry.gameId,
                 revision: entry.session.revision(),
                 memberUserIds: [...entry.session.members()],
-                serverState: entry.session.runner().snapshot(),
+                serverState: entry.session.snapshotFor({ userId }),
                 updatedAt: now(),
             };
         },