@antha/multiplayer-p2p-lock-step 0.20.0 → 0.21.0

package/dist/antha-multiplayer-p2p-lock-step.mod.d.ts

@@ -1,6 +1,7 @@
 import { type ModExecuteParams } from '@antha/engine';
 import { type ApiAndRoomConnectionState, MultiplayerControllerClientStatusEvent } from '@antha/multiplayer-core';
 import { type JsonCompatibleValue, type MaybePromise, type PartialWithUndefined, type SelectFrom } from '@augment-vir/common';
+import { type AnyDuration } from 'date-vir';
 import { MultiplayerControllerFrameEvent, type MultiplayerFramePacket, P2pLockStepMultiplayerController, type P2pLockStepMultiplayerControllerParams } from './p2p-lock-step-multiplayer-controller.js';
 /**
  * Engine state added by the p2p-lock-step multiplayer mod.
@@ -39,6 +40,26 @@ export type AnthaMultiplayerP2pLockStepOptions<MultiplayerPacket extends JsonCom
     frameDuration: true;
     gameId: true;
 }>> & PartialWithUndefined<{
+    /**
+     * Enables automatic desync checks. Every `interval`, each peer hashes its state with
+     * `createStateHash` right after applying the same frame, and the host sends its hash to
+     * clients with a later frame. A client whose hash doesn't match logs a warning and emits
+     * `MultiplayerControllerDesyncEvent` (which is forwarded to the engine). Handle that event
+     * to recover from the desync.
+     *
+     * @default no desync checks
+     */
+    desyncCheck: {
+        interval: AnyDuration;
+        /**
+         * Hashes the state that must match across peers, for example with `hashObject` from
+         * `@antha/util`. Return `undefined` to skip reporting for this check, such as before a
+         * joining peer has received its initial state.
+         */
+        createStateHash: (params: Readonly<{
+            state: Partial<State>;
+        }>) => MaybePromise<number | undefined>;
+    };
     /** Applies an individual action from within a frame event. */
     handlePacket: (params: Readonly<{
         packet: Readonly<MultiplayerFramePacket<MultiplayerPacket>>;

package/dist/antha-multiplayer-p2p-lock-step.mod.js

@@ -24,10 +24,13 @@ export function createAnthaMultiplayerP2pLockStepMod(options = {}) {
             debugMultiplayer: options.debugMultiplayer,
             multiplayerLockstepTick: 0,
         },
-        trigger: options.handlePacket || options.runFrameUpdate || options.handleClientStatus
+        trigger: options.handlePacket ||
+            options.runFrameUpdate ||
+            options.desyncCheck ||
+            options.handleClientStatus
             ? {
                 event: [
-                    ...(options.handlePacket || options.runFrameUpdate
+                    ...(options.handlePacket || options.runFrameUpdate || options.desyncCheck
                         ? [MultiplayerControllerFrameEvent]
                         : []),
                     ...(options.handleClientStatus
@@ -50,6 +53,7 @@ export function createAnthaMultiplayerP2pLockStepMod(options = {}) {
                         gameId: options.gameId || 'antha',
                         acceptConnection: options.acceptConnection,
                         debugMultiplayer: state.debugMultiplayer,
+                        desyncCheckInterval: options.desyncCheck?.interval,
                         frameDuration: options.frameDuration,
                     }),
                     connectionState: emptyApiAndRoomConnectionState,
@@ -79,9 +83,10 @@ export function createAnthaMultiplayerP2pLockStepMod(options = {}) {
                         return;
                     }
                     else if (event instanceof MultiplayerControllerFrameEvent &&
-                        (options.handlePacket || options.runFrameUpdate)) {
+                        (options.handlePacket || options.runFrameUpdate || options.desyncCheck)) {
+                        state.multiplayerP2pLockStep.multiplayerController.checkStateHash(event);
                         if (options.handlePacket) {
-                            for (const detail of event.detail) {
+                            for (const detail of event.detail.packets) {
                                 await options.handlePacket({
                                     packet: detail,
                                     multiplayerController: state.multiplayerP2pLockStep.multiplayerController,
@@ -110,6 +115,14 @@ export function createAnthaMultiplayerP2pLockStepMod(options = {}) {
                             multiplayerFrameEvent: event,
                             ticksSinceLastExecute: 1,
                         });
+                        if (event.detail.shouldReportNextFrameHash) {
+                            state.multiplayerP2pLockStep.multiplayerController.reportStateHash({
+                                frameEvent: event,
+                                stateHash: await options.desyncCheck?.createStateHash({
+                                    state,
+                                }),
+                            });
+                        }
                     }
                 });
             }

package/dist/p2p-lock-step-multiplayer-controller.d.ts

@@ -12,7 +12,7 @@ export declare enum P2pLockStepMessageType {
     Frame = "frame"
 }
 /**
- * Data received from {@link MultiplayerControllerFrameEvent}.
+ * A single action within a {@link MultiplayerFrame}.
  *
  * @category Internal
  */
@@ -20,6 +20,25 @@ export type MultiplayerFramePacket<MultiplayerPacket extends JsonCompatibleValue
     packet: MultiplayerPacket;
     sourceClientId: ClientId;
 };
+/**
+ * Data received from {@link MultiplayerControllerFrameEvent}.
+ *
+ * @category Internal
+ */
+export type MultiplayerFrame<MultiplayerPacket extends JsonCompatibleValue> = {
+    packets: ReadonlyArray<MultiplayerFramePacket<MultiplayerPacket>>;
+} & PartialWithUndefined<{
+    /**
+     * On clients, the host's state hash from right after the most recent check frame. Pass this
+     * frame's event to {@link P2pLockStepMultiplayerController.checkStateHash} before applying it.
+     */
+    hostStateHash: number;
+    /**
+     * Whether to pass this frame's event and a state hash to
+     * {@link P2pLockStepMultiplayerController.reportStateHash} right after applying it.
+     */
+    shouldReportNextFrameHash: boolean;
+}>;
 /**
  * Message exchanged by p2p-lock-step clients.
  *
@@ -39,7 +58,33 @@ export type P2pLockStepMessage<MultiplayerPacket extends JsonCompatibleValue> =
 } & PartialWithUndefined<{
     /** Whether this frame is meant for syncing a new client. */
     isSynchronizationFrame: boolean;
+    /**
+     * Whether every peer should hash its state right after applying this frame, for a later
+     * desync check.
+     */
+    shouldReportNextFrameHash: boolean;
+    /** The host's state hash from right after the most recent desync check frame. */
+    stateHash: number;
 }>);
+/**
+ * Each {@link P2pLockStepMessage} variant, keyed by its message type.
+ *
+ * @category Internal
+ */
+export type P2pLockStepMessageByType<MultiplayerPacket extends JsonCompatibleValue> = {
+    [Type in P2pLockStepMessageType]: Readonly<Extract<P2pLockStepMessage<MultiplayerPacket>, {
+        type: Type;
+    }>>;
+};
+/**
+ * Data received from {@link MultiplayerControllerDesyncEvent}.
+ *
+ * @category Internal
+ */
+export type MultiplayerDesync = {
+    hostStateHash: number;
+    localStateHash: number;
+};
 /**
  * Constructor parameters for {@link P2pLockStepMultiplayerController}.
  *
@@ -62,6 +107,19 @@ export type P2pLockStepMultiplayerControllerParams<Action extends JsonCompatible
     acceptConnection?: ((connectingClientId: ClientId, multiplayerController: P2pLockStepMultiplayerController<Action>) => MaybePromise<boolean>) | undefined;
     /** Enables verbose multiplayer debug logs. */
     debugMultiplayer?: boolean | undefined;
+    /**
+     * The duration between desync check frames, rounded to a whole number of frames. Ignored when
+     * `frameDuration` is zero, because then frames only run manually. Every peer's frame event for
+     * a check frame has `shouldReportNextFrameHash` set: pass the state hash from right after
+     * applying that frame to {@link P2pLockStepMultiplayerController.reportStateHash}. The host
+     * sends its hash with the next frame it produces, and clients compare it against their own hash
+     * with {@link P2pLockStepMultiplayerController.checkStateHash} before applying that frame.
+     * Frames are never held for a hash: if the host doesn't report one before its next check frame,
+     * that check is skipped.
+     *
+     * @default no desync checks
+     */
+    desyncCheckInterval?: AnyDuration | undefined;
     /**
      * The duration between each frame. This should probably always be smaller than your supported
      * render frame duration.
@@ -89,15 +147,37 @@ declare const MultiplayerControllerFrameEvent_base: (new (eventInitDict: {
  * @category Events
  */
 export declare class MultiplayerControllerFrameEvent<MultiplayerPacket extends JsonCompatibleValue> extends MultiplayerControllerFrameEvent_base {
-    detail: ReadonlyArray<MultiplayerFramePacket<MultiplayerPacket>>;
-    constructor(eventInitDict: TypedCustomEventInit<ReadonlyArray<MultiplayerFramePacket<MultiplayerPacket>>>);
+    detail: Readonly<MultiplayerFrame<MultiplayerPacket>>;
+    constructor(eventInitDict: TypedCustomEventInit<Readonly<MultiplayerFrame<MultiplayerPacket>>>);
+}
+declare const MultiplayerControllerDesyncEvent_base: (new (eventInitDict: {
+    bubbles?: boolean;
+    cancelable?: boolean;
+    composed?: boolean;
+    detail: Readonly<MultiplayerDesync>;
+}) => import("typed-event-target").TypedCustomEvent<Readonly<MultiplayerDesync>, "multiplayer-controller-desync">) & Pick<{
+    new (type: string, eventInitDict?: EventInit): Event;
+    prototype: Event;
+    readonly NONE: 0;
+    readonly CAPTURING_PHASE: 1;
+    readonly AT_TARGET: 2;
+    readonly BUBBLING_PHASE: 3;
+}, "prototype" | "NONE" | "CAPTURING_PHASE" | "AT_TARGET" | "BUBBLING_PHASE"> & Pick<import("typed-event-target").TypedCustomEvent<Readonly<MultiplayerDesync>, "multiplayer-controller-desync">, "type">;
+/**
+ * This is fired on a client when its state hash from a check frame does not match the host's. The
+ * host's state is no more correct than the client's, so this only says that the two disagree.
+ * Nothing else is done about the desync: handle it however your game needs to.
+ *
+ * @category Events
+ */
+export declare class MultiplayerControllerDesyncEvent extends MultiplayerControllerDesyncEvent_base {
 }
 /**
  * All events emitted by this controller.
  *
  * @category Internal
  */
-export type AllP2pLockStepMultiplayerControllerEvents<MultiplayerPacket extends JsonCompatibleValue> = MultiplayerControllerFrameEvent<MultiplayerPacket> | MultiplayerControllerRoomListEvent | MultiplayerControllerClientStatusEvent | MultiplayerControllerConnectionEvent;
+export type AllP2pLockStepMultiplayerControllerEvents<MultiplayerPacket extends JsonCompatibleValue> = MultiplayerControllerFrameEvent<MultiplayerPacket> | MultiplayerControllerDesyncEvent | MultiplayerControllerRoomListEvent | MultiplayerControllerClientStatusEvent | MultiplayerControllerConnectionEvent;
 /**
  * Listener callback for p2p-lock-step frame events.
  *
@@ -115,10 +195,12 @@ export declare class P2pLockStepMultiplayerController<MultiplayerPacket extends
     readonly currentFps: number;
     /** All events emitted by this controller. */
     static readonly events: {
+        MultiplayerControllerDesyncEvent: typeof MultiplayerControllerDesyncEvent;
         MultiplayerControllerFrameEvent: typeof MultiplayerControllerFrameEvent;
     };
     /** All events emitted by this controller. */
     readonly events: {
+        MultiplayerControllerDesyncEvent: typeof MultiplayerControllerDesyncEvent;
         MultiplayerControllerFrameEvent: typeof MultiplayerControllerFrameEvent;
     };
     static readonly knownErrors: {
@@ -136,6 +218,16 @@ export declare class P2pLockStepMultiplayerController<MultiplayerPacket extends
     protected timeoutId: ReturnType<typeof globalThis.setTimeout> | undefined;
     protected frameTickReady: boolean;
     frameMs: number;
+    /** On the host, the number of frames produced. */
+    protected producedFrameCount: number;
+    /** Number of frames between desync checks, or `undefined` when checks are disabled. */
+    protected readonly desyncCheckFrameInterval: number | undefined;
+    /** On the host, the most recent check frame event, the only one whose report is still sent. */
+    protected latestCheckFrameEvent: MultiplayerControllerFrameEvent<MultiplayerPacket> | undefined;
+    /** On the host, the state hash to send with the next frame. */
+    protected nextFrameStateHash: number | undefined;
+    /** On clients, this client's state hash from the most recent check frame. */
+    protected localStateHash: number | undefined;
     protected joiningRoom: boolean;
     protected lastFpsCalculation: {
         timestamp: number;
@@ -204,6 +296,22 @@ export declare class P2pLockStepMultiplayerController<MultiplayerPacket extends
     getFps(): number;
     /** Fire an action. This will be sent to all clients in the room so they can process it. */
     act(actions: MultiplayerPacket | ReadonlyArray<MultiplayerPacket>): void;
+    /**
+     * Call on every peer right after applying a frame event whose `shouldReportNextFrameHash` is
+     * set. The host sends the hash with its next frame, unless a newer check frame has already been
+     * sent. Clients keep the hash for {@link P2pLockStepMultiplayerController.checkStateHash}. Pass
+     * `undefined` when there's no state to hash yet, which skips this check.
+     */
+    reportStateHash({ frameEvent, stateHash, }: Readonly<{
+        frameEvent: Readonly<MultiplayerControllerFrameEvent<MultiplayerPacket>>;
+        stateHash: number | undefined;
+    }>): void;
+    /**
+     * Call on clients right before applying a frame event. When the event carries the host's state
+     * hash, this compares it against this client's latest reported hash, then logs a warning and
+     * emits {@link MultiplayerControllerDesyncEvent} if they differ.
+     */
+    checkStateHash(frameEvent: Readonly<MultiplayerControllerFrameEvent<MultiplayerPacket>>): void;
     /** Detects if this controller is the room host or not. */
     isHost(): boolean;
     /** Detects if this controller is connected to a room or not. */
@@ -227,8 +335,28 @@ export declare class P2pLockStepMultiplayerController<MultiplayerPacket extends
     protected handleNewHost(clientId: ClientId): void;
     /** Send an empty frame to a newly connected member so it can join the frame flow. */
     protected syncNewMember(clientId: ClientId): void;
-    /** Apply received member actions on the host or received frames on member clients. */
-    protected handleReceivedMessage(sourceClientId: ClientId, message: Readonly<P2pLockStepMessage<MultiplayerPacket>>): void;
+    /**
+     * Per message type, whether only the host or only member clients handle it and how. Messages
+     * received by the wrong side are ignored.
+     */
+    protected readonly messageHandlers: {
+        [Type in P2pLockStepMessageType]: {
+            /** Whether only the host should handle this message. */
+            isForHost: boolean;
+            /** Handles the message. */
+            handle: (params: Readonly<{
+                message: P2pLockStepMessageByType<MultiplayerPacket>[Type];
+                sourceClientId: ClientId;
+            }>) => void;
+        };
+    };
+    /**
+     * Route a received message to its handler in
+     * {@link P2pLockStepMultiplayerController.messageHandlers}.
+     */
+    protected handleReceivedMessage<Type extends P2pLockStepMessageType>(sourceClientId: ClientId, message: P2pLockStepMessageByType<MultiplayerPacket>[Type]): void;
+    /** Forget pending state hashes, such as when frames restart under a new host or room. */
+    protected resetDesyncCheck(): void;
     /** Recalculate the current data-flow FPS from completed frames. */
     protected calculateFps(): void;
     /** Complete the current frame and schedule the next automatic frame when configured. */

package/dist/p2p-lock-step-multiplayer-controller.js

@@ -22,6 +22,15 @@ export class MultiplayerControllerFrameEvent extends defineTypedCustomEvent()('m
         super(eventInitDict);
     }
 }
+/**
+ * This is fired on a client when its state hash from a check frame does not match the host's. The
+ * host's state is no more correct than the client's, so this only says that the two disagree.
+ * Nothing else is done about the desync: handle it however your game needs to.
+ *
+ * @category Events
+ */
+export class MultiplayerControllerDesyncEvent extends defineTypedCustomEvent()('multiplayer-controller-desync') {
+}
 const defaultFrameDuration = {
     milliseconds: 10,
 };
@@ -36,6 +45,7 @@ export class P2pLockStepMultiplayerController extends ListenTarget {
     currentFps = 0;
     /** All events emitted by this controller. */
     static events = {
+        MultiplayerControllerDesyncEvent,
         MultiplayerControllerFrameEvent,
     };
     /** All events emitted by this controller. */
@@ -53,6 +63,16 @@ export class P2pLockStepMultiplayerController extends ListenTarget {
     timeoutId;
     frameTickReady = true;
     frameMs;
+    /** On the host, the number of frames produced. */
+    producedFrameCount = 0;
+    /** Number of frames between desync checks, or `undefined` when checks are disabled. */
+    desyncCheckFrameInterval;
+    /** On the host, the most recent check frame event, the only one whose report is still sent. */
+    latestCheckFrameEvent;
+    /** On the host, the state hash to send with the next frame. */
+    nextFrameStateHash;
+    /** On clients, this client's state hash from the most recent check frame. */
+    localStateHash;
     joiningRoom = false;
     lastFpsCalculation = {
         timestamp: 0,
@@ -67,6 +87,12 @@ export class P2pLockStepMultiplayerController extends ListenTarget {
         this.frameMs = convertDuration(frameDuration, {
             milliseconds: true,
         }).milliseconds;
+        this.desyncCheckFrameInterval =
+            params.desyncCheckInterval && this.frameMs
+                ? Math.max(1, Math.round(convertDuration(params.desyncCheckInterval, {
+                    milliseconds: true,
+                }).milliseconds / this.frameMs))
+                : undefined;
         this.roomController = new MultiplayerRoomController({
             gameId: params.gameId,
             clientId: this.localClientId,
@@ -203,6 +229,41 @@ export class P2pLockStepMultiplayerController extends ListenTarget {
             }),
         ];
     }
+    /**
+     * Call on every peer right after applying a frame event whose `shouldReportNextFrameHash` is
+     * set. The host sends the hash with its next frame, unless a newer check frame has already been
+     * sent. Clients keep the hash for {@link P2pLockStepMultiplayerController.checkStateHash}. Pass
+     * `undefined` when there's no state to hash yet, which skips this check.
+     */
+    reportStateHash({ frameEvent, stateHash, }) {
+        if (!this.isHost()) {
+            this.localStateHash = stateHash;
+        }
+        else if (frameEvent === this.latestCheckFrameEvent) {
+            this.latestCheckFrameEvent = undefined;
+            this.nextFrameStateHash = stateHash;
+        }
+    }
+    /**
+     * Call on clients right before applying a frame event. When the event carries the host's state
+     * hash, this compares it against this client's latest reported hash, then logs a warning and
+     * emits {@link MultiplayerControllerDesyncEvent} if they differ.
+     */
+    checkStateHash(frameEvent) {
+        if (frameEvent.detail.hostStateHash == undefined ||
+            this.localStateHash == undefined ||
+            frameEvent.detail.hostStateHash === this.localStateHash) {
+            return;
+        }
+        const desync = {
+            hostStateHash: frameEvent.detail.hostStateHash,
+            localStateHash: this.localStateHash,
+        };
+        log.warning(`[multiplayer] Desync detected: local state hash ${desync.localStateHash} does not match host state hash ${desync.hostStateHash}.`);
+        this.dispatch(new MultiplayerControllerDesyncEvent({
+            detail: desync,
+        }));
+    }
     /** Detects if this controller is the room host or not. */
     isHost() {
         return this.singleplayer || this.roomConnection?.isHost() || false;
@@ -231,6 +292,7 @@ export class P2pLockStepMultiplayerController extends ListenTarget {
                 previousRoomConnection,
                 room,
             });
+            this.resetDesyncCheck();
             if (previousRoomConnection) {
                 globalThis.clearTimeout(this.timeoutId);
                 this.clientsResponded = {};
@@ -327,6 +389,7 @@ export class P2pLockStepMultiplayerController extends ListenTarget {
         }
         globalThis.clearTimeout(this.timeoutId);
         this.clientsResponded = {};
+        this.resetDesyncCheck();
         this.frameTickReady = true;
         this.finishFrame();
     }
@@ -341,49 +404,82 @@ export class P2pLockStepMultiplayerController extends ListenTarget {
             });
         }
     }
-    /** Apply received member actions on the host or received frames on member clients. */
+    /**
+     * Per message type, whether only the host or only member clients handle it and how. Messages
+     * received by the wrong side are ignored.
+     */
+    messageHandlers = {
+        [P2pLockStepMessageType.Actions]: {
+            isForHost: true,
+            handle: ({ message, sourceClientId }) => {
+                this.debugLog(`host received ${message.actions.length} actions from ${sourceClientId}`);
+                this.clientsResponded = {
+                    ...this.clientsResponded,
+                    [sourceClientId]: true,
+                };
+                this.frameActions = [
+                    ...this.frameActions,
+                    ...message.actions.map((packet) => {
+                        return {
+                            sourceClientId,
+                            packet,
+                        };
+                    }),
+                ];
+                this.maybeFinishFrame();
+            },
+        },
+        [P2pLockStepMessageType.Frame]: {
+            isForHost: false,
+            handle: ({ message }) => {
+                this.debugLog(`member received frame with ${message.packets.length} actions; sending ${this.frameActions.length} local actions back to host`);
+                const currentFrameActions = this.frameActions;
+                this.frameActions = [];
+                this.roomConnection?.sendMessage({
+                    actions: currentFrameActions.map(({ packet }) => {
+                        return packet;
+                    }),
+                    sourceClientId: this.clientId,
+                    type: P2pLockStepMessageType.Actions,
+                });
+                if (!message.isSynchronizationFrame) {
+                    this.calculateFps();
+                    this.dispatch(new MultiplayerControllerFrameEvent({
+                        detail: {
+                            packets: message.packets,
+                            hostStateHash: message.stateHash,
+                            shouldReportNextFrameHash: message.shouldReportNextFrameHash,
+                        },
+                    }));
+                }
+            },
+        },
+    };
+    /**
+     * Route a received message to its handler in
+     * {@link P2pLockStepMultiplayerController.messageHandlers}.
+     */
     handleReceivedMessage(sourceClientId, message) {
         this.debugLog(`received lock-step message from ${sourceClientId}: type=${message.type} host=${this.isHost()}`);
         if (!this.roomConnection) {
             this.debugLog('ignored message because no room connection is attached');
             return;
         }
-        if (this.isHost() && message.type === P2pLockStepMessageType.Actions) {
-            this.debugLog(`host received ${message.actions.length} actions from ${sourceClientId}`);
-            this.clientsResponded = {
-                ...this.clientsResponded,
-                [sourceClientId]: true,
-            };
-            this.frameActions = [
-                ...this.frameActions,
-                ...message.actions.map((packet) => {
-                    return {
-                        sourceClientId,
-                        packet,
-                    };
-                }),
-            ];
-            this.maybeFinishFrame();
-        }
-        else if (!this.isHost() && message.type === P2pLockStepMessageType.Frame) {
-            this.debugLog(`member received frame with ${message.packets.length} actions; sending ${this.frameActions.length} local actions back to host`);
-            const currentFrameActions = this.frameActions;
-            this.frameActions = [];
-            this.roomConnection.sendMessage({
-                actions: currentFrameActions.map(({ packet }) => {
-                    return packet;
-                }),
-                sourceClientId: this.clientId,
-                type: P2pLockStepMessageType.Actions,
+        /** Indexing by `message.type` directly loses the link between the handler and `message`. */
+        const type = message.type;
+        if (this.messageHandlers[type].isForHost === this.isHost()) {
+            this.messageHandlers[type].handle({
+                message,
+                sourceClientId,
             });
-            if (!message.isSynchronizationFrame) {
-                this.calculateFps();
-                this.dispatch(new MultiplayerControllerFrameEvent({
-                    detail: message.packets,
-                }));
-            }
         }
     }
+    /** Forget pending state hashes, such as when frames restart under a new host or room. */
+    resetDesyncCheck() {
+        this.latestCheckFrameEvent = undefined;
+        this.nextFrameStateHash = undefined;
+        this.localStateHash = undefined;
+    }
     /** Recalculate the current data-flow FPS from completed frames. */
     calculateFps() {
         const now = Date.now();
@@ -405,14 +501,33 @@ export class P2pLockStepMultiplayerController extends ListenTarget {
     /** Complete the current frame and schedule the next automatic frame when configured. */
     finishFrame() {
         const currentFrameActions = this.frameActions;
+        const stateHash = this.nextFrameStateHash;
         this.frameActions = [];
+        this.nextFrameStateHash = undefined;
+        this.producedFrameCount++;
+        const shouldReportNextFrameHash = !!this.desyncCheckFrameInterval &&
+            !(this.producedFrameCount % this.desyncCheckFrameInterval) &&
+            this.getAllClientIds().length > 1;
         this.roomConnection?.sendMessage({
             type: P2pLockStepMessageType.Frame,
             packets: currentFrameActions,
+            ...(shouldReportNextFrameHash && {
+                shouldReportNextFrameHash,
+            }),
+            ...(stateHash != undefined && {
+                stateHash,
+            }),
         });
-        this.dispatch(new MultiplayerControllerFrameEvent({
-            detail: currentFrameActions,
-        }));
+        const frameEvent = new MultiplayerControllerFrameEvent({
+            detail: {
+                packets: currentFrameActions,
+                shouldReportNextFrameHash,
+            },
+        });
+        if (shouldReportNextFrameHash) {
+            this.latestCheckFrameEvent = frameEvent;
+        }
+        this.dispatch(frameEvent);
         this.frameTickReady = false;
         this.calculateFps();
         if (this.frameMs) {

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@antha/multiplayer-p2p-lock-step",
-    "version": "0.20.0",
+    "version": "0.21.0",
     "description": "Multiplayer mod for the Antha engine.",
     "keywords": [
         "vir",
@@ -42,7 +42,7 @@
         "typed-event-target": "^4.3.3"
     },
     "devDependencies": {
-        "@antha/multiplayer-core": "^0.20.0",
+        "@antha/multiplayer-core": "^0.21.0",
         "@augment-vir/test": "^32.3.0",
         "@web/dev-server-esbuild": "^2.0.0",
         "@web/test-runner": "^1.0.0",
@@ -50,7 +50,7 @@
         "istanbul-smart-text-reporter": "^1.1.5"
     },
     "peerDependencies": {
-        "@antha/multiplayer-core": "^0.20.0"
+        "@antha/multiplayer-core": "^0.21.0"
     },
     "engines": {
         "node": ">=22"