@smoregg/sdk 0.5.0 → 0.6.0

package/dist/umd/smore-sdk-vanilla.umd.js

@@ -4,25 +4,6 @@
   (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.SmoreSDK = {}));
 })(this, (function (exports) { 'use strict';
 
-  class DirectTransport {
-    constructor(socket) {
-      this.socket = socket;
-    }
-    emit(event, ...args) {
-      this.socket.emit(event, ...args);
-    }
-    on(event, handler) {
-      this.socket.on(event, handler);
-    }
-    off(event, handler) {
-      if (handler) {
-        this.socket.off(event, handler);
-      } else {
-        this.socket.off(event);
-      }
-    }
-  }
-
   const SMORE_MSG_PREFIX = "smore:";
   function isSmoreMessage(data) {
     return data && typeof data === "object" && typeof data.type === "string" && data.type.startsWith(SMORE_MSG_PREFIX);
@@ -98,89 +79,234 @@
   const SYSTEM_EVENTS$1 = {
     PLAYER_JOIN: `${SYSTEM_PREFIX$1}player-join`,
     PLAYER_LEAVE: `${SYSTEM_PREFIX$1}player-leave`,
+    PLAYER_RECONNECT: `${SYSTEM_PREFIX$1}player-reconnect`,
     GAME_OVER: `${SYSTEM_PREFIX$1}game-over`
   };
-  const EVENT_NAME_REGEX$1 = /^[a-zA-Z]([a-zA-Z_-]*[a-zA-Z])?$/;
+  const DEFAULT_TIMEOUT$1 = 1e4;
+  let SmoreSDKError$1 = class SmoreSDKError extends Error {
+    code;
+    cause;
+    details;
+    constructor(code, message, options) {
+      super(message);
+      this.name = "SmoreSDKError";
+      this.code = code;
+      this.cause = options?.cause;
+      this.details = options?.details;
+      const ErrorWithCapture = Error;
+      if (typeof ErrorWithCapture.captureStackTrace === "function") {
+        ErrorWithCapture.captureStackTrace(this, SmoreSDKError);
+      }
+    }
+    toSmoreError() {
+      return {
+        code: this.code,
+        message: this.message,
+        cause: this.cause,
+        details: this.details
+      };
+    }
+  };
+  const EVENT_NAME_REGEX$1 = /^[a-zA-Z]([a-zA-Z0-9_-]*[a-zA-Z0-9])?$/;
   function validateEventName$1(event) {
+    if (!event || typeof event !== "string") {
+      throw new SmoreSDKError$1("INVALID_EVENT", "Event name must be a non-empty string");
+    }
     if (!EVENT_NAME_REGEX$1.test(event)) {
-      throw new Error(
-        `[SmoreHost] Invalid event name "${event}". Event names must:
-  - Only contain letters (a-z, A-Z), hyphens (-), and underscores (_)
-  - Start and end with a letter (no leading/trailing - or _)`
+      throw new SmoreSDKError$1(
+        "INVALID_EVENT",
+        `Invalid event name "${event}". Event names must start with a letter, contain only letters, numbers, hyphens, or underscores, and end with a letter or number.`,
+        { details: { event } }
+      );
+    }
+  }
+  function validatePlayerIndex(playerIndex, controllersCount) {
+    if (typeof playerIndex !== "number" || !Number.isInteger(playerIndex)) {
+      throw new SmoreSDKError$1("INVALID_PLAYER", "Player index must be an integer");
+    }
+    if (playerIndex < 0 || playerIndex >= controllersCount) {
+      throw new SmoreSDKError$1(
+        "INVALID_PLAYER",
+        `Invalid player index ${playerIndex}. Valid range: 0-${controllersCount - 1}`,
+        { details: { playerIndex, controllersCount } }
       );
     }
   }
-  class SmoreHost {
+  class DebugLogger {
+    enabled;
+    level;
+    prefix;
+    logSend;
+    logReceive;
+    logLifecycle;
+    customLogger;
+    static levelOrder = {
+      debug: 0,
+      info: 1,
+      warn: 2,
+      error: 3
+    };
+    constructor(options) {
+      if (typeof options === "boolean") {
+        this.enabled = options;
+        this.level = "debug";
+        this.prefix = "[SmoreScreen]";
+        this.logSend = true;
+        this.logReceive = true;
+        this.logLifecycle = true;
+      } else if (options) {
+        this.enabled = options.enabled ?? false;
+        this.level = options.level ?? "debug";
+        this.prefix = options.prefix ?? "[SmoreScreen]";
+        this.logSend = options.logSend ?? true;
+        this.logReceive = options.logReceive ?? true;
+        this.logLifecycle = options.logLifecycle ?? true;
+        this.customLogger = options.logger;
+      } else {
+        this.enabled = false;
+        this.level = "debug";
+        this.prefix = "[SmoreScreen]";
+        this.logSend = true;
+        this.logReceive = true;
+        this.logLifecycle = true;
+      }
+    }
+    shouldLog(level) {
+      return this.enabled && DebugLogger.levelOrder[level] >= DebugLogger.levelOrder[this.level];
+    }
+    log(level, message, data) {
+      if (!this.shouldLog(level)) return;
+      if (this.customLogger) {
+        this.customLogger(level, `${this.prefix} ${message}`, data);
+        return;
+      }
+      const consoleMethod = level === "error" ? "error" : level === "warn" ? "warn" : "log";
+      if (data !== void 0) {
+        console[consoleMethod](`${this.prefix} ${message}`, data);
+      } else {
+        console[consoleMethod](`${this.prefix} ${message}`);
+      }
+    }
+    debug(message, data) {
+      this.log("debug", message, data);
+    }
+    info(message, data) {
+      this.log("info", message, data);
+    }
+    warn(message, data) {
+      this.log("warn", message, data);
+    }
+    error(message, data) {
+      this.log("error", message, data);
+    }
+    send(event, data) {
+      if (this.logSend) {
+        this.debug(`-> SEND: ${event}`, data);
+      }
+    }
+    receive(event, data) {
+      if (this.logReceive) {
+        this.debug(`<- RECV: ${event}`, data);
+      }
+    }
+    lifecycle(message, data) {
+      if (this.logLifecycle) {
+        this.info(`[Lifecycle] ${message}`, data);
+      }
+    }
+  }
+  class ScreenImpl {
     transport = null;
     config;
-    _players = [];
+    logger;
+    _controllers = [];
     _roomCode = "";
     _leaderIndex = -1;
     _isReady = false;
     _isDestroyed = false;
+    eventHandlers = /* @__PURE__ */ new Map();
+    registeredTransportHandlers = [];
     boundMessageHandler = null;
-    registeredHandlers = [];
     constructor(config = {}) {
       this.config = config;
+      this.logger = new DebugLogger(config.debug);
       if (config.listeners) {
         for (const event of Object.keys(config.listeners)) {
           validateEventName$1(event);
         }
       }
-      if (config.socket) {
-        this.initBundled(config);
-      } else {
-        this.initIframe(config);
-      }
     }
     // ---------------------------------------------------------------------------
-    // Initialization
+    // Initialization (called by factory)
     // ---------------------------------------------------------------------------
-    initBundled(config) {
-      if (!config.socket) {
-        throw new Error("[SmoreHost] socket is required for bundled games");
-      }
-      this.transport = new DirectTransport(config.socket);
-      this._roomCode = config.roomCode || "";
-      this._players = config.players || [];
-      this._leaderIndex = config.leaderIndex ?? -1;
-      this.setupEventHandlers();
-      this._isReady = true;
-      this.config.onReady?.();
-    }
-    initIframe(config) {
-      const parentOrigin = config.parentOrigin || "*";
-      window.parent.postMessage({ type: "smore:ready" }, parentOrigin);
-      this.boundMessageHandler = (e) => {
-        if (parentOrigin !== "*" && e.origin !== parentOrigin) return;
-        const msg = e.data;
-        if (!isSmoreMessage(msg)) return;
-        if (msg.type === "smore:init") {
-          const initData = msg.payload;
-          if (initData.side !== "host") {
-            console.error("[SmoreHost] Received init for wrong side:", initData.side);
-            return;
-          }
-          this.transport = new PostMessageTransport(parentOrigin);
-          this._roomCode = initData.roomCode;
-          this._players = this.mapPlayersFromInit(initData.players);
-          this._leaderIndex = this.findLeaderIndex(initData.players, initData.leaderId);
-          this.setupEventHandlers();
-          this._isReady = true;
-          this.config.onReady?.();
-        } else if (msg.type === "smore:update") {
-          const updateData = msg.payload;
-          if (updateData.players) {
-            this._players = this.mapPlayersFromInit(updateData.players);
-          }
-          if (updateData.leaderId !== void 0) {
-            this._leaderIndex = this.findLeaderIndex(this._players, updateData.leaderId);
+    async initialize() {
+      this.logger.lifecycle("Initializing screen...");
+      const parentOrigin = this.config.parentOrigin ?? "*";
+      const timeout = this.config.timeout ?? DEFAULT_TIMEOUT$1;
+      return new Promise((resolve, reject) => {
+        const timeoutId = setTimeout(() => {
+          this.cleanup();
+          const error = new SmoreSDKError$1(
+            "TIMEOUT",
+            `Screen initialization timed out after ${timeout}ms. Make sure the parent frame sends smore:init.`,
+            { details: { timeout } }
+          );
+          this.handleError(error);
+          reject(error);
+        }, timeout);
+        this.boundMessageHandler = (e) => {
+          if (parentOrigin !== "*" && e.origin !== parentOrigin) return;
+          const msg = e.data;
+          if (!isSmoreMessage(msg)) return;
+          if (msg.type === "smore:init") {
+            clearTimeout(timeoutId);
+            const initData = msg.payload;
+            if (initData.side !== "host") {
+              const error = new SmoreSDKError$1(
+                "INIT_FAILED",
+                `Received init for wrong side: ${initData.side}. Expected "host".`,
+                { details: { side: initData.side } }
+              );
+              this.handleError(error);
+              reject(error);
+              return;
+            }
+            this.transport = new PostMessageTransport(parentOrigin);
+            this._roomCode = initData.roomCode;
+            this._controllers = this.mapControllersFromInit(initData.players);
+            this._leaderIndex = this.findLeaderIndex(initData.players, initData.leaderId);
+            this.setupEventHandlers();
+            this._isReady = true;
+            this.logger.lifecycle("Screen ready", {
+              roomCode: this._roomCode,
+              controllers: this._controllers.length,
+              leaderIndex: this._leaderIndex
+            });
+            this.config.onReady?.();
+            resolve();
+          } else if (msg.type === "smore:update") {
+            const updateData = msg.payload;
+            if (updateData.players) {
+              this._controllers = this.mapControllersFromInit(updateData.players);
+            }
+            if (updateData.leaderId !== void 0) {
+              this._leaderIndex = this.findLeaderIndex(
+                updateData.players ?? [],
+                updateData.leaderId
+              );
+            }
+            this.logger.lifecycle("Room updated", {
+              controllers: this._controllers.length,
+              leaderIndex: this._leaderIndex
+            });
           }
-        }
-      };
-      window.addEventListener("message", this.boundMessageHandler);
+        };
+        window.addEventListener("message", this.boundMessageHandler);
+        window.parent.postMessage({ type: "smore:ready" }, parentOrigin);
+        this.logger.lifecycle("Sent smore:ready to parent");
+      });
     }
-    mapPlayersFromInit(players) {
+    mapControllersFromInit(players) {
       return players.map((p, index) => ({
         playerIndex: p.playerIndex ?? index,
         nickname: p.nickname || `Player ${index + 1}`,
@@ -190,186 +316,239 @@
     }
     findLeaderIndex(players, leaderId) {
       if (!leaderId) return -1;
-      const idx = players.findIndex((p) => p.sessionId === leaderId);
+      const idx = players.findIndex(
+        (p) => p.sessionId === leaderId
+      );
       return idx >= 0 ? idx : -1;
     }
     setupEventHandlers() {
       if (!this.transport) return;
-      this.registerHandler(SYSTEM_EVENTS$1.PLAYER_JOIN, (data) => {
-        const playerIndex = data.player?.playerIndex;
-        if (playerIndex !== void 0) {
-          this.config.onPlayerJoin?.(playerIndex);
+      this.registerTransportHandler(SYSTEM_EVENTS$1.PLAYER_JOIN, (data) => {
+        const payload = data;
+        const player = payload?.player;
+        if (player && typeof player.playerIndex === "number") {
+          this.logger.lifecycle("Controller joined", { playerIndex: player.playerIndex });
+          this.config.onControllerJoin?.(player.playerIndex, player);
+        }
+      });
+      this.registerTransportHandler(SYSTEM_EVENTS$1.PLAYER_LEAVE, (data) => {
+        const payload = data;
+        if (typeof payload?.playerIndex === "number") {
+          this.logger.lifecycle("Controller left", { playerIndex: payload.playerIndex });
+          this.config.onControllerLeave?.(payload.playerIndex);
         }
       });
-      this.registerHandler(SYSTEM_EVENTS$1.PLAYER_LEAVE, (data) => {
-        if (data.playerIndex !== void 0) {
-          this.config.onPlayerLeave?.(data.playerIndex);
+      this.registerTransportHandler(SYSTEM_EVENTS$1.PLAYER_RECONNECT, (data) => {
+        const payload = data;
+        const player = payload?.player;
+        if (player && typeof player.playerIndex === "number") {
+          this.logger.lifecycle("Controller reconnected", { playerIndex: player.playerIndex });
+          this.config.onControllerReconnect?.(player.playerIndex, player);
         }
       });
-      this.registerHandler("room:player-joined", (data) => {
-        const playerIndex = data?.player?.playerIndex ?? data?.playerIndex;
-        if (playerIndex !== void 0) {
-          this.config.onPlayerJoin?.(playerIndex);
+      this.registerTransportHandler("room:player-joined", (data) => {
+        const payload = data;
+        const playerIndex = payload?.player?.playerIndex ?? payload?.playerIndex;
+        if (typeof playerIndex === "number") {
+          this.config.onControllerJoin?.(playerIndex, {
+            playerIndex,
+            nickname: `Player ${playerIndex + 1}`,
+            connected: true
+          });
         }
       });
-      this.registerHandler("room:player-left", (data) => {
-        const playerIndex = data?.playerIndex ?? data?.player?.playerIndex;
-        if (playerIndex !== void 0) {
-          this.config.onPlayerLeave?.(playerIndex);
+      this.registerTransportHandler("room:player-left", (data) => {
+        const payload = data;
+        const playerIndex = payload?.playerIndex ?? payload?.player?.playerIndex;
+        if (typeof playerIndex === "number") {
+          this.config.onControllerLeave?.(playerIndex);
         }
       });
       if (this.config.listeners) {
         for (const [event, handler] of Object.entries(this.config.listeners)) {
           if (!handler) continue;
-          this.registerHandler(event, (data) => {
-            const { playerIndex, ...rest } = data;
-            if (playerIndex !== void 0) {
-              handler(playerIndex, rest);
-            }
-          });
+          this.setupUserEventHandler(event, handler);
         }
       }
     }
-    registerHandler(event, handler) {
+    setupUserEventHandler(event, handler) {
+      const wrappedHandler = (data) => {
+        this.logger.receive(event, data);
+        const payload = data;
+        const { playerIndex, ...rest } = payload;
+        if (typeof playerIndex === "number") {
+          try {
+            handler(playerIndex, rest);
+          } catch (err) {
+            this.handleError(
+              new SmoreSDKError$1("UNKNOWN", `Error in handler for event "${event}"`, {
+                cause: err instanceof Error ? err : void 0,
+                details: { event, playerIndex }
+              })
+            );
+          }
+        }
+      };
+      this.registerTransportHandler(event, wrappedHandler);
+      let handlers = this.eventHandlers.get(event);
+      if (!handlers) {
+        handlers = /* @__PURE__ */ new Set();
+        this.eventHandlers.set(event, handlers);
+      }
+      handlers.add(handler);
+    }
+    registerTransportHandler(event, handler) {
       if (!this.transport) return;
       this.transport.on(event, handler);
-      this.registeredHandlers.push({ event, handler });
+      this.registeredTransportHandlers.push({ event, handler });
     }
     // ---------------------------------------------------------------------------
-    // Public Properties
+    // Properties (readonly)
     // ---------------------------------------------------------------------------
-    /**
-     * Get all players in the room.
-     * Returns a copy to prevent external mutation.
-     */
-    get players() {
-      return [...this._players];
-    }
-    /**
-     * Get the room code.
-     */
+    get controllers() {
+      return [...this._controllers];
+    }
     get roomCode() {
       return this._roomCode;
     }
-    /**
-     * Get the leader's player index (-1 if no leader).
-     */
     get leaderIndex() {
       return this._leaderIndex;
     }
-    /**
-     * Check if the host is initialized and ready.
-     */
     get isReady() {
       return this._isReady;
     }
+    get isDestroyed() {
+      return this._isDestroyed;
+    }
     // ---------------------------------------------------------------------------
-    // Public Methods
+    // Communication Methods
     // ---------------------------------------------------------------------------
-    /**
-     * Broadcast an event to all players.
-     *
-     * @param event - Event name (no colons allowed)
-     * @param data - Optional data payload
-     *
-     * @example
-     * ```ts
-     * host.broadcast('phase-update', { phase: 'playing' });
-     * host.broadcast('timer-tick', { remaining: 30 });
-     * ```
-     */
     broadcast(event, data) {
       this.ensureReady("broadcast");
       validateEventName$1(event);
+      this.logger.send(event, data);
+      this.transport.emit(event, data);
+    }
+    broadcastRaw(event, data) {
+      this.ensureReady("broadcastRaw");
+      validateEventName$1(event);
+      this.logger.send(event, data);
       this.transport.emit(event, data);
     }
-    /**
-     * Send an event to a specific player.
-     *
-     * @param playerIndex - Target player index (0, 1, 2, ...)
-     * @param event - Event name (no colons allowed)
-     * @param data - Optional data payload
-     *
-     * @example
-     * ```ts
-     * host.sendToPlayer(0, 'your-turn', { timeLimit: 30 });
-     * host.sendToPlayer(1, 'wait', { message: 'Not your turn' });
-     * ```
-     */
-    sendToPlayer(playerIndex, event, data) {
-      this.ensureReady("sendToPlayer");
+    sendToController(playerIndex, event, data) {
+      this.ensureReady("sendToController");
       validateEventName$1(event);
+      validatePlayerIndex(playerIndex, this._controllers.length);
+      this.logger.send(`${event} -> Player ${playerIndex}`, data);
       this.transport.emit(event, {
         targetPlayerIndex: playerIndex,
         ...data && typeof data === "object" ? data : { data }
       });
     }
-    /**
-     * Signal game over with results.
-     * This will broadcast the game over event to all players.
-     *
-     * @param results - Game results (scores, winner, etc.)
-     *
-     * @example
-     * ```ts
-     * host.gameOver({
-     *   scores: { 0: 100, 1: 75, 2: 50 },
-     *   winner: 0,
-     * });
-     * ```
-     */
+    sendToControllerRaw(playerIndex, event, data) {
+      this.ensureReady("sendToControllerRaw");
+      validateEventName$1(event);
+      validatePlayerIndex(playerIndex, this._controllers.length);
+      this.logger.send(`${event} -> Player ${playerIndex}`, data);
+      this.transport.emit(event, {
+        targetPlayerIndex: playerIndex,
+        ...data && typeof data === "object" ? data : { data }
+      });
+    }
+    // ---------------------------------------------------------------------------
+    // Game Lifecycle
+    // ---------------------------------------------------------------------------
     gameOver(results) {
       this.ensureReady("gameOver");
+      this.logger.lifecycle("Game over", results);
       this.transport.emit(SYSTEM_EVENTS$1.GAME_OVER, { results });
     }
-    /**
-     * Add a listener for a specific event after construction.
-     *
-     * @param event - Event name (no colons allowed)
-     * @param handler - Handler function (playerIndex, data) => void
-     * @returns Cleanup function to remove the listener
-     *
-     * @example
-     * ```ts
-     * const cleanup = host.on('tap', (playerIndex, data) => {
-     *   console.log(`Player ${playerIndex} tapped`);
-     * });
-     *
-     * // Later
-     * cleanup();
-     * ```
-     */
+    // ---------------------------------------------------------------------------
+    // Event Subscription
+    // ---------------------------------------------------------------------------
     on(event, handler) {
       validateEventName$1(event);
-      const wrappedHandler = (data) => {
-        const { playerIndex, ...rest } = data;
-        if (playerIndex !== void 0) {
-          handler(playerIndex, rest);
-        }
-      };
+      let handlers = this.eventHandlers.get(event);
+      if (!handlers) {
+        handlers = /* @__PURE__ */ new Set();
+        this.eventHandlers.set(event, handlers);
+      }
+      handlers.add(handler);
       if (this.transport) {
-        this.transport.on(event, wrappedHandler);
-        this.registeredHandlers.push({ event, handler: wrappedHandler });
+        const wrappedHandler = (data) => {
+          this.logger.receive(event, data);
+          const payload = data;
+          const { playerIndex, ...rest } = payload;
+          if (typeof playerIndex === "number") {
+            try {
+              handler(playerIndex, rest);
+            } catch (err) {
+              this.handleError(
+                new SmoreSDKError$1("UNKNOWN", `Error in handler for event "${event}"`, {
+                  cause: err instanceof Error ? err : void 0
+                })
+              );
+            }
+          }
+        };
+        this.registerTransportHandler(event, wrappedHandler);
       }
       return () => {
-        this.transport?.off(event, wrappedHandler);
-        this.registeredHandlers = this.registeredHandlers.filter(
-          (h) => h.event !== event || h.handler !== wrappedHandler
-        );
+        handlers?.delete(handler);
+        if (handlers?.size === 0) {
+          this.eventHandlers.delete(event);
+        }
       };
     }
-    /**
-     * Clean up all resources.
-     * Call this when unmounting/destroying the game.
-     */
+    once(event, handler) {
+      const wrappedHandler = (playerIndex, data) => {
+        unsubscribe();
+        handler(playerIndex, data);
+      };
+      const unsubscribe = this.on(event, wrappedHandler);
+      return unsubscribe;
+    }
+    off(event, handler) {
+      if (!handler) {
+        this.eventHandlers.delete(event);
+        this.transport?.off(event);
+      } else {
+        const handlers = this.eventHandlers.get(event);
+        handlers?.delete(handler);
+        if (handlers?.size === 0) {
+          this.eventHandlers.delete(event);
+        }
+      }
+    }
+    // ---------------------------------------------------------------------------
+    // Utilities
+    // ---------------------------------------------------------------------------
+    getController(playerIndex) {
+      return this._controllers.find((c) => c.playerIndex === playerIndex);
+    }
+    isLeader(playerIndex) {
+      return playerIndex === this._leaderIndex;
+    }
+    getControllerCount() {
+      return this._controllers.filter((c) => c.connected).length;
+    }
+    // ---------------------------------------------------------------------------
+    // Cleanup
+    // ---------------------------------------------------------------------------
     destroy() {
       if (this._isDestroyed) return;
+      this.logger.lifecycle("Destroying screen...");
       this._isDestroyed = true;
       this._isReady = false;
-      for (const { event, handler } of this.registeredHandlers) {
+      this.cleanup();
+      this.logger.lifecycle("Screen destroyed");
+    }
+    cleanup() {
+      for (const { event, handler } of this.registeredTransportHandlers) {
         this.transport?.off(event, handler);
       }
-      this.registeredHandlers = [];
+      this.registeredTransportHandlers = [];
+      this.eventHandlers.clear();
       if (this.transport instanceof PostMessageTransport) {
         this.transport.destroy();
       }
@@ -380,36 +559,126 @@
       }
     }
     // ---------------------------------------------------------------------------
-    // Private Helpers
+    // Error Handling
     // ---------------------------------------------------------------------------
-    ensureReady(method) {
-      if (!this._isReady || !this.transport) {
-        throw new Error(`[SmoreHost] Cannot call ${method}() before host is ready. Wait for onReady callback.`);
+    handleError(error) {
+      const smoreError = error.toSmoreError();
+      if (this.config.onError) {
+        this.config.onError(smoreError);
+      } else {
+        this.logger.error(error.message, error.details);
       }
+    }
+    ensureReady(method) {
       if (this._isDestroyed) {
-        throw new Error(`[SmoreHost] Cannot call ${method}() after destroy()`);
+        throw new SmoreSDKError$1(
+          "DESTROYED",
+          `Cannot call ${method}() after destroy()`,
+          { details: { method } }
+        );
+      }
+      if (!this._isReady || !this.transport) {
+        throw new SmoreSDKError$1(
+          "NOT_READY",
+          `Cannot call ${method}() before screen is ready. Use await createScreen() or onReady callback.`,
+          { details: { method } }
+        );
       }
     }
   }
+  function createScreen(config) {
+    const screen = new ScreenImpl(config);
+    const promise = screen.initialize().then(() => screen);
+    promise.instance = screen;
+    return promise;
+  }
 
   const SYSTEM_PREFIX = "smore:";
   const SYSTEM_EVENTS = {
     PLAYER_JOIN: `${SYSTEM_PREFIX}player-join`,
     PLAYER_LEAVE: `${SYSTEM_PREFIX}player-leave`
   };
-  const EVENT_NAME_REGEX = /^[a-zA-Z]([a-zA-Z_-]*[a-zA-Z])?$/;
+  const DEFAULT_TIMEOUT = 1e4;
+  class SmoreSDKError extends Error {
+    code;
+    cause;
+    details;
+    constructor(code, message, options) {
+      super(message);
+      this.name = "SmoreSDKError";
+      this.code = code;
+      this.cause = options?.cause;
+      this.details = options?.details;
+      const ErrorWithCapture = Error;
+      if (typeof ErrorWithCapture.captureStackTrace === "function") {
+        ErrorWithCapture.captureStackTrace(this, SmoreSDKError);
+      }
+    }
+    toSmoreError() {
+      return {
+        code: this.code,
+        message: this.message,
+        cause: this.cause,
+        details: this.details
+      };
+    }
+  }
+  const EVENT_NAME_REGEX = /^[a-zA-Z]([a-zA-Z0-9_-]*[a-zA-Z0-9])?$/;
   function validateEventName(event) {
+    if (!event || typeof event !== "string") {
+      throw new SmoreSDKError("INVALID_EVENT", "Event name must be a non-empty string");
+    }
     if (!EVENT_NAME_REGEX.test(event)) {
-      throw new Error(
-        `[SmorePlayer] Invalid event name "${event}". Event names must:
-  - Only contain letters (a-z, A-Z), hyphens (-), and underscores (_)
-  - Start and end with a letter (no leading/trailing - or _)`
+      throw new SmoreSDKError(
+        "INVALID_EVENT",
+        `Invalid event name "${event}". Event names must:
+  - Start with a letter (a-z, A-Z)
+  - Only contain letters, numbers, hyphens (-), and underscores (_)
+  - End with a letter or number`,
+        { details: { event } }
       );
     }
   }
-  class SmorePlayer {
+  function createLogger(options) {
+    const enabled = typeof options === "boolean" ? options : options?.enabled ?? false;
+    const level = (typeof options === "object" ? options.level : void 0) ?? "debug";
+    const prefix = (typeof options === "object" ? options.prefix : void 0) ?? "[SmoreController]";
+    const customLogger = typeof options === "object" ? options.logger : void 0;
+    const levelPriority = {
+      debug: 0,
+      info: 1,
+      warn: 2,
+      error: 3
+    };
+    const shouldLog = (msgLevel) => {
+      if (!enabled) return false;
+      return levelPriority[msgLevel] >= levelPriority[level];
+    };
+    const log = (msgLevel, message, data) => {
+      if (!shouldLog(msgLevel)) return;
+      if (customLogger) {
+        customLogger(msgLevel, message, data);
+        return;
+      }
+      const fullMessage = `${prefix} ${message}`;
+      const consoleFn = console[msgLevel] ?? console.log;
+      if (data !== void 0) {
+        consoleFn(fullMessage, data);
+      } else {
+        consoleFn(fullMessage);
+      }
+    };
+    return {
+      debug: (msg, data) => log("debug", msg, data),
+      info: (msg, data) => log("info", msg, data),
+      warn: (msg, data) => log("warn", msg, data),
+      error: (msg, data) => log("error", msg, data)
+    };
+  }
+  class ControllerImpl {
     transport = null;
     config;
+    logger;
     _roomCode = "";
     _myIndex = -1;
     _isLeader = false;
@@ -417,83 +686,138 @@
     _isDestroyed = false;
     boundMessageHandler = null;
     registeredHandlers = [];
+    eventListeners = /* @__PURE__ */ new Map();
     constructor(config = {}) {
       this.config = config;
+      this.logger = createLogger(config.debug);
       if (config.listeners) {
         for (const event of Object.keys(config.listeners)) {
           validateEventName(event);
         }
       }
-      if (config.socket) {
-        this.initBundled(config);
-      } else {
-        this.initIframe(config);
-      }
+    }
+    // ---------------------------------------------------------------------------
+    // Properties (readonly)
+    // ---------------------------------------------------------------------------
+    get myIndex() {
+      return this._myIndex;
+    }
+    get isLeader() {
+      return this._isLeader;
+    }
+    get roomCode() {
+      return this._roomCode;
+    }
+    get isReady() {
+      return this._isReady;
+    }
+    get isDestroyed() {
+      return this._isDestroyed;
     }
     // ---------------------------------------------------------------------------
     // Initialization
     // ---------------------------------------------------------------------------
-    initBundled(config) {
-      if (!config.socket) {
-        throw new Error("[SmorePlayer] socket is required for bundled games");
-      }
-      this.transport = new DirectTransport(config.socket);
-      this._roomCode = config.roomCode || "";
-      this._myIndex = config.myIndex ?? -1;
-      this._isLeader = config.isLeader ?? false;
+    async initialize() {
+      const parentOrigin = this.config.parentOrigin ?? "*";
+      const timeout = this.config.timeout ?? DEFAULT_TIMEOUT;
+      this.logger.debug("Initializing controller...", { parentOrigin, timeout });
+      return new Promise((resolve, reject) => {
+        const timeoutId = setTimeout(() => {
+          this.cleanup();
+          const error = new SmoreSDKError(
+            "TIMEOUT",
+            `Controller initialization timed out after ${timeout}ms. Make sure the parent window sends smore:init message.`,
+            { details: { timeout } }
+          );
+          this.handleError(error);
+          reject(error);
+        }, timeout);
+        this.boundMessageHandler = (e) => {
+          if (parentOrigin !== "*" && e.origin !== parentOrigin) return;
+          const msg = e.data;
+          if (!isSmoreMessage(msg)) return;
+          if (msg.type === "smore:init") {
+            clearTimeout(timeoutId);
+            this.handleInit(msg, parentOrigin, resolve, reject);
+          } else if (msg.type === "smore:update") {
+            this.handleUpdate(msg);
+          }
+        };
+        window.addEventListener("message", this.boundMessageHandler);
+        this.logger.debug("Sending smore:ready to parent");
+        window.parent.postMessage({ type: "smore:ready" }, parentOrigin);
+      });
+    }
+    handleInit(msg, parentOrigin, resolve, reject) {
+      const initData = msg.payload;
+      this.logger.debug("Received smore:init", initData);
+      if (initData.side !== "player") {
+        const error = new SmoreSDKError(
+          "INIT_FAILED",
+          `Controller received init for wrong side: ${initData.side}`,
+          { details: { side: initData.side } }
+        );
+        this.handleError(error);
+        reject(error);
+        return;
+      }
+      if (initData.myIndex === void 0) {
+        const error = new SmoreSDKError(
+          "INIT_FAILED",
+          "Missing myIndex in init payload",
+          { details: initData }
+        );
+        this.handleError(error);
+        reject(error);
+        return;
+      }
+      this.transport = new PostMessageTransport(parentOrigin);
+      this._roomCode = initData.roomCode;
+      this._myIndex = initData.myIndex;
+      this._isLeader = initData.isLeader ?? false;
       this.setupEventHandlers();
       this._isReady = true;
+      this.logger.info("Controller ready", {
+        roomCode: this._roomCode,
+        myIndex: this._myIndex,
+        isLeader: this._isLeader
+      });
       this.config.onReady?.();
+      resolve();
     }
-    initIframe(config) {
-      const parentOrigin = config.parentOrigin || "*";
-      window.parent.postMessage({ type: "smore:ready" }, parentOrigin);
-      this.boundMessageHandler = (e) => {
-        if (parentOrigin !== "*" && e.origin !== parentOrigin) return;
-        const msg = e.data;
-        if (!isSmoreMessage(msg)) return;
-        if (msg.type === "smore:init") {
-          const initData = msg.payload;
-          if (initData.side !== "player") {
-            console.error("[SmorePlayer] Received init for wrong side:", initData.side);
-            return;
-          }
-          if (initData.myIndex === void 0) {
-            console.error("[SmorePlayer] Missing myIndex in init payload");
-            return;
-          }
-          this.transport = new PostMessageTransport(parentOrigin);
-          this._roomCode = initData.roomCode;
-          this._myIndex = initData.myIndex;
-          this._isLeader = initData.isLeader ?? false;
-          this.setupEventHandlers();
-          this._isReady = true;
-          this.config.onReady?.();
-        } else if (msg.type === "smore:update") {
-          const updateData = msg.payload;
-          if (updateData.leaderId !== void 0) ;
-        }
-      };
-      window.addEventListener("message", this.boundMessageHandler);
+    handleUpdate(msg) {
+      const updateData = msg.payload;
+      this.logger.debug("Received smore:update", updateData);
     }
     setupEventHandlers() {
       if (!this.transport) return;
-      this.registerHandler(SYSTEM_EVENTS.PLAYER_JOIN, (data) => {
-        const playerIndex = data.player?.playerIndex ?? data.playerIndex;
-        if (playerIndex !== void 0) {
-          this.config.onPlayerJoin?.(playerIndex);
+      this.registerHandler(
+        SYSTEM_EVENTS.PLAYER_JOIN,
+        (data) => {
+          const playerIndex = data.player?.playerIndex ?? data.playerIndex;
+          if (playerIndex !== void 0) {
+            this.logger.debug("Player joined", { playerIndex });
+            this.config.onControllerJoin?.(playerIndex, data.player);
+          }
         }
-      });
-      this.registerHandler(SYSTEM_EVENTS.PLAYER_LEAVE, (data) => {
-        const playerIndex = data.player?.playerIndex ?? data.playerIndex;
-        if (playerIndex !== void 0) {
-          this.config.onPlayerLeave?.(playerIndex);
+      );
+      this.registerHandler(
+        SYSTEM_EVENTS.PLAYER_LEAVE,
+        (data) => {
+          const playerIndex = data.player?.playerIndex ?? data.playerIndex;
+          if (playerIndex !== void 0) {
+            this.logger.debug("Player left", { playerIndex });
+            this.config.onControllerLeave?.(playerIndex);
+          }
         }
-      });
+      );
       if (this.config.listeners) {
         for (const [event, handler] of Object.entries(this.config.listeners)) {
           if (!handler) continue;
-          this.registerHandler(event, handler);
+          this.registerHandler(event, (data) => {
+            this.logReceive(event, data);
+            handler(data);
+          });
         }
       }
     }
@@ -503,98 +827,90 @@
       this.registeredHandlers.push({ event, handler });
     }
     // ---------------------------------------------------------------------------
-    // Public Properties
+    // Communication Methods
     // ---------------------------------------------------------------------------
-    /**
-     * Get my player index (0, 1, 2, ...).
-     */
-    get myIndex() {
-      return this._myIndex;
-    }
-    /**
-     * Check if I am the room leader.
-     */
-    get isLeader() {
-      return this._isLeader;
-    }
-    /**
-     * Get the room code.
-     */
-    get roomCode() {
-      return this._roomCode;
-    }
-    /**
-     * Check if the player is initialized and ready.
-     */
-    get isReady() {
-      return this._isReady;
-    }
-    // ---------------------------------------------------------------------------
-    // Public Methods
-    // ---------------------------------------------------------------------------
-    /**
-     * Send an event to the host.
-     *
-     * @param event - Event name (no colons allowed)
-     * @param data - Optional data payload
-     *
-     * @example
-     * ```ts
-     * player.send('tap', { timestamp: Date.now() });
-     * player.send('answer', { choice: 2 });
-     * ```
-     */
     send(event, data) {
       this.ensureReady("send");
       validateEventName(event);
+      this.logSend(event, data);
       this.transport.emit(event, data);
     }
-    /**
-     * Add a listener for a specific event after construction.
-     *
-     * @param event - Event name (no colons allowed)
-     * @param handler - Handler function (data) => void
-     * @returns Cleanup function to remove the listener
-     *
-     * @example
-     * ```ts
-     * const cleanup = player.on('phase-update', (data) => {
-     *   console.log('New phase:', data.phase);
-     * });
-     *
-     * // Later
-     * cleanup();
-     * ```
-     */
+    sendRaw(event, data) {
+      this.ensureReady("sendRaw");
+      validateEventName(event);
+      this.logSend(event, data);
+      this.transport.emit(event, data);
+    }
+    // ---------------------------------------------------------------------------
+    // Event Subscription
+    // ---------------------------------------------------------------------------
     on(event, handler) {
       validateEventName(event);
+      let listeners = this.eventListeners.get(event);
+      if (!listeners) {
+        listeners = /* @__PURE__ */ new Set();
+        this.eventListeners.set(event, listeners);
+      }
+      listeners.add(handler);
+      const transportHandler = (data) => {
+        this.logReceive(event, data);
+        handler(data);
+      };
       if (this.transport) {
-        this.transport.on(event, handler);
-        this.registeredHandlers.push({ event, handler });
+        this.transport.on(event, transportHandler);
+        this.registeredHandlers.push({ event, handler: transportHandler });
       }
       return () => {
-        this.transport?.off(event, handler);
+        listeners?.delete(handler);
+        if (listeners?.size === 0) {
+          this.eventListeners.delete(event);
+        }
+        this.transport?.off(event, transportHandler);
         this.registeredHandlers = this.registeredHandlers.filter(
-          (h) => h.event !== event || h.handler !== handler
+          (h) => h.handler !== transportHandler
         );
       };
     }
-    /**
-     * Clean up all resources.
-     * Call this when unmounting/destroying the game.
-     */
+    once(event, handler) {
+      const unsubscribe = this.on(event, ((data) => {
+        unsubscribe();
+        handler(data);
+      }));
+      return unsubscribe;
+    }
+    off(event, handler) {
+      if (!handler) {
+        this.eventListeners.delete(event);
+        this.transport?.off(event);
+        this.registeredHandlers = this.registeredHandlers.filter((h) => h.event !== event);
+      } else {
+        const listeners = this.eventListeners.get(event);
+        listeners?.delete(handler);
+        if (listeners?.size === 0) {
+          this.eventListeners.delete(event);
+        }
+      }
+    }
+    // ---------------------------------------------------------------------------
+    // Cleanup
+    // ---------------------------------------------------------------------------
     destroy() {
       if (this._isDestroyed) return;
+      this.logger.info("Destroying controller");
+      this.cleanup();
       this._isDestroyed = true;
+    }
+    cleanup() {
       this._isReady = false;
       for (const { event, handler } of this.registeredHandlers) {
         this.transport?.off(event, handler);
       }
       this.registeredHandlers = [];
-      if (this.transport instanceof PostMessageTransport) {
+      this.eventListeners.clear();
+      if (this.transport) {
         this.transport.destroy();
+        this.transport = null;
       }
-      this.transport = null;
       if (this.boundMessageHandler) {
         window.removeEventListener("message", this.boundMessageHandler);
         this.boundMessageHandler = null;
@@ -604,11 +920,65 @@
     // Private Helpers
     // ---------------------------------------------------------------------------
     ensureReady(method) {
+      if (this._isDestroyed) {
+        throw new SmoreSDKError(
+          "DESTROYED",
+          `Cannot call ${method}() after destroy()`,
+          { details: { method } }
+        );
+      }
       if (!this._isReady || !this.transport) {
-        throw new Error(`[SmorePlayer] Cannot call ${method}() before player is ready. Wait for onReady callback.`);
+        throw new SmoreSDKError(
+          "NOT_READY",
+          `Cannot call ${method}() before controller is ready. Use await createController() or wait for onReady callback.`,
+          { details: { method, isReady: this._isReady } }
+        );
       }
-      if (this._isDestroyed) {
-        throw new Error(`[SmorePlayer] Cannot call ${method}() after destroy()`);
+    }
+    handleError(error) {
+      if (this.config.onError) {
+        this.config.onError(error.toSmoreError());
+      } else {
+        this.logger.error(error.message, error.details);
+      }
+    }
+    logSend(event, data) {
+      const options = this.config.debug;
+      const shouldLog = typeof options === "object" ? options.logSend ?? true : Boolean(options);
+      if (shouldLog) {
+        this.logger.debug(`\u2192 SEND [${event}]`, data);
+      }
+    }
+    logReceive(event, data) {
+      const options = this.config.debug;
+      const shouldLog = typeof options === "object" ? options.logReceive ?? true : Boolean(options);
+      if (shouldLog) {
+        this.logger.debug(`\u2190 RECV [${event}]`, data);
+      }
+    }
+  }
+  function createController(config) {
+    const controller = new ControllerImpl(config ?? {});
+    const promise = controller.initialize().then(() => controller);
+    promise.instance = controller;
+    return promise;
+  }
+
+  class DirectTransport {
+    constructor(socket) {
+      this.socket = socket;
+    }
+    emit(event, ...args) {
+      this.socket.emit(event, ...args);
+    }
+    on(event, handler) {
+      this.socket.on(event, handler);
+    }
+    off(event, handler) {
+      if (handler) {
+        this.socket.off(event, handler);
+      } else {
+        this.socket.off(event);
       }
     }
   }
@@ -638,11 +1008,266 @@
     return event.startsWith("smore:");
   }
 
+  function createMockScreen(options = {}) {
+    const {
+      roomCode = "TEST",
+      controllers: initialControllers = [],
+      autoReady = true
+    } = options;
+    let _controllers = [...initialControllers];
+    let _isReady = false;
+    let _isDestroyed = false;
+    let _leaderIndex = initialControllers[0]?.playerIndex ?? -1;
+    const listeners = /* @__PURE__ */ new Map();
+    const broadcasts = [];
+    const sends = [];
+    const screen = {
+      // === Properties ===
+      get controllers() {
+        return [..._controllers];
+      },
+      get roomCode() {
+        return roomCode;
+      },
+      get leaderIndex() {
+        return _leaderIndex;
+      },
+      get isReady() {
+        return _isReady;
+      },
+      get isDestroyed() {
+        return _isDestroyed;
+      },
+      // === Communication Methods ===
+      broadcast(event, data) {
+        if (_isDestroyed) {
+          throw new Error("Cannot broadcast: screen is destroyed");
+        }
+        broadcasts.push({ event, data });
+      },
+      broadcastRaw(event, data) {
+        if (_isDestroyed) {
+          throw new Error("Cannot broadcast: screen is destroyed");
+        }
+        broadcasts.push({ event, data });
+      },
+      sendToController(playerIndex, event, data) {
+        if (_isDestroyed) {
+          throw new Error("Cannot send: screen is destroyed");
+        }
+        if (!_controllers.some((c) => c.playerIndex === playerIndex)) {
+          throw new Error(`Invalid player index: ${playerIndex}`);
+        }
+        sends.push({ playerIndex, event, data });
+      },
+      sendToControllerRaw(playerIndex, event, data) {
+        if (_isDestroyed) {
+          throw new Error("Cannot send: screen is destroyed");
+        }
+        if (!_controllers.some((c) => c.playerIndex === playerIndex)) {
+          throw new Error(`Invalid player index: ${playerIndex}`);
+        }
+        sends.push({ playerIndex, event, data });
+      },
+      // === Game Lifecycle ===
+      gameOver(results) {
+        screen.broadcastRaw("game-over", results);
+      },
+      // === Event Subscription ===
+      on(event, handler) {
+        const eventStr = event;
+        if (!listeners.has(eventStr)) {
+          listeners.set(eventStr, /* @__PURE__ */ new Set());
+        }
+        listeners.get(eventStr).add(handler);
+        return () => {
+          listeners.get(eventStr)?.delete(handler);
+        };
+      },
+      once(event, handler) {
+        const wrapper = (playerIndex, data) => {
+          handler(playerIndex, data);
+          screen.off(event, wrapper);
+        };
+        return screen.on(event, wrapper);
+      },
+      off(event, handler) {
+        const eventStr = event;
+        if (!handler) {
+          listeners.delete(eventStr);
+        } else {
+          listeners.get(eventStr)?.delete(handler);
+        }
+      },
+      // === Utilities ===
+      getController(playerIndex) {
+        return _controllers.find((c) => c.playerIndex === playerIndex);
+      },
+      isLeader(playerIndex) {
+        return playerIndex === _leaderIndex;
+      },
+      getControllerCount() {
+        return _controllers.length;
+      },
+      // === Cleanup ===
+      destroy() {
+        _isDestroyed = true;
+        listeners.clear();
+        broadcasts.length = 0;
+        sends.length = 0;
+      },
+      // === Mock-specific methods ===
+      simulateEvent(playerIndex, event, data) {
+        const eventStr = event;
+        const handlers = listeners.get(eventStr);
+        if (handlers) {
+          handlers.forEach((handler) => {
+            handler(playerIndex, data);
+          });
+        }
+      },
+      simulateControllerJoin(info) {
+        _controllers.push(info);
+        if (_leaderIndex === -1) {
+          _leaderIndex = info.playerIndex;
+        }
+      },
+      simulateControllerLeave(playerIndex) {
+        _controllers = _controllers.filter((c) => c.playerIndex !== playerIndex);
+        if (_leaderIndex === playerIndex) {
+          _leaderIndex = _controllers[0]?.playerIndex ?? -1;
+        }
+      },
+      getBroadcasts() {
+        return [...broadcasts];
+      },
+      getSentToController(playerIndex) {
+        return sends.filter((s) => s.playerIndex === playerIndex).map((s) => ({ event: s.event, data: s.data }));
+      },
+      clearRecordedEvents() {
+        broadcasts.length = 0;
+        sends.length = 0;
+      },
+      triggerReady() {
+        _isReady = true;
+      }
+    };
+    if (autoReady) {
+      setTimeout(() => screen.triggerReady(), 0);
+    }
+    return screen;
+  }
+  function createMockController(options = {}) {
+    const {
+      roomCode = "TEST",
+      myIndex = 0,
+      isLeader: initialIsLeader = false,
+      autoReady = true
+    } = options;
+    let _isReady = false;
+    let _isDestroyed = false;
+    let _isLeader = initialIsLeader;
+    const listeners = /* @__PURE__ */ new Map();
+    const sentEvents = [];
+    const controller = {
+      // === Properties ===
+      get myIndex() {
+        return myIndex;
+      },
+      get isLeader() {
+        return _isLeader;
+      },
+      get roomCode() {
+        return roomCode;
+      },
+      get isReady() {
+        return _isReady;
+      },
+      get isDestroyed() {
+        return _isDestroyed;
+      },
+      // === Communication Methods ===
+      send(event, data) {
+        if (_isDestroyed) {
+          throw new Error("Cannot send: controller is destroyed");
+        }
+        sentEvents.push({ event, data });
+      },
+      sendRaw(event, data) {
+        if (_isDestroyed) {
+          throw new Error("Cannot send: controller is destroyed");
+        }
+        sentEvents.push({ event, data });
+      },
+      // === Event Subscription ===
+      on(event, handler) {
+        const eventStr = event;
+        if (!listeners.has(eventStr)) {
+          listeners.set(eventStr, /* @__PURE__ */ new Set());
+        }
+        listeners.get(eventStr).add(handler);
+        return () => {
+          listeners.get(eventStr)?.delete(handler);
+        };
+      },
+      once(event, handler) {
+        const wrapper = (data) => {
+          handler(data);
+          controller.off(event, wrapper);
+        };
+        return controller.on(event, wrapper);
+      },
+      off(event, handler) {
+        const eventStr = event;
+        if (!handler) {
+          listeners.delete(eventStr);
+        } else {
+          listeners.get(eventStr)?.delete(handler);
+        }
+      },
+      // === Cleanup ===
+      destroy() {
+        _isDestroyed = true;
+        listeners.clear();
+        sentEvents.length = 0;
+      },
+      // === Mock-specific methods ===
+      simulateEvent(event, data) {
+        const eventStr = event;
+        const handlers = listeners.get(eventStr);
+        if (handlers) {
+          handlers.forEach((handler) => {
+            handler(data);
+          });
+        }
+      },
+      getSentEvents() {
+        return [...sentEvents];
+      },
+      clearRecordedEvents() {
+        sentEvents.length = 0;
+      },
+      triggerReady() {
+        _isReady = true;
+      },
+      setLeader(isLeader) {
+        _isLeader = isLeader;
+      }
+    };
+    if (autoReady) {
+      setTimeout(() => controller.triggerReady(), 0);
+    }
+    return controller;
+  }
+
   exports.DirectTransport = DirectTransport;
   exports.PostMessageTransport = PostMessageTransport;
   exports.SMORE_EVENTS = SMORE_EVENTS;
-  exports.SmoreHost = SmoreHost;
-  exports.SmorePlayer = SmorePlayer;
+  exports.SmoreSDKError = SmoreSDKError$1;
+  exports.createController = createController;
+  exports.createMockController = createMockController;
+  exports.createMockScreen = createMockScreen;
+  exports.createScreen = createScreen;
   exports.isSystemEvent = isSystemEvent;
   exports.validateUserEvent = validateUserEvent;