@jgengine/convex 0.8.0 → 0.10.0

package/dist/server.d.ts

@@ -1,7 +1,8 @@
-import type { DataModelFromSchemaDefinition, GenericMutationCtx } from "convex/server";
+import type { Auth, DataModelFromSchemaDefinition, GenericMutationCtx } from "convex/server";
 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<{
@@ -158,11 +163,42 @@ export declare function jgengineTables(): {
         by_server_channel: ["serverId", "channelId", "_creationTime"];
     }, {}, {}>;
 };
+/**
+ * Convex table for the hosted GameContext-world path: one row per (gameId, serverId) holding the full
+ * `WorldSnapshot` blob, its revision, the member roster, and each member's held input. A sibling of
+ * {@link jgengineTables} — spread either (or both) into `defineSchema`.
+ */
+export declare function jgengineHostedTables(): {
+    jgHostedWorlds: import("convex/server").TableDefinition<import("convex/values").VObject<{
+        createdAt: number;
+        gameId: string;
+        inputs: any;
+        memberUserIds: string[];
+        revision: number;
+        serverId: string;
+        snapshot: any;
+        tickAnchorMs: number;
+        updatedAt: number;
+    }, {
+        gameId: import("convex/values").VString<string, "required">;
+        serverId: import("convex/values").VString<string, "required">;
+        snapshot: import("convex/values").VAny<any, "required", string>;
+        revision: import("convex/values").VFloat64<number, "required">;
+        memberUserIds: import("convex/values").VArray<string[], import("convex/values").VString<string, "required">, "required">;
+        inputs: import("convex/values").VAny<any, "required", string>;
+        tickAnchorMs: import("convex/values").VFloat64<number, "required">;
+        createdAt: import("convex/values").VFloat64<number, "required">;
+        updatedAt: import("convex/values").VFloat64<number, "required">;
+    }, "required", "createdAt" | "gameId" | "inputs" | "memberUserIds" | "revision" | "serverId" | "snapshot" | "tickAnchorMs" | "updatedAt" | `inputs.${string}` | `snapshot.${string}`>, {
+        by_game_and_server: ["gameId", "serverId", "_creationTime"];
+    }, {}, {}>;
+};
 declare const schemaForTypes: import("convex/server").SchemaDefinition<{
     jgGameServers: import("convex/server").TableDefinition<import("convex/values").VObject<{
         createdAt: number;
         dirtyAt?: number | undefined;
         gameId: string;
+        joinCode?: string | undefined;
         lastSavedAt?: number | undefined;
         memberUserIds: string[];
         mode?: string | undefined;
@@ -178,11 +214,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 +242,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 +354,27 @@ 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;
+/** Resolve the acting user id under a {@link JgAuthMode}: the Convex identity when signed in (rejecting a mismatched claim), the claimed external id under `"anonymous"`, else `null`. */
+export declare function resolveActor(ctx: {
+    auth: Auth;
+}, claimedExternalId: string | undefined, mode: JgAuthMode): Promise<string | null>;
 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 +414,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 +493,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,
@@ -82,11 +87,39 @@ export function jgengineTables() {
         }).index("by_server_channel", ["serverId", "channelId"]),
     };
 }
+/**
+ * Convex table for the hosted GameContext-world path: one row per (gameId, serverId) holding the full
+ * `WorldSnapshot` blob, its revision, the member roster, and each member's held input. A sibling of
+ * {@link jgengineTables} — spread either (or both) into `defineSchema`.
+ */
+export function jgengineHostedTables() {
+    return {
+        jgHostedWorlds: defineTable({
+            gameId: v.string(),
+            serverId: v.string(),
+            snapshot: v.any(),
+            revision: v.number(),
+            memberUserIds: v.array(v.string()),
+            inputs: v.any(),
+            tickAnchorMs: v.number(),
+            createdAt: v.number(),
+            updatedAt: v.number(),
+        }).index("by_game_and_server", ["gameId", "serverId"]),
+    };
+}
 const schemaForTypes = defineSchema(jgengineTables());
 const query = queryGeneric;
 const mutation = mutationGeneric;
 const internalMutation = internalMutationGeneric;
-async function resolveActor(ctx, claimedExternalId, mode) {
+export const DEFAULT_CONVEX_POSE_RULES = {
+    maxSpeed: 12,
+    maxVerticalOffset: 3,
+    minElapsedSec: 0.05,
+    maxElapsedSec: 0.5,
+    keepAliveRefreshMs: 10_000,
+};
+/** Resolve the acting user id under a {@link JgAuthMode}: the Convex identity when signed in (rejecting a mismatched claim), the claimed external id under `"anonymous"`, else `null`. */
+export async function resolveActor(ctx, claimedExternalId, mode) {
     const identity = await ctx.auth.getUserIdentity();
     if (identity !== null) {
         if (claimedExternalId !== undefined &&
@@ -101,6 +134,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 +173,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 +220,7 @@ async function loadServerSnapshot(ctx, server, runtime) {
         serverRow: server.serverState,
         playersByUserId,
         chunksByKey,
+        revision: server.revision,
     });
 }
 export async function applyLeaderboardIncrements(ctx, gameId, entries) {
@@ -254,6 +298,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 +325,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 +350,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 +369,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 +383,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 +403,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 +490,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 +566,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 +578,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 +648,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 +832,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 +848,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 +886,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 +947,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 +965,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 +999,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" };