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

package/dist/cjs/sparse-set.js

@@ -0,0 +1,169 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createDeterministicSparseSet = createDeterministicSparseSet;
+exports.runDeterministicSparseSetFixture = runDeterministicSparseSetFixture;
+const canonical_js_1 = require("./canonical.js");
+function createDeterministicSparseSet(capacity = 1024) {
+    const dense = [];
+    const values = [];
+    const sparse = new Map();
+    function assertId(id) {
+        if (!Number.isInteger(id) || id < 0 || id >= capacity) {
+            throw new Error(`Sparse-set id ${id} outside capacity ${capacity}`);
+        }
+    }
+    return {
+        add(id, value) {
+            assertId(id);
+            if (sparse.has(id)) {
+                throw new Error(`Sparse-set duplicate id ${id}`);
+            }
+            sparse.set(id, dense.length);
+            dense.push(id);
+            values.push((0, canonical_js_1.cloneCanonical)(value));
+        },
+        remove(id) {
+            assertId(id);
+            const index = sparse.get(id);
+            if (index === undefined) {
+                return false;
+            }
+            const lastIndex = dense.length - 1;
+            const lastId = dense[lastIndex];
+            dense[index] = lastId;
+            values[index] = values[lastIndex];
+            sparse.set(lastId, index);
+            dense.pop();
+            values.pop();
+            sparse.delete(id);
+            return true;
+        },
+        has(id) {
+            assertId(id);
+            return sparse.has(id);
+        },
+        get(id) {
+            assertId(id);
+            const index = sparse.get(id);
+            return index === undefined ? undefined : (0, canonical_js_1.cloneCanonical)(values[index]);
+        },
+        set(id, value) {
+            assertId(id);
+            const index = sparse.get(id);
+            if (index === undefined) {
+                throw new Error(`Sparse-set missing id ${id}`);
+            }
+            values[index] = (0, canonical_js_1.cloneCanonical)(value);
+        },
+        query() {
+            return dense.map((id, index) => ({ id, value: (0, canonical_js_1.cloneCanonical)(values[index]) }))
+                .sort((left, right) => left.id - right.id);
+        },
+        snapshot() {
+            return (0, canonical_js_1.cloneCanonical)({
+                capacity,
+                dense,
+                values,
+                sparseEntries: [...sparse.entries()]
+                    .map(([id, denseIndex]) => ({ id, denseIndex }))
+                    .sort((left, right) => left.id - right.id),
+            });
+        },
+        restore(snapshot) {
+            if (snapshot.capacity !== capacity) {
+                throw new Error(`Sparse-set capacity mismatch ${snapshot.capacity} !== ${capacity}`);
+            }
+            validateSparseSetSnapshot(snapshot, capacity);
+            dense.length = 0;
+            values.length = 0;
+            sparse.clear();
+            snapshot.dense.forEach((id, index) => {
+                dense.push(id);
+                values.push((0, canonical_js_1.cloneCanonical)(snapshot.values[index]));
+                sparse.set(id, index);
+            });
+        },
+        checksum() {
+            return (0, canonical_js_1.defaultChecksum)(this.snapshot());
+        },
+    };
+}
+function runDeterministicSparseSetFixture() {
+    const set = createDeterministicSparseSet(512);
+    let rejectedDuplicate = false;
+    let removed = 0;
+    for (let index = 0; index < 256; index += 1) {
+        set.add((index * 37) % 512, { hp: 100 - (index % 17), team: index % 4 });
+    }
+    try {
+        set.add(0, { hp: 1, team: 1 });
+    }
+    catch {
+        rejectedDuplicate = true;
+    }
+    for (let id = 0; id < 512; id += 5) {
+        removed += set.remove(id) ? 1 : 0;
+    }
+    for (const entry of set.query()) {
+        set.set(entry.id, { hp: entry.value.hp + 1, team: entry.value.team });
+    }
+    const checksum = set.checksum();
+    const firstQuery = set.query().map((entry) => entry.id);
+    const snapshot = set.snapshot();
+    const restored = createDeterministicSparseSet(512);
+    restored.restore(snapshot);
+    let rejectedMalformedSnapshot = false;
+    try {
+        restored.restore({ ...snapshot, sparseEntries: snapshot.sparseEntries.slice(1) });
+    }
+    catch {
+        rejectedMalformedSnapshot = true;
+    }
+    return {
+        checksum,
+        restoredChecksum: restored.checksum(),
+        queryOrderStable: (0, canonical_js_1.defaultChecksum)(firstQuery) === (0, canonical_js_1.defaultChecksum)(restored.query().map((entry) => entry.id)),
+        denseCount: snapshot.dense.length,
+        rejectedDuplicate,
+        rejectedMalformedSnapshot,
+        removed,
+    };
+}
+function validateSparseSetSnapshot(snapshot, capacity) {
+    if (snapshot.dense.length !== snapshot.values.length) {
+        throw new Error(`Sparse-set snapshot dense/value length mismatch ${snapshot.dense.length} !== ${snapshot.values.length}`);
+    }
+    if (snapshot.sparseEntries.length !== snapshot.dense.length) {
+        throw new Error(`Sparse-set snapshot sparse/dense length mismatch ${snapshot.sparseEntries.length} !== ${snapshot.dense.length}`);
+    }
+    const denseIds = new Set();
+    for (const id of snapshot.dense) {
+        if (!Number.isInteger(id) || id < 0 || id >= capacity) {
+            throw new Error(`Sparse-set snapshot id ${id} outside capacity ${capacity}`);
+        }
+        if (denseIds.has(id)) {
+            throw new Error(`Sparse-set snapshot duplicate dense id ${id}`);
+        }
+        denseIds.add(id);
+    }
+    const sparseIds = new Set();
+    const sparseById = new Map();
+    for (const entry of snapshot.sparseEntries) {
+        if (!Number.isInteger(entry.id) || entry.id < 0 || entry.id >= capacity) {
+            throw new Error(`Sparse-set snapshot sparse id ${entry.id} outside capacity ${capacity}`);
+        }
+        if (!Number.isInteger(entry.denseIndex) || entry.denseIndex < 0 || entry.denseIndex >= snapshot.dense.length) {
+            throw new Error(`Sparse-set snapshot dense index ${entry.denseIndex} outside dense length ${snapshot.dense.length}`);
+        }
+        if (sparseIds.has(entry.id)) {
+            throw new Error(`Sparse-set snapshot duplicate sparse id ${entry.id}`);
+        }
+        sparseIds.add(entry.id);
+        sparseById.set(entry.id, entry.denseIndex);
+    }
+    for (const [index, id] of snapshot.dense.entries()) {
+        if (sparseById.get(id) !== index) {
+            throw new Error(`Sparse-set snapshot sparse entry mismatch for id ${id}`);
+        }
+    }
+}

package/dist/cjs/synctest.js

@@ -0,0 +1,136 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runSyncplaySynctest = runSyncplaySynctest;
+const collections_js_1 = require("./collections.js");
+const errors_js_1 = require("./errors.js");
+const offline_session_js_1 = require("./offline-session.js");
+const random_js_1 = require("./random.js");
+const replay_js_1 = require("./replay.js");
+/**
+ * GGPO-style offline synctest: for every seed, runs the game straight through
+ * and again with a rollback (snapshot → step → restore → re-step) on EVERY
+ * frame, comparing per-frame checksums, then re-verifies the exported replay
+ * from scratch. Catches logic nondeterminism (stray Math.random, iteration
+ * order dependence, restore-sensitive state) with no networking involved.
+ * Divergence is reported in the result, never thrown; config errors throw.
+ */
+function runSyncplaySynctest(config) {
+    const { frames: framesOption, seeds: seedsOption, inputFuzz: inputFuzzOption, ...sessionBase } = config;
+    const frames = framesOption ?? 300;
+    const seeds = seedsOption ?? [1, 2, 3];
+    (0, errors_js_1.invariant)(Number.isInteger(frames) && frames >= 1, 'synctest frames must be a positive integer', 'synctest.frames');
+    (0, errors_js_1.invariant)(seeds.length > 0 && seeds.every((seed) => Number.isInteger(seed)), 'synctest seeds must be a non-empty list of integers', 'synctest.seeds');
+    const inputFuzz = inputFuzzOption ?? createDefaultInputFuzz(config.defaultInput);
+    let seedsRun = 0;
+    let framesChecked = 0;
+    for (const seed of seeds) {
+        seedsRun += 1;
+        let lastChecksum;
+        const sessionConfig = {
+            ...sessionBase,
+            randomSeed: seed,
+            checksumIntervalFrames: 1,
+            replayRecordingMode: 'memory',
+            onChecksumRecorded(checksum) {
+                lastChecksum = checksum;
+                sessionBase.onChecksumRecorded?.(checksum);
+            },
+        };
+        const straight = (0, offline_session_js_1.createOfflineSession)(sessionConfig);
+        const schedule = buildInputSchedule(config.playerCount, frames, seed, inputFuzz);
+        const straightChecksums = [];
+        for (let frame = 0; frame < frames; frame += 1) {
+            applyScheduledInputs(straight, schedule[frame]);
+            straight.stepFrames(1);
+            straightChecksums.push(takeChecksum(lastChecksum, straight.currentFrame));
+        }
+        const replay = straight.exportReplay();
+        const rollback = (0, offline_session_js_1.createOfflineSession)(sessionConfig);
+        for (let frame = 0; frame < frames; frame += 1) {
+            applyScheduledInputs(rollback, schedule[frame]);
+            rollback.stepFrames(1);
+            const firstPass = takeChecksum(lastChecksum, rollback.currentFrame);
+            rollback.restoreToFrame(frame);
+            applyScheduledInputs(rollback, schedule[frame]);
+            rollback.stepFrames(1);
+            const secondPass = takeChecksum(lastChecksum, rollback.currentFrame);
+            framesChecked += 1;
+            const straightChecksum = straightChecksums[frame];
+            if (firstPass !== straightChecksum) {
+                return diverged(seedsRun, framesChecked, {
+                    seed,
+                    frame: frame + 1,
+                    phase: 'straight',
+                    straightChecksum,
+                    rollbackChecksum: firstPass,
+                });
+            }
+            if (secondPass !== straightChecksum) {
+                return diverged(seedsRun, framesChecked, {
+                    seed,
+                    frame: frame + 1,
+                    phase: 'rollback',
+                    straightChecksum,
+                    rollbackChecksum: secondPass,
+                });
+            }
+        }
+        const replayResult = (0, replay_js_1.verifyReplay)({ ...sessionBase, replay, throwOnMismatch: false });
+        if (replayResult.firstMismatch !== undefined) {
+            return diverged(seedsRun, framesChecked, {
+                seed,
+                frame: replayResult.firstMismatch.frame,
+                phase: 'replay',
+                straightChecksum: replayResult.firstMismatch.expectedChecksum,
+                rollbackChecksum: replayResult.firstMismatch.actualChecksum,
+            });
+        }
+    }
+    return { ok: true, seedsRun, framesChecked };
+}
+function diverged(seedsRun, framesChecked, firstDivergence) {
+    return { ok: false, seedsRun, framesChecked, firstDivergence };
+}
+function takeChecksum(lastChecksum, frame) {
+    if (lastChecksum === undefined || lastChecksum.frame !== frame) {
+        throw new errors_js_1.SyncplayError(`Synctest expected a checksum record for frame ${frame}`, {
+            code: 'synctest.missing-checksum',
+            frame,
+        });
+    }
+    return lastChecksum.checksum;
+}
+function buildInputSchedule(playerCount, frames, seed, inputFuzz) {
+    const random = new random_js_1.DeterministicRandom(seed >>> 0).fork('synctest.input-fuzz');
+    const schedule = [];
+    for (let frame = 0; frame < frames; frame += 1) {
+        schedule.push(Array.from({ length: playerCount }, (_, slot) => inputFuzz(random, slot, frame)));
+    }
+    return schedule;
+}
+function applyScheduledInputs(session, inputs) {
+    inputs.forEach((input, slot) => session.setInput(slot, input));
+}
+function createDefaultInputFuzz(defaultInput) {
+    return (random) => fuzzFromTemplate(defaultInput, random);
+}
+function fuzzFromTemplate(template, random) {
+    if (typeof template === 'boolean') {
+        return random.nextInt(0, 1) === 1;
+    }
+    if (typeof template === 'number') {
+        return random.nextInt(-1, 1);
+    }
+    if (Array.isArray(template)) {
+        return template.map((item) => fuzzFromTemplate(item, random));
+    }
+    if (template !== null && typeof template === 'object' && Object.getPrototypeOf(template) === Object.prototype) {
+        const record = template;
+        const fuzzed = {};
+        for (const key of (0, collections_js_1.stableSortedKeys)(record)) {
+            fuzzed[key] = fuzzFromTemplate(record[key], random);
+        }
+        return fuzzed;
+    }
+    return template;
+}

package/dist/cjs/system-lifecycle.js

@@ -0,0 +1,286 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createDeterministicLifecycleRunner = createDeterministicLifecycleRunner;
+exports.runDeterministicLifecycleFixture = runDeterministicLifecycleFixture;
+exports.summarizeDeterministicLifecycleCounters = summarizeDeterministicLifecycleCounters;
+const canonical_js_1 = require("./canonical.js");
+function createDeterministicLifecycleRunner(descriptors, hooks) {
+    validateLifecycleDescriptors(descriptors, hooks);
+    const ordered = [...descriptors].sort(compareLifecycleDescriptors);
+    const descriptorById = new Map(ordered.map((descriptor) => [descriptor.id, descriptor]));
+    let frame = 0;
+    let initialized = new Set();
+    let enabled = new Set(ordered.filter((descriptor) => descriptor.startEnabled !== false).map((descriptor) => descriptor.id));
+    let pendingSignals = [];
+    let counters = new Map();
+    let log = [];
+    function context(systemId) {
+        return {
+            frame,
+            systemId,
+            emit(event) {
+                log.push(`${frame}:${systemId}:${event}`);
+            },
+            increment(key, amount = 1) {
+                counters.set(key, (counters.get(key) ?? 0) + amount);
+            },
+            signal(signal) {
+                pendingSignals.push((0, canonical_js_1.cloneCanonical)(signal));
+            },
+        };
+    }
+    function isEffectivelyEnabled(systemId) {
+        const descriptor = descriptorById.get(systemId);
+        if (descriptor === undefined || !enabled.has(systemId)) {
+            return false;
+        }
+        return descriptor.parentId === undefined || isEffectivelyEnabled(descriptor.parentId);
+    }
+    return {
+        get frame() {
+            return frame;
+        },
+        enable(systemId) {
+            assertLifecycleSystem(descriptorById, systemId);
+            if (!enabled.has(systemId)) {
+                enabled.add(systemId);
+                hooks[systemId]?.onEnabled?.(context(systemId));
+            }
+        },
+        disable(systemId) {
+            assertLifecycleSystem(descriptorById, systemId);
+            if (enabled.has(systemId)) {
+                enabled.delete(systemId);
+                hooks[systemId]?.onDisabled?.(context(systemId));
+            }
+        },
+        signal(signal) {
+            pendingSignals.push((0, canonical_js_1.cloneCanonical)(signal));
+        },
+        step() {
+            for (const descriptor of ordered) {
+                if (!initialized.has(descriptor.id)) {
+                    initialized.add(descriptor.id);
+                    hooks[descriptor.id]?.onInit?.(context(descriptor.id));
+                }
+            }
+            const signals = pendingSignals.sort(compareLifecycleSignals);
+            pendingSignals = [];
+            for (const descriptor of ordered) {
+                if (!isEffectivelyEnabled(descriptor.id)) {
+                    continue;
+                }
+                const systemHooks = hooks[descriptor.id];
+                for (const signal of signals) {
+                    systemHooks?.signal?.(context(descriptor.id), signal);
+                }
+                if (descriptor.signalsOnly !== true) {
+                    systemHooks?.update?.(context(descriptor.id));
+                }
+            }
+            frame += 1;
+        },
+        snapshot() {
+            return lifecycleSnapshot(frame, initialized, enabled, counters, pendingSignals, log);
+        },
+        restore(snapshot) {
+            validateLifecycleSnapshot(snapshot, descriptorById);
+            frame = snapshot.frame;
+            initialized = new Set(snapshot.initialized);
+            enabled = new Set(snapshot.enabled);
+            counters = new Map(stableRecordKeys(snapshot.counters).map((key) => [key, snapshot.counters[key]]));
+            pendingSignals = snapshot.pendingSignals.map((signal) => (0, canonical_js_1.cloneCanonical)(signal));
+            log = [...snapshot.log];
+        },
+    };
+}
+function runDeterministicLifecycleFixture(frames = 128) {
+    const descriptors = [
+        { id: 'root', order: 0 },
+        { id: 'child', order: 1, parentId: 'root' },
+        { id: 'late', order: 2, startEnabled: false },
+        { id: 'signals', order: 3, signalsOnly: true },
+    ];
+    const hooks = Object.fromEntries(descriptors.map((descriptor) => [descriptor.id, lifecycleCountingHooks(descriptor.id)]));
+    const runner = createDeterministicLifecycleRunner(descriptors, hooks);
+    let snapshot;
+    for (let frame = 0; frame < frames; frame += 1) {
+        if (frame === 4)
+            runner.enable('late');
+        if (frame === 8)
+            runner.disable('root');
+        if (frame === 12)
+            runner.enable('root');
+        if (frame % 5 === 0)
+            runner.signal({ id: 'tick', payload: { frame } });
+        if (frame === Math.floor(frames / 2))
+            snapshot = runner.snapshot();
+        runner.step();
+    }
+    const checksum = runner.snapshot().checksum;
+    if (snapshot === undefined) {
+        throw new Error('Lifecycle fixture did not capture snapshot');
+    }
+    const restored = createDeterministicLifecycleRunner(descriptors, hooks);
+    restored.restore(snapshot);
+    for (let frame = snapshot.frame; frame < frames; frame += 1) {
+        if (frame === 4)
+            restored.enable('late');
+        if (frame === 8)
+            restored.disable('root');
+        if (frame === 12)
+            restored.enable('root');
+        if (frame % 5 === 0)
+            restored.signal({ id: 'tick', payload: { frame } });
+        restored.step();
+    }
+    const restoredSnapshot = restored.snapshot();
+    return {
+        checksum,
+        restoredChecksum: restoredSnapshot.checksum,
+        rollbackEquivalent: checksum === restoredSnapshot.checksum,
+        ...summarizeDeterministicLifecycleCounters(restoredSnapshot.counters, restoredSnapshot.log),
+    };
+}
+function summarizeDeterministicLifecycleCounters(counters, log) {
+    return {
+        initCalls: counters.init ?? 0,
+        updateCalls: counters.update ?? 0,
+        enabledCalls: counters.enabled ?? 0,
+        disabledCalls: counters.disabled ?? 0,
+        signalCalls: counters.signal ?? 0,
+        hierarchySkippedUpdates: countMissingChildUpdates(log, 8, 12),
+        startDisabledCovered: log.some((entry) => entry.endsWith('late:enabled')),
+        signalOnlySkippedUpdate: log.length > 0 && log.every((entry) => !entry.includes(':signals:update')),
+        orderStable: firstFrameOrder(log).join(',') === 'root,child',
+    };
+}
+function lifecycleCountingHooks(systemId) {
+    return {
+        onInit(ctx) {
+            ctx.increment('init');
+            ctx.emit('init');
+        },
+        onEnabled(ctx) {
+            ctx.increment('enabled');
+            ctx.emit('enabled');
+        },
+        onDisabled(ctx) {
+            ctx.increment('disabled');
+            ctx.emit('disabled');
+        },
+        update(ctx) {
+            ctx.increment('update');
+            ctx.emit('update');
+        },
+        signal(ctx, signal) {
+            ctx.increment('signal');
+            ctx.emit(`signal:${signal.id}:${systemId}`);
+        },
+    };
+}
+function lifecycleSnapshot(frame, initialized, enabled, counters, pendingSignals, log) {
+    const body = {
+        frame,
+        initialized: [...initialized].sort(compareStrings),
+        enabled: [...enabled].sort(compareStrings),
+        counters: Object.fromEntries([...counters.entries()].sort((left, right) => compareStrings(left[0], right[0]))),
+        pendingSignals: [...pendingSignals].sort(compareLifecycleSignals).map((signal) => (0, canonical_js_1.cloneCanonical)(signal)),
+        log: [...log],
+    };
+    return { ...body, checksum: (0, canonical_js_1.defaultChecksum)(body) };
+}
+function validateLifecycleDescriptors(descriptors, hooks) {
+    const ids = new Set();
+    for (const descriptor of descriptors) {
+        if (typeof descriptor.id !== 'string' || !/^[A-Za-z][A-Za-z0-9_-]*$/.test(descriptor.id)) {
+            throw new Error(`Invalid lifecycle system id ${descriptor.id}`);
+        }
+        if (ids.has(descriptor.id)) {
+            throw new Error(`Duplicate lifecycle system id ${descriptor.id}`);
+        }
+        ids.add(descriptor.id);
+        if (!Number.isInteger(descriptor.order)) {
+            throw new Error(`Lifecycle system ${descriptor.id} order must be an integer`);
+        }
+    }
+    for (const descriptor of descriptors) {
+        if (descriptor.parentId !== undefined && typeof descriptor.parentId !== 'string') {
+            throw new Error(`Lifecycle system ${descriptor.id} references invalid parent ${descriptor.parentId}`);
+        }
+        if (descriptor.parentId !== undefined && !ids.has(descriptor.parentId)) {
+            throw new Error(`Lifecycle system ${descriptor.id} references missing parent ${descriptor.parentId}`);
+        }
+        if (hooks[descriptor.id] === undefined) {
+            throw new Error(`Lifecycle system ${descriptor.id} missing hooks`);
+        }
+    }
+    for (const descriptor of descriptors) {
+        validateParentChain(descriptor.id, new Set(), descriptors);
+    }
+}
+function validateParentChain(systemId, seen, descriptors) {
+    if (seen.has(systemId)) {
+        throw new Error(`Lifecycle system ${systemId} parent chain contains a cycle`);
+    }
+    seen.add(systemId);
+    const descriptor = descriptors.find((candidate) => candidate.id === systemId);
+    if (descriptor?.parentId !== undefined) {
+        validateParentChain(descriptor.parentId, seen, descriptors);
+    }
+    seen.delete(systemId);
+}
+function validateLifecycleSnapshot(snapshot, descriptors) {
+    if (!Number.isInteger(snapshot.frame) || snapshot.frame < 0) {
+        throw new Error('Lifecycle snapshot frame must be a non-negative integer');
+    }
+    for (const systemId of [...snapshot.initialized, ...snapshot.enabled]) {
+        if (!descriptors.has(systemId)) {
+            throw new Error(`Lifecycle snapshot references unknown system ${systemId}`);
+        }
+    }
+    for (const key of stableRecordKeys(snapshot.counters)) {
+        const value = snapshot.counters[key];
+        if (typeof value !== 'number' || !Number.isFinite(value)) {
+            throw new Error(`Lifecycle snapshot counter ${key} must be finite`);
+        }
+    }
+    const expected = lifecycleSnapshot(snapshot.frame, new Set(snapshot.initialized), new Set(snapshot.enabled), new Map(stableRecordKeys(snapshot.counters).map((key) => [key, snapshot.counters[key]])), snapshot.pendingSignals, snapshot.log).checksum;
+    if (snapshot.checksum !== expected) {
+        throw new Error('Lifecycle snapshot checksum mismatch');
+    }
+}
+function assertLifecycleSystem(descriptors, systemId) {
+    if (!descriptors.has(systemId)) {
+        throw new Error(`Unknown lifecycle system ${systemId}`);
+    }
+}
+function countMissingChildUpdates(log, startFrame, endFrame) {
+    let missing = 0;
+    const observedFrames = new Set(log.map((entry) => Number(entry.split(':')[0])).filter((frame) => Number.isInteger(frame)));
+    for (let frame = startFrame; frame < endFrame; frame += 1) {
+        if (observedFrames.has(frame) && !log.includes(`${frame}:child:update`)) {
+            missing += 1;
+        }
+    }
+    return missing;
+}
+function firstFrameOrder(log) {
+    return log
+        .filter((entry) => entry.startsWith('0:') && entry.endsWith(':update'))
+        .map((entry) => entry.split(':')[1]);
+}
+function compareLifecycleDescriptors(left, right) {
+    return left.order - right.order || compareStrings(left.id, right.id);
+}
+function compareLifecycleSignals(left, right) {
+    return compareStrings(left.id, right.id) || compareStrings((0, canonical_js_1.defaultChecksum)(left.payload), (0, canonical_js_1.defaultChecksum)(right.payload));
+}
+function compareStrings(left, right) {
+    return left < right ? -1 : left > right ? 1 : 0;
+}
+function stableRecordKeys(record) {
+    return Reflect.ownKeys(record)
+        .filter((key) => typeof key === 'string')
+        .sort(compareStrings);
+}

package/dist/cjs/timers.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.framesToMilliseconds = framesToMilliseconds;
+exports.millisecondsToFrames = millisecondsToFrames;
+exports.createCooldown = createCooldown;
+exports.tickCooldown = tickCooldown;
+exports.scheduleFrameEvent = scheduleFrameEvent;
+exports.popDueFrameEvents = popDueFrameEvents;
+function framesToMilliseconds(frames, tickRate) {
+    assertNonNegativeInteger('frames', frames);
+    assertPositiveInteger('tickRate', tickRate);
+    return Math.trunc((frames * 1000) / tickRate);
+}
+function millisecondsToFrames(milliseconds, tickRate) {
+    if (!Number.isFinite(milliseconds) || milliseconds < 0) {
+        throw new Error('milliseconds must be a finite non-negative number');
+    }
+    assertPositiveInteger('tickRate', tickRate);
+    return Math.ceil((milliseconds * tickRate) / 1000);
+}
+function createCooldown(durationFrames) {
+    assertNonNegativeInteger('durationFrames', durationFrames);
+    return {
+        remainingFrames: durationFrames,
+        ready: durationFrames === 0,
+    };
+}
+function tickCooldown(cooldown, frames = 1) {
+    assertNonNegativeInteger('frames', frames);
+    const remainingFrames = Math.max(0, cooldown.remainingFrames - frames);
+    return {
+        remainingFrames,
+        ready: remainingFrames === 0,
+    };
+}
+function scheduleFrameEvent(currentFrame, delayFrames, event) {
+    assertNonNegativeInteger('currentFrame', currentFrame);
+    assertNonNegativeInteger('delayFrames', delayFrames);
+    return {
+        frame: currentFrame + delayFrames,
+        event,
+    };
+}
+function popDueFrameEvents(currentFrame, events) {
+    assertNonNegativeInteger('currentFrame', currentFrame);
+    const sorted = [...events].sort((left, right) => left.frame - right.frame);
+    return {
+        due: sorted.filter((entry) => entry.frame <= currentFrame),
+        pending: sorted.filter((entry) => entry.frame > currentFrame),
+    };
+}
+function assertNonNegativeInteger(label, value) {
+    if (!Number.isInteger(value) || value < 0) {
+        throw new Error(`${label} must be a non-negative integer`);
+    }
+}
+function assertPositiveInteger(label, value) {
+    if (!Number.isInteger(value) || value <= 0) {
+        throw new Error(`${label} must be a positive integer`);
+    }
+}