@remix-gg/sdk 0.6.0 → 0.7.0

package/README.md

@@ -45,8 +45,8 @@ class MyGame {
   }
 
   private async setupEventListeners() {
-    // Listen for play again events
-    this.sdk.onPlayAgain(() => {
+    // Listen for play (replay or host-directed level start)
+    this.sdk.onPlay(() => {
       this.resetGame()
     })
 
@@ -123,6 +123,8 @@ class MyGame {
 
 This function will return when the SDK has recieved all the game information from Remix. You should await the call to this function before getting info from the SDK (sdk.player, sdk.gameState, etc)
 
+The SDK announces itself to the host automatically when it loads — games never send the `ready` handshake themselves. `sdk.ready()` only waits for host data (`gameInfo`, `gameState`, level progression) to arrive before you read it; a game that reads nothing from the host does not need to call it.
+
 #### `sdk.isReady: boolean`
 
 Check if the SDK has received game info and is ready. More often, you will just await the call to `sdk.ready()`, but you may use this value if you prefer.
@@ -222,13 +224,34 @@ The purchase flow works as follows:
 
 ### Single Player Actions
 
-#### `sdk.singlePlayer.actions.gameOver({ score: number })`
+#### `sdk.singlePlayer.actions.gameOver({ score: number, levelAttempt?: LevelAttempt })`
 
 Call this method when the game is over to report the final score.
 
 Parameters:
 
 - `score`: The player's final score (number)
+- `levelAttempt`: For level-based games only — the result of the attempt that just ended (see Level-Based Games below). `score` is ignored for level-based games; pass `0`.
+
+### Level-Based Games
+
+When the host configures a fixed level count, `gameInfo.levelBased` is set and the game runs as a level progression game:
+
+- `gameInfo.levelBased.levelCount` is the total number of levels.
+- `gameInfo.levelBased.progress` is the platform-owned, score-derived progression (`LevelProgressState`). Read it through the getters `sdk.isLevelBased`, `sdk.levelCount`, `sdk.currentLevelIndex`, `sdk.levelStars`, `sdk.highestUnlockedLevel`, and `sdk.totalStars`. Never store progression in `gameState`.
+- When an attempt ends, report only what happened:
+
+```js
+sdk.singlePlayer.actions.gameOver({
+  score: 0, // ignored for level-based games
+  levelAttempt: {
+    levelIndex, // 1-based level that was just played
+    stars, // 0 = failed, 1 | 2 | 3 earned on completion
+  },
+})
+```
+
+The platform merges attempts into cumulative progression — games never compute or report star maps, unlock state, or "all levels complete" (the host derives world completion from `levelIndex` and its own `levelCount`). Listen for host-directed level starts with `sdk.onPlay((data) => ...)`; the host passes the target level as `data.levelIndex`.
 
 #### `sdk.singlePlayer.actions.saveGameState({ gameState: Record<string, unknown> })`
 
@@ -303,9 +326,15 @@ The SDK provides both generic event listeners and specific typed listener method
 
 #### Event Listeners
 
-##### `sdk.onPlayAgain(callback: () => void)`
+##### `sdk.onPlay(callback: (data?: { levelIndex?: number }) => void)`
+
+Register a callback that is called when the host starts play — a replay after
+game over, or (for level-based games) a host-directed level via `data.levelIndex`.
+`data` may be omitted for a plain restart.
+
+##### `sdk.onPlayAgain(callback: (data?: { levelIndex?: number }) => void)`
 
-Register a callback function that is called when the player wants to play again.
+Alias of `sdk.onPlay`.
 
 ##### `sdk.onToggleMute(callback: (data: { isMuted: boolean }) => void)`
 
@@ -365,8 +394,8 @@ class Game {
   }
 
   private setupEventListeners() {
-    // Listen for play again events
-    this.sdk.onPlayAgain(() => {
+    // Listen for play (replay or host-directed level start)
+    this.sdk.onPlay(() => {
       this.resetGame()
     })
 

package/dist/index.d.mts

@@ -0,0 +1,284 @@
+declare global {
+    interface Window {
+        FarcadeSDK: typeof sdk;
+        RemixSDK: typeof sdk;
+    }
+}
+type ViewContext = 'feed' | 'full_screen' | 'challenge' | 'tournament';
+type SafeAreaInset = {
+    top: number;
+    right: number;
+    bottom: number;
+    left: number;
+};
+declare const ZERO_SAFE_AREA_INSET: SafeAreaInset;
+type GameState = Record<string, unknown>;
+type Player = {
+    id: string;
+    name: string;
+    purchasedItems: string[];
+    imageUrl?: string;
+};
+type InventoryItem = {
+    slug: string;
+    quantity: number;
+};
+type ShopItem = {
+    slug: string;
+    name: string;
+    itemType?: string;
+    bitsCost?: number | null;
+    description?: string | null;
+    iconUrl?: string | null;
+    tier?: number | null;
+};
+type GameInfo = {
+    players: Player[];
+    player: Player;
+    shopItems?: ShopItem[];
+    viewContext: ViewContext;
+    contentSafeAreaInset: SafeAreaInset;
+    initialGameState: {
+        id: string;
+        gameState: GameState;
+    } | null;
+    levelBased?: {
+        levelCount: number;
+        /**
+         * Score-derived level progression for this player. Platform-owned and kept
+         * fully separate from `gameState` — never read progression out of gameState.
+         */
+        progress: LevelProgressState;
+    };
+};
+/** Score-derived, platform-owned progression for a level-based game. */
+type LevelProgressState = {
+    currentLevelIndex: number;
+    highestUnlockedLevel: number;
+    levelStars: Record<string, LevelStars>;
+};
+type ReadyEvent = {
+    type: 'ready';
+    data: {
+        instanceId: string;
+    } | undefined;
+};
+type PlayAgainEvent = {
+    type: 'play_again';
+    data?: {
+        levelIndex?: number;
+    };
+};
+type LevelStars = 1 | 2 | 3;
+type LevelOutcome = 'level_complete' | 'level_failed' | 'all_complete';
+/**
+ * One level attempt reported with game_over. Games report only what happened
+ * in the attempt; the host owns and derives all cumulative progression
+ * (star maps, unlock state) — see `LevelProgressState` for the host→game snapshot.
+ */
+type LevelAttempt = {
+    /** 1-based index of the level that was just played. */
+    levelIndex: number;
+    /** Stars earned this attempt. Omit for star-less games; a completion counts as 1. */
+    stars?: LevelStars;
+    outcome: LevelOutcome;
+};
+type SinglePlayerGameOverEvent = {
+    type: 'game_over';
+    data: {
+        score: number;
+        levelAttempt?: LevelAttempt;
+    };
+};
+type MultiplayerGameOverEvent = {
+    type: 'multiplayer_game_over';
+    data: {
+        scores: {
+            playerId: string;
+            score: number;
+        }[];
+    };
+};
+type HapticFeedbackType = 'light' | 'medium' | 'hard' | 'success' | 'error';
+type HapticFeedbackEvent = {
+    type: 'haptic_feedback';
+    data?: {
+        type?: HapticFeedbackType;
+    };
+};
+type ToggleMuteEvent = {
+    type: 'toggle_mute';
+    data: {
+        isMuted: boolean;
+    };
+};
+type GameErrorEvent = {
+    type: 'error';
+    data: {
+        message: string;
+        source?: string;
+        lineno?: number;
+        colno?: number;
+        error?: Error;
+        stack?: string;
+    };
+};
+type GameInfoEvent = {
+    type: 'game_info';
+    data: GameInfo;
+};
+type MultiplayerSaveGameStateEvent = {
+    type: 'multiplayer_save_game_state';
+    data: {
+        gameState: GameState;
+        alertUserIds?: string[];
+    };
+};
+type GameStateUpdatedEvent = {
+    type: 'game_state_updated';
+    data: {
+        id: string;
+        gameState: GameState;
+    } | null;
+};
+type RefuteGameStateEvent = {
+    type: 'refute_game_state';
+    data: {
+        gameStateId: string;
+    };
+};
+type SaveGameStateEvent = {
+    type: 'save_game_state';
+    data: {
+        gameState: GameState;
+    };
+};
+type PurchaseEvent = {
+    type: 'purchase';
+    data: {
+        item: string;
+    };
+};
+type PurchaseCompleteEvent = {
+    type: 'purchase_complete';
+    data: {
+        success: boolean;
+        item?: string;
+    };
+};
+type GameEvent = PlayAgainEvent | SinglePlayerGameOverEvent | ReadyEvent | HapticFeedbackEvent | ToggleMuteEvent | GameErrorEvent | SaveGameStateEvent | RefuteGameStateEvent | GameInfoEvent | GameStateUpdatedEvent | MultiplayerGameOverEvent | MultiplayerSaveGameStateEvent | PurchaseEvent | PurchaseCompleteEvent;
+type GameEventMessage<T extends GameEvent['type']> = {
+    type: 'game_event';
+    event: Extract<GameEvent, {
+        type: T;
+    }>;
+};
+/**
+ * Build a game_event envelope for sending over postMessage. Hosts and the SDK
+ * share this so the wire format is defined in one place.
+ */
+declare const createGameEventMessage: <T extends GameEvent["type"]>(type: T, data: Extract<GameEvent, {
+    type: T;
+}>["data"]) => GameEventMessage<T>;
+/**
+ * Parse an unknown postMessage payload into a GameEvent, or null when the
+ * payload is not a well-formed game_event envelope.
+ */
+declare const parseGameEventMessage: (value: unknown) => GameEvent | null;
+/**
+ * Messages from the game host to the game client
+ */
+type IncomingGameEvent = GameEventMessage<'play_again' | 'toggle_mute' | 'game_info' | 'game_state_updated' | 'purchase_complete'>;
+type OutgoingGameEvent = GameEventMessage<'game_over' | 'ready' | 'haptic_feedback' | 'error' | 'save_game_state' | 'refute_game_state' | 'multiplayer_game_over' | 'multiplayer_save_game_state' | 'purchase'>;
+type IncomingGameEventType = IncomingGameEvent['event']['type'];
+type IncomingGameEventData<T extends IncomingGameEventType> = Extract<GameEvent, {
+    type: T;
+}>['data'];
+declare class RemixSDK {
+    private isClient;
+    private target;
+    private eventListeners;
+    private readyPromise;
+    private readyPromiseResolve;
+    private purchasePromiseResolvers;
+    private readyResendTimer;
+    private readonly instanceId;
+    private _gameInfo?;
+    private _gameState?;
+    private _levelStars;
+    constructor();
+    private scheduleReadyResend;
+    private cancelReadyResend;
+    on<T extends IncomingGameEventType>(eventType: T, callback: (data: IncomingGameEventData<T>) => void): () => void;
+    off<T extends IncomingGameEventType>(eventType: T, callback: (data: IncomingGameEventData<T>) => void): void;
+    /**
+     * Listen for the host starting play: a replay after game over, or — for level
+     * games — a host-directed level via `data.levelIndex` (Studio continue/jump or
+     * the production next-level button). `data` may be omitted for a plain restart.
+     */
+    onPlay(callback: (data?: PlayAgainEvent['data']) => void): () => void;
+    /** @deprecated Use {@link onPlay}. Retained for backward compatibility. */
+    onPlayAgain(callback: (data?: PlayAgainEvent['data']) => void): () => void;
+    onToggleMute(callback: (data: ToggleMuteEvent['data']) => void): () => void;
+    onGameStateUpdated(callback: (data: GameStateUpdatedEvent['data']) => void): () => void;
+    onGameInfo(callback: (data: GameInfoEvent['data']) => void): () => void;
+    onPurchaseComplete(callback: (data: PurchaseCompleteEvent['data']) => void): () => void;
+    setTarget(target: Window): void;
+    get purchasedItems(): string[];
+    get inventory(): InventoryItem[];
+    get shopItems(): ShopItem[];
+    get gameInfo(): GameInfo | undefined;
+    get gameState(): GameState | null | undefined;
+    get players(): Player[] | undefined;
+    get player(): Player | undefined;
+    get isReady(): boolean;
+    /** True when the host configured this game with a fixed level count. */
+    get isLevelBased(): boolean;
+    /** Total levels for level-based games (from host metadata). */
+    get levelCount(): number | undefined;
+    /** 1-based level index from score-derived progression, defaulting to 1. */
+    get currentLevelIndex(): number;
+    /** Best stars earned per level from score-derived progression. Keys are 1-based level indices. */
+    get levelStars(): Record<string, LevelStars>;
+    /** Highest unlocked level from score-derived progression, defaulting to 1. */
+    get highestUnlockedLevel(): number;
+    /** Sum of best stars across all completed levels. */
+    get totalStars(): number;
+    ready: () => Promise<GameInfo>;
+    purchase: (data: PurchaseEvent["data"]) => Promise<PurchaseCompleteEvent["data"]>;
+    reportError: (data: GameErrorEvent["data"]) => void;
+    hapticFeedback: (type?: HapticFeedbackType) => void;
+    hasItem: (item: string) => boolean;
+    getItemPurchaseCount: (item: string) => number;
+    getShopItem: (slug: string) => ShopItem | undefined;
+    singlePlayer: {
+        actions: {
+            ready: () => Promise<GameInfo>;
+            hapticFeedback: (type?: HapticFeedbackType) => void;
+            reportError: (data: GameErrorEvent["data"]) => void;
+            purchase: (data: PurchaseEvent["data"]) => Promise<PurchaseCompleteEvent["data"]>;
+            gameOver: (data: SinglePlayerGameOverEvent["data"]) => void;
+            saveGameState: (data: SaveGameStateEvent["data"]) => void;
+        };
+    };
+    multiplayer: {
+        actions: {
+            gameOver: (data: MultiplayerGameOverEvent["data"]) => void;
+            refuteGameState: (data: RefuteGameStateEvent["data"]) => void;
+            saveGameState: (data: MultiplayerSaveGameStateEvent["data"]) => void;
+            ready: () => Promise<GameInfo>;
+            hapticFeedback: (type?: HapticFeedbackType) => void;
+            reportError: (data: GameErrorEvent["data"]) => void;
+            purchase: (data: PurchaseEvent["data"]) => Promise<PurchaseCompleteEvent["data"]>;
+        };
+    };
+    private emit;
+    private handleMessage;
+    private sendMessage;
+    private handleGlobalError;
+    private handleUnhandledRejection;
+    private applyPurchaseToCurrentPlayer;
+}
+declare const sdk: RemixSDK;
+
+export { type GameErrorEvent, type GameEvent, type GameEventMessage, type GameInfo, type GameInfoEvent, type GameState, type GameStateUpdatedEvent, type HapticFeedbackEvent, type HapticFeedbackType, type IncomingGameEvent, type IncomingGameEventData, type IncomingGameEventType, type InventoryItem, type LevelAttempt, type LevelOutcome, type LevelProgressState, type LevelStars, type MultiplayerGameOverEvent, type MultiplayerSaveGameStateEvent, type OutgoingGameEvent, type PlayAgainEvent, type Player, type PurchaseCompleteEvent, type PurchaseEvent, type ReadyEvent, type RefuteGameStateEvent, RemixSDK, type SafeAreaInset, type SaveGameStateEvent, type ShopItem, type SinglePlayerGameOverEvent, type ToggleMuteEvent, type ViewContext, ZERO_SAFE_AREA_INSET, createGameEventMessage, parseGameEventMessage, sdk };

package/dist/index.d.ts

@@ -42,19 +42,52 @@ type GameInfo = {
         id: string;
         gameState: GameState;
     } | null;
+    levelBased?: {
+        levelCount: number;
+        /**
+         * Score-derived level progression for this player. Platform-owned and kept
+         * fully separate from `gameState` — never read progression out of gameState.
+         */
+        progress: LevelProgressState;
+    };
+};
+/** Score-derived, platform-owned progression for a level-based game. */
+type LevelProgressState = {
+    currentLevelIndex: number;
+    highestUnlockedLevel: number;
+    levelStars: Record<string, LevelStars>;
 };
 type ReadyEvent = {
     type: 'ready';
-    data: undefined;
+    data: {
+        instanceId: string;
+    } | undefined;
 };
 type PlayAgainEvent = {
     type: 'play_again';
-    data: undefined;
+    data?: {
+        levelIndex?: number;
+    };
+};
+type LevelStars = 1 | 2 | 3;
+type LevelOutcome = 'level_complete' | 'level_failed' | 'all_complete';
+/**
+ * One level attempt reported with game_over. Games report only what happened
+ * in the attempt; the host owns and derives all cumulative progression
+ * (star maps, unlock state) — see `LevelProgressState` for the host→game snapshot.
+ */
+type LevelAttempt = {
+    /** 1-based index of the level that was just played. */
+    levelIndex: number;
+    /** Stars earned this attempt. Omit for star-less games; a completion counts as 1. */
+    stars?: LevelStars;
+    outcome: LevelOutcome;
 };
 type SinglePlayerGameOverEvent = {
     type: 'game_over';
     data: {
         score: number;
+        levelAttempt?: LevelAttempt;
     };
 };
 type MultiplayerGameOverEvent = {
@@ -66,9 +99,12 @@ type MultiplayerGameOverEvent = {
         }[];
     };
 };
+type HapticFeedbackType = 'light' | 'medium' | 'hard' | 'success' | 'error';
 type HapticFeedbackEvent = {
     type: 'haptic_feedback';
-    data: undefined;
+    data?: {
+        type?: HapticFeedbackType;
+    };
 };
 type ToggleMuteEvent = {
     type: 'toggle_mute';
@@ -84,6 +120,7 @@ type GameErrorEvent = {
         lineno?: number;
         colno?: number;
         error?: Error;
+        stack?: string;
     };
 };
 type GameInfoEvent = {
@@ -136,28 +173,56 @@ type GameEventMessage<T extends GameEvent['type']> = {
         type: T;
     }>;
 };
+/**
+ * Build a game_event envelope for sending over postMessage. Hosts and the SDK
+ * share this so the wire format is defined in one place.
+ */
+declare const createGameEventMessage: <T extends GameEvent["type"]>(type: T, data: Extract<GameEvent, {
+    type: T;
+}>["data"]) => GameEventMessage<T>;
+/**
+ * Parse an unknown postMessage payload into a GameEvent, or null when the
+ * payload is not a well-formed game_event envelope.
+ */
+declare const parseGameEventMessage: (value: unknown) => GameEvent | null;
 /**
  * Messages from the game host to the game client
  */
 type IncomingGameEvent = GameEventMessage<'play_again' | 'toggle_mute' | 'game_info' | 'game_state_updated' | 'purchase_complete'>;
 type OutgoingGameEvent = GameEventMessage<'game_over' | 'ready' | 'haptic_feedback' | 'error' | 'save_game_state' | 'refute_game_state' | 'multiplayer_game_over' | 'multiplayer_save_game_state' | 'purchase'>;
-type EventCallback = (data: unknown) => void;
+type IncomingGameEventType = IncomingGameEvent['event']['type'];
+type IncomingGameEventData<T extends IncomingGameEventType> = Extract<GameEvent, {
+    type: T;
+}>['data'];
 declare class RemixSDK {
     private isClient;
     private target;
     private eventListeners;
+    private readyPromise;
     private readyPromiseResolve;
-    private purchasePromiseResolve;
+    private purchasePromiseResolvers;
+    private readyResendTimer;
+    private readonly instanceId;
     private _gameInfo?;
     private _gameState?;
+    private _levelStars;
     constructor();
-    on(eventType: IncomingGameEvent['event']['type'], callback: EventCallback): void;
-    off(eventType: IncomingGameEvent['event']['type'], callback: EventCallback): void;
-    onPlayAgain(callback: () => void): void;
-    onToggleMute(callback: (data: ToggleMuteEvent['data']) => void): void;
-    onGameStateUpdated(callback: (data: GameStateUpdatedEvent['data']) => void): void;
-    onGameInfo(callback: (data: GameInfoEvent['data']) => void): void;
-    onPurchaseComplete(callback: (data: PurchaseCompleteEvent['data']) => void): void;
+    private scheduleReadyResend;
+    private cancelReadyResend;
+    on<T extends IncomingGameEventType>(eventType: T, callback: (data: IncomingGameEventData<T>) => void): () => void;
+    off<T extends IncomingGameEventType>(eventType: T, callback: (data: IncomingGameEventData<T>) => void): void;
+    /**
+     * Listen for the host starting play: a replay after game over, or — for level
+     * games — a host-directed level via `data.levelIndex` (Studio continue/jump or
+     * the production next-level button). `data` may be omitted for a plain restart.
+     */
+    onPlay(callback: (data?: PlayAgainEvent['data']) => void): () => void;
+    /** @deprecated Use {@link onPlay}. Retained for backward compatibility. */
+    onPlayAgain(callback: (data?: PlayAgainEvent['data']) => void): () => void;
+    onToggleMute(callback: (data: ToggleMuteEvent['data']) => void): () => void;
+    onGameStateUpdated(callback: (data: GameStateUpdatedEvent['data']) => void): () => void;
+    onGameInfo(callback: (data: GameInfoEvent['data']) => void): () => void;
+    onPurchaseComplete(callback: (data: PurchaseCompleteEvent['data']) => void): () => void;
     setTarget(target: Window): void;
     get purchasedItems(): string[];
     get inventory(): InventoryItem[];
@@ -167,17 +232,29 @@ declare class RemixSDK {
     get players(): Player[] | undefined;
     get player(): Player | undefined;
     get isReady(): boolean;
+    /** True when the host configured this game with a fixed level count. */
+    get isLevelBased(): boolean;
+    /** Total levels for level-based games (from host metadata). */
+    get levelCount(): number | undefined;
+    /** 1-based level index from score-derived progression, defaulting to 1. */
+    get currentLevelIndex(): number;
+    /** Best stars earned per level from score-derived progression. Keys are 1-based level indices. */
+    get levelStars(): Record<string, LevelStars>;
+    /** Highest unlocked level from score-derived progression, defaulting to 1. */
+    get highestUnlockedLevel(): number;
+    /** Sum of best stars across all completed levels. */
+    get totalStars(): number;
     ready: () => Promise<GameInfo>;
     purchase: (data: PurchaseEvent["data"]) => Promise<PurchaseCompleteEvent["data"]>;
     reportError: (data: GameErrorEvent["data"]) => void;
-    hapticFeedback: () => void;
+    hapticFeedback: (type?: HapticFeedbackType) => void;
     hasItem: (item: string) => boolean;
     getItemPurchaseCount: (item: string) => number;
     getShopItem: (slug: string) => ShopItem | undefined;
     singlePlayer: {
         actions: {
             ready: () => Promise<GameInfo>;
-            hapticFeedback: () => void;
+            hapticFeedback: (type?: HapticFeedbackType) => void;
             reportError: (data: GameErrorEvent["data"]) => void;
             purchase: (data: PurchaseEvent["data"]) => Promise<PurchaseCompleteEvent["data"]>;
             gameOver: (data: SinglePlayerGameOverEvent["data"]) => void;
@@ -190,7 +267,7 @@ declare class RemixSDK {
             refuteGameState: (data: RefuteGameStateEvent["data"]) => void;
             saveGameState: (data: MultiplayerSaveGameStateEvent["data"]) => void;
             ready: () => Promise<GameInfo>;
-            hapticFeedback: () => void;
+            hapticFeedback: (type?: HapticFeedbackType) => void;
             reportError: (data: GameErrorEvent["data"]) => void;
             purchase: (data: PurchaseEvent["data"]) => Promise<PurchaseCompleteEvent["data"]>;
         };
@@ -204,4 +281,4 @@ declare class RemixSDK {
 }
 declare const sdk: RemixSDK;
 
-export { type GameErrorEvent, type GameEvent, type GameEventMessage, type GameInfo, type GameInfoEvent, type GameState, type GameStateUpdatedEvent, type HapticFeedbackEvent, type IncomingGameEvent, type InventoryItem, type MultiplayerGameOverEvent, type MultiplayerSaveGameStateEvent, type OutgoingGameEvent, type PlayAgainEvent, type Player, type PurchaseCompleteEvent, type PurchaseEvent, type ReadyEvent, type RefuteGameStateEvent, RemixSDK, type SafeAreaInset, type SaveGameStateEvent, type ShopItem, type SinglePlayerGameOverEvent, type ToggleMuteEvent, type ViewContext, ZERO_SAFE_AREA_INSET, sdk };
+export { type GameErrorEvent, type GameEvent, type GameEventMessage, type GameInfo, type GameInfoEvent, type GameState, type GameStateUpdatedEvent, type HapticFeedbackEvent, type HapticFeedbackType, type IncomingGameEvent, type IncomingGameEventData, type IncomingGameEventType, type InventoryItem, type LevelAttempt, type LevelOutcome, type LevelProgressState, type LevelStars, type MultiplayerGameOverEvent, type MultiplayerSaveGameStateEvent, type OutgoingGameEvent, type PlayAgainEvent, type Player, type PurchaseCompleteEvent, type PurchaseEvent, type ReadyEvent, type RefuteGameStateEvent, RemixSDK, type SafeAreaInset, type SaveGameStateEvent, type ShopItem, type SinglePlayerGameOverEvent, type ToggleMuteEvent, type ViewContext, ZERO_SAFE_AREA_INSET, createGameEventMessage, parseGameEventMessage, sdk };