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

package/dist/networked-input-authority.d.ts

@@ -0,0 +1,51 @@
+/**
+ * M0 networked input-authority spike (§6). De-risks the committed Option 1 architecture:
+ * a game-agnostic input authority orders/confirms inputs from independent remote clients
+ * over a real socket, the server never runs the sim, and each client runs the deterministic
+ * sim with prediction/rollback. Under seeded packet loss and delay, both clients must end at
+ * identical confirmed checksums with self-verifying replays.
+ *
+ * Network conditions are modelled as logical per-tick delay/loss over the real WebSocket so
+ * the spike is reproducible in CI while still forcing the full predict/roll-back/resim loop.
+ */
+export interface NetworkedInputAuthoritySpikeOptions {
+    readonly players: number;
+    readonly ticks: number;
+    readonly seed: number;
+    readonly hardToleranceTicks: number;
+    readonly maxPredictionTicks: number;
+    readonly lossPermille: number;
+    readonly minDelayTicks: number;
+    readonly maxDelayTicks: number;
+    readonly resendWindowTicks: number;
+    readonly redundancyWindowTicks: number;
+}
+export interface NetworkedInputAuthoritySpikeReport {
+    readonly players: number;
+    readonly ticks: number;
+    readonly seed: number;
+    readonly converged: boolean;
+    readonly confirmedThrough: number;
+    readonly confirmedStateChecksum: string;
+    readonly replayChecksum: string;
+    readonly clientChecksums: readonly string[];
+    readonly clientReplayChecksums: readonly string[];
+    readonly checksumsMatch: boolean;
+    readonly replaysMatch: boolean;
+    readonly replaysVerified: boolean;
+    /** Checksum from a clean sim fed only the authority's confirmed inputs — an independent oracle. */
+    readonly authorityOracleChecksum: string;
+    /** True when every client's confirmed state matches the independent oracle (catches symmetric bugs). */
+    readonly oracleMatch: boolean;
+    readonly totalRollbacks: number;
+    readonly maxRollbackDepth: number;
+    readonly meanRollbackDepth: number;
+    readonly maxConfirmationLagTicks: number;
+    readonly substitutedInputs: number;
+    readonly droppedInputMessages: number;
+    readonly droppedConfirmPackets: number;
+    readonly settleRounds: number;
+    readonly result: 'pass' | 'fail';
+}
+export declare const defaultNetworkedInputAuthoritySpikeOptions: NetworkedInputAuthoritySpikeOptions;
+export declare function runNetworkedInputAuthoritySpike(options: NetworkedInputAuthoritySpikeOptions): Promise<NetworkedInputAuthoritySpikeReport>;

package/dist/networked-input-authority.js

@@ -0,0 +1,439 @@
+import { canonicalStringify, defaultChecksum } from './canonical.js';
+import { invariant } from './errors.js';
+import { createInputAuthority, } from './input-authority.js';
+import { verifyReplay } from './replay.js';
+import { decodeDeterministicSessionMessage, encodeDeterministicSessionMessage } from './session-wire.js';
+import { canonicalizeLabInput, createLabSession, hydrateLabInput, labDefaultInput, labStep, } from './sample-lab.js';
+import { connectWebSocketClient, startWebSocketServer, } from './ws-frame.js';
+export const 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;
+export async function runNetworkedInputAuthoritySpike(options) {
+    invariant(options.players >= 2, 'spike requires at least two players', 'spike.players');
+    invariant(options.ticks >= 1, 'spike requires at least one tick', 'spike.ticks');
+    invariant(options.maxDelayTicks >= options.minDelayTicks && options.minDelayTicks >= 0, 'delay bounds must satisfy 0 <= min <= max', 'spike.delay-bounds');
+    const neutralInput = canonicalizeLabInput(labDefaultInput);
+    const authority = 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 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 startWebSocketServer({
+        path: '/authority',
+        onConnection(connection) {
+            const slot = nextSlot;
+            nextSlot += 1;
+            connections.push(connection);
+            connection.send(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 = 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 = 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 = 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 }, () => canonicalizeLabInput(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 = 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(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(defaultChecksum(session.getState()));
+        },
+        exportConfirmedReplay() {
+            return session.exportReplay();
+        },
+    };
+}
+function computeAuthorityOracleChecksum(authority, options) {
+    const session = 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, hydrateLabInput(frame.inputs[s]));
+        }
+        session.stepFrames(1);
+    }
+    return String(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 canonicalizeLabInput({ dx, dy, action });
+}
+function decodeLabInput(input) {
+    return hydrateLabInput(input);
+}
+function equalInputs(left, right) {
+    return canonicalStringify(left) === canonicalStringify(right);
+}
+function replayIdentity(replay) {
+    return String(defaultChecksum(replay));
+}
+function verifyLabReplay(replay) {
+    const result = verifyReplay({
+        replay,
+        step: labStep,
+        defaultInput: labDefaultInput,
+        inputSchemaId: 'lab-input/v1',
+        stateSchemaId: 'lab-state/v1',
+        deterministicVersion: '0.0.0-source',
+        canonicalizeInput: canonicalizeLabInput,
+        hydrateInput: 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/node.d.ts

@@ -0,0 +1,22 @@
+export * from './multiplayer-service.js';
+export * from './input-authority.js';
+export * from './local-authority-wire.js';
+export * from './session-wire.js';
+export * from './session-snapshot.js';
+export * from './networked-client.js';
+export { createOfflineSession } from './offline-session.js';
+export * from './instant-replay.js';
+export * from './pause-resume.js';
+export * from './session-promotion.js';
+export { verifyReplay } from './replay.js';
+export * from './replay-scoring.js';
+export * from './match-log.js';
+export * from './authority-room.js';
+export * from './ws-frame.js';
+export { defaultNetworkedInputAuthoritySpikeOptions, runNetworkedInputAuthoritySpike, type NetworkedInputAuthoritySpikeOptions, type NetworkedInputAuthoritySpikeReport, } from './networked-input-authority.js';
+export { runLocalWebSocketAdapterTest, startLocalWebSocketProtocolServer } from './local-ws-adapter.js';
+export type { LocalWebSocketAdapterTestOptions, LocalWebSocketServer } from './local-ws-adapter.js';
+export { explainChaosFixture, runChaosCertificationSuite } from './chaos-certification.js';
+export type { ChaosCertificationOptions, ChaosCertificationReport, ChaosExpectedResult, ChaosFixtureCategory, ChaosFixtureExplanation, ChaosFixtureReport, } from './chaos-certification.js';
+export { explainEngineParityFixture, runEngineParitySuite, stableEngineParityJson } from './engine-parity.js';
+export type { EngineParityCategory, EngineParityCategoryReport, EngineParityFixtureExplanation, EngineParityMetric, EngineParityMetrics, EngineParityOptions, EngineParityProfile, EngineParityResult, EngineParitySuiteReport, EngineParityTier, } from './engine-parity.js';

package/dist/node.js

@@ -0,0 +1,19 @@
+export * from './multiplayer-service.js';
+export * from './input-authority.js';
+export * from './local-authority-wire.js';
+export * from './session-wire.js';
+export * from './session-snapshot.js';
+export * from './networked-client.js';
+export { createOfflineSession } from './offline-session.js';
+export * from './instant-replay.js';
+export * from './pause-resume.js';
+export * from './session-promotion.js';
+export { verifyReplay } from './replay.js';
+export * from './replay-scoring.js';
+export * from './match-log.js';
+export * from './authority-room.js';
+export * from './ws-frame.js';
+export { defaultNetworkedInputAuthoritySpikeOptions, runNetworkedInputAuthoritySpike, } from './networked-input-authority.js';
+export { runLocalWebSocketAdapterTest, startLocalWebSocketProtocolServer } from './local-ws-adapter.js';
+export { explainChaosFixture, runChaosCertificationSuite } from './chaos-certification.js';
+export { explainEngineParityFixture, runEngineParitySuite, stableEngineParityJson } from './engine-parity.js';

package/dist/number-lab.d.ts

@@ -0,0 +1,15 @@
+export type NumberLabMode = 'integer' | 'fixed-q16' | 'quantized-float' | 'raw-float-basic' | 'raw-float-math';
+export interface NumberLabOptions {
+    readonly mode: NumberLabMode;
+    readonly frames: number;
+    readonly seed: number;
+}
+export interface NumberLabResult {
+    readonly mode: NumberLabMode;
+    readonly frames: number;
+    readonly seed: number;
+    readonly finalValue: number;
+    readonly finalChecksum: string;
+    readonly result: 'pass';
+}
+export declare function runNumberLab(options: NumberLabOptions): NumberLabResult;

package/dist/number-lab.js

@@ -0,0 +1,75 @@
+import { defaultChecksum } from './canonical.js';
+import { DeterministicRandom } from './random.js';
+const q16 = 65_536;
+export function runNumberLab(options) {
+    validateOptions(options);
+    const random = new 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: 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');
+    }
+}

package/dist/offline-session.d.ts

@@ -0,0 +1,2 @@
+import type { DeterministicSessionConfig, OfflineSession } from './types.js';
+export declare function createOfflineSession<State, Input>(config: DeterministicSessionConfig<State, Input>): OfflineSession<State, Input>;