@smoregg/sdk 0.6.2 → 1.0.0

package/dist/types/types.d.ts

@@ -18,7 +18,21 @@ export type RoomCode = string;
 /**
  * Base event map type. Extend this to define your game's events.
  *
- * @example
+ * **Important:** Event data values must be plain objects, not primitives.
+ * Primitive values (string, number, boolean) will be automatically wrapped
+ * as `{ data: <value> }` by the relay server, which breaks type safety.
+ *
+ * **Payload Size Limit:** Maximum payload size per event is 64KB. This limit
+ * is enforced by the server's genericRelay handler. Payloads exceeding this
+ * limit will be silently dropped by the server without error notification.
+ *
+ * **Type Safety Note:** Without providing an explicit generic type parameter,
+ * `createScreen()` and `createController()` default to the empty `EventMap`,
+ * which means `send()`, `broadcast()`, and `on()` accept any string as an event
+ * name and `unknown` as data -- effectively losing compile-time type checking.
+ * Always define and pass your game's event map for full type safety.
+ *
+ * @example Defining events for type safety
  * ```ts
  * interface MyGameEvents {
  *   // Screen receives from Controller
@@ -29,18 +43,28 @@ export type RoomCode = string;
  *   'phase-update': { phase: 'lobby' | 'playing' | 'results' };
  *   'your-turn': { timeLimit: number };
  * }
+ *
+ * // With explicit generic -- full type safety
+ * const screen = await createScreen<MyGameEvents>({ ... });
+ * screen.broadcast('tap', { x: 1, y: 2 }); // Type-checked
+ *
+ * // Without generic -- no type safety (not recommended)
+ * const screen = await createScreen({ ... });
+ * screen.broadcastRaw('anything', 'any data'); // No checking
+ * ```
+ *
+ * @example Event naming conventions
+ * ```ts
+ * // Define your game's event map for type safety:
+ * type MyEvents = {
+ *   'player-move': { x: number; y: number };
+ *   'game-action': { action: string; value: number };
+ * };
+ * // Event names: use kebab-case, no colons (:), no 'smore:' prefix
  * ```
  */
 export interface EventMap {
 }
-/**
- * Type constraint for event maps (allows interfaces without index signatures)
- */
-export type EventMapConstraint = Record<string, unknown>;
-/**
- * Empty event map for games that don't need custom events.
- */
-export type EmptyEventMap = Record<string, never>;
 /**
  * Extract event names from an event map.
  */
@@ -50,21 +74,25 @@ export type EventNames<TEvents extends EventMap> = keyof TEvents & string;
  */
 export type EventData<TEvents extends EventMap, TEvent extends EventNames<TEvents>> = TEvents[TEvent];
 /**
- * Character appearance options for player avatars.
+ * Character appearance data for player avatars.
+ *
+ * This type matches the server's CharacterDTO structure to ensure
+ * type consistency across the platform.
+ *
+ * @property id - Unique character identifier
+ * @property seed - Random seed for generating the character
+ * @property style - Character style preset identifier
+ * @property options - Additional character customization options
  */
 export interface CharacterAppearance {
-    /** Skin color hex code */
-    skinColor?: string;
-    /** Hair color hex code */
-    hairColor?: string;
-    /** Shirt/top color hex code */
-    shirtColor?: string;
-    /** Pants/bottom color hex code */
-    pantsColor?: string;
-    /** Hair style identifier */
-    hairStyle?: string;
-    /** Outfit style identifier */
-    outfit?: string;
+    /** Unique character identifier */
+    id: string;
+    /** Random seed for generating the character */
+    seed: string;
+    /** Character style preset identifier */
+    style: string;
+    /** Additional character customization options */
+    options: Record<string, any>;
 }
 /**
  * Information about a connected controller (player).
@@ -73,12 +101,27 @@ export interface CharacterAppearance {
 export interface ControllerInfo {
     /** Player's unique index (0, 1, 2, ...) */
     readonly playerIndex: PlayerIndex;
-    /** Player's chosen display name */
+    /**
+     * Player's chosen display name.
+     *
+     * Maps to `PlayerDTO.name` on the server side. The SDK exposes it as
+     * "nickname" for semantic clarity in game code.
+     * The mapping (`name` -> `nickname`) is handled automatically during
+     * player data deserialization in the transport layer.
+     *
+     * @see PlayerDTO.name (server) -- same value, different field name
+     */
     readonly nickname: string;
     /** Whether the player is currently connected */
     readonly connected: boolean;
-    /** Optional character appearance */
-    readonly appearance?: CharacterAppearance;
+    /**
+     * Optional character appearance data.
+     *
+     * Note: The server sends this as "character" in PlayerDTO.
+     * The SDK maps it to "appearance" for semantic clarity.
+     * The server may send `null` when no character is set.
+     */
+    readonly appearance?: CharacterAppearance | null;
 }
 /**
  * Handler for events received from controllers.
@@ -118,6 +161,17 @@ export type ScreenListeners<TEvents extends EventMap> = {
  * });
  * // Screen is ready here
  * ```
+ *
+ * ## Best Practices: Callbacks vs Events
+ *
+ * - **Config callbacks** (`onReady`, `onControllerJoin`, etc.): Use for essential lifecycle events
+ *   that should always be handled. These are registered once at creation and cannot be removed.
+ *
+ * - **`on()`/`off()` methods**: Use for dynamic event handlers that may need to be added/removed
+ *   during gameplay. These support multiple handlers per event and can be cleaned up with `off()`.
+ *
+ * For most games, config callbacks are sufficient. Use `on()`/`off()` only when you need
+ * dynamic handler management (e.g., different handlers per game phase).
  */
 export interface ScreenConfig<TEvents extends EventMap = EventMap> {
     /**
@@ -133,13 +187,46 @@ export interface ScreenConfig<TEvents extends EventMap = EventMap> {
      * Called when a controller (player) leaves the room.
      */
     onControllerLeave?: (playerIndex: PlayerIndex) => void;
+    /**
+     * Called when a controller temporarily disconnects (e.g., lost WiFi).
+     * The player may reconnect — see onControllerReconnect.
+     */
+    onControllerDisconnect?: (playerIndex: PlayerIndex) => void;
     /**
      * Called when a controller reconnects after a disconnect.
      */
     onControllerReconnect?: (playerIndex: PlayerIndex, info: ControllerInfo) => void;
+    /**
+     * Called when a player's character appearance is updated.
+     *
+     * @param playerIndex - The player whose character changed
+     * @param appearance - The new character appearance, or null if removed/reset
+     *
+     * @note Sending an empty/null character update from the platform resets the
+     * player's appearance to null (default state). This allows players to clear
+     * their character selection.
+     */
+    onCharacterUpdated?: (playerIndex: PlayerIndex, appearance: CharacterAppearance | null) => void;
+    /**
+     * Called when the server rate-limits an event from this client.
+     *
+     * @param event - The event name that was rate-limited
+     */
+    onRateLimited?: (event: string) => void;
     /**
      * Event listeners for messages from controllers.
      * Keys are event names, values are handler functions.
+     *
+     * **Relationship with on() method:**
+     * - Listeners passed in config are registered during initialization
+     * - Listeners added via on() are registered dynamically after initialization
+     * - Both types of listeners coexist and are called in registration order
+     *
+     * **Important:** Lifecycle listeners (onReady, onControllerJoin, etc.) passed
+     * in config are NOT removable via off(). They are permanent for the lifetime
+     * of the Screen instance. Only listeners added via on() can be removed via off().
+     *
+     * @see Best Practices section above for guidance on when to use `listeners` config vs `on()` method.
      */
     listeners?: ScreenListeners<TEvents>;
     /**
@@ -184,12 +271,16 @@ export interface ScreenConfig<TEvents extends EventMap = EventMap> {
  * ```
  */
 export interface Screen<TEvents extends EventMap = EventMap> {
-    /** All connected controllers. Returns a shallow copy. */
+    /**
+     * All connected controllers. Returns a new shallow copy on every access.
+     *
+     * **Performance note:** Each access creates a new array via spread.
+     * Avoid calling this in tight loops; cache the result in a local variable
+     * if you need to access it repeatedly within the same frame/tick.
+     */
     readonly controllers: readonly ControllerInfo[];
     /** The room code for this game session. */
     readonly roomCode: RoomCode;
-    /** Index of the leader/host controller (-1 if none). */
-    readonly leaderIndex: PlayerIndex;
     /** Whether the screen is initialized and ready. */
     readonly isReady: boolean;
     /** Whether the screen has been destroyed. */
@@ -199,6 +290,8 @@ export interface Screen<TEvents extends EventMap = EventMap> {
      *
      * @param event - Event name (must match TEvents keys)
      * @param data - Event data (type-safe based on event name)
+     * @note Data should be an object. Primitive values will be wrapped as `{ data: value }` by the relay server.
+     * @note Maximum payload size is 64KB. Payloads exceeding this limit will be silently dropped by the server.
      *
      * @example
      * ```ts
@@ -214,9 +307,13 @@ export interface Screen<TEvents extends EventMap = EventMap> {
     /**
      * Send an event to a specific controller.
      *
+     * Screen → Controller direction only. For Controller → Screen, see `send()`.
+     *
      * @param playerIndex - Target controller's player index
      * @param event - Event name (must match TEvents keys)
      * @param data - Event data (type-safe based on event name)
+     * @note Data should be an object. Primitive values will be wrapped as `{ data: value }` by the relay server.
+     * @note Maximum payload size is 64KB. Payloads exceeding this limit will be silently dropped by the server.
      *
      * @example
      * ```ts
@@ -265,6 +362,9 @@ export interface Screen<TEvents extends EventMap = EventMap> {
     on<K extends EventNames<TEvents>>(event: K, handler: ScreenEventHandler<EventData<TEvents, K>>): () => void;
     /**
      * Add a one-time listener that auto-removes after first call.
+     *
+     * @note The handler is internally wrapped, so it cannot be removed via
+     * `off(event, originalHandler)`. Use the returned unsubscribe function instead.
      */
     once<K extends EventNames<TEvents>>(event: K, handler: ScreenEventHandler<EventData<TEvents, K>>): () => void;
     /**
@@ -276,14 +376,18 @@ export interface Screen<TEvents extends EventMap = EventMap> {
      * Returns undefined if not found.
      */
     getController(playerIndex: PlayerIndex): ControllerInfo | undefined;
-    /**
-     * Check if a player index is the leader.
-     */
-    isLeader(playerIndex: PlayerIndex): boolean;
     /**
      * Get the number of connected controllers.
      */
     getControllerCount(): number;
+    /**
+     * Check if there is at least one connected controller.
+     * Useful for detecting when all players have disconnected
+     * (e.g., to pause the game or show a waiting screen).
+     *
+     * Screen-only method. Controller instances can check their own connection status directly.
+     */
+    hasAnyConnectedControllers(): boolean;
     /**
      * Clean up all resources and disconnect.
      * Call this when unmounting/destroying your game.
@@ -343,9 +447,62 @@ export interface ControllerConfig<TEvents extends EventMap = EventMap> {
      * Called when another player leaves the room.
      */
     onControllerLeave?: (playerIndex: PlayerIndex) => void;
+    /**
+     * Called when another player temporarily disconnects.
+     */
+    onControllerDisconnect?: (playerIndex: PlayerIndex) => void;
+    /**
+     * Called when another player reconnects after a disconnect.
+     */
+    onControllerReconnect?: (playerIndex: PlayerIndex, info: ControllerInfo) => void;
+    /**
+     * Called when a player's character appearance is updated.
+     *
+     * @param playerIndex - The player whose character changed
+     * @param appearance - The new character appearance, or null if removed/reset
+     *
+     * @note Sending an empty/null character update from the platform resets the
+     * player's appearance to null (default state). This allows players to clear
+     * their character selection.
+     */
+    onCharacterUpdated?: (playerIndex: PlayerIndex, appearance: CharacterAppearance | null) => void;
+    /**
+     * Called when the server rate-limits an event from this client.
+     *
+     * @param event - The event name that was rate-limited
+     */
+    onRateLimited?: (event: string) => void;
+    /**
+     * Called when the host/screen disconnects.
+     * The game may become unresponsive until the host reconnects.
+     *
+     * @experimental This callback is reserved for future use and currently non-functional.
+     * The server emits `smore:host-disconnected` but it is not yet forwarded to SDK games
+     * through the IframeGameBridge GAME_FACING_EVENTS allowlist. Setting this callback
+     * will produce a runtime warning. It will become functional in a future SDK release.
+     */
+    onHostDisconnect?: () => void;
+    /**
+     * Called when the host/screen reconnects after a disconnect.
+     *
+     * @experimental This callback is reserved for future use and currently non-functional.
+     * The server emits `smore:host-reconnected` but it is not yet forwarded to SDK games
+     * through the IframeGameBridge GAME_FACING_EVENTS allowlist. Setting this callback
+     * will produce a runtime warning. It will become functional in a future SDK release.
+     */
+    onHostReconnect?: () => void;
     /**
      * Event listeners for messages from the screen.
      * Keys are event names, values are handler functions.
+     *
+     * **Relationship with on() method:**
+     * - Listeners passed in config are registered during initialization
+     * - Listeners added via on() are registered dynamically after initialization
+     * - Both types of listeners coexist and are called in registration order
+     *
+     * **Important:** Lifecycle listeners (onReady, onControllerJoin, etc.) passed
+     * in config are NOT removable via off(). They are permanent for the lifetime
+     * of the Controller instance. Only listeners added via on() can be removed via off().
      */
     listeners?: ControllerListeners<TEvents>;
     /**
@@ -380,29 +537,46 @@ export interface ControllerConfig<TEvents extends EventMap = EventMap> {
  *
  * // Send input to screen
  * controller.send('tap', { x: 100, y: 200 });
- *
- * // Check if I'm the leader
- * if (controller.isLeader) {
- *   // Show leader-only controls
- * }
  * ```
+ *
+ * ## Controller API Design Note:
+ *
+ * Controller only has `send()` (no `broadcast()` or `gameOver()`).
+ * This is intentional: Controller-to-Controller (C2C) communication is not supported.
+ * All coordination between controllers must go through the Screen.
+ *
+ * Flow: Controller.send() → Screen receives → Screen.broadcast() or Screen.sendToController()
  */
 export interface Controller<TEvents extends EventMap = EventMap> {
     /** My player index (0, 1, 2, ...). */
     readonly myIndex: PlayerIndex;
-    /** Whether I am the room leader/host. */
-    readonly isLeader: boolean;
     /** The room code for this game session. */
     readonly roomCode: RoomCode;
     /** Whether the controller is initialized and ready. */
     readonly isReady: boolean;
     /** Whether the controller has been destroyed. */
     readonly isDestroyed: boolean;
+    /**
+     * Read-only list of all known controllers (players) in the room.
+     * Returns full ControllerInfo including playerIndex, nickname, connected status, and appearance.
+     * Consistent with Screen's `controllers` property.
+     *
+     * **Performance note:** Each access creates a new shallow copy array.
+     * Cache the result in a local variable if you need to access it repeatedly.
+     */
+    readonly controllers: readonly ControllerInfo[];
+    /**
+     * Returns the number of currently connected players.
+     */
+    getControllerCount(): number;
     /**
      * Send an event to the screen.
      *
+     * Controller → Screen direction only. For Screen → Controller, see `sendToController()`.
+     *
      * @param event - Event name (must match TEvents keys)
      * @param data - Event data (type-safe based on event name)
+     * @note Maximum payload size is 64KB. Payloads exceeding this limit will be silently dropped by the server.
      *
      * @example
      * ```ts
@@ -423,6 +597,11 @@ export interface Controller<TEvents extends EventMap = EventMap> {
      * @param handler - Handler function (data) => void
      * @returns Cleanup function to remove the listener
      *
+     * @note Events from screen.broadcast() do not include playerIndex.
+     * The handler signature is `(data: D)` without playerIndex context.
+     * If you need to know which player triggered the broadcast, include
+     * that information in the data object from the Screen side.
+     *
      * @example
      * ```ts
      * const unsubscribe = controller.on('phase-update', (data) => {
@@ -436,6 +615,9 @@ export interface Controller<TEvents extends EventMap = EventMap> {
     on<K extends EventNames<TEvents>>(event: K, handler: ControllerEventHandler<EventData<TEvents, K>>): () => void;
     /**
      * Add a one-time listener that auto-removes after first call.
+     *
+     * @note The handler is internally wrapped, so it cannot be removed via
+     * `off(event, originalHandler)`. Use the returned unsubscribe function instead.
      */
     once<K extends EventNames<TEvents>>(event: K, handler: ControllerEventHandler<EventData<TEvents, K>>): () => void;
     /**
@@ -479,20 +661,6 @@ export interface SmoreError {
     /** Additional context */
     details?: Record<string, unknown>;
 }
-/**
- * Custom error class for SDK errors.
- */
-export declare class SmoreSDKError extends Error {
-    readonly code: SmoreErrorCode;
-    readonly cause?: Error;
-    readonly details?: Record<string, unknown>;
-    constructor(code: SmoreErrorCode, message: string, options?: {
-        cause?: Error;
-        details?: Record<string, unknown>;
-    });
-    /** Convert to SmoreError interface */
-    toSmoreError(): SmoreError;
-}
 /**
  * Log levels for debug output.
  */
@@ -522,6 +690,10 @@ export interface DebugOptions {
  * Returns a Promise that resolves when the screen is ready.
  * You can also use the onReady callback in config for immediate instantiation.
  *
+ * The return type is a Promise with an `instance` property for dual access:
+ * - Await the Promise to get the instance after initialization completes
+ * - Access `instance` property for synchronous access before initialization
+ *
  * @template TEvents - Event map type for type-safe events
  * @param config - Screen configuration
  * @returns Promise that resolves to the Screen instance when ready
@@ -556,6 +728,10 @@ export declare function createScreen<TEvents extends EventMap = EventMap>(config
  * Returns a Promise that resolves when the controller is ready.
  * You can also use the onReady callback in config for immediate instantiation.
  *
+ * The return type is a Promise with an `instance` property for dual access:
+ * - Await the Promise to get the instance after initialization completes
+ * - Access `instance` property for synchronous access before initialization
+ *
  * @template TEvents - Event map type for type-safe events
  * @param config - Controller configuration
  * @returns Promise that resolves to the Controller instance when ready
@@ -594,10 +770,24 @@ export interface MockOptions {
     controllers?: ControllerInfo[];
     /** My index for Controller mock */
     myIndex?: PlayerIndex;
-    /** Am I leader for Controller mock */
-    isLeader?: boolean;
     /** Auto-trigger onReady */
     autoReady?: boolean;
+    /** Called when ready is triggered */
+    onReady?: () => void;
+    /** Called when a controller joins */
+    onControllerJoin?: (playerIndex: PlayerIndex, info: ControllerInfo) => void;
+    /** Called when a controller leaves */
+    onControllerLeave?: (playerIndex: PlayerIndex) => void;
+    /** Called when a controller disconnects */
+    onControllerDisconnect?: (playerIndex: PlayerIndex) => void;
+    /** Called when a controller reconnects */
+    onControllerReconnect?: (playerIndex: PlayerIndex, info: ControllerInfo) => void;
+    /** Called when a player's character appearance is updated */
+    onCharacterUpdated?: (playerIndex: PlayerIndex, appearance: CharacterAppearance | null) => void;
+    /** Called when the server rate-limits an event from this client */
+    onRateLimited?: (event: string) => void;
+    /** Called when an error occurs */
+    onError?: (error: SmoreError) => void;
 }
 /**
  * Mock Screen for testing.
@@ -619,6 +809,16 @@ export interface MockScreen<TEvents extends EventMap = EventMap> extends Screen<
      * Triggers onControllerLeave callback.
      */
     simulateControllerLeave(playerIndex: PlayerIndex): void;
+    /**
+     * Simulate a controller disconnecting temporarily.
+     * Triggers onControllerDisconnect callback and marks player as disconnected.
+     */
+    simulateControllerDisconnect(playerIndex: PlayerIndex): void;
+    /**
+     * Simulate a controller reconnecting after a disconnect.
+     * Triggers onControllerReconnect callback and marks player as connected.
+     */
+    simulateControllerReconnect(playerIndex: PlayerIndex): void;
     /**
      * Get all events that were broadcast.
      * Returns array of { event, data } objects.
@@ -642,6 +842,18 @@ export interface MockScreen<TEvents extends EventMap = EventMap> extends Screen<
      * Manually trigger the ready state.
      */
     triggerReady(): void;
+    /**
+     * Simulate a player's character appearance being updated.
+     * Triggers onCharacterUpdated callback and updates the controller's appearance.
+     */
+    simulateCharacterUpdate(playerIndex: PlayerIndex, appearance: CharacterAppearance | null): void;
+    /**
+     * Simulate the server rate-limiting an event.
+     * Triggers onRateLimited callback.
+     */
+    simulateRateLimited(event: string): void;
+    /** Simulate an error. Triggers onError callback. */
+    simulateError(error: any): void;
 }
 /**
  * Mock Controller for testing.
@@ -670,9 +882,37 @@ export interface MockController<TEvents extends EventMap = EventMap> extends Con
      */
     triggerReady(): void;
     /**
-     * Update the leader status.
+     * Simulate another player joining the room.
+     * Triggers onControllerJoin callback.
+     */
+    simulatePlayerJoin(playerIndex: PlayerIndex, info: ControllerInfo): void;
+    /**
+     * Simulate another player leaving the room.
+     * Triggers onControllerLeave callback.
+     */
+    simulatePlayerLeave(playerIndex: PlayerIndex): void;
+    /**
+     * Simulate another player disconnecting temporarily.
+     * Triggers onControllerDisconnect callback.
      */
-    setLeader(isLeader: boolean): void;
+    simulatePlayerDisconnect(playerIndex: PlayerIndex): void;
+    /**
+     * Simulate another player reconnecting after a disconnect.
+     * Triggers onControllerReconnect callback.
+     */
+    simulatePlayerReconnect(playerIndex: PlayerIndex, info: ControllerInfo): void;
+    /**
+     * Simulate a player's character appearance being updated.
+     * Triggers onCharacterUpdated callback and updates the controller's appearance.
+     */
+    simulateCharacterUpdate(playerIndex: PlayerIndex, appearance: CharacterAppearance | null): void;
+    /**
+     * Simulate the server rate-limiting an event.
+     * Triggers onRateLimited callback.
+     */
+    simulateRateLimited(event: string): void;
+    /** Simulate an error. Triggers onError callback. */
+    simulateError(error: any): void;
 }
 /**
  * Create a mock Screen for testing.
@@ -704,7 +944,6 @@ export declare function createMockScreen<TEvents extends EventMap = EventMap>(op
  * ```ts
  * const mockController = createMockController<MyEvents>({
  *   myIndex: 0,
- *   isLeader: true,
  * });
  *
  * // Simulate receiving from screen
@@ -718,81 +957,9 @@ export declare function createMockScreen<TEvents extends EventMap = EventMap>(op
  * ```
  */
 export declare function createMockController<TEvents extends EventMap = EventMap>(options?: MockOptions): MockController<TEvents>;
-/**
- * Transport event handler type.
- */
-export type TransportEventHandler = (...args: unknown[]) => void;
-/**
- * Abstract transport interface for communication.
- * Used internally but exposed for custom integrations.
- */
-export interface Transport {
-    /** Emit an event with optional data */
-    emit(event: string, ...args: unknown[]): void;
-    /** Register an event handler */
-    on(event: string, handler: TransportEventHandler): void;
-    /** Remove an event handler */
-    off(event: string, handler?: TransportEventHandler): void;
-}
-/**
- * Direct transport options (for bundled games with Socket.IO).
- */
-export interface DirectTransportOptions {
-    socket: unknown;
-}
-/**
- * PostMessage transport options (for iframe games).
- */
-export interface PostMessageTransportOptions {
-    /** Parent window origin for validation */
-    parentOrigin?: string;
-}
-/**
- * @deprecated Use ControllerInfo instead
- */
-export type Player = ControllerInfo;
-/**
- * @deprecated Use ControllerInfo instead
- */
-export type SmoreScreenPlayer = ControllerInfo;
-/**
- * @deprecated Use ControllerInfo instead
- */
-export type SmoreHostPlayer = ControllerInfo;
-/**
- * @deprecated Use ControllerInfo instead
- */
-export type SmoreControllerInfo = ControllerInfo;
-/**
- * @deprecated Use ControllerInfo instead
- */
-export type SmorePlayerInfo = ControllerInfo;
-/**
- * @deprecated Use ScreenConfig instead
- */
-export type SmoreScreenConfig<T extends EventMap = EventMap> = ScreenConfig<T>;
-/**
- * @deprecated Use ScreenConfig instead
- */
-export type SmoreHostConfig<T extends EventMap = EventMap> = ScreenConfig<T>;
-/**
- * @deprecated Use ControllerConfig instead
- */
-export type SmoreControllerConfig<T extends EventMap = EventMap> = ControllerConfig<T>;
-/**
- * @deprecated Use ControllerConfig instead
- */
-export type SmorePlayerConfig<T extends EventMap = EventMap> = ControllerConfig<T>;
-/**
- * @deprecated Use Screen instead
- */
-export type SmoreScreen<T extends EventMap = EventMap> = Screen<T>;
-/**
- * @deprecated Use Controller instead
- */
-export type SmoreController<T extends EventMap = EventMap> = Controller<T>;
 /**
  * Game metadata from game.json manifest.
+ * SYNC: Also defined in game-project/types/src/types.ts - keep in sync.
  */
 export interface GameMetadata {
     /** Unique game identifier */
@@ -814,88 +981,4 @@ export interface GameMetadata {
     /** Game version */
     version?: string;
 }
-/**
- * Generic game state type.
- * Use a more specific type in your game.
- */
-export type GameState = Record<string, unknown>;
-/**
- * Input callback type for legacy compatibility.
- * @deprecated Use ScreenEventHandler instead
- */
-export type InputCallback = (playerIndex: PlayerIndex, data?: unknown) => void;
-/**
- * Props for TapButton component.
- */
-export interface TapButtonProps {
-    /** Called when button is tapped */
-    onTap: () => void;
-    /** Button content */
-    children?: React.ReactNode;
-    /** Additional CSS classes */
-    className?: string;
-    /** Disable the button */
-    disabled?: boolean;
-}
-/**
- * Props for HoldButton component.
- */
-export interface HoldButtonProps {
-    /** Called when hold starts */
-    onHoldStart: () => void;
-    /** Called when hold ends */
-    onHoldEnd: () => void;
-    /** Button content */
-    children?: React.ReactNode;
-    /** Additional CSS classes */
-    className?: string;
-    /** Disable the button */
-    disabled?: boolean;
-}
-/**
- * Direction type for directional inputs.
- */
-export type Direction = 'up' | 'down' | 'left' | 'right';
-/**
- * Props for DirectionPad component.
- */
-export interface DirectionPadProps {
-    /** Called when a direction is pressed */
-    onDirection: (direction: Direction) => void;
-    /** Show only left/right buttons */
-    leftRightOnly?: boolean;
-    /** Show only up/down buttons */
-    upDownOnly?: boolean;
-    /** Additional CSS classes */
-    className?: string;
-}
-/**
- * Props for SwipeArea component.
- */
-export interface SwipeAreaProps {
-    /** Called when a swipe is detected */
-    onSwipe: (direction: Direction) => void;
-    /** Minimum swipe distance in pixels */
-    threshold?: number;
-    /** Area content */
-    children?: React.ReactNode;
-    /** Additional CSS classes */
-    className?: string;
-}
-/**
- * Namespace for Screen-related types.
- */
-export declare namespace Screen {
-    type Config<T extends EventMap = EventMap> = ScreenConfig<T>;
-    type Listeners<T extends EventMap = EventMap> = ScreenListeners<T>;
-    type EventHandler<T = unknown> = ScreenEventHandler<T>;
-}
-/**
- * Namespace for Controller-related types.
- */
-export declare namespace Controller {
-    type Config<T extends EventMap = EventMap> = ControllerConfig<T>;
-    type Listeners<T extends EventMap = EventMap> = ControllerListeners<T>;
-    type EventHandler<T = unknown> = ControllerEventHandler<T>;
-}
 //# sourceMappingURL=types.d.ts.map