@jgengine/convex 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/createConvexGameTransport.d.ts

@@ -14,9 +14,9 @@ export type ConvexGameApi = {
         joinServer: FunctionReference<"mutation", "public", {
             gameId: string;
             serverId?: string;
-            slotsPerServer?: number;
-            save?: unknown;
             mode?: string;
+            visibility?: "public" | "private";
+            joinCode?: string;
             externalId?: string;
         }, {
             serverId: string;
@@ -60,6 +60,7 @@ export type ConvexGameApi = {
     presence: {
         list: FunctionReference<"query", "public", {
             serverId: string;
+            externalId?: string;
         }, PresencePoseRow[]>;
         sync: FunctionReference<"mutation", "public", {
             serverId: string;

package/dist/createConvexGameTransport.js

@@ -73,7 +73,7 @@ export function createConvexPresenceSync(client, api, config, tuning) {
     const gate = createPoseSyncGate(tuning ?? DEFAULT_CONVEX_POSE_TUNING);
     return {
         subscribe(serverId, onChange) {
-            return watchConvexQuery(client, api.presence.list, { serverId }, (rows) => rows, onChange);
+            return watchConvexQuery(client, api.presence.list, { serverId, externalId: config.userId }, (rows) => rows, onChange);
         },
         syncPose(serverId, pose) {
             if (!gate.evaluate(pose, Date.now()))

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+export * from "./convexChatTransport.js";
+export * from "./convexPresenceTransport.js";
+export * from "./createConvexBackend.js";
+export * from "./createConvexGameTransport.js";
+export * from "./occ.js";
+export * from "./resolveConvexMultiplayer.js";
+export * from "./server.js";

package/dist/index.js

@@ -0,0 +1,7 @@
+export * from "./convexChatTransport.js";
+export * from "./convexPresenceTransport.js";
+export * from "./createConvexBackend.js";
+export * from "./createConvexGameTransport.js";
+export * from "./occ.js";
+export * from "./resolveConvexMultiplayer.js";
+export * from "./server.js";

package/dist/occ.d.ts

@@ -0,0 +1,24 @@
+import type { GameRuntime } from "@jgengine/core/runtime/gameRuntime";
+import type { GameRuntimeSnapshot } from "@jgengine/core/runtime/snapshot";
+export declare const REVISION_CONFLICT_REASON = "Revision conflict";
+export declare function commitIfRevisionMatch(loadedRevision: number, currentRevision: number): {
+    ok: true;
+} | {
+    ok: false;
+    reason: string;
+};
+export declare function applyCommandWithOcc(args: {
+    loadedRevision: number;
+    currentRevision: number;
+    snapshot: GameRuntimeSnapshot;
+    runtime: GameRuntime;
+    actorUserId: string;
+    command: string;
+    input: unknown;
+}): {
+    ok: true;
+    snapshot: GameRuntimeSnapshot;
+} | {
+    ok: false;
+    reason: string;
+};

package/dist/occ.js

@@ -0,0 +1,16 @@
+export const REVISION_CONFLICT_REASON = "Revision conflict";
+export function commitIfRevisionMatch(loadedRevision, currentRevision) {
+    if (currentRevision !== loadedRevision) {
+        return { ok: false, reason: REVISION_CONFLICT_REASON };
+    }
+    return { ok: true };
+}
+export function applyCommandWithOcc(args) {
+    const gate = commitIfRevisionMatch(args.loadedRevision, args.currentRevision);
+    if (!gate.ok)
+        return gate;
+    if (args.snapshot.revision !== args.loadedRevision) {
+        return { ok: false, reason: REVISION_CONFLICT_REASON };
+    }
+    return args.runtime.runCommand(args.snapshot, args.actorUserId, args.command, args.input);
+}

package/dist/server.d.ts

@@ -2,6 +2,7 @@ import type { DataModelFromSchemaDefinition, GenericMutationCtx } from "convex/s
 import type { GenericId } from "convex/values";
 import type { ChatMessage } from "@jgengine/core/game/chat";
 import type { ChatSendOutcome } from "@jgengine/core/multiplayer/chatContract";
+import { type PoseSyncRules } from "@jgengine/core/multiplayer/presenceModel";
 import type { GameRuntime } from "@jgengine/core/runtime/gameRuntime";
 import type { LeaderboardIncrement } from "@jgengine/core/runtime/hostPersistence";
 export declare function jgengineTables(): {
@@ -9,6 +10,7 @@ export declare function jgengineTables(): {
         createdAt: number;
         dirtyAt?: number | undefined;
         gameId: string;
+        joinCode?: string | undefined;
         lastSavedAt?: number | undefined;
         memberUserIds: string[];
         mode?: string | undefined;
@@ -24,11 +26,14 @@ export declare function jgengineTables(): {
         status: "closed" | "open" | "running";
         tickAnchorMs: number;
         updatedAt: number;
+        visibility?: "private" | "public" | undefined;
     }, {
         gameId: import("convex/values").VString<string, "required">;
         status: import("convex/values").VUnion<"closed" | "open" | "running", [import("convex/values").VLiteral<"open", "required">, import("convex/values").VLiteral<"running", "required">, import("convex/values").VLiteral<"closed", "required">], "required", never>;
         mode: import("convex/values").VString<string | undefined, "optional">;
         modeConfig: import("convex/values").VAny<any, "optional", string>;
+        visibility: import("convex/values").VUnion<"private" | "public" | undefined, [import("convex/values").VLiteral<"public", "required">, import("convex/values").VLiteral<"private", "required">], "optional", never>;
+        joinCode: import("convex/values").VString<string | undefined, "optional">;
         memberUserIds: import("convex/values").VArray<string[], import("convex/values").VString<string, "required">, "required">;
         slotsPerServer: import("convex/values").VFloat64<number, "required">;
         save: import("convex/values").VUnion<"none" | {
@@ -49,7 +54,7 @@ export declare function jgengineTables(): {
         dirtyAt: import("convex/values").VFloat64<number | undefined, "optional">;
         createdAt: import("convex/values").VFloat64<number, "required">;
         updatedAt: import("convex/values").VFloat64<number, "required">;
-    }, "required", "createdAt" | "dirtyAt" | "gameId" | "lastSavedAt" | "memberUserIds" | "mode" | "modeConfig" | "revision" | "save" | "save.auto" | "save.scope" | "serverState" | "sessionPlayers" | "slotsPerServer" | "status" | "tickAnchorMs" | "updatedAt" | `modeConfig.${string}` | `serverState.${string}` | `sessionPlayers.${string}`>, {
+    }, "required", "createdAt" | "dirtyAt" | "gameId" | "joinCode" | "lastSavedAt" | "memberUserIds" | "mode" | "modeConfig" | "revision" | "save" | "save.auto" | "save.scope" | "serverState" | "sessionPlayers" | "slotsPerServer" | "status" | "tickAnchorMs" | "updatedAt" | "visibility" | `modeConfig.${string}` | `serverState.${string}` | `sessionPlayers.${string}`>, {
         by_game_and_status: ["gameId", "status", "_creationTime"];
     }, {}, {}>;
     jgPlayerProfiles: import("convex/server").TableDefinition<import("convex/values").VObject<{
@@ -163,6 +168,7 @@ declare const schemaForTypes: import("convex/server").SchemaDefinition<{
         createdAt: number;
         dirtyAt?: number | undefined;
         gameId: string;
+        joinCode?: string | undefined;
         lastSavedAt?: number | undefined;
         memberUserIds: string[];
         mode?: string | undefined;
@@ -178,11 +184,14 @@ declare const schemaForTypes: import("convex/server").SchemaDefinition<{
         status: "closed" | "open" | "running";
         tickAnchorMs: number;
         updatedAt: number;
+        visibility?: "private" | "public" | undefined;
     }, {
         gameId: import("convex/values").VString<string, "required">;
         status: import("convex/values").VUnion<"closed" | "open" | "running", [import("convex/values").VLiteral<"open", "required">, import("convex/values").VLiteral<"running", "required">, import("convex/values").VLiteral<"closed", "required">], "required", never>;
         mode: import("convex/values").VString<string | undefined, "optional">;
         modeConfig: import("convex/values").VAny<any, "optional", string>;
+        visibility: import("convex/values").VUnion<"private" | "public" | undefined, [import("convex/values").VLiteral<"public", "required">, import("convex/values").VLiteral<"private", "required">], "optional", never>;
+        joinCode: import("convex/values").VString<string | undefined, "optional">;
         memberUserIds: import("convex/values").VArray<string[], import("convex/values").VString<string, "required">, "required">;
         slotsPerServer: import("convex/values").VFloat64<number, "required">;
         save: import("convex/values").VUnion<"none" | {
@@ -203,7 +212,7 @@ declare const schemaForTypes: import("convex/server").SchemaDefinition<{
         dirtyAt: import("convex/values").VFloat64<number | undefined, "optional">;
         createdAt: import("convex/values").VFloat64<number, "required">;
         updatedAt: import("convex/values").VFloat64<number, "required">;
-    }, "required", "createdAt" | "dirtyAt" | "gameId" | "lastSavedAt" | "memberUserIds" | "mode" | "modeConfig" | "revision" | "save" | "save.auto" | "save.scope" | "serverState" | "sessionPlayers" | "slotsPerServer" | "status" | "tickAnchorMs" | "updatedAt" | `modeConfig.${string}` | `serverState.${string}` | `sessionPlayers.${string}`>, {
+    }, "required", "createdAt" | "dirtyAt" | "gameId" | "joinCode" | "lastSavedAt" | "memberUserIds" | "mode" | "modeConfig" | "revision" | "save" | "save.auto" | "save.scope" | "serverState" | "sessionPlayers" | "slotsPerServer" | "status" | "tickAnchorMs" | "updatedAt" | "visibility" | `modeConfig.${string}` | `serverState.${string}` | `sessionPlayers.${string}`>, {
         by_game_and_status: ["gameId", "status", "_creationTime"];
     }, {}, {}>;
     jgPlayerProfiles: import("convex/server").TableDefinition<import("convex/values").VObject<{
@@ -315,23 +324,23 @@ declare const schemaForTypes: import("convex/server").SchemaDefinition<{
 type JGDataModel = DataModelFromSchemaDefinition<typeof schemaForTypes>;
 type JGMutationCtx = GenericMutationCtx<JGDataModel>;
 export type JgAuthMode = "anonymous" | "required";
+export declare const DEFAULT_CONVEX_POSE_RULES: PoseSyncRules;
 export declare function applyLeaderboardIncrements(ctx: JGMutationCtx, gameId: string, entries: LeaderboardIncrement[]): Promise<void>;
 export declare const JG_RUNTIME_TICK_MS = 1000;
 export declare function createGameServerFunctions(options?: {
     runtimes?: GameRuntime[];
     auth?: JgAuthMode;
+    slotsPerServer?: number;
+    allowedFeedActions?: readonly string[];
 }): {
     joinServer: import("convex/server").RegisteredMutation<"public", {
         externalId?: string | undefined;
         gameId: string;
+        joinCode?: string | undefined;
         mode?: string | undefined;
         modeConfig?: any;
-        save?: "none" | {
-            auto: string;
-            scope: "chunks" | "player" | "player+chunks";
-        } | undefined;
         serverId?: GenericId<"jgGameServers"> | undefined;
-        slotsPerServer?: number | undefined;
+        visibility?: "private" | "public" | undefined;
     }, Promise<{
         serverId: GenericId<"jgGameServers">;
         isNew: boolean;
@@ -371,7 +380,9 @@ export declare function createGameServerFunctions(options?: {
         };
         revision: number;
         serverState: any;
-        sessionPlayers: any;
+        sessionPlayers: {
+            [x: string]: {} | null;
+        };
         updatedAt: number;
     } | null>>;
     getPlayerProfile: import("convex/server").RegisteredQuery<"public", {
@@ -448,6 +459,7 @@ export declare function createLeaderboardFunctions(options?: {
 export declare function createPresenceFunctions(options?: {
     auth?: JgAuthMode;
     freshWindowMs?: number;
+    poseRules?: PoseSyncRules;
 }): {
     list: import("convex/server").RegisteredQuery<"public", {
         externalId?: string | undefined;

package/dist/server.js

@@ -1,8 +1,11 @@
 import { defineSchema, defineTable, internalMutationGeneric, mutationGeneric, queryGeneric, } from "convex/server";
 import { ConvexError, v } from "convex/values";
+import { createFeedWriteGate, validateFeedWrite, } from "@jgengine/core/multiplayer/feedWriteGate";
+import { decidePoseSync, spawnPresenceState, } from "@jgengine/core/multiplayer/presenceModel";
 import { createGameRuntime } from "@jgengine/core/runtime/gameRuntime";
 import { buildHydratePlayers, planServerPersist, shouldAutoSave, trimFeedEntries } from "@jgengine/core/runtime/hostPersistence";
 import { clearDirtyFlags, createEmptyServerRow } from "@jgengine/core/runtime/snapshot";
+import { applyCommandWithOcc, commitIfRevisionMatch } from "./occ.js";
 const saveConfigValidator = v.union(v.literal("none"), v.object({
     auto: v.string(),
     scope: v.union(v.literal("player"), v.literal("chunks"), v.literal("player+chunks")),
@@ -14,6 +17,8 @@ export function jgengineTables() {
             status: v.union(v.literal("open"), v.literal("running"), v.literal("closed")),
             mode: v.optional(v.string()),
             modeConfig: v.optional(v.any()),
+            visibility: v.optional(v.union(v.literal("public"), v.literal("private"))),
+            joinCode: v.optional(v.string()),
             memberUserIds: v.array(v.string()),
             slotsPerServer: v.number(),
             save: saveConfigValidator,
@@ -86,6 +91,13 @@ const schemaForTypes = defineSchema(jgengineTables());
 const query = queryGeneric;
 const mutation = mutationGeneric;
 const internalMutation = internalMutationGeneric;
+export const DEFAULT_CONVEX_POSE_RULES = {
+    maxSpeed: 12,
+    maxVerticalOffset: 3,
+    minElapsedSec: 0.05,
+    maxElapsedSec: 0.5,
+    keepAliveRefreshMs: 10_000,
+};
 async function resolveActor(ctx, claimedExternalId, mode) {
     const identity = await ctx.auth.getUserIdentity();
     if (identity !== null) {
@@ -101,6 +113,14 @@ async function resolveActor(ctx, claimedExternalId, mode) {
     }
     return null;
 }
+async function requireServerMember(ctx, serverId, actorUserId) {
+    const server = await ctx.db.get("jgGameServers", serverId);
+    if (!server)
+        return null;
+    if (!server.memberUserIds.includes(actorUserId))
+        return null;
+    return server;
+}
 const builtinRuntimeCommands = {
     "engine.ping": {
         validate: (_snapshot) => null,
@@ -132,6 +152,8 @@ function serverDocToRecord(server) {
         status: server.status,
         mode: server.mode,
         modeConfig: server.modeConfig,
+        visibility: server.visibility,
+        joinCode: server.joinCode,
         memberUserIds: server.memberUserIds,
         slotsPerServer: server.slotsPerServer,
         save: server.save,
@@ -177,6 +199,7 @@ async function loadServerSnapshot(ctx, server, runtime) {
         serverRow: server.serverState,
         playersByUserId,
         chunksByKey,
+        revision: server.revision,
     });
 }
 export async function applyLeaderboardIncrements(ctx, gameId, entries) {
@@ -254,6 +277,14 @@ async function persistServerSnapshot(ctx, server, snapshot, save) {
             });
         }
     }
+    for (const chunkKey of plan.deletedChunks) {
+        const existing = await ctx.db
+            .query("jgWorldChunks")
+            .withIndex("by_server_and_chunk", (q) => q.eq("serverId", server._id).eq("chunkKey", chunkKey))
+            .unique();
+        if (existing)
+            await ctx.db.delete(existing._id);
+    }
     await ctx.db.patch(server._id, {
         serverState: plan.server.serverState,
         sessionPlayers: plan.server.sessionPlayers,
@@ -273,16 +304,18 @@ async function flushServerIfDue(ctx, server, now, runtime) {
 }
 export const JG_RUNTIME_TICK_MS = 1_000;
 export function createGameServerFunctions(options) {
-    const mode = options?.auth ?? "anonymous";
+    const mode = options?.auth ?? "required";
+    const hostSlotsPerServer = options?.slotsPerServer ?? 16;
+    const feedWriteGate = createFeedWriteGate(options?.allowedFeedActions ?? []);
     const registry = buildRuntimeRegistry(options?.runtimes);
     const joinServer = mutation({
         args: {
             gameId: v.string(),
             serverId: v.optional(v.id("jgGameServers")),
-            slotsPerServer: v.optional(v.number()),
-            save: v.optional(saveConfigValidator),
             mode: v.optional(v.string()),
             modeConfig: v.optional(v.any()),
+            visibility: v.optional(v.union(v.literal("public"), v.literal("private"))),
+            joinCode: v.optional(v.string()),
             externalId: v.optional(v.string()),
         },
         returns: v.object({
@@ -296,9 +329,12 @@ export function createGameServerFunctions(options) {
             }
             const now = Date.now();
             const runtime = resolveRuntime(registry, args.gameId);
-            const save = (args.save ?? runtime.save);
-            const slotsPerServer = args.slotsPerServer ?? 16;
+            const save = runtime.save;
+            const slotsPerServer = hostSlotsPerServer;
             let server = args.serverId !== undefined ? await ctx.db.get("jgGameServers", args.serverId) : null;
+            if (args.serverId !== undefined && !server) {
+                throw new ConvexError("Server not found");
+            }
             if (server && server.gameId !== args.gameId) {
                 throw new ConvexError("Server belongs to a different game");
             }
@@ -312,8 +348,13 @@ export function createGameServerFunctions(options) {
                     joinable.push(...rows);
                 }
                 server =
-                    joinable.find((row) => row.memberUserIds.includes(actorUserId) ||
-                        row.memberUserIds.length < row.slotsPerServer) ?? null;
+                    joinable.find((row) => {
+                        if (row.memberUserIds.includes(actorUserId))
+                            return true;
+                        if (row.memberUserIds.length >= row.slotsPerServer)
+                            return false;
+                        return (row.visibility ?? "public") !== "private";
+                    }) ?? null;
             }
             if (!server) {
                 const serverId = await ctx.db.insert("jgGameServers", {
@@ -321,6 +362,8 @@ export function createGameServerFunctions(options) {
                     status: "running",
                     mode: args.mode,
                     modeConfig: args.modeConfig,
+                    visibility: args.visibility ?? "public",
+                    joinCode: args.joinCode,
                     memberUserIds: [],
                     slotsPerServer,
                     save,
@@ -339,6 +382,11 @@ export function createGameServerFunctions(options) {
                 !server.memberUserIds.includes(actorUserId)) {
                 throw new ConvexError("Server is full");
             }
+            if ((server.visibility ?? "public") === "private" &&
+                !server.memberUserIds.includes(actorUserId) &&
+                args.serverId === undefined) {
+                throw new ConvexError("Server is private");
+            }
             const profile = await ctx.db
                 .query("jgPlayerProfiles")
                 .withIndex("by_user_and_game", (q) => q.eq("userId", actorUserId).eq("gameId", args.gameId))
@@ -421,13 +469,30 @@ export function createGameServerFunctions(options) {
             if (!server.memberUserIds.includes(actorUserId)) {
                 return { ok: false, reason: "Not a member of this server" };
             }
+            const loadedRevision = server.revision;
             const runtime = resolveRuntime(registry, server.gameId);
             const snapshot = await loadServerSnapshot(ctx, server, runtime);
-            const result = runtime.runCommand(snapshot, actorUserId, args.command, args.input);
+            const result = applyCommandWithOcc({
+                loadedRevision,
+                currentRevision: server.revision,
+                snapshot,
+                runtime,
+                actorUserId,
+                command: args.command,
+                input: args.input,
+            });
             if (!result.ok) {
                 return result;
             }
-            await persistServerSnapshot(ctx, server, result.snapshot, server.save);
+            const latest = await ctx.db.get("jgGameServers", args.serverId);
+            if (!latest) {
+                return { ok: false, reason: "Server not found" };
+            }
+            const commit = commitIfRevisionMatch(loadedRevision, latest.revision);
+            if (!commit.ok) {
+                return commit;
+            }
+            await persistServerSnapshot(ctx, latest, result.snapshot, latest.save);
             return { ok: true };
         },
     });
@@ -480,6 +545,8 @@ export function createGameServerFunctions(options) {
                 return null;
             if (!server.memberUserIds.includes(actorUserId))
                 return null;
+            const sessionPlayers = server.sessionPlayers;
+            const ownSession = sessionPlayers[actorUserId];
             return {
                 _id: server._id,
                 gameId: server.gameId,
@@ -490,7 +557,7 @@ export function createGameServerFunctions(options) {
                 save: server.save,
                 revision: server.revision,
                 serverState: server.serverState,
-                sessionPlayers: server.sessionPlayers,
+                sessionPlayers: ownSession === undefined ? {} : { [actorUserId]: ownSession },
                 updatedAt: server.updatedAt,
             };
         },
@@ -560,6 +627,10 @@ export function createGameServerFunctions(options) {
             if (!actorUserId) {
                 throw new ConvexError("Not authenticated");
             }
+            const allowed = validateFeedWrite(feedWriteGate, args.action);
+            if (!allowed.ok) {
+                throw new ConvexError(allowed.reason);
+            }
             const server = await ctx.db.get("jgGameServers", args.serverId);
             if (!server || !server.memberUserIds.includes(actorUserId)) {
                 throw new ConvexError("Not a member of this server");
@@ -740,8 +811,9 @@ export function createLeaderboardFunctions(options) {
     return { getTop, getProfile, incrementMany };
 }
 export function createPresenceFunctions(options) {
-    const mode = options?.auth ?? "anonymous";
+    const mode = options?.auth ?? "required";
     const freshWindowMs = options?.freshWindowMs ?? 10_000;
+    const poseRules = options?.poseRules ?? DEFAULT_CONVEX_POSE_RULES;
     const list = query({
         args: {
             serverId: v.string(),
@@ -755,6 +827,11 @@ export function createPresenceFunctions(options) {
             lastSeenAt: v.number(),
         })),
         handler: async (ctx, args) => {
+            const actorUserId = await resolveActor(ctx, args.externalId, mode);
+            if (!actorUserId)
+                return [];
+            if ((await requireServerMember(ctx, args.serverId, actorUserId)) === null)
+                return [];
             const threshold = Date.now() - freshWindowMs;
             const rows = await ctx.db
                 .query("jgPoses")
@@ -788,21 +865,38 @@ export function createPresenceFunctions(options) {
             const actorUserId = await resolveActor(ctx, args.externalId, mode);
             if (!actorUserId)
                 return null;
+            if ((await requireServerMember(ctx, args.serverId, actorUserId)) === null)
+                return null;
             const now = Date.now();
             const existing = await ctx.db
                 .query("jgPoses")
                 .withIndex("by_server_and_user", (q) => q.eq("serverId", args.serverId).eq("userId", actorUserId))
                 .unique();
-            const patch = {
-                x: args.pose.x,
-                y: args.pose.y,
-                z: args.pose.z,
+            const current = existing === null
+                ? spawnPresenceState(undefined, now, poseRules)
+                : {
+                    position: { x: existing.x, y: existing.y, z: existing.z },
+                    rotationY: existing.rotationY,
+                    rotationPitch: existing.rotationPitch,
+                    lastSeenAtMs: existing.updatedAt,
+                };
+            const decision = decidePoseSync(current, {
+                position: { x: args.pose.x, y: args.pose.y, z: args.pose.z },
                 rotationY: args.pose.rotationY,
                 rotationPitch: args.pose.rotationPitch,
+            }, poseRules, now);
+            const patch = {
+                x: decision.position.x,
+                y: decision.position.y,
+                z: decision.position.z,
+                rotationY: decision.rotationY,
+                rotationPitch: decision.rotationPitch,
                 updatedAt: now,
             };
             if (existing) {
-                await ctx.db.patch(existing._id, patch);
+                if (decision.changed || decision.refreshKeepAlive) {
+                    await ctx.db.patch(existing._id, patch);
+                }
             }
             else {
                 await ctx.db.insert("jgPoses", { serverId: args.serverId, userId: actorUserId, ...patch });
@@ -832,7 +926,7 @@ export function createPresenceFunctions(options) {
     return { list, sync, leave };
 }
 export function createChatFunctions(options) {
-    const mode = options?.auth ?? "anonymous";
+    const mode = options?.auth ?? "required";
     const historyLimit = options?.historyLimit ?? 100;
     const maxBodyLength = options?.maxBodyLength ?? 500;
     const minIntervalMs = options?.minIntervalMs ?? 300;
@@ -850,6 +944,11 @@ export function createChatFunctions(options) {
             at: v.number(),
         })),
         handler: async (ctx, args) => {
+            const actorUserId = await resolveActor(ctx, args.externalId, mode);
+            if (!actorUserId)
+                return [];
+            if ((await requireServerMember(ctx, args.serverId, actorUserId)) === null)
+                return [];
             const rows = await ctx.db
                 .query("jgChatMessages")
                 .withIndex("by_server_channel", (q) => q.eq("serverId", args.serverId).eq("channelId", args.channelId))
@@ -879,6 +978,9 @@ export function createChatFunctions(options) {
             const actorUserId = await resolveActor(ctx, args.externalId, mode);
             if (!actorUserId)
                 return { ok: false, reason: "not signed in" };
+            if ((await requireServerMember(ctx, args.serverId, actorUserId)) === null) {
+                return { ok: false, reason: "not a member of this server" };
+            }
             const body = args.body.trim();
             if (body.length === 0)
                 return { ok: false, reason: "empty message" };