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

package/dist/reports.js

@@ -0,0 +1,174 @@
+import { canonicalStringify, defaultChecksum } from './canonical.js';
+export function createProtocolRollbackReport(options, result) {
+    const config = {
+        game: options.game ?? 'lab',
+        players: options.players,
+        frames: options.frames,
+        seed: options.seed,
+        minDelayFrames: options.minDelayFrames,
+        maxDelayFrames: options.maxDelayFrames,
+        bundleSizeFrames: options.bundleSizeFrames ?? 1,
+        inputDelayFrames: options.inputDelayFrames ?? 0,
+        duplicatePermille: options.duplicatePermille ?? 0,
+        lossPermille: options.lossPermille ?? 0,
+        resendIntervalFrames: options.resendIntervalFrames ?? Math.max(1, options.maxDelayFrames + 1),
+        maxResendAttempts: options.maxResendAttempts ?? 1,
+        botSlots: options.botSlots ?? [],
+        expectDesync: options.expectDesync === true,
+        eventTimelineLimit: options.eventTimelineLimit ?? 64,
+        predictionPolicy: options.predictionPolicy ?? 'repeat-last',
+        ...optionalNumber('disconnectStartFrame', options.disconnectStartFrame),
+        ...optionalNumber('disconnectEndFrame', options.disconnectEndFrame),
+        ...optionalNumber('lateJoinSlot', options.lateJoinSlot),
+        ...optionalNumber('lateJoinFrame', options.lateJoinFrame),
+        ...optionalNumber('latencySkewSlot', options.latencySkewSlot),
+        ...optionalNumber('latencySkewFrames', options.latencySkewFrames),
+        ...optionalNumber('desyncFrame', options.desyncFrame),
+        ...optionalNumber('desyncSlot', options.desyncSlot),
+    };
+    const reportWithoutId = {
+        schemaVersion: 1,
+        reportId: '',
+        kind: 'protocol-rollback',
+        generatedAtFrame: result.frames,
+        config,
+        metrics: result,
+        result: result.result,
+    };
+    return {
+        ...reportWithoutId,
+        reportId: defaultChecksum(reportWithoutId),
+    };
+}
+export function stableReportJson(report) {
+    return `${canonicalStringify(report)}\n`;
+}
+export function diffDeterministicReports(left, right, maxDifferences = 200) {
+    const entries = [];
+    let differences = 0;
+    let truncatedDifferences = 0;
+    const addDifference = (path, leftValue, rightValue) => {
+        differences += 1;
+        if (entries.length < maxDifferences) {
+            entries.push({
+                path,
+                left: summarizeReportValue(leftValue),
+                right: summarizeReportValue(rightValue),
+            });
+        }
+        else {
+            truncatedDifferences += 1;
+        }
+    };
+    const visit = (path, leftValue, rightValue) => {
+        if (Object.is(leftValue, rightValue)) {
+            return;
+        }
+        if (Array.isArray(leftValue) || Array.isArray(rightValue)) {
+            if (!Array.isArray(leftValue) || !Array.isArray(rightValue)) {
+                addDifference(path, leftValue, rightValue);
+                return;
+            }
+            if (leftValue.length !== rightValue.length) {
+                addDifference(`${path}.length`, leftValue.length, rightValue.length);
+            }
+            for (let index = 0; index < Math.min(leftValue.length, rightValue.length); index += 1) {
+                visit(`${path}[${index}]`, leftValue[index], rightValue[index]);
+            }
+            return;
+        }
+        if (isReportObject(leftValue) || isReportObject(rightValue)) {
+            if (!isReportObject(leftValue) || !isReportObject(rightValue)) {
+                addDifference(path, leftValue, rightValue);
+                return;
+            }
+            const keys = [...new Set([...Object.keys(leftValue), ...Object.keys(rightValue)])].sort();
+            for (const key of keys) {
+                visit(path === '$' ? `$.${key}` : `${path}.${key}`, leftValue[key], rightValue[key]);
+            }
+            return;
+        }
+        addDifference(path, leftValue, rightValue);
+    };
+    visit('$', left, right);
+    return {
+        schemaVersion: 1,
+        kind: 'report-diff',
+        leftReportId: reportIdentity(left),
+        rightReportId: reportIdentity(right),
+        differences,
+        truncatedDifferences,
+        entries,
+        result: differences === 0 ? 'pass' : 'diff',
+    };
+}
+export function stableReportDiffJson(diff) {
+    return `${canonicalStringify(diff)}\n`;
+}
+export function renderDeterministicReportHtml(report) {
+    const json = canonicalStringify(report);
+    return [
+        '<!doctype html>',
+        '<html lang="en">',
+        '<head>',
+        '<meta charset="utf-8">',
+        '<meta name="viewport" content="width=device-width,initial-scale=1">',
+        `<title>${escapeHtml(report.kind)} ${escapeHtml(report.result)}</title>`,
+        '<style>',
+        'body{font-family:system-ui,-apple-system,BlinkMacSystemFont,"Segoe UI",sans-serif;margin:24px;color:#171717;background:#fafafa}',
+        'main{max-width:1120px;margin:0 auto}',
+        'header{display:flex;gap:12px;align-items:baseline;justify-content:space-between;border-bottom:1px solid #d4d4d4;padding-bottom:12px}',
+        'h1{font-size:20px;margin:0}',
+        'section{margin-top:18px}',
+        'pre{white-space:pre-wrap;overflow:auto;background:#fff;border:1px solid #d4d4d4;border-radius:6px;padding:12px;font-size:12px;line-height:1.45}',
+        '.pill{font-size:12px;border:1px solid #a3a3a3;border-radius:999px;padding:2px 8px;background:#fff}',
+        '.pass{border-color:#16a34a;color:#166534}.fail,.desync{border-color:#dc2626;color:#991b1b}.warn{border-color:#ca8a04;color:#854d0e}',
+        '</style>',
+        '</head>',
+        '<body>',
+        `<main data-report-id="${escapeHtml(report.reportId)}">`,
+        '<header>',
+        `<h1>${escapeHtml(report.kind)}</h1>`,
+        `<span class="pill ${escapeHtml(report.result)}">${escapeHtml(report.result)}</span>`,
+        '</header>',
+        '<section>',
+        `<p><strong>Report:</strong> ${escapeHtml(report.reportId)}</p>`,
+        `<p><strong>Generated at frame:</strong> ${report.generatedAtFrame}</p>`,
+        '</section>',
+        '<section>',
+        '<h2>Canonical JSON</h2>',
+        `<pre>${escapeHtml(JSON.stringify(JSON.parse(json), null, 2))}</pre>`,
+        '</section>',
+        '</main>',
+        '</body>',
+        '</html>',
+        '',
+    ].join('\n');
+}
+function optionalNumber(key, value) {
+    return value === undefined ? {} : { [key]: value };
+}
+function isReportObject(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function reportIdentity(value) {
+    if (isReportObject(value) && typeof value.reportId === 'string' && value.reportId.length > 0) {
+        return value.reportId;
+    }
+    return defaultChecksum(value);
+}
+function summarizeReportValue(value) {
+    if (value === undefined) {
+        return '<missing>';
+    }
+    const text = typeof value === 'string' ? value : canonicalStringify(value);
+    return text.length > 240 ? `${text.slice(0, 237)}...` : text;
+}
+function escapeHtml(value) {
+    return value
+        .replaceAll('&', '&amp;')
+        .replaceAll('<', '&lt;')
+        .replaceAll('>', '&gt;')
+        .replaceAll('"', '&quot;')
+        .replaceAll("'", '&#39;');
+}

package/dist/rollback-history.d.ts

@@ -0,0 +1,46 @@
+export interface DeterministicRollbackHistoryEntry<TSnapshot> {
+    readonly frame: number;
+    readonly snapshot: TSnapshot;
+    readonly checksum: string;
+    readonly bytes: number;
+}
+export interface DeterministicRollbackHistorySnapshot<TSnapshot> {
+    readonly capacity: number;
+    readonly entries: readonly DeterministicRollbackHistoryEntry<TSnapshot>[];
+    readonly checksum: string;
+}
+export interface DeterministicRollbackHistory<TSnapshot> {
+    readonly capacity: number;
+    readonly size: number;
+    readonly oldestFrame: number | undefined;
+    readonly latestFrame: number | undefined;
+    record(frame: number, snapshot: TSnapshot): DeterministicRollbackHistoryEntry<TSnapshot>;
+    has(frame: number): boolean;
+    get(frame: number): DeterministicRollbackHistoryEntry<TSnapshot> | undefined;
+    require(frame: number): DeterministicRollbackHistoryEntry<TSnapshot>;
+    frames(): readonly number[];
+    snapshot(): DeterministicRollbackHistorySnapshot<TSnapshot>;
+    restore(snapshot: DeterministicRollbackHistorySnapshot<TSnapshot>): void;
+    checksum(): string;
+}
+export interface DeterministicRollbackHistoryFixtureResult {
+    readonly checksum: string;
+    readonly baselineChecksum: string;
+    readonly predictedChecksumBeforeCorrection: string;
+    readonly resimulatedChecksum: string;
+    readonly restoredHistoryChecksum: string;
+    readonly capacity: number;
+    readonly recordedFrames: number;
+    readonly evictedFrames: number;
+    readonly restoredFrame: number;
+    readonly predictedToFrame: number;
+    readonly resimulatedFrames: number;
+    readonly convergence: boolean;
+    readonly duplicateRejected: boolean;
+    readonly evictedRestoreRejected: boolean;
+    readonly malformedRestoreRejected: boolean;
+    readonly rollbackDepthBounded: boolean;
+    readonly orderStable: boolean;
+}
+export declare function createDeterministicRollbackHistory<TSnapshot>(capacity: number): DeterministicRollbackHistory<TSnapshot>;
+export declare function runDeterministicRollbackHistoryFixture(frames?: number, capacity?: number, seed?: number): DeterministicRollbackHistoryFixtureResult;

package/dist/rollback-history.js

@@ -0,0 +1,247 @@
+import { cloneCanonical, defaultChecksum } from './canonical.js';
+import { createDeterministicFrameRuntime, } from './engine-runtime.js';
+export function createDeterministicRollbackHistory(capacity) {
+    if (!Number.isInteger(capacity) || capacity <= 0) {
+        throw new Error('Deterministic rollback history capacity must be a positive integer');
+    }
+    const entries = new Map();
+    function sortedFrames() {
+        return [...entries.keys()].sort((left, right) => left - right);
+    }
+    function prune() {
+        while (entries.size > capacity) {
+            const oldest = sortedFrames()[0];
+            entries.delete(oldest);
+        }
+    }
+    return {
+        capacity,
+        get size() {
+            return entries.size;
+        },
+        get oldestFrame() {
+            return sortedFrames()[0];
+        },
+        get latestFrame() {
+            return sortedFrames().at(-1);
+        },
+        record(frame, snapshot) {
+            assertRollbackFrame(frame);
+            if (entries.has(frame)) {
+                throw new Error(`Deterministic rollback history already has frame ${frame}`);
+            }
+            const cloned = cloneCanonical(snapshot);
+            const bytes = JSON.stringify(cloned).length;
+            const entry = {
+                frame,
+                snapshot: cloned,
+                checksum: defaultChecksum({ frame, snapshot: cloned }),
+                bytes,
+            };
+            entries.set(frame, entry);
+            prune();
+            return cloneCanonical(entry);
+        },
+        has(frame) {
+            assertRollbackFrame(frame);
+            return entries.has(frame);
+        },
+        get(frame) {
+            assertRollbackFrame(frame);
+            const entry = entries.get(frame);
+            return entry === undefined ? undefined : cloneCanonical(entry);
+        },
+        require(frame) {
+            const entry = this.get(frame);
+            if (entry === undefined) {
+                throw new Error(`Deterministic rollback history frame ${frame} is outside the retained window`);
+            }
+            return entry;
+        },
+        frames() {
+            return sortedFrames();
+        },
+        snapshot() {
+            const withoutChecksum = {
+                capacity,
+                entries: sortedFrames().map((frame) => {
+                    const entry = entries.get(frame);
+                    /* istanbul ignore next -- sortedFrames is derived from the same entries map being read here. */
+                    if (entry === undefined) {
+                        throw new Error(`Deterministic rollback history missing retained frame ${frame}`);
+                    }
+                    return cloneCanonical(entry);
+                }),
+            };
+            return {
+                ...withoutChecksum,
+                checksum: defaultChecksum(withoutChecksum),
+            };
+        },
+        restore(snapshot) {
+            validateRollbackHistorySnapshot(snapshot, capacity);
+            entries.clear();
+            for (const entry of snapshot.entries) {
+                entries.set(entry.frame, cloneCanonical(entry));
+            }
+        },
+        checksum() {
+            return this.snapshot().checksum;
+        },
+    };
+}
+export function runDeterministicRollbackHistoryFixture(frames = 96, capacity = 24, seed = 71) {
+    const restoreFrame = Math.max(8, Math.floor(frames / 3));
+    const predictedToFrame = Math.min(frames, restoreFrame + Math.max(6, Math.floor(capacity / 2)));
+    const descriptor = rollbackHistoryDescriptor();
+    const systems = rollbackHistorySystems();
+    const baseline = createDeterministicFrameRuntime(descriptor, seed);
+    const predicted = createDeterministicFrameRuntime(descriptor, seed);
+    const history = createDeterministicRollbackHistory(capacity);
+    for (let frame = 0; frame <= predictedToFrame; frame += 1) {
+        history.record(frame, predicted.snapshot());
+        stepRollbackRuntime(predicted, systems, predictedInput(frame, seed, restoreFrame));
+        stepRollbackRuntime(baseline, systems, actualInput(frame, seed));
+    }
+    const predictedChecksumBeforeCorrection = predicted.snapshot().checksum;
+    const restoreEntry = history.require(restoreFrame);
+    predicted.restore(restoreEntry.snapshot);
+    for (let frame = restoreFrame; frame <= predictedToFrame; frame += 1) {
+        stepRollbackRuntime(predicted, systems, actualInput(frame, seed));
+    }
+    const resimulatedChecksum = predicted.snapshot().checksum;
+    const baselineChecksum = baseline.snapshot().checksum;
+    let duplicateRejected = false;
+    try {
+        history.record(restoreFrame, predicted.snapshot());
+    }
+    catch {
+        duplicateRejected = true;
+    }
+    const evictingHistory = createDeterministicRollbackHistory(capacity);
+    for (let frame = 0; frame < capacity + 4; frame += 1) {
+        evictingHistory.record(frame, baseline.snapshot());
+    }
+    let evictedRestoreRejected = false;
+    try {
+        evictingHistory.require(0);
+    }
+    catch {
+        evictedRestoreRejected = true;
+    }
+    const historySnapshot = history.snapshot();
+    const restoredHistory = createDeterministicRollbackHistory(capacity);
+    restoredHistory.restore(historySnapshot);
+    let malformedRestoreRejected = false;
+    try {
+        restoredHistory.restore({ ...historySnapshot, checksum: 'tampered' });
+    }
+    catch {
+        malformedRestoreRejected = true;
+    }
+    const withoutChecksum = {
+        baselineChecksum,
+        predictedChecksumBeforeCorrection,
+        resimulatedChecksum,
+        restoredHistoryChecksum: restoredHistory.checksum(),
+        frames,
+        capacity,
+        retainedFrames: history.frames(),
+        restoreFrame,
+        predictedToFrame,
+    };
+    return {
+        checksum: defaultChecksum(withoutChecksum),
+        baselineChecksum,
+        predictedChecksumBeforeCorrection,
+        resimulatedChecksum,
+        restoredHistoryChecksum: restoredHistory.checksum(),
+        capacity,
+        recordedFrames: history.size,
+        evictedFrames: Math.max(0, predictedToFrame + 1 - history.size),
+        restoredFrame: restoreFrame,
+        predictedToFrame,
+        resimulatedFrames: predictedToFrame - restoreFrame + 1,
+        convergence: baselineChecksum === resimulatedChecksum && baselineChecksum !== predictedChecksumBeforeCorrection,
+        duplicateRejected,
+        evictedRestoreRejected,
+        malformedRestoreRejected,
+        rollbackDepthBounded: history.size <= capacity && evictingHistory.oldestFrame === 4,
+        orderStable: defaultChecksum(history.frames()) === defaultChecksum(restoredHistory.frames()),
+    };
+}
+function assertRollbackFrame(frame) {
+    if (!Number.isInteger(frame) || frame < 0) {
+        throw new Error(`Deterministic rollback history frame ${frame} must be a non-negative integer`);
+    }
+}
+function validateRollbackHistorySnapshot(snapshot, capacity) {
+    if (snapshot.capacity !== capacity) {
+        throw new Error(`Deterministic rollback history capacity mismatch ${snapshot.capacity} !== ${capacity}`);
+    }
+    if (snapshot.entries.length > capacity) {
+        throw new Error(`Deterministic rollback history snapshot has ${snapshot.entries.length} entries for capacity ${capacity}`);
+    }
+    const frames = new Set();
+    let previousFrame = -1;
+    for (const entry of snapshot.entries) {
+        assertRollbackFrame(entry.frame);
+        if (frames.has(entry.frame)) {
+            throw new Error(`Deterministic rollback history snapshot duplicate frame ${entry.frame}`);
+        }
+        if (entry.frame <= previousFrame) {
+            throw new Error('Deterministic rollback history snapshot entries must be sorted by frame');
+        }
+        frames.add(entry.frame);
+        previousFrame = entry.frame;
+        if (!Number.isInteger(entry.bytes) || entry.bytes <= 0) {
+            throw new Error(`Deterministic rollback history snapshot frame ${entry.frame} has invalid byte size`);
+        }
+        const expectedBytes = JSON.stringify(cloneCanonical(entry.snapshot)).length;
+        if (entry.bytes !== expectedBytes) {
+            throw new Error(`Deterministic rollback history snapshot frame ${entry.frame} byte size mismatch`);
+        }
+        const expected = defaultChecksum({ frame: entry.frame, snapshot: entry.snapshot });
+        if (entry.checksum !== expected) {
+            throw new Error(`Deterministic rollback history snapshot checksum mismatch at frame ${entry.frame}`);
+        }
+    }
+    const expectedSnapshotChecksum = defaultChecksum({
+        capacity: snapshot.capacity,
+        entries: snapshot.entries,
+    });
+    if (snapshot.checksum !== expectedSnapshotChecksum) {
+        throw new Error('Deterministic rollback history snapshot checksum mismatch');
+    }
+}
+function rollbackHistoryDescriptor() {
+    return {
+        id: 'rollback-history-fixture',
+        tickRate: 60,
+        components: [
+            { id: 'input', singleton: true, fields: [{ name: 'value', kind: 'int', defaultValue: 0 }] },
+            { id: 'score', singleton: true, fields: [{ name: 'total', kind: 'int', defaultValue: 0 }] },
+        ],
+        systems: [{ id: 'score', group: 'simulation', order: 0 }],
+    };
+}
+function rollbackHistorySystems() {
+    return {
+        score(ctx) {
+            const input = ctx.getSingleton('input');
+            const score = ctx.getSingleton('score');
+            const total = score === undefined ? 0 : Number(score.total);
+            ctx.setSingleton('score', { total: total + Number(input.value) });
+        },
+    };
+}
+function stepRollbackRuntime(runtime, systems, input) {
+    runtime.setSingleton('input', { value: input });
+    runtime.step(systems);
+}
+function actualInput(frame, seed) {
+    return ((frame * 17 + seed) % 11) - 5;
+}
+function predictedInput(frame, seed, correctionFrame) {
+    return frame < correctionFrame ? actualInput(frame, seed) : actualInput(frame, seed) + 1;
+}

package/dist/runtime-guards.d.ts

@@ -0,0 +1 @@
+export declare function withRuntimeDeterminismGuards<State>(frame: number, run: () => State): State;

package/dist/runtime-guards.js

@@ -0,0 +1,108 @@
+import { SyncplayError } from './errors.js';
+const noopRestore = () => undefined;
+const deterministicTickReplacement = 'ctx.frame or deterministic tick counters';
+const deterministicStateTransitionReplacement = 'synchronous deterministic state transitions';
+export function withRuntimeDeterminismGuards(frame, run) {
+    const restoreGuards = [
+        replaceValue(Math, 'random', blockedFunction(frame, 'Math.random()', 'ctx.random.nextInt() or ctx.random.nextFixed()')),
+        replaceDateConstructor(frame),
+        replacePrototypeValue(globalThis.performance, 'now', blockedFunction(frame, 'performance.now()', 'ctx.frame or deterministic tick counters')),
+        replacePrototypeValue(globalThis.crypto, 'randomUUID', blockedFunction(frame, 'crypto.randomUUID()', 'ctx.random.nextInt() or deterministic ids')),
+        replacePrototypeValue(globalThis.crypto, 'getRandomValues', blockedFunction(frame, 'crypto.getRandomValues()', 'ctx.random deterministic streams')),
+        replaceGlobalTimer(frame, 'setTimeout', 'deterministic countdown fields advanced by fixed ticks'),
+        replaceGlobalTimer(frame, 'setInterval', 'deterministic countdown fields advanced by fixed ticks'),
+        replaceGlobalTimer(frame, 'setImmediate', 'deterministic countdown fields advanced by fixed ticks'),
+        replaceGlobalTimer(frame, 'queueMicrotask', 'explicit deterministic event queues in frame state'),
+        replaceGlobalTimer(frame, 'requestAnimationFrame', 'render-only callbacks outside simulation'),
+        replacePromiseConstructor(frame),
+    ];
+    try {
+        return run();
+    }
+    finally {
+        for (let index = restoreGuards.length - 1; index >= 0; index -= 1) {
+            restoreGuards[index]();
+        }
+    }
+}
+function blockedFunction(frame, api, replacement) {
+    return () => {
+        throw new SyncplayError(`${api} is not allowed during deterministic step. Use ${replacement}.`, {
+            code: 'runtime-guard.blocked-api',
+            frame,
+        });
+    };
+}
+function replacePromiseConstructor(frame) {
+    const target = globalThis;
+    const original = target.Promise;
+    const blockedPromise = blockedFunction(frame, 'new Promise()', deterministicStateTransitionReplacement);
+    const guarded = function deterministicPromiseGuard() {
+        throw blockedPromise();
+    };
+    guarded.prototype = original.prototype;
+    for (const key of ['all', 'allSettled', 'any', 'race', 'reject', 'resolve']) {
+        guarded[key] = blockedFunction(frame, `Promise.${key}()`, deterministicStateTransitionReplacement);
+    }
+    return replaceValue(target, 'Promise', guarded);
+}
+function replaceGlobalTimer(frame, key, replacement) {
+    const target = globalThis;
+    if (target[key] === undefined) {
+        return noopRestore;
+    }
+    return replaceValue(target, key, blockedFunction(frame, `${key}()`, replacement));
+}
+function replaceDateConstructor(frame) {
+    const target = globalThis;
+    const original = target.Date;
+    const blockedDate = blockedFunction(frame, 'new Date()', deterministicTickReplacement);
+    const blockedDateNow = blockedFunction(frame, 'Date.now()', deterministicTickReplacement);
+    const guarded = function deterministicDateGuard() {
+        throw blockedDate();
+    };
+    guarded.now = blockedDateNow;
+    guarded.parse = original.parse.bind(original);
+    guarded.UTC = original.UTC.bind(original);
+    guarded.prototype = original.prototype;
+    return replaceValue(target, 'Date', guarded);
+}
+function replacePrototypeValue(target, key, replacement) {
+    if (target === undefined) {
+        return noopRestore;
+    }
+    let current = target;
+    while (current !== null) {
+        const descriptor = Object.getOwnPropertyDescriptor(current, key);
+        if (descriptor !== undefined) {
+            if (descriptor.configurable !== true) {
+                return noopRestore;
+            }
+            Object.defineProperty(current, key, {
+                configurable: true,
+                writable: true,
+                value: replacement,
+            });
+            return () => {
+                Object.defineProperty(current, key, descriptor);
+            };
+        }
+        current = Object.getPrototypeOf(current);
+    }
+    return noopRestore;
+}
+function replaceValue(target, key, replacement) {
+    const originalDescriptor = Object.getOwnPropertyDescriptor(target, key);
+    /* istanbul ignore next -- non-configurable core globals cannot be made safely reversible inside this process. */
+    if (originalDescriptor?.configurable !== true) {
+        return noopRestore;
+    }
+    Object.defineProperty(target, key, {
+        configurable: true,
+        writable: true,
+        value: replacement,
+    });
+    return () => {
+        Object.defineProperty(target, key, originalDescriptor);
+    };
+}

package/dist/sample-lab.d.ts

@@ -0,0 +1,32 @@
+import { DeterministicRandom } from './random.js';
+import type { DeterministicStep, OfflineSession, RecordedChecksum, RecordedInputFrame, ReplayRecordingMode, TickRate } from './types.js';
+export interface LabInput {
+    readonly dx: number;
+    readonly dy: number;
+    readonly action: 0 | 1;
+}
+export interface LabState {
+    readonly positions: readonly number[];
+    readonly actions: readonly number[];
+    readonly frame: number;
+    readonly payload?: string;
+}
+export interface LabSessionOptions {
+    readonly players: number;
+    readonly seed: number;
+    readonly tickRate?: TickRate;
+    readonly snapshotBufferSize?: number;
+    readonly payloadBytes?: number;
+    readonly replayRecordingMode?: ReplayRecordingMode;
+    readonly onInputFrameRecorded?: (inputFrame: RecordedInputFrame) => void;
+    readonly onChecksumRecorded?: (checksum: RecordedChecksum) => void;
+}
+export declare const labDefaultInput: LabInput;
+export declare const labStep: DeterministicStep<LabState, LabInput>;
+export declare function createLabSession(options: LabSessionOptions): OfflineSession<LabState, LabInput>;
+export declare function canonicalizeLabInput(input: LabInput): readonly [number, number, 0 | 1];
+export declare function hydrateLabInput(recordedInput: unknown): LabInput;
+export declare function makeLabInput(random: DeterministicRandom): LabInput;
+export declare function applyLabInputs(session: OfflineSession<LabState, LabInput>, players: number, random: DeterministicRandom): readonly LabInput[];
+export declare function packLabInputFrame(inputs: readonly LabInput[]): Uint8Array;
+export declare function unpackLabInputFrame(bytes: Uint8Array, players: number): readonly LabInput[];