Pre-build backend to skip esbuild step in Docker

- Include pre-built backend/dist/backend/src/server.js
- Remove esbuild build step from Dockerfile
- Simplify to only npm install for runtime deps

Co-Authored-By: Claude <noreply@anthropic.com>

.dockerignore

@@ -12,9 +12,10 @@ README.md
 node_modules
 **/node_modules
 
-# Build outputs (will be generated during build) - keep app/dist for pre-built frontend
+# Build outputs - keep pre-built dist folders
 **/dist
 !trigo-web/app/dist
+!trigo-web/backend/dist
 
 # Test files
 tests

.gitignore

@@ -1,4 +1,4 @@
 node_modules/
-# Don't ignore trigo-web/app/dist - we commit pre-built frontend
-dist/
-!trigo-web/app/dist/
+# Don't ignore pre-built outputs
+# trigo-web/app/dist - pre-built frontend
+# trigo-web/backend/dist - pre-built backend

Dockerfile

@@ -3,7 +3,7 @@ FROM node:20-slim
 # Set noninteractive installation
 ENV DEBIAN_FRONTEND=noninteractive
 
-# Build timestamp to force cache invalidation: 2026-01-12T20:00
+# Build timestamp to force cache invalidation: 2026-01-12T20:10
 
 # Install build dependencies
 RUN apt-get update && apt-get install -y \
@@ -14,27 +14,24 @@ RUN apt-get update && apt-get install -y \
 # Create app directory
 WORKDIR /app
 
-# Copy trigo-web project (includes pre-built app/dist with onnx files)
+# Copy trigo-web project (includes pre-built app/dist and backend/dist)
 COPY trigo-web/ ./
 
-# Install build tools globally
-RUN npm install -g tsx jison typescript esbuild
+# Install build tools globally (still needed for some scripts)
+RUN npm install -g tsx jison typescript
 
 # Install dependencies
 # Root: production only (skip onnxruntime-node which requires native compilation)
-# App & Backend: all deps needed for runtime
+# App & Backend: runtime deps only
 RUN npm install --omit=dev && \
     cd app && npm install --omit=dev && \
-    cd ../backend && npm install && \
+    cd ../backend && npm install --omit=dev && \
     cd ..
 
-# Skip jison parser build - pre-built tgnParser.cjs is already in public/lib/
-# Skip vite build - pre-built dist is already included (with onnx files)
-
-# Build backend with esbuild (handles ESM imports without .js extensions)
-# Output to dist/backend/src/ to match backend/package.json main field
-RUN mkdir -p backend/dist/backend/src && \
-    esbuild backend/src/server.ts --bundle --platform=node --target=node20 --format=esm --outfile=backend/dist/backend/src/server.js --external:express --external:socket.io --external:cors --external:dotenv --external:uuid
+# Skip all build steps - everything is pre-built:
+# - Frontend: app/dist/ (includes onnx files)
+# - Backend: backend/dist/backend/src/server.js
+# - Parser: public/lib/tgnParser.cjs
 
 # Set environment variables for Hugging Face Spaces
 ENV PORT=7860

trigo-web/backend/dist/backend/src/server.js

@@ -0,0 +1,2104 @@
+// backend/src/server.ts
+import express from "express";
+import { createServer } from "http";
+import { Server } from "socket.io";
+import cors from "cors";
+import dotenv from "dotenv";
+import path from "path";
+import fs from "fs";
+import { fileURLToPath } from "url";
+
+// backend/src/services/gameManager.ts
+import { v4 as uuidv4 } from "uuid";
+
+// inc/trigo/gameUtils.ts
+var StoneType = {
+  EMPTY: 0,
+  BLACK: 1,
+  WHITE: 2
+};
+function getEnemyColor(color) {
+  if (color === StoneType.BLACK) return StoneType.WHITE;
+  if (color === StoneType.WHITE) return StoneType.BLACK;
+  return StoneType.EMPTY;
+}
+function isInBounds(pos, shape) {
+  return pos.x >= 0 && pos.x < shape.x && pos.y >= 0 && pos.y < shape.y && pos.z >= 0 && pos.z < shape.z;
+}
+function getNeighbors(pos, shape) {
+  const neighbors = [];
+  const directions = [
+    { x: 1, y: 0, z: 0 },
+    { x: -1, y: 0, z: 0 },
+    { x: 0, y: 1, z: 0 },
+    { x: 0, y: -1, z: 0 },
+    { x: 0, y: 0, z: 1 },
+    { x: 0, y: 0, z: -1 }
+  ];
+  for (const dir of directions) {
+    const neighbor = {
+      x: pos.x + dir.x,
+      y: pos.y + dir.y,
+      z: pos.z + dir.z
+    };
+    if (isInBounds(neighbor, shape)) {
+      neighbors.push(neighbor);
+    }
+  }
+  return neighbors;
+}
+function positionsEqual(p1, p2) {
+  return p1.x === p2.x && p1.y === p2.y && p1.z === p2.z;
+}
+var CoordSet = class {
+  constructor() {
+    this.positions = [];
+  }
+  has(pos) {
+    return this.positions.some((p) => positionsEqual(p, pos));
+  }
+  insert(pos) {
+    if (!this.has(pos)) {
+      this.positions.push(pos);
+      return true;
+    }
+    return false;
+  }
+  remove(pos) {
+    this.positions = this.positions.filter((p) => !positionsEqual(p, pos));
+  }
+  size() {
+    return this.positions.length;
+  }
+  empty() {
+    return this.positions.length === 0;
+  }
+  forEach(callback) {
+    this.positions.forEach(callback);
+  }
+  toArray() {
+    return [...this.positions];
+  }
+  clear() {
+    this.positions = [];
+  }
+};
+var Patch = class {
+  constructor(color = StoneType.EMPTY) {
+    this.positions = new CoordSet();
+    this.color = StoneType.EMPTY;
+    this.color = color;
+  }
+  addStone(pos) {
+    this.positions.insert(pos);
+  }
+  size() {
+    return this.positions.size();
+  }
+  /**
+   * Get all liberties (empty adjacent positions) for this group
+   *
+   * Equivalent to StoneArray.patchAir() in prototype
+   * Returns a CoordSet of empty positions adjacent to this patch
+   */
+  getLiberties(board, shape) {
+    const liberties = new CoordSet();
+    this.positions.forEach((stonePos) => {
+      const neighbors = getNeighbors(stonePos, shape);
+      for (const neighbor of neighbors) {
+        if (board[neighbor.x][neighbor.y][neighbor.z] === StoneType.EMPTY) {
+          liberties.insert(neighbor);
+        }
+      }
+    });
+    return liberties;
+  }
+};
+function findGroup(pos, board, shape) {
+  const color = board[pos.x][pos.y][pos.z];
+  const group = new Patch(color);
+  if (color === StoneType.EMPTY) {
+    return group;
+  }
+  const visited = new CoordSet();
+  const stack = [pos];
+  while (stack.length > 0) {
+    const current = stack.pop();
+    if (visited.has(current)) {
+      continue;
+    }
+    visited.insert(current);
+    if (board[current.x][current.y][current.z] === color) {
+      group.addStone(current);
+      const neighbors = getNeighbors(current, shape);
+      for (const neighbor of neighbors) {
+        if (!visited.has(neighbor)) {
+          stack.push(neighbor);
+        }
+      }
+    }
+  }
+  return group;
+}
+function getNeighborGroups(pos, board, shape, excludeEmpty = false) {
+  const neighbors = getNeighbors(pos, shape);
+  const groups = [];
+  const processedPositions = new CoordSet();
+  for (const neighbor of neighbors) {
+    if (processedPositions.has(neighbor)) {
+      continue;
+    }
+    const stone = board[neighbor.x][neighbor.y][neighbor.z];
+    if (excludeEmpty && stone === StoneType.EMPTY) {
+      continue;
+    }
+    if (stone !== StoneType.EMPTY) {
+      const group = findGroup(neighbor, board, shape);
+      group.positions.forEach((p) => processedPositions.insert(p));
+      groups.push(group);
+    }
+  }
+  return groups;
+}
+function isGroupCaptured(group, board, shape) {
+  const liberties = group.getLiberties(board, shape);
+  return liberties.size() === 0;
+}
+function findCapturedGroups(pos, playerColor, board, shape) {
+  const enemyColor = getEnemyColor(playerColor);
+  const captured = [];
+  const tempBoard = board.map((plane) => plane.map((row) => [...row]));
+  tempBoard[pos.x][pos.y][pos.z] = playerColor;
+  const neighborGroups = getNeighborGroups(pos, tempBoard, shape, true);
+  for (const group of neighborGroups) {
+    if (group.color === enemyColor) {
+      if (isGroupCaptured(group, tempBoard, shape)) {
+        captured.push(group);
+      }
+    }
+  }
+  return captured;
+}
+function isSuicideMove(pos, playerColor, board, shape) {
+  const tempBoard = board.map((plane) => plane.map((row) => [...row]));
+  tempBoard[pos.x][pos.y][pos.z] = playerColor;
+  const capturedGroups = findCapturedGroups(pos, playerColor, board, shape);
+  if (capturedGroups.length > 0) {
+    return false;
+  }
+  const placedGroup = findGroup(pos, tempBoard, shape);
+  const liberties = placedGroup.getLiberties(tempBoard, shape);
+  return liberties.size() === 0;
+}
+function isKoViolation(pos, playerColor, board, shape, lastCapturedPositions) {
+  if (!lastCapturedPositions || lastCapturedPositions.length !== 1) {
+    return false;
+  }
+  const capturedGroups = findCapturedGroups(pos, playerColor, board, shape);
+  if (capturedGroups.length !== 1 || capturedGroups[0].size() !== 1) {
+    return false;
+  }
+  const previouslyCaptured = lastCapturedPositions[0];
+  if (positionsEqual(pos, previouslyCaptured)) {
+    return true;
+  }
+  return false;
+}
+function executeCaptures(capturedGroups, board) {
+  const capturedPositions = [];
+  for (const group of capturedGroups) {
+    group.positions.forEach((pos) => {
+      board[pos.x][pos.y][pos.z] = StoneType.EMPTY;
+      capturedPositions.push(pos);
+    });
+  }
+  return capturedPositions;
+}
+function findEmptyRegion(startPos, board, shape, visited) {
+  const region = new CoordSet();
+  const stack = [startPos];
+  while (stack.length > 0) {
+    const pos = stack.pop();
+    if (visited.has(pos)) {
+      continue;
+    }
+    visited.insert(pos);
+    if (board[pos.x][pos.y][pos.z] === StoneType.EMPTY) {
+      region.insert(pos);
+      const neighbors = getNeighbors(pos, shape);
+      for (const neighbor of neighbors) {
+        if (!visited.has(neighbor)) {
+          stack.push(neighbor);
+        }
+      }
+    }
+  }
+  return region;
+}
+function determineRegionOwner(region, board, shape) {
+  let owner = StoneType.EMPTY;
+  let solved = false;
+  region.forEach((pos) => {
+    if (solved) return;
+    const neighbors = getNeighbors(pos, shape);
+    for (const neighbor of neighbors) {
+      if (solved) break;
+      const stone = board[neighbor.x][neighbor.y][neighbor.z];
+      if (stone !== StoneType.EMPTY) {
+        if (owner === StoneType.EMPTY) {
+          owner = stone;
+        } else if (owner !== stone) {
+          owner = StoneType.EMPTY;
+          solved = true;
+        }
+      }
+    }
+  });
+  return owner;
+}
+function calculateTerritory(board, shape) {
+  const result = {
+    black: 0,
+    white: 0,
+    neutral: 0,
+    blackTerritory: [],
+    whiteTerritory: [],
+    neutralTerritory: []
+  };
+  const visited = new CoordSet();
+  const emptyRegions = [];
+  for (let x = 0; x < shape.x; x++) {
+    for (let y = 0; y < shape.y; y++) {
+      for (let z = 0; z < shape.z; z++) {
+        const pos = { x, y, z };
+        const stone = board[x][y][z];
+        if (stone === StoneType.BLACK) {
+          result.black++;
+          result.blackTerritory.push(pos);
+        } else if (stone === StoneType.WHITE) {
+          result.white++;
+          result.whiteTerritory.push(pos);
+        } else if (!visited.has(pos)) {
+          const region = findEmptyRegion(pos, board, shape, visited);
+          emptyRegions.push(region);
+        }
+      }
+    }
+  }
+  for (const region of emptyRegions) {
+    const owner = determineRegionOwner(region, board, shape);
+    const regionArray = region.toArray();
+    if (owner === StoneType.BLACK) {
+      result.black += region.size();
+      result.blackTerritory.push(...regionArray);
+    } else if (owner === StoneType.WHITE) {
+      result.white += region.size();
+      result.whiteTerritory.push(...regionArray);
+    } else {
+      result.neutral += region.size();
+      result.neutralTerritory.push(...regionArray);
+    }
+  }
+  return result;
+}
+function validateMove(pos, playerColor, board, shape, lastCapturedPositions = null) {
+  if (!isInBounds(pos, shape)) {
+    return { valid: false, reason: "Position out of bounds" };
+  }
+  if (board[pos.x][pos.y][pos.z] !== StoneType.EMPTY) {
+    return { valid: false, reason: "Position already occupied" };
+  }
+  if (isKoViolation(pos, playerColor, board, shape, lastCapturedPositions)) {
+    return { valid: false, reason: "Ko rule violation" };
+  }
+  if (isSuicideMove(pos, playerColor, board, shape)) {
+    return { valid: false, reason: "suicide move not allowed" };
+  }
+  return { valid: true };
+}
+
+// inc/trigo/ab0yz.ts
+var compactShape = (shape) => shape[shape.length - 1] === 1 ? compactShape(shape.slice(0, shape.length - 1)) : shape;
+var encodeAb0yz = (pos, boardShape) => {
+  const compactedShape = compactShape(boardShape);
+  const result = [];
+  for (let i = 0; i < compactedShape.length; i++) {
+    const size = compactedShape[i];
+    const center = (size - 1) / 2;
+    const index = pos[i];
+    if (index === center) {
+      result.push("0");
+    } else if (index < center) {
+      result.push(String.fromCharCode(97 + index));
+    } else {
+      const offset = size - 1 - index;
+      result.push(String.fromCharCode(122 - offset));
+    }
+  }
+  return result.join("");
+};
+var decodeAb0yz = (code, boardShape) => {
+  const compactedShape = compactShape(boardShape);
+  if (code.length !== compactedShape.length) {
+    throw new Error(
+      `Invalid TGN coordinate: "${code}" (must be ${compactedShape.length} characters for board shape ${boardShape.join("x")})`
+    );
+  }
+  const result = [];
+  for (let i = 0; i < compactedShape.length; i++) {
+    const char = code[i];
+    const size = compactedShape[i];
+    const center = (size - 1) / 2;
+    if (char === "0") {
+      console.assert(Number.isInteger(center));
+      result.push(center);
+    } else {
+      const charCode = char.charCodeAt(0);
+      if (charCode >= 97 && charCode <= 122) {
+        const distFromA = charCode - 97;
+        const distFromZ = 122 - charCode;
+        if (distFromA < distFromZ) {
+          const index = distFromA;
+          if (index >= center) {
+            throw new Error(
+              `Invalid TGN coordinate: "${code}" (position ${index} >= center ${center} on axis ${i})`
+            );
+          }
+          result.push(index);
+        } else {
+          const index = size - 1 - distFromZ;
+          if (index <= center) {
+            throw new Error(
+              `Invalid TGN coordinate: "${code}" (position ${index} <= center ${center} on axis ${i})`
+            );
+          }
+          result.push(index);
+        }
+      } else {
+        throw new Error(
+          `Invalid TGN coordinate: "${code}" (character '${char}' at position ${i} must be '0' or a-z)`
+        );
+      }
+    }
+  }
+  while (result.length < boardShape.length) {
+    result.push(0);
+  }
+  return result;
+};
+
+// inc/tgn/tgnParser.ts
+var TGNParseError = class extends Error {
+  constructor(message, line, column, hash) {
+    super(message);
+    this.line = line;
+    this.column = column;
+    this.hash = hash;
+    this.name = "TGNParseError";
+  }
+};
+var parserModule = null;
+function getParser() {
+  if (!parserModule) {
+    throw new Error(
+      "TGN parser not loaded. Please ensure the parser has been built.\nRun: npm run build:parsers"
+    );
+  }
+  return parserModule;
+}
+function parseTGN(tgnString) {
+  const parser = getParser();
+  if (!parser.parse) {
+    throw new Error("TGN parser parse method not available");
+  }
+  try {
+    const result = parser.parse(tgnString);
+    return result;
+  } catch (error) {
+    throw new TGNParseError(
+      error.message || "Unknown parse error",
+      error.hash?.line,
+      error.hash?.loc?.first_column,
+      error.hash
+    );
+  }
+}
+
+// inc/trigo/game.ts
+var TrigoGame = class _TrigoGame {
+  /**
+   * Constructor
+   * Equivalent to trigo.Game constructor (lines 75-85)
+   */
+  constructor(shape = { x: 5, y: 5, z: 5 }, callbacks = {}) {
+    // Last captured stones for Ko rule detection
+    this.lastCapturedPositions = null;
+    // Static analysis cache (territory, capturing moves)
+    // Invalidated on any board state change
+    this.cachedTerritory = null;
+    this.cachedCapturingMove = /* @__PURE__ */ new Map();
+    this.shape = shape;
+    this.callbacks = callbacks;
+    this.board = this.createEmptyBoard();
+    this.currentPlayer = StoneType.BLACK;
+    this.stepHistory = [];
+    this.currentStepIndex = 0;
+    this.gameStatus = "idle";
+    this.gameResult = void 0;
+    this.passCount = 0;
+  }
+  /**
+   * Create an empty board
+   */
+  createEmptyBoard() {
+    const board = [];
+    for (let x = 0; x < this.shape.x; x++) {
+      board[x] = [];
+      for (let y = 0; y < this.shape.y; y++) {
+        board[x][y] = [];
+        for (let z = 0; z < this.shape.z; z++) {
+          board[x][y][z] = StoneType.EMPTY;
+        }
+      }
+    }
+    return board;
+  }
+  /**
+   * Reset the game to initial state
+   * Equivalent to Game.reset() (lines 153-163)
+   */
+  reset() {
+    this.board = this.createEmptyBoard();
+    this.currentPlayer = StoneType.BLACK;
+    this.stepHistory = [];
+    this.currentStepIndex = 0;
+    this.lastCapturedPositions = null;
+    this.invalidateAnalysisCache();
+    this.gameStatus = "idle";
+    this.gameResult = void 0;
+    this.passCount = 0;
+  }
+  /**
+   * Invalidate all static analysis caches
+   * Called when board state changes
+   */
+  invalidateAnalysisCache() {
+    this.cachedTerritory = null;
+    this.cachedCapturingMove.clear();
+  }
+  /**
+   * Clone the game state (deep copy)
+   * Creates an independent copy with all state preserved
+   */
+  clone() {
+    const cloned = new _TrigoGame(this.shape, {});
+    cloned.board = this.board.map((plane) => plane.map((row) => [...row]));
+    cloned.currentPlayer = this.currentPlayer;
+    cloned.currentStepIndex = this.currentStepIndex;
+    cloned.gameStatus = this.gameStatus;
+    cloned.passCount = this.passCount;
+    cloned.stepHistory = this.stepHistory.map((step) => ({
+      ...step,
+      position: step.position ? { ...step.position } : void 0,
+      capturedPositions: step.capturedPositions ? step.capturedPositions.map((pos) => ({ ...pos })) : []
+    }));
+    cloned.lastCapturedPositions = this.lastCapturedPositions ? this.lastCapturedPositions.map((pos) => ({ ...pos })) : null;
+    if (this.gameResult) {
+      cloned.gameResult = {
+        ...this.gameResult,
+        score: this.gameResult.score ? { ...this.gameResult.score } : void 0
+      };
+    }
+    cloned.invalidateAnalysisCache();
+    return cloned;
+  }
+  /**
+   * Get current board state (read-only)
+   */
+  getBoard() {
+    return this.board.map((plane) => plane.map((row) => [...row]));
+  }
+  /**
+   * Get stone at specific position
+   * Equivalent to Game.stone() (lines 95-97)
+   */
+  getStone(pos) {
+    return this.board[pos.x][pos.y][pos.z];
+  }
+  /**
+   * Get current player
+   */
+  getCurrentPlayer() {
+    return this.currentPlayer;
+  }
+  /**
+   * Get current step number
+   * Equivalent to Game.currentStep() (lines 99-101)
+   */
+  getCurrentStep() {
+    return this.currentStepIndex;
+  }
+  /**
+   * Get move history
+   * Equivalent to Game.routine() (lines 103-105)
+   */
+  getHistory() {
+    return [...this.stepHistory];
+  }
+  /**
+   * Get last move
+   * Equivalent to Game.lastStep() (lines 107-110)
+   */
+  getLastStep() {
+    if (this.currentStepIndex > 0) {
+      return this.stepHistory[this.currentStepIndex - 1];
+    }
+    return null;
+  }
+  /**
+   * Get board shape
+   * Equivalent to Game.shape() (lines 87-89)
+   */
+  getShape() {
+    return { ...this.shape };
+  }
+  /**
+   * Get game status
+   */
+  getGameStatus() {
+    return this.gameStatus;
+  }
+  /**
+   * Set game status
+   */
+  setGameStatus(status) {
+    this.gameStatus = status;
+  }
+  /**
+   * Get game result
+   */
+  getGameResult() {
+    return this.gameResult;
+  }
+  /**
+   * Get consecutive pass count
+   */
+  getPassCount() {
+    return this.passCount;
+  }
+  /**
+   * Recalculate consecutive pass count based on current history
+   * Counts consecutive PASS steps from the end of current history
+   */
+  recalculatePassCount() {
+    this.passCount = 0;
+    for (let i = this.currentStepIndex - 1; i >= 0; i--) {
+      if (this.stepHistory[i].type === 1 /* PASS */) {
+        this.passCount++;
+      } else {
+        break;
+      }
+    }
+  }
+  /**
+   * Start the game
+   */
+  startGame() {
+    if (this.gameStatus === "idle") {
+      this.gameStatus = "playing";
+    }
+  }
+  /**
+   * Check if game is active
+   */
+  isGameActive() {
+    return this.gameStatus === "playing";
+  }
+  /**
+   * Check if a move is valid
+   * Equivalent to Game.isDropable() and Game.isValidStep() (lines 112-151)
+   */
+  isValidMove(pos, player) {
+    const playerColor = player || this.currentPlayer;
+    return validateMove(pos, playerColor, this.board, this.shape, this.lastCapturedPositions);
+  }
+  /**
+   * Get all valid move positions for current player (efficient batch query)
+   *
+   * This method is optimized to avoid repeated validation checks by:
+   * 1. Only checking empty positions
+   * 2. Skipping bounds checking (iterator is already within bounds)
+   * 3. Using low-level validation functions directly
+   * 4. Batching board state access
+   *
+   * @param player - Optional player color (defaults to current player)
+   * @returns Array of all valid move positions
+   */
+  validMovePositions(player) {
+    const playerColor = player || this.currentPlayer;
+    const validPositions = [];
+    for (let x = 0; x < this.shape.x; x++) {
+      for (let y = 0; y < this.shape.y; y++) {
+        for (let z = 0; z < this.shape.z; z++) {
+          if (this.board[x][y][z] !== StoneType.EMPTY) {
+            continue;
+          }
+          const pos = { x, y, z };
+          if (isKoViolation(
+            pos,
+            playerColor,
+            this.board,
+            this.shape,
+            this.lastCapturedPositions
+          )) {
+            continue;
+          }
+          if (isSuicideMove(pos, playerColor, this.board, this.shape)) {
+            continue;
+          }
+          validPositions.push(pos);
+        }
+      }
+    }
+    return validPositions;
+  }
+  /**
+   * Check if any valid move can capture enemy stones
+   * Used by MCTS to determine if a position is truly terminal
+   *
+   * Results are cached and invalidated when board state changes.
+   *
+   * @param player - Optional player color (defaults to current player)
+   * @returns true if at least one valid move would capture stones
+   */
+  hasCapturingMove(player) {
+    const playerColor = player ?? this.currentPlayer;
+    if (this.cachedCapturingMove.has(playerColor)) {
+      return this.cachedCapturingMove.get(playerColor);
+    }
+    const result = this.computeHasCapturingMove(playerColor);
+    this.cachedCapturingMove.set(playerColor, result);
+    return result;
+  }
+  /**
+   * Internal: Compute whether a player has any capturing move
+   */
+  computeHasCapturingMove(playerColor) {
+    for (let x = 0; x < this.shape.x; x++) {
+      for (let y = 0; y < this.shape.y; y++) {
+        for (let z = 0; z < this.shape.z; z++) {
+          if (this.board[x][y][z] !== StoneType.EMPTY) {
+            continue;
+          }
+          const pos = { x, y, z };
+          if (isKoViolation(
+            pos,
+            playerColor,
+            this.board,
+            this.shape,
+            this.lastCapturedPositions
+          )) {
+            continue;
+          }
+          if (isSuicideMove(pos, playerColor, this.board, this.shape)) {
+            continue;
+          }
+          const capturedGroups = findCapturedGroups(pos, playerColor, this.board, this.shape);
+          if (capturedGroups.length > 0) {
+            return true;
+          }
+        }
+      }
+    }
+    return false;
+  }
+  /**
+   * Check if the game has reached a natural terminal state
+   *
+   * A game is naturally terminal when:
+   * - All territory is claimed (neutral === 0)
+   * - AND neither player has any capturing moves available
+   *
+   * This is different from the "finished" status which requires double pass.
+   * Natural termination means the game state is completely settled and
+   * no further moves can meaningfully change the outcome.
+   *
+   * NOTE: This method is expensive due to territory calculation and capture move checking.
+   * Use coverage ratio check as a pre-filter when calling frequently.
+   *
+   * Used by:
+   * - MCTS agent (terminal detection for tree search)
+   * - Model battle (early stopping when settled)
+   * - Self-play games (early stopping when settled)
+   *
+   * @returns true if the game is naturally terminal, false otherwise
+   */
+  isNaturallyTerminal() {
+    const territory = this.getTerritory();
+    if (territory.neutral !== 0) {
+      return false;
+    }
+    const blackCanCapture = this.hasCapturingMove(StoneType.BLACK);
+    const whiteCanCapture = this.hasCapturingMove(StoneType.WHITE);
+    return !blackCanCapture && !whiteCanCapture;
+  }
+  /**
+   * Reset pass count (called when a stone is placed)
+   */
+  resetPassCount() {
+    this.passCount = 0;
+  }
+  /**
+   * Place a stone (drop move)
+   * Equivalent to Game.drop() and Game.appendStone() (lines 181-273)
+   *
+   * @returns true if move was successful, false otherwise
+   */
+  drop(pos) {
+    const validation = this.isValidMove(pos);
+    if (!validation.valid) {
+      console.warn(`Invalid move at (${pos.x}, ${pos.y}, ${pos.z}): ${validation.reason}`);
+      return false;
+    }
+    const capturedGroups = findCapturedGroups(pos, this.currentPlayer, this.board, this.shape);
+    this.board[pos.x][pos.y][pos.z] = this.currentPlayer;
+    const capturedPositions = executeCaptures(capturedGroups, this.board);
+    this.lastCapturedPositions = capturedPositions.length > 0 ? capturedPositions : null;
+    this.invalidateAnalysisCache();
+    this.resetPassCount();
+    const step = {
+      type: 0 /* DROP */,
+      position: pos,
+      player: this.currentPlayer,
+      capturedPositions: capturedPositions.length > 0 ? capturedPositions : void 0,
+      timestamp: Date.now()
+    };
+    this.advanceStep(step);
+    if (capturedPositions.length > 0 && this.callbacks.onCapture) {
+      this.callbacks.onCapture(capturedPositions);
+    }
+    if (this.callbacks.onTerritoryChange) {
+      this.callbacks.onTerritoryChange(this.getTerritory());
+    }
+    return true;
+  }
+  /**
+   * Pass turn
+   * Equivalent to PASS step type in prototype
+   */
+  pass() {
+    const step = {
+      type: 1 /* PASS */,
+      player: this.currentPlayer,
+      timestamp: Date.now()
+    };
+    this.lastCapturedPositions = null;
+    this.passCount++;
+    this.advanceStep(step);
+    if (this.passCount >= 2) {
+      const territory = this.getTerritory();
+      const capturedCounts = this.getCapturedCounts();
+      const blackTotal = territory.black + capturedCounts.white;
+      const whiteTotal = territory.white + capturedCounts.black;
+      let winner;
+      if (blackTotal > whiteTotal) {
+        winner = "black";
+      } else if (whiteTotal > blackTotal) {
+        winner = "white";
+      } else {
+        winner = "draw";
+      }
+      this.gameResult = {
+        winner,
+        reason: "double-pass",
+        score: territory
+      };
+      this.gameStatus = "finished";
+      if (this.callbacks.onWin) {
+        const winnerStone = winner === "black" ? StoneType.BLACK : winner === "white" ? StoneType.WHITE : StoneType.EMPTY;
+        this.callbacks.onWin(winnerStone);
+      }
+    }
+    return true;
+  }
+  /**
+   * Surrender/resign
+   * Equivalent to Game.step() with SURRENDER type (lines 176-178)
+   */
+  surrender() {
+    const surrenderingPlayer = this.currentPlayer;
+    const step = {
+      type: 2 /* SURRENDER */,
+      player: this.currentPlayer,
+      timestamp: Date.now()
+    };
+    this.advanceStep(step);
+    const winner = surrenderingPlayer === StoneType.BLACK ? "white" : "black";
+    this.gameResult = {
+      winner,
+      reason: "resignation"
+    };
+    this.gameStatus = "finished";
+    const winnerStone = getEnemyColor(surrenderingPlayer);
+    if (this.callbacks.onWin) {
+      this.callbacks.onWin(winnerStone);
+    }
+    return true;
+  }
+  /**
+   * Undo last move
+   * Equivalent to Game.repent() (lines 197-230)
+   *
+   * @returns true if undo was successful, false if no moves to undo
+   */
+  undo() {
+    if (this.currentStepIndex === 0 || this.stepHistory.length === 0) {
+      return false;
+    }
+    const lastStep = this.stepHistory[this.currentStepIndex - 1];
+    if (lastStep.type === 0 /* DROP */ && lastStep.position) {
+      this.board[lastStep.position.x][lastStep.position.y][lastStep.position.z] = StoneType.EMPTY;
+      if (lastStep.capturedPositions) {
+        const enemyColor = getEnemyColor(lastStep.player);
+        for (const pos of lastStep.capturedPositions) {
+          this.board[pos.x][pos.y][pos.z] = enemyColor;
+        }
+      }
+    }
+    this.currentStepIndex--;
+    this.currentPlayer = lastStep.player;
+    this.recalculatePassCount();
+    if (this.currentStepIndex > 0) {
+      const previousStep = this.stepHistory[this.currentStepIndex - 1];
+      this.lastCapturedPositions = previousStep.capturedPositions || null;
+    } else {
+      this.lastCapturedPositions = null;
+    }
+    this.invalidateAnalysisCache();
+    if (this.callbacks.onStepBack) {
+      this.callbacks.onStepBack(lastStep, this.stepHistory.slice(0, this.currentStepIndex));
+    }
+    return true;
+  }
+  /**
+   * Redo next move (after undo)
+   *
+   * @returns true if redo was successful, false if no moves to redo
+   */
+  redo() {
+    if (this.currentStepIndex >= this.stepHistory.length) {
+      return false;
+    }
+    const nextStep = this.stepHistory[this.currentStepIndex];
+    if (nextStep.type === 0 /* DROP */ && nextStep.position) {
+      this.board[nextStep.position.x][nextStep.position.y][nextStep.position.z] = nextStep.player;
+      if (nextStep.capturedPositions) {
+        for (const pos of nextStep.capturedPositions) {
+          this.board[pos.x][pos.y][pos.z] = StoneType.EMPTY;
+        }
+      }
+      this.lastCapturedPositions = nextStep.capturedPositions || null;
+    } else if (nextStep.type === 1 /* PASS */) {
+      this.lastCapturedPositions = null;
+    }
+    this.currentStepIndex++;
+    this.currentPlayer = getEnemyColor(nextStep.player);
+    this.invalidateAnalysisCache();
+    if (this.callbacks.onStepAdvance) {
+      this.callbacks.onStepAdvance(
+        nextStep,
+        this.stepHistory.slice(0, this.currentStepIndex)
+      );
+    }
+    return true;
+  }
+  /**
+   * Check if redo is available
+   */
+  canRedo() {
+    return this.currentStepIndex < this.stepHistory.length;
+  }
+  /**
+   * Jump to specific step in history
+   * Rebuilds board state after applying the first 'index' moves
+   *
+   * @param index Number of moves to apply from history (0 for initial state, 1 for after first move, etc.)
+   * @returns true if jump was successful
+   */
+  jumpToStep(index) {
+    if (index < 0 || index > this.stepHistory.length) {
+      return false;
+    }
+    if (index === this.currentStepIndex) {
+      return false;
+    }
+    this.board = this.createEmptyBoard();
+    this.lastCapturedPositions = null;
+    for (let i = 0; i < index; i++) {
+      const step = this.stepHistory[i];
+      if (step.type === 0 /* DROP */ && step.position) {
+        const pos = step.position;
+        this.board[pos.x][pos.y][pos.z] = step.player;
+        if (step.capturedPositions) {
+          for (const capturedPos of step.capturedPositions) {
+            this.board[capturedPos.x][capturedPos.y][capturedPos.z] = StoneType.EMPTY;
+          }
+        }
+      }
+    }
+    if (index > 0) {
+      const lastAppliedStep = this.stepHistory[index - 1];
+      if (lastAppliedStep.type === 0 /* DROP */) {
+        this.lastCapturedPositions = lastAppliedStep.capturedPositions || null;
+      } else if (lastAppliedStep.type === 1 /* PASS */) {
+        this.lastCapturedPositions = null;
+      }
+    } else {
+      this.lastCapturedPositions = null;
+    }
+    const oldStepIndex = this.currentStepIndex;
+    this.currentStepIndex = index;
+    const movesPlayed = index;
+    this.currentPlayer = movesPlayed % 2 === 0 ? StoneType.BLACK : StoneType.WHITE;
+    this.recalculatePassCount();
+    this.invalidateAnalysisCache();
+    if (index < oldStepIndex && this.callbacks.onStepBack) {
+      const currentStep = this.stepHistory[index];
+      this.callbacks.onStepBack(currentStep, this.stepHistory.slice(0, index + 1));
+    } else if (index > oldStepIndex && this.callbacks.onStepAdvance) {
+      const currentStep = this.stepHistory[index];
+      this.callbacks.onStepAdvance(currentStep, this.stepHistory.slice(0, index + 1));
+    }
+    return true;
+  }
+  /**
+   * Advance to next step
+   * Equivalent to Game.stepAdvance() (lines 279-287)
+   */
+  advanceStep(step) {
+    if (this.currentStepIndex < this.stepHistory.length) {
+      this.stepHistory = this.stepHistory.slice(0, this.currentStepIndex);
+    }
+    this.stepHistory.push(step);
+    this.currentStepIndex++;
+    this.currentPlayer = getEnemyColor(this.currentPlayer);
+    if (this.callbacks.onStepAdvance) {
+      this.callbacks.onStepAdvance(step, this.stepHistory);
+    }
+  }
+  /**
+   * Get territory calculation
+   * Equivalent to Game.blackDomain() and Game.whiteDomain() (lines 232-244)
+   *
+   * Returns cached result if territory hasn't changed
+   */
+  getTerritory() {
+    if (!this.cachedTerritory)
+      this.cachedTerritory = calculateTerritory(this.board, this.shape);
+    return this.cachedTerritory;
+  }
+  /**
+   * Get captured stone counts up to current position in history
+   * Only counts captures that have been played (up to currentStepIndex)
+   */
+  getCapturedCounts() {
+    const counts = { black: 0, white: 0 };
+    for (let i = 0; i < this.currentStepIndex; i++) {
+      const step = this.stepHistory[i];
+      if (step.capturedPositions && step.capturedPositions.length > 0) {
+        const enemyColor = getEnemyColor(step.player);
+        if (enemyColor === StoneType.BLACK) {
+          counts.black += step.capturedPositions.length;
+        } else if (enemyColor === StoneType.WHITE) {
+          counts.white += step.capturedPositions.length;
+        }
+      }
+    }
+    return counts;
+  }
+  /**
+   * Serialize game state to JSON
+   * Equivalent to Game.serialize() (lines 250-252)
+   */
+  toJSON() {
+    return {
+      shape: this.shape,
+      currentPlayer: this.currentPlayer,
+      currentStepIndex: this.currentStepIndex,
+      history: this.stepHistory,
+      board: this.board,
+      gameStatus: this.gameStatus,
+      gameResult: this.gameResult,
+      passCount: this.passCount
+    };
+  }
+  /**
+   * Load game state from JSON
+   */
+  fromJSON(data) {
+    try {
+      if (!data || typeof data !== "object") {
+        return false;
+      }
+      if (!data.shape || !data.board || !Array.isArray(data.history)) {
+        return false;
+      }
+      this.shape = data.shape;
+      this.currentPlayer = data.currentPlayer;
+      this.currentStepIndex = data.currentStepIndex;
+      this.stepHistory = data.history || [];
+      this.board = data.board;
+      this.gameStatus = data.gameStatus || "idle";
+      this.gameResult = data.gameResult;
+      this.passCount = data.passCount || 0;
+      if (this.currentStepIndex > 0) {
+        const lastStep = this.stepHistory[this.currentStepIndex - 1];
+        this.lastCapturedPositions = lastStep.capturedPositions || null;
+      } else {
+        this.lastCapturedPositions = null;
+      }
+      this.invalidateAnalysisCache();
+      return true;
+    } catch (error) {
+      console.error("Failed to load game state:", error);
+      return false;
+    }
+  }
+  /**
+   * Get game statistics
+   */
+  getStats() {
+    const captured = this.getCapturedCounts();
+    const territory = this.getTerritory();
+    let blackMoves = 0;
+    let whiteMoves = 0;
+    for (const step of this.stepHistory.slice(0, this.currentStepIndex)) {
+      if (step.type === 0 /* DROP */) {
+        if (step.player === StoneType.BLACK) {
+          blackMoves++;
+        } else if (step.player === StoneType.WHITE) {
+          whiteMoves++;
+        }
+      }
+    }
+    return {
+      totalMoves: this.currentStepIndex,
+      blackMoves,
+      whiteMoves,
+      capturedByBlack: captured.white,
+      // Black captures white stones
+      capturedByWhite: captured.black,
+      // White captures black stones
+      territory
+    };
+  }
+  /**
+   * Save game state to sessionStorage
+   *
+   * @param key Storage key (default: "trigoGameState")
+   * @returns true if save was successful
+   */
+  saveToSessionStorage(key = "trigoGameState") {
+    if (typeof globalThis !== "undefined" && globalThis.sessionStorage) {
+      try {
+        const gameState = this.toJSON();
+        globalThis.sessionStorage.setItem(key, JSON.stringify(gameState));
+        return true;
+      } catch (error) {
+        console.error("Failed to save game state to sessionStorage:", error);
+        return false;
+      }
+    }
+    console.warn("sessionStorage is not available");
+    return false;
+  }
+  /**
+   * Load game state from sessionStorage
+   *
+   * @param key Storage key (default: "trigoGameState")
+   * @returns true if load was successful
+   */
+  loadFromSessionStorage(key = "trigoGameState") {
+    if (typeof globalThis !== "undefined" && globalThis.sessionStorage) {
+      try {
+        const savedState = globalThis.sessionStorage.getItem(key);
+        if (!savedState) {
+          console.log("No saved game state found");
+          return false;
+        }
+        const data = JSON.parse(savedState);
+        return this.fromJSON(data);
+      } catch (error) {
+        console.error("Failed to load game state from sessionStorage:", error);
+        return false;
+      }
+    }
+    console.warn("sessionStorage is not available");
+    return false;
+  }
+  /**
+   * Clear saved game state from sessionStorage
+   *
+   * @param key Storage key (default: "trigoGameState")
+   */
+  clearSessionStorage(key = "trigoGameState") {
+    if (typeof globalThis !== "undefined" && globalThis.sessionStorage) {
+      try {
+        globalThis.sessionStorage.removeItem(key);
+      } catch (error) {
+        console.error("Failed to clear sessionStorage:", error);
+      }
+    } else {
+      console.warn("sessionStorage is not available");
+    }
+  }
+  /**
+   * Export game to TGN (Trigo Game Notation) format
+   *
+   * TGN format is similar to PGN (Portable Game Notation) for chess.
+   * It includes metadata tags and move sequence using ab0yz coordinate notation.
+   *
+   * @param metadata Optional metadata for the game (Event, Site, Date, Players, etc.)
+   * @returns TGN-formatted string
+   *
+   * @example
+   * const tgn = game.toTGN({
+   *   event: "World Championship",
+   *   site: "Tokyo",
+   *   date: "2025.10.31",
+   *   black: "Alice",
+   *   white: "Bob"
+   * });
+   */
+  toTGN(metadata, { markResult } = {}) {
+    const lines = [];
+    if (metadata) {
+      if (metadata.event) lines.push(`[Event "${metadata.event}"]`);
+      if (metadata.site) lines.push(`[Site "${metadata.site}"]`);
+      if (metadata.date) lines.push(`[Date "${metadata.date}"]`);
+      if (metadata.round) lines.push(`[Round "${metadata.round}"]`);
+      if (metadata.black) lines.push(`[Black "${metadata.black}"]`);
+      if (metadata.white) lines.push(`[White "${metadata.white}"]`);
+    }
+    if (this.gameStatus === "finished" && this.gameResult) {
+      let resultStr = "";
+      if (this.gameResult.winner === "black") {
+        resultStr = "B+";
+      } else if (this.gameResult.winner === "white") {
+        resultStr = "W+";
+      } else {
+        resultStr = "=";
+      }
+      if (this.gameResult.score) {
+        const { black, white } = this.gameResult.score;
+        const diff = Math.abs(black - white);
+        resultStr += `${diff}points`;
+      } else if (this.gameResult.reason === "resignation") {
+        resultStr += "Resign";
+      }
+    }
+    const boardStr = this.shape.z === 1 ? `${this.shape.x}x${this.shape.y}` : `${this.shape.x}x${this.shape.y}x${this.shape.z}`;
+    lines.push(`[Board ${boardStr}]`);
+    if (metadata) {
+      if (metadata.rules) lines.push(`[Rules "${metadata.rules}"]`);
+      if (metadata.timeControl) lines.push(`[TimeControl "${metadata.timeControl}"]`);
+      if (metadata.application) lines.push(`[Application "${metadata.application}"]`);
+    }
+    lines.push("");
+    const moves = [];
+    let moveNumber = 1;
+    for (let i = 0; i < this.stepHistory.length; i++) {
+      const step = this.stepHistory[i];
+      let moveStr = "";
+      if (step.player === StoneType.BLACK) {
+        moveStr = `${moveNumber}. `;
+      }
+      if (step.type === 0 /* DROP */ && step.position) {
+        const pos = [step.position.x, step.position.y, step.position.z];
+        const boardShape = [this.shape.x, this.shape.y, this.shape.z];
+        const coord = encodeAb0yz(pos, boardShape);
+        moveStr += coord;
+      } else if (step.type === 1 /* PASS */) {
+        moveStr += "Pass";
+      } else if (step.type === 2 /* SURRENDER */) {
+        moveStr += "Resign";
+      }
+      moves.push(moveStr);
+      if (step.player === StoneType.WHITE) {
+        moveNumber++;
+      }
+    }
+    let currentLine = "";
+    for (let i = 0; i < moves.length; i++) {
+      const move = moves[i];
+      if (move.match(/^\d+\./)) {
+        if (currentLine) {
+          lines.push(currentLine);
+        }
+        currentLine = move;
+      } else {
+        currentLine += " " + move;
+      }
+    }
+    if (currentLine) {
+      lines.push(currentLine);
+    }
+    if (markResult) {
+      const territory = this.getTerritory();
+      const scoreDiff = territory.black - territory.white;
+      lines.push(`; ${scoreDiff > 0 ? "-" : scoreDiff < 0 ? "+" : ""}${Math.abs(scoreDiff)}`);
+    }
+    lines.push("");
+    return lines.join("\n");
+  }
+  /**
+   * Import game from TGN (Trigo Game Notation) format
+   *
+   * Static factory method that parses a TGN string and creates a new TrigoGame instance
+   * with the board configuration and moves from the TGN file.
+   *
+   * Synchronous operation - requires parser to be loaded via setParserModule()
+   *
+   * @param tgnString TGN-formatted game notation string
+   * @param callbacks Optional game callbacks
+   * @returns New TrigoGame instance with the imported game state
+   * @throws TGNParseError if the TGN string is invalid
+   *
+   * @example
+   * const tgnString = `
+   * [Event "World Championship"]
+   * [Board "5x5x5"]
+   * [Black "Alice"]
+   * [White "Bob"]
+   *
+   * 1. 000 y00
+   * 2. 0y0 pass
+   * `;
+   * const game = TrigoGame.fromTGN(tgnString);
+   */
+  static fromTGN(tgnString, callbacks) {
+    const parsed = parseTGN(tgnString);
+    let boardShape;
+    if (parsed.tags.Board && Array.isArray(parsed.tags.Board)) {
+      const shape = parsed.tags.Board;
+      boardShape = {
+        x: shape[0] || 5,
+        y: shape[1] || 5,
+        z: shape[2] || 1
+      };
+    } else {
+      boardShape = { x: 5, y: 5, z: 5 };
+    }
+    const game = new this(boardShape, callbacks);
+    game.startGame();
+    if (parsed.moves && parsed.moves.length > 0) {
+      for (const round of parsed.moves) {
+        if (round.action_black) {
+          game._applyParsedMove(round.action_black, boardShape);
+        }
+        if (round.action_white) {
+          game._applyParsedMove(round.action_white, boardShape);
+        }
+      }
+    }
+    return game;
+  }
+  /**
+   * Apply a parsed move action to the game
+   * Private helper method for fromTGN
+   *
+   * @param action Parsed move action from TGN parser
+   * @param boardShape Board dimensions for coordinate decoding
+   */
+  _applyParsedMove(action, boardShape) {
+    if (action.type === "pass") {
+      this.pass();
+    } else if (action.type === "resign") {
+      this.surrender();
+    } else if (action.type === "move" && action.position) {
+      const coords = decodeAb0yz(action.position, [boardShape.x, boardShape.y, boardShape.z]);
+      const position = {
+        x: coords[0],
+        y: coords[1],
+        z: coords[2]
+      };
+      this.drop(position);
+    }
+  }
+};
+
+// backend/src/services/gameManager.ts
+var GameManager = class {
+  // Default 5x5x5 board
+  constructor() {
+    this.rooms = /* @__PURE__ */ new Map();
+    this.playerRoomMap = /* @__PURE__ */ new Map();
+    this.defaultBoardShape = { x: 5, y: 5, z: 5 };
+    console.log("GameManager initialized");
+  }
+  createRoom(playerId, nickname, boardShape, preferredColor) {
+    const roomId = this.generateRoomId();
+    const shape = boardShape || this.defaultBoardShape;
+    const playerColor = preferredColor || "black";
+    const room = {
+      id: roomId,
+      adminId: playerId,
+      // Room creator is admin
+      players: {
+        [playerId]: {
+          id: playerId,
+          nickname,
+          color: playerColor,
+          connected: true
+        }
+      },
+      game: new TrigoGame(shape, {
+        onStepAdvance: (_step, history) => {
+          console.log(`Step ${history.length}: Player made move`);
+        },
+        onCapture: (captured) => {
+          console.log(`Captured ${captured.length} stones`);
+        },
+        onWin: (winner) => {
+          console.log(`Game won by ${winner}`);
+        }
+      }),
+      gameState: {
+        gameStatus: "waiting",
+        winner: null
+      },
+      createdAt: /* @__PURE__ */ new Date(),
+      startedAt: null
+    };
+    this.rooms.set(roomId, room);
+    this.playerRoomMap.set(playerId, roomId);
+    console.log(`Room ${roomId} created by ${playerId}`);
+    return room;
+  }
+  joinRoom(roomId, playerId, nickname, preferredColor) {
+    const room = this.rooms.get(roomId);
+    if (!room) {
+      return null;
+    }
+    const playerCount = Object.keys(room.players).length;
+    if (playerCount >= 2) {
+      return null;
+    }
+    const firstPlayer = Object.values(room.players)[0];
+    let assignedColor;
+    if (preferredColor && preferredColor !== firstPlayer.color) {
+      assignedColor = preferredColor;
+    } else {
+      assignedColor = firstPlayer.color === "black" ? "white" : "black";
+    }
+    room.players[playerId] = {
+      id: playerId,
+      nickname,
+      color: assignedColor,
+      connected: true
+    };
+    this.playerRoomMap.set(playerId, roomId);
+    if (playerCount === 1) {
+      room.gameState.gameStatus = "playing";
+      room.startedAt = /* @__PURE__ */ new Date();
+    }
+    return room;
+  }
+  leaveRoom(roomId, playerId) {
+    const room = this.rooms.get(roomId);
+    if (!room) return;
+    if (room.players[playerId]) {
+      room.players[playerId].connected = false;
+    }
+    this.playerRoomMap.delete(playerId);
+    const connectedPlayers = Object.values(room.players).filter((p) => p.connected);
+    if (connectedPlayers.length === 0) {
+      this.rooms.delete(roomId);
+      console.log(`Room ${roomId} deleted - no players remaining`);
+    }
+  }
+  makeMove(roomId, playerId, move) {
+    const room = this.rooms.get(roomId);
+    if (!room) return false;
+    const player = room.players[playerId];
+    if (!player) return false;
+    if (room.gameState.gameStatus !== "playing") {
+      return false;
+    }
+    const expectedPlayer = player.color === "black" ? StoneType.BLACK : StoneType.WHITE;
+    const currentPlayer = room.game.getCurrentPlayer();
+    if (currentPlayer !== expectedPlayer) {
+      return false;
+    }
+    const position = { x: move.x, y: move.y, z: move.z };
+    const success = room.game.drop(position);
+    return success;
+  }
+  passTurn(roomId, playerId) {
+    const room = this.rooms.get(roomId);
+    if (!room) return false;
+    const player = room.players[playerId];
+    if (!player) return false;
+    if (room.gameState.gameStatus !== "playing") {
+      return false;
+    }
+    const expectedPlayer = player.color === "black" ? StoneType.BLACK : StoneType.WHITE;
+    const currentPlayer = room.game.getCurrentPlayer();
+    if (currentPlayer !== expectedPlayer) {
+      return false;
+    }
+    return room.game.pass();
+  }
+  resign(roomId, playerId) {
+    const room = this.rooms.get(roomId);
+    if (!room) return false;
+    const player = room.players[playerId];
+    if (!player) return false;
+    room.game.surrender();
+    room.gameState.gameStatus = "finished";
+    room.gameState.winner = player.color === "black" ? "white" : "black";
+    return true;
+  }
+  /**
+   * Undo the last move (悔棋)
+   */
+  undoMove(roomId, playerId) {
+    const room = this.rooms.get(roomId);
+    if (!room) return false;
+    const player = room.players[playerId];
+    if (!player) return false;
+    if (room.gameState.gameStatus !== "playing") {
+      return false;
+    }
+    return room.game.undo();
+  }
+  /**
+   * Redo the last undone move (forward in history)
+   */
+  redoMove(roomId, playerId) {
+    const room = this.rooms.get(roomId);
+    if (!room) return false;
+    const player = room.players[playerId];
+    if (!player) return false;
+    if (room.gameState.gameStatus !== "playing") {
+      return false;
+    }
+    return room.game.redo();
+  }
+  /**
+   * Reset the game to initial state (new game in same room)
+   * Only admin can reset the game
+   */
+  resetGame(roomId, adminId, options) {
+    const room = this.rooms.get(roomId);
+    if (!room) return { success: false, error: "Room not found" };
+    if (room.adminId !== adminId) {
+      return { success: false, error: "Only room admin can reset the game" };
+    }
+    const boardShape = options?.boardShape;
+    const playerColors = options?.playerColors;
+    if (playerColors) {
+      const playerIds = Object.keys(room.players);
+      for (const playerId of playerIds) {
+        if (playerColors[playerId]) {
+          room.players[playerId].color = playerColors[playerId];
+        }
+      }
+      console.log(`Player colors assigned:`, playerColors);
+    }
+    if (boardShape) {
+      const currentShape = room.game.getShape();
+      if (boardShape.x !== currentShape.x || boardShape.y !== currentShape.y || boardShape.z !== currentShape.z) {
+        room.game = new TrigoGame(boardShape, {
+          onStepAdvance: (_step, history) => {
+            console.log(`Step ${history.length}: Player made move`);
+          },
+          onCapture: (captured) => {
+            console.log(`Captured ${captured.length} stones`);
+          },
+          onWin: (winner) => {
+            console.log(`Game won by ${winner}`);
+          }
+        });
+        console.log(`Game ${roomId} reset with new board shape: ${boardShape.x}x${boardShape.y}x${boardShape.z}`);
+      } else {
+        room.game.reset();
+        console.log(`Game ${roomId} reset to initial state`);
+      }
+    } else {
+      room.game.reset();
+      console.log(`Game ${roomId} reset to initial state`);
+    }
+    room.gameState.gameStatus = "playing";
+    room.gameState.winner = null;
+    room.startedAt = /* @__PURE__ */ new Date();
+    return { success: true };
+  }
+  /**
+   * Get game board state for a room
+   */
+  getGameBoard(roomId) {
+    const room = this.rooms.get(roomId);
+    if (!room) return null;
+    return room.game.getBoard();
+  }
+  /**
+   * Get game statistics for a room
+   */
+  getGameStats(roomId) {
+    const room = this.rooms.get(roomId);
+    if (!room) return null;
+    return room.game.getStats();
+  }
+  /**
+   * Get current player for a room
+   */
+  getCurrentPlayer(roomId) {
+    const room = this.rooms.get(roomId);
+    if (!room) return null;
+    const currentStone = room.game.getCurrentPlayer();
+    return currentStone === StoneType.BLACK ? "black" : "white";
+  }
+  /**
+   * Calculate and get territory for a room
+   */
+  getTerritory(roomId) {
+    const room = this.rooms.get(roomId);
+    if (!room) return null;
+    return room.game.getTerritory();
+  }
+  /**
+   * End the game and determine winner based on territory
+   */
+  endGameByTerritory(roomId) {
+    const room = this.rooms.get(roomId);
+    if (!room) return false;
+    if (room.gameState.gameStatus !== "playing") {
+      return false;
+    }
+    const territory = room.game.getTerritory();
+    if (territory.black > territory.white) {
+      room.gameState.winner = "black";
+    } else if (territory.white > territory.black) {
+      room.gameState.winner = "white";
+    } else {
+      room.gameState.winner = null;
+    }
+    room.gameState.gameStatus = "finished";
+    console.log(
+      `Game ${roomId} ended. Black: ${territory.black}, White: ${territory.white}, Winner: ${room.gameState.winner}`
+    );
+    return true;
+  }
+  /**
+   * Check if both players passed consecutively (game should end)
+   * Returns true if game was ended
+   */
+  checkConsecutivePasses(roomId) {
+    const room = this.rooms.get(roomId);
+    if (!room) return false;
+    const history = room.game.getHistory();
+    if (history.length < 2) return false;
+    const lastMove = history[history.length - 1];
+    const secondLastMove = history[history.length - 2];
+    if (lastMove.type === 1 /* PASS */ && secondLastMove.type === 1 /* PASS */) {
+      this.endGameByTerritory(roomId);
+      return true;
+    }
+    return false;
+  }
+  getRoom(roomId) {
+    return this.rooms.get(roomId);
+  }
+  getPlayerRoom(playerId) {
+    const roomId = this.playerRoomMap.get(playerId);
+    if (!roomId) return void 0;
+    return this.rooms.get(roomId);
+  }
+  getActiveRooms() {
+    return Array.from(this.rooms.values()).filter(
+      (room) => room.gameState.gameStatus !== "finished"
+    );
+  }
+  generateRoomId() {
+    return uuidv4().substring(0, 8).toUpperCase();
+  }
+};
+
+// backend/src/sockets/gameSocket.ts
+function getRoomSummary(room) {
+  const connectedPlayers = Object.values(room.players).filter((p) => p.connected);
+  return {
+    id: room.id,
+    playerCount: connectedPlayers.length,
+    maxPlayers: 2,
+    status: room.gameState.gameStatus,
+    isFull: connectedPlayers.length >= 2,
+    createdAt: room.createdAt.toISOString()
+  };
+}
+function setupSocketHandlers(io2, socket, gameManager2) {
+  console.log(`Setting up socket handlers for ${socket.id}`);
+  socket.on("listRooms", (callback) => {
+    const rooms = gameManager2.getActiveRooms();
+    const roomList = rooms.map((room) => getRoomSummary(room));
+    if (callback) {
+      callback({ success: true, rooms: roomList });
+    }
+  });
+  socket.on(
+    "joinRoom",
+    (data, callback) => {
+      console.log("[gameSocket] joinRoom event received:", {
+        roomId: data.roomId,
+        nickname: data.nickname,
+        preferredColor: data.preferredColor,
+        hasCallback: !!callback,
+        socketId: socket.id
+      });
+      const { roomId, nickname, preferredColor } = data;
+      try {
+        let room;
+        if (roomId) {
+          const existingRoom = gameManager2.getRoom(roomId);
+          if (!existingRoom) {
+            if (callback) {
+              callback({
+                success: false,
+                error: "Room not found",
+                errorCode: "ROOM_NOT_FOUND"
+              });
+            }
+            return;
+          }
+          const playerCount = Object.keys(existingRoom.players).length;
+          if (playerCount >= 2) {
+            if (callback) {
+              callback({
+                success: false,
+                error: "Room is full",
+                errorCode: "ROOM_FULL"
+              });
+            }
+            return;
+          }
+          room = gameManager2.joinRoom(roomId, socket.id, nickname, preferredColor);
+        } else {
+          room = gameManager2.createRoom(socket.id, nickname, void 0, preferredColor);
+        }
+        if (room) {
+          socket.join(room.id);
+          const roomSockets = io2.sockets.adapter.rooms.get(room.id);
+          console.log(`[gameSocket] Socket ${socket.id} joined room ${room.id}`);
+          console.log(`[gameSocket] Room ${room.id} now has sockets:`, roomSockets ? Array.from(roomSockets) : []);
+          const currentPlayer = gameManager2.getCurrentPlayer(room.id);
+          const stats = gameManager2.getGameStats(room.id);
+          const tgn = room.game.toTGN();
+          const players = {};
+          for (const [pid, player] of Object.entries(room.players)) {
+            players[pid] = {
+              nickname: player.nickname,
+              color: player.color
+            };
+          }
+          const response = {
+            success: true,
+            roomId: room.id,
+            playerId: socket.id,
+            playerColor: room.players[socket.id]?.color,
+            isAdmin: room.adminId === socket.id,
+            adminId: room.adminId,
+            players,
+            // Include all players in room
+            gameState: {
+              boardShape: room.game.getShape(),
+              currentPlayer,
+              currentMoveIndex: room.game.getCurrentStep(),
+              capturedStones: {
+                black: stats?.capturedByBlack || 0,
+                white: stats?.capturedByWhite || 0
+              },
+              gameStatus: room.gameState.gameStatus,
+              winner: room.gameState.winner,
+              tgn
+            }
+          };
+          if (callback) {
+            console.log("[gameSocket] Sending response via callback:", {
+              roomId: response.roomId,
+              playerColor: response.playerColor
+            });
+            callback(response);
+          } else {
+            console.log("[gameSocket] No callback, using roomJoined emit");
+            socket.emit("roomJoined", response);
+          }
+          console.log(`[gameSocket] Broadcasting playerJoined to room ${room.id} (excluding ${socket.id})`);
+          socket.to(room.id).emit("playerJoined", {
+            playerId: socket.id,
+            nickname
+          });
+          console.log(`[gameSocket] playerJoined broadcast sent`);
+          const roomSummary = getRoomSummary(room);
+          if (roomId) {
+            io2.emit("roomUpdated", roomSummary);
+          } else {
+            io2.emit("roomCreated", roomSummary);
+          }
+          console.log(
+            `Player ${socket.id} ${roomId ? "joined" : "created"} room ${room.id}`
+          );
+        } else {
+          if (callback) {
+            callback({
+              success: false,
+              error: "Failed to join or create room",
+              errorCode: "UNKNOWN_ERROR"
+            });
+          }
+        }
+      } catch (error) {
+        console.error(`Error in joinRoom handler:`, error);
+        if (callback) {
+          callback({
+            success: false,
+            error: "Server error",
+            errorCode: "SERVER_ERROR"
+          });
+        }
+      }
+    }
+  );
+  socket.on("leaveRoom", () => {
+    const room = gameManager2.getPlayerRoom(socket.id);
+    if (room) {
+      const roomId = room.id;
+      socket.leave(room.id);
+      gameManager2.leaveRoom(room.id, socket.id);
+      socket.to(roomId).emit("playerLeft", {
+        playerId: socket.id
+      });
+      const updatedRoom = gameManager2.getRoom(roomId);
+      if (updatedRoom) {
+        io2.emit("roomUpdated", getRoomSummary(updatedRoom));
+      } else {
+        io2.emit("roomDeleted", { roomId });
+      }
+    }
+  });
+  socket.on("makeMove", (data) => {
+    const room = gameManager2.getPlayerRoom(socket.id);
+    if (room && gameManager2.makeMove(room.id, socket.id, data)) {
+      const currentPlayer = gameManager2.getCurrentPlayer(room.id);
+      const stats = gameManager2.getGameStats(room.id);
+      const lastStep = room.game.getLastStep();
+      const tgn = room.game.toTGN();
+      io2.to(room.id).emit("gameUpdate", {
+        currentPlayer,
+        action: "move",
+        lastMove: data,
+        capturedStones: {
+          black: stats?.capturedByBlack || 0,
+          white: stats?.capturedByWhite || 0
+        },
+        capturedPositions: lastStep?.capturedPositions,
+        currentMoveIndex: room.game.getCurrentStep(),
+        tgn
+      });
+    } else {
+      socket.emit("error", { message: "Invalid move" });
+    }
+  });
+  socket.on("pass", () => {
+    const room = gameManager2.getPlayerRoom(socket.id);
+    if (room && gameManager2.passTurn(room.id, socket.id)) {
+      const currentPlayer = gameManager2.getCurrentPlayer(room.id);
+      const tgn = room.game.toTGN();
+      io2.to(room.id).emit("gameUpdate", {
+        currentPlayer,
+        action: "pass",
+        currentMoveIndex: room.game.getCurrentStep(),
+        tgn
+      });
+      if (gameManager2.checkConsecutivePasses(room.id)) {
+        const territory = gameManager2.getTerritory(room.id);
+        io2.to(room.id).emit("gameEnded", {
+          winner: room.gameState.winner,
+          reason: "double-pass",
+          territory
+        });
+      }
+    }
+  });
+  socket.on("resign", () => {
+    const room = gameManager2.getPlayerRoom(socket.id);
+    if (room && gameManager2.resign(room.id, socket.id)) {
+      io2.to(room.id).emit("gameEnded", {
+        winner: room.gameState.winner,
+        reason: "resignation"
+      });
+    }
+  });
+  socket.on("undoMove", (callback) => {
+    const room = gameManager2.getPlayerRoom(socket.id);
+    if (!room) {
+      if (callback) callback({ success: false, error: "Not in a room", errorCode: "NOT_IN_ROOM" });
+      return;
+    }
+    if (room.gameState.gameStatus !== "playing") {
+      if (callback) callback({ success: false, error: "Game not active", errorCode: "GAME_NOT_ACTIVE" });
+      return;
+    }
+    const success = gameManager2.undoMove(room.id, socket.id);
+    if (success) {
+      const currentPlayer = gameManager2.getCurrentPlayer(room.id);
+      const stats = gameManager2.getGameStats(room.id);
+      const tgn = room.game.toTGN();
+      io2.to(room.id).emit("gameUpdate", {
+        currentPlayer,
+        action: "undo",
+        currentMoveIndex: room.game.getCurrentStep(),
+        capturedStones: {
+          black: stats?.capturedByBlack || 0,
+          white: stats?.capturedByWhite || 0
+        },
+        tgn
+      });
+      if (callback) callback({ success: true });
+    } else {
+      if (callback) callback({ success: false, error: "Cannot undo", errorCode: "UNDO_FAILED" });
+    }
+  });
+  socket.on("redoMove", (callback) => {
+    const room = gameManager2.getPlayerRoom(socket.id);
+    if (!room) {
+      if (callback) callback({ success: false, error: "Not in a room", errorCode: "NOT_IN_ROOM" });
+      return;
+    }
+    if (room.gameState.gameStatus !== "playing") {
+      if (callback) callback({ success: false, error: "Game not active", errorCode: "GAME_NOT_ACTIVE" });
+      return;
+    }
+    if (!room.game.canRedo()) {
+      if (callback) callback({ success: false, error: "Nothing to redo", errorCode: "NOTHING_TO_REDO" });
+      return;
+    }
+    const success = gameManager2.redoMove(room.id, socket.id);
+    if (success) {
+      const currentPlayer = gameManager2.getCurrentPlayer(room.id);
+      const stats = gameManager2.getGameStats(room.id);
+      const lastStep = room.game.getLastStep();
+      const tgn = room.game.toTGN();
+      io2.to(room.id).emit("gameUpdate", {
+        currentPlayer,
+        action: "redo",
+        lastMove: lastStep?.position,
+        capturedStones: {
+          black: stats?.capturedByBlack || 0,
+          white: stats?.capturedByWhite || 0
+        },
+        capturedPositions: lastStep?.capturedPositions,
+        currentMoveIndex: room.game.getCurrentStep(),
+        tgn
+      });
+      if (callback) callback({ success: true });
+    } else {
+      if (callback) callback({ success: false, error: "Redo failed", errorCode: "REDO_FAILED" });
+    }
+  });
+  socket.on("resetGame", (data, callback) => {
+    const room = gameManager2.getPlayerRoom(socket.id);
+    if (!room) {
+      const cb = typeof data === "function" ? data : callback;
+      if (cb) cb({ success: false, error: "Not in a room", errorCode: "NOT_IN_ROOM" });
+      return;
+    }
+    const options = typeof data === "object" && data !== null ? {
+      boardShape: data.boardShape,
+      playerColors: data.playerColors
+    } : void 0;
+    const responseCb = typeof data === "function" ? data : callback;
+    const result = gameManager2.resetGame(room.id, socket.id, options);
+    if (result.success) {
+      const currentPlayer = gameManager2.getCurrentPlayer(room.id);
+      const tgn = room.game.toTGN();
+      const players = {};
+      for (const [pid, player] of Object.entries(room.players)) {
+        players[pid] = {
+          nickname: player.nickname,
+          color: player.color
+        };
+      }
+      io2.to(room.id).emit("gameReset", {
+        currentPlayer,
+        boardShape: room.game.getShape(),
+        currentMoveIndex: 0,
+        capturedStones: { black: 0, white: 0 },
+        players,
+        tgn
+      });
+      if (responseCb) responseCb({ success: true });
+    } else {
+      if (responseCb) responseCb({
+        success: false,
+        error: result.error || "Reset failed",
+        errorCode: result.error === "Only room admin can reset the game" ? "NOT_ADMIN" : "RESET_FAILED"
+      });
+    }
+  });
+  socket.on("chatMessage", (data) => {
+    const room = gameManager2.getPlayerRoom(socket.id);
+    if (room) {
+      const player = room.players[socket.id];
+      io2.to(room.id).emit("chatMessage", {
+        author: player?.nickname || "Unknown",
+        content: data.content,
+        playerId: socket.id
+      });
+    }
+  });
+  socket.on(
+    "changeNickname",
+    (data, callback) => {
+      const room = gameManager2.getPlayerRoom(socket.id);
+      if (!room) {
+        const error = { success: false, error: "Not in a room" };
+        if (callback) callback(error);
+        return;
+      }
+      const validation = validateNickname(data.nickname);
+      if (!validation.valid) {
+        const error = { success: false, error: validation.error };
+        if (callback) callback(error);
+        return;
+      }
+      const player = room.players[socket.id];
+      if (player) {
+        const oldNickname = player.nickname;
+        player.nickname = data.nickname;
+        io2.to(room.id).emit("nicknameChanged", {
+          playerId: socket.id,
+          nickname: data.nickname,
+          oldNickname
+        });
+        console.log(`Player ${socket.id} changed nickname: ${oldNickname} -> ${data.nickname}`);
+        if (callback) {
+          callback({ success: true, nickname: data.nickname });
+        }
+      }
+    }
+  );
+  socket.on("disconnect", () => {
+    console.log(`Client disconnected: ${socket.id}`);
+    const room = gameManager2.getPlayerRoom(socket.id);
+    if (room) {
+      const roomId = room.id;
+      gameManager2.leaveRoom(room.id, socket.id);
+      socket.to(room.id).emit("playerDisconnected", {
+        playerId: socket.id
+      });
+      const updatedRoom = gameManager2.getRoom(roomId);
+      if (updatedRoom) {
+        io2.emit("roomUpdated", getRoomSummary(updatedRoom));
+      } else {
+        io2.emit("roomDeleted", { roomId });
+      }
+    }
+  });
+}
+function validateNickname(nickname) {
+  if (!nickname || typeof nickname !== "string") {
+    return { valid: false, error: "Invalid nickname" };
+  }
+  const trimmed = nickname.trim();
+  if (trimmed.length < 3) {
+    return { valid: false, error: "Nickname must be at least 3 characters" };
+  }
+  if (trimmed.length > 20) {
+    return { valid: false, error: "Nickname must be 20 characters or less" };
+  }
+  if (!/^[a-zA-Z0-9 ]+$/.test(trimmed)) {
+    return { valid: false, error: "Only letters, numbers, and spaces allowed" };
+  }
+  if (trimmed !== nickname) {
+    return { valid: false, error: "No leading or trailing spaces allowed" };
+  }
+  return { valid: true };
+}
+
+// backend/src/server.ts
+var __filename = fileURLToPath(import.meta.url);
+var __dirname = path.dirname(__filename);
+var isDev = __dirname.includes("/src") && !__dirname.includes("/dist");
+var levelsUp = isDev ? "../" : "../../../";
+var envPath = path.join(__dirname, levelsUp, ".env");
+var envLocalPath = path.join(__dirname, levelsUp, ".env.local");
+if (fs.existsSync(envPath)) {
+  dotenv.config({ path: envPath });
+  console.log("[Config] Loaded .env");
+} else {
+  console.log(`[Config] .env not found at: ${envPath}`);
+}
+if (fs.existsSync(envLocalPath)) {
+  dotenv.config({ path: envLocalPath, override: true });
+  console.log("[Config] Loaded .env.local (overriding .env)");
+} else {
+  console.log(`[Config] .env.local not found at: ${envLocalPath}`);
+}
+var app = express();
+var httpServer = createServer(app);
+var io = new Server(httpServer, {
+  cors: {
+    origin: process.env.NODE_ENV === "production" ? process.env.CLIENT_URL || "http://localhost:5173" : true,
+    // Allow all origins in development
+    methods: ["GET", "POST"],
+    credentials: true
+  }
+});
+var gameManager = new GameManager();
+var PORT = parseInt(process.env.PORT || "3000", 10);
+var HOST = process.env.HOST || "0.0.0.0";
+console.log(`[Config] Server Configuration:`);
+console.log(`[Config]   PORT: ${PORT}`);
+console.log(`[Config]   HOST: ${HOST}`);
+console.log(`[Config]   NODE_ENV: ${process.env.NODE_ENV || "development"}`);
+console.log(`[Config]   CLIENT_URL: ${process.env.CLIENT_URL || "not set"}`);
+app.use(cors());
+app.use(express.json());
+if (process.env.NODE_ENV === "production") {
+  const frontendPath = path.join(__dirname, "../../../../app/dist");
+  app.use(express.static(frontendPath));
+  app.get("*", (req, res, next) => {
+    if (req.path.startsWith("/health") || req.path.startsWith("/socket.io")) {
+      return next();
+    }
+    res.sendFile(path.join(frontendPath, "index.html"));
+  });
+}
+app.get("/health", (_req, res) => {
+  res.json({ status: "ok", timestamp: (/* @__PURE__ */ new Date()).toISOString() });
+});
+io.on("connection", (socket) => {
+  console.log(`New client connected: ${socket.id}`);
+  setupSocketHandlers(io, socket, gameManager);
+  socket.on("echo", (data, callback) => {
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+    const responseMessage = `Hello from server! Received: "${data.message}" at ${timestamp}`;
+    console.log(`[Echo] Client ${socket.id}: ${data.message}`);
+    if (callback && typeof callback === "function") {
+      callback({
+        message: responseMessage,
+        serverTime: timestamp,
+        clientTime: data.timestamp
+      });
+    }
+  });
+  socket.on("disconnect", () => {
+    console.log(`Client disconnected: ${socket.id}`);
+  });
+});
+httpServer.listen(PORT, HOST, () => {
+  console.log(`Server running on ${HOST}:${PORT}`);
+  console.log(`Health check: http://${HOST}:${PORT}/health`);
+  console.log(`Environment: ${process.env.NODE_ENV || "development"}`);
+});

trigo-web/backend/dist/server.js

@@ -0,0 +1,2104 @@
+// backend/src/server.ts
+import express from "express";
+import { createServer } from "http";
+import { Server } from "socket.io";
+import cors from "cors";
+import dotenv from "dotenv";
+import path from "path";
+import fs from "fs";
+import { fileURLToPath } from "url";
+
+// backend/src/services/gameManager.ts
+import { v4 as uuidv4 } from "uuid";
+
+// inc/trigo/gameUtils.ts
+var StoneType = {
+  EMPTY: 0,
+  BLACK: 1,
+  WHITE: 2
+};
+function getEnemyColor(color) {
+  if (color === StoneType.BLACK) return StoneType.WHITE;
+  if (color === StoneType.WHITE) return StoneType.BLACK;
+  return StoneType.EMPTY;
+}
+function isInBounds(pos, shape) {
+  return pos.x >= 0 && pos.x < shape.x && pos.y >= 0 && pos.y < shape.y && pos.z >= 0 && pos.z < shape.z;
+}
+function getNeighbors(pos, shape) {
+  const neighbors = [];
+  const directions = [
+    { x: 1, y: 0, z: 0 },
+    { x: -1, y: 0, z: 0 },
+    { x: 0, y: 1, z: 0 },
+    { x: 0, y: -1, z: 0 },
+    { x: 0, y: 0, z: 1 },
+    { x: 0, y: 0, z: -1 }
+  ];
+  for (const dir of directions) {
+    const neighbor = {
+      x: pos.x + dir.x,
+      y: pos.y + dir.y,
+      z: pos.z + dir.z
+    };
+    if (isInBounds(neighbor, shape)) {
+      neighbors.push(neighbor);
+    }
+  }
+  return neighbors;
+}
+function positionsEqual(p1, p2) {
+  return p1.x === p2.x && p1.y === p2.y && p1.z === p2.z;
+}
+var CoordSet = class {
+  constructor() {
+    this.positions = [];
+  }
+  has(pos) {
+    return this.positions.some((p) => positionsEqual(p, pos));
+  }
+  insert(pos) {
+    if (!this.has(pos)) {
+      this.positions.push(pos);
+      return true;
+    }
+    return false;
+  }
+  remove(pos) {
+    this.positions = this.positions.filter((p) => !positionsEqual(p, pos));
+  }
+  size() {
+    return this.positions.length;
+  }
+  empty() {
+    return this.positions.length === 0;
+  }
+  forEach(callback) {
+    this.positions.forEach(callback);
+  }
+  toArray() {
+    return [...this.positions];
+  }
+  clear() {
+    this.positions = [];
+  }
+};
+var Patch = class {
+  constructor(color = StoneType.EMPTY) {
+    this.positions = new CoordSet();
+    this.color = StoneType.EMPTY;
+    this.color = color;
+  }
+  addStone(pos) {
+    this.positions.insert(pos);
+  }
+  size() {
+    return this.positions.size();
+  }
+  /**
+   * Get all liberties (empty adjacent positions) for this group
+   *
+   * Equivalent to StoneArray.patchAir() in prototype
+   * Returns a CoordSet of empty positions adjacent to this patch
+   */
+  getLiberties(board, shape) {
+    const liberties = new CoordSet();
+    this.positions.forEach((stonePos) => {
+      const neighbors = getNeighbors(stonePos, shape);
+      for (const neighbor of neighbors) {
+        if (board[neighbor.x][neighbor.y][neighbor.z] === StoneType.EMPTY) {
+          liberties.insert(neighbor);
+        }
+      }
+    });
+    return liberties;
+  }
+};
+function findGroup(pos, board, shape) {
+  const color = board[pos.x][pos.y][pos.z];
+  const group = new Patch(color);
+  if (color === StoneType.EMPTY) {
+    return group;
+  }
+  const visited = new CoordSet();
+  const stack = [pos];
+  while (stack.length > 0) {
+    const current = stack.pop();
+    if (visited.has(current)) {
+      continue;
+    }
+    visited.insert(current);
+    if (board[current.x][current.y][current.z] === color) {
+      group.addStone(current);
+      const neighbors = getNeighbors(current, shape);
+      for (const neighbor of neighbors) {
+        if (!visited.has(neighbor)) {
+          stack.push(neighbor);
+        }
+      }
+    }
+  }
+  return group;
+}
+function getNeighborGroups(pos, board, shape, excludeEmpty = false) {
+  const neighbors = getNeighbors(pos, shape);
+  const groups = [];
+  const processedPositions = new CoordSet();
+  for (const neighbor of neighbors) {
+    if (processedPositions.has(neighbor)) {
+      continue;
+    }
+    const stone = board[neighbor.x][neighbor.y][neighbor.z];
+    if (excludeEmpty && stone === StoneType.EMPTY) {
+      continue;
+    }
+    if (stone !== StoneType.EMPTY) {
+      const group = findGroup(neighbor, board, shape);
+      group.positions.forEach((p) => processedPositions.insert(p));
+      groups.push(group);
+    }
+  }
+  return groups;
+}
+function isGroupCaptured(group, board, shape) {
+  const liberties = group.getLiberties(board, shape);
+  return liberties.size() === 0;
+}
+function findCapturedGroups(pos, playerColor, board, shape) {
+  const enemyColor = getEnemyColor(playerColor);
+  const captured = [];
+  const tempBoard = board.map((plane) => plane.map((row) => [...row]));
+  tempBoard[pos.x][pos.y][pos.z] = playerColor;
+  const neighborGroups = getNeighborGroups(pos, tempBoard, shape, true);
+  for (const group of neighborGroups) {
+    if (group.color === enemyColor) {
+      if (isGroupCaptured(group, tempBoard, shape)) {
+        captured.push(group);
+      }
+    }
+  }
+  return captured;
+}
+function isSuicideMove(pos, playerColor, board, shape) {
+  const tempBoard = board.map((plane) => plane.map((row) => [...row]));
+  tempBoard[pos.x][pos.y][pos.z] = playerColor;
+  const capturedGroups = findCapturedGroups(pos, playerColor, board, shape);
+  if (capturedGroups.length > 0) {
+    return false;
+  }
+  const placedGroup = findGroup(pos, tempBoard, shape);
+  const liberties = placedGroup.getLiberties(tempBoard, shape);
+  return liberties.size() === 0;
+}
+function isKoViolation(pos, playerColor, board, shape, lastCapturedPositions) {
+  if (!lastCapturedPositions || lastCapturedPositions.length !== 1) {
+    return false;
+  }
+  const capturedGroups = findCapturedGroups(pos, playerColor, board, shape);
+  if (capturedGroups.length !== 1 || capturedGroups[0].size() !== 1) {
+    return false;
+  }
+  const previouslyCaptured = lastCapturedPositions[0];
+  if (positionsEqual(pos, previouslyCaptured)) {
+    return true;
+  }
+  return false;
+}
+function executeCaptures(capturedGroups, board) {
+  const capturedPositions = [];
+  for (const group of capturedGroups) {
+    group.positions.forEach((pos) => {
+      board[pos.x][pos.y][pos.z] = StoneType.EMPTY;
+      capturedPositions.push(pos);
+    });
+  }
+  return capturedPositions;
+}
+function findEmptyRegion(startPos, board, shape, visited) {
+  const region = new CoordSet();
+  const stack = [startPos];
+  while (stack.length > 0) {
+    const pos = stack.pop();
+    if (visited.has(pos)) {
+      continue;
+    }
+    visited.insert(pos);
+    if (board[pos.x][pos.y][pos.z] === StoneType.EMPTY) {
+      region.insert(pos);
+      const neighbors = getNeighbors(pos, shape);
+      for (const neighbor of neighbors) {
+        if (!visited.has(neighbor)) {
+          stack.push(neighbor);
+        }
+      }
+    }
+  }
+  return region;
+}
+function determineRegionOwner(region, board, shape) {
+  let owner = StoneType.EMPTY;
+  let solved = false;
+  region.forEach((pos) => {
+    if (solved) return;
+    const neighbors = getNeighbors(pos, shape);
+    for (const neighbor of neighbors) {
+      if (solved) break;
+      const stone = board[neighbor.x][neighbor.y][neighbor.z];
+      if (stone !== StoneType.EMPTY) {
+        if (owner === StoneType.EMPTY) {
+          owner = stone;
+        } else if (owner !== stone) {
+          owner = StoneType.EMPTY;
+          solved = true;
+        }
+      }
+    }
+  });
+  return owner;
+}
+function calculateTerritory(board, shape) {
+  const result = {
+    black: 0,
+    white: 0,
+    neutral: 0,
+    blackTerritory: [],
+    whiteTerritory: [],
+    neutralTerritory: []
+  };
+  const visited = new CoordSet();
+  const emptyRegions = [];
+  for (let x = 0; x < shape.x; x++) {
+    for (let y = 0; y < shape.y; y++) {
+      for (let z = 0; z < shape.z; z++) {
+        const pos = { x, y, z };
+        const stone = board[x][y][z];
+        if (stone === StoneType.BLACK) {
+          result.black++;
+          result.blackTerritory.push(pos);
+        } else if (stone === StoneType.WHITE) {
+          result.white++;
+          result.whiteTerritory.push(pos);
+        } else if (!visited.has(pos)) {
+          const region = findEmptyRegion(pos, board, shape, visited);
+          emptyRegions.push(region);
+        }
+      }
+    }
+  }
+  for (const region of emptyRegions) {
+    const owner = determineRegionOwner(region, board, shape);
+    const regionArray = region.toArray();
+    if (owner === StoneType.BLACK) {
+      result.black += region.size();
+      result.blackTerritory.push(...regionArray);
+    } else if (owner === StoneType.WHITE) {
+      result.white += region.size();
+      result.whiteTerritory.push(...regionArray);
+    } else {
+      result.neutral += region.size();
+      result.neutralTerritory.push(...regionArray);
+    }
+  }
+  return result;
+}
+function validateMove(pos, playerColor, board, shape, lastCapturedPositions = null) {
+  if (!isInBounds(pos, shape)) {
+    return { valid: false, reason: "Position out of bounds" };
+  }
+  if (board[pos.x][pos.y][pos.z] !== StoneType.EMPTY) {
+    return { valid: false, reason: "Position already occupied" };
+  }
+  if (isKoViolation(pos, playerColor, board, shape, lastCapturedPositions)) {
+    return { valid: false, reason: "Ko rule violation" };
+  }
+  if (isSuicideMove(pos, playerColor, board, shape)) {
+    return { valid: false, reason: "suicide move not allowed" };
+  }
+  return { valid: true };
+}
+
+// inc/trigo/ab0yz.ts
+var compactShape = (shape) => shape[shape.length - 1] === 1 ? compactShape(shape.slice(0, shape.length - 1)) : shape;
+var encodeAb0yz = (pos, boardShape) => {
+  const compactedShape = compactShape(boardShape);
+  const result = [];
+  for (let i = 0; i < compactedShape.length; i++) {
+    const size = compactedShape[i];
+    const center = (size - 1) / 2;
+    const index = pos[i];
+    if (index === center) {
+      result.push("0");
+    } else if (index < center) {
+      result.push(String.fromCharCode(97 + index));
+    } else {
+      const offset = size - 1 - index;
+      result.push(String.fromCharCode(122 - offset));
+    }
+  }
+  return result.join("");
+};
+var decodeAb0yz = (code, boardShape) => {
+  const compactedShape = compactShape(boardShape);
+  if (code.length !== compactedShape.length) {
+    throw new Error(
+      `Invalid TGN coordinate: "${code}" (must be ${compactedShape.length} characters for board shape ${boardShape.join("x")})`
+    );
+  }
+  const result = [];
+  for (let i = 0; i < compactedShape.length; i++) {
+    const char = code[i];
+    const size = compactedShape[i];
+    const center = (size - 1) / 2;
+    if (char === "0") {
+      console.assert(Number.isInteger(center));
+      result.push(center);
+    } else {
+      const charCode = char.charCodeAt(0);
+      if (charCode >= 97 && charCode <= 122) {
+        const distFromA = charCode - 97;
+        const distFromZ = 122 - charCode;
+        if (distFromA < distFromZ) {
+          const index = distFromA;
+          if (index >= center) {
+            throw new Error(
+              `Invalid TGN coordinate: "${code}" (position ${index} >= center ${center} on axis ${i})`
+            );
+          }
+          result.push(index);
+        } else {
+          const index = size - 1 - distFromZ;
+          if (index <= center) {
+            throw new Error(
+              `Invalid TGN coordinate: "${code}" (position ${index} <= center ${center} on axis ${i})`
+            );
+          }
+          result.push(index);
+        }
+      } else {
+        throw new Error(
+          `Invalid TGN coordinate: "${code}" (character '${char}' at position ${i} must be '0' or a-z)`
+        );
+      }
+    }
+  }
+  while (result.length < boardShape.length) {
+    result.push(0);
+  }
+  return result;
+};
+
+// inc/tgn/tgnParser.ts
+var TGNParseError = class extends Error {
+  constructor(message, line, column, hash) {
+    super(message);
+    this.line = line;
+    this.column = column;
+    this.hash = hash;
+    this.name = "TGNParseError";
+  }
+};
+var parserModule = null;
+function getParser() {
+  if (!parserModule) {
+    throw new Error(
+      "TGN parser not loaded. Please ensure the parser has been built.\nRun: npm run build:parsers"
+    );
+  }
+  return parserModule;
+}
+function parseTGN(tgnString) {
+  const parser = getParser();
+  if (!parser.parse) {
+    throw new Error("TGN parser parse method not available");
+  }
+  try {
+    const result = parser.parse(tgnString);
+    return result;
+  } catch (error) {
+    throw new TGNParseError(
+      error.message || "Unknown parse error",
+      error.hash?.line,
+      error.hash?.loc?.first_column,
+      error.hash
+    );
+  }
+}
+
+// inc/trigo/game.ts
+var TrigoGame = class _TrigoGame {
+  /**
+   * Constructor
+   * Equivalent to trigo.Game constructor (lines 75-85)
+   */
+  constructor(shape = { x: 5, y: 5, z: 5 }, callbacks = {}) {
+    // Last captured stones for Ko rule detection
+    this.lastCapturedPositions = null;
+    // Static analysis cache (territory, capturing moves)
+    // Invalidated on any board state change
+    this.cachedTerritory = null;
+    this.cachedCapturingMove = /* @__PURE__ */ new Map();
+    this.shape = shape;
+    this.callbacks = callbacks;
+    this.board = this.createEmptyBoard();
+    this.currentPlayer = StoneType.BLACK;
+    this.stepHistory = [];
+    this.currentStepIndex = 0;
+    this.gameStatus = "idle";
+    this.gameResult = void 0;
+    this.passCount = 0;
+  }
+  /**
+   * Create an empty board
+   */
+  createEmptyBoard() {
+    const board = [];
+    for (let x = 0; x < this.shape.x; x++) {
+      board[x] = [];
+      for (let y = 0; y < this.shape.y; y++) {
+        board[x][y] = [];
+        for (let z = 0; z < this.shape.z; z++) {
+          board[x][y][z] = StoneType.EMPTY;
+        }
+      }
+    }
+    return board;
+  }
+  /**
+   * Reset the game to initial state
+   * Equivalent to Game.reset() (lines 153-163)
+   */
+  reset() {
+    this.board = this.createEmptyBoard();
+    this.currentPlayer = StoneType.BLACK;
+    this.stepHistory = [];
+    this.currentStepIndex = 0;
+    this.lastCapturedPositions = null;
+    this.invalidateAnalysisCache();
+    this.gameStatus = "idle";
+    this.gameResult = void 0;
+    this.passCount = 0;
+  }
+  /**
+   * Invalidate all static analysis caches
+   * Called when board state changes
+   */
+  invalidateAnalysisCache() {
+    this.cachedTerritory = null;
+    this.cachedCapturingMove.clear();
+  }
+  /**
+   * Clone the game state (deep copy)
+   * Creates an independent copy with all state preserved
+   */
+  clone() {
+    const cloned = new _TrigoGame(this.shape, {});
+    cloned.board = this.board.map((plane) => plane.map((row) => [...row]));
+    cloned.currentPlayer = this.currentPlayer;
+    cloned.currentStepIndex = this.currentStepIndex;
+    cloned.gameStatus = this.gameStatus;
+    cloned.passCount = this.passCount;
+    cloned.stepHistory = this.stepHistory.map((step) => ({
+      ...step,
+      position: step.position ? { ...step.position } : void 0,
+      capturedPositions: step.capturedPositions ? step.capturedPositions.map((pos) => ({ ...pos })) : []
+    }));
+    cloned.lastCapturedPositions = this.lastCapturedPositions ? this.lastCapturedPositions.map((pos) => ({ ...pos })) : null;
+    if (this.gameResult) {
+      cloned.gameResult = {
+        ...this.gameResult,
+        score: this.gameResult.score ? { ...this.gameResult.score } : void 0
+      };
+    }
+    cloned.invalidateAnalysisCache();
+    return cloned;
+  }
+  /**
+   * Get current board state (read-only)
+   */
+  getBoard() {
+    return this.board.map((plane) => plane.map((row) => [...row]));
+  }
+  /**
+   * Get stone at specific position
+   * Equivalent to Game.stone() (lines 95-97)
+   */
+  getStone(pos) {
+    return this.board[pos.x][pos.y][pos.z];
+  }
+  /**
+   * Get current player
+   */
+  getCurrentPlayer() {
+    return this.currentPlayer;
+  }
+  /**
+   * Get current step number
+   * Equivalent to Game.currentStep() (lines 99-101)
+   */
+  getCurrentStep() {
+    return this.currentStepIndex;
+  }
+  /**
+   * Get move history
+   * Equivalent to Game.routine() (lines 103-105)
+   */
+  getHistory() {
+    return [...this.stepHistory];
+  }
+  /**
+   * Get last move
+   * Equivalent to Game.lastStep() (lines 107-110)
+   */
+  getLastStep() {
+    if (this.currentStepIndex > 0) {
+      return this.stepHistory[this.currentStepIndex - 1];
+    }
+    return null;
+  }
+  /**
+   * Get board shape
+   * Equivalent to Game.shape() (lines 87-89)
+   */
+  getShape() {
+    return { ...this.shape };
+  }
+  /**
+   * Get game status
+   */
+  getGameStatus() {
+    return this.gameStatus;
+  }
+  /**
+   * Set game status
+   */
+  setGameStatus(status) {
+    this.gameStatus = status;
+  }
+  /**
+   * Get game result
+   */
+  getGameResult() {
+    return this.gameResult;
+  }
+  /**
+   * Get consecutive pass count
+   */
+  getPassCount() {
+    return this.passCount;
+  }
+  /**
+   * Recalculate consecutive pass count based on current history
+   * Counts consecutive PASS steps from the end of current history
+   */
+  recalculatePassCount() {
+    this.passCount = 0;
+    for (let i = this.currentStepIndex - 1; i >= 0; i--) {
+      if (this.stepHistory[i].type === 1 /* PASS */) {
+        this.passCount++;
+      } else {
+        break;
+      }
+    }
+  }
+  /**
+   * Start the game
+   */
+  startGame() {
+    if (this.gameStatus === "idle") {
+      this.gameStatus = "playing";
+    }
+  }
+  /**
+   * Check if game is active
+   */
+  isGameActive() {
+    return this.gameStatus === "playing";
+  }
+  /**
+   * Check if a move is valid
+   * Equivalent to Game.isDropable() and Game.isValidStep() (lines 112-151)
+   */
+  isValidMove(pos, player) {
+    const playerColor = player || this.currentPlayer;
+    return validateMove(pos, playerColor, this.board, this.shape, this.lastCapturedPositions);
+  }
+  /**
+   * Get all valid move positions for current player (efficient batch query)
+   *
+   * This method is optimized to avoid repeated validation checks by:
+   * 1. Only checking empty positions
+   * 2. Skipping bounds checking (iterator is already within bounds)
+   * 3. Using low-level validation functions directly
+   * 4. Batching board state access
+   *
+   * @param player - Optional player color (defaults to current player)
+   * @returns Array of all valid move positions
+   */
+  validMovePositions(player) {
+    const playerColor = player || this.currentPlayer;
+    const validPositions = [];
+    for (let x = 0; x < this.shape.x; x++) {
+      for (let y = 0; y < this.shape.y; y++) {
+        for (let z = 0; z < this.shape.z; z++) {
+          if (this.board[x][y][z] !== StoneType.EMPTY) {
+            continue;
+          }
+          const pos = { x, y, z };
+          if (isKoViolation(
+            pos,
+            playerColor,
+            this.board,
+            this.shape,
+            this.lastCapturedPositions
+          )) {
+            continue;
+          }
+          if (isSuicideMove(pos, playerColor, this.board, this.shape)) {
+            continue;
+          }
+          validPositions.push(pos);
+        }
+      }
+    }
+    return validPositions;
+  }
+  /**
+   * Check if any valid move can capture enemy stones
+   * Used by MCTS to determine if a position is truly terminal
+   *
+   * Results are cached and invalidated when board state changes.
+   *
+   * @param player - Optional player color (defaults to current player)
+   * @returns true if at least one valid move would capture stones
+   */
+  hasCapturingMove(player) {
+    const playerColor = player ?? this.currentPlayer;
+    if (this.cachedCapturingMove.has(playerColor)) {
+      return this.cachedCapturingMove.get(playerColor);
+    }
+    const result = this.computeHasCapturingMove(playerColor);
+    this.cachedCapturingMove.set(playerColor, result);
+    return result;
+  }
+  /**
+   * Internal: Compute whether a player has any capturing move
+   */
+  computeHasCapturingMove(playerColor) {
+    for (let x = 0; x < this.shape.x; x++) {
+      for (let y = 0; y < this.shape.y; y++) {
+        for (let z = 0; z < this.shape.z; z++) {
+          if (this.board[x][y][z] !== StoneType.EMPTY) {
+            continue;
+          }
+          const pos = { x, y, z };
+          if (isKoViolation(
+            pos,
+            playerColor,
+            this.board,
+            this.shape,
+            this.lastCapturedPositions
+          )) {
+            continue;
+          }
+          if (isSuicideMove(pos, playerColor, this.board, this.shape)) {
+            continue;
+          }
+          const capturedGroups = findCapturedGroups(pos, playerColor, this.board, this.shape);
+          if (capturedGroups.length > 0) {
+            return true;
+          }
+        }
+      }
+    }
+    return false;
+  }
+  /**
+   * Check if the game has reached a natural terminal state
+   *
+   * A game is naturally terminal when:
+   * - All territory is claimed (neutral === 0)
+   * - AND neither player has any capturing moves available
+   *
+   * This is different from the "finished" status which requires double pass.
+   * Natural termination means the game state is completely settled and
+   * no further moves can meaningfully change the outcome.
+   *
+   * NOTE: This method is expensive due to territory calculation and capture move checking.
+   * Use coverage ratio check as a pre-filter when calling frequently.
+   *
+   * Used by:
+   * - MCTS agent (terminal detection for tree search)
+   * - Model battle (early stopping when settled)
+   * - Self-play games (early stopping when settled)
+   *
+   * @returns true if the game is naturally terminal, false otherwise
+   */
+  isNaturallyTerminal() {
+    const territory = this.getTerritory();
+    if (territory.neutral !== 0) {
+      return false;
+    }
+    const blackCanCapture = this.hasCapturingMove(StoneType.BLACK);
+    const whiteCanCapture = this.hasCapturingMove(StoneType.WHITE);
+    return !blackCanCapture && !whiteCanCapture;
+  }
+  /**
+   * Reset pass count (called when a stone is placed)
+   */
+  resetPassCount() {
+    this.passCount = 0;
+  }
+  /**
+   * Place a stone (drop move)
+   * Equivalent to Game.drop() and Game.appendStone() (lines 181-273)
+   *
+   * @returns true if move was successful, false otherwise
+   */
+  drop(pos) {
+    const validation = this.isValidMove(pos);
+    if (!validation.valid) {
+      console.warn(`Invalid move at (${pos.x}, ${pos.y}, ${pos.z}): ${validation.reason}`);
+      return false;
+    }
+    const capturedGroups = findCapturedGroups(pos, this.currentPlayer, this.board, this.shape);
+    this.board[pos.x][pos.y][pos.z] = this.currentPlayer;
+    const capturedPositions = executeCaptures(capturedGroups, this.board);
+    this.lastCapturedPositions = capturedPositions.length > 0 ? capturedPositions : null;
+    this.invalidateAnalysisCache();
+    this.resetPassCount();
+    const step = {
+      type: 0 /* DROP */,
+      position: pos,
+      player: this.currentPlayer,
+      capturedPositions: capturedPositions.length > 0 ? capturedPositions : void 0,
+      timestamp: Date.now()
+    };
+    this.advanceStep(step);
+    if (capturedPositions.length > 0 && this.callbacks.onCapture) {
+      this.callbacks.onCapture(capturedPositions);
+    }
+    if (this.callbacks.onTerritoryChange) {
+      this.callbacks.onTerritoryChange(this.getTerritory());
+    }
+    return true;
+  }
+  /**
+   * Pass turn
+   * Equivalent to PASS step type in prototype
+   */
+  pass() {
+    const step = {
+      type: 1 /* PASS */,
+      player: this.currentPlayer,
+      timestamp: Date.now()
+    };
+    this.lastCapturedPositions = null;
+    this.passCount++;
+    this.advanceStep(step);
+    if (this.passCount >= 2) {
+      const territory = this.getTerritory();
+      const capturedCounts = this.getCapturedCounts();
+      const blackTotal = territory.black + capturedCounts.white;
+      const whiteTotal = territory.white + capturedCounts.black;
+      let winner;
+      if (blackTotal > whiteTotal) {
+        winner = "black";
+      } else if (whiteTotal > blackTotal) {
+        winner = "white";
+      } else {
+        winner = "draw";
+      }
+      this.gameResult = {
+        winner,
+        reason: "double-pass",
+        score: territory
+      };
+      this.gameStatus = "finished";
+      if (this.callbacks.onWin) {
+        const winnerStone = winner === "black" ? StoneType.BLACK : winner === "white" ? StoneType.WHITE : StoneType.EMPTY;
+        this.callbacks.onWin(winnerStone);
+      }
+    }
+    return true;
+  }
+  /**
+   * Surrender/resign
+   * Equivalent to Game.step() with SURRENDER type (lines 176-178)
+   */
+  surrender() {
+    const surrenderingPlayer = this.currentPlayer;
+    const step = {
+      type: 2 /* SURRENDER */,
+      player: this.currentPlayer,
+      timestamp: Date.now()
+    };
+    this.advanceStep(step);
+    const winner = surrenderingPlayer === StoneType.BLACK ? "white" : "black";
+    this.gameResult = {
+      winner,
+      reason: "resignation"
+    };
+    this.gameStatus = "finished";
+    const winnerStone = getEnemyColor(surrenderingPlayer);
+    if (this.callbacks.onWin) {
+      this.callbacks.onWin(winnerStone);
+    }
+    return true;
+  }
+  /**
+   * Undo last move
+   * Equivalent to Game.repent() (lines 197-230)
+   *
+   * @returns true if undo was successful, false if no moves to undo
+   */
+  undo() {
+    if (this.currentStepIndex === 0 || this.stepHistory.length === 0) {
+      return false;
+    }
+    const lastStep = this.stepHistory[this.currentStepIndex - 1];
+    if (lastStep.type === 0 /* DROP */ && lastStep.position) {
+      this.board[lastStep.position.x][lastStep.position.y][lastStep.position.z] = StoneType.EMPTY;
+      if (lastStep.capturedPositions) {
+        const enemyColor = getEnemyColor(lastStep.player);
+        for (const pos of lastStep.capturedPositions) {
+          this.board[pos.x][pos.y][pos.z] = enemyColor;
+        }
+      }
+    }
+    this.currentStepIndex--;
+    this.currentPlayer = lastStep.player;
+    this.recalculatePassCount();
+    if (this.currentStepIndex > 0) {
+      const previousStep = this.stepHistory[this.currentStepIndex - 1];
+      this.lastCapturedPositions = previousStep.capturedPositions || null;
+    } else {
+      this.lastCapturedPositions = null;
+    }
+    this.invalidateAnalysisCache();
+    if (this.callbacks.onStepBack) {
+      this.callbacks.onStepBack(lastStep, this.stepHistory.slice(0, this.currentStepIndex));
+    }
+    return true;
+  }
+  /**
+   * Redo next move (after undo)
+   *
+   * @returns true if redo was successful, false if no moves to redo
+   */
+  redo() {
+    if (this.currentStepIndex >= this.stepHistory.length) {
+      return false;
+    }
+    const nextStep = this.stepHistory[this.currentStepIndex];
+    if (nextStep.type === 0 /* DROP */ && nextStep.position) {
+      this.board[nextStep.position.x][nextStep.position.y][nextStep.position.z] = nextStep.player;
+      if (nextStep.capturedPositions) {
+        for (const pos of nextStep.capturedPositions) {
+          this.board[pos.x][pos.y][pos.z] = StoneType.EMPTY;
+        }
+      }
+      this.lastCapturedPositions = nextStep.capturedPositions || null;
+    } else if (nextStep.type === 1 /* PASS */) {
+      this.lastCapturedPositions = null;
+    }
+    this.currentStepIndex++;
+    this.currentPlayer = getEnemyColor(nextStep.player);
+    this.invalidateAnalysisCache();
+    if (this.callbacks.onStepAdvance) {
+      this.callbacks.onStepAdvance(
+        nextStep,
+        this.stepHistory.slice(0, this.currentStepIndex)
+      );
+    }
+    return true;
+  }
+  /**
+   * Check if redo is available
+   */
+  canRedo() {
+    return this.currentStepIndex < this.stepHistory.length;
+  }
+  /**
+   * Jump to specific step in history
+   * Rebuilds board state after applying the first 'index' moves
+   *
+   * @param index Number of moves to apply from history (0 for initial state, 1 for after first move, etc.)
+   * @returns true if jump was successful
+   */
+  jumpToStep(index) {
+    if (index < 0 || index > this.stepHistory.length) {
+      return false;
+    }
+    if (index === this.currentStepIndex) {
+      return false;
+    }
+    this.board = this.createEmptyBoard();
+    this.lastCapturedPositions = null;
+    for (let i = 0; i < index; i++) {
+      const step = this.stepHistory[i];
+      if (step.type === 0 /* DROP */ && step.position) {
+        const pos = step.position;
+        this.board[pos.x][pos.y][pos.z] = step.player;
+        if (step.capturedPositions) {
+          for (const capturedPos of step.capturedPositions) {
+            this.board[capturedPos.x][capturedPos.y][capturedPos.z] = StoneType.EMPTY;
+          }
+        }
+      }
+    }
+    if (index > 0) {
+      const lastAppliedStep = this.stepHistory[index - 1];
+      if (lastAppliedStep.type === 0 /* DROP */) {
+        this.lastCapturedPositions = lastAppliedStep.capturedPositions || null;
+      } else if (lastAppliedStep.type === 1 /* PASS */) {
+        this.lastCapturedPositions = null;
+      }
+    } else {
+      this.lastCapturedPositions = null;
+    }
+    const oldStepIndex = this.currentStepIndex;
+    this.currentStepIndex = index;
+    const movesPlayed = index;
+    this.currentPlayer = movesPlayed % 2 === 0 ? StoneType.BLACK : StoneType.WHITE;
+    this.recalculatePassCount();
+    this.invalidateAnalysisCache();
+    if (index < oldStepIndex && this.callbacks.onStepBack) {
+      const currentStep = this.stepHistory[index];
+      this.callbacks.onStepBack(currentStep, this.stepHistory.slice(0, index + 1));
+    } else if (index > oldStepIndex && this.callbacks.onStepAdvance) {
+      const currentStep = this.stepHistory[index];
+      this.callbacks.onStepAdvance(currentStep, this.stepHistory.slice(0, index + 1));
+    }
+    return true;
+  }
+  /**
+   * Advance to next step
+   * Equivalent to Game.stepAdvance() (lines 279-287)
+   */
+  advanceStep(step) {
+    if (this.currentStepIndex < this.stepHistory.length) {
+      this.stepHistory = this.stepHistory.slice(0, this.currentStepIndex);
+    }
+    this.stepHistory.push(step);
+    this.currentStepIndex++;
+    this.currentPlayer = getEnemyColor(this.currentPlayer);
+    if (this.callbacks.onStepAdvance) {
+      this.callbacks.onStepAdvance(step, this.stepHistory);
+    }
+  }
+  /**
+   * Get territory calculation
+   * Equivalent to Game.blackDomain() and Game.whiteDomain() (lines 232-244)
+   *
+   * Returns cached result if territory hasn't changed
+   */
+  getTerritory() {
+    if (!this.cachedTerritory)
+      this.cachedTerritory = calculateTerritory(this.board, this.shape);
+    return this.cachedTerritory;
+  }
+  /**
+   * Get captured stone counts up to current position in history
+   * Only counts captures that have been played (up to currentStepIndex)
+   */
+  getCapturedCounts() {
+    const counts = { black: 0, white: 0 };
+    for (let i = 0; i < this.currentStepIndex; i++) {
+      const step = this.stepHistory[i];
+      if (step.capturedPositions && step.capturedPositions.length > 0) {
+        const enemyColor = getEnemyColor(step.player);
+        if (enemyColor === StoneType.BLACK) {
+          counts.black += step.capturedPositions.length;
+        } else if (enemyColor === StoneType.WHITE) {
+          counts.white += step.capturedPositions.length;
+        }
+      }
+    }
+    return counts;
+  }
+  /**
+   * Serialize game state to JSON
+   * Equivalent to Game.serialize() (lines 250-252)
+   */
+  toJSON() {
+    return {
+      shape: this.shape,
+      currentPlayer: this.currentPlayer,
+      currentStepIndex: this.currentStepIndex,
+      history: this.stepHistory,
+      board: this.board,
+      gameStatus: this.gameStatus,
+      gameResult: this.gameResult,
+      passCount: this.passCount
+    };
+  }
+  /**
+   * Load game state from JSON
+   */
+  fromJSON(data) {
+    try {
+      if (!data || typeof data !== "object") {
+        return false;
+      }
+      if (!data.shape || !data.board || !Array.isArray(data.history)) {
+        return false;
+      }
+      this.shape = data.shape;
+      this.currentPlayer = data.currentPlayer;
+      this.currentStepIndex = data.currentStepIndex;
+      this.stepHistory = data.history || [];
+      this.board = data.board;
+      this.gameStatus = data.gameStatus || "idle";
+      this.gameResult = data.gameResult;
+      this.passCount = data.passCount || 0;
+      if (this.currentStepIndex > 0) {
+        const lastStep = this.stepHistory[this.currentStepIndex - 1];
+        this.lastCapturedPositions = lastStep.capturedPositions || null;
+      } else {
+        this.lastCapturedPositions = null;
+      }
+      this.invalidateAnalysisCache();
+      return true;
+    } catch (error) {
+      console.error("Failed to load game state:", error);
+      return false;
+    }
+  }
+  /**
+   * Get game statistics
+   */
+  getStats() {
+    const captured = this.getCapturedCounts();
+    const territory = this.getTerritory();
+    let blackMoves = 0;
+    let whiteMoves = 0;
+    for (const step of this.stepHistory.slice(0, this.currentStepIndex)) {
+      if (step.type === 0 /* DROP */) {
+        if (step.player === StoneType.BLACK) {
+          blackMoves++;
+        } else if (step.player === StoneType.WHITE) {
+          whiteMoves++;
+        }
+      }
+    }
+    return {
+      totalMoves: this.currentStepIndex,
+      blackMoves,
+      whiteMoves,
+      capturedByBlack: captured.white,
+      // Black captures white stones
+      capturedByWhite: captured.black,
+      // White captures black stones
+      territory
+    };
+  }
+  /**
+   * Save game state to sessionStorage
+   *
+   * @param key Storage key (default: "trigoGameState")
+   * @returns true if save was successful
+   */
+  saveToSessionStorage(key = "trigoGameState") {
+    if (typeof globalThis !== "undefined" && globalThis.sessionStorage) {
+      try {
+        const gameState = this.toJSON();
+        globalThis.sessionStorage.setItem(key, JSON.stringify(gameState));
+        return true;
+      } catch (error) {
+        console.error("Failed to save game state to sessionStorage:", error);
+        return false;
+      }
+    }
+    console.warn("sessionStorage is not available");
+    return false;
+  }
+  /**
+   * Load game state from sessionStorage
+   *
+   * @param key Storage key (default: "trigoGameState")
+   * @returns true if load was successful
+   */
+  loadFromSessionStorage(key = "trigoGameState") {
+    if (typeof globalThis !== "undefined" && globalThis.sessionStorage) {
+      try {
+        const savedState = globalThis.sessionStorage.getItem(key);
+        if (!savedState) {
+          console.log("No saved game state found");
+          return false;
+        }
+        const data = JSON.parse(savedState);
+        return this.fromJSON(data);
+      } catch (error) {
+        console.error("Failed to load game state from sessionStorage:", error);
+        return false;
+      }
+    }
+    console.warn("sessionStorage is not available");
+    return false;
+  }
+  /**
+   * Clear saved game state from sessionStorage
+   *
+   * @param key Storage key (default: "trigoGameState")
+   */
+  clearSessionStorage(key = "trigoGameState") {
+    if (typeof globalThis !== "undefined" && globalThis.sessionStorage) {
+      try {
+        globalThis.sessionStorage.removeItem(key);
+      } catch (error) {
+        console.error("Failed to clear sessionStorage:", error);
+      }
+    } else {
+      console.warn("sessionStorage is not available");
+    }
+  }
+  /**
+   * Export game to TGN (Trigo Game Notation) format
+   *
+   * TGN format is similar to PGN (Portable Game Notation) for chess.
+   * It includes metadata tags and move sequence using ab0yz coordinate notation.
+   *
+   * @param metadata Optional metadata for the game (Event, Site, Date, Players, etc.)
+   * @returns TGN-formatted string
+   *
+   * @example
+   * const tgn = game.toTGN({
+   *   event: "World Championship",
+   *   site: "Tokyo",
+   *   date: "2025.10.31",
+   *   black: "Alice",
+   *   white: "Bob"
+   * });
+   */
+  toTGN(metadata, { markResult } = {}) {
+    const lines = [];
+    if (metadata) {
+      if (metadata.event) lines.push(`[Event "${metadata.event}"]`);
+      if (metadata.site) lines.push(`[Site "${metadata.site}"]`);
+      if (metadata.date) lines.push(`[Date "${metadata.date}"]`);
+      if (metadata.round) lines.push(`[Round "${metadata.round}"]`);
+      if (metadata.black) lines.push(`[Black "${metadata.black}"]`);
+      if (metadata.white) lines.push(`[White "${metadata.white}"]`);
+    }
+    if (this.gameStatus === "finished" && this.gameResult) {
+      let resultStr = "";
+      if (this.gameResult.winner === "black") {
+        resultStr = "B+";
+      } else if (this.gameResult.winner === "white") {
+        resultStr = "W+";
+      } else {
+        resultStr = "=";
+      }
+      if (this.gameResult.score) {
+        const { black, white } = this.gameResult.score;
+        const diff = Math.abs(black - white);
+        resultStr += `${diff}points`;
+      } else if (this.gameResult.reason === "resignation") {
+        resultStr += "Resign";
+      }
+    }
+    const boardStr = this.shape.z === 1 ? `${this.shape.x}x${this.shape.y}` : `${this.shape.x}x${this.shape.y}x${this.shape.z}`;
+    lines.push(`[Board ${boardStr}]`);
+    if (metadata) {
+      if (metadata.rules) lines.push(`[Rules "${metadata.rules}"]`);
+      if (metadata.timeControl) lines.push(`[TimeControl "${metadata.timeControl}"]`);
+      if (metadata.application) lines.push(`[Application "${metadata.application}"]`);
+    }
+    lines.push("");
+    const moves = [];
+    let moveNumber = 1;
+    for (let i = 0; i < this.stepHistory.length; i++) {
+      const step = this.stepHistory[i];
+      let moveStr = "";
+      if (step.player === StoneType.BLACK) {
+        moveStr = `${moveNumber}. `;
+      }
+      if (step.type === 0 /* DROP */ && step.position) {
+        const pos = [step.position.x, step.position.y, step.position.z];
+        const boardShape = [this.shape.x, this.shape.y, this.shape.z];
+        const coord = encodeAb0yz(pos, boardShape);
+        moveStr += coord;
+      } else if (step.type === 1 /* PASS */) {
+        moveStr += "Pass";
+      } else if (step.type === 2 /* SURRENDER */) {
+        moveStr += "Resign";
+      }
+      moves.push(moveStr);
+      if (step.player === StoneType.WHITE) {
+        moveNumber++;
+      }
+    }
+    let currentLine = "";
+    for (let i = 0; i < moves.length; i++) {
+      const move = moves[i];
+      if (move.match(/^\d+\./)) {
+        if (currentLine) {
+          lines.push(currentLine);
+        }
+        currentLine = move;
+      } else {
+        currentLine += " " + move;
+      }
+    }
+    if (currentLine) {
+      lines.push(currentLine);
+    }
+    if (markResult) {
+      const territory = this.getTerritory();
+      const scoreDiff = territory.black - territory.white;
+      lines.push(`; ${scoreDiff > 0 ? "-" : scoreDiff < 0 ? "+" : ""}${Math.abs(scoreDiff)}`);
+    }
+    lines.push("");
+    return lines.join("\n");
+  }
+  /**
+   * Import game from TGN (Trigo Game Notation) format
+   *
+   * Static factory method that parses a TGN string and creates a new TrigoGame instance
+   * with the board configuration and moves from the TGN file.
+   *
+   * Synchronous operation - requires parser to be loaded via setParserModule()
+   *
+   * @param tgnString TGN-formatted game notation string
+   * @param callbacks Optional game callbacks
+   * @returns New TrigoGame instance with the imported game state
+   * @throws TGNParseError if the TGN string is invalid
+   *
+   * @example
+   * const tgnString = `
+   * [Event "World Championship"]
+   * [Board "5x5x5"]
+   * [Black "Alice"]
+   * [White "Bob"]
+   *
+   * 1. 000 y00
+   * 2. 0y0 pass
+   * `;
+   * const game = TrigoGame.fromTGN(tgnString);
+   */
+  static fromTGN(tgnString, callbacks) {
+    const parsed = parseTGN(tgnString);
+    let boardShape;
+    if (parsed.tags.Board && Array.isArray(parsed.tags.Board)) {
+      const shape = parsed.tags.Board;
+      boardShape = {
+        x: shape[0] || 5,
+        y: shape[1] || 5,
+        z: shape[2] || 1
+      };
+    } else {
+      boardShape = { x: 5, y: 5, z: 5 };
+    }
+    const game = new this(boardShape, callbacks);
+    game.startGame();
+    if (parsed.moves && parsed.moves.length > 0) {
+      for (const round of parsed.moves) {
+        if (round.action_black) {
+          game._applyParsedMove(round.action_black, boardShape);
+        }
+        if (round.action_white) {
+          game._applyParsedMove(round.action_white, boardShape);
+        }
+      }
+    }
+    return game;
+  }
+  /**
+   * Apply a parsed move action to the game
+   * Private helper method for fromTGN
+   *
+   * @param action Parsed move action from TGN parser
+   * @param boardShape Board dimensions for coordinate decoding
+   */
+  _applyParsedMove(action, boardShape) {
+    if (action.type === "pass") {
+      this.pass();
+    } else if (action.type === "resign") {
+      this.surrender();
+    } else if (action.type === "move" && action.position) {
+      const coords = decodeAb0yz(action.position, [boardShape.x, boardShape.y, boardShape.z]);
+      const position = {
+        x: coords[0],
+        y: coords[1],
+        z: coords[2]
+      };
+      this.drop(position);
+    }
+  }
+};
+
+// backend/src/services/gameManager.ts
+var GameManager = class {
+  // Default 5x5x5 board
+  constructor() {
+    this.rooms = /* @__PURE__ */ new Map();
+    this.playerRoomMap = /* @__PURE__ */ new Map();
+    this.defaultBoardShape = { x: 5, y: 5, z: 5 };
+    console.log("GameManager initialized");
+  }
+  createRoom(playerId, nickname, boardShape, preferredColor) {
+    const roomId = this.generateRoomId();
+    const shape = boardShape || this.defaultBoardShape;
+    const playerColor = preferredColor || "black";
+    const room = {
+      id: roomId,
+      adminId: playerId,
+      // Room creator is admin
+      players: {
+        [playerId]: {
+          id: playerId,
+          nickname,
+          color: playerColor,
+          connected: true
+        }
+      },
+      game: new TrigoGame(shape, {
+        onStepAdvance: (_step, history) => {
+          console.log(`Step ${history.length}: Player made move`);
+        },
+        onCapture: (captured) => {
+          console.log(`Captured ${captured.length} stones`);
+        },
+        onWin: (winner) => {
+          console.log(`Game won by ${winner}`);
+        }
+      }),
+      gameState: {
+        gameStatus: "waiting",
+        winner: null
+      },
+      createdAt: /* @__PURE__ */ new Date(),
+      startedAt: null
+    };
+    this.rooms.set(roomId, room);
+    this.playerRoomMap.set(playerId, roomId);
+    console.log(`Room ${roomId} created by ${playerId}`);
+    return room;
+  }
+  joinRoom(roomId, playerId, nickname, preferredColor) {
+    const room = this.rooms.get(roomId);
+    if (!room) {
+      return null;
+    }
+    const playerCount = Object.keys(room.players).length;
+    if (playerCount >= 2) {
+      return null;
+    }
+    const firstPlayer = Object.values(room.players)[0];
+    let assignedColor;
+    if (preferredColor && preferredColor !== firstPlayer.color) {
+      assignedColor = preferredColor;
+    } else {
+      assignedColor = firstPlayer.color === "black" ? "white" : "black";
+    }
+    room.players[playerId] = {
+      id: playerId,
+      nickname,
+      color: assignedColor,
+      connected: true
+    };
+    this.playerRoomMap.set(playerId, roomId);
+    if (playerCount === 1) {
+      room.gameState.gameStatus = "playing";
+      room.startedAt = /* @__PURE__ */ new Date();
+    }
+    return room;
+  }
+  leaveRoom(roomId, playerId) {
+    const room = this.rooms.get(roomId);
+    if (!room) return;
+    if (room.players[playerId]) {
+      room.players[playerId].connected = false;
+    }
+    this.playerRoomMap.delete(playerId);
+    const connectedPlayers = Object.values(room.players).filter((p) => p.connected);
+    if (connectedPlayers.length === 0) {
+      this.rooms.delete(roomId);
+      console.log(`Room ${roomId} deleted - no players remaining`);
+    }
+  }
+  makeMove(roomId, playerId, move) {
+    const room = this.rooms.get(roomId);
+    if (!room) return false;
+    const player = room.players[playerId];
+    if (!player) return false;
+    if (room.gameState.gameStatus !== "playing") {
+      return false;
+    }
+    const expectedPlayer = player.color === "black" ? StoneType.BLACK : StoneType.WHITE;
+    const currentPlayer = room.game.getCurrentPlayer();
+    if (currentPlayer !== expectedPlayer) {
+      return false;
+    }
+    const position = { x: move.x, y: move.y, z: move.z };
+    const success = room.game.drop(position);
+    return success;
+  }
+  passTurn(roomId, playerId) {
+    const room = this.rooms.get(roomId);
+    if (!room) return false;
+    const player = room.players[playerId];
+    if (!player) return false;
+    if (room.gameState.gameStatus !== "playing") {
+      return false;
+    }
+    const expectedPlayer = player.color === "black" ? StoneType.BLACK : StoneType.WHITE;
+    const currentPlayer = room.game.getCurrentPlayer();
+    if (currentPlayer !== expectedPlayer) {
+      return false;
+    }
+    return room.game.pass();
+  }
+  resign(roomId, playerId) {
+    const room = this.rooms.get(roomId);
+    if (!room) return false;
+    const player = room.players[playerId];
+    if (!player) return false;
+    room.game.surrender();
+    room.gameState.gameStatus = "finished";
+    room.gameState.winner = player.color === "black" ? "white" : "black";
+    return true;
+  }
+  /**
+   * Undo the last move (悔棋)
+   */
+  undoMove(roomId, playerId) {
+    const room = this.rooms.get(roomId);
+    if (!room) return false;
+    const player = room.players[playerId];
+    if (!player) return false;
+    if (room.gameState.gameStatus !== "playing") {
+      return false;
+    }
+    return room.game.undo();
+  }
+  /**
+   * Redo the last undone move (forward in history)
+   */
+  redoMove(roomId, playerId) {
+    const room = this.rooms.get(roomId);
+    if (!room) return false;
+    const player = room.players[playerId];
+    if (!player) return false;
+    if (room.gameState.gameStatus !== "playing") {
+      return false;
+    }
+    return room.game.redo();
+  }
+  /**
+   * Reset the game to initial state (new game in same room)
+   * Only admin can reset the game
+   */
+  resetGame(roomId, adminId, options) {
+    const room = this.rooms.get(roomId);
+    if (!room) return { success: false, error: "Room not found" };
+    if (room.adminId !== adminId) {
+      return { success: false, error: "Only room admin can reset the game" };
+    }
+    const boardShape = options?.boardShape;
+    const playerColors = options?.playerColors;
+    if (playerColors) {
+      const playerIds = Object.keys(room.players);
+      for (const playerId of playerIds) {
+        if (playerColors[playerId]) {
+          room.players[playerId].color = playerColors[playerId];
+        }
+      }
+      console.log(`Player colors assigned:`, playerColors);
+    }
+    if (boardShape) {
+      const currentShape = room.game.getShape();
+      if (boardShape.x !== currentShape.x || boardShape.y !== currentShape.y || boardShape.z !== currentShape.z) {
+        room.game = new TrigoGame(boardShape, {
+          onStepAdvance: (_step, history) => {
+            console.log(`Step ${history.length}: Player made move`);
+          },
+          onCapture: (captured) => {
+            console.log(`Captured ${captured.length} stones`);
+          },
+          onWin: (winner) => {
+            console.log(`Game won by ${winner}`);
+          }
+        });
+        console.log(`Game ${roomId} reset with new board shape: ${boardShape.x}x${boardShape.y}x${boardShape.z}`);
+      } else {
+        room.game.reset();
+        console.log(`Game ${roomId} reset to initial state`);
+      }
+    } else {
+      room.game.reset();
+      console.log(`Game ${roomId} reset to initial state`);
+    }
+    room.gameState.gameStatus = "playing";
+    room.gameState.winner = null;
+    room.startedAt = /* @__PURE__ */ new Date();
+    return { success: true };
+  }
+  /**
+   * Get game board state for a room
+   */
+  getGameBoard(roomId) {
+    const room = this.rooms.get(roomId);
+    if (!room) return null;
+    return room.game.getBoard();
+  }
+  /**
+   * Get game statistics for a room
+   */
+  getGameStats(roomId) {
+    const room = this.rooms.get(roomId);
+    if (!room) return null;
+    return room.game.getStats();
+  }
+  /**
+   * Get current player for a room
+   */
+  getCurrentPlayer(roomId) {
+    const room = this.rooms.get(roomId);
+    if (!room) return null;
+    const currentStone = room.game.getCurrentPlayer();
+    return currentStone === StoneType.BLACK ? "black" : "white";
+  }
+  /**
+   * Calculate and get territory for a room
+   */
+  getTerritory(roomId) {
+    const room = this.rooms.get(roomId);
+    if (!room) return null;
+    return room.game.getTerritory();
+  }
+  /**
+   * End the game and determine winner based on territory
+   */
+  endGameByTerritory(roomId) {
+    const room = this.rooms.get(roomId);
+    if (!room) return false;
+    if (room.gameState.gameStatus !== "playing") {
+      return false;
+    }
+    const territory = room.game.getTerritory();
+    if (territory.black > territory.white) {
+      room.gameState.winner = "black";
+    } else if (territory.white > territory.black) {
+      room.gameState.winner = "white";
+    } else {
+      room.gameState.winner = null;
+    }
+    room.gameState.gameStatus = "finished";
+    console.log(
+      `Game ${roomId} ended. Black: ${territory.black}, White: ${territory.white}, Winner: ${room.gameState.winner}`
+    );
+    return true;
+  }
+  /**
+   * Check if both players passed consecutively (game should end)
+   * Returns true if game was ended
+   */
+  checkConsecutivePasses(roomId) {
+    const room = this.rooms.get(roomId);
+    if (!room) return false;
+    const history = room.game.getHistory();
+    if (history.length < 2) return false;
+    const lastMove = history[history.length - 1];
+    const secondLastMove = history[history.length - 2];
+    if (lastMove.type === 1 /* PASS */ && secondLastMove.type === 1 /* PASS */) {
+      this.endGameByTerritory(roomId);
+      return true;
+    }
+    return false;
+  }
+  getRoom(roomId) {
+    return this.rooms.get(roomId);
+  }
+  getPlayerRoom(playerId) {
+    const roomId = this.playerRoomMap.get(playerId);
+    if (!roomId) return void 0;
+    return this.rooms.get(roomId);
+  }
+  getActiveRooms() {
+    return Array.from(this.rooms.values()).filter(
+      (room) => room.gameState.gameStatus !== "finished"
+    );
+  }
+  generateRoomId() {
+    return uuidv4().substring(0, 8).toUpperCase();
+  }
+};
+
+// backend/src/sockets/gameSocket.ts
+function getRoomSummary(room) {
+  const connectedPlayers = Object.values(room.players).filter((p) => p.connected);
+  return {
+    id: room.id,
+    playerCount: connectedPlayers.length,
+    maxPlayers: 2,
+    status: room.gameState.gameStatus,
+    isFull: connectedPlayers.length >= 2,
+    createdAt: room.createdAt.toISOString()
+  };
+}
+function setupSocketHandlers(io2, socket, gameManager2) {
+  console.log(`Setting up socket handlers for ${socket.id}`);
+  socket.on("listRooms", (callback) => {
+    const rooms = gameManager2.getActiveRooms();
+    const roomList = rooms.map((room) => getRoomSummary(room));
+    if (callback) {
+      callback({ success: true, rooms: roomList });
+    }
+  });
+  socket.on(
+    "joinRoom",
+    (data, callback) => {
+      console.log("[gameSocket] joinRoom event received:", {
+        roomId: data.roomId,
+        nickname: data.nickname,
+        preferredColor: data.preferredColor,
+        hasCallback: !!callback,
+        socketId: socket.id
+      });
+      const { roomId, nickname, preferredColor } = data;
+      try {
+        let room;
+        if (roomId) {
+          const existingRoom = gameManager2.getRoom(roomId);
+          if (!existingRoom) {
+            if (callback) {
+              callback({
+                success: false,
+                error: "Room not found",
+                errorCode: "ROOM_NOT_FOUND"
+              });
+            }
+            return;
+          }
+          const playerCount = Object.keys(existingRoom.players).length;
+          if (playerCount >= 2) {
+            if (callback) {
+              callback({
+                success: false,
+                error: "Room is full",
+                errorCode: "ROOM_FULL"
+              });
+            }
+            return;
+          }
+          room = gameManager2.joinRoom(roomId, socket.id, nickname, preferredColor);
+        } else {
+          room = gameManager2.createRoom(socket.id, nickname, void 0, preferredColor);
+        }
+        if (room) {
+          socket.join(room.id);
+          const roomSockets = io2.sockets.adapter.rooms.get(room.id);
+          console.log(`[gameSocket] Socket ${socket.id} joined room ${room.id}`);
+          console.log(`[gameSocket] Room ${room.id} now has sockets:`, roomSockets ? Array.from(roomSockets) : []);
+          const currentPlayer = gameManager2.getCurrentPlayer(room.id);
+          const stats = gameManager2.getGameStats(room.id);
+          const tgn = room.game.toTGN();
+          const players = {};
+          for (const [pid, player] of Object.entries(room.players)) {
+            players[pid] = {
+              nickname: player.nickname,
+              color: player.color
+            };
+          }
+          const response = {
+            success: true,
+            roomId: room.id,
+            playerId: socket.id,
+            playerColor: room.players[socket.id]?.color,
+            isAdmin: room.adminId === socket.id,
+            adminId: room.adminId,
+            players,
+            // Include all players in room
+            gameState: {
+              boardShape: room.game.getShape(),
+              currentPlayer,
+              currentMoveIndex: room.game.getCurrentStep(),
+              capturedStones: {
+                black: stats?.capturedByBlack || 0,
+                white: stats?.capturedByWhite || 0
+              },
+              gameStatus: room.gameState.gameStatus,
+              winner: room.gameState.winner,
+              tgn
+            }
+          };
+          if (callback) {
+            console.log("[gameSocket] Sending response via callback:", {
+              roomId: response.roomId,
+              playerColor: response.playerColor
+            });
+            callback(response);
+          } else {
+            console.log("[gameSocket] No callback, using roomJoined emit");
+            socket.emit("roomJoined", response);
+          }
+          console.log(`[gameSocket] Broadcasting playerJoined to room ${room.id} (excluding ${socket.id})`);
+          socket.to(room.id).emit("playerJoined", {
+            playerId: socket.id,
+            nickname
+          });
+          console.log(`[gameSocket] playerJoined broadcast sent`);
+          const roomSummary = getRoomSummary(room);
+          if (roomId) {
+            io2.emit("roomUpdated", roomSummary);
+          } else {
+            io2.emit("roomCreated", roomSummary);
+          }
+          console.log(
+            `Player ${socket.id} ${roomId ? "joined" : "created"} room ${room.id}`
+          );
+        } else {
+          if (callback) {
+            callback({
+              success: false,
+              error: "Failed to join or create room",
+              errorCode: "UNKNOWN_ERROR"
+            });
+          }
+        }
+      } catch (error) {
+        console.error(`Error in joinRoom handler:`, error);
+        if (callback) {
+          callback({
+            success: false,
+            error: "Server error",
+            errorCode: "SERVER_ERROR"
+          });
+        }
+      }
+    }
+  );
+  socket.on("leaveRoom", () => {
+    const room = gameManager2.getPlayerRoom(socket.id);
+    if (room) {
+      const roomId = room.id;
+      socket.leave(room.id);
+      gameManager2.leaveRoom(room.id, socket.id);
+      socket.to(roomId).emit("playerLeft", {
+        playerId: socket.id
+      });
+      const updatedRoom = gameManager2.getRoom(roomId);
+      if (updatedRoom) {
+        io2.emit("roomUpdated", getRoomSummary(updatedRoom));
+      } else {
+        io2.emit("roomDeleted", { roomId });
+      }
+    }
+  });
+  socket.on("makeMove", (data) => {
+    const room = gameManager2.getPlayerRoom(socket.id);
+    if (room && gameManager2.makeMove(room.id, socket.id, data)) {
+      const currentPlayer = gameManager2.getCurrentPlayer(room.id);
+      const stats = gameManager2.getGameStats(room.id);
+      const lastStep = room.game.getLastStep();
+      const tgn = room.game.toTGN();
+      io2.to(room.id).emit("gameUpdate", {
+        currentPlayer,
+        action: "move",
+        lastMove: data,
+        capturedStones: {
+          black: stats?.capturedByBlack || 0,
+          white: stats?.capturedByWhite || 0
+        },
+        capturedPositions: lastStep?.capturedPositions,
+        currentMoveIndex: room.game.getCurrentStep(),
+        tgn
+      });
+    } else {
+      socket.emit("error", { message: "Invalid move" });
+    }
+  });
+  socket.on("pass", () => {
+    const room = gameManager2.getPlayerRoom(socket.id);
+    if (room && gameManager2.passTurn(room.id, socket.id)) {
+      const currentPlayer = gameManager2.getCurrentPlayer(room.id);
+      const tgn = room.game.toTGN();
+      io2.to(room.id).emit("gameUpdate", {
+        currentPlayer,
+        action: "pass",
+        currentMoveIndex: room.game.getCurrentStep(),
+        tgn
+      });
+      if (gameManager2.checkConsecutivePasses(room.id)) {
+        const territory = gameManager2.getTerritory(room.id);
+        io2.to(room.id).emit("gameEnded", {
+          winner: room.gameState.winner,
+          reason: "double-pass",
+          territory
+        });
+      }
+    }
+  });
+  socket.on("resign", () => {
+    const room = gameManager2.getPlayerRoom(socket.id);
+    if (room && gameManager2.resign(room.id, socket.id)) {
+      io2.to(room.id).emit("gameEnded", {
+        winner: room.gameState.winner,
+        reason: "resignation"
+      });
+    }
+  });
+  socket.on("undoMove", (callback) => {
+    const room = gameManager2.getPlayerRoom(socket.id);
+    if (!room) {
+      if (callback) callback({ success: false, error: "Not in a room", errorCode: "NOT_IN_ROOM" });
+      return;
+    }
+    if (room.gameState.gameStatus !== "playing") {
+      if (callback) callback({ success: false, error: "Game not active", errorCode: "GAME_NOT_ACTIVE" });
+      return;
+    }
+    const success = gameManager2.undoMove(room.id, socket.id);
+    if (success) {
+      const currentPlayer = gameManager2.getCurrentPlayer(room.id);
+      const stats = gameManager2.getGameStats(room.id);
+      const tgn = room.game.toTGN();
+      io2.to(room.id).emit("gameUpdate", {
+        currentPlayer,
+        action: "undo",
+        currentMoveIndex: room.game.getCurrentStep(),
+        capturedStones: {
+          black: stats?.capturedByBlack || 0,
+          white: stats?.capturedByWhite || 0
+        },
+        tgn
+      });
+      if (callback) callback({ success: true });
+    } else {
+      if (callback) callback({ success: false, error: "Cannot undo", errorCode: "UNDO_FAILED" });
+    }
+  });
+  socket.on("redoMove", (callback) => {
+    const room = gameManager2.getPlayerRoom(socket.id);
+    if (!room) {
+      if (callback) callback({ success: false, error: "Not in a room", errorCode: "NOT_IN_ROOM" });
+      return;
+    }
+    if (room.gameState.gameStatus !== "playing") {
+      if (callback) callback({ success: false, error: "Game not active", errorCode: "GAME_NOT_ACTIVE" });
+      return;
+    }
+    if (!room.game.canRedo()) {
+      if (callback) callback({ success: false, error: "Nothing to redo", errorCode: "NOTHING_TO_REDO" });
+      return;
+    }
+    const success = gameManager2.redoMove(room.id, socket.id);
+    if (success) {
+      const currentPlayer = gameManager2.getCurrentPlayer(room.id);
+      const stats = gameManager2.getGameStats(room.id);
+      const lastStep = room.game.getLastStep();
+      const tgn = room.game.toTGN();
+      io2.to(room.id).emit("gameUpdate", {
+        currentPlayer,
+        action: "redo",
+        lastMove: lastStep?.position,
+        capturedStones: {
+          black: stats?.capturedByBlack || 0,
+          white: stats?.capturedByWhite || 0
+        },
+        capturedPositions: lastStep?.capturedPositions,
+        currentMoveIndex: room.game.getCurrentStep(),
+        tgn
+      });
+      if (callback) callback({ success: true });
+    } else {
+      if (callback) callback({ success: false, error: "Redo failed", errorCode: "REDO_FAILED" });
+    }
+  });
+  socket.on("resetGame", (data, callback) => {
+    const room = gameManager2.getPlayerRoom(socket.id);
+    if (!room) {
+      const cb = typeof data === "function" ? data : callback;
+      if (cb) cb({ success: false, error: "Not in a room", errorCode: "NOT_IN_ROOM" });
+      return;
+    }
+    const options = typeof data === "object" && data !== null ? {
+      boardShape: data.boardShape,
+      playerColors: data.playerColors
+    } : void 0;
+    const responseCb = typeof data === "function" ? data : callback;
+    const result = gameManager2.resetGame(room.id, socket.id, options);
+    if (result.success) {
+      const currentPlayer = gameManager2.getCurrentPlayer(room.id);
+      const tgn = room.game.toTGN();
+      const players = {};
+      for (const [pid, player] of Object.entries(room.players)) {
+        players[pid] = {
+          nickname: player.nickname,
+          color: player.color
+        };
+      }
+      io2.to(room.id).emit("gameReset", {
+        currentPlayer,
+        boardShape: room.game.getShape(),
+        currentMoveIndex: 0,
+        capturedStones: { black: 0, white: 0 },
+        players,
+        tgn
+      });
+      if (responseCb) responseCb({ success: true });
+    } else {
+      if (responseCb) responseCb({
+        success: false,
+        error: result.error || "Reset failed",
+        errorCode: result.error === "Only room admin can reset the game" ? "NOT_ADMIN" : "RESET_FAILED"
+      });
+    }
+  });
+  socket.on("chatMessage", (data) => {
+    const room = gameManager2.getPlayerRoom(socket.id);
+    if (room) {
+      const player = room.players[socket.id];
+      io2.to(room.id).emit("chatMessage", {
+        author: player?.nickname || "Unknown",
+        content: data.content,
+        playerId: socket.id
+      });
+    }
+  });
+  socket.on(
+    "changeNickname",
+    (data, callback) => {
+      const room = gameManager2.getPlayerRoom(socket.id);
+      if (!room) {
+        const error = { success: false, error: "Not in a room" };
+        if (callback) callback(error);
+        return;
+      }
+      const validation = validateNickname(data.nickname);
+      if (!validation.valid) {
+        const error = { success: false, error: validation.error };
+        if (callback) callback(error);
+        return;
+      }
+      const player = room.players[socket.id];
+      if (player) {
+        const oldNickname = player.nickname;
+        player.nickname = data.nickname;
+        io2.to(room.id).emit("nicknameChanged", {
+          playerId: socket.id,
+          nickname: data.nickname,
+          oldNickname
+        });
+        console.log(`Player ${socket.id} changed nickname: ${oldNickname} -> ${data.nickname}`);
+        if (callback) {
+          callback({ success: true, nickname: data.nickname });
+        }
+      }
+    }
+  );
+  socket.on("disconnect", () => {
+    console.log(`Client disconnected: ${socket.id}`);
+    const room = gameManager2.getPlayerRoom(socket.id);
+    if (room) {
+      const roomId = room.id;
+      gameManager2.leaveRoom(room.id, socket.id);
+      socket.to(room.id).emit("playerDisconnected", {
+        playerId: socket.id
+      });
+      const updatedRoom = gameManager2.getRoom(roomId);
+      if (updatedRoom) {
+        io2.emit("roomUpdated", getRoomSummary(updatedRoom));
+      } else {
+        io2.emit("roomDeleted", { roomId });
+      }
+    }
+  });
+}
+function validateNickname(nickname) {
+  if (!nickname || typeof nickname !== "string") {
+    return { valid: false, error: "Invalid nickname" };
+  }
+  const trimmed = nickname.trim();
+  if (trimmed.length < 3) {
+    return { valid: false, error: "Nickname must be at least 3 characters" };
+  }
+  if (trimmed.length > 20) {
+    return { valid: false, error: "Nickname must be 20 characters or less" };
+  }
+  if (!/^[a-zA-Z0-9 ]+$/.test(trimmed)) {
+    return { valid: false, error: "Only letters, numbers, and spaces allowed" };
+  }
+  if (trimmed !== nickname) {
+    return { valid: false, error: "No leading or trailing spaces allowed" };
+  }
+  return { valid: true };
+}
+
+// backend/src/server.ts
+var __filename = fileURLToPath(import.meta.url);
+var __dirname = path.dirname(__filename);
+var isDev = __dirname.includes("/src") && !__dirname.includes("/dist");
+var levelsUp = isDev ? "../" : "../../../";
+var envPath = path.join(__dirname, levelsUp, ".env");
+var envLocalPath = path.join(__dirname, levelsUp, ".env.local");
+if (fs.existsSync(envPath)) {
+  dotenv.config({ path: envPath });
+  console.log("[Config] Loaded .env");
+} else {
+  console.log(`[Config] .env not found at: ${envPath}`);
+}
+if (fs.existsSync(envLocalPath)) {
+  dotenv.config({ path: envLocalPath, override: true });
+  console.log("[Config] Loaded .env.local (overriding .env)");
+} else {
+  console.log(`[Config] .env.local not found at: ${envLocalPath}`);
+}
+var app = express();
+var httpServer = createServer(app);
+var io = new Server(httpServer, {
+  cors: {
+    origin: process.env.NODE_ENV === "production" ? process.env.CLIENT_URL || "http://localhost:5173" : true,
+    // Allow all origins in development
+    methods: ["GET", "POST"],
+    credentials: true
+  }
+});
+var gameManager = new GameManager();
+var PORT = parseInt(process.env.PORT || "3000", 10);
+var HOST = process.env.HOST || "0.0.0.0";
+console.log(`[Config] Server Configuration:`);
+console.log(`[Config]   PORT: ${PORT}`);
+console.log(`[Config]   HOST: ${HOST}`);
+console.log(`[Config]   NODE_ENV: ${process.env.NODE_ENV || "development"}`);
+console.log(`[Config]   CLIENT_URL: ${process.env.CLIENT_URL || "not set"}`);
+app.use(cors());
+app.use(express.json());
+if (process.env.NODE_ENV === "production") {
+  const frontendPath = path.join(__dirname, "../../../../app/dist");
+  app.use(express.static(frontendPath));
+  app.get("*", (req, res, next) => {
+    if (req.path.startsWith("/health") || req.path.startsWith("/socket.io")) {
+      return next();
+    }
+    res.sendFile(path.join(frontendPath, "index.html"));
+  });
+}
+app.get("/health", (_req, res) => {
+  res.json({ status: "ok", timestamp: (/* @__PURE__ */ new Date()).toISOString() });
+});
+io.on("connection", (socket) => {
+  console.log(`New client connected: ${socket.id}`);
+  setupSocketHandlers(io, socket, gameManager);
+  socket.on("echo", (data, callback) => {
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+    const responseMessage = `Hello from server! Received: "${data.message}" at ${timestamp}`;
+    console.log(`[Echo] Client ${socket.id}: ${data.message}`);
+    if (callback && typeof callback === "function") {
+      callback({
+        message: responseMessage,
+        serverTime: timestamp,
+        clientTime: data.timestamp
+      });
+    }
+  });
+  socket.on("disconnect", () => {
+    console.log(`Client disconnected: ${socket.id}`);
+  });
+});
+httpServer.listen(PORT, HOST, () => {
+  console.log(`Server running on ${HOST}:${PORT}`);
+  console.log(`Health check: http://${HOST}:${PORT}/health`);
+  console.log(`Environment: ${process.env.NODE_ENV || "development"}`);
+});