p2p-lockstep-kit-session 0.1.7 → 0.1.9

package/dist/session/index.js

@@ -2,6 +2,53 @@ 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);
 
+// utils/logger.ts
+var logWith = (level) => (message, meta) => {
+  if (meta !== void 0) {
+    console[level](message, meta);
+    return;
+  }
+  console[level](message);
+};
+var consoleLogger = {
+  debug: logWith("debug"),
+  info: logWith("info"),
+  warn: logWith("warn"),
+  error: logWith("error")
+};
+
+// utils/serialization/json.ts
+var decodeSafe = (raw) => {
+  if (typeof raw !== "string") {
+    return {
+      ok: false,
+      error: new TypeError("decodeSafe expects a serialized string")
+    };
+  }
+  try {
+    return { ok: true, value: JSON.parse(raw) };
+  } catch (error) {
+    return { ok: false, error };
+  }
+};
+
+// utils/protocol/session.ts
+var parseSessionMessage = (data) => {
+  if (typeof data !== "string") {
+    if (!data || typeof data !== "object") {
+      return null;
+    }
+    return data;
+  }
+  const decoded = decodeSafe(
+    data
+  );
+  if (!decoded.ok || !decoded.value || typeof decoded.value !== "object") {
+    return null;
+  }
+  return decoded.value;
+};
+
 // session/commandBus.ts
 var CommandBus = class {
   constructor() {
@@ -13,17 +60,31 @@ var CommandBus = class {
   }
   register(type, handler) {
     this.handlers[type] = handler;
+    consoleLogger.debug(`[session:bus] registered ${type}`);
   }
   dispatch(message) {
     this.processingQueue = this.processingQueue.then(async () => {
+      consoleLogger.debug(`[session:bus] dispatch ${message.type}`, {
+        from: message.from,
+        payload: message.payload,
+        turn: message.turn,
+        sid: message.sid
+      });
       const handler = this.handlers[message.type];
       if (handler) {
         try {
           await handler(message);
+          consoleLogger.debug(`[session:bus] handled ${message.type}`, {
+            from: message.from
+          });
         } catch (err) {
           console.error(`[CommandBus] Error in ${message.type}:`, err);
         }
+        return;
       }
+      consoleLogger.debug(`[session:bus] no handler for ${message.type}`, {
+        from: message.from
+      });
     });
   }
 };
@@ -57,11 +118,12 @@ var transitions = [
   { 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
+  // Approval outcomes when we were waiting for the peer.
   { 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
+  // Approval outcomes when we were confirming the peer's request.
+  // The target turn is explicit because resumeTurn decides who continues.
   { from: "approving", event: "APPROVE", to: "remote_turn" },
   { from: "approving", event: "REJECT", to: "remote_turn" },
   { from: "approving", event: "REJECT", to: "turn" },
@@ -257,11 +319,21 @@ var UINotificationAdapter = class {
     if (this.lastNotificationTime + this.notificationThrottleMs > now) return;
     this.lastNotificationTime = now;
     const snapshot = buildGameStateSnapshot(this.stateRef, this.getConnected());
+    consoleLogger.debug("[session:observer] state snapshot", {
+      local: snapshot.localState,
+      remote: snapshot.remoteState,
+      turn: snapshot.turn,
+      history: snapshot.history.length,
+      pending: snapshot.pendingAction,
+      connected: snapshot.connected
+    });
     this.uiObserver.notifyStateChange(snapshot);
   }
   onHistoryChanged() {
+    this.onStateChanged();
   }
   onGameReset() {
+    this.onStateChanged();
   }
   emitEvent(event) {
     this.uiObserver.notifyGameEvent(event);
@@ -299,6 +371,7 @@ var State = class {
     if (remoteId) {
       this.remoteId = remoteId;
     }
+    consoleLogger.debug("[session:state] created", { localId: id, remoteId });
   }
   /**
    * Register an internal observer (like plugin pattern)
@@ -316,6 +389,7 @@ var State = class {
   }
   setremoteId(id) {
     this.remoteId = id;
+    consoleLogger.debug("[session:state] remote id set", { remoteId: id });
   }
   getState(player) {
     return this.getPlayerFsm(player).getState();
@@ -327,6 +401,7 @@ var State = class {
     return this.history.slice();
   }
   replaceHistory(entries) {
+    consoleLogger.debug("[session:history] replace", { count: entries.length });
     this.clearHistory();
     entries.forEach((entry) => {
       this.pushHistory({
@@ -337,15 +412,33 @@ var State = class {
     });
   }
   clearHistory() {
+    const count = this.history.length;
     this.history.splice(0, this.history.length);
+    consoleLogger.debug("[session:history] clear", { count });
     this.notifyHistoryChanged();
   }
   pushHistory(entry) {
     this.history.push(entry);
+    consoleLogger.debug("[session:history] push", {
+      turn: entry.turn,
+      player: entry.player,
+      move: entry.move,
+      count: this.history.length
+    });
     this.notifyHistoryChanged();
   }
   popHistory() {
-    return this.history.pop() ?? null;
+    const entry = this.history.pop() ?? null;
+    if (entry) {
+      consoleLogger.debug("[session:history] pop", {
+        turn: entry.turn,
+        player: entry.player,
+        move: entry.move,
+        count: this.history.length
+      });
+      this.notifyHistoryChanged();
+    }
+    return entry;
   }
   canAction(player, action) {
     return this.getPlayerFsm(player).hasNextState(action);
@@ -358,28 +451,56 @@ var State = class {
    * so we automatically find and apply it.
    */
   dispatch(player, action, to) {
+    const before = this.getState(player);
     this.getPlayerFsm(player).dispatch(action, to);
+    const after = this.getState(player);
+    consoleLogger.debug(`[session:fsm] ${player} ${action}`, {
+      from: before,
+      to: after,
+      requested: to,
+      local: this.getState("local"),
+      remote: this.getState("remote"),
+      turn: this.getTurnCount(),
+      history: this.history.length,
+      pending: this.pendingAction
+    });
     this.notifyStateChanged();
   }
   setPendingAction(action) {
+    consoleLogger.debug("[session:state] pending action set", {
+      from: this.pendingAction,
+      to: action
+    });
     this.pendingAction = action;
   }
   getPendingAction() {
     return this.pendingAction;
   }
   setPendingUndoCount(count) {
+    consoleLogger.debug("[session:state] pending undo count set", {
+      from: this.pendingUndoCount,
+      to: count
+    });
     this.pendingUndoCount = count;
   }
   getPendingUndoCount() {
     return this.pendingUndoCount;
   }
   setLastStart(player) {
+    consoleLogger.debug("[session:state] last start set", {
+      from: this.lastStart,
+      to: player
+    });
     this.lastStart = player;
   }
   getLastStart() {
     return this.lastStart;
   }
   setResumeTurn(player) {
+    consoleLogger.debug("[session:state] resume turn set", {
+      from: this.resumeTurn,
+      to: player
+    });
     this.resumeTurn = player;
   }
   getResumeTurn() {
@@ -389,27 +510,60 @@ var State = class {
     return player === "local" ? this.local : this.remote;
   }
   notifyStateChanged() {
+    consoleLogger.debug("[session:state] notify state changed", {
+      local: this.getState("local"),
+      remote: this.getState("remote"),
+      turn: this.getTurnCount(),
+      history: this.history.length,
+      pending: this.pendingAction
+    });
     this.stateObserverManager.notifyStateChanged();
   }
   notifyHistoryChanged() {
+    consoleLogger.debug("[session:state] notify history changed", {
+      turn: this.getTurnCount(),
+      history: this.history.length,
+      pending: this.pendingAction
+    });
     this.stateObserverManager.notifyHistoryChanged();
   }
   notifyGameReset() {
+    consoleLogger.debug("[session:state] notify game reset");
     this.stateObserverManager.notifyGameReset();
   }
   dispatchPair(localAction, localTo, remoteAction, remoteTo) {
+    const before = {
+      local: this.local.getState(),
+      remote: this.remote.getState()
+    };
     this.local.dispatch(localAction, localTo);
     this.remote.dispatch(remoteAction, remoteTo);
+    consoleLogger.debug("[session:fsm] pair dispatch", {
+      before,
+      after: {
+        local: this.local.getState(),
+        remote: this.remote.getState()
+      },
+      localAction,
+      localTo,
+      remoteAction,
+      remoteTo,
+      turn: this.getTurnCount(),
+      history: this.history.length,
+      pending: this.pendingAction
+    });
     this.notifyStateChanged();
   }
   saveGameSnapshot(snapshot) {
     this.gameSnapshot = snapshot;
+    consoleLogger.debug("[session:state] game snapshot saved", { snapshot });
   }
   getGameSnapshot() {
     return this.gameSnapshot;
   }
   clearGameSnapshot() {
     this.gameSnapshot = null;
+    consoleLogger.debug("[session:state] game snapshot cleared");
   }
   /**
    * Check if there's a pending action (undo/restart)
@@ -421,6 +575,11 @@ var State = class {
    * Clear all pending states (called after approval/rejection)
    */
   clearPendingStates() {
+    consoleLogger.debug("[session:state] pending states cleared", {
+      pending: this.pendingAction,
+      pendingUndoCount: this.pendingUndoCount,
+      resumeTurn: this.resumeTurn
+    });
     this.pendingAction = null;
     this.pendingUndoCount = null;
     this.resumeTurn = null;
@@ -433,6 +592,10 @@ var State = class {
     this.pendingAction = "undo";
     this.pendingUndoCount = undoCount;
     this.resumeTurn = resumeTurn;
+    consoleLogger.debug("[session:state] undo request initialized", {
+      undoCount,
+      resumeTurn
+    });
   }
   /**
    * Initialize restart request with resume turn
@@ -440,6 +603,9 @@ var State = class {
   initializeRestartRequest(resumeTurn) {
     this.pendingAction = "restart";
     this.resumeTurn = resumeTurn;
+    consoleLogger.debug("[session:state] restart request initialized", {
+      resumeTurn
+    });
   }
   /**
    * Check if pending action is undo
@@ -457,6 +623,7 @@ var State = class {
    * Apply undo by popping history N times
    */
   applyUndo(count = 1) {
+    consoleLogger.debug("[session:history] apply undo", { count });
     for (let i = 0; i < count; i++) {
       this.popHistory();
     }
@@ -465,6 +632,13 @@ var State = class {
    * Reset game state to initial (for restart)
    */
   resetGame() {
+    consoleLogger.debug("[session:state] reset game", {
+      local: this.getState("local"),
+      remote: this.getState("remote"),
+      history: this.history.length,
+      lastStart: this.lastStart,
+      pending: this.pendingAction
+    });
     this.clearHistory();
     this.local = new SessionFsm("idle");
     this.remote = new SessionFsm("idle");
@@ -480,6 +654,7 @@ var State = class {
    */
   recordStartPlayer(player) {
     this.lastStart = player;
+    consoleLogger.debug("[session:state] start player recorded", { player });
   }
   /**
    * Get move to undo from history
@@ -517,6 +692,11 @@ var State = class {
    * Determines who plays first based on starter parameter
    */
   dispatchStart(firstPlayer) {
+    const before = {
+      local: this.local.getState(),
+      remote: this.remote.getState(),
+      lastStart: this.lastStart
+    };
     if (firstPlayer === "local") {
       this.local.dispatch("START", "turn");
       this.remote.dispatch("START", "remote_turn");
@@ -526,18 +706,38 @@ var State = class {
       this.remote.dispatch("START", "turn");
       this.lastStart = "remote";
     }
+    consoleLogger.debug("[session:fsm] start dispatch", {
+      before,
+      firstPlayer,
+      after: {
+        local: this.local.getState(),
+        remote: this.remote.getState(),
+        lastStart: this.lastStart
+      }
+    });
+    this.notifyStateChanged();
   }
   /**
    * Dispatch SYNC_COMPLETE with automatic target state resolution
    * Based on who should have the turn after sync
    */
   dispatchSyncComplete(nextPlayer) {
-    this.resumeTurn = nextPlayer;
     if (nextPlayer === "local") {
-      this.dispatchPair("SYNC_COMPLETE", "turn", "SYNC_COMPLETE", "remote_turn");
+      this.dispatchPair(
+        "SYNC_COMPLETE",
+        "turn",
+        "SYNC_COMPLETE",
+        "remote_turn"
+      );
     } else {
-      this.dispatchPair("SYNC_COMPLETE", "remote_turn", "SYNC_COMPLETE", "turn");
+      this.dispatchPair(
+        "SYNC_COMPLETE",
+        "remote_turn",
+        "SYNC_COMPLETE",
+        "turn"
+      );
     }
+    this.resumeTurn = null;
   }
   // ===== Game Plugin Integration (Proxy Pattern) =====
   /**
@@ -546,6 +746,10 @@ var State = class {
    */
   setGamePlugin(plugin) {
     this.gamePlugin = plugin;
+    consoleLogger.debug("[session:plugin] game plugin set", {
+      hasInitialize: Boolean(plugin.initialize),
+      hasCleanup: Boolean(plugin.cleanup)
+    });
     if (plugin.initialize) {
       plugin.initialize();
     }
@@ -564,7 +768,16 @@ var State = class {
    */
   validateMove(move2) {
     const gameState = this.buildGameState();
-    return this.gamePlugin.validateMove(move2, gameState);
+    const result = this.gamePlugin.validateMove(move2, gameState);
+    consoleLogger.debug("[session:plugin] validate move", {
+      move: move2,
+      result,
+      local: gameState.localState,
+      remote: gameState.remoteState,
+      turn: gameState.turn,
+      history: gameState.history.length
+    });
+    return result;
   }
   /**
    * Check if game has ended (someone won)
@@ -573,7 +786,13 @@ var State = class {
    */
   checkWin() {
     const gameState = this.buildGameState();
-    return this.gamePlugin.checkWin(gameState, this.getHistory());
+    const winner = this.gamePlugin.checkWin(gameState, this.getHistory());
+    consoleLogger.debug("[session:plugin] check win", {
+      winner,
+      turn: gameState.turn,
+      history: gameState.history.length
+    });
+    return winner;
   }
   /**
    * Cleanup when game ends (for plugin to reset internal state)
@@ -582,6 +801,7 @@ var State = class {
     if (this.gamePlugin.cleanup) {
       this.gamePlugin.cleanup();
     }
+    consoleLogger.debug("[session:plugin] cleanup game");
   }
   /**
    * Build game state for plugin
@@ -598,53 +818,6 @@ var State = class {
   }
 };
 
-// utils/logger.ts
-var logWith = (level) => (message, meta) => {
-  if (meta !== void 0) {
-    console[level](message, meta);
-    return;
-  }
-  console[level](message);
-};
-var consoleLogger = {
-  debug: logWith("debug"),
-  info: logWith("info"),
-  warn: logWith("warn"),
-  error: logWith("error")
-};
-
-// utils/serialization/json.ts
-var decodeSafe = (raw) => {
-  if (typeof raw !== "string") {
-    return {
-      ok: false,
-      error: new TypeError("decodeSafe expects a serialized string")
-    };
-  }
-  try {
-    return { ok: true, value: JSON.parse(raw) };
-  } catch (error) {
-    return { ok: false, error };
-  }
-};
-
-// utils/protocol/session.ts
-var parseSessionMessage = (data) => {
-  if (typeof data !== "string") {
-    if (!data || typeof data !== "object") {
-      return null;
-    }
-    return data;
-  }
-  const decoded = decodeSafe(
-    data
-  );
-  if (!decoded.ok || !decoded.value || typeof decoded.value !== "object") {
-    return null;
-  }
-  return decoded.value;
-};
-
 // session/net.ts
 var NetClient = class {
   constructor(client, bus, peerId) {
@@ -791,6 +964,13 @@ var ready = (command) => {
   const state = getState();
   const bus = getBus();
   const localSid = getSid();
+  consoleLogger.debug("[session:ready] received", {
+    from: command.from,
+    sid: command.sid,
+    localSid,
+    local: state.getState("local"),
+    remote: state.getState("remote")
+  });
   if (command.from === "local") {
     if (!state.canAction("local", "READY")) {
       console.warn("[Ready] Cannot dispatch READY from current state", {
@@ -805,6 +985,10 @@ var ready = (command) => {
       sid: localSid
     };
     send(message);
+    consoleLogger.debug("[session:ready] local toggled", {
+      local: state.getState("local"),
+      remote: state.getState("remote")
+    });
     return;
   }
   const remoteSid = command.sid;
@@ -824,6 +1008,10 @@ var ready = (command) => {
   }
   state.dispatch("remote", "READY");
   state.dispatch("local", "REMOTE_READY");
+  consoleLogger.debug("[session:ready] remote toggled", {
+    local: state.getState("local"),
+    remote: state.getState("remote")
+  });
 };
 
 // session/handlers/start.ts
@@ -835,6 +1023,13 @@ var getNextStarter = (lastStarter) => {
 };
 var start = (command) => {
   const state = getState();
+  consoleLogger.debug("[session:start] received", {
+    from: command.from,
+    payload: command.payload,
+    local: state.getState("local"),
+    remote: state.getState("remote"),
+    lastStart: state.getLastStart()
+  });
   if (command.from === "local") {
     if (!state.canAction("local", "START") || !state.canAction("remote", "REMOTE_START")) {
       console.warn("[Start] Cannot START from current state", {
@@ -846,6 +1041,10 @@ var start = (command) => {
     const nextStarter = getNextStarter(state.getLastStart());
     const localTarget2 = nextStarter === "local" ? "turn" : "remote_turn";
     const remoteTarget2 = nextStarter === "local" ? "remote_turn" : "turn";
+    if (state.getHistory().length > 0) {
+      state.clearHistory();
+      consoleLogger.debug("[session:start] cleared previous match history");
+    }
     state.setLastStart(nextStarter);
     state.dispatch("local", "START", localTarget2);
     state.dispatch("remote", "REMOTE_START", remoteTarget2);
@@ -853,6 +1052,7 @@ var start = (command) => {
       type: "START",
       payload: { starter: nextStarter === "local" ? "sender" : "receiver" }
     });
+    consoleLogger.debug("[session:start] local started", { nextStarter });
     return;
   }
   const starterInfo = command.payload?.starter;
@@ -870,16 +1070,28 @@ var start = (command) => {
   const starter = starterInfo === "sender" ? "remote" : "local";
   const localTarget = starter === "local" ? "turn" : "remote_turn";
   const remoteTarget = starter === "local" ? "remote_turn" : "turn";
+  if (state.getHistory().length > 0) {
+    state.clearHistory();
+    consoleLogger.debug("[session:start] cleared previous match history");
+  }
   state.setLastStart(starter);
   state.dispatch("local", "REMOTE_START", localTarget);
   state.dispatch("remote", "START", remoteTarget);
+  consoleLogger.debug("[session:start] remote started", { starter });
 };
 
 // session/handlers/move.ts
 var move = (command) => {
   const state = getState();
-  const bus = getBus();
   const movePayload = command.payload;
+  consoleLogger.debug("[session:move] received", {
+    from: command.from,
+    payload: movePayload,
+    local: state.getState("local"),
+    remote: state.getState("remote"),
+    turn: state.getTurnCount(),
+    history: state.getHistory().length
+  });
   if (command.from === "local") {
     if (!state.canAction("local", "MOVE")) {
       console.warn("[Move] Cannot MOVE from current state", {
@@ -903,25 +1115,31 @@ var move = (command) => {
       player: "local",
       move: movePayload
     });
+    const message = {
+      type: "MOVE",
+      turn: turn2,
+      payload: movePayload
+    };
+    send(message);
+    consoleLogger.debug("[session:move] local move sent", {
+      turn: turn2,
+      payload: 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 }
+      consoleLogger.debug("[session:move] game over detected", {
+        winner: winner2,
+        turn: turn2
       });
       state.dispatch("local", "GAME_OVER");
       state.dispatch("remote", "GAME_OVER");
       state.cleanupGame();
+      consoleLogger.debug("[session:move] local game over applied", {
+        winner: winner2,
+        turn: turn2
+      });
       return;
     }
-    const message = {
-      type: "MOVE",
-      turn: turn2,
-      payload: movePayload
-    };
-    send(message);
     return;
   }
   if (!state.canAction("remote", "MOVE")) {
@@ -948,31 +1166,63 @@ var move = (command) => {
   });
   const winner = state.checkWin();
   if (winner) {
-    console.log("[Move] Game over, winner:", winner);
-    bus.emit("GAME_OVER", { winner, turn }, "local");
+    consoleLogger.debug("[session:move] game over detected", { winner, turn });
     state.dispatch("local", "GAME_OVER");
     state.dispatch("remote", "GAME_OVER");
     state.cleanupGame();
+    consoleLogger.debug("[session:move] remote game over applied", {
+      winner,
+      turn
+    });
+    return;
   }
+  consoleLogger.debug("[session:move] remote move applied", {
+    turn,
+    payload: movePayload
+  });
 };
 
 // session/handlers/request.ts
+var isRequestAction = (value) => value === "undo" || value === "restart";
 var request = (command) => {
   if (command.type !== "APPROVE" && command.type !== "REJECT") {
     return;
   }
   const state = getState();
-  const action = state.getPendingAction();
+  const payload = command.payload;
+  const pendingAction = state.getPendingAction();
+  const action = pendingAction ?? (command.from === "local" && command.type === "REJECT" && isRequestAction(payload?.action) ? payload.action : null);
+  consoleLogger.debug("[session:request] received", {
+    type: command.type,
+    from: command.from,
+    action,
+    local: state.getState("local"),
+    remote: state.getState("remote"),
+    history: state.getHistory().length
+  });
   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 });
+    console.warn("[Request] Action mismatch", {
+      pending: action,
+      payload: payload.action
+    });
     return;
   }
   if (command.from === "local") {
+    if (!pendingAction && command.type === "REJECT") {
+      send({
+        type: "REJECT",
+        payload: { action, reason: payload?.reason ?? "rejected" }
+      });
+      consoleLogger.debug("[session:request] local auto rejected", {
+        action,
+        reason: payload?.reason
+      });
+      return;
+    }
     if (command.type === "APPROVE") {
       if (!state.canAction("local", "APPROVE")) {
         console.warn("[Request] Cannot APPROVE from current state");
@@ -986,6 +1236,7 @@ var request = (command) => {
       }
       send({ type: "APPROVE", payload: { action } });
       state.clearPendingStates();
+      consoleLogger.debug("[session:request] local approved", { action });
       return;
     }
     if (!state.canAction("local", "REJECT")) {
@@ -998,11 +1249,14 @@ var request = (command) => {
       payload: { action, reason: payload?.reason ?? "rejected" }
     });
     state.clearPendingStates();
+    consoleLogger.debug("[session:request] local rejected", { action });
     return;
   }
   if (command.type === "APPROVE") {
     if (!state.canAction("local", "APPROVE")) {
-      console.warn("[Request] Cannot APPROVE from current state (remote approved)");
+      console.warn(
+        "[Request] Cannot APPROVE from current state (remote approved)"
+      );
       return;
     }
     state.dispatchApprove();
@@ -1012,70 +1266,141 @@ var request = (command) => {
       state.resetGame();
     }
     state.clearPendingStates();
+    consoleLogger.debug("[session:request] remote approved", { action });
     return;
   }
   if (!state.canAction("local", "REJECT")) {
-    console.warn("[Request] Cannot REJECT from current state (remote rejected)");
+    console.warn(
+      "[Request] Cannot REJECT from current state (remote rejected)"
+    );
     state.clearPendingStates();
     return;
   }
   state.dispatchReject();
   state.clearPendingStates();
+  consoleLogger.debug("[session:request] remote rejected", { action });
 };
 
 // session/handlers/sync.ts
-var sync = (command) => {
+var fromPeerPerspective = (player) => player === "local" ? "remote" : "local";
+var getCurrentTurn = () => {
   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;
+  return state.getResumeTurn() ?? (state.getState("local") === "turn" ? "local" : "remote");
+};
+var buildSyncPayload = () => {
+  const state = getState();
+  const turn = getCurrentTurn();
+  return {
+    history: state.getHistory(),
+    lastStart: state.getLastStart(),
+    turn,
+    resumeTurn: state.getResumeTurn()
+  };
+};
+var isInSyncRecovery = () => {
+  const state = getState();
+  return state.getState("local") === "syncing" || state.getState("remote") === "syncing" || state.getState("remote") === "offline" || state.getResumeTurn() !== null;
+};
+var enterSyncState = () => {
+  const state = getState();
+  if (state.getState("local") !== "syncing") {
+    if (!state.canAction("local", "SYNC")) {
+      consoleLogger.debug("[session:sync] local cannot enter sync", {
+        local: state.getState("local")
+      });
+      return false;
     }
-    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;
+    state.dispatch("local", "SYNC", "syncing");
   }
-  if (command.type !== "SYNC_STATE") {
-    return;
+  if (state.getState("remote") === "offline") {
+    if (!state.canAction("remote", "ONLINE")) {
+      consoleLogger.debug("[session:sync] offline remote cannot enter sync", {
+        remote: state.getState("remote")
+      });
+      return false;
+    }
+    state.dispatch("remote", "ONLINE", "syncing");
+  } else if (state.getState("remote") !== "syncing") {
+    if (!state.canAction("remote", "SYNC")) {
+      consoleLogger.debug("[session:sync] remote cannot enter sync", {
+        remote: state.getState("remote")
+      });
+      return false;
+    }
+    state.dispatch("remote", "SYNC", "syncing");
   }
-  const payload = command.payload || {};
+  return state.getState("local") === "syncing" && state.getState("remote") === "syncing";
+};
+var restoreFromPayload = (payload, mapPeerLabels) => {
+  const state = getState();
+  const mapPlayer = mapPeerLabels ? fromPeerPerspective : (player) => player;
   if (payload.history && payload.history.length > 0) {
-    state.replaceHistory(payload.history);
+    state.replaceHistory(
+      payload.history.map((entry) => ({
+        ...entry,
+        player: mapPlayer(entry.player)
+      }))
+    );
   } else {
     state.clearHistory();
   }
   if (payload.lastStart) {
-    state.setLastStart(payload.lastStart);
+    state.setLastStart(mapPlayer(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", {
+  const nextPlayer = payload.resumeTurn ? mapPlayer(payload.resumeTurn) : payload.turn ? mapPlayer(payload.turn) : getCurrentTurn();
+  consoleLogger.debug("[session:sync] state restored", {
     historyLength: state.getHistory().length,
     lastStart: state.getLastStart(),
-    nextTurnPlayer: nextPlayer
+    nextTurnPlayer: nextPlayer,
+    mapped: mapPeerLabels
   });
+  if (!enterSyncState()) {
+    return;
+  }
   state.dispatchSyncComplete(nextPlayer);
 };
+var sync = (command) => {
+  const state = getState();
+  consoleLogger.debug("[session:sync] received", {
+    type: command.type,
+    from: command.from,
+    payload: command.payload,
+    local: state.getState("local"),
+    remote: state.getState("remote"),
+    history: state.getHistory().length,
+    resumeTurn: state.getResumeTurn()
+  });
+  if (command.type === "SYNC_REQUEST") {
+    if (command.from === "local") {
+      if (state.getState("local") !== "syncing" && !state.canAction("local", "SYNC")) {
+        console.warn("[Sync] Cannot SYNC from current state");
+        return;
+      }
+      if (state.getState("local") !== "syncing") {
+        state.dispatch("local", "SYNC", "syncing");
+      }
+      if (state.getState("remote") !== "syncing") {
+        state.dispatch("remote", "SYNC", "syncing");
+      }
+      send({ type: "SYNC_REQUEST", from: "", payload: command.payload });
+      consoleLogger.debug("[session:sync] request sent");
+      return;
+    }
+    const payload = buildSyncPayload();
+    send({ type: "SYNC_STATE", from: "", payload });
+    consoleLogger.debug("[session:sync] state sent", payload);
+    if (isInSyncRecovery()) {
+      restoreFromPayload(payload, false);
+    }
+    return;
+  }
+  if (command.type !== "SYNC_STATE") {
+    return;
+  }
+  restoreFromPayload(command.payload || {}, true);
+};
 
 // session/handlers/undo.ts
 var undo = (command) => {
@@ -1083,6 +1408,14 @@ var undo = (command) => {
     return;
   }
   const state = getState();
+  const bus = getBus();
+  consoleLogger.debug("[session:undo] received", {
+    from: command.from,
+    local: state.getState("local"),
+    remote: state.getState("remote"),
+    pending: state.getPendingAction(),
+    history: state.getHistory().length
+  });
   if (command.from === "local") {
     if (state.hasPendingAction()) {
       return;
@@ -1092,40 +1425,46 @@ var undo = (command) => {
       return;
     }
     const localState = state.getState("local");
-    const undoCount = localState === "turn" ? 1 : 2;
+    const undoCount = localState === "turn" ? 2 : 1;
+    const rejectResumePlayer = localState === "turn" ? "local" : "remote";
     if (state.getHistory().length < undoCount) {
       console.warn("[Undo] Not enough history to undo", { count: undoCount });
       return;
     }
-    state.initializeUndoRequest(undoCount, "local");
+    state.initializeUndoRequest(undoCount, rejectResumePlayer);
     state.dispatch("local", "UNDO");
     state.dispatch("remote", "REMOTE_UNDO");
     send({ type: "UNDO", payload: { count: undoCount } });
+    consoleLogger.debug("[session:undo] local requested", { undoCount });
     return;
   }
   if (state.hasPendingAction()) {
-    send({ type: "REJECT", payload: { action: "undo", reason: "busy" } });
+    bus.emit("REJECT", { action: "undo", reason: "busy" }, "local");
     return;
   }
   if (!state.canAction("local", "REMOTE_UNDO")) {
     console.warn("[Undo] Cannot accept remote UNDO request");
-    send({ type: "REJECT", payload: { action: "undo", reason: "invalid_state" } });
+    bus.emit("REJECT", { action: "undo", reason: "invalid_state" }, "local");
     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" } });
+    bus.emit("REJECT", { action: "undo", reason: "invalid" }, "local");
     return;
   }
-  if (count === 2 && state.getHistory().length < 2) {
-    send({ type: "REJECT", payload: { action: "undo", reason: "no_history" } });
+  if (state.getHistory().length < count) {
+    bus.emit("REJECT", { action: "undo", reason: "no_history" }, "local");
     return;
   }
   const resumePlayer = state.getState("local") === "turn" ? "local" : "remote";
   state.initializeUndoRequest(count, resumePlayer);
   state.dispatch("local", "REMOTE_UNDO");
   state.dispatch("remote", "UNDO");
+  consoleLogger.debug("[session:undo] remote requested", {
+    count,
+    resumePlayer
+  });
 };
 
 // session/handlers/restart.ts
@@ -1134,6 +1473,14 @@ var restart = (command) => {
     return;
   }
   const state = getState();
+  const bus = getBus();
+  consoleLogger.debug("[session:restart] received", {
+    from: command.from,
+    local: state.getState("local"),
+    remote: state.getState("remote"),
+    pending: state.getPendingAction(),
+    history: state.getHistory().length
+  });
   if (command.from === "local") {
     if (state.hasPendingAction()) {
       return;
@@ -1147,21 +1494,23 @@ var restart = (command) => {
     state.dispatch("local", "RESTART");
     state.dispatch("remote", "REMOTE_RESTART");
     send({ type: "RESTART" });
+    consoleLogger.debug("[session:restart] local requested", { resumePlayer: resumePlayer2 });
     return;
   }
   if (state.hasPendingAction()) {
-    send({ type: "REJECT", payload: { action: "restart", reason: "busy" } });
+    bus.emit("REJECT", { action: "restart", reason: "busy" }, "local");
     return;
   }
   if (!state.canAction("local", "REMOTE_RESTART")) {
     console.warn("[Restart] Cannot accept remote RESTART request");
-    send({ type: "REJECT", payload: { action: "restart", reason: "invalid_state" } });
+    bus.emit("REJECT", { action: "restart", reason: "invalid_state" }, "local");
     return;
   }
   const resumePlayer = state.getState("local") === "turn" ? "local" : "remote";
   state.initializeRestartRequest(resumePlayer);
   state.dispatch("local", "REMOTE_RESTART");
   state.dispatch("remote", "RESTART");
+  consoleLogger.debug("[session:restart] remote requested", { resumePlayer });
 };
 
 // session/handlers/offLine.ts
@@ -1171,17 +1520,40 @@ var offline = (command) => {
   }
   const state = getState();
   const bus = getBus();
+  consoleLogger.debug("[session:connection] received", {
+    type: command.type,
+    from: command.from,
+    local: state.getState("local"),
+    remote: state.getState("remote"),
+    pending: state.getPendingAction(),
+    resumeTurn: state.getResumeTurn()
+  });
   if (command.type === "OFFLINE") {
+    if (state.hasPendingAction()) {
+      const resumeTurn = state.getResumeTurn();
+      if (state.canAction("local", "SYNC")) {
+        state.dispatch("local", "SYNC", "syncing");
+      }
+      state.clearPendingStates();
+      state.setResumeTurn(resumeTurn);
+    }
     if (!state.canAction("remote", "OFFLINE")) {
       console.warn("[Offline] Cannot transition to OFFLINE from current state");
       return;
     }
-    const currentTurn = state.getState("local") === "turn" ? "local" : "remote";
+    const currentTurn = state.getResumeTurn() ?? (state.getState("local") === "turn" ? "local" : "remote");
     state.setResumeTurn(currentTurn);
     state.dispatch("remote", "OFFLINE", "offline");
+    consoleLogger.debug("[session:connection] remote offline", { currentTurn });
     return;
   }
   if (state.getState("remote") !== "offline") {
+    consoleLogger.debug(
+      "[session:connection] ignored online while remote is not offline",
+      {
+        remote: state.getState("remote")
+      }
+    );
     return;
   }
   if (!state.canAction("remote", "ONLINE")) {
@@ -1190,6 +1562,7 @@ var offline = (command) => {
   }
   state.dispatch("remote", "ONLINE", "syncing");
   bus.emit("SYNC_REQUEST", void 0, "local");
+  consoleLogger.debug("[session:connection] remote online, sync requested");
 };
 
 // session/handlers/busRegister.ts