@smoregg/sdk 0.6.1 → 1.0.0

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

@@ -4,9 +4,28 @@
   (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.SmoreSDK = {}));
 })(this, (function (exports) { 'use strict';
 
-  const SMORE_MSG_PREFIX = "smore:";
-  function isSmoreMessage(data) {
-    return data && typeof data === "object" && typeof data.type === "string" && data.type.startsWith(SMORE_MSG_PREFIX);
+  const BRIDGE_MSG_PREFIX = "_bridge:";
+  function isBridgeMessage(data) {
+    return data !== null && typeof data === "object" && "type" in data && typeof data.type === "string" && data.type.startsWith(BRIDGE_MSG_PREFIX);
+  }
+  function validateInitPayload(payload) {
+    if (!payload || typeof payload !== "object") {
+      throw new Error("[SDK] _bridge:init payload must be an object");
+    }
+    const p = payload;
+    if (typeof p.side !== "string" || !["host", "player"].includes(p.side)) {
+      throw new Error(`[SDK] _bridge:init payload.side must be "host" or "player", got: ${p.side}`);
+    }
+    if (typeof p.roomCode !== "string" || p.roomCode.length === 0) {
+      throw new Error("[SDK] _bridge:init payload.roomCode must be a non-empty string");
+    }
+    if (!Array.isArray(p.players)) {
+      throw new Error("[SDK] _bridge:init payload.players must be an array");
+    }
+    if (p.myIndex !== void 0 && typeof p.myIndex !== "number") {
+      throw new Error("[SDK] _bridge:init payload.myIndex must be a number if provided");
+    }
+    return true;
   }
 
   class PostMessageTransport {
@@ -23,14 +42,19 @@
     emit(event, ...args) {
       let data = args[0];
       let ackId;
-      if (args.length >= 2 && typeof args[args.length - 1] === "function") {
-        data = args.length === 2 ? args[0] : args[0];
+      if (args.length === 1 && typeof args[0] === "function") {
+        data = void 0;
+        const callback = args[0];
+        ackId = `ack_${++this.ackCounter}`;
+        this.ackCallbacks.set(ackId, callback);
+      } else if (args.length >= 2 && typeof args[args.length - 1] === "function") {
+        data = args[0];
         const callback = args[args.length - 1];
         ackId = `ack_${++this.ackCounter}`;
         this.ackCallbacks.set(ackId, callback);
       }
       window.parent.postMessage(
-        { type: "smore:emit", payload: { event, data, ackId } },
+        { type: "_bridge:emit", payload: { event, data, ackId } },
         this.parentOrigin
       );
     }
@@ -57,14 +81,14 @@
     handleMessage(e) {
       if (this.parentOrigin !== "*" && e.origin !== this.parentOrigin) return;
       const msg = e.data;
-      if (!isSmoreMessage(msg)) return;
-      if (msg.type === "smore:event") {
+      if (!isBridgeMessage(msg)) return;
+      if (msg.type === "_bridge:event") {
         const { event, data } = msg.payload;
         const set = this.handlers.get(event);
         if (set) {
           set.forEach((handler) => handler(data));
         }
-      } else if (msg.type === "smore:ack") {
+      } else if (msg.type === "_bridge:ack") {
         const { ackId, data } = msg.payload;
         const cb = this.ackCallbacks.get(ackId);
         if (cb) {
@@ -75,23 +99,22 @@
     }
   }
 
-  const SYSTEM_PREFIX$1 = "smore:";
-  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 DEFAULT_TIMEOUT$1 = 1e4;
-  let SmoreSDKError$1 = class SmoreSDKError extends Error {
+  class SmoreSDKError extends Error {
     code;
+    /**
+     * The original error that caused this error.
+     *
+     * **Note:** This field intentionally shadows the native `Error.cause` (ES2022).
+     * Both this class field and the native property (set via `super()` options bag)
+     * are assigned the same value, so there is no behavioral difference.
+     * The explicit field provides TypeScript type narrowing to `Error` instead of `unknown`.
+     */
     cause;
     details;
     constructor(code, message, options) {
-      super(message);
+      super(message, options?.cause ? { cause: options.cause } : void 0);
       this.name = "SmoreSDKError";
       this.code = code;
-      this.cause = options?.cause;
       this.details = options?.details;
       const ErrorWithCapture = Error;
       if (typeof ErrorWithCapture.captureStackTrace === "function") {
@@ -106,32 +129,51 @@
         details: this.details
       };
     }
+  }
+
+  const SMORE_EVENTS = {
+    // Game lifecycle
+    GAME_OVER: "smore:game-over",
+    RETURN_TO_LOBBY: "smore:return-to-lobby",
+    // Used internally by platform, not handled by SDK
+    // Player management
+    PLAYER_JOINED: "smore:player-joined",
+    PLAYER_LEFT: "smore:player-left",
+    PLAYER_DISCONNECTED: "smore:player-disconnected",
+    PLAYER_RECONNECTED: "smore:player-reconnected",
+    // Character change
+    PLAYER_CHARACTER_UPDATED: "smore:player-character-updated",
+    // Rate limiting
+    RATE_LIMITED: "smore:rate-limited",
+    // Send to specific player (internal use)
+    SEND_TO_PLAYER: "smore:send-to-player"
+    // Used internally by platform, not handled by SDK
   };
-  const EVENT_NAME_REGEX$1 = /^[a-zA-Z]([a-zA-Z0-9_-]*[a-zA-Z0-9])?$/;
-  function validateEventName$1(event) {
+  new Set(
+    Object.values(SMORE_EVENTS)
+  );
+  const EVENT_NAME_REGEX = /^[a-zA-Z]([a-zA-Z0-9_-]*[a-zA-Z0-9])?$/;
+  const EVENT_NAME_MAX_LENGTH = 128;
+  function validateEventName(event) {
     if (!event || typeof event !== "string") {
-      throw new SmoreSDKError$1("INVALID_EVENT", "Event name must be a non-empty string");
+      throw new SmoreSDKError("INVALID_EVENT", "Event name must be a non-empty string");
     }
-    if (!EVENT_NAME_REGEX$1.test(event)) {
-      throw new SmoreSDKError$1(
+    if (event.length > EVENT_NAME_MAX_LENGTH) {
+      throw new SmoreSDKError(
         "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 } }
+        `Event name exceeds maximum length of ${EVENT_NAME_MAX_LENGTH} characters (got ${event.length}).`,
+        { details: { event: event.slice(0, 50) + "..." } }
       );
     }
-  }
-  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 } }
+    if (!EVENT_NAME_REGEX.test(event)) {
+      throw new SmoreSDKError(
+        "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 } }
       );
     }
   }
+
   class DebugLogger {
     enabled;
     level;
@@ -146,30 +188,15 @@
       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;
-      }
+    constructor(options, defaultPrefix = "[Smore]") {
+      const opts = typeof options === "boolean" ? { enabled: options } : options;
+      this.enabled = opts?.enabled ?? false;
+      this.level = opts?.level ?? "debug";
+      this.prefix = opts?.prefix ?? defaultPrefix;
+      this.logSend = opts?.logSend ?? true;
+      this.logReceive = opts?.logReceive ?? true;
+      this.logLifecycle = opts?.logLifecycle ?? true;
+      this.customLogger = opts?.logger;
     }
     shouldLog(level) {
       return this.enabled && DebugLogger.levelOrder[level] >= DebugLogger.levelOrder[this.level];
@@ -180,7 +207,7 @@
         this.customLogger(level, `${this.prefix} ${message}`, data);
         return;
       }
-      const consoleMethod = level === "error" ? "error" : level === "warn" ? "warn" : "log";
+      const consoleMethod = level === "error" ? "error" : level === "warn" ? "warn" : level === "debug" ? "debug" : "info";
       if (data !== void 0) {
         console[consoleMethod](`${this.prefix} ${message}`, data);
       } else {
@@ -200,11 +227,13 @@
       this.log("error", message, data);
     }
     send(event, data) {
+      if (!this.enabled) return;
       if (this.logSend) {
         this.debug(`-> SEND: ${event}`, data);
       }
     }
     receive(event, data) {
+      if (!this.enabled) return;
       if (this.logReceive) {
         this.debug(`<- RECV: ${event}`, data);
       }
@@ -215,24 +244,41 @@
       }
     }
   }
+
+  const DEFAULT_TIMEOUT$1 = 1e4;
+  function validatePlayerIndex(playerIndex, controllers) {
+    if (typeof playerIndex !== "number" || !Number.isInteger(playerIndex)) {
+      throw new SmoreSDKError("INVALID_PLAYER", "Player index must be an integer");
+    }
+    if (!controllers.some((c) => c.playerIndex === playerIndex)) {
+      throw new SmoreSDKError(
+        "INVALID_PLAYER",
+        `No controller found with player index ${playerIndex}`,
+        { details: { playerIndex } }
+      );
+    }
+  }
   class ScreenImpl {
     transport = null;
     config;
     logger;
     _controllers = [];
     _roomCode = "";
-    _leaderIndex = -1;
     _isReady = false;
     _isDestroyed = false;
     eventHandlers = /* @__PURE__ */ new Map();
     registeredTransportHandlers = [];
     boundMessageHandler = null;
+    // Maps user-facing handler → transport wrappedHandler for proper cleanup in on()/off()
+    handlerToTransport = /* @__PURE__ */ new Map();
+    // Tracks event names registered via config.listeners so off(event) without handler won't remove them
+    _configListenerEvents = /* @__PURE__ */ new Set();
     constructor(config = {}) {
       this.config = config;
-      this.logger = new DebugLogger(config.debug);
+      this.logger = new DebugLogger(config.debug, "[SmoreScreen]");
       if (config.listeners) {
         for (const event of Object.keys(config.listeners)) {
-          validateEventName$1(event);
+          validateEventName(event);
         }
       }
     }
@@ -246,9 +292,9 @@
       return new Promise((resolve, reject) => {
         const timeoutId = setTimeout(() => {
           this.cleanup();
-          const error = new SmoreSDKError$1(
+          const error = new SmoreSDKError(
             "TIMEOUT",
-            `Screen initialization timed out after ${timeout}ms. Make sure the parent frame sends smore:init.`,
+            `Screen initialization timed out after ${timeout}ms. Make sure the parent frame sends _bridge:init. Check that the iframe has correct sandbox attributes (allow-scripts required) and same-origin/cross-origin settings. Create a new Screen instance to retry (this instance has been cleaned up).`,
             { details: { timeout } }
           );
           this.handleError(error);
@@ -257,12 +303,26 @@
         this.boundMessageHandler = (e) => {
           if (parentOrigin !== "*" && e.origin !== parentOrigin) return;
           const msg = e.data;
-          if (!isSmoreMessage(msg)) return;
-          if (msg.type === "smore:init") {
+          if (!isBridgeMessage(msg)) return;
+          if (msg.type === "_bridge:init") {
             clearTimeout(timeoutId);
-            const initData = msg.payload;
+            const initPayload = msg.payload;
+            try {
+              validateInitPayload(initPayload);
+            } catch (err) {
+              const error = new SmoreSDKError(
+                "INIT_FAILED",
+                `Invalid _bridge:init payload: ${err instanceof Error ? err.message : String(err)}`,
+                { details: { payload: initPayload } }
+              );
+              this.logger.warn("_bridge:init validation failed", error);
+              this.handleError(error);
+              reject(error);
+              return;
+            }
+            const initData = initPayload;
             if (initData.side !== "host") {
-              const error = new SmoreSDKError$1(
+              const error = new SmoreSDKError(
                 "INIT_FAILED",
                 `Received init for wrong side: ${initData.side}. Expected "host".`,
                 { details: { side: initData.side } }
@@ -274,103 +334,155 @@
             this.transport = new PostMessageTransport(parentOrigin);
             this._roomCode = initData.roomCode;
             this._controllers = this.mapControllersFromInit(initData.players);
-            this._leaderIndex = this.findLeaderIndex(initData.players, initData.leaderId);
+            if (this._controllers.length === 0) {
+              this.logger.warn("Screen initialized with zero controllers");
+            }
             this.setupEventHandlers();
             this._isReady = true;
             this.logger.lifecycle("Screen ready", {
               roomCode: this._roomCode,
-              controllers: this._controllers.length,
-              leaderIndex: this._leaderIndex
+              controllers: this._controllers.length
             });
             this.config.onReady?.();
             resolve();
-          } else if (msg.type === "smore:update") {
-            const updateData = msg.payload;
-            if (updateData.players) {
-              this._controllers = this.mapControllersFromInit(updateData.players);
+          } else if (msg.type === "_bridge:update") {
+            if (!this._isReady) {
+              this.logger.debug("Ignoring _bridge:update before init completes");
+              return;
             }
-            if (updateData.leaderId !== void 0) {
-              this._leaderIndex = this.findLeaderIndex(
-                updateData.players ?? [],
-                updateData.leaderId
-              );
+            const updateData = msg.payload;
+            if (updateData.players && Array.isArray(updateData.players)) {
+              const oldControllers = this._controllers;
+              const newControllers = this.mapControllersFromInit(updateData.players);
+              this._controllers = newControllers;
+              for (const nc of newControllers) {
+                if (!oldControllers.some((oc) => oc.playerIndex === nc.playerIndex)) {
+                  this.logger.lifecycle("Controller joined (via update)", { playerIndex: nc.playerIndex });
+                  this.config.onControllerJoin?.(nc.playerIndex, nc);
+                }
+              }
+              for (const oc of oldControllers) {
+                if (!newControllers.some((nc) => nc.playerIndex === oc.playerIndex)) {
+                  this.logger.lifecycle("Controller left (via update)", { playerIndex: oc.playerIndex });
+                  this.config.onControllerLeave?.(oc.playerIndex);
+                }
+              }
             }
             this.logger.lifecycle("Room updated", {
-              controllers: this._controllers.length,
-              leaderIndex: this._leaderIndex
+              controllers: this._controllers.length
             });
           }
         };
         window.addEventListener("message", this.boundMessageHandler);
-        window.parent.postMessage({ type: "smore:ready" }, parentOrigin);
-        this.logger.lifecycle("Sent smore:ready to parent");
+        window.parent.postMessage({ type: "_bridge:ready" }, parentOrigin);
+        this.logger.lifecycle("Sent _bridge:ready to parent");
       });
     }
     mapControllersFromInit(players) {
       return players.map((p, index) => ({
         playerIndex: p.playerIndex ?? index,
-        nickname: p.nickname || `Player ${index + 1}`,
+        // Fallback to `nickname` for defensive compatibility (server currently always sends `name`)
+        nickname: p.nickname || p.name || `Player ${index + 1}`,
         connected: p.connected !== false,
-        appearance: p.appearance
+        // Fallback to `appearance` for defensive compatibility (server currently always sends `character`)
+        appearance: p.appearance ?? p.character
       }));
     }
-    findLeaderIndex(players, leaderId) {
-      if (!leaderId) return -1;
-      const idx = players.findIndex(
-        (p) => p.sessionId === leaderId
-      );
-      return idx >= 0 ? idx : -1;
-    }
     setupEventHandlers() {
       if (!this.transport) return;
-      this.registerTransportHandler(SYSTEM_EVENTS$1.PLAYER_JOIN, (data) => {
+      this.registerTransportHandler(SMORE_EVENTS.PLAYER_JOINED, (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);
+        const playerData = payload?.player;
+        if (playerData && typeof playerData.playerIndex === "number") {
+          const controllerInfo = {
+            playerIndex: playerData.playerIndex,
+            nickname: playerData.nickname || playerData.name || `Player ${playerData.playerIndex + 1}`,
+            connected: playerData.connected !== false,
+            appearance: playerData.appearance ?? playerData.character
+          };
+          if (this._controllers.some((c) => c.playerIndex === controllerInfo.playerIndex)) return;
+          this._controllers = [...this._controllers, controllerInfo];
+          this.logger.lifecycle("Controller joined", { playerIndex: controllerInfo.playerIndex });
+          this.config.onControllerJoin?.(controllerInfo.playerIndex, controllerInfo);
         }
       });
-      this.registerTransportHandler(SYSTEM_EVENTS$1.PLAYER_LEAVE, (data) => {
+      this.registerTransportHandler(SMORE_EVENTS.PLAYER_LEFT, (data) => {
         const payload = data;
-        if (typeof payload?.playerIndex === "number") {
-          this.logger.lifecycle("Controller left", { playerIndex: payload.playerIndex });
-          this.config.onControllerLeave?.(payload.playerIndex);
+        const playerIndex = payload?.player?.playerIndex ?? payload?.playerIndex;
+        if (typeof playerIndex === "number") {
+          if (!this._controllers.some((c) => c.playerIndex === playerIndex)) return;
+          this._controllers = this._controllers.filter((c) => c.playerIndex !== playerIndex);
+          this.logger.lifecycle("Controller left", { playerIndex });
+          this.config.onControllerLeave?.(playerIndex);
         }
       });
-      this.registerTransportHandler(SYSTEM_EVENTS$1.PLAYER_RECONNECT, (data) => {
+      this.registerTransportHandler(SMORE_EVENTS.PLAYER_DISCONNECTED, (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);
+        const playerIndex = payload?.player?.playerIndex ?? payload?.playerIndex;
+        if (typeof playerIndex === "number") {
+          this._controllers = this._controllers.map(
+            (c) => c.playerIndex === playerIndex ? { ...c, connected: false } : c
+          );
+          this.logger.lifecycle("Controller disconnected", { playerIndex });
+          this.config.onControllerDisconnect?.(playerIndex);
         }
       });
-      this.registerTransportHandler("room:player-joined", (data) => {
+      this.registerTransportHandler(SMORE_EVENTS.PLAYER_RECONNECTED, (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
-          });
+        const playerData = payload?.player;
+        if (playerData && typeof playerData.playerIndex === "number") {
+          const controllerInfo = {
+            playerIndex: playerData.playerIndex,
+            nickname: playerData.nickname || playerData.name || `Player ${playerData.playerIndex + 1}`,
+            connected: true,
+            appearance: playerData.appearance ?? playerData.character
+          };
+          this._controllers = this._controllers.map(
+            (c) => c.playerIndex === controllerInfo.playerIndex ? controllerInfo : c
+          );
+          this.logger.lifecycle("Controller reconnected", { playerIndex: controllerInfo.playerIndex });
+          this.config.onControllerReconnect?.(controllerInfo.playerIndex, controllerInfo);
         }
       });
-      this.registerTransportHandler("room:player-left", (data) => {
+      this.registerTransportHandler(SMORE_EVENTS.PLAYER_CHARACTER_UPDATED, (data) => {
         const payload = data;
-        const playerIndex = payload?.playerIndex ?? payload?.player?.playerIndex;
-        if (typeof playerIndex === "number") {
-          this.config.onControllerLeave?.(playerIndex);
+        const playerData = payload?.player;
+        if (playerData && typeof playerData.playerIndex === "number") {
+          const appearance = playerData.character ?? null;
+          this._controllers = this._controllers.map(
+            (c) => c.playerIndex === playerData.playerIndex ? { ...c, appearance } : c
+          );
+          this.logger.lifecycle("Player character updated", { playerIndex: playerData.playerIndex });
+          this.config.onCharacterUpdated?.(playerData.playerIndex, appearance ?? null);
         }
       });
+      this.registerTransportHandler(SMORE_EVENTS.RATE_LIMITED, (data) => {
+        const payload = data;
+        const event = payload?.event ?? "unknown";
+        this.logger.warn(`Rate limited: ${event}`);
+        this.config.onRateLimited?.(event);
+      });
       if (this.config.listeners) {
         for (const [event, handler] of Object.entries(this.config.listeners)) {
           if (!handler) continue;
+          this._configListenerEvents.add(event);
           this.setupUserEventHandler(event, handler);
         }
       }
     }
+    /**
+     * Sets up a user event handler with playerIndex extraction.
+     *
+     * Events received from controllers are dropped if they lack a playerIndex field.
+     * This is a security measure to prevent controller impersonation - the relay server
+     * automatically attaches playerIndex based on the sender's authenticated session,
+     * ensuring controllers cannot forge events as other players.
+     *
+     * Note: `playerIndex` is a reserved field name in event payloads.
+     * It is automatically extracted by the SDK and passed as the first argument
+     * to Screen event handlers. Game developers must NOT use `playerIndex` as
+     * a custom data field name -- it will be stripped from the data object.
+     */
     setupUserEventHandler(event, handler) {
       const wrappedHandler = (data) => {
         this.logger.receive(event, data);
@@ -381,12 +493,14 @@
             handler(playerIndex, rest);
           } catch (err) {
             this.handleError(
-              new SmoreSDKError$1("UNKNOWN", `Error in handler for event "${event}"`, {
+              new SmoreSDKError("UNKNOWN", `Error in handler for event "${event}"`, {
                 cause: err instanceof Error ? err : void 0,
                 details: { event, playerIndex }
               })
             );
           }
+        } else {
+          this.logger.debug(`Dropping event "${event}" without playerIndex`, data);
         }
       };
       this.registerTransportHandler(event, wrappedHandler);
@@ -405,15 +519,16 @@
     // ---------------------------------------------------------------------------
     // Properties (readonly)
     // ---------------------------------------------------------------------------
+    /**
+     * Returns a new shallow copy of the controllers array on every access.
+     * Cache the result if accessing repeatedly in the same frame/tick.
+     */
     get controllers() {
       return [...this._controllers];
     }
     get roomCode() {
       return this._roomCode;
     }
-    get leaderIndex() {
-      return this._leaderIndex;
-    }
     get isReady() {
       return this._isReady;
     }
@@ -423,22 +538,70 @@
     // ---------------------------------------------------------------------------
     // Communication Methods
     // ---------------------------------------------------------------------------
+    /**
+     * Send type-safe events to all controllers.
+     *
+     * Uses EventMap generic for compile-time type checking of event names and data payloads.
+     * Runtime behavior is identical to broadcastRaw - both call validateEventName at runtime.
+     *
+     * @note Data should be an object. Primitive values will be wrapped as `{ data: value }` by the relay server.
+     * @note Maximum payload size is 64KB. Data exceeding this limit will be silently dropped by the server.
+     * @note Fire-and-forget sends (no callback) will silently fail if rate-limited.
+     * Use the onError callback or smore:rate-limited event to detect rate limiting.
+     *
+     * Warning: Avoid sending primitive values directly (string, number, boolean).
+     * Wrap in an object: broadcast('event', { value: 42 }) instead of broadcast('event', 42)
+     *
+     * @see broadcastRaw for bypassing TypeScript type checking (runtime behavior identical)
+     */
     broadcast(event, data) {
       this.ensureReady("broadcast");
-      validateEventName$1(event);
+      validateEventName(event);
       this.logger.send(event, data);
       this.transport.emit(event, data);
     }
+    /**
+     * Send events to all controllers without TypeScript type checking.
+     *
+     * Bypasses EventMap generic type checks at compile time.
+     * Runtime behavior is identical to broadcast - both call validateEventName at runtime.
+     *
+     * Use this when you need dynamic event names or when working without a predefined EventMap.
+     *
+     * @note Data should be an object. Primitive values will be wrapped as `{ data: value }` by the relay server.
+     * @note Maximum payload size is 64KB. Data exceeding this limit will be silently dropped by the server.
+     *
+     * @see broadcast for type-safe version using EventMap generic
+     */
     broadcastRaw(event, data) {
       this.ensureReady("broadcastRaw");
-      validateEventName$1(event);
+      validateEventName(event);
       this.logger.send(event, data);
       this.transport.emit(event, data);
     }
+    /**
+     * Send an event to a specific controller.
+     *
+     * **Reserved field:** `targetPlayerIndex` is automatically merged into the data payload
+     * to route the event to the specified controller. Game developers should avoid using
+     * `targetPlayerIndex` as a custom data field name to prevent conflicts.
+     *
+     * @note Data should be an object. Primitive values will be wrapped as `{ data: value }` by the relay server.
+     * @note Maximum payload size is 64KB. Data exceeding this limit will be silently dropped by the server.
+     *
+     * @param playerIndex - Target controller's player index
+     * @param event - Event name
+     * @param data - Event data payload
+     */
     sendToController(playerIndex, event, data) {
       this.ensureReady("sendToController");
-      validateEventName$1(event);
-      validatePlayerIndex(playerIndex, this._controllers.length);
+      validateEventName(event);
+      validatePlayerIndex(playerIndex, this._controllers);
+      if (data && typeof data === "object" && "targetPlayerIndex" in data) {
+        this.logger.warn(
+          `Event "${event}" data contains reserved field "targetPlayerIndex" which will be overwritten for routing.`
+        );
+      }
       this.logger.send(`${event} -> Player ${playerIndex}`, data);
       this.transport.emit(event, {
         targetPlayerIndex: playerIndex,
@@ -447,8 +610,13 @@
     }
     sendToControllerRaw(playerIndex, event, data) {
       this.ensureReady("sendToControllerRaw");
-      validateEventName$1(event);
-      validatePlayerIndex(playerIndex, this._controllers.length);
+      validateEventName(event);
+      validatePlayerIndex(playerIndex, this._controllers);
+      if (data && typeof data === "object" && "targetPlayerIndex" in data) {
+        this.logger.warn(
+          `Event "${event}" data contains reserved field "targetPlayerIndex" which will be overwritten for routing.`
+        );
+      }
       this.logger.send(`${event} -> Player ${playerIndex}`, data);
       this.transport.emit(event, {
         targetPlayerIndex: playerIndex,
@@ -461,21 +629,31 @@
     gameOver(results) {
       this.ensureReady("gameOver");
       this.logger.lifecycle("Game over", results);
-      this.transport.emit(SYSTEM_EVENTS$1.GAME_OVER, { results });
+      this.transport.emit(SMORE_EVENTS.GAME_OVER, { results });
     }
     // ---------------------------------------------------------------------------
     // Event Subscription
     // ---------------------------------------------------------------------------
+    /**
+     * Register an event handler for messages from controllers.
+     *
+     * **Important:** If called before the Screen is ready (i.e., before `await createScreen()`
+     * resolves or before the `onReady` callback fires), the handler is stored locally but
+     * will NOT be registered with the transport layer. This means the handler will never
+     * fire for events received during the pre-ready window. Always call `on()` after
+     * initialization completes, or use `config.listeners` for handlers needed from the start.
+     */
     on(event, handler) {
-      validateEventName$1(event);
+      validateEventName(event);
       let handlers = this.eventHandlers.get(event);
       if (!handlers) {
         handlers = /* @__PURE__ */ new Set();
         this.eventHandlers.set(event, handlers);
       }
       handlers.add(handler);
+      let wrappedHandler = null;
       if (this.transport) {
-        const wrappedHandler = (data) => {
+        wrappedHandler = (data) => {
           this.logger.receive(event, data);
           const payload = data;
           const { playerIndex, ...rest } = payload;
@@ -484,22 +662,54 @@
               handler(playerIndex, rest);
             } catch (err) {
               this.handleError(
-                new SmoreSDKError$1("UNKNOWN", `Error in handler for event "${event}"`, {
+                new SmoreSDKError("UNKNOWN", `Error in handler for event "${event}"`, {
                   cause: err instanceof Error ? err : void 0
                 })
               );
             }
+          } else {
+            this.logger.debug(`Dropping event "${event}" without playerIndex`, data);
           }
         };
         this.registerTransportHandler(event, wrappedHandler);
+        this.handlerToTransport.set(handler, { event, transportHandler: wrappedHandler });
       }
       return () => {
         handlers?.delete(handler);
         if (handlers?.size === 0) {
           this.eventHandlers.delete(event);
         }
+        if (wrappedHandler) {
+          this.transport?.off(event, wrappedHandler);
+          this.registeredTransportHandlers = this.registeredTransportHandlers.filter(
+            (h) => h.handler !== wrappedHandler
+          );
+          this.handlerToTransport.delete(handler);
+        }
       };
     }
+    /**
+     * Register an event handler that will be called only once.
+     *
+     * The handler is automatically removed after the first invocation.
+     *
+     * **Important:** The wrapped handler cannot be removed via `off(event, originalHandler)`.
+     * Use the returned unsubscribe function instead.
+     *
+     * @param event - Event name to listen for
+     * @param handler - Handler function to call once
+     * @returns Unsubscribe function to remove the handler before it fires
+     *
+     * @example
+     * ```ts
+     * const unsubscribe = screen.once('ready', (playerIndex, data) => {
+     *   console.log('Ready event received');
+     * });
+     *
+     * // To remove before the event fires:
+     * unsubscribe();
+     * ```
+     */
     once(event, handler) {
       const wrappedHandler = (playerIndex, data) => {
         unsubscribe();
@@ -510,14 +720,38 @@
     }
     off(event, handler) {
       if (!handler) {
-        this.eventHandlers.delete(event);
-        this.transport?.off(event);
+        if (this._configListenerEvents.has(event)) {
+          for (const [key, val] of this.handlerToTransport) {
+            if (val.event === event) {
+              this.transport?.off(event, val.transportHandler);
+              this.registeredTransportHandlers = this.registeredTransportHandlers.filter(
+                (h) => h.handler !== val.transportHandler
+              );
+              this.handlerToTransport.delete(key);
+            }
+          }
+        } else {
+          this.eventHandlers.delete(event);
+          this.transport?.off(event);
+          this.registeredTransportHandlers = this.registeredTransportHandlers.filter((h) => h.event !== event);
+          for (const [key, val] of this.handlerToTransport) {
+            if (val.event === event) this.handlerToTransport.delete(key);
+          }
+        }
       } else {
         const handlers = this.eventHandlers.get(event);
         handlers?.delete(handler);
         if (handlers?.size === 0) {
           this.eventHandlers.delete(event);
         }
+        const entry = this.handlerToTransport.get(handler);
+        if (entry) {
+          this.transport?.off(event, entry.transportHandler);
+          this.registeredTransportHandlers = this.registeredTransportHandlers.filter(
+            (h) => h.handler !== entry.transportHandler
+          );
+          this.handlerToTransport.delete(handler);
+        }
       }
     }
     // ---------------------------------------------------------------------------
@@ -526,12 +760,31 @@
     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;
     }
+    /**
+     * 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).
+     *
+     * Use this in onControllerDisconnect callback to detect when all controllers have disconnected.
+     *
+     * @example
+     * ```ts
+     * const screen = await createScreen<MyEvents>({
+     *   onControllerDisconnect: (playerIndex) => {
+     *     if (!screen.hasAnyConnectedControllers()) {
+     *       console.log('All controllers disconnected!');
+     *       screen.broadcast('waiting-for-players', {});
+     *     }
+     *   },
+     * });
+     * ```
+     */
+    hasAnyConnectedControllers() {
+      return this._controllers.some((c) => c.connected);
+    }
     // ---------------------------------------------------------------------------
     // Cleanup
     // ---------------------------------------------------------------------------
@@ -549,6 +802,7 @@
       }
       this.registeredTransportHandlers = [];
       this.eventHandlers.clear();
+      this.handlerToTransport.clear();
       if (this.transport instanceof PostMessageTransport) {
         this.transport.destroy();
       }
@@ -562,6 +816,7 @@
     // Error Handling
     // ---------------------------------------------------------------------------
     handleError(error) {
+      this.logger.warn(`Error in handler: ${error.message}`);
       const smoreError = error.toSmoreError();
       if (this.config.onError) {
         this.config.onError(smoreError);
@@ -571,14 +826,14 @@
     }
     ensureReady(method) {
       if (this._isDestroyed) {
-        throw new SmoreSDKError$1(
+        throw new SmoreSDKError(
           "DESTROYED",
           `Cannot call ${method}() after destroy()`,
           { details: { method } }
         );
       }
       if (!this._isReady || !this.transport) {
-        throw new SmoreSDKError$1(
+        throw new SmoreSDKError(
           "NOT_READY",
           `Cannot call ${method}() before screen is ready. Use await createScreen() or onReady callback.`,
           { details: { method } }
@@ -593,103 +848,26 @@
     return promise;
   }
 
-  const SYSTEM_PREFIX = "smore:";
-  const SYSTEM_EVENTS = {
-    PLAYER_JOIN: `${SYSTEM_PREFIX}player-join`,
-    PLAYER_LEAVE: `${SYSTEM_PREFIX}player-leave`
-  };
   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 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 } }
-      );
-    }
-  }
-  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;
     _isReady = false;
     _isDestroyed = false;
     boundMessageHandler = null;
     registeredHandlers = [];
     eventListeners = /* @__PURE__ */ new Map();
+    // Maps user-facing handler -> transport wrappedHandler for proper cleanup in on()/off()
+    handlerToTransport = /* @__PURE__ */ new Map();
+    _controllers = [];
+    // Tracks event names registered via config.listeners so off(event) without handler won't remove them
+    _configListenerEvents = /* @__PURE__ */ new Set();
     constructor(config = {}) {
       this.config = config;
-      this.logger = createLogger(config.debug);
+      this.logger = new DebugLogger(config.debug, "[SmoreController]");
       if (config.listeners) {
         for (const event of Object.keys(config.listeners)) {
           validateEventName(event);
@@ -702,9 +880,6 @@
     get myIndex() {
       return this._myIndex;
     }
-    get isLeader() {
-      return this._isLeader;
-    }
     get roomCode() {
       return this._roomCode;
     }
@@ -714,19 +889,35 @@
     get isDestroyed() {
       return this._isDestroyed;
     }
+    /**
+     * Read-only list of all known controllers (players) in the room.
+     * Returns full ControllerInfo including playerIndex, nickname, connected status, and appearance.
+     *
+     * Returns a new shallow copy on every access. Cache the result if accessing
+     * repeatedly in the same frame/tick.
+     */
+    get controllers() {
+      return [...this._controllers];
+    }
+    /**
+     * Returns the number of currently connected players.
+     */
+    getControllerCount() {
+      return this._controllers.filter((c) => c.connected).length;
+    }
     // ---------------------------------------------------------------------------
     // Initialization
     // ---------------------------------------------------------------------------
     async initialize() {
       const parentOrigin = this.config.parentOrigin ?? "*";
       const timeout = this.config.timeout ?? DEFAULT_TIMEOUT;
-      this.logger.debug("Initializing controller...", { parentOrigin, timeout });
+      this.logger.lifecycle("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.`,
+            `Controller initialization timed out after ${timeout}ms. Make sure the parent window sends _bridge:init message. Check that the iframe has correct sandbox attributes (allow-scripts required) and same-origin/cross-origin settings. Create a new Controller instance to retry (this instance has been cleaned up).`,
             { details: { timeout } }
           );
           this.handleError(error);
@@ -735,22 +926,36 @@
         this.boundMessageHandler = (e) => {
           if (parentOrigin !== "*" && e.origin !== parentOrigin) return;
           const msg = e.data;
-          if (!isSmoreMessage(msg)) return;
-          if (msg.type === "smore:init") {
+          if (!isBridgeMessage(msg)) return;
+          if (msg.type === "_bridge:init") {
             clearTimeout(timeoutId);
             this.handleInit(msg, parentOrigin, resolve, reject);
-          } else if (msg.type === "smore:update") {
+          } else if (msg.type === "_bridge:update") {
             this.handleUpdate(msg);
           }
         };
         window.addEventListener("message", this.boundMessageHandler);
-        this.logger.debug("Sending smore:ready to parent");
-        window.parent.postMessage({ type: "smore:ready" }, parentOrigin);
+        this.logger.lifecycle("Sending _bridge:ready to parent");
+        window.parent.postMessage({ type: "_bridge:ready" }, parentOrigin);
       });
     }
     handleInit(msg, parentOrigin, resolve, reject) {
-      const initData = msg.payload;
-      this.logger.debug("Received smore:init", initData);
+      const initPayload = msg.payload;
+      this.logger.debug("Received _bridge:init", initPayload);
+      try {
+        validateInitPayload(initPayload);
+      } catch (err) {
+        const error = new SmoreSDKError(
+          "INIT_FAILED",
+          `Invalid _bridge:init payload: ${err instanceof Error ? err.message : String(err)}`,
+          { details: { payload: initPayload } }
+        );
+        this.logger.warn("_bridge:init validation failed", error);
+        this.handleError(error);
+        reject(error);
+        return;
+      }
+      const initData = initPayload;
       if (initData.side !== "player") {
         const error = new SmoreSDKError(
           "INIT_FAILED",
@@ -774,49 +979,171 @@
       this.transport = new PostMessageTransport(parentOrigin);
       this._roomCode = initData.roomCode;
       this._myIndex = initData.myIndex;
-      this._isLeader = initData.isLeader ?? false;
+      const initPlayers = initData.players;
+      this._controllers = initPlayers.filter((p) => typeof p.playerIndex === "number").map((p) => ({
+        playerIndex: p.playerIndex,
+        nickname: p.nickname || p.name || `Player ${p.playerIndex + 1}`,
+        connected: p.connected !== false,
+        appearance: p.appearance ?? p.character
+      }));
       this.setupEventHandlers();
       this._isReady = true;
-      this.logger.info("Controller ready", {
+      this.logger.lifecycle("Controller ready", {
         roomCode: this._roomCode,
-        myIndex: this._myIndex,
-        isLeader: this._isLeader
+        myIndex: this._myIndex
       });
       this.config.onReady?.();
       resolve();
     }
     handleUpdate(msg) {
+      if (!this._isReady) {
+        this.logger.debug("Ignoring _bridge:update before init completes");
+        return;
+      }
       const updateData = msg.payload;
-      this.logger.debug("Received smore:update", updateData);
+      this.logger.debug("Received _bridge:update", updateData);
+      if (updateData.players && Array.isArray(updateData.players)) {
+        const players = updateData.players;
+        const newControllers = players.filter((p) => typeof p.playerIndex === "number").map((p) => ({
+          playerIndex: p.playerIndex,
+          nickname: p.nickname || p.name || `Player ${p.playerIndex + 1}`,
+          connected: p.connected !== false,
+          appearance: p.appearance ?? p.character
+        }));
+        const oldControllers = this._controllers;
+        for (const nc of newControllers) {
+          if (!oldControllers.some((oc) => oc.playerIndex === nc.playerIndex)) {
+            this.config.onControllerJoin?.(nc.playerIndex, nc);
+          }
+        }
+        for (const oc of oldControllers) {
+          if (!newControllers.some((nc) => nc.playerIndex === oc.playerIndex)) {
+            this.config.onControllerLeave?.(oc.playerIndex);
+          }
+        }
+        for (const nc of newControllers) {
+          const oc = oldControllers.find((c) => c.playerIndex === nc.playerIndex);
+          if (oc) {
+            if (oc.connected && !nc.connected) {
+              this.logger.debug("Player disconnected (via update)", { playerIndex: nc.playerIndex });
+              this.config.onControllerDisconnect?.(nc.playerIndex);
+            }
+            if (!oc.connected && nc.connected) {
+              this.logger.debug("Player reconnected (via update)", { playerIndex: nc.playerIndex });
+              this.config.onControllerReconnect?.(nc.playerIndex, nc);
+            }
+          }
+        }
+        this._controllers = newControllers;
+      }
     }
     setupEventHandlers() {
       if (!this.transport) return;
-      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(SMORE_EVENTS.PLAYER_JOINED, (raw) => {
+        const data = raw;
+        const playerInfo = data.player;
+        const playerIndex = playerInfo?.playerIndex ?? data.playerIndex;
+        if (playerIndex !== void 0) {
+          if (this._controllers.some((c) => c.playerIndex === playerIndex)) return;
+          const controllerInfo = playerInfo ? {
+            playerIndex,
+            nickname: playerInfo.nickname || playerInfo.name || `Player ${playerIndex + 1}`,
+            connected: playerInfo.connected !== false,
+            appearance: playerInfo.appearance ?? playerInfo.character
+          } : {
+            playerIndex,
+            nickname: `Player ${playerIndex + 1}`,
+            connected: true
+          };
+          this._controllers = [...this._controllers, controllerInfo];
+          this.logger.debug("Player joined", { playerIndex });
+          this.config.onControllerJoin?.(playerIndex, controllerInfo);
         }
-      );
-      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);
-          }
+      });
+      this.registerHandler(SMORE_EVENTS.PLAYER_LEFT, (raw) => {
+        const data = raw;
+        const playerIndex = data.player?.playerIndex ?? data.playerIndex;
+        if (playerIndex !== void 0) {
+          if (!this._controllers.some((c) => c.playerIndex === playerIndex)) return;
+          this._controllers = this._controllers.filter((c) => c.playerIndex !== playerIndex);
+          this.logger.debug("Player left", { playerIndex });
+          this.config.onControllerLeave?.(playerIndex);
         }
-      );
+      });
+      this.registerHandler(SMORE_EVENTS.PLAYER_DISCONNECTED, (raw) => {
+        const data = raw;
+        const playerData = data.player;
+        const playerIndex = playerData?.playerIndex ?? data.playerIndex;
+        if (playerIndex !== void 0) {
+          this._controllers = this._controllers.map(
+            (c) => c.playerIndex === playerIndex ? { ...c, connected: false } : c
+          );
+          this.logger.debug("Player disconnected", { playerIndex });
+          this.config.onControllerDisconnect?.(playerIndex);
+        }
+      });
+      this.registerHandler(SMORE_EVENTS.PLAYER_RECONNECTED, (raw) => {
+        const data = raw;
+        const playerData = data.player;
+        const playerIndex = playerData?.playerIndex ?? data.playerIndex;
+        if (playerIndex !== void 0) {
+          const controllerInfo = playerData ? {
+            playerIndex,
+            nickname: playerData.nickname || playerData.name || `Player ${playerIndex + 1}`,
+            connected: true,
+            appearance: playerData.appearance ?? playerData.character
+          } : {
+            playerIndex,
+            nickname: `Player ${playerIndex + 1}`,
+            connected: true
+          };
+          this._controllers = this._controllers.map(
+            (c) => c.playerIndex === playerIndex ? controllerInfo : c
+          );
+          this.logger.debug("Player reconnected", { playerIndex });
+          this.config.onControllerReconnect?.(playerIndex, controllerInfo);
+        }
+      });
+      this.registerHandler(SMORE_EVENTS.PLAYER_CHARACTER_UPDATED, (raw) => {
+        const payload = raw;
+        const playerData = payload?.player;
+        if (playerData && typeof playerData.playerIndex === "number") {
+          const appearance = playerData.character ?? null;
+          this._controllers = this._controllers.map(
+            (c) => c.playerIndex === playerData.playerIndex ? { ...c, appearance } : c
+          );
+          this.logger.debug("Player character updated", { playerIndex: playerData.playerIndex });
+          this.config.onCharacterUpdated?.(playerData.playerIndex, appearance ?? null);
+        }
+      });
+      this.registerHandler(SMORE_EVENTS.RATE_LIMITED, (raw) => {
+        const data = raw;
+        const event = data?.event ?? "unknown";
+        this.logger.warn(`Rate limited: ${event}`);
+        this.config.onRateLimited?.(event);
+      });
+      if (this.config.onHostDisconnect) {
+        this.logger.warn("onHostDisconnect is reserved for future use and currently non-functional");
+      }
+      if (this.config.onHostReconnect) {
+        this.logger.warn("onHostReconnect is reserved for future use and currently non-functional");
+      }
       if (this.config.listeners) {
         for (const [event, handler] of Object.entries(this.config.listeners)) {
           if (!handler) continue;
+          this._configListenerEvents.add(event);
           this.registerHandler(event, (data) => {
             this.logReceive(event, data);
-            handler(data);
+            try {
+              handler(data);
+            } catch (err) {
+              this.handleError(
+                new SmoreSDKError("UNKNOWN", `Error in handler for event "${event}"`, {
+                  cause: err instanceof Error ? err : void 0,
+                  details: { event }
+                })
+              );
+            }
           });
         }
       }
@@ -829,9 +1156,24 @@
     // ---------------------------------------------------------------------------
     // Communication Methods
     // ---------------------------------------------------------------------------
+    /**
+     * Send an event to the Screen. Controller-to-Controller direct communication
+     * is not supported; all messages must go through the Screen.
+     *
+     * Data is sent to the Screen only (not to other controllers). For Screen→Controller communication,
+     * Screen uses broadcast() or sendToController().
+     *
+     * @note Fire-and-forget sends (no callback) will silently fail if rate-limited.
+     * Use the onError callback or smore:rate-limited event to detect rate limiting.
+     */
     send(event, data) {
       this.ensureReady("send");
       validateEventName(event);
+      if (typeof data !== "object" || data === null) {
+        this.logger.warn(
+          'Event data should be an object. Primitive values will be wrapped as { data: value } by the relay server. To avoid confusion, wrap explicitly: send("event", { value: 42 }) instead of send("event", 42).'
+        );
+      }
       this.logSend(event, data);
       this.transport.emit(event, data);
     }
@@ -844,6 +1186,28 @@
     // ---------------------------------------------------------------------------
     // Event Subscription
     // ---------------------------------------------------------------------------
+    /**
+     * Register a handler for custom events.
+     *
+     * When receiving events from Screen's `broadcast()`:
+     *   handler receives `(data)` — no playerIndex included.
+     *
+     * When receiving events from Screen's `sendToController()`:
+     *   handler receives `(data)` — targeted to this specific controller.
+     *
+     * @note Unlike Screen's `on()` which receives `(playerIndex, data)`,
+     * Controller's `on()` receives only `(data)` since there's only one player per controller.
+     *
+     * Controller's on() handler signature: (data) => void
+     * Unlike Screen's (playerIndex, data) => void, Controller doesn't receive playerIndex
+     * because Controller only receives events from Screen, not from other controllers.
+     * The sender is always the Screen, so playerIndex is not applicable.
+     *
+     * **Important:** If called before the Controller is ready (i.e., before `await createController()`
+     * resolves or before the `onReady` callback fires), the handler is stored locally but
+     * will NOT receive events until the transport is initialized. Always call `on()` after
+     * initialization completes, or use `config.listeners` for handlers needed from the start.
+     */
     on(event, handler) {
       validateEventName(event);
       let listeners = this.eventListeners.get(event);
@@ -854,11 +1218,21 @@
       listeners.add(handler);
       const transportHandler = (data) => {
         this.logReceive(event, data);
-        handler(data);
+        try {
+          handler(data);
+        } catch (err) {
+          this.handleError(
+            new SmoreSDKError("UNKNOWN", `Error in handler for event "${event}"`, {
+              cause: err instanceof Error ? err : void 0,
+              details: { event }
+            })
+          );
+        }
       };
       if (this.transport) {
         this.transport.on(event, transportHandler);
         this.registeredHandlers.push({ event, handler: transportHandler });
+        this.handlerToTransport.set(handler, { event, transportHandler });
       }
       return () => {
         listeners?.delete(handler);
@@ -869,8 +1243,25 @@
         this.registeredHandlers = this.registeredHandlers.filter(
           (h) => h.handler !== transportHandler
         );
+        this.handlerToTransport.delete(handler);
       };
     }
+    /**
+     * 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.
+     *
+     * @example
+     * ```ts
+     * const unsubscribe = controller.once('game-start', (data) => {
+     *   console.log('Game started!', data);
+     * });
+     *
+     * // To cancel before it fires:
+     * unsubscribe();
+     * ```
+     */
     once(event, handler) {
       const unsubscribe = this.on(event, ((data) => {
         unsubscribe();
@@ -880,15 +1271,38 @@
     }
     off(event, handler) {
       if (!handler) {
-        this.eventListeners.delete(event);
-        this.transport?.off(event);
-        this.registeredHandlers = this.registeredHandlers.filter((h) => h.event !== event);
+        if (this._configListenerEvents.has(event)) {
+          for (const [key, val] of this.handlerToTransport) {
+            if (val.event === event) {
+              this.transport?.off(event, val.transportHandler);
+              this.registeredHandlers = this.registeredHandlers.filter(
+                (h) => h.handler !== val.transportHandler
+              );
+              this.handlerToTransport.delete(key);
+            }
+          }
+        } else {
+          this.eventListeners.delete(event);
+          this.transport?.off(event);
+          this.registeredHandlers = this.registeredHandlers.filter((h) => h.event !== event);
+          for (const [key, val] of this.handlerToTransport) {
+            if (val.event === event) this.handlerToTransport.delete(key);
+          }
+        }
       } else {
         const listeners = this.eventListeners.get(event);
         listeners?.delete(handler);
         if (listeners?.size === 0) {
           this.eventListeners.delete(event);
         }
+        const entry = this.handlerToTransport.get(handler);
+        if (entry) {
+          this.transport?.off(event, entry.transportHandler);
+          this.registeredHandlers = this.registeredHandlers.filter(
+            (h) => h.handler !== entry.transportHandler
+          );
+          this.handlerToTransport.delete(handler);
+        }
       }
     }
     // ---------------------------------------------------------------------------
@@ -896,7 +1310,7 @@
     // ---------------------------------------------------------------------------
     destroy() {
       if (this._isDestroyed) return;
-      this.logger.info("Destroying controller");
+      this.logger.lifecycle("Destroying controller");
       this.cleanup();
       this._isDestroyed = true;
     }
@@ -907,6 +1321,7 @@
       }
       this.registeredHandlers = [];
       this.eventListeners.clear();
+      this.handlerToTransport.clear();
       if (this.transport) {
         this.transport.destroy();
         this.transport = null;
@@ -936,6 +1351,7 @@
       }
     }
     handleError(error) {
+      this.logger.warn(`Error in handler: ${error.message}`);
       if (this.config.onError) {
         this.config.onError(error.toSmoreError());
       } else {
@@ -943,18 +1359,10 @@
       }
     }
     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);
-      }
+      this.logger.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);
-      }
+      this.logger.receive(event, data);
     }
   }
   function createController(config) {
@@ -964,61 +1372,40 @@
     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);
-      }
-    }
-  }
-
-  const SMORE_EVENTS = {
-    // 게임 lifecycle
-    READY: "smore:ready",
-    GAME_OVER: "smore:game-over",
-    RETURN_TO_LOBBY: "smore:return-to-lobby",
-    // 플레이어 관리
-    PLAYER_JOIN: "smore:player-join",
-    PLAYER_LEAVE: "smore:player-leave",
-    // 특정 플레이어에게 전송 (내부용)
-    SEND_TO_PLAYER: "smore:send-to-player",
-    // 초기화
-    INIT: "smore:init",
-    UPDATE: "smore:update"
-  };
-  function validateUserEvent(event) {
-    if (event.includes(":")) {
-      throw new Error(
-        `Invalid event name "${event}": User events cannot contain ':'. Use '_' or '-' instead. System events use 'smore:' prefix.`
-      );
-    }
-  }
-  function isSystemEvent(event) {
-    return event.startsWith("smore:");
-  }
-
   function createMockScreen(options = {}) {
     const {
       roomCode = "TEST",
       controllers: initialControllers = [],
-      autoReady = true
+      autoReady = true,
+      onReady: onReadyCb,
+      onControllerJoin: onJoinCb,
+      onControllerLeave: onLeaveCb,
+      onControllerDisconnect: onDisconnectCb,
+      onControllerReconnect: onReconnectCb,
+      onCharacterUpdated: onCharacterUpdatedCb,
+      onRateLimited: onRateLimitedCb,
+      onError: onErrorCb
     } = options;
     let _controllers = [...initialControllers];
     let _isReady = false;
     let _isDestroyed = false;
-    let _leaderIndex = initialControllers[0]?.playerIndex ?? -1;
     const listeners = /* @__PURE__ */ new Map();
+    let onReadyCallback;
+    let onControllerJoinCallback;
+    let onControllerLeaveCallback;
+    let onControllerDisconnectCallback;
+    let onControllerReconnectCallback;
+    let onCharacterUpdatedCallback;
+    let onRateLimitedCallback;
+    let onErrorCallback;
+    onReadyCallback = onReadyCb;
+    onControllerJoinCallback = onJoinCb;
+    onControllerLeaveCallback = onLeaveCb;
+    onControllerDisconnectCallback = onDisconnectCb;
+    onControllerReconnectCallback = onReconnectCb;
+    onCharacterUpdatedCallback = onCharacterUpdatedCb;
+    onRateLimitedCallback = onRateLimitedCb;
+    onErrorCallback = onErrorCb;
     const broadcasts = [];
     const sends = [];
     const screen = {
@@ -1029,9 +1416,6 @@
       get roomCode() {
         return roomCode;
       },
-      get leaderIndex() {
-        return _leaderIndex;
-      },
       get isReady() {
         return _isReady;
       },
@@ -1043,18 +1427,30 @@
         if (_isDestroyed) {
           throw new Error("Cannot broadcast: screen is destroyed");
         }
+        if (!_isReady) {
+          throw new Error("Cannot broadcast: screen is not ready");
+        }
+        validateEventName(event);
         broadcasts.push({ event, data });
       },
       broadcastRaw(event, data) {
         if (_isDestroyed) {
           throw new Error("Cannot broadcast: screen is destroyed");
         }
+        if (!_isReady) {
+          throw new Error("Cannot broadcast: screen is not ready");
+        }
+        validateEventName(event);
         broadcasts.push({ event, data });
       },
       sendToController(playerIndex, event, data) {
         if (_isDestroyed) {
           throw new Error("Cannot send: screen is destroyed");
         }
+        if (!_isReady) {
+          throw new Error("Cannot send: screen is not ready");
+        }
+        validateEventName(event);
         if (!_controllers.some((c) => c.playerIndex === playerIndex)) {
           throw new Error(`Invalid player index: ${playerIndex}`);
         }
@@ -1064,6 +1460,10 @@
         if (_isDestroyed) {
           throw new Error("Cannot send: screen is destroyed");
         }
+        if (!_isReady) {
+          throw new Error("Cannot send: screen is not ready");
+        }
+        validateEventName(event);
         if (!_controllers.some((c) => c.playerIndex === playerIndex)) {
           throw new Error(`Invalid player index: ${playerIndex}`);
         }
@@ -1071,10 +1471,17 @@
       },
       // === Game Lifecycle ===
       gameOver(results) {
-        screen.broadcastRaw("game-over", results);
+        if (_isDestroyed) {
+          throw new Error("Cannot call gameOver: screen is destroyed");
+        }
+        if (!_isReady) {
+          throw new Error("Cannot call gameOver: screen is not ready");
+        }
+        broadcasts.push({ event: "smore:game-over", data: { results } });
       },
       // === Event Subscription ===
       on(event, handler) {
+        validateEventName(event);
         const eventStr = event;
         if (!listeners.has(eventStr)) {
           listeners.set(eventStr, /* @__PURE__ */ new Set());
@@ -1085,6 +1492,7 @@
         };
       },
       once(event, handler) {
+        validateEventName(event);
         const wrapper = (playerIndex, data) => {
           handler(playerIndex, data);
           screen.off(event, wrapper);
@@ -1092,6 +1500,7 @@
         return screen.on(event, wrapper);
       },
       off(event, handler) {
+        validateEventName(event);
         const eventStr = event;
         if (!handler) {
           listeners.delete(eventStr);
@@ -1103,13 +1512,16 @@
       getController(playerIndex) {
         return _controllers.find((c) => c.playerIndex === playerIndex);
       },
-      isLeader(playerIndex) {
-        return playerIndex === _leaderIndex;
-      },
       getControllerCount() {
-        return _controllers.length;
+        return _controllers.filter((c) => c.connected).length;
+      },
+      hasAnyConnectedControllers() {
+        return _controllers.some((c) => c.connected);
       },
       // === Cleanup ===
+      /**
+       * Note: destroy() clears recorded broadcast/event arrays. Call getBroadcasts() before destroy() if assertions are needed.
+       */
       destroy() {
         _isDestroyed = true;
         listeners.clear();
@@ -1118,6 +1530,7 @@
       },
       // === Mock-specific methods ===
       simulateEvent(playerIndex, event, data) {
+        validateEventName(event);
         const eventStr = event;
         const handlers = listeners.get(eventStr);
         if (handlers) {
@@ -1128,14 +1541,80 @@
       },
       simulateControllerJoin(info) {
         _controllers.push(info);
-        if (_leaderIndex === -1) {
-          _leaderIndex = info.playerIndex;
+        if (onControllerJoinCallback) {
+          onControllerJoinCallback(info.playerIndex, info);
         }
       },
       simulateControllerLeave(playerIndex) {
         _controllers = _controllers.filter((c) => c.playerIndex !== playerIndex);
-        if (_leaderIndex === playerIndex) {
-          _leaderIndex = _controllers[0]?.playerIndex ?? -1;
+        if (onControllerLeaveCallback) {
+          onControllerLeaveCallback(playerIndex);
+        }
+      },
+      /**
+       * Simulate a controller network disconnect (player still in room but unreachable).
+       *
+       * @example
+       * ```ts
+       * screen.simulateControllerDisconnect(0);
+       * expect(screen.getController(0)?.connected).toBe(false);
+       * ```
+       */
+      simulateControllerDisconnect(playerIndex) {
+        const controller = _controllers.find((c) => c.playerIndex === playerIndex);
+        if (!controller) {
+          throw new Error(`Controller ${playerIndex} not found`);
+        }
+        _controllers = _controllers.map(
+          (c) => c.playerIndex === playerIndex ? { ...c, connected: false } : c
+        );
+        if (onControllerDisconnectCallback) {
+          onControllerDisconnectCallback(playerIndex);
+        }
+      },
+      /**
+       * Simulate a controller network reconnect after disconnect.
+       *
+       * @example
+       * ```ts
+       * screen.simulateControllerDisconnect(0);
+       * screen.simulateControllerReconnect(0);
+       * expect(screen.getController(0)?.connected).toBe(true);
+       * ```
+       */
+      simulateControllerReconnect(playerIndex) {
+        const controller = _controllers.find((c) => c.playerIndex === playerIndex);
+        if (!controller) {
+          throw new Error(`Controller ${playerIndex} not found`);
+        }
+        const reconnectedController = { ...controller, connected: true };
+        _controllers = _controllers.map(
+          (c) => c.playerIndex === playerIndex ? reconnectedController : c
+        );
+        if (onControllerReconnectCallback) {
+          onControllerReconnectCallback(playerIndex, reconnectedController);
+        }
+      },
+      simulateCharacterUpdate(playerIndex, appearance) {
+        const controller = _controllers.find((c) => c.playerIndex === playerIndex);
+        if (!controller) {
+          throw new Error(`Controller ${playerIndex} not found`);
+        }
+        _controllers = _controllers.map(
+          (c) => c.playerIndex === playerIndex ? { ...c, appearance } : c
+        );
+        if (onCharacterUpdatedCallback) {
+          onCharacterUpdatedCallback(playerIndex, appearance);
+        }
+      },
+      simulateRateLimited(event) {
+        if (onRateLimitedCallback) {
+          onRateLimitedCallback(event);
+        }
+      },
+      simulateError(error) {
+        if (onErrorCallback) {
+          onErrorCallback(error);
         }
       },
       getBroadcasts() {
@@ -1150,6 +1629,9 @@
       },
       triggerReady() {
         _isReady = true;
+        if (onReadyCallback) {
+          onReadyCallback();
+        }
       }
     };
     if (autoReady) {
@@ -1161,22 +1643,42 @@
     const {
       roomCode = "TEST",
       myIndex = 0,
-      isLeader: initialIsLeader = false,
-      autoReady = true
+      autoReady = true,
+      onReady: onReadyCb,
+      onControllerJoin: onJoinCb,
+      onControllerLeave: onLeaveCb,
+      onControllerDisconnect: onDisconnectCb,
+      onControllerReconnect: onReconnectCb,
+      onCharacterUpdated: onCharacterUpdatedCb,
+      onRateLimited: onRateLimitedCb,
+      onError: onErrorCb
     } = options;
     let _isReady = false;
     let _isDestroyed = false;
-    let _isLeader = initialIsLeader;
+    let _controllers = options.controllers ?? [];
     const listeners = /* @__PURE__ */ new Map();
+    let onReadyCallback;
+    let onControllerJoinCallback;
+    let onControllerLeaveCallback;
+    let onControllerDisconnectCallback;
+    let onControllerReconnectCallback;
+    let onCharacterUpdatedCallback;
+    let onRateLimitedCallback;
+    let onErrorCallback;
+    onReadyCallback = onReadyCb;
+    onControllerJoinCallback = onJoinCb;
+    onControllerLeaveCallback = onLeaveCb;
+    onControllerDisconnectCallback = onDisconnectCb;
+    onControllerReconnectCallback = onReconnectCb;
+    onCharacterUpdatedCallback = onCharacterUpdatedCb;
+    onRateLimitedCallback = onRateLimitedCb;
+    onErrorCallback = onErrorCb;
     const sentEvents = [];
     const controller = {
       // === Properties ===
       get myIndex() {
         return myIndex;
       },
-      get isLeader() {
-        return _isLeader;
-      },
       get roomCode() {
         return roomCode;
       },
@@ -1186,21 +1688,30 @@
       get isDestroyed() {
         return _isDestroyed;
       },
+      get controllers() {
+        return [..._controllers];
+      },
+      getControllerCount() {
+        return _controllers.filter((c) => c.connected).length;
+      },
       // === Communication Methods ===
       send(event, data) {
         if (_isDestroyed) {
           throw new Error("Cannot send: controller is destroyed");
         }
+        validateEventName(event);
         sentEvents.push({ event, data });
       },
       sendRaw(event, data) {
         if (_isDestroyed) {
           throw new Error("Cannot send: controller is destroyed");
         }
+        validateEventName(event);
         sentEvents.push({ event, data });
       },
       // === Event Subscription ===
       on(event, handler) {
+        validateEventName(event);
         const eventStr = event;
         if (!listeners.has(eventStr)) {
           listeners.set(eventStr, /* @__PURE__ */ new Set());
@@ -1211,6 +1722,7 @@
         };
       },
       once(event, handler) {
+        validateEventName(event);
         const wrapper = (data) => {
           handler(data);
           controller.off(event, wrapper);
@@ -1218,6 +1730,7 @@
         return controller.on(event, wrapper);
       },
       off(event, handler) {
+        validateEventName(event);
         const eventStr = event;
         if (!handler) {
           listeners.delete(eventStr);
@@ -1233,6 +1746,7 @@
       },
       // === Mock-specific methods ===
       simulateEvent(event, data) {
+        validateEventName(event);
         const eventStr = event;
         const handlers = listeners.get(eventStr);
         if (handlers) {
@@ -1249,9 +1763,100 @@
       },
       triggerReady() {
         _isReady = true;
+        if (onReadyCallback) {
+          onReadyCallback();
+        }
+      },
+      /**
+       * Simulate a new player joining the room.
+       * Stores full ControllerInfo (nickname, appearance, etc.) for later retrieval.
+       *
+       * @example
+       * ```ts
+       * controller.simulatePlayerJoin(2, { playerIndex: 2, nickname: 'Alice', connected: true });
+       * expect(controller.getControllerCount()).toBe(3);
+       * expect(controller.controllers.find(c => c.playerIndex === 2)?.nickname).toBe('Alice');
+       * ```
+       */
+      simulatePlayerJoin(playerIndex, info) {
+        if (!_controllers.some((c) => c.playerIndex === playerIndex)) {
+          _controllers = [..._controllers, { ...info, connected: info.connected ?? true }];
+        }
+        if (onControllerJoinCallback) {
+          onControllerJoinCallback(playerIndex, info);
+        }
+      },
+      /**
+       * Simulate a player leaving the room (fully removed).
+       *
+       * @example
+       * ```ts
+       * controller.simulatePlayerLeave(1);
+       * expect(controller.controllers.some(c => c.playerIndex === 1)).toBe(false);
+       * ```
+       */
+      simulatePlayerLeave(playerIndex) {
+        _controllers = _controllers.filter((c) => c.playerIndex !== playerIndex);
+        if (onControllerLeaveCallback) {
+          onControllerLeaveCallback(playerIndex);
+        }
       },
-      setLeader(isLeader) {
-        _isLeader = isLeader;
+      /**
+       * Simulate a player network disconnect (player still in room but unreachable).
+       *
+       * @example
+       * ```ts
+       * controller.simulatePlayerDisconnect(1);
+       * expect(controller.controllers.find(c => c.playerIndex === 1)?.connected).toBe(false);
+       * ```
+       */
+      simulatePlayerDisconnect(playerIndex) {
+        _controllers = _controllers.map(
+          (c) => c.playerIndex === playerIndex ? { ...c, connected: false } : c
+        );
+        if (onControllerDisconnectCallback) {
+          onControllerDisconnectCallback(playerIndex);
+        }
+      },
+      /**
+       * Simulate a player network reconnect after disconnect.
+       *
+       * @example
+       * ```ts
+       * controller.simulatePlayerDisconnect(1);
+       * controller.simulatePlayerReconnect(1, { playerIndex: 1, nickname: 'Bob', connected: true });
+       * expect(controller.controllers.find(c => c.playerIndex === 1)?.connected).toBe(true);
+       * ```
+       */
+      simulatePlayerReconnect(playerIndex, info) {
+        _controllers = _controllers.map(
+          (c) => c.playerIndex === playerIndex ? { ...info, connected: true } : c
+        );
+        if (onControllerReconnectCallback) {
+          onControllerReconnectCallback(playerIndex, info);
+        }
+      },
+      simulateCharacterUpdate(playerIndex, appearance) {
+        const controller2 = _controllers.find((c) => c.playerIndex === playerIndex);
+        if (!controller2) {
+          throw new Error(`Controller ${playerIndex} not found`);
+        }
+        _controllers = _controllers.map(
+          (c) => c.playerIndex === playerIndex ? { ...c, appearance } : c
+        );
+        if (onCharacterUpdatedCallback) {
+          onCharacterUpdatedCallback(playerIndex, appearance);
+        }
+      },
+      simulateRateLimited(event) {
+        if (onRateLimitedCallback) {
+          onRateLimitedCallback(event);
+        }
+      },
+      simulateError(error) {
+        if (onErrorCallback) {
+          onErrorCallback(error);
+        }
       }
     };
     if (autoReady) {
@@ -1260,16 +1865,12 @@
     return controller;
   }
 
-  exports.DirectTransport = DirectTransport;
-  exports.PostMessageTransport = PostMessageTransport;
-  exports.SMORE_EVENTS = SMORE_EVENTS;
-  exports.SmoreSDKError = SmoreSDKError$1;
+  exports.SmoreSDKError = SmoreSDKError;
   exports.createController = createController;
   exports.createMockController = createMockController;
   exports.createMockScreen = createMockScreen;
   exports.createScreen = createScreen;
-  exports.isSystemEvent = isSystemEvent;
-  exports.validateUserEvent = validateUserEvent;
+  exports.validateEventName = validateEventName;
 
 }));
 //# sourceMappingURL=smore-sdk.umd.js.map