@jgengine/convex 0.8.0 → 0.10.0

package/CHANGELOG.md

@@ -11,6 +11,42 @@ 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.
 
+## 0.10.0
+
+### Migrate
+
+- **Nothing to change for existing games** — the shared mobile-composition system (viewport allocation, region collision, `--jg-*` viewport vars) is wired automatically by the shell for every game; `HudPanel`s inside a `HudCanvas` register themselves. Legacy `orientation: "landscape" | "portrait"` keeps its advisory dismissible-hint behavior unchanged.
+- **Opt a driving/landscape game into the strict gate**: replace the advisory `orientation` with the contract form — `orientation: { mobile: "landscape-required" }` (rules: `any` · `portrait`/`landscape` advisory · `portrait-required`/`landscape-required` · `unsupported`). In portrait the engine now shows a polished `RotateDeviceScreen`, suppresses input, freezes the sim, and unmounts the HUD/controls until the device is landscape.
+- **Declare HUD intent** where useful: `HudPanel` gains `priority` (`critical`/`secondary`/`tertiary`), `mobileBehavior` (`hidden` unmounts on phones, `transient` softens collision, …), `allowOverlapWith`, and `collisionGroup`. Optional — omitting them keeps prior behavior.
+- **Mobile validation now also fails on overlap**: `bun run shoot <game> --device mobile|mobile-landscape|both` exits non-zero on forbidden inter-element collisions (not just viewport overflow), naming both regions.
+
+### Added
+
+- Shared mobile layout composition — `@jgengine/core/ui/gameLayout` (pure geometry: `resolveLayoutMode`, `intersects`, `overlapArea`, `detectLayoutCollisions`, `computeGameplayRect`, `LayoutRegion`, `GameViewportLayout`) and `@jgengine/core/ui/orientation` (`resolveOrientationRequirement`, `orientationGateActive`, `MobileOrientationRule`). `@jgengine/react` adds `GameViewportProvider` (mounted by the shell), hooks (`useGameViewportLayout`, `useGameLayoutMode`, `useGameOrientation`, `useReservedControlZones`, `useLayoutCollisions`, `useRegisterLayoutRegion`), and a headless `RotateDeviceScreen`. The provider tracks `window.visualViewport`, publishes `--jg-viewport-*` / `--jg-visual-viewport-*` / `--jg-safe-*` CSS vars, resolves the explicit layout mode, and detects forbidden region overlaps (dev `data-jg-layout-collision` + console diagnostic).
+- Mandatory orientation contract — `PlayableGame.orientation` accepts `{ mobile: <rule> }`; `landscape-required`/`portrait-required` render an engine-owned rotate gate that blocks gameplay (input suppressed, simulation frozen, HUD/controls unmounted), self-correcting when the device is turned. Reduced-motion and safe-area respected; `visualViewport`-sized for mobile Safari/PWA.
+- Reserved touch-control zones — the touch dock registers its joystick / action-cluster / utility rectangles (runtime-measured) as `control` regions, so HUD placement and collision validation know exactly where controls sit.
+- HUD placement metadata — `HudPanel` gains `priority`, `mobileBehavior`, `allowOverlapWith`, `collisionGroup`, and registers as a collision-tracked layout region.
+- Mobile-landscape shoot device — `bun run shoot --device mobile-landscape` (844×390) plus collision-gate reads that fail mobile validation on forbidden overlaps.
+- Canyon Chase migrated as the reference landscape-required game — declares `orientation: { mobile: "landscape-required" }`, composes its HUD through coordinated `HudPanel` regions (pursuit distance critical, border secondary, survey map hidden on mobile, radio transient) instead of independent fixed corners.
+
+### Changed
+
+- First-person projectile tracers now originate from the weapon muzzle instead of the camera/eye centerline. Hit detection is unchanged (still crosshair-accurate) — only the drawn tracer's start point moved to the viewmodel muzzle, which tracks full aim yaw and pitch. Non-viewmodel games and enemy tracers are unaffected.
+
+## 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/hostedServer.d.ts

@@ -0,0 +1,96 @@
+import type { GameDefinition } from "@jgengine/core/game/defineGame";
+import type { GameContextContent } from "@jgengine/core/runtime/gameContext";
+import { type InputFrame } from "@jgengine/core/runtime/hostedGameRunner";
+import { type HostedWorldSession, type HostedWorldStore } from "@jgengine/core/runtime/hostedWorldSession";
+import type { ModelAssetRef } from "@jgengine/core/scene/assetCatalog";
+import { type JgAuthMode } from "./server.js";
+/** One game the hosted path can serve, bound per `gameId`: its definition plus content lookup. */
+export interface HostedGameConfig {
+    definition: GameDefinition<ModelAssetRef, unknown>;
+    content: GameContextContent;
+}
+/**
+ * Everything one stateless invocation reconstructs a hosted world from: the persisted record via `store`,
+ * plus the member roster and held inputs the snapshot doesn't carry, and the op to apply to the fresh session.
+ */
+export interface HostedWorldInvocation<T> {
+    game: HostedGameConfig;
+    store: HostedWorldStore;
+    members?: readonly string[];
+    inputs?: Readonly<Record<string, InputFrame>>;
+    now?: () => number;
+    op: (session: HostedWorldSession) => T;
+}
+/** What one stateless invocation produced: the op's value, the resulting revision, whether the world changed (and was saved back), and the post-op roster. */
+export interface HostedWorldOutcome<T> {
+    value: T;
+    revision: number;
+    changed: boolean;
+    members: readonly string[];
+}
+/**
+ * The reconstruct → op → save core of the stateless hosted path, Convex-agnostic so it unit-tests against
+ * `memoryWorldStore`: build a fresh {@link createHostedWorldSession} from `store.load()`, resume persisted
+ * members and replay held inputs, run the op, then persist the snapshot at `revision + 1` iff the world changed.
+ */
+export declare function invokeHostedWorld<T>(invocation: HostedWorldInvocation<T>): HostedWorldOutcome<T>;
+/** Default minimum elapsed ms before `tickHostedWorlds` advances a world — override via the factory's `tickMs`. */
+export declare const JG_HOSTED_TICK_MS = 1000;
+/**
+ * The Convex counterpart of ws's `createWorldGameHost`: serves GameContext worlds statelessly by
+ * reconstructing a hosted session from the persisted `jgHostedWorlds` row on every invocation via
+ * {@link invokeHostedWorld}. Destructure + re-export the returned functions from a `convex/` module and
+ * drive `tickHostedWorlds` from a cron. Requires {@link jgengineHostedTables} in the deployment schema.
+ */
+export declare function createHostedGameServerFunctions(options: {
+    games: Record<string, HostedGameConfig>;
+    auth?: JgAuthMode;
+    tickMs?: number;
+}): {
+    getHostedServer: import("convex/server").RegisteredQuery<"public", {
+        externalId?: string | undefined;
+        gameId: string;
+        serverId?: string | undefined;
+    }, Promise<{
+        serverId: string;
+        gameId: string;
+        revision: number;
+        serverState: any;
+        memberUserIds: string[];
+    } | null>>;
+    joinHostedServer: import("convex/server").RegisteredMutation<"public", {
+        externalId?: string | undefined;
+        gameId: string;
+        serverId?: string | undefined;
+    }, Promise<{
+        serverId: string;
+        isNew: boolean;
+    }>>;
+    leaveHostedServer: import("convex/server").RegisteredMutation<"public", {
+        externalId?: string | undefined;
+        gameId: string;
+        serverId?: string | undefined;
+    }, Promise<null>>;
+    runHostedCommand: import("convex/server").RegisteredMutation<"public", {
+        command: string;
+        externalId?: string | undefined;
+        gameId: string;
+        input: any;
+        serverId?: string | undefined;
+    }, Promise<{
+        ok: false;
+        reason: string;
+    } | {
+        ok: true;
+    }>>;
+    submitHostedInput: import("convex/server").RegisteredMutation<"public", {
+        externalId?: string | undefined;
+        frame: any;
+        gameId: string;
+        serverId?: string | undefined;
+    }, Promise<null>>;
+    tickHostedWorlds: import("convex/server").RegisteredMutation<"internal", {}, Promise<{
+        ticked: number;
+        saved: number;
+    }>>;
+};

package/dist/hostedServer.js

@@ -0,0 +1,350 @@
+import { defineSchema, internalMutationGeneric, mutationGeneric, queryGeneric, } from "convex/server";
+import { ConvexError, v } from "convex/values";
+import { INPUT_COMMAND } from "@jgengine/core/runtime/hostedGameRunner";
+import { createHostedWorldSession, } from "@jgengine/core/runtime/hostedWorldSession";
+import { commitIfRevisionMatch } from "./occ.js";
+import { jgengineHostedTables, resolveActor } from "./server.js";
+/**
+ * The reconstruct → op → save core of the stateless hosted path, Convex-agnostic so it unit-tests against
+ * `memoryWorldStore`: build a fresh {@link createHostedWorldSession} from `store.load()`, resume persisted
+ * members and replay held inputs, run the op, then persist the snapshot at `revision + 1` iff the world changed.
+ */
+export function invokeHostedWorld(invocation) {
+    const { game, store, members = [], inputs = {}, now, op } = invocation;
+    const loaded = store.load();
+    const loadedJson = loaded === null ? null : JSON.stringify(loaded.snapshot);
+    const session = createHostedWorldSession({
+        definition: game.definition,
+        content: game.content,
+        store: { load: () => loaded, save: () => { } },
+        ...(now === undefined ? {} : { now }),
+    });
+    for (const userId of members)
+        session.runner().resume(userId);
+    for (const [userId, frame] of Object.entries(inputs))
+        session.input(userId, frame);
+    const value = op(session);
+    const snapshot = session.runner().snapshot();
+    const baseRevision = loaded?.revision ?? 0;
+    if (loadedJson !== null && JSON.stringify(snapshot) === loadedJson) {
+        return { value, revision: baseRevision, changed: false, members: session.members() };
+    }
+    const record = { snapshot, revision: baseRevision + 1 };
+    store.save(record);
+    return { value, revision: record.revision, changed: true, members: session.members() };
+}
+const hostedSchemaForTypes = defineSchema(jgengineHostedTables());
+const query = queryGeneric;
+const mutation = mutationGeneric;
+const internalMutation = internalMutationGeneric;
+/** Default minimum elapsed ms before `tickHostedWorlds` advances a world — override via the factory's `tickMs`. */
+export const JG_HOSTED_TICK_MS = 1_000;
+async function getWorldRow(ctx, gameId, serverId) {
+    return await ctx.db
+        .query("jgHostedWorlds")
+        .withIndex("by_game_and_server", (q) => q.eq("gameId", gameId).eq("serverId", serverId))
+        .unique();
+}
+function heldInputsOf(row) {
+    return (row?.inputs ?? {});
+}
+function worldStoreForRow(row) {
+    const loaded = row === null ? null : { snapshot: row.snapshot, revision: row.revision };
+    let captured = null;
+    return {
+        store: {
+            load: () => loaded,
+            save(record) {
+                captured = record;
+            },
+        },
+        captured: () => captured,
+    };
+}
+async function persistWorldRow(ctx, args) {
+    const nowMs = Date.now();
+    if (args.row === null) {
+        if (args.record === null)
+            return;
+        await ctx.db.insert("jgHostedWorlds", {
+            gameId: args.gameId,
+            serverId: args.serverId,
+            snapshot: args.record.snapshot,
+            revision: args.record.revision,
+            memberUserIds: [...args.memberUserIds],
+            inputs: args.inputs,
+            tickAnchorMs: args.tickAnchorMs ?? nowMs,
+            createdAt: nowMs,
+            updatedAt: nowMs,
+        });
+        return;
+    }
+    await ctx.db.patch(args.row._id, {
+        ...(args.record === null
+            ? {}
+            : { snapshot: args.record.snapshot, revision: args.record.revision }),
+        memberUserIds: [...args.memberUserIds],
+        inputs: args.inputs,
+        ...(args.tickAnchorMs === undefined ? {} : { tickAnchorMs: args.tickAnchorMs }),
+        updatedAt: nowMs,
+    });
+}
+/**
+ * The Convex counterpart of ws's `createWorldGameHost`: serves GameContext worlds statelessly by
+ * reconstructing a hosted session from the persisted `jgHostedWorlds` row on every invocation via
+ * {@link invokeHostedWorld}. Destructure + re-export the returned functions from a `convex/` module and
+ * drive `tickHostedWorlds` from a cron. Requires {@link jgengineHostedTables} in the deployment schema.
+ */
+export function createHostedGameServerFunctions(options) {
+    const mode = options.auth ?? "anonymous";
+    const tickMs = options.tickMs ?? JG_HOSTED_TICK_MS;
+    function resolveGame(gameId) {
+        const game = options.games[gameId];
+        if (game === undefined)
+            throw new ConvexError(`Unknown hosted game "${gameId}"`);
+        return game;
+    }
+    const getHostedServer = query({
+        args: {
+            gameId: v.string(),
+            serverId: v.optional(v.string()),
+            externalId: v.optional(v.string()),
+        },
+        returns: v.union(v.object({
+            serverId: v.string(),
+            gameId: v.string(),
+            revision: v.number(),
+            serverState: v.any(),
+            memberUserIds: v.array(v.string()),
+        }), v.null()),
+        handler: async (ctx, args) => {
+            const actorUserId = await resolveActor(ctx, args.externalId, mode);
+            if (!actorUserId)
+                return null;
+            const row = await getWorldRow(ctx, args.gameId, args.serverId ?? args.gameId);
+            if (!row)
+                return null;
+            if (!row.memberUserIds.includes(actorUserId))
+                return null;
+            return {
+                serverId: row.serverId,
+                gameId: row.gameId,
+                revision: row.revision,
+                serverState: row.snapshot,
+                memberUserIds: row.memberUserIds,
+            };
+        },
+    });
+    const joinHostedServer = mutation({
+        args: {
+            gameId: v.string(),
+            serverId: v.optional(v.string()),
+            externalId: v.optional(v.string()),
+        },
+        returns: v.object({ serverId: v.string(), isNew: v.boolean() }),
+        handler: async (ctx, args) => {
+            const actorUserId = await resolveActor(ctx, args.externalId, mode);
+            if (!actorUserId) {
+                throw new ConvexError("Not authenticated");
+            }
+            const game = resolveGame(args.gameId);
+            const serverId = args.serverId ?? args.gameId;
+            const row = await getWorldRow(ctx, args.gameId, serverId);
+            const isNew = !(row?.memberUserIds ?? []).includes(actorUserId);
+            const { store, captured } = worldStoreForRow(row);
+            const outcome = invokeHostedWorld({
+                game,
+                store,
+                members: row?.memberUserIds ?? [],
+                inputs: heldInputsOf(row),
+                op: (session) => session.join(actorUserId, isNew),
+            });
+            await persistWorldRow(ctx, {
+                gameId: args.gameId,
+                serverId,
+                row,
+                record: captured(),
+                memberUserIds: outcome.members,
+                inputs: heldInputsOf(row),
+            });
+            return { serverId, isNew };
+        },
+    });
+    const leaveHostedServer = mutation({
+        args: {
+            gameId: v.string(),
+            serverId: v.optional(v.string()),
+            externalId: v.optional(v.string()),
+        },
+        returns: v.null(),
+        handler: async (ctx, args) => {
+            const actorUserId = await resolveActor(ctx, args.externalId, mode);
+            if (!actorUserId) {
+                throw new ConvexError("Not authenticated");
+            }
+            const serverId = args.serverId ?? args.gameId;
+            const row = await getWorldRow(ctx, args.gameId, serverId);
+            if (!row)
+                return null;
+            if (!row.memberUserIds.includes(actorUserId))
+                return null;
+            const game = resolveGame(args.gameId);
+            const { store, captured } = worldStoreForRow(row);
+            const outcome = invokeHostedWorld({
+                game,
+                store,
+                members: row.memberUserIds,
+                inputs: heldInputsOf(row),
+                op: (session) => session.leave(actorUserId),
+            });
+            const inputs = heldInputsOf(row);
+            delete inputs[actorUserId];
+            await persistWorldRow(ctx, {
+                gameId: args.gameId,
+                serverId,
+                row,
+                record: captured(),
+                memberUserIds: outcome.members,
+                inputs,
+            });
+            return null;
+        },
+    });
+    const runHostedCommand = mutation({
+        args: {
+            gameId: v.string(),
+            serverId: v.optional(v.string()),
+            command: v.string(),
+            input: v.any(),
+            externalId: v.optional(v.string()),
+        },
+        returns: v.union(v.object({ ok: v.literal(true) }), v.object({ ok: v.literal(false), reason: v.string() })),
+        handler: async (ctx, args) => {
+            const actorUserId = await resolveActor(ctx, args.externalId, mode);
+            if (!actorUserId) {
+                throw new ConvexError("Not authenticated");
+            }
+            const serverId = args.serverId ?? args.gameId;
+            const row = await getWorldRow(ctx, args.gameId, serverId);
+            if (!row) {
+                return { ok: false, reason: "Server not found" };
+            }
+            if (!row.memberUserIds.includes(actorUserId)) {
+                return { ok: false, reason: "Not a member of this server" };
+            }
+            if (args.command === INPUT_COMMAND) {
+                await ctx.db.patch(row._id, {
+                    inputs: { ...heldInputsOf(row), [actorUserId]: args.input },
+                    updatedAt: Date.now(),
+                });
+                return { ok: true };
+            }
+            const game = resolveGame(args.gameId);
+            const loadedRevision = row.revision;
+            const { store, captured } = worldStoreForRow(row);
+            const outcome = invokeHostedWorld({
+                game,
+                store,
+                members: row.memberUserIds,
+                inputs: heldInputsOf(row),
+                op: (session) => session.command(actorUserId, args.command, args.input),
+            });
+            if (outcome.value.status === "rejected") {
+                return { ok: false, reason: outcome.value.reason };
+            }
+            if (outcome.value.status === "unknown-command") {
+                return { ok: false, reason: "unknown-command" };
+            }
+            const latest = await getWorldRow(ctx, args.gameId, serverId);
+            if (!latest) {
+                return { ok: false, reason: "Server not found" };
+            }
+            const commit = commitIfRevisionMatch(loadedRevision, latest.revision);
+            if (!commit.ok) {
+                return commit;
+            }
+            await persistWorldRow(ctx, {
+                gameId: args.gameId,
+                serverId,
+                row: latest,
+                record: captured(),
+                memberUserIds: outcome.members,
+                inputs: heldInputsOf(latest),
+            });
+            return { ok: true };
+        },
+    });
+    const submitHostedInput = mutation({
+        args: {
+            gameId: v.string(),
+            serverId: v.optional(v.string()),
+            frame: v.any(),
+            externalId: v.optional(v.string()),
+        },
+        returns: v.null(),
+        handler: async (ctx, args) => {
+            const actorUserId = await resolveActor(ctx, args.externalId, mode);
+            if (!actorUserId) {
+                throw new ConvexError("Not authenticated");
+            }
+            const row = await getWorldRow(ctx, args.gameId, args.serverId ?? args.gameId);
+            if (!row || !row.memberUserIds.includes(actorUserId)) {
+                throw new ConvexError("Not a member of this server");
+            }
+            await ctx.db.patch(row._id, {
+                inputs: { ...heldInputsOf(row), [actorUserId]: args.frame },
+                updatedAt: Date.now(),
+            });
+            return null;
+        },
+    });
+    const tickHostedWorlds = internalMutation({
+        args: {},
+        handler: async (ctx) => {
+            const nowMs = Date.now();
+            const rows = await ctx.db.query("jgHostedWorlds").collect();
+            let ticked = 0;
+            let saved = 0;
+            for (const row of rows) {
+                const game = options.games[row.gameId];
+                if (game === undefined)
+                    continue;
+                if (row.memberUserIds.length === 0)
+                    continue;
+                const elapsedMs = nowMs - row.tickAnchorMs;
+                if (elapsedMs < tickMs)
+                    continue;
+                const { store, captured } = worldStoreForRow(row);
+                const outcome = invokeHostedWorld({
+                    game,
+                    store,
+                    members: row.memberUserIds,
+                    inputs: heldInputsOf(row),
+                    op: (session) => session.tick(elapsedMs / 1_000),
+                });
+                ticked += 1;
+                const record = captured();
+                if (record !== null)
+                    saved += 1;
+                await persistWorldRow(ctx, {
+                    gameId: row.gameId,
+                    serverId: row.serverId,
+                    row,
+                    record,
+                    memberUserIds: outcome.members,
+                    inputs: heldInputsOf(row),
+                    tickAnchorMs: nowMs,
+                });
+            }
+            return { ticked, saved };
+        },
+    });
+    return {
+        getHostedServer,
+        joinHostedServer,
+        leaveHostedServer,
+        runHostedCommand,
+        submitHostedInput,
+        tickHostedWorlds,
+    };
+}

package/dist/index.d.ts

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

package/dist/index.js

@@ -0,0 +1,8 @@
+export * from "./convexChatTransport.js";
+export * from "./convexPresenceTransport.js";
+export * from "./createConvexBackend.js";
+export * from "./createConvexGameTransport.js";
+export * from "./hostedServer.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);
+}