@jgengine/node 0.7.0 → 0.8.0

package/CHANGELOG.md

@@ -11,6 +11,53 @@ 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.8.0
+
+Transport-agnostic multiplayer (socket.io, WebRTC p2p, LAN/Fly adapters) plus grid/voxel
+and puzzle primitives, HUD-only presentation, cumulative leveling, and a round of
+controller/camera/sensor additions. **Breaking:** the `gameui` component kit moved out of
+`@jgengine/react` onto the shadcn registry.
+
+### Migrate
+
+- Bump every `@jgengine/*` dependency to `^0.8.0` (the eight packages version in lockstep).
+- Additive only, except for `gameui` — every other 0.7.0 API is unchanged; opt into any of the below by importing it directly.
+- **Breaking:** replace any `@jgengine/react/gameui` import with the equivalent registry component (`npx shadcn@latest add https://jgengine.com/r/<name>.json`), and swap `GameUiThemeProvider` for `--jg-*` CSS variables on a wrapper element. `GameIcon` and friends moved to `@jgengine/react/gameIcons`.
+- `leveling({ thresholdMode: 'cumulative' })` is opt-in; the default `perLevel` behavior is unchanged.
+- `defineGame.physics.gravity`/`jumpVelocity` are now read by the built-in kinematics controller every frame — if a game already set them expecting a no-op, jump/fall now actually reflects them; omit both to keep the previous defaults.
+
+### Added
+
+- Cumulative leveling — `leveling({ thresholdMode: 'cumulative' })` tracks xp as a lifetime total that resolves upward across levels and clamps at the max-level threshold once capped (#12).
+- Direction-aware pool depletion — `EffectSystem.canReceive(instanceId, effect, magnitude?)` takes an optional signed magnitude; negative checks the opposite direction and returns `pools-depleted` only when every stat in the receive order is already at max, so heals reach fully-depleted targets (#168).
+- Puzzle primitives — `puzzle/cellGrid` (uniform-cell boards: line-clear, match-3 cascade, run detection) and `puzzle/fallingPiece` (rotation-state shapes, ghost drop, lock delay, classic gravity/level/score curves) for Tetris/match-3 games (#166).
+- Voxel field — `world/voxelField` (`createVoxelField`, chunked block lattice, neighbors/exposedFaces, 3D DDA raycast, dirty-tracked `chunkVersion`) for voxel games and instanced renderers; assert on `field.summary()` the way environment worlds assert on `summarizeEnvironment` (#166).
+- `defineGame` games may omit `assets` (an empty catalog is injected); `PlayableGame.presentation: 'hud'` mounts no 3D canvas/camera/pointer for board/card/menu games; an `environment()` world auto-renders as the shell's backdrop when `PlayableGame.environment` is unset (#166).
+- Declared-action intent board — `turn/intent` `createIntentBoard` for one-turn-ahead intents (Slay-the-Spire style): declare/peek/all/consume/clear (#168).
+- `turnLoop` lifecycle hooks — `config.onTurnStart`/`onTurnEnd` fire on every `advanceTurn()`; `ctx.game.turn.loop(id, config)` lazily creates/returns a notify-wrapped `TurnLoop` so every mutation (`advanceTurn`/`advancePhase`/`advanceRound`/`spend`/`gain`/`refill`/`setOrder`/...) auto-bumps `ctx.version()` with no manual wiring (#163/#168).
+- `ctx.game.store` — a reactive per-game keyed store (`set`/`delete`/`get`/`has`/`subscribe`/`mapSnapshot`/`arraySnapshot`) plus `@jgengine/react`'s `useGameStore` selector hook, replacing hand-rolled module-level stores for ad-hoc reactive game state; `ctx.game.cards.pile(id, config?)` lazily creates/returns a notify-wrapped `CardPile` the same way; `createCardPile` gained an `onChange` hook for headless use; `CommandDefinition.apply` may return void for side-effect-only commands (#163).
+- Camera — `sideScroll` rig (fixed lateral follow for 2.5D platformers/beat-'em-ups), a `none` rig (no camera mounted; pairs with `PlayableGame.presentation: 'hud'`), `rts.pan: false` (static backdrop camera: no pan/edge-scroll/rotate/zoom, still re-centers on the follow target), and the `observer` rig now defaults to the local player when `bind` is unset (#167).
+- Sensors + session — `sensor/concealment` (`colorDistance`/`concealmentScore`/`createConcealmentSensor`), `sensor/freezeMonitor` (`createFreezeMonitor`), `session/roles` (`assignRoles`); `createRoundState`'s `RoundConfig.teams` accepts per-team roles and an optional `winCondition` that `evaluate()` checks each tick, and takes an optional `phaseOrder` for arbitrary named phase cycles (`concludeRound`/`evaluate` settle only while the current phase is neither the first nor the last entry) (#151).
+- Appearance replication — presence rows carry an optional per-slot appearance channel (cosmetic ids, hex tints, model keys) alongside pose, riding the existing pose message with no protocol bump; wire `ctx.player.cosmetics.get(userId)` into the outgoing pose (#151).
+- `ctx.input` — a per-frame held-action snapshot (`publish(held)`/`isDown(action)`/`held()`) without bumping `ctx.version()`; action bindings gained `repeatMs` (repeat-fire while held); every command resolved from a bound action now carries `aim`; `pointer.secondaryCommand` runs a command on right-click off the same raycast as move/ping (#164).
+- Object spatial queries + entity patching — `ctx.scene.object.at`/`inBox`/`raycast`/`raycastAll` over unit-box objects; `ctx.scene.entity.update(id, patch)` for name/position/rotation/role/movement/behaviors/meta; per-instance `renderObject`/`objectStyles` overrides; `pointerService.worldHitCenter()` + pointer-lock center-ray aiming (#165).
+- Controller movement config — `PlayerMovementConfig` (`mode`: free/axis/grid, `axis`, `cellSize`, `collideObjects`, `beforeCommit` pre-commit hook) for the shell-driven walk controller; `defineGame.physics.gravity`/`jumpVelocity` are honored by the built-in walk controller (distinct from the standalone `physics/physicsWorld` rigid-body sim); `ctx.player.motion.impulse`/`setVerticalVelocity`/`setY`/`takePending` (`MotionIntents`); `entity.spawnPoseOf`/`resetToSpawn`/`resetAllToSpawn` (#162).
+- Model material/animation + paint — `ModelConfig.tint`/`metalness`/`roughness`/`animation` (GLTF clip playback, paused pose holds); `PointerHit.uv` + `pointerService.sampleSurface()` for material-aware picking; `ctx.scene.entity.paint` runtime paint layer, auto-rendered via a per-instance canvas texture with no per-game wiring; remote-player appearance tint recolors the shell's default capsule (#151).
+- **Transport pipe seam** (`@jgengine/ws/pipe`) — `createWsBackend` runs over any bidirectional string channel, not just a raw `WebSocket`: `TransportPipe`/`TransportPipeHandlers`/`TransportPipeFactory`, with `webSocketPipe(url, webSocketFactory?)` as the default. `createWsBackend({ userId, url?, pipe? })` — `url` stays the common case, `pipe` opens the seam to socket.io, WebRTC, and in-process loopback below.
+- **Browser-safe authoritative host** — `createGameHost` and `memoryPersistence` moved from `@jgengine/node` to `@jgengine/ws/host` (zero Node dependencies; `@jgengine/node` re-exports both unchanged from `@jgengine/node/host` / `@jgengine/node/persistence`, so existing imports keep working). `@jgengine/ws/hostRouter`'s `createHostRouter({ host, authenticate?, poseRules?, positionHistoryMs?, chatRateLimit?, chatHistoryLimit?, chatMaxBodyLength?, now? })` extracts the ws wire-protocol session logic out of `createGameWsServer` into a transport-agnostic `HostRouter` (`connect(transport) → { handleRaw, close }`, `rewind`, `close`); `@jgengine/node`'s `createGameWsServer` is now a thin binding of this router onto the `ws` npm package, same public API. `loopbackPipe(router): TransportPipeFactory` connects a `createWsBackend` straight into an in-process router.
+- **Socket.IO transport** — `@jgengine/ws/socketIoPipe` (`SocketIoLikeSocket` structural type, `socketIoPipe(socket)`, `createSocketIoBackend({ socket, userId, … })`) and `@jgengine/node/socketIoServer` (`attachGameSocketIoServer({ io, host, …router options }): { rewind, close }`, structural `SocketIoLikeServer`/`SocketIoLikeServerSocket`) ride the existing ws JSON protocol over socket.io's `send`/`message` frames — no socket.io dependency in either package's types. New `socketIo({ topology?, url? })` adapter in `@jgengine/core/runtime/adapter`.
+- **WebRTC peer-to-peer** (`@jgengine/ws/peer`) — one browser tab hosts, authoritatively, with no server process. `createPeerHost({ userId, host?, runtimes?, persistence?, tickMs?, router?, rtc? })` runs a `GameHost` + `HostRouter` in the host tab (`backend` is the host player's own loopback connection, `accept(offerCode) → Promise<answerCode>` per guest); `createPeerGuest({ userId, token?, rtc? })` offers/connects from the joining side. `encodePeerSignal`/`decodePeerSignal` turn SDP into copy-pasteable base64url codes for manual cross-machine signaling; `broadcastChannelSignaling(room)` automates it for same-origin multi-tab play, with `announcePeerHost`/`joinPeerSession` wiring host/guest to a `PeerSignaling` in one call. New `p2p({ topology?, room? })` adapter (topology defaults `"private"`).
+- **LAN adapter + Fly sugar** — `lan({ topology?, port?, path? })` in `@jgengine/core/runtime/adapter` resolves through `@jgengine/shell/multiplayer`'s `resolveShellMultiplayer` to `ws(s)://<page hostname>:<port ?? 8080><path ?? /ws>` derived from `window.location`, so any browser on the LAN auto-connects to whichever machine served the page — no URL configuration. `fly({ app, topology?, path? })` is `ws` sugar for a Fly.io deploy: resolves to `wss://<app>.fly.dev<path ?? "/ws">`. `apps/dev`'s Vite server now listens on the network (`server: { host: true }`) and exposes `?p2p=host` / `?p2p=join` query params wired through the new `resolvePeerShellMultiplayer({ gameId, role, room?, userId?, feedActions? })`.
+- `ws()` (`@jgengine/core/runtime/adapter`) gained an optional `url` field, carried through by `resolveShellMultiplayer` (`args.url ?? adapter.url ?? default`).
+
+### Removed
+
+- **The `gameui` component kit** (`@jgengine/react/gameui`) — the themed HUD kit (bars, slots, feedback, meters, panels, screens, reticles, icons) and its `GameUiThemeProvider`/`useGameUiTheme` theming have been removed. **Breaking** for anyone importing `@jgengine/react/gameui` (or its subpaths/barrel). The components now ship as installable shadcn registry items at `https://jgengine.com/r/<name>.json` (`npx shadcn@latest add https://jgengine.com/r/<name>.json`), styled with Tailwind + `--jg-*` CSS variables instead of a theme object. The icon catalog (`GameIcon`, `iconForAction`, `iconForItemId`, `isGameIconName`, `GameIconName`) moved to `@jgengine/react/gameIcons`. To theme, set the `--jg-*` variables on a wrapper element (the registry's `jg-theme` presets mirror the old `ember`/`synthwave`/`fieldkit` palettes) instead of wrapping in `GameUiThemeProvider`.
+
+### Docs
+
+- Added [CREDITS.md](CREDITS.md) crediting [achrefelouafi](https://github.com/achrefelouafi) for the MIT Three.js reference projects behind the procedural building, water, rain, and snow renderers, with links from the root, `@jgengine/core`, and `@jgengine/shell` READMEs.
+
 ## 0.7.0
 
 The engine-gaps release — 22 system-level additions across turn/tactics, cards & boards,

package/dist/host.d.ts

@@ -1,84 +1 @@
-import type { GameRuntime } from "@jgengine/core/runtime/gameRuntime";
-import type { HostPersistence, ServerListing, SessionAttributes } from "@jgengine/core/runtime/hostPersistence";
-import type { MatchFilter, SessionListing } from "@jgengine/core/multiplayer/matchmaking";
-import type { GameRuntimePlayerView, GameRuntimeServerView, JoinServerResult, TransportRunCommandResult } from "@jgengine/core/runtime/transport";
-export type HostChangeEvent = {
-    type: "server";
-    serverId: string;
-} | {
-    type: "player";
-    serverId: string;
-    userId: string;
-} | {
-    type: "feed";
-    serverId: string;
-    action: string;
-};
-export type GameHostOptions = {
-    runtimes?: GameRuntime[];
-    persistence: HostPersistence;
-    tickMs?: number;
-    slotsPerServer?: number;
-    now?: () => number;
-    createServerId?: () => string;
-};
-export type GameHost = {
-    joinServer: (args: {
-        userId: string;
-        gameId: string;
-        serverId?: string;
-        attributes?: SessionAttributes;
-    }) => Promise<JoinServerResult>;
-    browseServers: (args: {
-        gameId: string;
-        filter?: MatchFilter;
-        limit?: number;
-    }) => Promise<SessionListing[]>;
-    joinByCode: (args: {
-        userId: string;
-        gameId: string;
-        code: string;
-    }) => Promise<JoinServerResult | null>;
-    leaveServer: (args: {
-        userId: string;
-        serverId: string;
-    }) => Promise<void>;
-    runCommand: (args: {
-        userId: string;
-        serverId: string;
-        command: string;
-        input: unknown;
-    }) => Promise<TransportRunCommandResult>;
-    getServerView: (args: {
-        userId: string;
-        serverId: string;
-    }) => Promise<GameRuntimeServerView | null>;
-    getPlayerView: (args: {
-        userId: string;
-        serverId: string;
-    }) => Promise<GameRuntimePlayerView | null>;
-    getFeed: (args: {
-        userId: string;
-        serverId: string;
-        action: string;
-    }) => Promise<unknown[]>;
-    pushFeedEntry: (args: {
-        userId: string;
-        serverId: string;
-        action: string;
-        entry: unknown;
-    }) => Promise<void>;
-    listOpenServers: (args: {
-        gameId: string;
-        limit?: number;
-    }) => Promise<ServerListing[]>;
-    tickOnce: () => Promise<{
-        ticked: number;
-        saved: number;
-    }>;
-    flushAll: () => Promise<number>;
-    start: () => void;
-    stop: () => Promise<void>;
-    subscribe: (listener: (event: HostChangeEvent) => void) => () => void;
-};
-export declare function createGameHost(options: GameHostOptions): GameHost;
+export { createGameHost, memoryPersistence, type GameHost, type GameHostOptions, type HostChangeEvent, } from "@jgengine/ws/host";

package/dist/host.js

@@ -1,375 +1 @@
-import { randomUUID } from "node:crypto";
-import { createGameRuntime } from "@jgengine/core/runtime/gameRuntime";
-import { buildHydratePlayers, planServerPersist, shouldAutoSave, toServerListing, } from "@jgengine/core/runtime/hostPersistence";
-import { browseSessions, findByJoinCode } from "@jgengine/core/multiplayer/matchmaking";
-import { clearDirtyFlags, createEmptyServerRow, splitProfilePlayer } from "@jgengine/core/runtime/snapshot";
-const builtinCommands = {
-    "engine.ping": {
-        validate: () => null,
-        apply: (snapshot) => snapshot,
-    },
-};
-export function createGameHost(options) {
-    const now = options.now ?? Date.now;
-    const tickMs = options.tickMs ?? 1_000;
-    const defaultSlots = options.slotsPerServer ?? 16;
-    const createServerId = options.createServerId ?? (() => `srv-${randomUUID()}`);
-    const persistence = options.persistence;
-    const runtimes = new Map();
-    for (const runtime of options.runtimes ?? []) {
-        runtimes.set(runtime.gameId, runtime);
-    }
-    const resolveRuntime = (gameId) => {
-        const existing = runtimes.get(gameId);
-        if (existing)
-            return existing;
-        const fallback = createGameRuntime({ gameId, save: "none", commands: builtinCommands });
-        runtimes.set(gameId, fallback);
-        return fallback;
-    };
-    const live = new Map();
-    const listeners = new Set();
-    const emit = (event) => {
-        for (const listener of listeners)
-            listener(event);
-    };
-    let queue = Promise.resolve();
-    const enqueue = (operation) => {
-        const run = queue.then(operation);
-        queue = run.catch(() => undefined);
-        return run;
-    };
-    const hydrate = async (record) => {
-        const runtime = resolveRuntime(record.gameId);
-        const profiles = {};
-        for (const userId of record.memberUserIds) {
-            profiles[userId] = await persistence.loadProfile({ userId, gameId: record.gameId });
-        }
-        const chunkRecords = await persistence.loadChunks(record.serverId);
-        const chunksByKey = {};
-        for (const chunk of chunkRecords) {
-            chunksByKey[chunk.chunkKey] = chunk.snapshot;
-        }
-        const snapshot = runtime.hydrate({
-            gameId: record.gameId,
-            serverId: record.serverId,
-            serverRow: record.serverState,
-            playersByUserId: buildHydratePlayers(record, profiles),
-            chunksByKey,
-        });
-        const existing = live.get(record.serverId);
-        if (existing)
-            return existing;
-        const entry = { record, snapshot };
-        live.set(record.serverId, entry);
-        return entry;
-    };
-    const getLive = async (serverId) => {
-        const existing = live.get(serverId);
-        if (existing)
-            return existing;
-        const record = await persistence.loadServer(serverId);
-        if (record === null)
-            return null;
-        return hydrate(record);
-    };
-    const flushServer = async (entry) => {
-        const timestamp = now();
-        const plan = planServerPersist(entry.record, entry.snapshot, entry.record.save, timestamp);
-        const cleared = { ...plan, server: { ...plan.server, dirtyAt: undefined } };
-        if (persistence.savePlan) {
-            await persistence.savePlan(cleared);
-        }
-        else {
-            if (cleared.leaderboard.length > 0) {
-                await persistence.applyLeaderboardIncrements(entry.record.gameId, cleared.leaderboard);
-            }
-            for (const profile of cleared.profiles) {
-                await persistence.saveProfile(profile);
-            }
-            if (cleared.chunks.length > 0) {
-                await persistence.saveChunks(entry.record.serverId, cleared.chunks);
-            }
-            await persistence.saveServer(cleared.server);
-        }
-        entry.record = cleared.server;
-        entry.snapshot = clearDirtyFlags({ ...entry.snapshot, server: cleared.server.serverState });
-    };
-    const markMutated = (entry) => {
-        const timestamp = now();
-        entry.record = {
-            ...entry.record,
-            revision: entry.snapshot.revision,
-            dirtyAt: entry.record.dirtyAt ?? timestamp,
-            updatedAt: timestamp,
-        };
-    };
-    let interval = null;
-    const tickOnce = () => enqueue(async () => {
-        const timestamp = now();
-        let ticked = 0;
-        let saved = 0;
-        for (const entry of live.values()) {
-            if (entry.record.status !== "running")
-                continue;
-            if (entry.record.memberUserIds.length === 0)
-                continue;
-            const elapsedMs = timestamp - entry.record.tickAnchorMs;
-            if (elapsedMs < tickMs)
-                continue;
-            const runtime = resolveRuntime(entry.record.gameId);
-            const before = entry.snapshot.revision;
-            entry.snapshot = runtime.tick(entry.snapshot, elapsedMs / 1_000);
-            entry.record = { ...entry.record, tickAnchorMs: timestamp, updatedAt: timestamp };
-            ticked += 1;
-            if (entry.snapshot.revision !== before) {
-                markMutated(entry);
-                emit({ type: "server", serverId: entry.record.serverId });
-            }
-            if (shouldAutoSave(entry.record.save, entry.record.dirtyAt, entry.record.lastSavedAt, timestamp)) {
-                await flushServer(entry);
-                saved += 1;
-            }
-        }
-        return { ticked, saved };
-    });
-    const collectListings = async (gameId) => {
-        const byId = new Map();
-        for (const record of await persistence.listServers(gameId)) {
-            byId.set(record.serverId, record);
-        }
-        for (const entry of live.values()) {
-            if (entry.record.gameId !== gameId)
-                continue;
-            byId.set(entry.record.serverId, entry.record);
-        }
-        return [...byId.values()].map((record) => ({
-            serverId: record.serverId,
-            gameId: record.gameId,
-            status: record.status,
-            visibility: record.visibility ?? "public",
-            memberCount: record.memberUserIds.length,
-            slotsPerServer: record.slotsPerServer,
-            label: record.label,
-            mode: record.mode,
-            joinCode: record.joinCode,
-            tags: record.tags,
-            updatedAt: record.updatedAt,
-        }));
-    };
-    const host = {
-        joinServer: (args) => enqueue(async () => {
-            const timestamp = now();
-            const runtime = resolveRuntime(args.gameId);
-            let entry = args.serverId === undefined ? null : await getLive(args.serverId);
-            if (entry !== null && entry.record.gameId !== args.gameId) {
-                throw new Error("Server belongs to a different game");
-            }
-            if (entry === null) {
-                const attributes = args.attributes;
-                const record = {
-                    serverId: createServerId(),
-                    gameId: args.gameId,
-                    status: "running",
-                    memberUserIds: [],
-                    slotsPerServer: defaultSlots,
-                    save: runtime.save,
-                    serverState: createEmptyServerRow(),
-                    sessionPlayers: {},
-                    revision: 0,
-                    tickAnchorMs: timestamp,
-                    createdAt: timestamp,
-                    updatedAt: timestamp,
-                    ...(attributes?.label !== undefined ? { label: attributes.label } : {}),
-                    ...(attributes?.mode !== undefined ? { mode: attributes.mode } : {}),
-                    ...(attributes?.visibility !== undefined ? { visibility: attributes.visibility } : {}),
-                    ...(attributes?.joinCode !== undefined ? { joinCode: attributes.joinCode } : {}),
-                    ...(attributes?.tags !== undefined ? { tags: attributes.tags } : {}),
-                };
-                entry = await hydrate(record);
-            }
-            const { record } = entry;
-            if (record.memberUserIds.length >= record.slotsPerServer &&
-                !record.memberUserIds.includes(args.userId)) {
-                throw new Error("Server is full");
-            }
-            const profile = await persistence.loadProfile({ userId: args.userId, gameId: args.gameId });
-            const isNew = profile === null;
-            entry.record = {
-                ...record,
-                memberUserIds: record.memberUserIds.includes(args.userId)
-                    ? record.memberUserIds
-                    : [...record.memberUserIds, args.userId],
-                status: "running",
-                updatedAt: timestamp,
-                dirtyAt: timestamp,
-            };
-            entry.snapshot = runtime.joinPlayer(entry.snapshot, args.userId, isNew);
-            await flushServer(entry);
-            emit({ type: "server", serverId: entry.record.serverId });
-            emit({ type: "player", serverId: entry.record.serverId, userId: args.userId });
-            return { serverId: entry.record.serverId, isNew };
-        }),
-        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);
-            if (match === null)
-                return null;
-            return host.joinServer({ userId: args.userId, gameId: args.gameId, serverId: match.serverId });
-        },
-        leaveServer: (args) => enqueue(async () => {
-            const entry = await getLive(args.serverId);
-            if (entry === null)
-                return;
-            if (!entry.record.memberUserIds.includes(args.userId))
-                return;
-            await flushServer(entry);
-            const timestamp = now();
-            const memberUserIds = entry.record.memberUserIds.filter((id) => id !== args.userId);
-            const sessionPlayers = { ...entry.record.sessionPlayers };
-            delete sessionPlayers[args.userId];
-            const players = { ...entry.snapshot.players };
-            delete players[args.userId];
-            entry.record = {
-                ...entry.record,
-                memberUserIds,
-                sessionPlayers,
-                updatedAt: timestamp,
-                status: memberUserIds.length === 0 ? "open" : entry.record.status,
-            };
-            entry.snapshot = { ...entry.snapshot, players };
-            await persistence.saveServer(entry.record);
-            if (memberUserIds.length === 0) {
-                live.delete(entry.record.serverId);
-            }
-            emit({ type: "server", serverId: args.serverId });
-        }),
-        runCommand: (args) => enqueue(async () => {
-            const entry = await getLive(args.serverId);
-            if (entry === null) {
-                return { ok: false, reason: "Server not found" };
-            }
-            if (!entry.record.memberUserIds.includes(args.userId)) {
-                return { ok: false, reason: "Not a member of this server" };
-            }
-            const runtime = resolveRuntime(entry.record.gameId);
-            const result = runtime.runCommand(entry.snapshot, args.userId, args.command, args.input);
-            if (!result.ok) {
-                return { ok: false, reason: result.reason };
-            }
-            entry.snapshot = result.snapshot;
-            markMutated(entry);
-            emit({ type: "server", serverId: args.serverId });
-            emit({ type: "player", serverId: args.serverId, userId: args.userId });
-            return { ok: true };
-        }),
-        getServerView: async (args) => {
-            const entry = await getLive(args.serverId);
-            if (entry === null)
-                return null;
-            if (!entry.record.memberUserIds.includes(args.userId))
-                return null;
-            return {
-                serverId: entry.record.serverId,
-                gameId: entry.record.gameId,
-                revision: entry.snapshot.revision,
-                memberUserIds: entry.record.memberUserIds,
-                serverState: entry.snapshot.server,
-                updatedAt: entry.record.updatedAt,
-            };
-        },
-        getPlayerView: async (args) => {
-            const entry = await getLive(args.serverId);
-            if (entry === null)
-                return null;
-            if (!entry.record.memberUserIds.includes(args.userId))
-                return null;
-            const player = entry.snapshot.players[args.userId];
-            if (player !== undefined) {
-                return {
-                    userId: args.userId,
-                    gameId: entry.record.gameId,
-                    playerState: splitProfilePlayer(player).persistent,
-                    updatedAt: entry.record.updatedAt,
-                };
-            }
-            const profile = await persistence.loadProfile({ userId: args.userId, gameId: entry.record.gameId });
-            if (profile === null)
-                return null;
-            return {
-                userId: profile.userId,
-                gameId: profile.gameId,
-                playerState: profile.playerState,
-                updatedAt: profile.updatedAt,
-            };
-        },
-        getFeed: async (args) => {
-            const entry = await getLive(args.serverId);
-            if (entry === null)
-                return [];
-            if (!entry.record.memberUserIds.includes(args.userId))
-                return [];
-            return persistence.loadFeed({ serverId: args.serverId, action: args.action });
-        },
-        pushFeedEntry: (args) => enqueue(async () => {
-            const entry = await getLive(args.serverId);
-            if (entry === null || !entry.record.memberUserIds.includes(args.userId)) {
-                throw new Error("Not a member of this server");
-            }
-            await persistence.appendFeed({ serverId: args.serverId, action: args.action, entry: args.entry });
-            emit({ type: "feed", serverId: args.serverId, action: args.action });
-        }),
-        listOpenServers: async (args) => {
-            const limit = args.limit ?? 20;
-            const byId = new Map();
-            for (const record of await persistence.listServers(args.gameId)) {
-                byId.set(record.serverId, toServerListing(record));
-            }
-            for (const entry of live.values()) {
-                if (entry.record.gameId !== args.gameId)
-                    continue;
-                byId.set(entry.record.serverId, toServerListing(entry.record));
-            }
-            return [...byId.values()]
-                .filter((listing) => listing.status === "running")
-                .sort((a, b) => b.updatedAt - a.updatedAt)
-                .slice(0, limit);
-        },
-        tickOnce,
-        flushAll: () => enqueue(async () => {
-            let saved = 0;
-            for (const entry of live.values()) {
-                if (entry.record.dirtyAt === undefined)
-                    continue;
-                await flushServer(entry);
-                saved += 1;
-            }
-            return saved;
-        }),
-        start: () => {
-            if (interval !== null)
-                return;
-            interval = setInterval(() => {
-                void tickOnce();
-            }, tickMs);
-        },
-        stop: async () => {
-            if (interval !== null) {
-                clearInterval(interval);
-                interval = null;
-            }
-            await enqueue(async () => {
-                for (const entry of live.values()) {
-                    if (entry.record.dirtyAt === undefined)
-                        continue;
-                    await flushServer(entry);
-                }
-            });
-        },
-        subscribe: (listener) => {
-            listeners.add(listener);
-            return () => listeners.delete(listener);
-        },
-    };
-    return host;
-}
+export { createGameHost, memoryPersistence, } from "@jgengine/ws/host";

package/dist/persistence.d.ts

@@ -1,4 +1,4 @@
 import type { HostPersistence } from "@jgengine/core/runtime/hostPersistence";
-export declare function memoryPersistence(now?: () => number): HostPersistence;
+export { memoryPersistence } from "@jgengine/ws/host";
 export declare function filePersistence(dir: string, now?: () => number): HostPersistence;
 export declare function clearFilePersistence(dir: string): Promise<void>;

package/dist/persistence.js

@@ -1,105 +1,7 @@
 import { mkdir, readdir, readFile, rename, rm, writeFile } from "node:fs/promises";
 import { join } from "node:path";
-import { trimFeedEntries } from "@jgengine/core/runtime/hostPersistence";
-const MAX_TOP_LIMIT = 100;
-function leaderboardRowKey(row) {
-    return [row.gameId, row.scope, row.stat, row.serverId ?? "", row.userId].join("|");
-}
-function applyIncrements(rows, gameId, entries, now) {
-    for (const entry of entries) {
-        const key = leaderboardRowKey({ ...entry, gameId });
-        const existing = rows.get(key);
-        if (existing) {
-            rows.set(key, { ...existing, value: existing.value + entry.by, updatedAt: now });
-        }
-        else {
-            rows.set(key, {
-                gameId,
-                stat: entry.stat,
-                scope: entry.scope,
-                serverId: entry.serverId,
-                userId: entry.userId,
-                value: entry.by,
-                updatedAt: now,
-            });
-        }
-    }
-}
-function topRows(rows, args) {
-    const limit = Math.min(Math.max(args.limit ?? MAX_TOP_LIMIT, 1), MAX_TOP_LIMIT);
-    return [...rows]
-        .filter((row) => row.gameId === args.gameId &&
-        row.stat === args.stat &&
-        row.scope === args.scope &&
-        (args.serverId === undefined || row.serverId === args.serverId))
-        .sort((a, b) => b.value - a.value)
-        .slice(0, limit)
-        .map((row) => ({ userId: row.userId, value: row.value }));
-}
-function profileStats(rows, gameId, userId) {
-    const profile = {};
-    for (const row of rows) {
-        if (row.gameId === gameId && row.userId === userId && row.scope === "profile") {
-            profile[row.stat] = row.value;
-        }
-    }
-    return profile;
-}
-export function memoryPersistence(now = Date.now) {
-    const servers = new Map();
-    const profiles = new Map();
-    const chunks = new Map();
-    const feeds = new Map();
-    const leaderboard = new Map();
-    const clone = (value) => structuredClone(value);
-    return {
-        async loadServer(serverId) {
-            const record = servers.get(serverId);
-            return record === undefined ? null : clone(record);
-        },
-        async saveServer(record) {
-            servers.set(record.serverId, clone(record));
-        },
-        async listServers(gameId) {
-            return [...servers.values()].filter((record) => record.gameId === gameId).map(clone);
-        },
-        async loadProfile({ userId, gameId }) {
-            const record = profiles.get(`${gameId}|${userId}`);
-            return record === undefined ? null : clone(record);
-        },
-        async saveProfile(record) {
-            profiles.set(`${record.gameId}|${record.userId}`, clone(record));
-        },
-        async loadChunks(serverId) {
-            return [...(chunks.get(serverId)?.values() ?? [])].map(clone);
-        },
-        async saveChunks(serverId, records) {
-            const byKey = chunks.get(serverId) ?? new Map();
-            for (const record of records) {
-                byKey.set(record.chunkKey, clone(record));
-            }
-            chunks.set(serverId, byKey);
-        },
-        async loadFeed({ serverId, action }) {
-            return clone(feeds.get(`${serverId}|${action}`) ?? []);
-        },
-        async appendFeed({ serverId, action, entry }) {
-            const key = `${serverId}|${action}`;
-            const entries = trimFeedEntries([...(feeds.get(key) ?? []), clone(entry)]);
-            feeds.set(key, entries);
-            return clone(entries);
-        },
-        async applyLeaderboardIncrements(gameId, entries) {
-            applyIncrements(leaderboard, gameId, entries, now());
-        },
-        async getLeaderboardTop(args) {
-            return topRows(leaderboard.values(), args);
-        },
-        async getLeaderboardProfile({ gameId, userId }) {
-            return profileStats(leaderboard.values(), gameId, userId);
-        },
-    };
-}
+import { applyLeaderboardRows, leaderboardRowKey, profileLeaderboardStats, topLeaderboardRows, trimFeedEntries, } from "@jgengine/core/runtime/hostPersistence";
+export { memoryPersistence } from "@jgengine/ws/host";
 async function readJson(path) {
     try {
         return JSON.parse(await readFile(path, "utf8"));
@@ -203,7 +105,7 @@ export function filePersistence(dir, now = Date.now) {
             const run = leaderboardLock.then(async () => {
                 await ensureDirs();
                 const rows = await loadLeaderboard();
-                applyIncrements(rows, gameId, entries, now());
+                applyLeaderboardRows(rows, gameId, entries, now());
                 await writeJson(leaderboardPath, [...rows.values()]);
             });
             leaderboardLock = run.catch(() => undefined);
@@ -211,11 +113,11 @@ export function filePersistence(dir, now = Date.now) {
         },
         async getLeaderboardTop(args) {
             await ensureDirs();
-            return topRows((await loadLeaderboard()).values(), args);
+            return topLeaderboardRows((await loadLeaderboard()).values(), args);
         },
         async getLeaderboardProfile({ gameId, userId }) {
             await ensureDirs();
-            return profileStats((await loadLeaderboard()).values(), gameId, userId);
+            return profileLeaderboardStats((await loadLeaderboard()).values(), gameId, userId);
         },
     };
 }