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

package/dist/cjs/session-snapshot.js

@@ -0,0 +1,265 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_MAX_SNAPSHOT_BYTES = exports.DEFAULT_SNAPSHOT_CHUNK_SIZE = void 0;
+exports.deterministicRoomDescriptorHash = deterministicRoomDescriptorHash;
+exports.encodeDeterministicStateSnapshot = encodeDeterministicStateSnapshot;
+exports.decodeDeterministicStateSnapshot = decodeDeterministicStateSnapshot;
+exports.bytesToBase64 = bytesToBase64;
+exports.base64ToBytes = base64ToBytes;
+exports.createSnapshotTransferFromBytes = createSnapshotTransferFromBytes;
+exports.createSnapshotTransferCollector = createSnapshotTransferCollector;
+const canonical_js_1 = require("./canonical.js");
+/**
+ * Room-level snapshot identity, computable by the game-agnostic authority AND
+ * every client from the session-start parameters — the `descriptorHash` on
+ * snapshot wire envelopes. Game-build identity (`schemaHash`) is layered on
+ * top by clients, which know their schema ids; the authority passes it through
+ * opaquely.
+ */
+function deterministicRoomDescriptorHash(params) {
+    return (0, canonical_js_1.defaultChecksum)({
+        kind: 'rdm-room-descriptor',
+        seed: params.seed,
+        playerCount: params.playerCount,
+        tickRateHz: params.tickRateHz,
+        hardToleranceTicks: params.hardToleranceTicks,
+    });
+}
+function encodeDeterministicStateSnapshot(snapshot) {
+    return (0, canonical_js_1.canonicalStringify)(snapshot);
+}
+function decodeDeterministicStateSnapshot(text) {
+    let parsed;
+    try {
+        parsed = JSON.parse(text);
+    }
+    catch {
+        return { ok: false, reason: 'invalid-json' };
+    }
+    if (!isRecord(parsed)) {
+        return { ok: false, reason: 'not-a-snapshot' };
+    }
+    if (parsed.v !== 1) {
+        return { ok: false, reason: 'unsupported-snapshot-version' };
+    }
+    if (!isNonNegativeInt(parsed.tick) ||
+        !isNonNegativeInt(parsed.sessionFrame) ||
+        parsed.sessionFrame !== parsed.tick + 1 ||
+        typeof parsed.stateBytes !== 'string' ||
+        !Number.isInteger(parsed.randomState) ||
+        typeof parsed.stateChecksum !== 'string' ||
+        parsed.stateChecksum.length === 0 ||
+        !Array.isArray(parsed.confirmedInputs)) {
+        return { ok: false, reason: 'malformed-snapshot' };
+    }
+    return {
+        ok: true,
+        snapshot: {
+            v: 1,
+            tick: parsed.tick,
+            sessionFrame: parsed.sessionFrame,
+            stateBytes: parsed.stateBytes,
+            randomState: parsed.randomState,
+            stateChecksum: parsed.stateChecksum,
+            confirmedInputs: (0, canonical_js_1.cloneCanonical)(parsed.confirmedInputs),
+        },
+    };
+}
+// ── base64 (browser-safe: no Buffer, no atob dependency) ──
+const BASE64_ALPHABET = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
+const BASE64_LOOKUP = new Map([...BASE64_ALPHABET].map((char, index) => [char, index]));
+function bytesToBase64(bytes) {
+    let out = '';
+    for (let index = 0; index < bytes.length; index += 3) {
+        const b0 = bytes[index];
+        const b1 = index + 1 < bytes.length ? bytes[index + 1] : 0;
+        const b2 = index + 2 < bytes.length ? bytes[index + 2] : 0;
+        out += BASE64_ALPHABET[b0 >> 2];
+        out += BASE64_ALPHABET[((b0 & 0x03) << 4) | (b1 >> 4)];
+        out += index + 1 < bytes.length ? BASE64_ALPHABET[((b1 & 0x0f) << 2) | (b2 >> 6)] : '=';
+        out += index + 2 < bytes.length ? BASE64_ALPHABET[b2 & 0x3f] : '=';
+    }
+    return out;
+}
+function base64ToBytes(text) {
+    if (text.length % 4 !== 0) {
+        throw new Error('base64 length must be a multiple of 4');
+    }
+    const padding = text.endsWith('==') ? 2 : text.endsWith('=') ? 1 : 0;
+    const byteLength = (text.length / 4) * 3 - padding;
+    const bytes = new Uint8Array(byteLength);
+    let byteIndex = 0;
+    for (let index = 0; index < text.length; index += 4) {
+        const values = [];
+        for (let offset = 0; offset < 4; offset += 1) {
+            const char = text[index + offset];
+            if (char === '=') {
+                if (index + 4 < text.length || offset < 2) {
+                    throw new Error('base64 padding is only valid at the end');
+                }
+                values.push(0);
+                continue;
+            }
+            const value = BASE64_LOOKUP.get(char);
+            if (value === undefined) {
+                throw new Error(`invalid base64 character ${JSON.stringify(char)}`);
+            }
+            values.push(value);
+        }
+        const triple = (values[0] << 18) | (values[1] << 12) | (values[2] << 6) | values[3];
+        if (byteIndex < byteLength)
+            bytes[byteIndex++] = (triple >> 16) & 0xff;
+        if (byteIndex < byteLength)
+            bytes[byteIndex++] = (triple >> 8) & 0xff;
+        if (byteIndex < byteLength)
+            bytes[byteIndex++] = triple & 0xff;
+    }
+    return bytes;
+}
+// ── transfer builder (raw bytes → frozen wire transfer shape) ──
+exports.DEFAULT_SNAPSHOT_CHUNK_SIZE = 262_144;
+exports.DEFAULT_MAX_SNAPSHOT_BYTES = 4_194_304;
+function createSnapshotTransferFromBytes(snapshotBytes, options) {
+    const chunkSize = options.chunkSize ?? exports.DEFAULT_SNAPSHOT_CHUNK_SIZE;
+    if (!Number.isInteger(chunkSize) || chunkSize <= 0) {
+        throw new Error('Snapshot chunkSize must be a positive integer');
+    }
+    if (snapshotBytes.length === 0) {
+        throw new Error('Snapshot bytes must be non-empty');
+    }
+    const chunks = [];
+    for (let offset = 0; offset < snapshotBytes.length; offset += chunkSize) {
+        chunks.push(snapshotBytes.slice(offset, offset + chunkSize));
+    }
+    return {
+        transferId: options.transferId,
+        identity: (0, canonical_js_1.cloneCanonical)(options.identity),
+        frame: options.frame,
+        snapshotChecksum: (0, canonical_js_1.defaultChecksum)(snapshotBytes),
+        snapshotBytes,
+        chunkSize,
+        chunks,
+        chunkChecksums: chunks.map((chunk) => (0, canonical_js_1.defaultChecksum)(chunk)),
+    };
+}
+function createSnapshotTransferCollector(options = {}) {
+    const maxSnapshotBytes = options.maxSnapshotBytes ?? exports.DEFAULT_MAX_SNAPSHOT_BYTES;
+    const pending = new Map();
+    return {
+        offer(payload) {
+            const identity = parseIdentity(payload.identity);
+            if (typeof payload.transferId !== 'string' ||
+                payload.transferId.length === 0 ||
+                identity === undefined ||
+                !isNonNegativeInt(payload.frame) ||
+                typeof payload.snapshotChecksum !== 'string' ||
+                !isNonNegativeInt(payload.chunkCount) ||
+                payload.chunkCount < 1 ||
+                !isNonNegativeInt(payload.totalBytes) ||
+                payload.totalBytes < 1 ||
+                // Every chunk carries at least one character, so a chunkCount that
+                // exceeds totalBytes is self-contradictory (forged offer).
+                payload.chunkCount > payload.totalBytes ||
+                !isStringArray(payload.chunkChecksums) ||
+                payload.chunkChecksums.length !== payload.chunkCount) {
+                return { accepted: false, reason: 'malformed-snapshot-offer' };
+            }
+            if (payload.totalBytes > maxSnapshotBytes) {
+                return { accepted: false, reason: 'snapshot-too-large' };
+            }
+            pending.set(payload.transferId, {
+                transferId: payload.transferId,
+                identity,
+                frame: payload.frame,
+                snapshotChecksum: payload.snapshotChecksum,
+                chunkCount: payload.chunkCount,
+                totalBytes: payload.totalBytes,
+                chunkChecksums: [...payload.chunkChecksums],
+                chunks: new Map(),
+            });
+            return { accepted: true };
+        },
+        chunk(payload) {
+            if (typeof payload.transferId !== 'string') {
+                return { accepted: false, reason: 'malformed-snapshot-chunk' };
+            }
+            const transfer = pending.get(payload.transferId);
+            if (transfer === undefined) {
+                return { accepted: false, reason: 'unknown-snapshot-transfer' };
+            }
+            if (typeof payload.chunk !== 'string' || typeof payload.chunkChecksum !== 'string') {
+                return { accepted: false, reason: 'malformed-snapshot-chunk' };
+            }
+            const chunkIndex = payload.chunkIndex;
+            if (!isNonNegativeInt(chunkIndex) || chunkIndex >= transfer.chunkCount) {
+                return { accepted: false, reason: 'snapshot-chunk-index-out-of-range' };
+            }
+            if (transfer.chunks.has(chunkIndex)) {
+                return { accepted: false, reason: 'duplicate-snapshot-chunk' };
+            }
+            if (transfer.chunkChecksums[chunkIndex] !== payload.chunkChecksum ||
+                (0, canonical_js_1.defaultChecksum)(payload.chunk) !== payload.chunkChecksum) {
+                return { accepted: false, reason: 'snapshot-chunk-checksum-mismatch' };
+            }
+            transfer.chunks.set(chunkIndex, payload.chunk);
+            return { accepted: true };
+        },
+        complete(payload) {
+            if (typeof payload.transferId !== 'string') {
+                return { accepted: false, reason: 'malformed-snapshot-complete' };
+            }
+            const transfer = pending.get(payload.transferId);
+            if (transfer === undefined) {
+                return { accepted: false, reason: 'unknown-snapshot-transfer' };
+            }
+            if (transfer.chunks.size !== transfer.chunkCount) {
+                return { accepted: false, reason: 'missing-snapshot-chunk' };
+            }
+            const snapshotBytes = Array.from({ length: transfer.chunkCount }, (_, index) => transfer.chunks.get(index)).join('');
+            // A failed terminal check consumes the transfer either way — the bytes are bad.
+            pending.delete(payload.transferId);
+            if (snapshotBytes.length !== transfer.totalBytes) {
+                return { accepted: false, reason: 'snapshot-byte-length-mismatch' };
+            }
+            if ((0, canonical_js_1.defaultChecksum)(snapshotBytes) !== transfer.snapshotChecksum) {
+                return { accepted: false, reason: 'snapshot-transfer-checksum-mismatch' };
+            }
+            return {
+                accepted: true,
+                transfer: {
+                    transferId: transfer.transferId,
+                    identity: transfer.identity,
+                    frame: transfer.frame,
+                    snapshotChecksum: transfer.snapshotChecksum,
+                    snapshotBytes,
+                },
+            };
+        },
+        abort(transferId) {
+            pending.delete(transferId);
+        },
+        get pendingTransferIds() {
+            return [...pending.keys()];
+        },
+    };
+}
+function parseIdentity(value) {
+    if (!isRecord(value) || typeof value.descriptorHash !== 'string' || value.descriptorHash.length === 0) {
+        return undefined;
+    }
+    return {
+        descriptorHash: value.descriptorHash,
+        ...(typeof value.schemaHash === 'string' ? { schemaHash: value.schemaHash } : {}),
+        ...(typeof value.assetDbHash === 'string' ? { assetDbHash: value.assetDbHash } : {}),
+        ...(typeof value.configHash === 'string' ? { configHash: value.configHash } : {}),
+    };
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function isNonNegativeInt(value) {
+    return typeof value === 'number' && Number.isInteger(value) && value >= 0;
+}
+function isStringArray(value) {
+    return Array.isArray(value) && value.every((entry) => typeof entry === 'string');
+}

package/dist/cjs/session-wire.js

@@ -0,0 +1,216 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deterministicSessionWireVersion = void 0;
+exports.encodeDeterministicSessionMessage = encodeDeterministicSessionMessage;
+exports.decodeDeterministicSessionMessage = decodeDeterministicSessionMessage;
+const canonical_js_1 = require("./canonical.js");
+const local_authority_wire_js_1 = require("./local-authority-wire.js");
+/**
+ * Frozen v1 session-control wire protocol for game-agnostic input-authority rooms (§8, M1).
+ *
+ * Covers the server/client roles for a live match: session-start (slot assignment + the
+ * server-owned RNG seed + tick params), clock/time-sync, input, confirmed-input (the verified
+ * tick), reconnect, spectator, and close/error. Snapshot request/offer/chunk/complete for
+ * late-join reuse the existing envelopes in `local-authority-wire.ts` (wired at M5).
+ *
+ * Both families share the `rdm-local-authority/v1` version namespace. Decoding is FAIL-CLOSED:
+ * unknown protocol, unknown version, unknown kind, malformed payload, or checksum mismatch are
+ * rejected with a reason — never silently coerced. This is a public forward-compat boundary; the
+ * discriminants below are frozen and must only be extended, never repurposed.
+ */
+exports.deterministicSessionWireVersion = 1;
+const sessionMessageKinds = new Set([
+    'session-start',
+    'time-sync-ping',
+    'time-sync-pong',
+    'input',
+    'confirmed-input',
+    'reconnect',
+    'spectator-join',
+    'checksum-report',
+    'net-stats',
+    'close',
+    'error',
+]);
+function encodeDeterministicSessionMessage(message) {
+    const { kind, ...rest } = message;
+    const payload = rest;
+    const envelope = {
+        protocol: local_authority_wire_js_1.deterministicLocalAuthorityWireProtocol,
+        v: exports.deterministicSessionWireVersion,
+        kind,
+        payload,
+        checksum: sessionChecksum(kind, payload),
+    };
+    return (0, canonical_js_1.canonicalStringify)(envelope);
+}
+function decodeDeterministicSessionMessage(text) {
+    let parsed;
+    try {
+        parsed = JSON.parse(text);
+    }
+    catch {
+        return { ok: false, reason: 'invalid-json' };
+    }
+    if (!isRecord(parsed)) {
+        return { ok: false, reason: 'not-an-envelope' };
+    }
+    if (parsed.protocol !== local_authority_wire_js_1.deterministicLocalAuthorityWireProtocol) {
+        return { ok: false, reason: 'unknown-protocol' };
+    }
+    if (parsed.v !== exports.deterministicSessionWireVersion) {
+        return { ok: false, reason: 'unknown-version' };
+    }
+    if (typeof parsed.kind !== 'string' || !sessionMessageKinds.has(parsed.kind)) {
+        return { ok: false, reason: 'unknown-kind' };
+    }
+    const kind = parsed.kind;
+    if (!isRecord(parsed.payload)) {
+        return { ok: false, reason: 'malformed-payload' };
+    }
+    // Symmetry with encode: the encoder checksummed the LIVE payload value and
+    // then canonical-encoded it, so sentinel values (-0, NaN, ±Infinity,
+    // undefined, bigint, Map/Set/typed arrays) sit on the wire as literal
+    // `{"$rdm":…}` objects. Decode them back to real values BEFORE recomputing
+    // the checksum — hashing the raw parse output would trip canonicalize's
+    // reserved-key guard and throw out of a decoder whose contract is
+    // fail-closed. Any malformed/hostile `$rdm` literal lands in the catch.
+    let payload;
+    let expectedChecksum;
+    try {
+        const decoded = (0, canonical_js_1.decodeCanonicalValue)(parsed.payload);
+        if (!isRecord(decoded)) {
+            return { ok: false, reason: 'malformed-payload' };
+        }
+        payload = decoded;
+        expectedChecksum = sessionChecksum(kind, payload);
+    }
+    catch {
+        return { ok: false, reason: 'malformed-payload' };
+    }
+    if (parsed.checksum !== expectedChecksum) {
+        return { ok: false, reason: 'checksum-mismatch' };
+    }
+    const message = parseSessionPayload(kind, payload);
+    if (message === undefined) {
+        return { ok: false, reason: 'malformed-payload' };
+    }
+    return { ok: true, message };
+}
+function parseSessionPayload(kind, payload) {
+    switch (kind) {
+        case 'session-start':
+            if (isInt(payload.slot) &&
+                isInt(payload.playerCount) &&
+                isInt(payload.seed) &&
+                isFiniteNumber(payload.tickRateHz) &&
+                isInt(payload.hardToleranceTicks) &&
+                isRole(payload.role)) {
+                return {
+                    kind,
+                    slot: payload.slot,
+                    playerCount: payload.playerCount,
+                    seed: payload.seed,
+                    tickRateHz: payload.tickRateHz,
+                    hardToleranceTicks: payload.hardToleranceTicks,
+                    role: payload.role,
+                };
+            }
+            return undefined;
+        case 'time-sync-ping':
+            if (isInt(payload.clientSendTick) && isInt(payload.nonce)) {
+                return { kind, clientSendTick: payload.clientSendTick, nonce: payload.nonce };
+            }
+            return undefined;
+        case 'time-sync-pong':
+            if (isInt(payload.clientSendTick) && isInt(payload.nonce) && isInt(payload.authorityTick)) {
+                return { kind, clientSendTick: payload.clientSendTick, nonce: payload.nonce, authorityTick: payload.authorityTick };
+            }
+            return undefined;
+        case 'input':
+            if (isInt(payload.slot) && isInt(payload.tick) && isInt(payload.attempt) && payload.input !== undefined) {
+                return { kind, slot: payload.slot, tick: payload.tick, input: payload.input, attempt: payload.attempt };
+            }
+            return undefined;
+        case 'confirmed-input':
+            if (isInt(payload.authorityTick) && isConfirmedFrameArray(payload.frames)) {
+                return { kind, authorityTick: payload.authorityTick, frames: payload.frames };
+            }
+            return undefined;
+        case 'reconnect':
+            if (isInt(payload.slot) && isInt(payload.resumeFromTick)) {
+                return { kind, slot: payload.slot, resumeFromTick: payload.resumeFromTick };
+            }
+            return undefined;
+        case 'spectator-join':
+            return { kind };
+        case 'checksum-report':
+            if (isInt(payload.slot) && isInt(payload.tick) && typeof payload.checksum === 'string') {
+                return { kind, slot: payload.slot, tick: payload.tick, checksum: payload.checksum };
+            }
+            return undefined;
+        case 'net-stats':
+            if (isInt(payload.slot) &&
+                isInt(payload.tick) &&
+                isInt(payload.rttMs) &&
+                isInt(payload.rollbacks) &&
+                isInt(payload.maxRollbackDepth) &&
+                isInt(payload.timescalePermille) &&
+                isInt(payload.inputDelayTicks)) {
+                return {
+                    kind,
+                    slot: payload.slot,
+                    tick: payload.tick,
+                    rttMs: payload.rttMs,
+                    rollbacks: payload.rollbacks,
+                    maxRollbackDepth: payload.maxRollbackDepth,
+                    timescalePermille: payload.timescalePermille,
+                    inputDelayTicks: payload.inputDelayTicks,
+                };
+            }
+            return undefined;
+        case 'close':
+            if (typeof payload.code === 'string' && typeof payload.reason === 'string') {
+                return { kind, code: payload.code, reason: payload.reason };
+            }
+            return undefined;
+        case 'error':
+            if (typeof payload.code === 'string' && typeof payload.message === 'string') {
+                return { kind, code: payload.code, message: payload.message };
+            }
+            return undefined;
+        default:
+            return assertNever(kind);
+    }
+}
+function sessionChecksum(kind, payload) {
+    return String((0, canonical_js_1.defaultChecksum)({ protocol: local_authority_wire_js_1.deterministicLocalAuthorityWireProtocol, v: exports.deterministicSessionWireVersion, kind, payload }));
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function isInt(value) {
+    return typeof value === 'number' && Number.isInteger(value);
+}
+function isFiniteNumber(value) {
+    return typeof value === 'number' && Number.isFinite(value);
+}
+function isRole(value) {
+    return value === 'player' || value === 'spectator';
+}
+function isConfirmedFrameArray(value) {
+    // The codec is stateless (it does not know playerCount), so it cannot check inputs.length — the
+    // consumer validates that against its own slot count. It CAN reject a frame whose substituted-slot
+    // indices are not integers (a string index survives JSON.parse and would corrupt slot handling).
+    return (Array.isArray(value) &&
+        value.every((frame) => isRecord(frame) &&
+            isInt(frame.tick) &&
+            Array.isArray(frame.inputs) &&
+            Array.isArray(frame.substitutedSlots) &&
+            frame.substitutedSlots.every((slot) => isInt(slot)) &&
+            typeof frame.checksum === 'string'));
+}
+function assertNever(value) {
+    void value;
+    return undefined;
+}

package/dist/cjs/signals.js

@@ -0,0 +1,103 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createDeterministicSignalBus = createDeterministicSignalBus;
+exports.runDeterministicSignalFixture = runDeterministicSignalFixture;
+const canonical_js_1 = require("./canonical.js");
+function createDeterministicSignalBus(subscriptions) {
+    const orderedSubscriptions = [...subscriptions].sort(compareSubscriptions);
+    const emitted = [];
+    const dispatched = [];
+    let sequence = 0;
+    return {
+        emit(signal) {
+            emitted.push({ sequence, signal: (0, canonical_js_1.cloneCanonical)(signal) });
+            sequence += 1;
+        },
+        dispatch(state, frame) {
+            let nextState = (0, canonical_js_1.cloneCanonical)(state);
+            const due = emitted
+                .filter((entry) => entry.signal.frame <= frame)
+                .sort(compareQueuedSignals);
+            for (const entry of due) {
+                for (const subscription of orderedSubscriptions) {
+                    if (subscription.type === entry.signal.type) {
+                        nextState = subscription.handle(nextState, entry.signal);
+                    }
+                }
+                dispatched.push((0, canonical_js_1.cloneCanonical)(entry.signal));
+            }
+            const dueSequences = new Set(due.map((entry) => entry.sequence));
+            for (let index = emitted.length - 1; index >= 0; index -= 1) {
+                if (dueSequences.has(emitted[index].sequence)) {
+                    emitted.splice(index, 1);
+                }
+            }
+            return nextState;
+        },
+        snapshot() {
+            const snapshot = {
+                emitted: emitted.sort(compareQueuedSignals).map((entry) => entry.signal),
+                dispatched,
+                sequence,
+            };
+            return (0, canonical_js_1.cloneCanonical)(snapshot);
+        },
+        restore(snapshot) {
+            emitted.length = 0;
+            snapshot.emitted.forEach((signal, index) => emitted.push({ sequence: index, signal: (0, canonical_js_1.cloneCanonical)(signal) }));
+            dispatched.length = 0;
+            snapshot.dispatched.forEach((signal) => dispatched.push((0, canonical_js_1.cloneCanonical)(signal)));
+            sequence = snapshot.sequence;
+        },
+    };
+}
+function runDeterministicSignalFixture() {
+    const subscriptions = [
+        {
+            id: 'score',
+            type: 'hit',
+            order: 20,
+            handle: (state, signal) => ({
+                ...state,
+                score: state.score + Number(signal.payload.points),
+                trace: [...state.trace, `score:${signal.payload.points}`],
+            }),
+        },
+        {
+            id: 'damage',
+            type: 'hit',
+            order: 10,
+            handle: (state, signal) => ({
+                ...state,
+                damage: state.damage + Number(signal.payload.damage),
+                trace: [...state.trace, `damage:${signal.payload.damage}`],
+            }),
+        },
+    ];
+    const bus = createDeterministicSignalBus(subscriptions);
+    const initial = { score: 0, damage: 0, trace: [] };
+    bus.emit({ frame: 2, type: 'hit', payload: { points: 3, damage: 1 } });
+    bus.emit({ frame: 1, type: 'hit', payload: { points: 5, damage: 2 } });
+    const snapshot = bus.snapshot();
+    const after = bus.dispatch(bus.dispatch(initial, 1), 2);
+    const checksum = (0, canonical_js_1.defaultChecksum)(after);
+    const restoredBus = createDeterministicSignalBus(subscriptions);
+    restoredBus.restore(snapshot);
+    const restored = restoredBus.dispatch(restoredBus.dispatch(initial, 1), 2);
+    return {
+        checksum,
+        restoredChecksum: (0, canonical_js_1.defaultChecksum)(restored),
+        dispatchedSignals: bus.snapshot().dispatched.length,
+        subscriptionOrderStable: after.trace.join('|') === 'damage:2|score:5|damage:1|score:3',
+        rollbackEquivalent: checksum === (0, canonical_js_1.defaultChecksum)(restored),
+    };
+}
+function compareSubscriptions(left, right) {
+    return left.order - right.order || compareStrings(left.id, right.id);
+}
+function compareQueuedSignals(left, right) {
+    return left.signal.frame - right.signal.frame || left.sequence - right.sequence;
+}
+function compareStrings(left, right) {
+    return left < right ? -1 : left > right ? 1 : 0;
+}