@series-inc/rundot-syncplay 5.23.0-beta.7

package/dist/cjs/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/venus-mp-budget.js

@@ -0,0 +1,125 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runVenusMpBudgetLab = runVenusMpBudgetLab;
+const canonical_js_1 = require("./canonical.js");
+const random_js_1 = require("./random.js");
+const sample_lab_js_1 = require("./sample-lab.js");
+function runVenusMpBudgetLab(options) {
+    validateOptions(options);
+    const random = new random_js_1.DeterministicRandom(options.seed);
+    const frames = Array.from({ length: options.framesPerMessage }, (_, frame) => ({
+        frame,
+        inputs: Array.from({ length: options.players }, () => (0, sample_lab_js_1.makeLabInput)(random)),
+    }));
+    const jsonPayload = {
+        type: 'message',
+        msgType: 'rdm.input.v1',
+        data: {
+            startFrame: 0,
+            frames,
+        },
+    };
+    const packedPayloadBytes = frames.reduce((sum, frame) => sum + (0, sample_lab_js_1.packLabInputFrame)(frame.inputs).byteLength, 0);
+    const packedEnvelopeBytes = JSON.stringify({
+        type: 'message',
+        msgType: 'rdm.input-packed.v1',
+        data: {
+            startFrame: 0,
+            frames: options.framesPerMessage,
+            bytes: packedPayloadBytes,
+        },
+    }).length;
+    const jsonMessageBytes = JSON.stringify(jsonPayload).length;
+    const packedMessageBytes = packedEnvelopeBytes + packedPayloadBytes;
+    const messagesPerSecondPerPlayer = options.hz / options.framesPerMessage;
+    const roomInboundMessagesPerSecond = messagesPerSecondPerPlayer * options.players;
+    const withinMaxPlayers = options.players <= options.maxPlayers;
+    const withinRateLimit = roomInboundMessagesPerSecond <= options.rateLimitPerSecond;
+    const jsonWithinMaxMessage = jsonMessageBytes <= options.maxMessageBytes;
+    const packedWithinMaxMessage = packedMessageBytes <= options.maxMessageBytes;
+    let result = 'fail';
+    if (withinMaxPlayers && withinRateLimit && (jsonWithinMaxMessage || packedWithinMaxMessage)) {
+        result = 'pass';
+    }
+    const recommendation = chooseRecommendation({
+        withinMaxPlayers,
+        withinRateLimit,
+        jsonWithinMaxMessage,
+        packedWithinMaxMessage,
+    });
+    const reportWithoutChecksum = {
+        ...options,
+        messagesPerSecondPerPlayer,
+        roomInboundMessagesPerSecond,
+        jsonMessageBytes,
+        packedMessageBytes,
+        jsonWithinMaxMessage,
+        packedWithinMaxMessage,
+        withinRateLimit,
+        withinMaxPlayers,
+        recommendation,
+        result,
+    };
+    return {
+        players: options.players,
+        hz: options.hz,
+        framesPerMessage: options.framesPerMessage,
+        maxPlayers: options.maxPlayers,
+        rateLimitPerSecond: options.rateLimitPerSecond,
+        maxMessageBytes: options.maxMessageBytes,
+        messagesPerSecondPerPlayer: messagesPerSecondPerPlayer.toFixed(2),
+        roomInboundMessagesPerSecond: roomInboundMessagesPerSecond.toFixed(2),
+        jsonMessageBytes,
+        packedMessageBytes,
+        jsonWithinMaxMessage,
+        packedWithinMaxMessage,
+        withinRateLimit,
+        withinMaxPlayers,
+        recommendation,
+        checksum: (0, canonical_js_1.defaultChecksum)(reportWithoutChecksum),
+        result,
+    };
+}
+function chooseRecommendation(config) {
+    const failures = [
+        !config.withinMaxPlayers,
+        !config.withinRateLimit,
+        !config.jsonWithinMaxMessage && !config.packedWithinMaxMessage,
+    ].filter(Boolean).length;
+    if (failures === 0) {
+        return 'pass';
+    }
+    if (failures > 1) {
+        return 'multiple-changes';
+    }
+    if (!config.withinMaxPlayers) {
+        return 'increase-max-players';
+    }
+    if (!config.withinRateLimit) {
+        return 'increase-bundle-size';
+    }
+    return 'compact-payload';
+}
+function validateOptions(options) {
+    if (!Number.isInteger(options.players) || options.players < 1 || options.players > 128) {
+        throw new Error('Venus MP budget players must be between 1 and 128');
+    }
+    if (![10, 20, 30, 60].includes(options.hz)) {
+        throw new Error('Venus MP budget hz must be 10, 20, 30, or 60');
+    }
+    if (!Number.isInteger(options.framesPerMessage) || options.framesPerMessage < 1 || options.framesPerMessage > 60) {
+        throw new Error('Venus MP budget framesPerMessage must be between 1 and 60');
+    }
+    if (!Number.isInteger(options.maxPlayers) || options.maxPlayers < 1) {
+        throw new Error('Venus MP budget maxPlayers must be positive');
+    }
+    if (!Number.isInteger(options.rateLimitPerSecond) || options.rateLimitPerSecond < 1) {
+        throw new Error('Venus MP budget rateLimitPerSecond must be positive');
+    }
+    if (!Number.isInteger(options.maxMessageBytes) || options.maxMessageBytes < 1) {
+        throw new Error('Venus MP budget maxMessageBytes must be positive');
+    }
+    if (!Number.isInteger(options.seed) || options.seed < 0 || options.seed > 0xffff_ffff) {
+        throw new Error('Venus MP budget seed must be a uint32 integer');
+    }
+}

package/dist/cjs/ws-frame.js

@@ -0,0 +1,255 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.webSocketAcceptKey = webSocketAcceptKey;
+exports.encodeWebSocketTextFrame = encodeWebSocketTextFrame;
+exports.encodeWebSocketCloseFrame = encodeWebSocketCloseFrame;
+exports.readWebSocketFrame = readWebSocketFrame;
+exports.startWebSocketServer = startWebSocketServer;
+exports.connectWebSocketClient = connectWebSocketClient;
+const node_crypto_1 = require("node:crypto");
+const node_http_1 = require("node:http");
+const canonical_js_1 = require("./canonical.js");
+/**
+ * Minimal RFC 6455 text-frame codec plus a connection-oriented server/client.
+ *
+ * The engine ships with zero runtime dependencies, so this hand-rolls just enough of the
+ * WebSocket wire format to carry small JSON control messages over a real socket. It supports
+ * unfragmented text frames up to 65535 bytes — sufficient for input/confirmed-input traffic.
+ * `local-ws-adapter.ts` and the M0 networked-authority spike share this codec.
+ */
+const webSocketGuid = '258EAFA5-E914-47DA-95CA-C5AB0DC85B11';
+function webSocketAcceptKey(secWebSocketKey) {
+    return (0, node_crypto_1.createHash)('sha1').update(`${secWebSocketKey}${webSocketGuid}`).digest('base64');
+}
+function encodeWebSocketTextFrame(text) {
+    const payload = (0, canonical_js_1.encodeUtf8)(text);
+    if (payload.byteLength > 65535) {
+        throw new Error('WebSocket text frame exceeds the 65535-byte codec limit');
+    }
+    const headerLength = payload.byteLength < 126 ? 2 : 4;
+    const frame = new Uint8Array(headerLength + payload.byteLength);
+    frame[0] = 0x81;
+    if (payload.byteLength < 126) {
+        frame[1] = payload.byteLength;
+    }
+    else {
+        frame[1] = 126;
+        frame[2] = Math.floor(payload.byteLength / 256);
+        frame[3] = payload.byteLength % 256;
+    }
+    frame.set(payload, headerLength);
+    return frame;
+}
+/** A minimal, bodyless close frame (opcode 0x8, FIN set). */
+function encodeWebSocketCloseFrame() {
+    return new Uint8Array([0x88, 0x00]);
+}
+/**
+ * NEVER throws: this runs inside raw `socket.on('data')` handlers, where an
+ * uncaught throw is not routed to the 'error' listener and takes the process
+ * down — a handful of malformed bytes from any client would be an
+ * unauthenticated crash. Malformed input is reported as `kind: 'invalid'` so
+ * the receive loop can close the connection instead.
+ */
+function readWebSocketFrame(bytes) {
+    if (bytes.byteLength < 2) {
+        return { kind: 'incomplete' };
+    }
+    const opcode = bytes[0] & 0x0f;
+    const masked = (bytes[1] & 0x80) !== 0;
+    // Capture the 7-bit tag BEFORE the 126 branch reassigns `length`: a 127-byte
+    // payload arrives in the 16-bit form and must not trip the 64-bit guard.
+    const lengthTag = bytes[1] & 0x7f;
+    let length = lengthTag;
+    let offset = 2;
+    if (lengthTag === 127) {
+        return { kind: 'invalid', reason: 'unsupported-64-bit-frame-length' };
+    }
+    if (lengthTag === 126) {
+        if (bytes.byteLength < 4) {
+            return { kind: 'incomplete' };
+        }
+        length = bytes[2] * 256 + bytes[3];
+        offset = 4;
+    }
+    const maskBytes = masked ? bytes.slice(offset, offset + 4) : undefined;
+    offset += masked ? 4 : 0;
+    if (bytes.byteLength < offset + length) {
+        return { kind: 'incomplete' };
+    }
+    const payload = bytes.slice(offset, offset + length);
+    if (maskBytes !== undefined) {
+        for (let index = 0; index < payload.byteLength; index += 1) {
+            payload[index] ^= maskBytes[index % 4];
+        }
+    }
+    let text;
+    try {
+        text = (0, canonical_js_1.decodeUtf8)(payload);
+    }
+    catch {
+        return { kind: 'invalid', reason: 'malformed-utf8-payload' };
+    }
+    return { kind: 'frame', frame: { opcode, text, bytesRead: offset + length } };
+}
+async function startWebSocketServer(options) {
+    const path = options.path ?? '/';
+    const server = (0, node_http_1.createServer)((request, response) => {
+        if (request.url === '/health') {
+            response.statusCode = 200;
+            response.setHeader('content-type', 'text/plain');
+            response.end('ok');
+            return;
+        }
+        response.statusCode = 404;
+        response.end('not found');
+    });
+    server.on('upgrade', (request, socket, head) => {
+        if (new URL(request.url ?? '/', 'http://127.0.0.1').pathname !== path) {
+            socket.end('HTTP/1.1 404 Not Found\r\n\r\n');
+            return;
+        }
+        const key = request.headers['sec-websocket-key'];
+        if (typeof key !== 'string') {
+            socket.end('HTTP/1.1 400 Bad Request\r\n\r\n');
+            return;
+        }
+        socket.write([
+            'HTTP/1.1 101 Switching Protocols',
+            'Upgrade: websocket',
+            'Connection: Upgrade',
+            `Sec-WebSocket-Accept: ${webSocketAcceptKey(key)}`,
+            '\r\n',
+        ].join('\r\n'));
+        // The upgraded socket is a net.Socket at runtime; @types/node's upgrade signature omits a
+        // 'close' overload, so narrow it to the small surface this codec actually uses.
+        const connection = createServerConnection(socket);
+        options.onConnection(connection.handle, request);
+        if (head.byteLength > 0) {
+            connection.receive(head);
+        }
+    });
+    await new Promise((resolveListen) => {
+        server.listen(options.port ?? 0, '127.0.0.1', resolveListen);
+    });
+    const address = server.address();
+    if (address === null || typeof address === 'string') {
+        throw new Error('Could not determine WebSocket server port');
+    }
+    const port = address.port;
+    return {
+        port,
+        url: `ws://127.0.0.1:${port}${path}`,
+        close() {
+            return new Promise((resolveClose, rejectClose) => {
+                server.close((error) => (error === undefined ? resolveClose() : rejectClose(error)));
+            });
+        },
+    };
+}
+function createServerConnection(socket) {
+    let pending = new Uint8Array();
+    const messageHandlers = [];
+    const closeHandlers = [];
+    let closed = false;
+    function emitClose() {
+        if (closed) {
+            return;
+        }
+        closed = true;
+        for (const handler of closeHandlers) {
+            handler();
+        }
+    }
+    function receive(chunk) {
+        pending = concatBytes(pending, chunk);
+        let result = readWebSocketFrame(pending);
+        while (result.kind === 'frame') {
+            const frame = result.frame;
+            pending = pending.slice(frame.bytesRead);
+            if (frame.opcode === 0x8) {
+                socket.end(encodeWebSocketCloseFrame());
+                emitClose();
+                return;
+            }
+            if (frame.opcode === 0x1) {
+                const text = frame.text;
+                for (const handler of messageHandlers) {
+                    handler(text);
+                }
+            }
+            result = readWebSocketFrame(pending);
+        }
+        if (result.kind === 'invalid') {
+            // Malformed frame: close the connection instead of crashing the process.
+            socket.end(encodeWebSocketCloseFrame());
+            emitClose();
+        }
+    }
+    socket.on('data', (chunk) => receive(chunk));
+    socket.on('error', () => {
+        socket.destroy();
+        emitClose();
+    });
+    socket.on('close', emitClose);
+    const handle = {
+        send(text) {
+            if (!closed) {
+                socket.write(encodeWebSocketTextFrame(text));
+            }
+        },
+        onMessage(handler) {
+            messageHandlers.push(handler);
+        },
+        onClose(handler) {
+            closeHandlers.push(handler);
+        },
+        close() {
+            if (!closed) {
+                socket.end(encodeWebSocketCloseFrame());
+                emitClose();
+            }
+        },
+    };
+    return { handle, receive };
+}
+async function connectWebSocketClient(url) {
+    const socket = new WebSocket(url);
+    const messageHandlers = [];
+    const closeHandlers = [];
+    socket.addEventListener('message', (event) => {
+        const text = String(event.data);
+        for (const handler of messageHandlers) {
+            handler(text);
+        }
+    });
+    socket.addEventListener('close', () => {
+        for (const handler of closeHandlers) {
+            handler();
+        }
+    });
+    await new Promise((resolveOpen, rejectOpen) => {
+        socket.addEventListener('open', () => resolveOpen(), { once: true });
+        socket.addEventListener('error', () => rejectOpen(new Error(`Could not connect to ${url}`)), { once: true });
+    });
+    return {
+        send(text) {
+            socket.send(text);
+        },
+        onMessage(handler) {
+            messageHandlers.push(handler);
+        },
+        onClose(handler) {
+            closeHandlers.push(handler);
+        },
+        close() {
+            socket.close();
+        },
+    };
+}
+function concatBytes(left, right) {
+    const output = new Uint8Array(left.byteLength + right.byteLength);
+    output.set(left, 0);
+    output.set(right, left.byteLength);
+    return output;
+}

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};