@jgengine/ws 0.8.0 → 0.9.0

package/CHANGELOG.md

@@ -11,6 +11,22 @@ Agents building on the published SDK can also read this programmatically:
 same data as typed values, so an updater can diff its installed version against
 the latest and surface the migration steps.
 
+## Unreleased
+
+## 0.9.0
+
+### Added
+
+- Mobile HUD fit — design-resolution UI scaling now applies to every game by default: `HudCanvas` measures the live viewport and scales the whole HUD from `PlayableGame.hudFit.designSize` (default 1600×900, clamps `minScale`/`maxScale` 0.4–1) so desktop-authored layouts shrink to fit a phone instead of overflowing it; `hudFit.mobile` overrides tune the phone fit separately. Pure math lives in `@jgengine/core/ui/hudScale` (`hudScaleForViewport`, `resolveHudFit`, `rectOverflow`, `overflowingPanels`); the shell mounts `@jgengine/react`'s `HudViewportProvider` around `GameUI` so games need no wiring.
+- Graphics → UI scale — a player-facing `graphics.uiScale` slider (0.5–1.5, default 1) multiplies the computed HUD scale on every platform; the same resolution system drives desktop preference and mobile shrink.
+- HUD overflow gate — `HudCanvas` measures every `HudPanel` against the viewport at runtime and reports offenders on a `data-hud-overflow` attribute (plus a console warning); `bun run shoot <game> --device mobile|both` now exits non-zero naming the panels that escape the viewport.
+- Automatic visibility & streaming defaults — an engine-level `VisibilitySystem` (exported from `@jgengine/core`) gives every scene renderer-agnostic culling and asset-streaming policy with no per-object wiring: distance culling, preload margins, hysteresis, delayed unloading, multi-camera awareness (including cameras excluded from streaming), and per-object overrides (always-visible, never-unload, disabled culling/streaming, custom render distance and preload margin).
+- Self-hosted asset mirror — `DEFAULT_RELEASE_BASE` now points at this repo's rolling `packs` release instead of the upstream host; a catalog-driven `mirror-assets` workflow (weekly cron + manual dispatch) keeps the mirror in sync with the asset catalog.
+
+### Changed
+
+- Mobile HUD fit is on by default — design-resolution HUD scaling now applies to every game with no config change (previously opt-in via `platforms: ["web", "mobile"]`). A desktop-only game keeps the legacy fixed 0.85 compact zoom by declaring `platforms: ["web"]` (without `"mobile"`).
+
 ## 0.8.0
 
 Transport-agnostic multiplayer (socket.io, WebRTC p2p, LAN/Fly adapters) plus grid/voxel

package/dist/createWsBackend.d.ts

@@ -13,8 +13,12 @@ export type WsBackendOptions = {
     token?: string;
     webSocketFactory?: (url: string) => WebSocket;
     reconnectDelayMs?: number;
+    maxReconnectDelayMs?: number;
+    rpcTimeoutMs?: number;
     poseTuning?: PoseSyncTuning;
     now?: () => number;
+    setTimeoutFn?: typeof setTimeout;
+    clearTimeoutFn?: typeof clearTimeout;
 };
 export type WsPresenceSync = {
     subscribe: (serverId: string, onChange: (rows: WsPresenceRow[]) => void) => () => void;

package/dist/createWsBackend.js

@@ -1,5 +1,5 @@
 import { createPoseSyncGate } from "@jgengine/core/multiplayer/poseSyncGate";
-import { decodeWsServerMessage, encodeWsMessage, subscriptionKey, } from "./protocol.js";
+import { decodeWsServerMessage, encodeWsMessage, inspectWsDecodeFailure, subscriptionKey, } from "./protocol.js";
 import { webSocketPipe } from "./pipe.js";
 const DEFAULT_POSE_TUNING = {
     minIntervalMs: 100,
@@ -8,9 +8,16 @@ const DEFAULT_POSE_TUNING = {
     verticalEpsilon: 0.01,
     rotationEpsilon: 0.01,
 };
+const DEFAULT_RPC_TIMEOUT_MS = 15_000;
+const DEFAULT_RECONNECT_DELAY_MS = 1_000;
+const DEFAULT_MAX_RECONNECT_DELAY_MS = 30_000;
 export function createWsBackend(options) {
     const now = options.now ?? Date.now;
-    const reconnectDelayMs = options.reconnectDelayMs ?? 1_000;
+    const baseReconnectDelayMs = options.reconnectDelayMs ?? DEFAULT_RECONNECT_DELAY_MS;
+    const maxReconnectDelayMs = options.maxReconnectDelayMs ?? DEFAULT_MAX_RECONNECT_DELAY_MS;
+    const rpcTimeoutMs = options.rpcTimeoutMs ?? DEFAULT_RPC_TIMEOUT_MS;
+    const schedule = options.setTimeoutFn ?? setTimeout;
+    const cancel = options.clearTimeoutFn ?? clearTimeout;
     const pipeFactory = options.pipe ??
         (() => {
             const url = options.url;
@@ -22,29 +29,89 @@ export function createWsBackend(options) {
     let open = false;
     let ready = null;
     let closed = false;
+    let wantConnection = false;
     let nextId = 1;
+    let reconnectAttempt = 0;
+    let reconnectTimer = null;
     const pending = new Map();
     const subscriptions = new Map();
+    const clearRequestTimer = (request) => {
+        if (request.timer !== null) {
+            cancel(request.timer);
+            request.timer = null;
+        }
+    };
     const failPending = (reason) => {
         for (const request of pending.values()) {
+            clearRequestTimer(request);
             request.reject(new Error(reason));
         }
         pending.clear();
     };
+    const armRpcTimeout = (request) => {
+        if (rpcTimeoutMs <= 0 || request.kind === "hello")
+            return;
+        request.timer = schedule(() => {
+            const current = pending.get(request.id);
+            if (current !== request)
+                return;
+            pending.delete(request.id);
+            request.timer = null;
+            request.reject(new Error("RPC timeout"));
+        }, rpcTimeoutMs);
+    };
     const rawSend = (message) => {
         if (pipe === null || !open)
             return;
         pipe.send(encodeWsMessage(message));
     };
+    const resendPendingRpcs = () => {
+        const entries = [...pending.entries()];
+        pending.clear();
+        for (const [, request] of entries) {
+            if (request.kind === "hello") {
+                clearRequestTimer(request);
+                request.reject(new Error("Connection reset"));
+                continue;
+            }
+            request.id = nextId++;
+            request.sent = true;
+            pending.set(request.id, request);
+            rawSend(request.build(request.id));
+        }
+    };
+    const resubscribeAll = () => {
+        for (const subscription of subscriptions.values()) {
+            rawSend({
+                v: 1,
+                t: "subscribe",
+                id: nextId++,
+                channel: subscription.channel,
+                serverId: subscription.serverId,
+                action: subscription.action,
+            });
+        }
+    };
     const handleMessage = (raw) => {
         const message = decodeWsServerMessage(raw);
-        if (message === null)
+        if (message === null) {
+            const failure = inspectWsDecodeFailure(raw);
+            if (failure.id !== undefined) {
+                const request = pending.get(failure.id);
+                if (request !== undefined) {
+                    pending.delete(failure.id);
+                    clearRequestTimer(request);
+                    request.reject(new Error(failure.reason));
+                }
+            }
             return;
+        }
         if (message.t === "reply") {
             const request = pending.get(message.id);
             if (request === undefined)
                 return;
             pending.delete(message.id);
+            clearRequestTimer(request);
             if (message.ok) {
                 request.resolve(message.result);
             }
@@ -65,58 +132,129 @@ export function createWsBackend(options) {
         for (const callback of subscription.callbacks)
             callback(data);
     };
+    const clearReconnectTimer = () => {
+        if (reconnectTimer !== null) {
+            cancel(reconnectTimer);
+            reconnectTimer = null;
+        }
+    };
+    const scheduleReconnect = () => {
+        if (closed || !wantConnection || reconnectTimer !== null)
+            return;
+        const delay = Math.min(maxReconnectDelayMs, baseReconnectDelayMs * 2 ** reconnectAttempt);
+        reconnectAttempt += 1;
+        reconnectTimer = schedule(() => {
+            reconnectTimer = null;
+            if (closed || !wantConnection)
+                return;
+            void connect().catch(() => undefined);
+        }, delay);
+    };
     const connect = () => {
         if (closed)
             return Promise.reject(new Error("Backend closed"));
+        wantConnection = true;
         if (ready !== null)
             return ready;
+        clearReconnectTimer();
         ready = new Promise((resolve, reject) => {
+            let settled = false;
+            const settleReject = (error) => {
+                if (settled)
+                    return;
+                settled = true;
+                reject(error);
+            };
+            const settleResolve = () => {
+                if (settled)
+                    return;
+                settled = true;
+                resolve();
+            };
             pipe = pipeFactory({
                 onOpen: () => {
                     open = true;
                     const id = nextId++;
+                    const helloBuild = (requestId) => ({
+                        v: 1,
+                        t: "hello",
+                        id: requestId,
+                        userId: options.userId,
+                        token: options.token,
+                    });
                     pending.set(id, {
+                        id,
                         resolve: () => {
-                            for (const subscription of subscriptions.values()) {
-                                rawSend({
-                                    v: 1,
-                                    t: "subscribe",
-                                    id: nextId++,
-                                    channel: subscription.channel,
-                                    serverId: subscription.serverId,
-                                    action: subscription.action,
-                                });
-                            }
-                            resolve();
+                            reconnectAttempt = 0;
+                            resubscribeAll();
+                            resendPendingRpcs();
+                            settleResolve();
                         },
-                        reject,
+                        reject: (error) => {
+                            settleReject(error);
+                        },
+                        build: helloBuild,
+                        timer: null,
+                        kind: "hello",
+                        sent: true,
                     });
-                    rawSend({ v: 1, t: "hello", id, userId: options.userId, token: options.token });
+                    rawSend(helloBuild(id));
                 },
                 onMessage: handleMessage,
                 onClose: () => {
                     open = false;
-                    failPending("Connection closed");
                     pipe = null;
                     ready = null;
-                    reject(new Error("Connection closed"));
-                    if (!closed && subscriptions.size > 0) {
-                        setTimeout(() => {
-                            if (!closed)
-                                void connect().catch(() => undefined);
-                        }, reconnectDelayMs);
+                    for (const [id, request] of [...pending.entries()]) {
+                        if (request.kind === "hello") {
+                            pending.delete(id);
+                            clearRequestTimer(request);
+                            request.reject(new Error("Connection closed"));
+                        }
+                        else {
+                            request.sent = false;
+                        }
+                    }
+                    settleReject(new Error("Connection closed"));
+                    if (!closed && wantConnection) {
+                        scheduleReconnect();
                     }
                 },
             });
         });
         return ready;
     };
-    const request = async (build) => {
-        await connect();
+    const request = (build) => {
+        if (closed)
+            return Promise.reject(new Error("Backend closed"));
+        wantConnection = true;
         const id = nextId++;
         return new Promise((resolve, reject) => {
-            pending.set(id, { resolve, reject });
-            rawSend(build(id));
+            const entry = {
+                id,
+                resolve,
+                reject,
+                build,
+                timer: null,
+                kind: "rpc",
+                sent: false,
+            };
+            pending.set(id, entry);
+            armRpcTimeout(entry);
+            void connect()
+                .then(() => {
+                if (pending.get(entry.id) !== entry || entry.sent || !open)
+                    return;
+                entry.sent = true;
+                rawSend(build(entry.id));
+            })
+                .catch((error) => {
+                if (pending.get(entry.id) !== entry)
+                    return;
+                pending.delete(entry.id);
+                clearRequestTimer(entry);
+                reject(error instanceof Error ? error : new Error(String(error)));
+            });
         });
     };
     const transport = {
@@ -290,6 +428,8 @@ export function createWsBackend(options) {
         },
         close: () => {
             closed = true;
+            wantConnection = false;
+            clearReconnectTimer();
             failPending("Backend closed");
             pipe?.close();
             pipe = null;

package/dist/host.d.ts

@@ -21,6 +21,7 @@ export type GameHostOptions = {
     slotsPerServer?: number;
     now?: () => number;
     createServerId?: () => string;
+    allowedFeedActions?: readonly string[];
 };
 export type GameHost = {
     joinServer: (args: {
@@ -49,6 +50,10 @@ export type GameHost = {
         command: string;
         input: unknown;
     }) => Promise<TransportRunCommandResult>;
+    isMember: (args: {
+        userId: string;
+        serverId: string;
+    }) => Promise<boolean>;
     getServerView: (args: {
         userId: string;
         serverId: string;

package/dist/host.js

@@ -1,6 +1,7 @@
 import { createGameRuntime } from "@jgengine/core/runtime/gameRuntime";
 import { applyLeaderboardRows, buildHydratePlayers, planServerPersist, profileLeaderboardStats, shouldAutoSave, topLeaderboardRows, toOpenServerListings, toServerListing, trimFeedEntries, } from "@jgengine/core/runtime/hostPersistence";
 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";
 const builtinCommands = {
     "engine.ping": {
@@ -14,6 +15,7 @@ export function createGameHost(options) {
     const defaultSlots = options.slotsPerServer ?? 16;
     const createServerId = options.createServerId ?? (() => `srv-${crypto.randomUUID()}`);
     const persistence = options.persistence;
+    const feedWriteGate = createFeedWriteGate(options.allowedFeedActions ?? []);
     const runtimes = new Map();
     for (const runtime of options.runtimes ?? []) {
         runtimes.set(runtime.gameId, runtime);
@@ -55,6 +57,7 @@ export function createGameHost(options) {
             serverRow: record.serverState,
             playersByUserId: buildHydratePlayers(record, profiles),
             chunksByKey,
+            revision: record.revision,
         });
         const existing = live.get(record.serverId);
         if (existing)
@@ -89,6 +92,9 @@ export function createGameHost(options) {
             if (cleared.chunks.length > 0) {
                 await persistence.saveChunks(entry.record.serverId, cleared.chunks);
             }
+            if (cleared.deletedChunks.length > 0) {
+                await persistence.deleteChunks(entry.record.serverId, cleared.deletedChunks);
+            }
             await persistence.saveServer(cleared.server);
         }
         entry.record = cleared.server;
@@ -132,7 +138,7 @@ export function createGameHost(options) {
         }
         return { ticked, saved };
     });
-    const collectListings = async (gameId) => {
+    const collectListings = async (gameId, options = {}) => {
         const byId = new Map();
         for (const record of await persistence.listServers(gameId)) {
             byId.set(record.serverId, record);
@@ -151,7 +157,9 @@ export function createGameHost(options) {
             slotsPerServer: record.slotsPerServer,
             label: record.label,
             mode: record.mode,
-            joinCode: record.joinCode,
+            ...(options.includeJoinCode === true && record.joinCode !== undefined
+                ? { joinCode: record.joinCode }
+                : {}),
             tags: record.tags,
             updatedAt: record.updatedAt,
         }));
@@ -161,6 +169,9 @@ export function createGameHost(options) {
             const timestamp = now();
             const runtime = resolveRuntime(args.gameId);
             let entry = args.serverId === undefined ? null : await getLive(args.serverId);
+            if (args.serverId !== undefined && entry === null) {
+                throw new Error("Server not found");
+            }
             if (entry !== null && entry.record.gameId !== args.gameId) {
                 throw new Error("Server belongs to a different game");
             }
@@ -211,7 +222,7 @@ export function createGameHost(options) {
         }),
         browseServers: async (args) => browseSessions(await collectListings(args.gameId), args.filter ?? {}, { limit: args.limit }),
         joinByCode: async (args) => {
-            const match = findByJoinCode(await collectListings(args.gameId), args.code);
+            const match = findByJoinCode(await collectListings(args.gameId, { includeJoinCode: true }), args.code);
             if (match === null)
                 return null;
             return host.joinServer({ userId: args.userId, gameId: args.gameId, serverId: match.serverId });
@@ -262,6 +273,12 @@ export function createGameHost(options) {
             emit({ type: "player", serverId: args.serverId, userId: args.userId });
             return { ok: true };
         }),
+        isMember: async (args) => {
+            const entry = await getLive(args.serverId);
+            if (entry === null)
+                return false;
+            return entry.record.memberUserIds.includes(args.userId);
+        },
         getServerView: async (args) => {
             const entry = await getLive(args.serverId);
             if (entry === null)
@@ -311,6 +328,10 @@ export function createGameHost(options) {
             return persistence.loadFeed({ serverId: args.serverId, action: args.action });
         },
         pushFeedEntry: (args) => enqueue(async () => {
+            const allowed = validateFeedWrite(feedWriteGate, args.action);
+            if (!allowed.ok) {
+                throw new Error(allowed.reason);
+            }
             const entry = await getLive(args.serverId);
             if (entry === null || !entry.record.memberUserIds.includes(args.userId)) {
                 throw new Error("Not a member of this server");
@@ -403,6 +424,14 @@ export function memoryPersistence(now = Date.now) {
             }
             chunks.set(serverId, byKey);
         },
+        async deleteChunks(serverId, chunkKeys) {
+            const byKey = chunks.get(serverId);
+            if (byKey === undefined)
+                return;
+            for (const chunkKey of chunkKeys) {
+                byKey.delete(chunkKey);
+            }
+        },
         async loadFeed({ serverId, action }) {
             return clone(feeds.get(`${serverId}|${action}`) ?? []);
         },

package/dist/hostRouter.d.ts

@@ -2,12 +2,15 @@ import type { PoseSyncRules } from "@jgengine/core/multiplayer/presenceModel";
 import { type ChatRateLimit } from "@jgengine/core/game/chat";
 import type { GameHost } from "./host.js";
 import type { TransportPipeFactory } from "./pipe.js";
+export type HostRouterAuthenticate = (args: {
+    userId: string;
+    token?: string;
+}) => Promise<string | null> | string | null;
 export type HostRouterOptions = {
     host: GameHost;
-    authenticate?: (args: {
-        userId: string;
-        token?: string;
-    }) => Promise<string | null> | string | null;
+    authenticate?: HostRouterAuthenticate;
+    allowAnonymous?: boolean;
+    singleSession?: boolean;
     poseRules?: PoseSyncRules;
     positionHistoryMs?: number;
     chatRateLimit?: ChatRateLimit;