@smoregg/sdk 0.4.1 → 0.6.0

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

@@ -1,7 +1,7 @@
 (function (global, factory) {
   typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
   typeof define === 'function' && define.amd ? define(['exports'], factory) :
-  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.SmoreSDKIframe = {}));
+  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.SmoreSDK = {}));
 })(this, (function (exports) { 'use strict';
 
   const SMORE_MSG_PREFIX = "smore:";
@@ -75,152 +75,1201 @@
     }
   }
 
-  const EVENT_NAME_REGEX = /^[a-zA-Z]([a-zA-Z_-]*[a-zA-Z])?$/;
-  function validateEventName(event) {
-    if (!EVENT_NAME_REGEX.test(event)) {
-      console.error(
-        `[SDK] 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 _)`
+  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 {
+    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 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 } }
       );
-      return false;
     }
-    return true;
   }
-  function createHostBridge(options) {
-    const { parentOrigin = "*", gameId, listeners, onPlayerJoin, onPlayerLeave, onReady } = options;
-    let transport = null;
-    window.parent.postMessage({ type: "smore:ready" }, parentOrigin);
-    const messageHandler = (e) => {
-      if (parentOrigin !== "*" && e.origin !== parentOrigin) return;
-      const msg = e.data;
-      if (!isSmoreMessage(msg)) return;
-      if (msg.type === "smore:init") {
-        const { side, roomCode, players, leaderId } = msg.payload;
-        if (side !== "host") {
-          console.error("[HostBridge] Received init for wrong side:", side);
-          return;
-        }
-        transport = new PostMessageTransport(parentOrigin);
-        if (listeners) {
-          Object.keys(listeners).forEach((event) => {
-            validateEventName(event);
-            const handler = listeners[event];
-            transport.on(event, handler);
-          });
+  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 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;
+    logger;
+    _controllers = [];
+    _roomCode = "";
+    _leaderIndex = -1;
+    _isReady = false;
+    _isDestroyed = false;
+    eventHandlers = /* @__PURE__ */ new Map();
+    registeredTransportHandlers = [];
+    boundMessageHandler = null;
+    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 (onPlayerJoin) {
-          transport.on("player:joined", (payload) => {
-            onPlayerJoin(payload.sessionId);
-          });
+      }
+    }
+    // ---------------------------------------------------------------------------
+    // Initialization (called by factory)
+    // ---------------------------------------------------------------------------
+    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.parent.postMessage({ type: "smore:ready" }, parentOrigin);
+        this.logger.lifecycle("Sent smore:ready to parent");
+      });
+    }
+    mapControllersFromInit(players) {
+      return players.map((p, index) => ({
+        playerIndex: p.playerIndex ?? index,
+        nickname: p.nickname || `Player ${index + 1}`,
+        connected: p.connected !== false,
+        appearance: p.appearance
+      }));
+    }
+    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) => {
+        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.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);
         }
-        if (onPlayerLeave) {
-          transport.on("player:left", (payload) => {
-            onPlayerLeave(payload.sessionId);
+      });
+      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
           });
         }
-        if (onReady) {
-          onReady({ roomCode, players, leaderId });
+      });
+      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.setupUserEventHandler(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.registeredTransportHandlers.push({ event, handler });
+    }
+    // ---------------------------------------------------------------------------
+    // Properties (readonly)
+    // ---------------------------------------------------------------------------
+    get controllers() {
+      return [...this._controllers];
+    }
+    get roomCode() {
+      return this._roomCode;
+    }
+    get leaderIndex() {
+      return this._leaderIndex;
+    }
+    get isReady() {
+      return this._isReady;
+    }
+    get isDestroyed() {
+      return this._isDestroyed;
+    }
+    // ---------------------------------------------------------------------------
+    // Communication Methods
+    // ---------------------------------------------------------------------------
+    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);
+    }
+    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 }
+      });
+    }
+    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 });
+    }
+    // ---------------------------------------------------------------------------
+    // Event Subscription
+    // ---------------------------------------------------------------------------
+    on(event, handler) {
+      validateEventName$1(event);
+      let handlers = this.eventHandlers.get(event);
+      if (!handlers) {
+        handlers = /* @__PURE__ */ new Set();
+        this.eventHandlers.set(event, handlers);
+      }
+      handlers.add(handler);
+      if (this.transport) {
+        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 () => {
+        handlers?.delete(handler);
+        if (handlers?.size === 0) {
+          this.eventHandlers.delete(event);
+        }
+      };
+    }
+    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;
+      this.cleanup();
+      this.logger.lifecycle("Screen destroyed");
+    }
+    cleanup() {
+      for (const { event, handler } of this.registeredTransportHandlers) {
+        this.transport?.off(event, handler);
+      }
+      this.registeredTransportHandlers = [];
+      this.eventHandlers.clear();
+      if (this.transport instanceof PostMessageTransport) {
+        this.transport.destroy();
+      }
+      this.transport = null;
+      if (this.boundMessageHandler) {
+        window.removeEventListener("message", this.boundMessageHandler);
+        this.boundMessageHandler = null;
+      }
+    }
+    // ---------------------------------------------------------------------------
+    // Error Handling
+    // ---------------------------------------------------------------------------
+    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 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 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);
+      }
     };
-    window.addEventListener("message", messageHandler);
     return {
-      broadcast: (event, data) => {
-        if (!transport) {
-          console.warn("[HostBridge] Cannot broadcast before init");
-          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();
+    constructor(config = {}) {
+      this.config = config;
+      this.logger = createLogger(config.debug);
+      if (config.listeners) {
+        for (const event of Object.keys(config.listeners)) {
+          validateEventName(event);
         }
-        validateEventName(event);
-        transport.emit(event, data);
+      }
+    }
+    // ---------------------------------------------------------------------------
+    // 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
+    // ---------------------------------------------------------------------------
+    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();
+    }
+    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.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.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, (data) => {
+            this.logReceive(event, data);
+            handler(data);
+          });
+        }
+      }
+    }
+    registerHandler(event, handler) {
+      if (!this.transport) return;
+      this.transport.on(event, handler);
+      this.registeredHandlers.push({ event, handler });
+    }
+    // ---------------------------------------------------------------------------
+    // Communication Methods
+    // ---------------------------------------------------------------------------
+    send(event, data) {
+      this.ensureReady("send");
+      validateEventName(event);
+      this.logSend(event, data);
+      this.transport.emit(event, data);
+    }
+    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, transportHandler);
+        this.registeredHandlers.push({ event, handler: transportHandler });
+      }
+      return () => {
+        listeners?.delete(handler);
+        if (listeners?.size === 0) {
+          this.eventListeners.delete(event);
+        }
+        this.transport?.off(event, transportHandler);
+        this.registeredHandlers = this.registeredHandlers.filter(
+          (h) => h.handler !== transportHandler
+        );
+      };
+    }
+    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 = [];
+      this.eventListeners.clear();
+      if (this.transport) {
+        this.transport.destroy();
+        this.transport = null;
+      }
+      if (this.boundMessageHandler) {
+        window.removeEventListener("message", this.boundMessageHandler);
+        this.boundMessageHandler = null;
+      }
+    }
+    // ---------------------------------------------------------------------------
+    // 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 SmoreSDKError(
+          "NOT_READY",
+          `Cannot call ${method}() before controller is ready. Use await createController() or wait for onReady callback.`,
+          { details: { method, isReady: this._isReady } }
+        );
+      }
+    }
+    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);
+      }
+    }
+  }
+
+  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
+    } = 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;
       },
-      sendToPlayer: (playerId, event, data) => {
-        if (!transport) {
-          console.warn("[HostBridge] Cannot sendToPlayer before init");
-          return;
+      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");
         }
-        transport.emit(event, { targetSessionId: playerId, ...data });
+        broadcasts.push({ event, data });
       },
-      emitGameOver: (results) => {
-        if (!transport) {
-          console.warn("[HostBridge] Cannot emitGameOver before init");
-          return;
+      broadcastRaw(event, data) {
+        if (_isDestroyed) {
+          throw new Error("Cannot broadcast: screen is destroyed");
         }
-        transport.emit("game-over", results);
+        broadcasts.push({ event, data });
       },
-      setLoaded: () => {
-        window.parent.postMessage({ type: "smore:loaded" }, parentOrigin);
+      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 });
       },
-      destroy: () => {
-        window.removeEventListener("message", messageHandler);
-        transport?.destroy();
-        transport = null;
-      }
-    };
-  }
-  function createPlayerBridge(options) {
-    const { parentOrigin = "*", gameId, listeners, onReady } = options;
-    let transport = null;
-    window.parent.postMessage({ type: "smore:ready" }, parentOrigin);
-    const messageHandler = (e) => {
-      if (parentOrigin !== "*" && e.origin !== parentOrigin) return;
-      const msg = e.data;
-      if (!isSmoreMessage(msg)) return;
-      if (msg.type === "smore:init") {
-        const { side, roomCode, mySessionId, isLeader } = msg.payload;
-        if (side !== "player") {
-          console.error("[PlayerBridge] Received init for wrong side:", side);
-          return;
-        }
-        if (!mySessionId) {
-          console.error("[PlayerBridge] Missing mySessionId in init payload");
-          return;
-        }
-        transport = new PostMessageTransport(parentOrigin);
-        if (listeners) {
-          Object.keys(listeners).forEach((event) => {
-            validateEventName(event);
-            const handler = listeners[event];
-            transport.on(event, handler);
+      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);
           });
         }
-        if (onReady) {
-          onReady({ roomCode, isLeader: !!isLeader, mySessionId });
+      },
+      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;
       }
     };
-    window.addEventListener("message", messageHandler);
-    return {
-      emit: (event, data) => {
-        if (!transport) {
-          console.warn("[PlayerBridge] Cannot emit before init");
-          return;
-        }
-        validateEventName(event);
-        transport.emit(event, data);
-      },
-      onEvent: (event, handler) => {
-        if (!transport) {
-          console.warn("[PlayerBridge] Cannot onEvent before init");
-          return () => {
-          };
-        }
-        validateEventName(event);
-        transport.on(event, handler);
+    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 () => {
-          transport?.off(event, handler);
+          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;
       },
-      destroy: () => {
-        window.removeEventListener("message", messageHandler);
-        transport?.destroy();
-        transport = null;
+      // === 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.createHostBridge = createHostBridge;
-  exports.createPlayerBridge = createPlayerBridge;
+  exports.DirectTransport = DirectTransport;
+  exports.PostMessageTransport = PostMessageTransport;
+  exports.SMORE_EVENTS = SMORE_EVENTS;
+  exports.SmoreSDKError = SmoreSDKError$1;
+  exports.createController = createController;
+  exports.createMockController = createMockController;
+  exports.createMockScreen = createMockScreen;
+  exports.createScreen = createScreen;
+  exports.isSystemEvent = isSystemEvent;
+  exports.validateUserEvent = validateUserEvent;
 
 }));
 //# sourceMappingURL=smore-sdk-vanilla.umd.js.map