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

package/dist/cjs/reports.js

@@ -0,0 +1,181 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createProtocolRollbackReport = createProtocolRollbackReport;
+exports.stableReportJson = stableReportJson;
+exports.diffDeterministicReports = diffDeterministicReports;
+exports.stableReportDiffJson = stableReportDiffJson;
+exports.renderDeterministicReportHtml = renderDeterministicReportHtml;
+const canonical_js_1 = require("./canonical.js");
+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: (0, canonical_js_1.defaultChecksum)(reportWithoutId),
+    };
+}
+function stableReportJson(report) {
+    return `${(0, canonical_js_1.canonicalStringify)(report)}\n`;
+}
+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',
+    };
+}
+function stableReportDiffJson(diff) {
+    return `${(0, canonical_js_1.canonicalStringify)(diff)}\n`;
+}
+function renderDeterministicReportHtml(report) {
+    const json = (0, canonical_js_1.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 (0, canonical_js_1.defaultChecksum)(value);
+}
+function summarizeReportValue(value) {
+    if (value === undefined) {
+        return '<missing>';
+    }
+    const text = typeof value === 'string' ? value : (0, canonical_js_1.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/cjs/rollback-history.js

@@ -0,0 +1,251 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createDeterministicRollbackHistory = createDeterministicRollbackHistory;
+exports.runDeterministicRollbackHistoryFixture = runDeterministicRollbackHistoryFixture;
+const canonical_js_1 = require("./canonical.js");
+const engine_runtime_js_1 = require("./engine-runtime.js");
+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 = (0, canonical_js_1.cloneCanonical)(snapshot);
+            const bytes = JSON.stringify(cloned).length;
+            const entry = {
+                frame,
+                snapshot: cloned,
+                checksum: (0, canonical_js_1.defaultChecksum)({ frame, snapshot: cloned }),
+                bytes,
+            };
+            entries.set(frame, entry);
+            prune();
+            return (0, canonical_js_1.cloneCanonical)(entry);
+        },
+        has(frame) {
+            assertRollbackFrame(frame);
+            return entries.has(frame);
+        },
+        get(frame) {
+            assertRollbackFrame(frame);
+            const entry = entries.get(frame);
+            return entry === undefined ? undefined : (0, canonical_js_1.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 (0, canonical_js_1.cloneCanonical)(entry);
+                }),
+            };
+            return {
+                ...withoutChecksum,
+                checksum: (0, canonical_js_1.defaultChecksum)(withoutChecksum),
+            };
+        },
+        restore(snapshot) {
+            validateRollbackHistorySnapshot(snapshot, capacity);
+            entries.clear();
+            for (const entry of snapshot.entries) {
+                entries.set(entry.frame, (0, canonical_js_1.cloneCanonical)(entry));
+            }
+        },
+        checksum() {
+            return this.snapshot().checksum;
+        },
+    };
+}
+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 = (0, engine_runtime_js_1.createDeterministicFrameRuntime)(descriptor, seed);
+    const predicted = (0, engine_runtime_js_1.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: (0, canonical_js_1.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: (0, canonical_js_1.defaultChecksum)(history.frames()) === (0, canonical_js_1.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((0, canonical_js_1.cloneCanonical)(entry.snapshot)).length;
+        if (entry.bytes !== expectedBytes) {
+            throw new Error(`Deterministic rollback history snapshot frame ${entry.frame} byte size mismatch`);
+        }
+        const expected = (0, canonical_js_1.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 = (0, canonical_js_1.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/cjs/runtime-guards.js

@@ -0,0 +1,111 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.withRuntimeDeterminismGuards = withRuntimeDeterminismGuards;
+const errors_js_1 = require("./errors.js");
+const noopRestore = () => undefined;
+const deterministicTickReplacement = 'ctx.frame or deterministic tick counters';
+const deterministicStateTransitionReplacement = 'synchronous deterministic state transitions';
+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 errors_js_1.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/cjs/sample-lab.js

@@ -0,0 +1,145 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.labStep = exports.labDefaultInput = void 0;
+exports.createLabSession = createLabSession;
+exports.canonicalizeLabInput = canonicalizeLabInput;
+exports.hydrateLabInput = hydrateLabInput;
+exports.makeLabInput = makeLabInput;
+exports.applyLabInputs = applyLabInputs;
+exports.packLabInputFrame = packLabInputFrame;
+exports.unpackLabInputFrame = unpackLabInputFrame;
+const offline_session_js_1 = require("./offline-session.js");
+exports.labDefaultInput = { dx: 0, dy: 0, action: 0 };
+const labStep = (state, inputs) => {
+    const positions = state.positions.slice();
+    const actions = state.actions.slice();
+    inputs.forEach((input, slot) => {
+        const baseIndex = slot * 2;
+        positions[baseIndex] = (positions[baseIndex] ?? 0) + input.dx;
+        positions[baseIndex + 1] = (positions[baseIndex + 1] ?? 0) + input.dy;
+        actions[slot] = (actions[slot] ?? 0) + input.action;
+    });
+    return {
+        positions,
+        actions,
+        frame: state.frame + 1,
+        ...(state.payload === undefined ? {} : { payload: state.payload }),
+    };
+};
+exports.labStep = labStep;
+function createLabSession(options) {
+    const initialState = {
+        positions: Array.from({ length: options.players * 2 }, () => 0),
+        actions: Array.from({ length: options.players }, () => 0),
+        frame: 0,
+        ...(options.payloadBytes === undefined ? {} : { payload: 'x'.repeat(options.payloadBytes) }),
+    };
+    return (0, offline_session_js_1.createOfflineSession)({
+        tickRate: options.tickRate ?? 30,
+        playerCount: options.players,
+        initialState,
+        step: exports.labStep,
+        defaultInput: exports.labDefaultInput,
+        inputSchemaId: 'lab-input/v1',
+        stateSchemaId: 'lab-state/v1',
+        deterministicVersion: '0.0.0-source',
+        randomSeed: options.seed,
+        snapshotBufferSize: options.snapshotBufferSize,
+        replayRecordingMode: options.replayRecordingMode,
+        onInputFrameRecorded: options.onInputFrameRecorded,
+        onChecksumRecorded: options.onChecksumRecorded,
+        canonicalizeInput: canonicalizeLabInput,
+        hydrateInput: hydrateLabInput,
+    });
+}
+function canonicalizeLabInput(input) {
+    return [input.dx, input.dy, input.action];
+}
+function hydrateLabInput(recordedInput) {
+    if (Array.isArray(recordedInput) &&
+        recordedInput.length === 3 &&
+        typeof recordedInput[0] === 'number' &&
+        typeof recordedInput[1] === 'number' &&
+        (recordedInput[2] === 0 || recordedInput[2] === 1)) {
+        return {
+            dx: recordedInput[0],
+            dy: recordedInput[1],
+            action: recordedInput[2],
+        };
+    }
+    throw new Error('Invalid lab replay input');
+}
+function makeLabInput(random) {
+    return {
+        dx: random.nextInt(-1, 1),
+        dy: random.nextInt(-1, 1),
+        action: random.nextInt(0, 9) === 0 ? 1 : 0,
+    };
+}
+function applyLabInputs(session, players, random) {
+    const inputs = [];
+    for (let slot = 0; slot < players; slot += 1) {
+        const input = makeLabInput(random);
+        inputs.push(input);
+        session.setInput(slot, input);
+    }
+    return inputs;
+}
+function packLabInputFrame(inputs) {
+    const writer = new BitWriter(inputs.length * 5);
+    for (const input of inputs) {
+        writer.write(input.dx + 1, 2);
+        writer.write(input.dy + 1, 2);
+        writer.write(input.action, 1);
+    }
+    return writer.toBytes();
+}
+function unpackLabInputFrame(bytes, players) {
+    const reader = new BitReader(bytes);
+    return Array.from({ length: players }, () => {
+        const dx = reader.read(2) - 1;
+        const dy = reader.read(2) - 1;
+        const action = reader.read(1);
+        if ((dx !== -1 && dx !== 0 && dx !== 1) || (dy !== -1 && dy !== 0 && dy !== 1) || (action !== 0 && action !== 1)) {
+            throw new Error('Invalid packed lab input frame');
+        }
+        return { dx, dy, action };
+    });
+}
+class BitWriter {
+    bytes;
+    bitOffset = 0;
+    constructor(totalBits) {
+        this.bytes = new Uint8Array(Math.ceil(totalBits / 8));
+    }
+    write(value, bits) {
+        for (let bit = 0; bit < bits; bit += 1) {
+            if (((value >> bit) & 1) === 1) {
+                const byteIndex = Math.floor(this.bitOffset / 8);
+                const bitIndex = this.bitOffset % 8;
+                this.bytes[byteIndex] |= 1 << bitIndex;
+            }
+            this.bitOffset += 1;
+        }
+    }
+    toBytes() {
+        return this.bytes;
+    }
+}
+class BitReader {
+    bytes;
+    bitOffset = 0;
+    constructor(bytes) {
+        this.bytes = bytes;
+    }
+    read(bits) {
+        let value = 0;
+        for (let bit = 0; bit < bits; bit += 1) {
+            const byteIndex = Math.floor(this.bitOffset / 8);
+            const bitIndex = this.bitOffset % 8;
+            value |= ((this.bytes[byteIndex] >> bitIndex) & 1) << bit;
+            this.bitOffset += 1;
+        }
+        return value;
+    }
+}