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

package/dist/cjs/local-ws-adapter.js

@@ -0,0 +1,150 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startLocalWebSocketProtocolServer = startLocalWebSocketProtocolServer;
+exports.runLocalWebSocketAdapterTest = runLocalWebSocketAdapterTest;
+const node_http_1 = require("node:http");
+const mock_network_adapter_js_1 = require("./mock-network-adapter.js");
+const ws_frame_js_1 = require("./ws-frame.js");
+async function startLocalWebSocketProtocolServer(port) {
+    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 !== '/protocol') {
+            socket.end('HTTP/1.1 404 Not Found\r\n\r\n');
+            return;
+        }
+        acceptWebSocket(request, socket);
+        const connection = createLocalProtocolConnection(socket);
+        if (head.byteLength > 0) {
+            connection.receive(head);
+        }
+    });
+    await new Promise((resolveListen) => {
+        server.listen(port, '127.0.0.1', resolveListen);
+    });
+    const actualPort = serverPort(server);
+    return {
+        port: actualPort,
+        healthUrl: `http://127.0.0.1:${actualPort}/health`,
+        url: `ws://127.0.0.1:${actualPort}/protocol`,
+        close() {
+            return new Promise((resolveClose, rejectClose) => {
+                server.close((error) => {
+                    if (error !== undefined) {
+                        rejectClose(error);
+                        return;
+                    }
+                    resolveClose();
+                });
+            });
+        },
+    };
+}
+async function runLocalWebSocketAdapterTest(options) {
+    const socket = new WebSocket(options.url);
+    const request = {
+        kind: 'run-protocol',
+        options: options.protocolOptions,
+    };
+    await new Promise((resolveOpen, rejectOpen) => {
+        socket.addEventListener('open', () => resolveOpen(), { once: true });
+        socket.addEventListener('error', () => rejectOpen(new Error(`Could not connect to ${options.url}`)), { once: true });
+    });
+    const response = new Promise((resolveMessage, rejectMessage) => {
+        socket.addEventListener('message', (event) => {
+            try {
+                resolveMessage(JSON.parse(String(event.data)));
+            }
+            catch (error) {
+                rejectMessage(error);
+            }
+            finally {
+                socket.close();
+            }
+        }, { once: true });
+        socket.addEventListener('error', () => rejectMessage(new Error(`WebSocket error from ${options.url}`)), { once: true });
+    });
+    socket.send(JSON.stringify(request));
+    return response;
+}
+function acceptWebSocket(request, socket) {
+    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: ${(0, ws_frame_js_1.webSocketAcceptKey)(key)}`,
+        '\r\n',
+    ].join('\r\n'));
+}
+function createLocalProtocolConnection(socket) {
+    let pending = new Uint8Array();
+    socket.on('data', (chunk) => {
+        receive(chunk);
+    });
+    socket.on('error', () => {
+        socket.destroy();
+    });
+    function receive(chunk) {
+        pending = concatBytes(pending, chunk);
+        let result = (0, ws_frame_js_1.readWebSocketFrame)(pending);
+        while (result.kind === 'frame') {
+            const frame = result.frame;
+            pending = pending.slice(frame.bytesRead);
+            if (frame.opcode === 8) {
+                socket.end((0, ws_frame_js_1.encodeWebSocketCloseFrame)());
+                return;
+            }
+            if (frame.opcode === 1) {
+                handleProtocolText(socket, frame.text);
+            }
+            result = (0, ws_frame_js_1.readWebSocketFrame)(pending);
+        }
+        if (result.kind === 'invalid') {
+            // Malformed frame: close the connection instead of crashing the process.
+            socket.end((0, ws_frame_js_1.encodeWebSocketCloseFrame)());
+        }
+    }
+    return { receive };
+}
+function handleProtocolText(socket, text) {
+    try {
+        const request = JSON.parse(text);
+        if (request.kind !== 'run-protocol') {
+            throw new Error('Unsupported local WebSocket request');
+        }
+        const replay = (0, mock_network_adapter_js_1.createDeterministicMockNetworkAdapter)(request.options).exportReplay();
+        socket.write((0, ws_frame_js_1.encodeWebSocketTextFrame)(JSON.stringify(replay)));
+    }
+    catch (error) {
+        socket.write((0, ws_frame_js_1.encodeWebSocketTextFrame)(JSON.stringify({
+            kind: 'error',
+            message: error instanceof Error ? error.message : String(error),
+        })));
+    }
+}
+function concatBytes(left, right) {
+    const output = new Uint8Array(left.byteLength + right.byteLength);
+    output.set(left, 0);
+    output.set(right, left.byteLength);
+    return output;
+}
+function serverPort(server) {
+    const address = server.address();
+    if (address === null || typeof address === 'string') {
+        throw new Error('Could not determine local WebSocket server port');
+    }
+    return address.port;
+}

package/dist/cjs/match-log.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.verifyScoredMatchLog = verifyScoredMatchLog;
+exports.matchLogSessionFactory = matchLogSessionFactory;
+const offline_session_js_1 = require("./offline-session.js");
+const canonical_js_1 = require("./canonical.js");
+function verifyScoredMatchLog(config) {
+    const { log } = config;
+    // The log must be the complete, gap-free tick 0..confirmedThrough sequence —
+    // a truncated or reordered log must never verify a score.
+    if (log.frames.length !== log.confirmedThrough + 1 || log.frames.some((frame, index) => frame.tick !== index)) {
+        return { ok: false, reason: 'log-not-contiguous', submittedScore: config.submittedScore, framesReplayed: 0 };
+    }
+    const session = config.createSession({ seed: log.seed, playerCount: log.playerCount });
+    for (const frame of log.frames) {
+        for (let slot = 0; slot < log.playerCount; slot += 1) {
+            session.setInput(slot, config.decodeInput(frame.inputs[slot]));
+        }
+        session.stepFrames(1);
+    }
+    const finalChecksum = String((0, canonical_js_1.defaultChecksum)(session.getState()));
+    if (config.expectedFinalChecksum !== undefined && finalChecksum !== config.expectedFinalChecksum) {
+        return {
+            ok: false,
+            reason: 'checksum-mismatch',
+            submittedScore: config.submittedScore,
+            framesReplayed: log.frames.length,
+            finalChecksum,
+        };
+    }
+    const replayScore = config.extractScore(session.getState());
+    if (replayScore !== config.submittedScore) {
+        return {
+            ok: false,
+            reason: 'score-mismatch',
+            replayScore,
+            submittedScore: config.submittedScore,
+            framesReplayed: log.frames.length,
+            finalChecksum,
+        };
+    }
+    return {
+        ok: true,
+        replayScore,
+        submittedScore: config.submittedScore,
+        framesReplayed: log.frames.length,
+        finalChecksum,
+    };
+}
+/**
+ * Convenience: build the verifier's session factory from a full
+ * DeterministicSessionConfig (creators usually have one of these), overriding
+ * seed/playerCount from the log.
+ */
+function matchLogSessionFactory(base) {
+    return ({ seed, playerCount }) => (0, offline_session_js_1.createOfflineSession)({
+        ...base,
+        randomSeed: seed,
+        playerCount,
+    });
+}

package/dist/cjs/math.js

@@ -0,0 +1,157 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createDeterministicMath = createDeterministicMath;
+const DEFAULT_MIN_FIXED = -2_147_483_648;
+const DEFAULT_MAX_FIXED = 2_147_483_647;
+function createDeterministicMath(fixedScale = 1_000, minFixed = DEFAULT_MIN_FIXED, maxFixed = DEFAULT_MAX_FIXED) {
+    if (!Number.isInteger(fixedScale) || fixedScale <= 0) {
+        throw new Error('fixedScale must be a positive integer');
+    }
+    if (!Number.isInteger(minFixed) || !Number.isInteger(maxFixed) || minFixed >= maxFixed) {
+        throw new Error('fixed range must be integer min < max');
+    }
+    return {
+        fixedScale,
+        minFixed,
+        maxFixed,
+        toFixed(value) {
+            if (!Number.isFinite(value)) {
+                throw new Error('Cannot convert a non-finite number to fixed point');
+            }
+            // normalizeZero: Math.round of a tiny negative yields -0, which the
+            // canonical layer tags as {$rdm:'negative-zero'} — keep -0 out of state.
+            return normalizeZero(saturate(Math.round(value * fixedScale), minFixed, maxFixed));
+        },
+        fromFixed(value) {
+            if (!Number.isInteger(value)) {
+                throw new Error('Fixed point values must be integers');
+            }
+            return value / fixedScale;
+        },
+        add(a, b) {
+            assertFixed(a);
+            assertFixed(b);
+            const result = a + b;
+            if (result < minFixed || result > maxFixed) {
+                throw new Error('Fixed point addition overflow');
+            }
+            return result;
+        },
+        sub(a, b) {
+            assertFixed(a);
+            assertFixed(b);
+            const result = a - b;
+            if (result < minFixed || result > maxFixed) {
+                throw new Error('Fixed point subtraction overflow');
+            }
+            return result;
+        },
+        // Exactness bound: the a*b intermediate is an IEEE double, so results are
+        // deterministic everywhere (correctly-rounded *), but INTEGER-EXACT only
+        // while |a*b| <= 2^53 — at the default fixedScale 1000 that is operands up
+        // to ~95k real units each. Beyond that the product quietly loses low bits
+        // (identically on every peer). Keep gameplay magnitudes inside the bound
+        // or use a larger fixedScale with smaller ranges. div has the same bound
+        // via a*fixedScale.
+        mul(a, b) {
+            assertFixed(a);
+            assertFixed(b);
+            return normalizeZero(saturate(Math.trunc((a * b) / fixedScale), minFixed, maxFixed));
+        },
+        div(a, b) {
+            assertFixed(a);
+            assertFixed(b);
+            if (b === 0) {
+                throw new Error('Fixed point division by zero');
+            }
+            return normalizeZero(saturate(Math.trunc((a * fixedScale) / b), minFixed, maxFixed));
+        },
+        saturatingAdd(a, b) {
+            assertFixed(a);
+            assertFixed(b);
+            return saturate(a + b, minFixed, maxFixed);
+        },
+        saturatingSub(a, b) {
+            assertFixed(a);
+            assertFixed(b);
+            return saturate(a - b, minFixed, maxFixed);
+        },
+        quantize(value, engine) {
+            assertFixed(value);
+            if (!Number.isInteger(engine) || engine <= 0) {
+                throw new Error('engine must be a positive integer');
+            }
+            return Math.trunc(value / engine) * engine;
+        },
+        sinTurns(turns) {
+            assertFixed(turns);
+            return trigLookup(turns, fixedScale, 'sin');
+        },
+        cosTurns(turns) {
+            assertFixed(turns);
+            return trigLookup(turns, fixedScale, 'cos');
+        },
+        vec2(x, y) {
+            assertFixed(x);
+            assertFixed(y);
+            return { x, y };
+        },
+        vec2Add(a, b) {
+            return {
+                x: saturate(a.x + b.x, minFixed, maxFixed),
+                y: saturate(a.y + b.y, minFixed, maxFixed),
+            };
+        },
+        vec2Lerp(a, b, t) {
+            assertFixed(t);
+            return {
+                x: normalizeZero(a.x + Math.trunc(((b.x - a.x) * t) / fixedScale)),
+                y: normalizeZero(a.y + Math.trunc(((b.y - a.y) * t) / fixedScale)),
+            };
+        },
+        quatFromYawTurns(turns) {
+            assertFixed(turns);
+            const halfTurns = Math.trunc(turns / 2);
+            return {
+                x: 0,
+                y: 0,
+                z: normalizeZero(trigLookup(halfTurns, fixedScale, 'sin')),
+                w: normalizeZero(trigLookup(halfTurns, fixedScale, 'cos')),
+            };
+        },
+        quatLerp(a, b, t) {
+            assertFixed(t);
+            return {
+                x: a.x + Math.trunc(((b.x - a.x) * t) / fixedScale),
+                y: a.y + Math.trunc(((b.y - a.y) * t) / fixedScale),
+                z: a.z + Math.trunc(((b.z - a.z) * t) / fixedScale),
+                w: a.w + Math.trunc(((b.w - a.w) * t) / fixedScale),
+            };
+        },
+        clamp(value, min, max) {
+            return Math.min(max, Math.max(min, value));
+        },
+    };
+}
+function assertFixed(value) {
+    if (!Number.isInteger(value)) {
+        throw new Error('Fixed point values must be integers');
+    }
+}
+function saturate(value, min, max) {
+    return Math.min(max, Math.max(min, value));
+}
+function trigLookup(turns, fixedScale, op) {
+    const normalized = ((turns % fixedScale) + fixedScale) % fixedScale;
+    const quadrant = Math.trunc((normalized * 4) / fixedScale) % 4;
+    const offset = normalized - Math.trunc((quadrant * fixedScale) / 4);
+    const ramp = Math.trunc((offset * fixedScale * 4) / fixedScale);
+    const sin = quadrant === 0 ? ramp : quadrant === 1 ? fixedScale - ramp : quadrant === 2 ? -ramp : -fixedScale + ramp;
+    if (op === 'sin') {
+        return normalizeZero(sin);
+    }
+    return trigLookup(normalized + Math.trunc(fixedScale / 4), fixedScale, 'sin');
+}
+function normalizeZero(value) {
+    return Object.is(value, -0) ? 0 : value;
+}

package/dist/cjs/mock-network-adapter.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createDeterministicMockNetworkAdapter = createDeterministicMockNetworkAdapter;
+const canonical_js_1 = require("./canonical.js");
+const protocol_lab_js_1 = require("./protocol-lab.js");
+function createDeterministicMockNetworkAdapter(options) {
+    const stableOptions = (0, canonical_js_1.cloneCanonical)(options);
+    let result;
+    return {
+        options: stableOptions,
+        run() {
+            result = (0, protocol_lab_js_1.runProtocolRollbackLab)(stableOptions);
+            return (0, canonical_js_1.cloneCanonical)(result);
+        },
+        exportReplay() {
+            const replayResult = result ?? (0, protocol_lab_js_1.runProtocolRollbackLab)(stableOptions);
+            result = replayResult;
+            return {
+                formatVersion: 1,
+                kind: 'deterministic-mock-network',
+                options: (0, canonical_js_1.cloneCanonical)(stableOptions),
+                result: (0, canonical_js_1.cloneCanonical)(replayResult),
+            };
+        },
+    };
+}