@jgengine/node 0.7.0 → 0.9.0

package/dist/persistence.js

@@ -1,117 +1,30 @@
-import { mkdir, readdir, readFile, rename, rm, writeFile } from "node:fs/promises";
+import { randomUUID } from "node:crypto";
+import { mkdir, readdir, readFile, rename, rm, unlink, 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";
+function isMissing(error) {
+    return error?.code === "ENOENT";
 }
 async function readJson(path) {
+    let text;
     try {
-        return JSON.parse(await readFile(path, "utf8"));
+        text = await readFile(path, "utf8");
     }
-    catch {
-        return null;
+    catch (error) {
+        if (isMissing(error))
+            return null;
+        throw error;
     }
+    return JSON.parse(text);
 }
-async function writeJson(path, value) {
-    const temp = `${path}.tmp`;
+async function stageJson(path, value) {
+    const temp = `${path}.${randomUUID()}.tmp`;
     await writeFile(temp, JSON.stringify(value), "utf8");
-    await rename(temp, path);
+    return temp;
+}
+async function writeJson(path, value) {
+    await rename(await stageJson(path, value), path);
 }
 const enc = encodeURIComponent;
 export function filePersistence(dir, now = Date.now) {
@@ -130,6 +43,7 @@ export function filePersistence(dir, now = Date.now) {
         return new Map(rows.map((row) => [leaderboardRowKey(row), row]));
     };
     let leaderboardLock = Promise.resolve();
+    const feedLocks = new Map();
     return {
         async loadServer(serverId) {
             await ensureDirs();
@@ -184,9 +98,24 @@ export function filePersistence(dir, now = Date.now) {
             await ensureDirs();
             const serverDir = join(chunksDir, enc(serverId));
             await mkdir(serverDir, { recursive: true });
-            for (const record of records) {
-                await writeJson(join(serverDir, `${enc(record.chunkKey)}.json`), record);
-            }
+            const staged = await Promise.all(records.map(async (record) => {
+                const final = join(serverDir, `${enc(record.chunkKey)}.json`);
+                return { temp: await stageJson(final, record), final };
+            }));
+            await Promise.all(staged.map(({ temp, final }) => rename(temp, final)));
+        },
+        async deleteChunks(serverId, chunkKeys) {
+            await ensureDirs();
+            const serverDir = join(chunksDir, enc(serverId));
+            await Promise.all(chunkKeys.map(async (chunkKey) => {
+                try {
+                    await unlink(join(serverDir, `${enc(chunkKey)}.json`));
+                }
+                catch (error) {
+                    if (!isMissing(error))
+                        throw error;
+                }
+            }));
         },
         async loadFeed({ serverId, action }) {
             await ensureDirs();
@@ -195,15 +124,20 @@ export function filePersistence(dir, now = Date.now) {
         async appendFeed({ serverId, action, entry }) {
             await ensureDirs();
             const path = join(feedsDir, `${enc(serverId)}__${enc(action)}.json`);
-            const entries = trimFeedEntries([...((await readJson(path)) ?? []), entry]);
-            await writeJson(path, entries);
-            return entries;
+            const prev = feedLocks.get(path) ?? Promise.resolve();
+            const run = prev.then(async () => {
+                const entries = trimFeedEntries([...((await readJson(path)) ?? []), entry]);
+                await writeJson(path, entries);
+                return entries;
+            });
+            feedLocks.set(path, run.catch(() => undefined));
+            return run;
         },
         async applyLeaderboardIncrements(gameId, entries) {
             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 +145,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);
         },
     };
 }

package/dist/socketIoServer.d.ts

@@ -0,0 +1,21 @@
+import { type HostRouterOptions, type RewoundPosition } from "@jgengine/ws/hostRouter";
+export type { RewoundPosition };
+export type SocketIoLikeServerSocket = {
+    on: (event: string, listener: (payload: string) => void) => unknown;
+    send: (data: string) => unknown;
+    disconnect: (close?: boolean) => unknown;
+};
+export type SocketIoLikeServer = {
+    on: (event: "connection", listener: (socket: SocketIoLikeServerSocket) => void) => unknown;
+};
+export type GameSocketIoServerOptions = HostRouterOptions & {
+    io: SocketIoLikeServer;
+};
+export type GameSocketIoServer = {
+    rewind: (args: {
+        serverId: string;
+        atMs: number;
+    }) => RewoundPosition[];
+    close: () => void;
+};
+export declare function attachGameSocketIoServer(options: GameSocketIoServerOptions): GameSocketIoServer;

package/dist/socketIoServer.js

@@ -0,0 +1,16 @@
+import { createHostRouter } from "@jgengine/ws/hostRouter";
+export function attachGameSocketIoServer(options) {
+    const router = createHostRouter(options);
+    options.io.on("connection", (socket) => {
+        const connection = router.connect({
+            send: (data) => socket.send(data),
+            close: () => socket.disconnect(true),
+        });
+        socket.on("message", (raw) => connection.handleRaw(raw));
+        socket.on("disconnect", () => connection.close());
+    });
+    return {
+        rewind: router.rewind,
+        close: () => router.close(),
+    };
+}

package/dist/webHandler.d.ts

@@ -0,0 +1,5 @@
+import type { IncomingMessage, ServerResponse } from "node:http";
+export type WebHandler = (request: Request) => Promise<Response>;
+export type NodeHandler = (req: IncomingMessage, res: ServerResponse) => void;
+export declare function toWebRequest(req: IncomingMessage): Promise<Request>;
+export declare function toNodeHandler(handler: WebHandler): NodeHandler;

package/dist/webHandler.js

@@ -0,0 +1,40 @@
+export async function toWebRequest(req) {
+    const host = req.headers.host ?? "localhost";
+    const headers = new Headers();
+    for (const [key, value] of Object.entries(req.headers)) {
+        if (typeof value === "string")
+            headers.set(key, value);
+        else if (Array.isArray(value))
+            for (const entry of value)
+                headers.append(key, entry);
+    }
+    const method = req.method ?? "GET";
+    let body;
+    if (method !== "GET" && method !== "HEAD") {
+        const chunks = [];
+        for await (const chunk of req)
+            chunks.push(chunk);
+        if (chunks.length > 0) {
+            const buffer = Buffer.concat(chunks);
+            if (buffer.byteLength > 0)
+                body = Uint8Array.from(buffer);
+        }
+    }
+    return new Request(`http://${host}${req.url ?? "/"}`, { method, headers, body });
+}
+export function toNodeHandler(handler) {
+    return (req, res) => {
+        void toWebRequest(req)
+            .then(handler)
+            .then(async (response) => {
+            res.statusCode = response.status;
+            response.headers.forEach((value, key) => res.setHeader(key, value));
+            res.end(Buffer.from(await response.arrayBuffer()));
+        })
+            .catch((error) => {
+            res.statusCode = 500;
+            res.setHeader("content-type", "application/json");
+            res.end(JSON.stringify({ error: error instanceof Error ? error.message : "internal error" }));
+        });
+    };
+}

package/dist/wsServer.d.ts

@@ -1,25 +1,11 @@
 import type { Server as HttpServer } from "node:http";
 import { WebSocketServer } from "ws";
-import type { PoseSyncRules } from "@jgengine/core/multiplayer/presenceModel";
-import type { GameHost } from "./host.js";
-export type GameWsServerOptions = {
-    host: GameHost;
+import { type HostRouterOptions, type RewoundPosition } from "@jgengine/ws/hostRouter";
+export type { RewoundPosition };
+export type GameWsServerOptions = HostRouterOptions & {
     server?: HttpServer;
     port?: number;
     path?: string;
-    authenticate?: (args: {
-        userId: string;
-        token?: string;
-    }) => Promise<string | null> | string | null;
-    poseRules?: PoseSyncRules;
-    positionHistoryMs?: number;
-    now?: () => number;
-};
-export type RewoundPosition = {
-    userId: string;
-    x: number;
-    y: number;
-    z: number;
 };
 export type GameWsServer = {
     wss: WebSocketServer;

package/dist/wsServer.js

@@ -1,256 +1,21 @@
 import { WebSocketServer } from "ws";
-import { decidePoseSync } from "@jgengine/core/multiplayer/presenceModel";
-import { createPositionHistory } from "@jgengine/core/multiplayer/lagCompensation";
-import { decodeWsClientMessage, encodeWsMessage, subscriptionKey, } from "@jgengine/ws/protocol";
-const DEFAULT_POSE_RULES = {
-    maxSpeed: 12,
-    maxVerticalOffset: 3,
-    minElapsedSec: 0.05,
-    maxElapsedSec: 0.5,
-    keepAliveRefreshMs: 10_000,
-};
+import { createHostRouter } from "@jgengine/ws/hostRouter";
 export function createGameWsServer(options) {
-    const host = options.host;
-    const now = options.now ?? Date.now;
-    const poseRules = options.poseRules ?? DEFAULT_POSE_RULES;
-    const authenticate = options.authenticate ?? (({ userId }) => userId);
+    const router = createHostRouter(options);
     const wss = options.server !== undefined
         ? new WebSocketServer({ server: options.server, path: options.path })
         : new WebSocketServer({ port: options.port ?? 0, path: options.path });
-    const connections = new Set();
-    const presence = new Map();
-    const positionHistoryMs = options.positionHistoryMs ?? 1_000;
-    const histories = new Map();
-    const historyFor = (serverId) => {
-        let history = histories.get(serverId);
-        if (history === undefined) {
-            history = createPositionHistory({ historyMs: positionHistoryMs });
-            histories.set(serverId, history);
-        }
-        return history;
-    };
-    const send = (connection, message) => {
-        if (connection.socket.readyState !== connection.socket.OPEN)
-            return;
-        connection.socket.send(encodeWsMessage(message));
-    };
-    const reply = (connection, id, result) => {
-        send(connection, { v: 1, t: "reply", id, ok: true, result });
-    };
-    const replyError = (connection, id, reason) => {
-        send(connection, { v: 1, t: "reply", id, ok: false, reason });
-    };
-    const presenceRows = (serverId) => {
-        const rows = presence.get(serverId);
-        if (rows === undefined)
-            return [];
-        return [...rows.entries()].map(([userId, pose]) => ({
-            userId,
-            position: pose.position,
-            rotationY: pose.rotationY,
-            rotationPitch: pose.rotationPitch ?? 0,
-            lastSeenAt: pose.lastSeenAtMs ?? 0,
-        }));
-    };
-    const broadcastPresence = (serverId) => {
-        const key = subscriptionKey("presence", serverId);
-        const data = presenceRows(serverId);
-        for (const connection of connections) {
-            if (!connection.subscriptions.has(key))
-                continue;
-            send(connection, { v: 1, t: "update", channel: "presence", serverId, data });
-        }
-    };
-    const pushSubscription = async (connection, channel, serverId, action) => {
-        if (connection.userId === null)
-            return;
-        if (channel === "server") {
-            const data = await host.getServerView({ userId: connection.userId, serverId });
-            send(connection, { v: 1, t: "update", channel, serverId, data });
-        }
-        else if (channel === "player") {
-            const data = await host.getPlayerView({ userId: connection.userId, serverId });
-            send(connection, { v: 1, t: "update", channel, serverId, data });
-        }
-        else if (channel === "feed") {
-            const data = await host.getFeed({ userId: connection.userId, serverId, action: action ?? "" });
-            send(connection, { v: 1, t: "update", channel, serverId, action: action ?? "", data });
-        }
-        else {
-            send(connection, { v: 1, t: "update", channel, serverId, data: presenceRows(serverId) });
-        }
-    };
-    const onHostEvent = (event) => {
-        for (const connection of connections) {
-            if (connection.userId === null)
-                continue;
-            if (event.type === "server") {
-                if (connection.subscriptions.has(subscriptionKey("server", event.serverId))) {
-                    void pushSubscription(connection, "server", event.serverId);
-                }
-            }
-            else if (event.type === "player") {
-                if (connection.userId === event.userId &&
-                    connection.subscriptions.has(subscriptionKey("player", event.serverId))) {
-                    void pushSubscription(connection, "player", event.serverId);
-                }
-            }
-            else {
-                if (connection.subscriptions.has(subscriptionKey("feed", event.serverId, event.action))) {
-                    void pushSubscription(connection, "feed", event.serverId, event.action);
-                }
-            }
-        }
-    };
-    const unsubscribeHost = host.subscribe(onHostEvent);
-    const handlePose = (connection, serverId, pose) => {
-        if (connection.userId === null)
-            return;
-        const rows = presence.get(serverId) ?? new Map();
-        presence.set(serverId, rows);
-        const timestamp = now();
-        const current = rows.get(connection.userId);
-        if (current === undefined) {
-            rows.set(connection.userId, {
-                position: { x: pose.x, y: pose.y, z: pose.z },
-                rotationY: pose.rotationY,
-                rotationPitch: pose.rotationPitch,
-                lastSeenAtMs: timestamp,
-            });
-            historyFor(serverId).record(connection.userId, timestamp, { x: pose.x, y: pose.y, z: pose.z });
-            broadcastPresence(serverId);
-            return;
-        }
-        const decision = decidePoseSync(current, { position: { x: pose.x, y: pose.y, z: pose.z }, rotationY: pose.rotationY, rotationPitch: pose.rotationPitch }, poseRules, timestamp);
-        if (decision.changed || decision.refreshKeepAlive) {
-            rows.set(connection.userId, {
-                position: decision.position,
-                rotationY: decision.rotationY,
-                rotationPitch: decision.rotationPitch,
-                lastSeenAtMs: timestamp,
-            });
-            historyFor(serverId).record(connection.userId, timestamp, decision.position);
-        }
-        if (decision.changed)
-            broadcastPresence(serverId);
-    };
-    const dropPresence = (connection) => {
-        if (connection.userId === null)
-            return;
-        for (const [serverId, rows] of presence) {
-            if (rows.delete(connection.userId)) {
-                if (rows.size === 0)
-                    presence.delete(serverId);
-                broadcastPresence(serverId);
-            }
-        }
-    };
-    const handleMessage = async (connection, message) => {
-        if (message.t === "hello") {
-            const userId = await authenticate({ userId: message.userId, token: message.token });
-            if (userId === null) {
-                replyError(connection, message.id, "Not authenticated");
-                connection.socket.close();
-                return;
-            }
-            connection.userId = userId;
-            reply(connection, message.id, { userId });
-            return;
-        }
-        if (message.t === "pose") {
-            handlePose(connection, message.serverId, message.pose);
-            return;
-        }
-        if (connection.userId === null) {
-            replyError(connection, message.id, "Not authenticated");
-            return;
-        }
-        const userId = connection.userId;
-        try {
-            switch (message.t) {
-                case "join": {
-                    const result = await host.joinServer({
-                        userId,
-                        gameId: message.gameId,
-                        serverId: message.serverId,
-                        attributes: message.attributes,
-                    });
-                    reply(connection, message.id, result);
-                    return;
-                }
-                case "joinByCode": {
-                    const result = await host.joinByCode({
-                        userId,
-                        gameId: message.gameId,
-                        code: message.code,
-                    });
-                    reply(connection, message.id, result);
-                    return;
-                }
-                case "browse": {
-                    const result = await host.browseServers({
-                        gameId: message.gameId,
-                        filter: message.filter,
-                        limit: message.limit,
-                    });
-                    reply(connection, message.id, result);
-                    return;
-                }
-                case "leave": {
-                    await host.leaveServer({ userId, serverId: message.serverId });
-                    reply(connection, message.id, null);
-                    return;
-                }
-                case "runCommand": {
-                    const result = await host.runCommand({
-                        userId,
-                        serverId: message.serverId,
-                        command: message.command,
-                        input: message.input,
-                    });
-                    reply(connection, message.id, result);
-                    return;
-                }
-                case "pushFeed": {
-                    await host.pushFeedEntry({
-                        userId,
-                        serverId: message.serverId,
-                        action: message.action,
-                        entry: message.entry,
-                    });
-                    reply(connection, message.id, null);
-                    return;
-                }
-                case "subscribe": {
-                    connection.subscriptions.add(subscriptionKey(message.channel, message.serverId, message.action));
-                    reply(connection, message.id, null);
-                    await pushSubscription(connection, message.channel, message.serverId, message.action);
-                    return;
-                }
-                case "unsubscribe": {
-                    connection.subscriptions.delete(subscriptionKey(message.channel, message.serverId, message.action));
-                    reply(connection, message.id, null);
-                    return;
-                }
-            }
-        }
-        catch (error) {
-            replyError(connection, message.id, error instanceof Error ? error.message : "Internal error");
-        }
-    };
     wss.on("connection", (socket) => {
-        const connection = { socket, userId: null, subscriptions: new Set() };
-        connections.add(connection);
-        socket.on("message", (raw) => {
-            const message = decodeWsClientMessage(raw.toString());
-            if (message === null)
-                return;
-            void handleMessage(connection, message);
-        });
-        socket.on("close", () => {
-            connections.delete(connection);
-            dropPresence(connection);
+        const connection = router.connect({
+            send: (data) => {
+                if (socket.readyState !== socket.OPEN)
+                    return;
+                socket.send(data);
+            },
+            close: () => socket.close(),
         });
+        socket.on("message", (raw) => connection.handleRaw(raw.toString()));
+        socket.on("close", () => connection.close());
     });
     return {
         wss,
@@ -261,23 +26,11 @@ export function createGameWsServer(options) {
             }
             return address.port;
         },
-        rewind: ({ serverId, atMs }) => {
-            const history = histories.get(serverId);
-            if (history === undefined)
-                return [];
-            const positions = [];
-            for (const userId of history.entities()) {
-                const sample = history.sampleAt(userId, atMs);
-                if (sample !== null) {
-                    positions.push({ userId, x: sample.x, y: sample.y, z: sample.z });
-                }
-            }
-            return positions;
-        },
+        rewind: router.rewind,
         close: () => new Promise((resolve) => {
-            unsubscribeHost();
-            for (const connection of connections) {
-                connection.socket.terminate();
+            router.close();
+            for (const client of wss.clients) {
+                client.terminate();
             }
             let settled = false;
             const finish = () => {