@jgengine/node 0.7.0 → 0.8.0

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): Request;
+export declare function toNodeHandler(handler: WebHandler): NodeHandler;

package/dist/webHandler.js

@@ -0,0 +1,27 @@
+export 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);
+    }
+    return new Request(`http://${host}${req.url ?? "/"}`, { method: req.method, headers });
+}
+export function toNodeHandler(handler) {
+    return (req, res) => {
+        void handler(toWebRequest(req))
+            .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 = () => {