@antha/multiplayer-p2p-authoritative-host 0.12.0 → 0.14.0

package/dist/antha-multiplayer-p2p-authoritative-host.mod.d.ts

@@ -6,15 +6,15 @@ import { P2pAuthoritativeHostMultiplayerController, type P2pAuthoritativeHostMul
  *
  * @category Internal
  */
-export type AnthaMultiplayerP2pAuthoritativeHostState<Input extends JsonCompatibleValue = any, State extends JsonCompatibleValue = any> = {
+export type AnthaMultiplayerP2pAuthoritativeHostState<Input extends JsonCompatibleValue = any, MultiplayerGameState extends JsonCompatibleValue = any> = {
     /** P2p-authoritative-host controller state. */
     multiplayerP2pAuthoritativeHost: {
         /** Controller used to drive singleplayer or multiplayer state sync. */
-        multiplayerController: P2pAuthoritativeHostMultiplayerController<Input, State>;
+        multiplayerController: P2pAuthoritativeHostMultiplayerController<Input, MultiplayerGameState>;
         /** Current backend API and room connection state. */
         connectionState: ApiAndRoomConnectionState;
         /** Latest state emitted by the multiplayer controller. */
-        currentState: State;
+        currentState: MultiplayerGameState;
     };
 };
 /**
@@ -22,10 +22,10 @@ export type AnthaMultiplayerP2pAuthoritativeHostState<Input extends JsonCompatib
  *
  * @category Internal
  */
-export type AnthaMultiplayerP2pAuthoritativeHostOptions<Input extends JsonCompatibleValue = any, State extends JsonCompatibleValue = any> = SelectFrom<P2pAuthoritativeHostMultiplayerControllerParams<Input, State>, {
+export type AnthaMultiplayerP2pAuthoritativeHostOptions<Input extends JsonCompatibleValue = any, MultiplayerGameState extends JsonCompatibleValue = any> = SelectFrom<P2pAuthoritativeHostMultiplayerControllerParams<Input, MultiplayerGameState>, {
     applyInput: true;
     createInitialState: true;
-}> & PartialWithUndefined<SelectFrom<P2pAuthoritativeHostMultiplayerControllerParams<Input, State>, {
+}> & PartialWithUndefined<SelectFrom<P2pAuthoritativeHostMultiplayerControllerParams<Input, MultiplayerGameState>, {
     acceptConnection: true;
     gameId: true;
     shouldAcceptInput: true;
@@ -36,4 +36,4 @@ export type AnthaMultiplayerP2pAuthoritativeHostOptions<Input extends JsonCompat
  *
  * @category Main
  */
-export declare function createAnthaMultiplayerP2pAuthoritativeHostMod<const Input extends JsonCompatibleValue = any, const State extends JsonCompatibleValue = any>(options: Readonly<AnthaMultiplayerP2pAuthoritativeHostOptions<Input, State>>): import("@antha/engine").AnthaMod<NoInfer<AnthaMultiplayerP2pAuthoritativeHostState<NoInfer<Input>, State>>>;
+export declare function createAnthaMultiplayerP2pAuthoritativeHostMod<const Input extends JsonCompatibleValue = any, const MultiplayerGameState extends JsonCompatibleValue = any>(options: Readonly<AnthaMultiplayerP2pAuthoritativeHostOptions<Input, MultiplayerGameState>>): import("@antha/engine").AnthaMod<NoInfer<AnthaMultiplayerP2pAuthoritativeHostState<NoInfer<Input>, NoInfer<MultiplayerGameState>>>>;

package/dist/p2p-authoritative-host-multiplayer-controller.d.ts

@@ -16,9 +16,9 @@ export declare enum P2pAuthoritativeHostMessageType {
  *
  * @category Internal
  */
-export type P2pAuthoritativeHostStateSnapshot<State extends JsonCompatibleValue> = {
+export type P2pAuthoritativeHostStateSnapshot<MultiplayerGameState extends JsonCompatibleValue> = {
     sequence: number;
-    state: State;
+    state: MultiplayerGameState;
 } & PartialWithUndefined<{
     /** Identifies the state request that this snapshot fulfills. */
     stateSyncId: SocketMessageId;
@@ -28,7 +28,7 @@ export type P2pAuthoritativeHostStateSnapshot<State extends JsonCompatibleValue>
  *
  * @category Internal
  */
-export type StateEventDetail<Input extends JsonCompatibleValue, State extends JsonCompatibleValue> = P2pAuthoritativeHostStateSnapshot<State> & PartialWithUndefined<{
+export type StateEventDetail<Input extends JsonCompatibleValue, MultiplayerGameState extends JsonCompatibleValue> = P2pAuthoritativeHostStateSnapshot<MultiplayerGameState> & PartialWithUndefined<{
     clientId: ClientId;
     input: Input;
 }>;
@@ -37,7 +37,7 @@ export type StateEventDetail<Input extends JsonCompatibleValue, State extends Js
  *
  * @category Internal
  */
-export type P2pAuthoritativeHostMessage<Input extends JsonCompatibleValue, State extends JsonCompatibleValue> = {
+export type P2pAuthoritativeHostMessage<Input extends JsonCompatibleValue, MultiplayerGameState extends JsonCompatibleValue> = {
     type: P2pAuthoritativeHostMessageType.Input;
     input: Input;
 } | {
@@ -45,53 +45,53 @@ export type P2pAuthoritativeHostMessage<Input extends JsonCompatibleValue, State
     stateSyncId: SocketMessageId;
 } | ({
     type: P2pAuthoritativeHostMessageType.StateSnapshot;
-} & StateEventDetail<Input, State>);
+} & StateEventDetail<Input, MultiplayerGameState>);
 /**
  * Game-specific logic for an authoritative-host connection.
  *
  * @category Internal
  */
-export type P2pAuthoritativeHostGameDefinition<Input extends JsonCompatibleValue, State extends JsonCompatibleValue> = {
+export type P2pAuthoritativeHostGameDefinition<Input extends JsonCompatibleValue, MultiplayerGameState extends JsonCompatibleValue> = {
     /** Create the initial game state before singleplayer or multiplayer starts. */
-    createInitialState: () => State;
+    createInitialState: () => MultiplayerGameState;
     /** Apply an accepted input to the current authoritative state. */
     applyInput: (params: Readonly<{
         clientId: ClientId;
         input: Readonly<Input>;
-        state: Readonly<State>;
-    }>) => State;
+        state: Readonly<MultiplayerGameState>;
+    }>) => MultiplayerGameState;
     /** Return `false` to reject an input before it changes authoritative state. */
     shouldAcceptInput?: (params: Readonly<{
         clientId: ClientId;
         input: Readonly<Input>;
-        state: Readonly<State>;
+        state: Readonly<MultiplayerGameState>;
     }>) => boolean | undefined;
     /** Advance authoritative state from elapsed time without a player input. */
     tick?: (params: Readonly<{
         elapsedMs: number;
-        state: Readonly<State>;
-    }>) => State;
+        state: Readonly<MultiplayerGameState>;
+    }>) => MultiplayerGameState;
 };
 /**
  * Constructor parameters for {@link P2pAuthoritativeHostMultiplayerController}.
  *
  * @category Internal
  */
-export type P2pAuthoritativeHostMultiplayerControllerParams<Input extends JsonCompatibleValue, State extends JsonCompatibleValue> = {
+export type P2pAuthoritativeHostMultiplayerControllerParams<Input extends JsonCompatibleValue, MultiplayerGameState extends JsonCompatibleValue> = {
     /**
      * A unique string id that represents your game so that your lobby server can serve multiple
      * games at once. Your lobby server will need to know this game id ahead of time and match it to
      * your frontend's origin.
      */
     gameId: string;
-} & P2pAuthoritativeHostGameDefinition<Input, State> & PartialWithUndefined<{
+} & P2pAuthoritativeHostGameDefinition<Input, MultiplayerGameState> & PartialWithUndefined<{
     /**
      * This is fired when a WebRTC peer attempts to connect to the host client. Return `true` to
      * accept the connection. Return `false` to reject it.
      *
      * @default accept all connections
      */
-    acceptConnection?: ((connectingClientId: ClientId, controller: P2pAuthoritativeHostMultiplayerController<Input, State>) => MaybePromise<boolean>) | undefined;
+    acceptConnection?: ((connectingClientId: ClientId, controller: P2pAuthoritativeHostMultiplayerController<Input, MultiplayerGameState>) => MaybePromise<boolean>) | undefined;
 }>;
 declare const ControllerStateEvent_base: (new (eventInitDict: {
     bubbles?: boolean;
@@ -111,23 +111,23 @@ declare const ControllerStateEvent_base: (new (eventInitDict: {
  *
  * @category Events
  */
-export declare class ControllerStateEvent<State extends JsonCompatibleValue, Input extends JsonCompatibleValue = any> extends ControllerStateEvent_base {
-    detail: Readonly<StateEventDetail<Input, State>>;
-    constructor(eventInitDict: TypedCustomEventInit<Readonly<StateEventDetail<Input, State>>>);
+export declare class ControllerStateEvent<MultiplayerGameState extends JsonCompatibleValue, Input extends JsonCompatibleValue = any> extends ControllerStateEvent_base {
+    detail: Readonly<StateEventDetail<Input, MultiplayerGameState>>;
+    constructor(eventInitDict: TypedCustomEventInit<Readonly<StateEventDetail<Input, MultiplayerGameState>>>);
 }
 /**
  * All events emitted by this controller.
  *
  * @category Internal
  */
-export type AllP2pAuthoritativeHostMultiplayerControllerEvents<Input extends JsonCompatibleValue, State extends JsonCompatibleValue> = ControllerStateEvent<State, Input> | ControllerRoomListEvent | ControllerClientEvent | ControllerConnectionEvent;
+export type AllP2pAuthoritativeHostMultiplayerControllerEvents<Input extends JsonCompatibleValue, MultiplayerGameState extends JsonCompatibleValue> = ControllerStateEvent<MultiplayerGameState, Input> | ControllerRoomListEvent | ControllerClientEvent | ControllerConnectionEvent;
 /**
  * An all-in-one controller for singleplayer or p2p-authoritative-host multiplayer game state.
  *
  * @category Main
  */
-export declare class P2pAuthoritativeHostMultiplayerController<Input extends JsonCompatibleValue = any, State extends JsonCompatibleValue = any> extends ListenTarget<AllP2pAuthoritativeHostMultiplayerControllerEvents<Input, State>> {
-    protected readonly params: P2pAuthoritativeHostMultiplayerControllerParams<Input, State>;
+export declare class P2pAuthoritativeHostMultiplayerController<Input extends JsonCompatibleValue = any, MultiplayerGameState extends JsonCompatibleValue = any> extends ListenTarget<AllP2pAuthoritativeHostMultiplayerControllerEvents<Input, MultiplayerGameState>> {
+    protected readonly params: P2pAuthoritativeHostMultiplayerControllerParams<Input, MultiplayerGameState>;
     /** All events emitted by this controller. */
     static readonly events: {
         ControllerStateEvent: typeof ControllerStateEvent;
@@ -143,14 +143,14 @@ export declare class P2pAuthoritativeHostMultiplayerController<Input extends Jso
         RoomRejectionError: typeof RoomRejectionError;
     };
     /** Core multiplayer room controller that owns API, room polling, signaling, and transport. */
-    readonly roomController: MultiplayerRoomController<P2pAuthoritativeHostMessage<Input, State>>;
+    readonly roomController: MultiplayerRoomController<P2pAuthoritativeHostMessage<Input, MultiplayerGameState>>;
     protected readonly localClientId: ClientId;
-    protected roomConnection: MultiplayerRoomConnection<P2pAuthoritativeHostMessage<Input, State>> | undefined;
-    protected currentState: State;
+    protected roomConnection: MultiplayerRoomConnection<P2pAuthoritativeHostMessage<Input, MultiplayerGameState>> | undefined;
+    protected currentState: MultiplayerGameState;
     protected currentSequence: number;
     protected pendingStateSyncId: SocketMessageId | undefined;
     protected singleplayer: boolean;
-    constructor(params: P2pAuthoritativeHostMultiplayerControllerParams<Input, State>);
+    constructor(params: P2pAuthoritativeHostMultiplayerControllerParams<Input, MultiplayerGameState>);
     /** Current p2p-authoritative-host connection, exposed for compatibility checks. */
     get currentConnection(): this | undefined;
     /** The current client id. */
@@ -199,7 +199,7 @@ export declare class P2pAuthoritativeHostMultiplayerController<Input extends Jso
      */
     getAllClientIds(): ClientId[];
     /** Get the latest local state view. */
-    getState(): State;
+    getState(): MultiplayerGameState;
     /** Initialize multiplayer API access without opening a room or starting host pings. */
     initMultiplayer(params: Readonly<MultiplayerInitParams>): Promise<void>;
     /** Start local play without contacting the multiplayer API. This can later open into a room. */
@@ -217,40 +217,40 @@ export declare class P2pAuthoritativeHostMultiplayerController<Input extends Jso
     /** Join or create a room. */
     joinOrCreateRoom(room: Readonly<RoomInput>): Promise<void>;
     /** Join through the core room controller after its candidate connection is state-synchronized. */
-    protected joinRoom(room: Readonly<RoomInput>): Promise<MultiplayerRoomConnection<P2pAuthoritativeHostMessage<Input, State>>>;
+    protected joinRoom(room: Readonly<RoomInput>): Promise<MultiplayerRoomConnection<P2pAuthoritativeHostMessage<Input, MultiplayerGameState>>>;
     /** Leave the current room or single player connection. */
     leaveRoom(): void;
     /** Forward core room-controller events into this state-sync controller. */
     protected listenToRoomController(): void;
     /** Attach an established room transport and publish the current state view. */
-    protected attachMultiplayerRoomConnection(roomConnection: Readonly<MultiplayerRoomConnection<P2pAuthoritativeHostMessage<Input, State>>>): void;
+    protected attachMultiplayerRoomConnection(roomConnection: Readonly<MultiplayerRoomConnection<P2pAuthoritativeHostMessage<Input, MultiplayerGameState>>>): void;
     /** Apply received inputs on the host or received state snapshots on member clients. */
-    protected handleReceivedMessage(sourceClientId: ClientId, message: Readonly<P2pAuthoritativeHostMessage<Input, State>>): void;
+    protected handleReceivedMessage(sourceClientId: ClientId, message: Readonly<P2pAuthoritativeHostMessage<Input, MultiplayerGameState>>): void;
     /** Attach and synchronize a candidate room before the core controller commits to it. */
-    protected prepareRoomConnection(roomConnection: Readonly<MultiplayerRoomConnection<P2pAuthoritativeHostMessage<Input, State>>>): Promise<void>;
+    protected prepareRoomConnection(roomConnection: Readonly<MultiplayerRoomConnection<P2pAuthoritativeHostMessage<Input, MultiplayerGameState>>>): Promise<void>;
     /** Validate and apply an input against the current authoritative state. */
     protected applyInput({ clientId, input, }: Readonly<{
         clientId: ClientId;
         input: Readonly<Input>;
     }>): void;
     /** Publish a new authoritative state that was not caused by a player input. */
-    protected updateState(state: State): void;
+    protected updateState(state: MultiplayerGameState): void;
     /** Publish a new authoritative state caused by a player input. */
     protected updateStateFromInput({ clientId, input, state, }: Readonly<{
         clientId: ClientId;
         input: Readonly<Input>;
-        state: State;
+        state: MultiplayerGameState;
     }>): void;
     /** Dispatch the typed state event to local listeners. */
-    protected dispatchState(detail: Readonly<StateEventDetail<Input, State>>): void;
+    protected dispatchState(detail: Readonly<StateEventDetail<Input, MultiplayerGameState>>): void;
     /** Broadcast a state snapshot when the local client is the host. */
-    protected sendStateSnapshot(detail: Readonly<StateEventDetail<Input, State>>): void;
+    protected sendStateSnapshot(detail: Readonly<StateEventDetail<Input, MultiplayerGameState>>): void;
     /** Create a network message from state event detail. */
-    protected createStateSnapshotMessage(detail: Readonly<StateEventDetail<Input, State>>, stateSyncId?: SocketMessageId | undefined): P2pAuthoritativeHostMessage<Input, State>;
+    protected createStateSnapshotMessage(detail: Readonly<StateEventDetail<Input, MultiplayerGameState>>, stateSyncId?: SocketMessageId | undefined): P2pAuthoritativeHostMessage<Input, MultiplayerGameState>;
     /** Create the local state event detail for the current sequence and state. */
     protected createStateEventDetail(source?: Readonly<PartialWithUndefined<{
         clientId: ClientId;
         input: Readonly<Input>;
-    }>>): StateEventDetail<Input, State>;
+    }>>): StateEventDetail<Input, MultiplayerGameState>;
 }
 export {};

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@antha/multiplayer-p2p-authoritative-host",
-    "version": "0.12.0",
+    "version": "0.14.0",
     "description": "P2P authoritative-host multiplayer strategy for the Antha engine.",
     "keywords": [
         "vir",
@@ -36,19 +36,19 @@
         "test:docs": "virmator docs check"
     },
     "dependencies": {
-        "@augment-vir/assert": "^32.2.3",
-        "@augment-vir/common": "^32.2.3",
+        "@augment-vir/assert": "^32.2.4",
+        "@augment-vir/common": "^32.2.4",
         "typed-event-target": "^4.3.3"
     },
     "devDependencies": {
-        "@augment-vir/test": "^32.2.3",
+        "@augment-vir/test": "^32.2.4",
         "@web/dev-server-esbuild": "^2.0.0",
         "@web/test-runner": "^1.0.0",
         "@web/test-runner-playwright": "^1.0.0",
         "istanbul-smart-text-reporter": "^1.1.5"
     },
     "peerDependencies": {
-        "@antha/multiplayer-core": "^0.12.0"
+        "@antha/multiplayer-core": "^0.14.0"
     },
     "engines": {
         "node": ">=22"