p2p-lockstep-kit-session 0.1.2 → 0.1.3

package/dist/session/index.js

@@ -0,0 +1,1198 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+
+// session/commandBus.ts
+var CommandBus = class {
+  constructor() {
+    __publicField(this, "handlers", {});
+    __publicField(this, "processingQueue", Promise.resolve());
+  }
+  emit(type, payload, from = "local") {
+    this.dispatch({ type, payload, from });
+  }
+  register(type, handler) {
+    this.handlers[type] = handler;
+  }
+  dispatch(message) {
+    this.processingQueue = this.processingQueue.then(async () => {
+      const handler = this.handlers[message.type];
+      if (handler) {
+        try {
+          await handler(message);
+        } catch (err) {
+          console.error(`[CommandBus] Error in ${message.type}:`, err);
+        }
+      }
+    });
+  }
+};
+
+// session/state/fsm.ts
+var transitions = [
+  // Lobby readiness
+  { from: "idle", event: "READY", to: "ready" },
+  { from: "ready", event: "READY", to: "idle" },
+  { from: "idle", event: "REMOTE_READY", to: "could_start" },
+  { from: "could_start", event: "REMOTE_READY", to: "idle" },
+  { from: "ready", event: "REJECT", to: "idle" },
+  { from: "could_start", event: "REJECT", to: "idle" },
+  // Match start / turn assignment
+  { from: "ready", event: "REMOTE_START", to: "turn" },
+  { from: "ready", event: "REMOTE_START", to: "remote_turn" },
+  { from: "could_start", event: "START", to: "turn" },
+  { from: "could_start", event: "START", to: "remote_turn" },
+  // Turn swapping after moves
+  { from: "turn", event: "MOVE", to: "remote_turn" },
+  { from: "remote_turn", event: "REMOTE_MOVE", to: "turn" },
+  { from: "turn", event: "REJECT", to: "turn" },
+  { from: "remote_turn", event: "REJECT", to: "remote_turn" },
+  // Requests initiated by local player (undo/restart)
+  { from: "turn", event: "UNDO", to: "waiting_approval" },
+  { from: "remote_turn", event: "UNDO", to: "waiting_approval" },
+  { from: "turn", event: "RESTART", to: "waiting_approval" },
+  { from: "remote_turn", event: "RESTART", to: "waiting_approval" },
+  // Requests coming from remote (we need to approve)
+  { from: "turn", event: "REMOTE_UNDO", to: "approving" },
+  { from: "remote_turn", event: "REMOTE_UNDO", to: "approving" },
+  { from: "turn", event: "REMOTE_RESTART", to: "approving" },
+  { from: "remote_turn", event: "REMOTE_RESTART", to: "approving" },
+  // Approval outcomes when we were waiting
+  { from: "waiting_approval", event: "APPROVE", to: "turn" },
+  { from: "waiting_approval", event: "REJECT", to: "turn" },
+  { from: "waiting_approval", event: "REJECT", to: "remote_turn" },
+  // Approval outcomes when we were confirming
+  { from: "approving", event: "APPROVE", to: "remote_turn" },
+  { from: "approving", event: "REJECT", to: "remote_turn" },
+  { from: "approving", event: "REJECT", to: "turn" },
+  // Game end resets back to lobby idle
+  { from: "turn", event: "GAME_OVER", to: "idle" },
+  { from: "remote_turn", event: "GAME_OVER", to: "idle" },
+  // Rejoin/sync flows
+  { from: "turn", event: "SYNC", to: "syncing" },
+  { from: "remote_turn", event: "SYNC", to: "syncing" },
+  { from: "waiting_approval", event: "SYNC", to: "syncing" },
+  { from: "approving", event: "SYNC", to: "syncing" },
+  { from: "idle", event: "SYNC", to: "syncing" },
+  { from: "ready", event: "SYNC", to: "syncing" },
+  { from: "could_start", event: "SYNC", to: "syncing" },
+  { from: "syncing", event: "SYNC_COMPLETE", to: "turn" },
+  { from: "syncing", event: "SYNC_COMPLETE", to: "remote_turn" },
+  // Connection state
+  { from: "idle", event: "OFFLINE", to: "offline" },
+  { from: "ready", event: "OFFLINE", to: "offline" },
+  { from: "could_start", event: "OFFLINE", to: "offline" },
+  { from: "turn", event: "OFFLINE", to: "offline" },
+  { from: "remote_turn", event: "OFFLINE", to: "offline" },
+  { from: "waiting_approval", event: "OFFLINE", to: "offline" },
+  { from: "approving", event: "OFFLINE", to: "offline" },
+  { from: "syncing", event: "OFFLINE", to: "offline" },
+  { from: "offline", event: "ONLINE", to: "syncing" }
+];
+var nextState = (state, event, to) => {
+  if (to) {
+    if (!!transitions.find(
+      (t) => t.from === state && t.event === event && t.to === to
+    )) {
+      return to;
+    } else {
+      return state;
+    }
+  } else {
+    const hit = transitions.find((t) => t.from === state && t.event === event);
+    return hit ? hit.to : state;
+  }
+};
+var hasNextState = (state, action, to) => {
+  if (to) {
+    return !!transitions.find(
+      (t) => t.from === state && t.event === action && t.to === to
+    );
+  }
+  return !!transitions.find((t) => t.from === state && t.event === action);
+};
+var SessionFsm = class {
+  constructor(state = "idle") {
+    __publicField(this, "state");
+    this.state = state;
+  }
+  getState() {
+    return this.state;
+  }
+  hasNextState(event, to) {
+    return hasNextState(this.state, event, to);
+  }
+  dispatch(action, to) {
+    this.state = nextState(this.state, action, to);
+  }
+};
+
+// session/observer/index.ts
+var DefaultGamePlugin = class {
+  validateMove() {
+    return { valid: true };
+  }
+  checkWin() {
+    return null;
+  }
+};
+var StateObserverManager = class {
+  constructor() {
+    __publicField(this, "observers", /* @__PURE__ */ new Set());
+  }
+  subscribe(observer) {
+    this.observers.add(observer);
+  }
+  unsubscribe(observer) {
+    this.observers.delete(observer);
+  }
+  notifyStateChanged() {
+    for (const observer of this.observers) {
+      try {
+        observer.onStateChanged?.();
+      } catch (err) {
+        console.error("[StateObserver]", err);
+      }
+    }
+  }
+  notifyHistoryChanged() {
+    for (const observer of this.observers) {
+      try {
+        observer.onHistoryChanged?.();
+      } catch (err) {
+        console.error("[StateObserver]", err);
+      }
+    }
+  }
+  notifyGameReset() {
+    for (const observer of this.observers) {
+      try {
+        observer.onGameReset?.();
+      } catch (err) {
+        console.error("[StateObserver]", err);
+      }
+    }
+  }
+};
+var GameStateObserver = class {
+  constructor() {
+    __publicField(this, "observers", /* @__PURE__ */ new Set());
+    __publicField(this, "currentSnapshot", null);
+  }
+  subscribe(observer) {
+    this.observers.add(observer);
+    return () => {
+      this.observers.delete(observer);
+    };
+  }
+  unsubscribe(observer) {
+    this.observers.delete(observer);
+  }
+  notifyStateChange(snapshot) {
+    this.currentSnapshot = snapshot;
+    for (const observer of this.observers) {
+      try {
+        observer.onStateChange(snapshot);
+      } catch (err) {
+        console.error("[GameStateObserver]", err);
+      }
+    }
+  }
+  notifyGameEvent(event) {
+    event.timestamp = Date.now();
+    for (const observer of this.observers) {
+      try {
+        observer.onGameEvent(event);
+      } catch (err) {
+        console.error("[GameStateObserver]", err);
+      }
+    }
+  }
+  notifyConnectionChange(connected) {
+    for (const observer of this.observers) {
+      try {
+        observer.onConnectionChange?.(connected);
+      } catch (err) {
+        console.error("[GameStateObserver]", err);
+      }
+    }
+  }
+  notifyError(error) {
+    for (const observer of this.observers) {
+      try {
+        observer.onError?.(error);
+      } catch (err) {
+        console.error("[GameStateObserver]", err);
+      }
+    }
+  }
+  getSnapshot() {
+    return this.currentSnapshot;
+  }
+  getObserverCount() {
+    return this.observers.size;
+  }
+};
+function buildGameStateSnapshot(state, connected = false) {
+  return {
+    localState: state.getState("local"),
+    remoteState: state.getState("remote"),
+    turn: state.getTurnCount(),
+    history: state.getHistory(),
+    lastStart: state.getLastStart(),
+    pendingAction: state.getPendingAction(),
+    connected
+  };
+}
+var UINotificationAdapter = class {
+  constructor(stateRef, uiObserver) {
+    __publicField(this, "stateRef", stateRef);
+    __publicField(this, "uiObserver", uiObserver);
+    __publicField(this, "lastNotificationTime", 0);
+    __publicField(this, "notificationThrottleMs", 0);
+  }
+  onStateChanged() {
+    const now = Date.now();
+    if (this.lastNotificationTime + this.notificationThrottleMs > now) return;
+    this.lastNotificationTime = now;
+    const snapshot = buildGameStateSnapshot(this.stateRef);
+    this.uiObserver.notifyStateChange(snapshot);
+  }
+  onHistoryChanged() {
+  }
+  onGameReset() {
+  }
+  emitEvent(event) {
+    this.uiObserver.notifyGameEvent(event);
+  }
+};
+
+// session/state/state.ts
+var State = class {
+  constructor(id, remoteId) {
+    // will update map when multi-players (>=3)
+    __publicField(this, "local", new SessionFsm("idle"));
+    __publicField(this, "remote", new SessionFsm("idle"));
+    // for compare remote is same people or not
+    __publicField(this, "localId", null);
+    __publicField(this, "remoteId", null);
+    // store all actions
+    __publicField(this, "history", []);
+    // pending some state
+    __publicField(this, "pendingAction", null);
+    __publicField(this, "pendingUndoCount", null);
+    __publicField(this, "resumeTurn", null);
+    __publicField(this, "lastStart", null);
+    // Game plugin for rule validation and win checking
+    __publicField(this, "gamePlugin", new DefaultGamePlugin());
+    // Internal state observer for UI notifications
+    __publicField(this, "stateObserverManager", new StateObserverManager());
+    // ===== Helper Methods for Undo/Restart Request Handling =====
+    /**
+     * Save game state snapshot for undo/restart operations
+     */
+    __publicField(this, "gameSnapshot", null);
+    if (id) {
+      this.localId = id;
+    }
+    if (remoteId) {
+      this.remoteId = remoteId;
+    }
+  }
+  /**
+   * Register an internal observer (like plugin pattern)
+   * Use this to connect State mutations to UI updates
+   */
+  subscribeStateObserver(observer) {
+    this.stateObserverManager.subscribe(observer);
+  }
+  // ...existing code...
+  getId() {
+    return this.localId;
+  }
+  getremoteId() {
+    return this.remoteId;
+  }
+  setremoteId(id) {
+    this.remoteId = id;
+  }
+  getState(player) {
+    return this.getPlayerFsm(player).getState();
+  }
+  getTurnCount() {
+    return this.history.length + 1;
+  }
+  getHistory() {
+    return this.history.slice();
+  }
+  replaceHistory(entries) {
+    this.clearHistory();
+    entries.forEach((entry) => {
+      this.pushHistory({
+        turn: entry.turn,
+        player: entry.player,
+        move: entry.move
+      });
+    });
+  }
+  clearHistory() {
+    this.history.splice(0, this.history.length);
+    this.stateObserverManager.notifyHistoryChanged();
+  }
+  pushHistory(entry) {
+    this.history.push(entry);
+    this.stateObserverManager.notifyHistoryChanged();
+  }
+  popHistory() {
+    return this.history.pop() ?? null;
+  }
+  canAction(player, action) {
+    return this.getPlayerFsm(player).hasNextState(action);
+  }
+  /**
+   * Dispatch an action and automatically determine target state if unique
+   * Only use explicit 'to' parameter for ambiguous transitions (APPROVE, REJECT, etc.)
+   *
+   * For most actions (READY, MOVE, START, etc.), there's only one valid transition,
+   * so we automatically find and apply it.
+   */
+  dispatch(player, action, to) {
+    this.getPlayerFsm(player).dispatch(action, to);
+    this.stateObserverManager.notifyStateChanged();
+  }
+  setPendingAction(action) {
+    this.pendingAction = action;
+  }
+  getPendingAction() {
+    return this.pendingAction;
+  }
+  setPendingUndoCount(count) {
+    this.pendingUndoCount = count;
+  }
+  getPendingUndoCount() {
+    return this.pendingUndoCount;
+  }
+  setLastStart(player) {
+    this.lastStart = player;
+  }
+  getLastStart() {
+    return this.lastStart;
+  }
+  setResumeTurn(player) {
+    this.resumeTurn = player;
+  }
+  getResumeTurn() {
+    return this.resumeTurn;
+  }
+  getPlayerFsm(player) {
+    return player === "local" ? this.local : this.remote;
+  }
+  saveGameSnapshot(snapshot) {
+    this.gameSnapshot = snapshot;
+  }
+  getGameSnapshot() {
+    return this.gameSnapshot;
+  }
+  clearGameSnapshot() {
+    this.gameSnapshot = null;
+  }
+  /**
+   * Check if there's a pending action (undo/restart)
+   */
+  hasPendingAction() {
+    return this.pendingAction !== null;
+  }
+  /**
+   * Clear all pending states (called after approval/rejection)
+   */
+  clearPendingStates() {
+    this.pendingAction = null;
+    this.pendingUndoCount = null;
+    this.resumeTurn = null;
+  }
+  /**
+   * Initialize undo request with undo count and current turn holder
+   */
+  initializeUndoRequest(undoCount, resumeTurn) {
+    this.pendingAction = "undo";
+    this.pendingUndoCount = undoCount;
+    this.resumeTurn = resumeTurn;
+  }
+  /**
+   * Initialize restart request with resume turn
+   */
+  initializeRestartRequest(resumeTurn) {
+    this.pendingAction = "restart";
+    this.resumeTurn = resumeTurn;
+  }
+  /**
+   * Check if pending action is undo
+   */
+  isPendingUndo() {
+    return this.pendingAction === "undo";
+  }
+  /**
+   * Check if pending action is restart
+   */
+  isPendingRestart() {
+    return this.pendingAction === "restart";
+  }
+  /**
+   * Apply undo by popping history N times
+   */
+  applyUndo(count = 1) {
+    for (let i = 0; i < count; i++) {
+      this.popHistory();
+    }
+  }
+  /**
+   * Reset game state to initial (for restart)
+   */
+  resetGame() {
+    this.clearHistory();
+    this.local = new SessionFsm("idle");
+    this.remote = new SessionFsm("idle");
+    this.lastStart = null;
+    this.resumeTurn = null;
+    this.stateObserverManager.notifyGameReset();
+  }
+  /**
+   * Save start player for rejoin flow
+   */
+  recordStartPlayer(player) {
+    this.lastStart = player;
+  }
+  /**
+   * Get move to undo from history
+   */
+  getLastMove() {
+    return this.history.length > 0 ? this.history[this.history.length - 1] : null;
+  }
+  // ===== Specialized FSM Dispatch Methods =====
+  /**
+   * Dispatch APPROVE action with automatic target state resolution
+   * Multiple valid transitions exist - use state context to determine target
+   */
+  dispatchApprove() {
+    const localState = this.local.getState();
+    if (localState === "waiting_approval") {
+      this.local.dispatch("APPROVE", "turn");
+      this.remote.dispatch("APPROVE", "turn");
+    } else if (localState === "approving") {
+      this.local.dispatch("APPROVE", "remote_turn");
+      this.remote.dispatch("APPROVE", "remote_turn");
+    }
+  }
+  /**
+   * Dispatch REJECT action with automatic target state resolution
+   * Multiple valid transitions exist - use resumeTurn to determine who continues
+   */
+  dispatchReject() {
+    const localState = this.local.getState();
+    if (localState === "waiting_approval" || localState === "approving") {
+      const targetState = this.resumeTurn === "local" ? "turn" : "remote_turn";
+      this.local.dispatch("REJECT", targetState);
+      this.remote.dispatch("REJECT", targetState);
+    }
+  }
+  /**
+   * Dispatch START action with automatic target state resolution
+   * Determines who plays first based on starter parameter
+   */
+  dispatchStart(firstPlayer) {
+    if (firstPlayer === "local") {
+      this.local.dispatch("START", "turn");
+      this.remote.dispatch("START", "remote_turn");
+      this.lastStart = "local";
+    } else {
+      this.local.dispatch("START", "remote_turn");
+      this.remote.dispatch("START", "turn");
+      this.lastStart = "remote";
+    }
+  }
+  /**
+   * Dispatch SYNC_COMPLETE with automatic target state resolution
+   * Based on who should have the turn after sync
+   */
+  dispatchSyncComplete(nextPlayer) {
+    if (nextPlayer === "local") {
+      this.local.dispatch("SYNC_COMPLETE", "turn");
+      this.remote.dispatch("SYNC_COMPLETE", "remote_turn");
+    } else {
+      this.local.dispatch("SYNC_COMPLETE", "remote_turn");
+      this.remote.dispatch("SYNC_COMPLETE", "turn");
+    }
+    this.resumeTurn = nextPlayer;
+  }
+  // ===== Game Plugin Integration (Proxy Pattern) =====
+  /**
+   * Set the game plugin for rule validation and win checking
+   * @param plugin Implementation of IGamePlugin
+   */
+  setGamePlugin(plugin) {
+    this.gamePlugin = plugin;
+    if (plugin.initialize) {
+      plugin.initialize();
+    }
+  }
+  /**
+   * Get current game plugin
+   */
+  getGamePlugin() {
+    return this.gamePlugin;
+  }
+  /**
+   * Validate a move using the game plugin
+   * Called by move handler to check if move is legal
+   * @param move The move data to validate
+   * @returns Validation result with reason if invalid
+   */
+  validateMove(move2) {
+    const gameState = this.buildGameState();
+    return this.gamePlugin.validateMove(move2, gameState);
+  }
+  /**
+   * Check if game has ended (someone won)
+   * Called by move handler after move is applied
+   * @returns Winner (local/remote) or null if game continues
+   */
+  checkWin() {
+    const gameState = this.buildGameState();
+    return this.gamePlugin.checkWin(gameState, this.getHistory());
+  }
+  /**
+   * Cleanup when game ends (for plugin to reset internal state)
+   */
+  cleanupGame() {
+    if (this.gamePlugin.cleanup) {
+      this.gamePlugin.cleanup();
+    }
+  }
+  /**
+   * Build game state for plugin
+   * @private
+   */
+  buildGameState() {
+    return {
+      history: this.getHistory(),
+      localState: this.getState("local"),
+      remoteState: this.getState("remote"),
+      turn: this.getTurnCount(),
+      lastStart: this.getLastStart()
+    };
+  }
+};
+
+// session/net.ts
+var NetClient = class {
+  constructor(client, bus, peerId) {
+    __publicField(this, "client", client);
+    __publicField(this, "bus", bus);
+    __publicField(this, "localPeerId");
+    __publicField(this, "remotePeerId");
+    __publicField(this, "isConnected", false);
+    __publicField(this, "connectionChangeListener", () => {
+    });
+    __publicField(this, "mediaStateListener", () => {
+    });
+    this.localPeerId = peerId ?? null;
+    this.remotePeerId = null;
+    this.client.onMessage((data) => {
+      const message = data;
+      if (!message || typeof message !== "object" || !message.type) {
+        return;
+      }
+      this.bus.emit(
+        message.type,
+        message,
+        "remote"
+      );
+    });
+    this.client.onStateChange((state) => {
+      const wasConnected = this.isConnected;
+      this.isConnected = state === "connected";
+      this.connectionChangeListener(this.isConnected);
+      if (this.isConnected && !wasConnected) {
+        this.bus.emit("ONLINE", void 0, "local");
+      } else if (!this.isConnected && wasConnected) {
+        this.bus.emit("OFFLINE", void 0, "local");
+      }
+    });
+    this.client.onRemoteStream((stream) => {
+      const active = !!stream && stream.getTracks().some((track) => track.readyState === "live");
+      this.mediaStateListener(active);
+    });
+  }
+  /**
+   * Send a message to the remote peer
+   * Drops message if not connected and logs warning
+   */
+  send(message) {
+    if (!this.isConnected) {
+      console.warn(
+        "[NetClient] Cannot send message: not connected",
+        message.type
+      );
+      return;
+    }
+    const enriched = {
+      ...message,
+      from: message.from ?? this.localPeerId ?? ""
+    };
+    this.client.send(JSON.stringify(enriched));
+  }
+  /**
+   * Update local and remote peer IDs
+   */
+  setPeerIds(ids) {
+    if (ids.local !== void 0) {
+      this.localPeerId = ids.local;
+    }
+    if (ids.remote !== void 0) {
+      this.remotePeerId = ids.remote;
+    }
+  }
+  /**
+   * Get current peer IDs
+   */
+  getPeerIds() {
+    return { local: this.localPeerId, remote: this.remotePeerId };
+  }
+  /**
+   * Check if currently connected to peer
+   */
+  getIsConnected() {
+    return this.isConnected;
+  }
+  /**
+   * Monitor connection state changes
+   * @param handler Called when connection state changes (true=connected, false=disconnected)
+   */
+  onConnectionChange(handler) {
+    this.connectionChangeListener = handler;
+    handler(this.isConnected);
+  }
+  /**
+   * Monitor remote media stream state changes
+   * @param handler Called when remote media becomes available or unavailable
+   */
+  onMediaStateChange(handler) {
+    this.mediaStateListener = handler;
+  }
+};
+var createNetClient = (client, bus, peerId) => new NetClient(client, bus, peerId);
+
+// session/context.ts
+var SessionContext = class {
+  constructor(state, bus, net, sid) {
+    __publicField(this, "state");
+    __publicField(this, "bus");
+    __publicField(this, "net");
+    __publicField(this, "sid");
+    this.state = state;
+    this.bus = bus;
+    this.net = net;
+    this.sid = sid;
+  }
+  getState() {
+    return this.state;
+  }
+  getBus() {
+    return this.bus;
+  }
+  getNet() {
+    return this.net;
+  }
+  getSid() {
+    return this.sid;
+  }
+};
+var instance = null;
+var initializeContext = (state, bus, net, sid) => {
+  instance = new SessionContext(state, bus, net, sid);
+};
+var requireContext = () => {
+  if (!instance) {
+    throw new Error(
+      "[SessionContext] Not initialized. Call initializeContext() first."
+    );
+  }
+  return instance;
+};
+var getState = () => requireContext().getState();
+var getBus = () => requireContext().getBus();
+var getSid = () => requireContext().getSid();
+var send = (message) => requireContext().getNet().send(message);
+
+// session/handlers/ready.ts
+var ready = (command) => {
+  const state = getState();
+  const bus = getBus();
+  const localSid = getSid();
+  if (command.from === "local") {
+    if (!state.canAction("local", "READY")) {
+      console.warn("[Ready] Cannot dispatch READY from current state", {
+        state: state.getState("local")
+      });
+      return;
+    }
+    state.dispatch("local", "READY");
+    state.dispatch("remote", "REMOTE_READY");
+    const message = {
+      type: "READY",
+      sid: localSid
+    };
+    send(message);
+    return;
+  }
+  const remoteSid = command.sid;
+  if (!remoteSid || localSid !== remoteSid) {
+    console.warn("[Ready] Session ID mismatch", {
+      local: localSid,
+      remote: remoteSid
+    });
+    bus.emit("REJECT", { reason: "sid-mismatch" }, "local");
+    return;
+  }
+  if (!state.canAction("remote", "READY")) {
+    console.warn("[Ready] Cannot dispatch READY for remote peer", {
+      state: state.getState("remote")
+    });
+    return;
+  }
+  state.dispatch("remote", "READY");
+  state.dispatch("local", "REMOTE_READY");
+};
+
+// session/handlers/start.ts
+var getNextStarter = (lastStarter) => {
+  if (!lastStarter) {
+    return Math.random() < 0.5 ? "local" : "remote";
+  }
+  return lastStarter === "local" ? "remote" : "local";
+};
+var start = (command) => {
+  const state = getState();
+  if (command.from === "local") {
+    if (!state.canAction("local", "START")) {
+      console.warn("[Start] Cannot START from current state", {
+        state: state.getState("local")
+      });
+      return;
+    }
+    const nextStarter = getNextStarter(state.getLastStart());
+    state.dispatchStart(nextStarter);
+    send({
+      type: "START",
+      payload: { starter: nextStarter === "local" ? "sender" : "receiver" }
+    });
+    return;
+  }
+  const starterInfo = command.payload?.starter;
+  if (!starterInfo) {
+    console.warn("[Start] Invalid START message format", { payload: command });
+    return;
+  }
+  if (!state.canAction("local", "REMOTE_START")) {
+    console.warn("[Start] Cannot START from current state", {
+      state: state.getState("local")
+    });
+    return;
+  }
+  const starter = starterInfo === "sender" ? "local" : "remote";
+  state.dispatchStart(starter);
+};
+
+// session/handlers/move.ts
+var move = (command) => {
+  const state = getState();
+  const bus = getBus();
+  const movePayload = command.payload;
+  if (command.from === "local") {
+    if (!state.canAction("local", "MOVE")) {
+      console.warn("[Move] Cannot MOVE from current state", {
+        state: state.getState("local")
+      });
+      return;
+    }
+    const validation2 = state.validateMove(movePayload);
+    if (!validation2.valid) {
+      console.warn("[Move] Move validation failed", {
+        reason: validation2.reason,
+        move: movePayload
+      });
+      return;
+    }
+    state.dispatch("local", "MOVE");
+    state.dispatch("remote", "REMOTE_MOVE");
+    const turn2 = state.getTurnCount();
+    state.pushHistory({
+      turn: turn2,
+      player: "local",
+      move: movePayload
+    });
+    const winner2 = state.checkWin();
+    if (winner2) {
+      console.log("[Move] Game over, winner:", winner2);
+      bus.emit("GAME_OVER", { winner: winner2, turn: turn2 }, "local");
+      send({
+        type: "GAME_OVER",
+        payload: { winner: winner2, turn: turn2 }
+      });
+      state.dispatch("local", "GAME_OVER");
+      state.dispatch("remote", "GAME_OVER");
+      state.cleanupGame();
+      return;
+    }
+    const message = {
+      type: "MOVE",
+      turn: turn2,
+      payload: movePayload
+    };
+    send(message);
+    return;
+  }
+  if (!state.canAction("remote", "MOVE")) {
+    console.warn("[Move] Cannot MOVE for remote player", {
+      state: state.getState("remote")
+    });
+    return;
+  }
+  const validation = state.validateMove(movePayload);
+  if (!validation.valid) {
+    console.warn("[Move] Remote move validation failed", {
+      reason: validation.reason,
+      move: movePayload
+    });
+    return;
+  }
+  state.dispatch("remote", "MOVE");
+  state.dispatch("local", "REMOTE_MOVE");
+  const turn = state.getTurnCount();
+  state.pushHistory({
+    turn,
+    player: "remote",
+    move: movePayload
+  });
+  const winner = state.checkWin();
+  if (winner) {
+    console.log("[Move] Game over, winner:", winner);
+    bus.emit("GAME_OVER", { winner, turn }, "local");
+    state.dispatch("local", "GAME_OVER");
+    state.dispatch("remote", "GAME_OVER");
+    state.cleanupGame();
+  }
+};
+
+// session/handlers/request.ts
+var request = (command) => {
+  if (command.type !== "APPROVE" && command.type !== "REJECT") {
+    return;
+  }
+  const state = getState();
+  const action = state.getPendingAction();
+  if (!action) {
+    console.warn("[Request] No pending action", { commandType: command.type });
+    return;
+  }
+  const payload = command.payload;
+  if (payload?.action && payload.action !== action) {
+    console.warn("[Request] Action mismatch", { pending: action, payload: payload.action });
+    return;
+  }
+  if (command.from === "local") {
+    if (command.type === "APPROVE") {
+      if (!state.canAction("local", "APPROVE")) {
+        console.warn("[Request] Cannot APPROVE from current state");
+        return;
+      }
+      state.dispatchApprove();
+      if (action === "undo") {
+        state.applyUndo(state.getPendingUndoCount() ?? 1);
+      } else if (action === "restart") {
+        state.resetGame();
+      }
+      send({ type: "APPROVE", payload: { action } });
+      state.clearPendingStates();
+      return;
+    }
+    if (!state.canAction("local", "REJECT")) {
+      console.warn("[Request] Cannot REJECT from current state");
+      return;
+    }
+    state.dispatchReject();
+    send({
+      type: "REJECT",
+      payload: { action, reason: payload?.reason ?? "rejected" }
+    });
+    state.clearPendingStates();
+    return;
+  }
+  if (command.type === "APPROVE") {
+    if (!state.canAction("local", "APPROVE")) {
+      console.warn("[Request] Cannot APPROVE from current state (remote approved)");
+      return;
+    }
+    state.dispatchApprove();
+    if (action === "undo") {
+      state.applyUndo(state.getPendingUndoCount() ?? 1);
+    } else if (action === "restart") {
+      state.resetGame();
+    }
+    state.clearPendingStates();
+    return;
+  }
+  if (!state.canAction("local", "REJECT")) {
+    console.warn("[Request] Cannot REJECT from current state (remote rejected)");
+    state.clearPendingStates();
+    return;
+  }
+  state.dispatchReject();
+  state.clearPendingStates();
+};
+
+// session/handlers/sync.ts
+var sync = (command) => {
+  const state = getState();
+  if (command.type === "SYNC_REQUEST") {
+    if (command.from === "local") {
+      if (!state.canAction("local", "SYNC")) {
+        console.warn("[Sync] Cannot SYNC from current state");
+        return;
+      }
+      state.dispatch("local", "SYNC", "syncing");
+      state.dispatch("remote", "SYNC", "syncing");
+      send({ type: "SYNC_REQUEST", from: "", payload: command.payload });
+      return;
+    }
+    const payload2 = {
+      history: state.getHistory(),
+      lastStart: state.getLastStart(),
+      turn: state.getState("local") === "turn" ? "local" : "remote",
+      resumeTurn: state.getResumeTurn()
+      // Send back the saved resume turn
+    };
+    send({ type: "SYNC_STATE", from: "", payload: payload2 });
+    return;
+  }
+  if (command.type !== "SYNC_STATE") {
+    return;
+  }
+  const payload = command.payload || {};
+  if (payload.history && payload.history.length > 0) {
+    state.replaceHistory(payload.history);
+  } else {
+    state.clearHistory();
+  }
+  if (payload.lastStart) {
+    state.setLastStart(payload.lastStart);
+  } else {
+    state.setLastStart(null);
+  }
+  let nextPlayer;
+  if (payload.resumeTurn) {
+    nextPlayer = payload.resumeTurn;
+  } else if (payload.turn) {
+    nextPlayer = payload.turn === "local" ? "local" : "remote";
+  } else {
+    nextPlayer = state.getState("local") === "turn" ? "local" : "remote";
+  }
+  console.log("[Sync] Restored game state", {
+    historyLength: state.getHistory().length,
+    lastStart: state.getLastStart(),
+    nextTurnPlayer: nextPlayer
+  });
+  state.dispatchSyncComplete(nextPlayer);
+};
+
+// session/handlers/undo.ts
+var undo = (command) => {
+  if (command.type !== "UNDO") {
+    return;
+  }
+  const state = getState();
+  if (command.from === "local") {
+    if (state.hasPendingAction()) {
+      return;
+    }
+    if (!state.canAction("local", "UNDO")) {
+      console.warn("[Undo] Cannot UNDO from current state");
+      return;
+    }
+    const localState = state.getState("local");
+    const undoCount = localState === "turn" ? 1 : 2;
+    if (state.getHistory().length < undoCount) {
+      console.warn("[Undo] Not enough history to undo", { count: undoCount });
+      return;
+    }
+    state.initializeUndoRequest(undoCount, "local");
+    state.dispatch("local", "UNDO");
+    state.dispatch("remote", "REMOTE_UNDO");
+    send({ type: "UNDO", payload: { count: undoCount } });
+    return;
+  }
+  if (state.hasPendingAction()) {
+    send({ type: "REJECT", payload: { action: "undo", reason: "busy" } });
+    return;
+  }
+  if (!state.canAction("local", "REMOTE_UNDO")) {
+    console.warn("[Undo] Cannot accept remote UNDO request");
+    send({ type: "REJECT", payload: { action: "undo", reason: "invalid_state" } });
+    return;
+  }
+  const payload = command.payload;
+  const count = payload?.count === 2 ? 2 : 1;
+  if (payload?.count && payload.count !== 1 && payload.count !== 2) {
+    send({ type: "REJECT", payload: { action: "undo", reason: "invalid" } });
+    return;
+  }
+  if (count === 2 && state.getHistory().length < 2) {
+    send({ type: "REJECT", payload: { action: "undo", reason: "no_history" } });
+    return;
+  }
+  const resumePlayer = state.getState("local") === "turn" ? "local" : "remote";
+  state.initializeUndoRequest(count, resumePlayer);
+  state.dispatch("local", "REMOTE_UNDO");
+  state.dispatch("remote", "UNDO");
+};
+
+// session/handlers/restart.ts
+var restart = (command) => {
+  if (command.type !== "RESTART") {
+    return;
+  }
+  const state = getState();
+  if (command.from === "local") {
+    if (state.hasPendingAction()) {
+      return;
+    }
+    if (!state.canAction("local", "RESTART")) {
+      console.warn("[Restart] Cannot RESTART from current state");
+      return;
+    }
+    const resumePlayer2 = state.getState("local") === "turn" ? "local" : "remote";
+    state.initializeRestartRequest(resumePlayer2);
+    state.dispatch("local", "RESTART");
+    state.dispatch("remote", "REMOTE_RESTART");
+    send({ type: "RESTART" });
+    return;
+  }
+  if (state.hasPendingAction()) {
+    send({ type: "REJECT", payload: { action: "restart", reason: "busy" } });
+    return;
+  }
+  if (!state.canAction("local", "REMOTE_RESTART")) {
+    console.warn("[Restart] Cannot accept remote RESTART request");
+    send({ type: "REJECT", payload: { action: "restart", reason: "invalid_state" } });
+    return;
+  }
+  const resumePlayer = state.getState("local") === "turn" ? "local" : "remote";
+  state.initializeRestartRequest(resumePlayer);
+  state.dispatch("local", "REMOTE_RESTART");
+  state.dispatch("remote", "RESTART");
+};
+
+// session/handlers/offLine.ts
+var offline = (command) => {
+  if (command.type !== "OFFLINE" && command.type !== "ONLINE") {
+    return;
+  }
+  const state = getState();
+  const bus = getBus();
+  if (command.type === "OFFLINE") {
+    if (!state.canAction("remote", "OFFLINE")) {
+      console.warn("[Offline] Cannot transition to OFFLINE from current state");
+      return;
+    }
+    const currentTurn = state.getState("local") === "turn" ? "local" : "remote";
+    state.setResumeTurn(currentTurn);
+    state.dispatch("remote", "OFFLINE", "offline");
+    return;
+  }
+  if (!state.canAction("remote", "ONLINE")) {
+    console.warn("[Offline] Cannot transition to ONLINE from current state");
+    return;
+  }
+  state.dispatch("remote", "ONLINE", "syncing");
+  bus.emit("SYNC_REQUEST", void 0, "local");
+};
+
+// session/handlers/busRegister.ts
+var registerHandlers = (bus) => {
+  bus.register("READY", ready);
+  bus.register("START", start);
+  bus.register("MOVE", move);
+  bus.register("UNDO", undo);
+  bus.register("RESTART", restart);
+  bus.register("SYNC_REQUEST", sync);
+  bus.register("SYNC_STATE", sync);
+  bus.register("OFFLINE", offline);
+  bus.register("ONLINE", offline);
+  bus.register("APPROVE", request);
+  bus.register("REJECT", request);
+};
+
+// session/actions.ts
+var LocalActionsAPI = class {
+  constructor(bus) {
+    __publicField(this, "bus", bus);
+  }
+  ready() {
+    this.bus.emit("READY");
+  }
+  start() {
+    this.bus.emit("START");
+  }
+  move(data) {
+    this.bus.emit("MOVE", data);
+  }
+  undo() {
+    this.bus.emit("UNDO");
+  }
+  restart() {
+    this.bus.emit("RESTART");
+  }
+  approve() {
+    this.bus.emit("APPROVE");
+  }
+  reject() {
+    this.bus.emit("REJECT");
+  }
+  rejoin(sid) {
+    this.bus.emit("REJOIN", { sid });
+  }
+};
+
+// session/index.ts
+var createSession = (networkClient, sid) => {
+  const bus = new CommandBus();
+  const state = new State(null, null);
+  const observer = new GameStateObserver();
+  const net = createNetClient(networkClient, bus, null);
+  const uiAdapter = new UINotificationAdapter(state, observer);
+  state.subscribeStateObserver(uiAdapter);
+  initializeContext(state, bus, net, sid);
+  registerHandlers(bus);
+  const actions = new LocalActionsAPI(bus);
+  net.onConnectionChange((isConnected) => {
+    bus.emit(isConnected ? "ONLINE" : "OFFLINE");
+    observer.notifyConnectionChange(isConnected);
+  });
+  return {
+    bus,
+    state,
+    observer,
+    net,
+    actions,
+    send: net.send.bind(net)
+  };
+};
+export {
+  DefaultGamePlugin,
+  GameStateObserver,
+  StateObserverManager,
+  UINotificationAdapter,
+  buildGameStateSnapshot,
+  createSession
+};
+//# sourceMappingURL=index.js.map