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

package/dist/cjs/networked-input-authority.js

@@ -0,0 +1,443 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultNetworkedInputAuthoritySpikeOptions = void 0;
+exports.runNetworkedInputAuthoritySpike = runNetworkedInputAuthoritySpike;
+const canonical_js_1 = require("./canonical.js");
+const errors_js_1 = require("./errors.js");
+const input_authority_js_1 = require("./input-authority.js");
+const replay_js_1 = require("./replay.js");
+const session_wire_js_1 = require("./session-wire.js");
+const sample_lab_js_1 = require("./sample-lab.js");
+const ws_frame_js_1 = require("./ws-frame.js");
+exports.defaultNetworkedInputAuthoritySpikeOptions = {
+    players: 2,
+    ticks: 300,
+    seed: 71,
+    hardToleranceTicks: 6,
+    maxPredictionTicks: 8,
+    lossPermille: 80,
+    minDelayTicks: 1,
+    maxDelayTicks: 4,
+    resendWindowTicks: 6,
+    redundancyWindowTicks: 8,
+};
+const TAG_INPUT = 1;
+const TAG_CONFIRM = 2;
+// createLabSession's default tick rate; carried in session-start so a real client could pace itself.
+const SESSION_TICK_RATE_HZ = 30;
+async function runNetworkedInputAuthoritySpike(options) {
+    (0, errors_js_1.invariant)(options.players >= 2, 'spike requires at least two players', 'spike.players');
+    (0, errors_js_1.invariant)(options.ticks >= 1, 'spike requires at least one tick', 'spike.ticks');
+    (0, errors_js_1.invariant)(options.maxDelayTicks >= options.minDelayTicks && options.minDelayTicks >= 0, 'delay bounds must satisfy 0 <= min <= max', 'spike.delay-bounds');
+    const neutralInput = (0, sample_lab_js_1.canonicalizeLabInput)(sample_lab_js_1.labDefaultInput);
+    const authority = (0, input_authority_js_1.createInputAuthority)({
+        playerCount: options.players,
+        hardToleranceTicks: options.hardToleranceTicks,
+        neutralInput,
+        maxFutureTicks: options.maxPredictionTicks + options.hardToleranceTicks + 4,
+        retainedConfirmedFrames: options.ticks + options.redundancyWindowTicks + 8,
+    });
+    const server = await startServer(authority, options);
+    try {
+        const clients = [];
+        for (let slot = 0; slot < options.players; slot += 1) {
+            const connection = await (0, ws_frame_js_1.connectWebSocketClient)(server.url);
+            clients.push(await createSpikeClient(connection, slot, options));
+        }
+        const settleCap = options.ticks + options.hardToleranceTicks + options.maxDelayTicks + 64;
+        let now = 0;
+        let settleRounds = 0;
+        for (; now < settleCap; now += 1) {
+            for (const client of clients) {
+                client.pump(now);
+            }
+            await flush();
+            server.pump(now);
+            await flush();
+            for (const client of clients) {
+                client.drain(now);
+            }
+            const done = clients.every((client) => client.appliedThrough >= options.ticks - 1 && client.predictedThrough >= options.ticks);
+            if (done) {
+                break;
+            }
+            if (now >= options.ticks) {
+                settleRounds += 1;
+            }
+        }
+        const confirmedTick = options.ticks - 1;
+        const converged = clients.every((client) => client.appliedThrough >= confirmedTick && client.predictedThrough >= options.ticks);
+        const clientChecksums = converged ? clients.map((client) => client.confirmedStateChecksum(options.ticks)) : [];
+        const replays = converged ? clients.map((client) => client.exportConfirmedReplay()) : [];
+        const clientReplayChecksums = replays.map((replay) => replayIdentity(replay));
+        const replaysVerified = converged && replays.every((replay) => verifyLabReplay(replay));
+        const checksumsMatch = converged && clientChecksums.every((checksum) => checksum === clientChecksums[0]);
+        const replaysMatch = converged && clientReplayChecksums.every((checksum) => checksum === clientReplayChecksums[0]);
+        // Independent oracle: replay ONLY the authority's confirmed inputs through a clean sim with no
+        // prediction/rollback. Comparing clients against it catches a symmetric rollback bug that would
+        // otherwise leave both clients identically wrong (both consume the same confirmed inputs).
+        const authorityOracleChecksum = converged ? computeAuthorityOracleChecksum(authority, options) : '';
+        const oracleMatch = converged && authorityOracleChecksum !== '' && clientChecksums.every((checksum) => checksum === authorityOracleChecksum);
+        const totalRollbacks = clients.reduce((sum, client) => sum + client.rollbacks, 0);
+        const maxRollbackDepth = clients.reduce((max, client) => Math.max(max, client.maxRollbackDepth), 0);
+        const rollbackDepthSum = clients.reduce((sum, client) => sum + client.rollbackDepthSum, 0);
+        const maxConfirmationLagTicks = clients.reduce((max, client) => Math.max(max, client.maxConfirmationLag), 0);
+        const pass = converged && checksumsMatch && replaysMatch && replaysVerified && oracleMatch;
+        return {
+            players: options.players,
+            ticks: options.ticks,
+            seed: options.seed,
+            converged,
+            confirmedThrough: authority.confirmedThrough,
+            confirmedStateChecksum: clientChecksums[0] ?? '',
+            replayChecksum: clientReplayChecksums[0] ?? '',
+            clientChecksums,
+            clientReplayChecksums,
+            checksumsMatch,
+            replaysMatch,
+            replaysVerified,
+            authorityOracleChecksum,
+            oracleMatch,
+            totalRollbacks,
+            maxRollbackDepth,
+            meanRollbackDepth: totalRollbacks === 0 ? 0 : Number((rollbackDepthSum / totalRollbacks).toFixed(3)),
+            maxConfirmationLagTicks,
+            substitutedInputs: authority.stats().substitutedInputs,
+            droppedInputMessages: server.droppedInputMessages(),
+            droppedConfirmPackets: clients.reduce((sum, client) => sum + client.droppedConfirmPackets, 0),
+            settleRounds,
+            result: pass ? 'pass' : 'fail',
+        };
+    }
+    finally {
+        await server.close();
+    }
+}
+async function startServer(authority, options) {
+    const connections = [];
+    const inbox = [];
+    let nextSlot = 0;
+    let droppedInputs = 0;
+    const handle = await (0, ws_frame_js_1.startWebSocketServer)({
+        path: '/authority',
+        onConnection(connection) {
+            const slot = nextSlot;
+            nextSlot += 1;
+            connections.push(connection);
+            connection.send((0, session_wire_js_1.encodeDeterministicSessionMessage)({
+                kind: 'session-start',
+                slot,
+                playerCount: options.players,
+                seed: options.seed,
+                tickRateHz: SESSION_TICK_RATE_HZ,
+                hardToleranceTicks: options.hardToleranceTicks,
+                role: 'player',
+            }));
+            connection.onMessage((text) => {
+                // Fail closed: malformed or unknown messages are dropped, never coerced.
+                const decoded = (0, session_wire_js_1.decodeDeterministicSessionMessage)(text);
+                if (!decoded.ok || decoded.message.kind !== 'input') {
+                    return;
+                }
+                const { slot: msgSlot, tick, input, attempt } = decoded.message;
+                // Server owns the slot mapping — reject input claiming a slot other than this connection's.
+                if (msgSlot !== slot) {
+                    return;
+                }
+                const roll = networkRoll(options, TAG_INPUT, tick, slot, attempt);
+                if (roll.drop) {
+                    droppedInputs += 1;
+                    return;
+                }
+                inbox.push({ slot, tick, input, releaseAt: tick + roll.delay });
+            });
+        },
+    });
+    return {
+        url: handle.url,
+        pump(now) {
+            for (let index = inbox.length - 1; index >= 0; index -= 1) {
+                const entry = inbox[index];
+                if (entry.releaseAt <= now) {
+                    authority.receiveInput(entry.slot, entry.tick, entry.input);
+                    inbox.splice(index, 1);
+                }
+            }
+            authority.advance(now);
+            const from = Math.max(0, authority.confirmedThrough - options.redundancyWindowTicks + 1);
+            const frames = [];
+            for (let tick = from; tick <= authority.confirmedThrough; tick += 1) {
+                const frame = authority.confirmedFrame(tick);
+                if (frame !== undefined) {
+                    frames.push(frame);
+                }
+            }
+            if (frames.length === 0) {
+                return;
+            }
+            const packet = (0, session_wire_js_1.encodeDeterministicSessionMessage)({ kind: 'confirmed-input', authorityTick: now, frames });
+            for (const connection of connections) {
+                connection.send(packet);
+            }
+        },
+        droppedInputMessages() {
+            return droppedInputs;
+        },
+        async close() {
+            for (const connection of connections) {
+                connection.close();
+            }
+            await handle.close();
+        },
+    };
+}
+async function createSpikeClient(connection, slot, options) {
+    const session = (0, sample_lab_js_1.createLabSession)({ players: options.players, seed: options.seed, snapshotBufferSize: Math.max(256, options.ticks + 16) });
+    const timeline = [];
+    const ownInputs = new Map();
+    const confirmed = new Map();
+    const lastConfirmedBySlot = Array.from({ length: options.players }, () => (0, sample_lab_js_1.canonicalizeLabInput)(sample_lab_js_1.labDefaultInput));
+    const sendAttempts = new Map();
+    const inbox = [];
+    let predictedThrough = 0;
+    let appliedThrough = -1;
+    let rollbacks = 0;
+    let maxRollbackDepth = 0;
+    let rollbackDepthSum = 0;
+    let maxConfirmationLag = 0;
+    let droppedConfirmPackets = 0;
+    await new Promise((resolveWelcome) => {
+        connection.onMessage((text) => {
+            const decoded = (0, session_wire_js_1.decodeDeterministicSessionMessage)(text);
+            if (!decoded.ok) {
+                return;
+            }
+            const message = decoded.message;
+            if (message.kind === 'session-start') {
+                resolveWelcome();
+                return;
+            }
+            if (message.kind === 'confirmed-input') {
+                const roll = networkRoll(options, TAG_CONFIRM, message.authorityTick, slot, 0);
+                if (roll.drop) {
+                    droppedConfirmPackets += 1;
+                    return;
+                }
+                inbox.push({ frames: message.frames, releaseAt: message.authorityTick + roll.delay, authorityNow: message.authorityTick });
+            }
+        });
+    });
+    function ensureOwnInput(tick) {
+        let own = ownInputs.get(tick);
+        if (own === undefined) {
+            own = ownInputForTick(options.seed, slot, tick);
+            ownInputs.set(tick, own);
+        }
+        return own;
+    }
+    function predictedInputForSlot(targetSlot, tick) {
+        // A confirmed tick is authoritative for every slot — including our own, whose real input
+        // the authority may have substituted (repeated) when it never arrived in time.
+        const conf = confirmed.get(tick);
+        if (conf !== undefined) {
+            return conf[targetSlot];
+        }
+        if (targetSlot === slot) {
+            return ensureOwnInput(tick);
+        }
+        return lastConfirmedBySlot[targetSlot];
+    }
+    function simulateTick(tick) {
+        const inputs = [];
+        for (let s = 0; s < options.players; s += 1) {
+            const input = predictedInputForSlot(s, tick);
+            inputs.push(input);
+            session.setInput(s, decodeLabInput(input));
+        }
+        timeline[tick] = inputs;
+        session.stepFrames(1);
+    }
+    function resimulateFrom(tick) {
+        // Frame/tick invariant: session snapshot at frame N is the state BEFORE tick N's inputs (after
+        // ticks 0..N-1). restoreToFrame(tick) leaves the session ready to re-apply tick `tick` onward.
+        session.restoreToFrame(tick);
+        for (let t = tick; t < predictedThrough; t += 1) {
+            const inputs = [];
+            for (let s = 0; s < options.players; s += 1) {
+                const input = predictedInputForSlot(s, t);
+                inputs.push(input);
+                session.setInput(s, decodeLabInput(input));
+            }
+            timeline[t] = inputs;
+            session.stepFrames(1);
+        }
+    }
+    function pump(now) {
+        while (predictedThrough < options.ticks && predictedThrough <= appliedThrough + options.maxPredictionTicks) {
+            const tick = predictedThrough;
+            const own = ensureOwnInput(tick);
+            simulateTick(tick);
+            predictedThrough = tick + 1;
+            sendInput(tick, own);
+        }
+        const resendFrom = Math.max(appliedThrough + 1, predictedThrough - options.resendWindowTicks);
+        for (let tick = resendFrom; tick < predictedThrough; tick += 1) {
+            const own = ownInputs.get(tick);
+            if (own !== undefined) {
+                sendInput(tick, own);
+            }
+        }
+    }
+    function sendInput(tick, input) {
+        const attempt = sendAttempts.get(tick) ?? 0;
+        sendAttempts.set(tick, attempt + 1);
+        connection.send((0, session_wire_js_1.encodeDeterministicSessionMessage)({ kind: 'input', slot, tick, input, attempt }));
+    }
+    function drain(now) {
+        for (let index = inbox.length - 1; index >= 0; index -= 1) {
+            const packet = inbox[index];
+            if (packet.releaseAt > now) {
+                continue;
+            }
+            inbox.splice(index, 1);
+            for (const frame of packet.frames) {
+                if (frame.tick <= appliedThrough) {
+                    continue;
+                }
+                confirmed.set(frame.tick, frame.inputs);
+            }
+            maxConfirmationLag = Math.max(maxConfirmationLag, packet.authorityNow - appliedThrough);
+        }
+        applyConfirmed();
+    }
+    function applyConfirmed() {
+        while (confirmed.has(appliedThrough + 1)) {
+            const tick = appliedThrough + 1;
+            const confInputs = confirmed.get(tick);
+            const predInputs = timeline[tick];
+            if (predInputs === undefined || !equalInputs(confInputs, predInputs)) {
+                const depth = predictedThrough - tick;
+                if (depth > 0) {
+                    rollbacks += 1;
+                    rollbackDepthSum += depth;
+                    maxRollbackDepth = Math.max(maxRollbackDepth, depth);
+                }
+                timeline[tick] = confInputs.slice();
+                if (depth > 0) {
+                    resimulateFrom(tick);
+                }
+                else {
+                    // Confirm leads prediction (a lagging client): the authority confirmed a tick we had not
+                    // predicted yet. Extend the predicted head and step through it so the stepped session keeps
+                    // pace with appliedThrough — mirrors the fix in createNetworkedSyncplayClient.
+                    predictedThrough = tick + 1;
+                    resimulateFrom(tick);
+                }
+            }
+            for (let s = 0; s < options.players; s += 1) {
+                lastConfirmedBySlot[s] = confInputs[s];
+            }
+            appliedThrough = tick;
+        }
+    }
+    return {
+        slot,
+        get predictedThrough() {
+            return predictedThrough;
+        },
+        get appliedThrough() {
+            return appliedThrough;
+        },
+        get rollbacks() {
+            return rollbacks;
+        },
+        get maxRollbackDepth() {
+            return maxRollbackDepth;
+        },
+        get rollbackDepthSum() {
+            return rollbackDepthSum;
+        },
+        get maxConfirmationLag() {
+            return maxConfirmationLag;
+        },
+        get droppedConfirmPackets() {
+            return droppedConfirmPackets;
+        },
+        pump,
+        drain,
+        confirmedStateChecksum(ticks) {
+            session.restoreToFrame(ticks);
+            return String((0, canonical_js_1.defaultChecksum)(session.getState()));
+        },
+        exportConfirmedReplay() {
+            return session.exportReplay();
+        },
+    };
+}
+function computeAuthorityOracleChecksum(authority, options) {
+    const session = (0, sample_lab_js_1.createLabSession)({ players: options.players, seed: options.seed, snapshotBufferSize: options.ticks + 16 });
+    for (let tick = 0; tick < options.ticks; tick += 1) {
+        const frame = authority.confirmedFrame(tick);
+        if (frame === undefined) {
+            return '';
+        }
+        for (let s = 0; s < options.players; s += 1) {
+            session.setInput(s, (0, sample_lab_js_1.hydrateLabInput)(frame.inputs[s]));
+        }
+        session.stepFrames(1);
+    }
+    return String((0, canonical_js_1.defaultChecksum)(session.getState()));
+}
+function ownInputForTick(seed, slot, tick) {
+    const h = mixHash([seed, slot, tick, 0x51ed]);
+    const dx = (h % 3) - 1;
+    const dy = (Math.floor(h / 3) % 3) - 1;
+    const action = (h & 1);
+    return (0, sample_lab_js_1.canonicalizeLabInput)({ dx, dy, action });
+}
+function decodeLabInput(input) {
+    return (0, sample_lab_js_1.hydrateLabInput)(input);
+}
+function equalInputs(left, right) {
+    return (0, canonical_js_1.canonicalStringify)(left) === (0, canonical_js_1.canonicalStringify)(right);
+}
+function replayIdentity(replay) {
+    return String((0, canonical_js_1.defaultChecksum)(replay));
+}
+function verifyLabReplay(replay) {
+    const result = (0, replay_js_1.verifyReplay)({
+        replay,
+        step: sample_lab_js_1.labStep,
+        defaultInput: sample_lab_js_1.labDefaultInput,
+        inputSchemaId: 'lab-input/v1',
+        stateSchemaId: 'lab-state/v1',
+        deterministicVersion: '0.0.0-source',
+        canonicalizeInput: sample_lab_js_1.canonicalizeLabInput,
+        hydrateInput: sample_lab_js_1.hydrateLabInput,
+    });
+    return result.mismatches === 0;
+}
+function networkRoll(options, tag, tick, slot, attempt) {
+    const h = mixHash([options.seed, tag, tick, slot, attempt]);
+    const drop = h % 1000 < options.lossPermille;
+    const span = options.maxDelayTicks - options.minDelayTicks + 1;
+    const delay = options.minDelayTicks + (mixHash([h, 0x9e3779b9]) % span);
+    return { drop, delay };
+}
+// FNV-1a variant with a per-step avalanche, over integer tuples. Used only for the seeded network
+// model (loss/delay) — order-independent so results are reproducible regardless of arrival order.
+function mixHash(values) {
+    let h = 0x811c9dc5;
+    for (const value of values) {
+        h ^= value | 0;
+        h = Math.imul(h, 0x01000193);
+        h ^= h >>> 15;
+    }
+    return h >>> 0;
+}
+// Yields to the event loop (not a timing delay — logical time is the discrete `now` counter) so
+// real loopback WebSocket messages sent this round are delivered before the next round processes them.
+async function flush() {
+    await new Promise((resolve) => setImmediate(resolve));
+    await new Promise((resolve) => setImmediate(resolve));
+}

package/dist/cjs/node.js

@@ -0,0 +1,47 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stableEngineParityJson = exports.runEngineParitySuite = exports.explainEngineParityFixture = exports.runChaosCertificationSuite = exports.explainChaosFixture = exports.startLocalWebSocketProtocolServer = exports.runLocalWebSocketAdapterTest = exports.runNetworkedInputAuthoritySpike = exports.defaultNetworkedInputAuthoritySpikeOptions = exports.verifyReplay = exports.createOfflineSession = void 0;
+__exportStar(require("./multiplayer-service.js"), exports);
+__exportStar(require("./input-authority.js"), exports);
+__exportStar(require("./local-authority-wire.js"), exports);
+__exportStar(require("./session-wire.js"), exports);
+__exportStar(require("./session-snapshot.js"), exports);
+__exportStar(require("./networked-client.js"), exports);
+var offline_session_js_1 = require("./offline-session.js");
+Object.defineProperty(exports, "createOfflineSession", { enumerable: true, get: function () { return offline_session_js_1.createOfflineSession; } });
+__exportStar(require("./instant-replay.js"), exports);
+__exportStar(require("./pause-resume.js"), exports);
+__exportStar(require("./session-promotion.js"), exports);
+var replay_js_1 = require("./replay.js");
+Object.defineProperty(exports, "verifyReplay", { enumerable: true, get: function () { return replay_js_1.verifyReplay; } });
+__exportStar(require("./replay-scoring.js"), exports);
+__exportStar(require("./match-log.js"), exports);
+__exportStar(require("./authority-room.js"), exports);
+__exportStar(require("./ws-frame.js"), exports);
+var networked_input_authority_js_1 = require("./networked-input-authority.js");
+Object.defineProperty(exports, "defaultNetworkedInputAuthoritySpikeOptions", { enumerable: true, get: function () { return networked_input_authority_js_1.defaultNetworkedInputAuthoritySpikeOptions; } });
+Object.defineProperty(exports, "runNetworkedInputAuthoritySpike", { enumerable: true, get: function () { return networked_input_authority_js_1.runNetworkedInputAuthoritySpike; } });
+var local_ws_adapter_js_1 = require("./local-ws-adapter.js");
+Object.defineProperty(exports, "runLocalWebSocketAdapterTest", { enumerable: true, get: function () { return local_ws_adapter_js_1.runLocalWebSocketAdapterTest; } });
+Object.defineProperty(exports, "startLocalWebSocketProtocolServer", { enumerable: true, get: function () { return local_ws_adapter_js_1.startLocalWebSocketProtocolServer; } });
+var chaos_certification_js_1 = require("./chaos-certification.js");
+Object.defineProperty(exports, "explainChaosFixture", { enumerable: true, get: function () { return chaos_certification_js_1.explainChaosFixture; } });
+Object.defineProperty(exports, "runChaosCertificationSuite", { enumerable: true, get: function () { return chaos_certification_js_1.runChaosCertificationSuite; } });
+var engine_parity_js_1 = require("./engine-parity.js");
+Object.defineProperty(exports, "explainEngineParityFixture", { enumerable: true, get: function () { return engine_parity_js_1.explainEngineParityFixture; } });
+Object.defineProperty(exports, "runEngineParitySuite", { enumerable: true, get: function () { return engine_parity_js_1.runEngineParitySuite; } });
+Object.defineProperty(exports, "stableEngineParityJson", { enumerable: true, get: function () { return engine_parity_js_1.stableEngineParityJson; } });

package/dist/cjs/number-lab.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runNumberLab = runNumberLab;
+const canonical_js_1 = require("./canonical.js");
+const random_js_1 = require("./random.js");
+const q16 = 65_536;
+function runNumberLab(options) {
+    validateOptions(options);
+    const random = new random_js_1.DeterministicRandom(options.seed);
+    let state = { value: 0, accumulator: 0, frame: 0 };
+    for (let frame = 0; frame < options.frames; frame += 1) {
+        state = stepNumberLab(options.mode, state, random, frame);
+    }
+    return {
+        mode: options.mode,
+        frames: options.frames,
+        seed: options.seed,
+        finalValue: state.value,
+        finalChecksum: (0, canonical_js_1.defaultChecksum)(state),
+        result: 'pass',
+    };
+}
+function stepNumberLab(mode, state, random, frame) {
+    const signed = random.nextInt(-1000, 1000);
+    if (mode === 'integer') {
+        return {
+            value: state.value + signed,
+            accumulator: state.accumulator + (signed % 17),
+            frame: frame + 1,
+        };
+    }
+    if (mode === 'fixed-q16') {
+        const delta = Math.trunc((signed * q16) / 1000);
+        return {
+            value: state.value + delta,
+            accumulator: state.accumulator + Math.trunc((delta * delta) / q16),
+            frame: frame + 1,
+        };
+    }
+    if (mode === 'quantized-float') {
+        const raw = state.value / 1000 + signed / 1000;
+        const quantized = Math.round(raw * 1000);
+        return {
+            value: quantized,
+            // rdm-ignore-next-line determinism/no-trig-math: number lab intentionally compares quantized float behavior outside gameplay runtime
+            accumulator: state.accumulator + Math.round(Math.sqrt(Math.abs(quantized)) * 1000),
+            frame: frame + 1,
+        };
+    }
+    if (mode === 'raw-float-basic') {
+        const value = state.value + signed / 1000 + 0.1;
+        return {
+            value,
+            accumulator: state.accumulator + value / 3,
+            frame: frame + 1,
+        };
+    }
+    const angle = (frame % 360) * (Math.PI / 180);
+    // rdm-ignore-next-line determinism/no-trig-math: raw-float-math mode intentionally demonstrates host math drift in diagnostics
+    const value = state.value + Math.sin(angle) * (signed / 1000) + Math.sqrt(Math.abs(signed));
+    return {
+        value,
+        // rdm-ignore-next-line determinism/no-trig-math: raw-float-math mode intentionally demonstrates host math drift in diagnostics
+        accumulator: state.accumulator + Math.cos(angle) + Math.atan2(signed, frame + 1),
+        frame: frame + 1,
+    };
+}
+function validateOptions(options) {
+    if (!['integer', 'fixed-q16', 'quantized-float', 'raw-float-basic', 'raw-float-math'].includes(options.mode)) {
+        throw new Error(`Unsupported number lab mode ${options.mode}`);
+    }
+    if (!Number.isInteger(options.frames) || options.frames < 1) {
+        throw new Error('number lab requires at least one frame');
+    }
+    if (!Number.isInteger(options.seed)) {
+        throw new Error('number lab seed must be an integer');
+    }
+}