@smoregg/sdk 2.0.0 → 2.2.0

package/dist/esm/controller.js

@@ -1,9 +1,9 @@
 import { PostMessageTransport } from './transport/PostMessageTransport.js';
-import { isBridgeMessage, validateInitPayload } from './transport/protocol.js';
+import { PROTOCOL_VERSION, isBridgeMessage, validateInitPayload } from './transport/protocol.js';
 import { SmoreSDKError } from './errors.js';
-import { SMORE_EVENTS, validateEventName } from './events.js';
+import { SMORE_EVENTS, validateEventName, CONTROLLER_LIFECYCLE_EVENTS } from './events.js';
 import { DebugLogger } from './logger.js';
-import { getGlobalConfig } from './config.js';
+import { mapPlayerDTO, validatePayloadSize } from './shared.js';
 
 const DEFAULT_TIMEOUT = 1e4;
 class ControllerImpl {
@@ -11,7 +11,7 @@ class ControllerImpl {
   config;
   logger;
   _roomCode = "";
-  _myIndex = -1;
+  _myPlayerIndex = -1;
   _isReady = false;
   _isDestroyed = false;
   _initTimeoutId = null;
@@ -21,19 +21,20 @@ class ControllerImpl {
   // Maps user-facing handler -> transport wrappedHandler for proper cleanup in on()/off()
   handlerToTransport = /* @__PURE__ */ new Map();
   _controllers = [];
+  _customStates = /* @__PURE__ */ new Map();
+  _stateChangeListeners = /* @__PURE__ */ new Set();
   // Pending handlers registered via on() before transport is ready
   _pendingHandlers = [];
-  // Lifecycle callback arrays
-  _onAllReadyCallbacks = /* @__PURE__ */ new Set();
-  _onControllerJoinCallbacks = /* @__PURE__ */ new Set();
-  _onControllerLeaveCallbacks = /* @__PURE__ */ new Set();
-  _onControllerDisconnectCallbacks = /* @__PURE__ */ new Set();
-  _onControllerReconnectCallbacks = /* @__PURE__ */ new Set();
-  _onCharacterUpdatedCallbacks = /* @__PURE__ */ new Set();
-  _onRateLimitedCallbacks = /* @__PURE__ */ new Set();
-  _onErrorCallbacks = /* @__PURE__ */ new Set();
+  // Unified lifecycle listener map (supports both onXxx() and on('$xxx') patterns)
+  _lifecycleListeners = /* @__PURE__ */ new Map();
+  // Outbound message buffer (messages sent before ready)
+  _outboundBuffer = [];
   // Whether all-ready has fired
   _allReadyFired = false;
+  // Self-connection awareness
+  _isConnected = false;
+  // Protocol versioning
+  _protocolVersion = PROTOCOL_VERSION;
   // Ready promise
   _readyResolve;
   _readyReject;
@@ -50,8 +51,8 @@ class ControllerImpl {
   // ---------------------------------------------------------------------------
   // Properties (readonly)
   // ---------------------------------------------------------------------------
-  get myIndex() {
-    return this._myIndex;
+  get myPlayerIndex() {
+    return this._myPlayerIndex;
   }
   get roomCode() {
     return this._roomCode;
@@ -62,6 +63,12 @@ class ControllerImpl {
   get isDestroyed() {
     return this._isDestroyed;
   }
+  get isConnected() {
+    return this._isConnected;
+  }
+  get protocolVersion() {
+    return this._protocolVersion;
+  }
   /**
    * Read-only list of all known controllers (players) in the room.
    * Returns full ControllerInfo including playerIndex, nickname, connected status, and appearance.
@@ -72,12 +79,18 @@ class ControllerImpl {
   get controllers() {
     return [...this._controllers];
   }
+  get me() {
+    return this._controllers.find((c) => c.playerIndex === this._myPlayerIndex);
+  }
   /**
    * Returns the number of currently connected players.
    */
   getControllerCount() {
     return this._controllers.filter((c) => c.connected).length;
   }
+  getController(playerIndex) {
+    return this._controllers.find((c) => c.playerIndex === playerIndex);
+  }
   // ---------------------------------------------------------------------------
   // Initialization
   // ---------------------------------------------------------------------------
@@ -108,7 +121,7 @@ class ControllerImpl {
     };
     window.addEventListener("message", this.boundMessageHandler);
     this.logger.lifecycle("Sending _bridge:ready to parent");
-    window.parent.postMessage({ type: "_bridge:ready" }, parentOrigin);
+    window.parent.postMessage({ type: "_bridge:ready", protocolVersion: PROTOCOL_VERSION }, parentOrigin);
   }
   handleInit(msg, parentOrigin) {
     const initPayload = msg.payload;
@@ -147,28 +160,48 @@ class ControllerImpl {
       this._readyReject(error);
       return;
     }
-    this.transport = new PostMessageTransport(parentOrigin);
+    this.transport = this.config.transport ?? new PostMessageTransport(parentOrigin);
     this._roomCode = initData.roomCode;
-    this._myIndex = initData.myIndex;
+    const serverProtocolVersion = initData.protocolVersion;
+    if (serverProtocolVersion !== void 0) {
+      this._protocolVersion = serverProtocolVersion;
+      if (serverProtocolVersion !== PROTOCOL_VERSION) {
+        this.logger.warn(
+          `Protocol version mismatch: SDK v${PROTOCOL_VERSION}, server v${serverProtocolVersion}. Some features may not work correctly.`
+        );
+      }
+    }
+    this._myPlayerIndex = initData.myIndex;
     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._controllers = initPlayers.filter((p) => typeof p.playerIndex === "number").map((p, index) => mapPlayerDTO(p, index));
     this.setupEventHandlers();
     for (const { event, handler } of this._pendingHandlers) {
       this.setupUserEventHandler(event, handler);
     }
     this._pendingHandlers = [];
+    this._isConnected = true;
     this._isReady = true;
+    if (initData.gameInProgress && this.transport) {
+      this.logger.lifecycle("Game in progress detected, requesting state recovery");
+      this.transport.emit(SMORE_EVENTS.STATE_GET_ALL, {});
+    }
+    for (const buffered of this._outboundBuffer) {
+      try {
+        switch (buffered.method) {
+          case "send":
+            this.send(buffered.args[0], buffered.args[1]);
+            break;
+        }
+      } catch (err) {
+        this.handleError(err instanceof SmoreSDKError ? err : new SmoreSDKError("UNKNOWN", "Failed to flush buffered message"));
+      }
+    }
+    this._outboundBuffer = [];
     this.logger.lifecycle("Controller ready", {
       roomCode: this._roomCode,
-      myIndex: this._myIndex
+      myIndex: this._myPlayerIndex
     });
-    const autoReady = getGlobalConfig().autoReady ?? true;
-    if (autoReady) {
+    if (this.config.autoReady !== false) {
       this.logger.lifecycle("Auto-signaling ready (autoReady enabled)");
       this.signalReady();
     }
@@ -183,21 +216,16 @@ class ControllerImpl {
     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 newControllers = players.filter((p) => typeof p.playerIndex === "number").map((p, index) => mapPlayerDTO(p, index));
       const oldControllers = this._controllers;
       for (const nc of newControllers) {
         if (!oldControllers.some((oc) => oc.playerIndex === nc.playerIndex)) {
-          this._onControllerJoinCallbacks.forEach((cb) => cb(nc.playerIndex, nc));
+          this._emitLifecycle("$controller-join", nc.playerIndex, nc);
         }
       }
       for (const oc of oldControllers) {
         if (!newControllers.some((nc) => nc.playerIndex === oc.playerIndex)) {
-          this._onControllerLeaveCallbacks.forEach((cb) => cb(oc.playerIndex));
+          this._emitLifecycle("$controller-leave", oc.playerIndex);
         }
       }
       for (const nc of newControllers) {
@@ -205,11 +233,11 @@ class ControllerImpl {
         if (oc) {
           if (oc.connected && !nc.connected) {
             this.logger.debug("Player disconnected (via update)", { playerIndex: nc.playerIndex });
-            this._onControllerDisconnectCallbacks.forEach((cb) => cb(nc.playerIndex));
+            this._emitLifecycle("$controller-disconnect", nc.playerIndex);
           }
           if (!oc.connected && nc.connected) {
             this.logger.debug("Player reconnected (via update)", { playerIndex: nc.playerIndex });
-            this._onControllerReconnectCallbacks.forEach((cb) => cb(nc.playerIndex, nc));
+            this._emitLifecycle("$controller-reconnect", nc.playerIndex, nc);
           }
         }
       }
@@ -224,19 +252,10 @@ class ControllerImpl {
       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
-        };
+        const controllerInfo = playerInfo ? mapPlayerDTO(playerInfo, playerIndex) : mapPlayerDTO({ playerIndex, connected: true }, playerIndex);
         this._controllers = [...this._controllers, controllerInfo];
         this.logger.debug("Player joined", { playerIndex });
-        this._onControllerJoinCallbacks.forEach((cb) => cb(playerIndex, controllerInfo));
+        this._emitLifecycle("$controller-join", playerIndex, controllerInfo);
       }
     });
     this.registerHandler(SMORE_EVENTS.PLAYER_LEFT, (raw) => {
@@ -246,7 +265,7 @@ class ControllerImpl {
         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._onControllerLeaveCallbacks.forEach((cb) => cb(playerIndex));
+        this._emitLifecycle("$controller-leave", playerIndex);
       }
     });
     this.registerHandler(SMORE_EVENTS.PLAYER_DISCONNECTED, (raw) => {
@@ -258,7 +277,7 @@ class ControllerImpl {
           (c) => c.playerIndex === playerIndex ? { ...c, connected: false } : c
         );
         this.logger.debug("Player disconnected", { playerIndex });
-        this._onControllerDisconnectCallbacks.forEach((cb) => cb(playerIndex));
+        this._emitLifecycle("$controller-disconnect", playerIndex);
       }
     });
     this.registerHandler(SMORE_EVENTS.PLAYER_RECONNECTED, (raw) => {
@@ -266,21 +285,12 @@ class ControllerImpl {
       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
-        };
+        const controllerInfo = playerData ? mapPlayerDTO(playerData, playerIndex) : mapPlayerDTO({ playerIndex, connected: true }, playerIndex);
         this._controllers = this._controllers.map(
           (c) => c.playerIndex === playerIndex ? controllerInfo : c
         );
         this.logger.debug("Player reconnected", { playerIndex });
-        this._onControllerReconnectCallbacks.forEach((cb) => cb(playerIndex, controllerInfo));
+        this._emitLifecycle("$controller-reconnect", playerIndex, controllerInfo);
       }
     });
     this.registerHandler(SMORE_EVENTS.PLAYER_CHARACTER_UPDATED, (raw) => {
@@ -293,19 +303,75 @@ class ControllerImpl {
           (c) => c.playerIndex === pi ? { ...c, appearance } : c
         );
         this.logger.debug("Player character updated", { playerIndex: pi });
-        this._onCharacterUpdatedCallbacks.forEach((cb) => cb(pi, appearance ?? null));
+        this._emitLifecycle("$character-updated", pi, appearance ?? null);
       }
     });
     this.registerHandler(SMORE_EVENTS.RATE_LIMITED, (raw) => {
       const data = raw;
-      const event = data?.event ?? "unknown";
-      this.logger.warn(`Rate limited: ${event}`);
-      this._onRateLimitedCallbacks.forEach((cb) => cb(event));
+      const eventName = data?.event ?? "unknown";
+      this.handleError(
+        new SmoreSDKError("RATE_LIMITED", `Server rate-limited event: ${eventName}`, {
+          details: { event: eventName }
+        })
+      );
+    });
+    this.registerHandler(SMORE_EVENTS.GAME_OVER, (raw) => {
+      const data = raw;
+      this.logger.lifecycle("Game over", data?.results);
+      this._emitLifecycle("$game-over", data?.results);
     });
     this.registerHandler(SMORE_EVENTS.ALL_READY, () => {
       this.logger.lifecycle("All participants ready");
       this._allReadyFired = true;
-      this._onAllReadyCallbacks.forEach((cb) => cb());
+      this._emitLifecycle("$all-ready");
+    });
+    this.registerHandler(SMORE_EVENTS.SELF_DISCONNECTED, () => {
+      this._isConnected = false;
+      this.logger.lifecycle("Connection lost");
+      this._emitLifecycle("$connection-change", false);
+    });
+    this.registerHandler(SMORE_EVENTS.SELF_RECONNECTED, () => {
+      this._isConnected = true;
+      this.logger.lifecycle("Connection restored");
+      this._emitLifecycle("$connection-change", true);
+    });
+    this.registerHandler(SMORE_EVENTS.STATE_CHANGED, (raw) => {
+      const data = raw;
+      if (typeof data?.playerIndex === "number" && data.state) {
+        this._customStates.set(data.playerIndex, data.state);
+        this._stateChangeListeners.forEach((cb) => {
+          try {
+            cb(data.playerIndex, data.state);
+          } catch (err) {
+            this.handleError(
+              new SmoreSDKError("UNKNOWN", "Error in custom state change listener", {
+                cause: err instanceof Error ? err : void 0
+              })
+            );
+          }
+        });
+      }
+    });
+    this.registerHandler(SMORE_EVENTS.STATE_ALL, (raw) => {
+      const data = raw;
+      if (data?.states) {
+        for (const [key, value] of Object.entries(data.states)) {
+          const pi = Number(key);
+          this._customStates.set(pi, value);
+          this._stateChangeListeners.forEach((cb) => {
+            try {
+              cb(pi, value);
+            } catch (err) {
+              this.handleError(
+                new SmoreSDKError("UNKNOWN", "Error in custom state change listener", {
+                  cause: err instanceof Error ? err : void 0
+                })
+              );
+            }
+          });
+        }
+        this._emitLifecycle("$state-recovery", data.states);
+      }
     });
   }
   /**
@@ -344,57 +410,89 @@ class ControllerImpl {
     this.registeredHandlers.push({ event, handler });
   }
   // ---------------------------------------------------------------------------
+  // Lifecycle Listener Helpers
+  // ---------------------------------------------------------------------------
+  _addLifecycleListener(event, listener) {
+    let set = this._lifecycleListeners.get(event);
+    if (!set) {
+      set = /* @__PURE__ */ new Set();
+      this._lifecycleListeners.set(event, set);
+    }
+    set.add(listener);
+    return () => {
+      set.delete(listener);
+      if (set.size === 0) this._lifecycleListeners.delete(event);
+    };
+  }
+  _emitLifecycle(event, ...args) {
+    this._lifecycleListeners.get(event)?.forEach((cb) => {
+      try {
+        cb(...args);
+      } catch (err) {
+        this.handleError(
+          new SmoreSDKError("UNKNOWN", `Error in lifecycle handler for "${event}"`, {
+            cause: err instanceof Error ? err : void 0,
+            details: { event }
+          })
+        );
+      }
+    });
+  }
+  _hasLifecycleListeners(event) {
+    const set = this._lifecycleListeners.get(event);
+    return set !== void 0 && set.size > 0;
+  }
+  // ---------------------------------------------------------------------------
   // Lifecycle Methods
   // ---------------------------------------------------------------------------
   onAllReady(callback) {
     if (this._allReadyFired) {
       callback();
     }
-    this._onAllReadyCallbacks.add(callback);
-    return () => {
-      this._onAllReadyCallbacks.delete(callback);
-    };
+    return this._addLifecycleListener("$all-ready", callback);
   }
   onControllerJoin(callback) {
-    this._onControllerJoinCallbacks.add(callback);
-    return () => {
-      this._onControllerJoinCallbacks.delete(callback);
-    };
+    return this._addLifecycleListener("$controller-join", callback);
   }
   onControllerLeave(callback) {
-    this._onControllerLeaveCallbacks.add(callback);
-    return () => {
-      this._onControllerLeaveCallbacks.delete(callback);
-    };
+    return this._addLifecycleListener("$controller-leave", callback);
   }
   onControllerDisconnect(callback) {
-    this._onControllerDisconnectCallbacks.add(callback);
-    return () => {
-      this._onControllerDisconnectCallbacks.delete(callback);
-    };
+    return this._addLifecycleListener("$controller-disconnect", callback);
   }
   onControllerReconnect(callback) {
-    this._onControllerReconnectCallbacks.add(callback);
-    return () => {
-      this._onControllerReconnectCallbacks.delete(callback);
-    };
+    return this._addLifecycleListener("$controller-reconnect", callback);
   }
   onCharacterUpdated(callback) {
-    this._onCharacterUpdatedCallbacks.add(callback);
-    return () => {
-      this._onCharacterUpdatedCallbacks.delete(callback);
-    };
-  }
-  onRateLimited(callback) {
-    this._onRateLimitedCallbacks.add(callback);
-    return () => {
-      this._onRateLimitedCallbacks.delete(callback);
-    };
+    return this._addLifecycleListener("$character-updated", callback);
   }
   onError(callback) {
-    this._onErrorCallbacks.add(callback);
+    return this._addLifecycleListener("$error", callback);
+  }
+  onConnectionChange(callback) {
+    return this._addLifecycleListener("$connection-change", callback);
+  }
+  onGameOver(callback) {
+    return this._addLifecycleListener("$game-over", callback);
+  }
+  // ---------------------------------------------------------------------------
+  // Custom State Methods
+  // ---------------------------------------------------------------------------
+  setState(state) {
+    const current = this._customStates.get(this._myPlayerIndex) ?? {};
+    const merged = { ...current, ...state };
+    this._customStates.set(this._myPlayerIndex, merged);
+    if (this.transport) {
+      this.transport.emit(SMORE_EVENTS.STATE_SET, { state });
+    }
+  }
+  getMyState() {
+    return this._customStates.get(this._myPlayerIndex);
+  }
+  onCustomStateChange(listener) {
+    this._stateChangeListeners.add(listener);
     return () => {
-      this._onErrorCallbacks.delete(callback);
+      this._stateChangeListeners.delete(listener);
     };
   }
   // ---------------------------------------------------------------------------
@@ -411,8 +509,16 @@ class ControllerImpl {
    * Use the onError callback or smore:rate-limited event to detect rate limiting.
    */
   send(event, data) {
-    this.ensureReady("send");
+    if (this._isDestroyed) {
+      throw new SmoreSDKError("DESTROYED", "Cannot call send() after destroy()");
+    }
+    if (!this._isReady || !this.transport) {
+      this._outboundBuffer.push({ method: "send", args: [event, data] });
+      this.logger.debug(`Buffered send "${event}" (controller not ready yet)`);
+      return;
+    }
     validateEventName(event);
+    validatePayloadSize(data);
     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).'
@@ -421,12 +527,6 @@ class ControllerImpl {
     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);
-  }
   signalReady() {
     this.ensureReady("signalReady");
     this.logSend(SMORE_EVENTS.GAME_READY, {});
@@ -448,6 +548,16 @@ class ControllerImpl {
    *   handler receives `(data)` -- targeted to this specific controller.
    */
   on(event, handler) {
+    if (typeof event === "string" && event.startsWith("$")) {
+      const validEvents = CONTROLLER_LIFECYCLE_EVENTS;
+      if (!validEvents.has(event)) {
+        throw new SmoreSDKError("INVALID_EVENT", `Unknown lifecycle event: "${event}". Valid lifecycle events: ${Array.from(validEvents).join(", ")}`);
+      }
+      if (event === "$all-ready" && this._allReadyFired) {
+        handler();
+      }
+      return this._addLifecycleListener(event, handler);
+    }
     validateEventName(event);
     let listeners = this.eventListeners.get(event);
     if (!listeners) {
@@ -500,6 +610,23 @@ class ControllerImpl {
    * `off(event, originalHandler)`. Use the returned unsubscribe function instead.
    */
   once(event, handler) {
+    if (typeof event === "string" && event.startsWith("$")) {
+      const validEvents = CONTROLLER_LIFECYCLE_EVENTS;
+      if (!validEvents.has(event)) {
+        throw new SmoreSDKError("INVALID_EVENT", `Unknown lifecycle event: "${event}"`);
+      }
+      if (event === "$all-ready" && this._allReadyFired) {
+        handler();
+        return () => {
+        };
+      }
+      const wrapper = (...args) => {
+        unsub();
+        handler(...args);
+      };
+      const unsub = this._addLifecycleListener(event, wrapper);
+      return unsub;
+    }
     const unsubscribe = this.on(event, ((data) => {
       unsubscribe();
       handler(data);
@@ -507,6 +634,14 @@ class ControllerImpl {
     return unsubscribe;
   }
   off(event, handler) {
+    if (typeof event === "string" && event.startsWith("$")) {
+      if (!handler) {
+        this._lifecycleListeners.delete(event);
+      } else {
+        this._lifecycleListeners.get(event)?.delete(handler);
+      }
+      return;
+    }
     if (!handler) {
       this.eventListeners.delete(event);
       this.transport?.off(event);
@@ -534,6 +669,21 @@ class ControllerImpl {
       );
     }
   }
+  removeAllListeners(event) {
+    if (event) {
+      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);
+      }
+      this._pendingHandlers = this._pendingHandlers.filter((p) => p.event !== event);
+    } else {
+      for (const evt of [...this.eventListeners.keys()]) {
+        this.removeAllListeners(evt);
+      }
+    }
+  }
   // ---------------------------------------------------------------------------
   // Cleanup
   // ---------------------------------------------------------------------------
@@ -557,14 +707,11 @@ class ControllerImpl {
     this.eventListeners.clear();
     this.handlerToTransport.clear();
     this._pendingHandlers = [];
-    this._onAllReadyCallbacks.clear();
-    this._onControllerJoinCallbacks.clear();
-    this._onControllerLeaveCallbacks.clear();
-    this._onControllerDisconnectCallbacks.clear();
-    this._onControllerReconnectCallbacks.clear();
-    this._onCharacterUpdatedCallbacks.clear();
-    this._onRateLimitedCallbacks.clear();
-    this._onErrorCallbacks.clear();
+    this._lifecycleListeners.clear();
+    this._customStates.clear();
+    this._stateChangeListeners.clear();
+    this._isConnected = false;
+    this._outboundBuffer = [];
     if (this.transport) {
       this.transport.destroy();
       this.transport = null;
@@ -596,8 +743,8 @@ class ControllerImpl {
   handleError(error) {
     this.logger.warn(`Error in handler: ${error.message}`);
     const smoreError = error.toSmoreError();
-    if (this._onErrorCallbacks.size > 0) {
-      this._onErrorCallbacks.forEach((cb) => cb(smoreError));
+    if (this._hasLifecycleListeners("$error")) {
+      this._emitLifecycle("$error", smoreError);
     } else {
       this.logger.error(error.message, error.details);
     }