@pompidup/kingdomino-engine 3.0.0 → 3.2.0

package/dist/index.js

@@ -1,3 +1,266 @@
+// src/core/domain/types/game.ts
+var gameSteps = {
+  /** Waiting for players to be added */
+  addPlayers: "addPlayers",
+  /** Optional rules selection phase */
+  options: "options",
+  /** Ready to start the game */
+  start: "start",
+  /** Game has ended, results available */
+  result: "result"
+};
+var isGameWithNextAction = (game) => {
+  return game.nextAction.type === "action";
+};
+var isGameWithNextStep = (game) => {
+  return game.nextAction.type === "step";
+};
+
+// src/core/useCases/gameDebug.ts
+var summarizeGameState = (game) => {
+  const nextAction = isGameWithNextAction(game) ? `action:${game.nextAction.nextAction}` : `step:${game.nextAction.step}`;
+  return {
+    gameId: game.id,
+    turn: game.turn,
+    nextAction,
+    playersCount: game.players.length,
+    dominoesRemaining: game.dominoes.length,
+    currentDominoesCount: game.currentDominoes.length,
+    lordsCount: game.lords.length
+  };
+};
+var defaultDebugLogger = {
+  log: (entry) => {
+    const phase = entry.phase.toUpperCase().padEnd(5);
+    const base = `[KDomino:Debug] ${entry.timestamp} ${phase} ${entry.method}`;
+    if (entry.phase === "error") {
+      console.error(`${base} | error: ${entry.error}`);
+      return;
+    }
+    if (entry.summary) {
+      const s = entry.summary;
+      console.log(
+        `${base} | turn=${s.turn} next=${s.nextAction} players=${s.playersCount} dominoes=${s.dominoesRemaining}`
+      );
+    } else {
+      console.log(base);
+    }
+  }
+};
+var isGameState = (value) => {
+  return typeof value === "object" && value !== null && "id" in value && "nextAction" in value && "players" in value && "dominoes" in value;
+};
+var hasGameInCommand = (cmd) => {
+  return typeof cmd === "object" && cmd !== null && "game" in cmd && isGameState(cmd.game);
+};
+var extractParams = (cmd) => {
+  if (typeof cmd !== "object" || cmd === null) return void 0;
+  const record = cmd;
+  const params = {};
+  if ("mode" in record) params.mode = record.mode;
+  if ("lordId" in record) params.lordId = record.lordId;
+  if ("dominoPick" in record) params.dominoPick = record.dominoPick;
+  if ("position" in record) params.position = record.position;
+  if ("rotation" in record) params.rotation = record.rotation;
+  if ("players" in record) params.players = record.players;
+  if ("extraRules" in record) params.extraRules = record.extraRules;
+  return Object.keys(params).length > 0 ? params : void 0;
+};
+var wrapMethod = (method, fn, logger, level) => {
+  return (cmd) => {
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+    const beforeSummary = level !== "minimal" && hasGameInCommand(cmd) ? summarizeGameState(cmd.game) : null;
+    const beforeEntry = {
+      timestamp,
+      method,
+      phase: "before",
+      summary: beforeSummary,
+      params: level !== "minimal" ? extractParams(cmd) : void 0
+    };
+    logger.log(beforeEntry);
+    const start = performance.now();
+    let result;
+    try {
+      result = fn(cmd);
+    } catch (err3) {
+      const durationMs2 = Math.round((performance.now() - start) * 100) / 100;
+      const errorEntry = {
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        method,
+        phase: "error",
+        summary: beforeSummary,
+        error: err3 instanceof Error ? err3.message : String(err3),
+        durationMs: durationMs2
+      };
+      logger.log(errorEntry);
+      throw err3;
+    }
+    const durationMs = Math.round((performance.now() - start) * 100) / 100;
+    const afterSummary = level !== "minimal" && isGameState(result) ? summarizeGameState(result) : null;
+    const afterEntry = {
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      method,
+      phase: "after",
+      summary: afterSummary,
+      durationMs,
+      fullState: level === "verbose" && isGameState(result) ? result : void 0
+    };
+    logger.log(afterEntry);
+    return result;
+  };
+};
+var wrapWithDebug = (engine, options) => {
+  const logger = options?.logger ?? defaultDebugLogger;
+  const level = options?.level ?? "standard";
+  return {
+    getModes: wrapMethod("getModes", engine.getModes, logger, level),
+    getExtraRules: wrapMethod(
+      "getExtraRules",
+      engine.getExtraRules,
+      logger,
+      level
+    ),
+    createGame: wrapMethod("createGame", engine.createGame, logger, level),
+    addPlayers: wrapMethod("addPlayers", engine.addPlayers, logger, level),
+    addExtraRules: wrapMethod(
+      "addExtraRules",
+      engine.addExtraRules,
+      logger,
+      level
+    ),
+    startGame: wrapMethod("startGame", engine.startGame, logger, level),
+    chooseDomino: wrapMethod(
+      "chooseDomino",
+      engine.chooseDomino,
+      logger,
+      level
+    ),
+    placeDomino: wrapMethod("placeDomino", engine.placeDomino, logger, level),
+    discardDomino: wrapMethod(
+      "discardDomino",
+      engine.discardDomino,
+      logger,
+      level
+    ),
+    getResults: wrapMethod("getResults", engine.getResults, logger, level),
+    calculateScore: wrapMethod(
+      "calculateScore",
+      engine.calculateScore,
+      logger,
+      level
+    ),
+    getValidPlacements: wrapMethod(
+      "getValidPlacements",
+      engine.getValidPlacements,
+      logger,
+      level
+    ),
+    canPlaceDomino: wrapMethod(
+      "canPlaceDomino",
+      engine.canPlaceDomino,
+      logger,
+      level
+    ),
+    serialize: wrapMethod("serialize", engine.serialize, logger, level),
+    deserialize: wrapMethod("deserialize", engine.deserialize, logger, level),
+    getDynastyResults: wrapMethod(
+      "getDynastyResults",
+      engine.getDynastyResults,
+      logger,
+      level
+    )
+  };
+};
+
+// src/core/useCases/gameEvents.ts
+var isGameEnded = (game) => isGameWithNextStep(game) && game.nextAction.step === "result";
+var wrapWithEvents = (engine, callbacks) => ({
+  // Read-only methods — pass through
+  getModes: (cmd) => engine.getModes(cmd),
+  getExtraRules: (cmd) => engine.getExtraRules(cmd),
+  calculateScore: (cmd) => engine.calculateScore(cmd),
+  getValidPlacements: (cmd) => engine.getValidPlacements(cmd),
+  canPlaceDomino: (cmd) => engine.canPlaceDomino(cmd),
+  serialize: (cmd) => engine.serialize(cmd),
+  deserialize: (cmd) => engine.deserialize(cmd),
+  getResults: (cmd) => engine.getResults(cmd),
+  getDynastyResults: (cmd) => engine.getDynastyResults(cmd),
+  // State-changing methods — emit events after execution
+  createGame: (cmd) => {
+    const game = engine.createGame(cmd);
+    callbacks.onGameCreated?.({ game });
+    return game;
+  },
+  addPlayers: (cmd) => {
+    const game = engine.addPlayers(cmd);
+    callbacks.onPlayersAdded?.({ game });
+    return game;
+  },
+  addExtraRules: (cmd) => engine.addExtraRules(cmd),
+  startGame: (cmd) => {
+    const game = engine.startGame(cmd);
+    callbacks.onGameStarted?.({ game });
+    callbacks.onTurnStart?.({ game, turn: game.turn });
+    return game;
+  },
+  chooseDomino: (cmd) => {
+    const turnBefore = cmd.game.turn;
+    const game = engine.chooseDomino(cmd);
+    callbacks.onDominoPicked?.({
+      game,
+      lordId: cmd.lordId,
+      dominoNumber: cmd.dominoPick
+    });
+    if (game.turn !== turnBefore) {
+      callbacks.onTurnEnd?.({ game, turn: turnBefore });
+      callbacks.onTurnStart?.({ game, turn: game.turn });
+    }
+    return game;
+  },
+  placeDomino: (cmd) => {
+    const game = engine.placeDomino(cmd);
+    callbacks.onDominoPlaced?.({ game, lordId: cmd.lordId });
+    if (isGameEnded(game)) {
+      callbacks.onGameEnd?.({ game });
+    }
+    return game;
+  },
+  discardDomino: (cmd) => {
+    const game = engine.discardDomino(cmd);
+    callbacks.onDominoDiscarded?.({ game, lordId: cmd.lordId });
+    if (isGameEnded(game)) {
+      callbacks.onGameEnd?.({ game });
+    }
+    return game;
+  }
+});
+
+// src/adapterServerside/consoleLogger.ts
+var consoleLogger = (isLoggingEnabled) => {
+  const formatMessage = (level, message) => {
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+    return `${timestamp} [KDomino_Engine] ${level}: ${message}`;
+  };
+  return {
+    info: (message) => {
+      if (isLoggingEnabled) {
+        console.log(formatMessage("info", message));
+      }
+    },
+    error: (message) => {
+      if (isLoggingEnabled) {
+        console.error(formatMessage("error", message));
+      }
+    }
+  };
+};
+var silentLogger = {
+  info: () => {
+  },
+  error: () => {
+  }
+};
+
 // src/datasources/dominoes.json
 var dominoes_default = {
   Classic: [
@@ -588,26 +851,37 @@ var jsonModes_default = jsonModes;
 // src/datasources/rules.json
 var rules_default = {
   commun: [
+    {
+      playersLimit: 1,
+      lordsPerPlayer: 1,
+      maxDominoes: 48,
+      dominoesPerTurn: 4,
+      maxTurns: 12,
+      maxKingdomSize: 5
+    },
     {
       playersLimit: 2,
       lordsPerPlayer: 2,
       maxDominoes: 24,
       dominoesPerTurn: 4,
-      maxTurns: 6
+      maxTurns: 6,
+      maxKingdomSize: 5
     },
     {
       playersLimit: 3,
       lordsPerPlayer: 1,
-      maxDominoes: 36,
-      dominoesPerTurn: 3,
-      maxTurns: 12
+      maxDominoes: 48,
+      dominoesPerTurn: 4,
+      maxTurns: 12,
+      maxKingdomSize: 5
     },
     {
       playersLimit: 4,
       lordsPerPlayer: 1,
       maxDominoes: 48,
       dominoesPerTurn: 4,
-      maxTurns: 12
+      maxTurns: 12,
+      maxKingdomSize: 5
     }
   ],
   extra: [
@@ -620,6 +894,17 @@ var rules_default = {
       name: "Harmony",
       description: "Gain 5 additional points if your kingdom is complete (no discarded dominoes).",
       mode: [{ name: "Classic", description: "King Domino classic mode" }]
+    },
+    {
+      name: "The Mighty Duel",
+      description: "Use all 48 dominoes and build a 7x7 kingdom. For 2 players only.",
+      mode: [{ name: "Classic", description: "King Domino classic mode" }],
+      playersLimit: 2
+    },
+    {
+      name: "Dynasty",
+      description: "Play 3 games in a row. The player with the highest total points wins.",
+      mode: [{ name: "Classic", description: "King Domino classic mode" }]
     }
   ]
 };
@@ -637,14 +922,16 @@ var jsonRules = () => {
       lords: rule.lordsPerPlayer,
       maxDominoes: rule.maxDominoes,
       dominoesPerTurn: rule.dominoesPerTurn,
-      maxTurns: rule.maxTurns
+      maxTurns: rule.maxTurns,
+      maxKingdomSize: rule.maxKingdomSize
     };
   });
   extraRules.forEach((rule) => {
     rules.extraRules.push({
       name: rule.name,
       description: rule.description,
-      mode: rule.mode
+      mode: rule.mode,
+      ..."playersLimit" in rule && { playersLimit: rule.playersLimit }
     });
   });
   return {
@@ -673,90 +960,274 @@ var uuidMethod = () => {
   return randomUUID();
 };
 
-// src/adapterServerside/winstonLogger.ts
-import winston from "winston";
-var winstonLogger = (isLoggingEnabled) => {
-  const myFormat = winston.format.printf(
-    ({ level, message, label, timestamp }) => {
-      return `${timestamp} [${label}] ${level}: ${message}`;
-    }
-  );
-  const logger = winston.createLogger({
-    level: "info",
-    format: winston.format.combine(
-      winston.format.label({ label: "KDomino_Engine" }),
-      winston.format.timestamp(),
-      winston.format.simple(),
-      winston.format.json(),
-      winston.format.colorize(),
-      myFormat
-    ),
-    transports: [new winston.transports.Console()]
-  });
-  return {
-    info: (message) => {
-      if (isLoggingEnabled) {
-        logger.info(message);
-      }
-      return void 0;
-    },
-    error: (message) => {
-      if (isLoggingEnabled) {
-        logger.error(message);
-      }
-      return void 0;
-    }
-  };
-};
-
 // src/core/domain/errors/domainErrors.ts
-var InvalidStepError = class extends Error {
-  constructor(message) {
-    super(message);
+var ErrorCode = {
+  // Game flow errors
+  INVALID_STEP: "INVALID_STEP",
+  STEP_EXECUTION_FAILED: "STEP_EXECUTION_FAILED",
+  ACTION_EXECUTION_FAILED: "ACTION_EXECUTION_FAILED",
+  // Entity not found errors
+  LORD_NOT_FOUND: "LORD_NOT_FOUND",
+  PLAYER_NOT_FOUND: "PLAYER_NOT_FOUND",
+  DOMINO_NOT_FOUND: "DOMINO_NOT_FOUND",
+  MODE_NOT_FOUND: "MODE_NOT_FOUND",
+  // Validation errors
+  INVALID_PLAYER_COUNT: "INVALID_PLAYER_COUNT",
+  INVALID_PLAYER_NAME: "INVALID_PLAYER_NAME",
+  INVALID_PLACEMENT: "INVALID_PLACEMENT",
+  PLACEMENT_NOT_EMPTY: "PLACEMENT_NOT_EMPTY",
+  PLACEMENT_NOT_ADJACENT: "PLACEMENT_NOT_ADJACENT",
+  PLACEMENT_INVALID_TERRAIN: "PLACEMENT_INVALID_TERRAIN",
+  PLACEMENT_OUT_OF_BOUNDS: "PLACEMENT_OUT_OF_BOUNDS",
+  PLACEMENT_EXCEEDS_KINGDOM_SIZE: "PLACEMENT_EXCEEDS_KINGDOM_SIZE",
+  // Action errors
+  NOT_YOUR_TURN: "NOT_YOUR_TURN",
+  CANNOT_PICK: "CANNOT_PICK",
+  CANNOT_PLACE: "CANNOT_PLACE",
+  DOMINO_ALREADY_PICKED: "DOMINO_ALREADY_PICKED",
+  // History errors
+  UNDO_UNAVAILABLE: "UNDO_UNAVAILABLE",
+  REDO_UNAVAILABLE: "REDO_UNAVAILABLE"
+};
+var createDomainError = (code, message, context) => ({
+  code,
+  message,
+  context
+});
+var DomainException = class extends Error {
+  code;
+  context;
+  constructor(error) {
+    super(error.message);
+    this.name = "DomainException";
+    this.code = error.code;
+    this.context = error.context;
+  }
+};
+var InvalidStepError = class extends DomainException {
+  constructor(message, context) {
+    super({
+      code: ErrorCode.INVALID_STEP,
+      message,
+      context
+    });
     this.name = "InvalidStepError";
   }
 };
-var StepExecutionError = class extends Error {
-  constructor(message) {
-    super(message);
+var StepExecutionError = class extends DomainException {
+  constructor(message, code = ErrorCode.STEP_EXECUTION_FAILED, context) {
+    super({
+      code,
+      message,
+      context
+    });
     this.name = "StepExecutionError";
   }
 };
-var ActionExecutionError = class extends Error {
-  constructor(message) {
-    super(message);
+var ActionExecutionError = class extends DomainException {
+  constructor(message, code = ErrorCode.ACTION_EXECUTION_FAILED, context) {
+    super({
+      code,
+      message,
+      context
+    });
     this.name = "ActionExecutionError";
   }
 };
-var NotFoundError = class extends Error {
-  constructor(message) {
-    super(message);
+var NotFoundError = class extends DomainException {
+  constructor(message, code = ErrorCode.LORD_NOT_FOUND, context) {
+    super({
+      code,
+      message,
+      context
+    });
     this.name = "NotFoundError";
   }
 };
-
-// src/core/domain/types/game.ts
-var gameSteps = {
-  addPlayers: "addPlayers",
-  options: "options",
-  start: "start",
-  result: "result"
+var ValidationError = class extends DomainException {
+  constructor(message, code, context) {
+    super({
+      code,
+      message,
+      context
+    });
+    this.name = "ValidationError";
+  }
 };
-var isGameWithNextAction = (game) => {
-  return game.nextAction.type === "action";
+var UndoError = class extends DomainException {
+  constructor(message = "No state to undo", context) {
+    super({
+      code: ErrorCode.UNDO_UNAVAILABLE,
+      message,
+      context
+    });
+    this.name = "UndoError";
+  }
 };
-var isGameWithNextStep = (game) => {
-  return game.nextAction.type === "step";
+var RedoError = class extends DomainException {
+  constructor(message = "No state to redo", context) {
+    super({
+      code: ErrorCode.REDO_UNAVAILABLE,
+      message,
+      context
+    });
+    this.name = "RedoError";
+  }
+};
+
+// src/core/i18n/translations.ts
+var TranslationKey = {
+  // Error messages
+  ERROR_INVALID_STEP: "error.invalidStep",
+  ERROR_STEP_EXECUTION_FAILED: "error.stepExecutionFailed",
+  ERROR_ACTION_EXECUTION_FAILED: "error.actionExecutionFailed",
+  ERROR_LORD_NOT_FOUND: "error.lordNotFound",
+  ERROR_PLAYER_NOT_FOUND: "error.playerNotFound",
+  ERROR_DOMINO_NOT_FOUND: "error.dominoNotFound",
+  ERROR_MODE_NOT_FOUND: "error.modeNotFound",
+  ERROR_INVALID_PLACEMENT: "error.invalidPlacement",
+  ERROR_PLACEMENT_NOT_EMPTY: "error.placementNotEmpty",
+  ERROR_PLACEMENT_NOT_ADJACENT: "error.placementNotAdjacent",
+  ERROR_PLACEMENT_INVALID_TERRAIN: "error.placementInvalidTerrain",
+  ERROR_PLACEMENT_OUT_OF_BOUNDS: "error.placementOutOfBounds",
+  ERROR_PLACEMENT_EXCEEDS_KINGDOM_SIZE: "error.placementExceedsKingdomSize",
+  ERROR_NOT_YOUR_TURN: "error.notYourTurn",
+  ERROR_CANNOT_PICK: "error.cannotPick",
+  ERROR_CANNOT_PLACE: "error.cannotPlace",
+  ERROR_DOMINO_ALREADY_PICKED: "error.dominoAlreadyPicked",
+  ERROR_INVALID_PLAYER_COUNT: "error.invalidPlayerCount",
+  ERROR_INVALID_PLAYER_NAME: "error.invalidPlayerName",
+  ERROR_UNDO_UNAVAILABLE: "error.undoUnavailable",
+  ERROR_REDO_UNAVAILABLE: "error.redoUnavailable",
+  // Game mode names
+  MODE_CLASSIC: "mode.classic",
+  // Extra rule names
+  RULE_MIDDLE_KINGDOM: "rule.middleKingdom",
+  RULE_HARMONY: "rule.harmony",
+  // Ground types
+  GROUND_CASTLE: "ground.castle",
+  GROUND_WHEAT: "ground.wheat",
+  GROUND_FOREST: "ground.forest",
+  GROUND_SEA: "ground.sea",
+  GROUND_PLAIN: "ground.plain",
+  GROUND_SWAMP: "ground.swamp",
+  GROUND_MINE: "ground.mine",
+  // Game phases
+  PHASE_ADD_PLAYERS: "phase.addPlayers",
+  PHASE_OPTIONS: "phase.options",
+  PHASE_START: "phase.start",
+  PHASE_RESULT: "phase.result",
+  // Actions
+  ACTION_PICK_DOMINO: "action.pickDomino",
+  ACTION_PLACE_DOMINO: "action.placeDomino",
+  ACTION_PASS: "action.pass"
+};
+var defaultTranslations = {
+  // Error messages
+  [TranslationKey.ERROR_INVALID_STEP]: "Invalid game step",
+  [TranslationKey.ERROR_STEP_EXECUTION_FAILED]: "Step execution failed",
+  [TranslationKey.ERROR_ACTION_EXECUTION_FAILED]: "Action execution failed",
+  [TranslationKey.ERROR_LORD_NOT_FOUND]: "Lord not found",
+  [TranslationKey.ERROR_PLAYER_NOT_FOUND]: "Player not found",
+  [TranslationKey.ERROR_DOMINO_NOT_FOUND]: "Domino not found",
+  [TranslationKey.ERROR_MODE_NOT_FOUND]: "Game mode not found",
+  [TranslationKey.ERROR_INVALID_PLACEMENT]: "Invalid placement",
+  [TranslationKey.ERROR_PLACEMENT_NOT_EMPTY]: "Position is not empty",
+  [TranslationKey.ERROR_PLACEMENT_NOT_ADJACENT]: "Not adjacent to existing tiles",
+  [TranslationKey.ERROR_PLACEMENT_INVALID_TERRAIN]: "Terrain type does not match",
+  [TranslationKey.ERROR_PLACEMENT_OUT_OF_BOUNDS]: "Placement is out of bounds",
+  [TranslationKey.ERROR_PLACEMENT_EXCEEDS_KINGDOM_SIZE]: "Placement exceeds kingdom size",
+  [TranslationKey.ERROR_NOT_YOUR_TURN]: "It is not your turn",
+  [TranslationKey.ERROR_CANNOT_PICK]: "Cannot pick a domino now",
+  [TranslationKey.ERROR_CANNOT_PLACE]: "Cannot place a domino now",
+  [TranslationKey.ERROR_DOMINO_ALREADY_PICKED]: "Domino has already been picked",
+  [TranslationKey.ERROR_INVALID_PLAYER_COUNT]: "Invalid number of players (1-4 required)",
+  [TranslationKey.ERROR_INVALID_PLAYER_NAME]: "Player name must be at least 3 characters",
+  [TranslationKey.ERROR_UNDO_UNAVAILABLE]: "No state to undo",
+  [TranslationKey.ERROR_REDO_UNAVAILABLE]: "No state to redo",
+  // Game mode names
+  [TranslationKey.MODE_CLASSIC]: "Classic",
+  // Extra rule names
+  [TranslationKey.RULE_MIDDLE_KINGDOM]: "The Middle Kingdom",
+  [TranslationKey.RULE_HARMONY]: "Harmony",
+  // Ground types
+  [TranslationKey.GROUND_CASTLE]: "Castle",
+  [TranslationKey.GROUND_WHEAT]: "Wheat Field",
+  [TranslationKey.GROUND_FOREST]: "Forest",
+  [TranslationKey.GROUND_SEA]: "Sea",
+  [TranslationKey.GROUND_PLAIN]: "Plain",
+  [TranslationKey.GROUND_SWAMP]: "Swamp",
+  [TranslationKey.GROUND_MINE]: "Mine",
+  // Game phases
+  [TranslationKey.PHASE_ADD_PLAYERS]: "Add Players",
+  [TranslationKey.PHASE_OPTIONS]: "Game Options",
+  [TranslationKey.PHASE_START]: "Start Game",
+  [TranslationKey.PHASE_RESULT]: "Game Results",
+  // Actions
+  [TranslationKey.ACTION_PICK_DOMINO]: "Pick Domino",
+  [TranslationKey.ACTION_PLACE_DOMINO]: "Place Domino",
+  [TranslationKey.ACTION_PASS]: "Pass"
+};
+var errorCodeToTranslationKey = {
+  [ErrorCode.INVALID_STEP]: TranslationKey.ERROR_INVALID_STEP,
+  [ErrorCode.STEP_EXECUTION_FAILED]: TranslationKey.ERROR_STEP_EXECUTION_FAILED,
+  [ErrorCode.ACTION_EXECUTION_FAILED]: TranslationKey.ERROR_ACTION_EXECUTION_FAILED,
+  [ErrorCode.LORD_NOT_FOUND]: TranslationKey.ERROR_LORD_NOT_FOUND,
+  [ErrorCode.PLAYER_NOT_FOUND]: TranslationKey.ERROR_PLAYER_NOT_FOUND,
+  [ErrorCode.DOMINO_NOT_FOUND]: TranslationKey.ERROR_DOMINO_NOT_FOUND,
+  [ErrorCode.MODE_NOT_FOUND]: TranslationKey.ERROR_MODE_NOT_FOUND,
+  [ErrorCode.INVALID_PLAYER_COUNT]: TranslationKey.ERROR_INVALID_PLAYER_COUNT,
+  [ErrorCode.INVALID_PLAYER_NAME]: TranslationKey.ERROR_INVALID_PLAYER_NAME,
+  [ErrorCode.INVALID_PLACEMENT]: TranslationKey.ERROR_INVALID_PLACEMENT,
+  [ErrorCode.PLACEMENT_NOT_EMPTY]: TranslationKey.ERROR_PLACEMENT_NOT_EMPTY,
+  [ErrorCode.PLACEMENT_NOT_ADJACENT]: TranslationKey.ERROR_PLACEMENT_NOT_ADJACENT,
+  [ErrorCode.PLACEMENT_INVALID_TERRAIN]: TranslationKey.ERROR_PLACEMENT_INVALID_TERRAIN,
+  [ErrorCode.PLACEMENT_OUT_OF_BOUNDS]: TranslationKey.ERROR_PLACEMENT_OUT_OF_BOUNDS,
+  [ErrorCode.PLACEMENT_EXCEEDS_KINGDOM_SIZE]: TranslationKey.ERROR_PLACEMENT_EXCEEDS_KINGDOM_SIZE,
+  [ErrorCode.NOT_YOUR_TURN]: TranslationKey.ERROR_NOT_YOUR_TURN,
+  [ErrorCode.CANNOT_PICK]: TranslationKey.ERROR_CANNOT_PICK,
+  [ErrorCode.CANNOT_PLACE]: TranslationKey.ERROR_CANNOT_PLACE,
+  [ErrorCode.DOMINO_ALREADY_PICKED]: TranslationKey.ERROR_DOMINO_ALREADY_PICKED,
+  [ErrorCode.UNDO_UNAVAILABLE]: TranslationKey.ERROR_UNDO_UNAVAILABLE,
+  [ErrorCode.REDO_UNAVAILABLE]: TranslationKey.ERROR_REDO_UNAVAILABLE
+};
+var translateErrorCode = (translator, code, params) => {
+  const key = errorCodeToTranslationKey[code];
+  return translator.t(key, params);
+};
+var createTranslator = (translations = {}) => {
+  const mergedTranslations = { ...defaultTranslations, ...translations };
+  return {
+    t(key, params) {
+      let text = mergedTranslations[key] || key;
+      if (params) {
+        for (const [paramKey, value] of Object.entries(params)) {
+          text = text.replace(
+            new RegExp(`\\{\\{${paramKey}\\}\\}`, "g"),
+            String(value)
+          );
+        }
+      }
+      return text;
+    }
+  };
 };
+var defaultTranslator = createTranslator();
 
 // src/utils/result.ts
 var ok = (value) => ({ tag: "Ok", value });
 var err = (error) => ({ tag: "Err", error });
 var isOk = (result) => result.tag === "Ok";
 var isErr = (result) => result.tag === "Err";
+var unwrap = (result) => {
+  if (result.tag === "Err") {
+    throw new Error(result.error);
+  }
+  return result.value;
+};
 
 // src/application/handlers/addExtraRulesHandler.ts
-var addExtraRulesHandler = (logger, useCase) => (command) => {
+var addExtraRulesHandler = (logger, translator, useCase) => (command) => {
   const { game, extraRules } = command;
   logger.info(`Adding extra rules to game: ${game.id}`);
   logger.info(`Extra rules: ${extraRules}`);
@@ -764,50 +1235,101 @@ var addExtraRulesHandler = (logger, useCase) => (command) => {
     logger.error(
       `Invalid game, required nextAction type: 'step' but got: ${game.nextAction.type}`
     );
-    throw new InvalidStepError("Required game with nextAction type: 'step'");
+    throw new InvalidStepError(
+      translateErrorCode(translator, ErrorCode.INVALID_STEP),
+      { expected: "step", actual: game.nextAction.type, gameId: game.id }
+    );
   }
   if (game.nextAction.step !== "options") {
     logger.error(
       `Required game with options step but got: ${game.nextAction.step}`
     );
-    throw new InvalidStepError("Required game with options step");
+    throw new InvalidStepError(
+      translateErrorCode(translator, ErrorCode.INVALID_STEP),
+      { expected: "options", actual: game.nextAction.step, gameId: game.id }
+    );
   }
   const result = useCase(game, extraRules);
   if (isErr(result)) {
     logger.error(`Error adding extra rules: ${result.error}`);
-    throw new StepExecutionError(result.error);
+    const code = result.error;
+    throw new StepExecutionError(translateErrorCode(translator, code), code, {
+      gameId: game.id,
+      extraRules: command.extraRules
+    });
   }
   logger.info(`Extra rules added to game: ${game.id}`);
   return result.value;
 };
 
 // src/application/handlers/addPlayersHandler.ts
-var addPlayersHandler = (logger, useCase) => (command) => {
+var addPlayersHandler = (logger, translator, useCase) => (command) => {
   const { game, players } = command;
   logger.info(`Adding players to game: ${game.id}`);
   if (!isGameWithNextStep(game)) {
     logger.error(
       `Invalid game, required nextAction type: 'step' but got: ${game.nextAction.type}`
     );
-    throw new InvalidStepError("Required game with nextAction type: 'step'");
+    throw new InvalidStepError(
+      translateErrorCode(translator, ErrorCode.INVALID_STEP),
+      { expected: "step", actual: game.nextAction.type, gameId: game.id }
+    );
   }
   if (game.nextAction.step !== "addPlayers") {
     logger.error(
       `Required game with addPlayers step but got: ${game.nextAction.step}`
     );
-    throw new InvalidStepError("Required game with addPlayers step");
+    throw new InvalidStepError(
+      translateErrorCode(translator, ErrorCode.INVALID_STEP),
+      {
+        expected: "addPlayers",
+        actual: game.nextAction.step,
+        gameId: game.id
+      }
+    );
   }
   const result = useCase(game, players);
   if (isErr(result)) {
     logger.error(`Error adding players: ${result.error}`);
-    throw new StepExecutionError(result.error);
+    const code = result.error;
+    throw new StepExecutionError(translateErrorCode(translator, code), code, {
+      gameId: game.id,
+      players: command.players
+    });
   }
   logger.info(`Players added to game: ${game.id}`);
   return result.value;
 };
 
+// src/application/handlers/calculateScoreHandler.ts
+var calculateScoreHandler = (logger, translator, useCase) => (command) => {
+  const { kingdom } = command;
+  logger.info(`Calculating score for kingdom`);
+  const result = useCase(kingdom);
+  if (isErr(result)) {
+    logger.error(`Error calculating score: ${result.error}`);
+    throw new Error(result.error);
+  }
+  logger.info(`Score calculated: ${result.value}`);
+  return result.value;
+};
+
+// src/application/handlers/canPlaceDominoHandler.ts
+var canPlaceDominoHandler = (logger, translator, useCase) => {
+  return (command) => {
+    logger.info(`Checking if domino ${command.domino.number} can be placed`);
+    const canPlace = useCase(
+      command.kingdom,
+      command.domino,
+      command.maxKingdomSize
+    );
+    logger.info(`Can place domino: ${canPlace}`);
+    return canPlace;
+  };
+};
+
 // src/application/handlers/chooseDominoHandler.ts
-var chooseDominoHandler = (logger, useCase) => (command) => {
+var chooseDominoHandler = (logger, translator, useCase) => (command) => {
   const { game, lordId, dominoPick } = command;
   logger.info(
     `Choosing domino: ${dominoPick} for lord: ${lordId} in game: ${game.id}`
@@ -817,19 +1339,36 @@ var chooseDominoHandler = (logger, useCase) => (command) => {
       `Invalid game, required nextAction type: 'action' but got: ${game.nextAction.type}`
     );
     throw new InvalidStepError(
-      "Required game with nextAction type: 'action'"
+      translateErrorCode(translator, ErrorCode.INVALID_STEP),
+      { expected: "action", actual: game.nextAction.type, gameId: game.id }
     );
   }
   if (game.nextAction.nextAction !== "pickDomino") {
     logger.error(
       `Required game with pickDomino action but got: ${game.nextAction.nextAction}`
     );
-    throw new InvalidStepError("Required game with pickDomino action");
+    throw new InvalidStepError(
+      translateErrorCode(translator, ErrorCode.INVALID_STEP),
+      {
+        expected: "pickDomino",
+        actual: game.nextAction.nextAction,
+        gameId: game.id
+      }
+    );
   }
   const result = useCase(game, lordId, dominoPick);
   if (isErr(result)) {
     logger.error(`Error choosing domino: ${result.error}`);
-    throw new ActionExecutionError(result.error);
+    const code = result.error;
+    throw new ActionExecutionError(
+      translateErrorCode(translator, code),
+      code,
+      {
+        gameId: game.id,
+        lordId: command.lordId,
+        dominoPick: command.dominoPick
+      }
+    );
   }
   logger.info(
     `Domino chosen: ${dominoPick} for lord: ${lordId} in game: ${game.id}`
@@ -838,19 +1377,22 @@ var chooseDominoHandler = (logger, useCase) => (command) => {
 };
 
 // src/application/handlers/createGameHandler.ts
-var createGameHandler = (logger, useCase) => (command) => {
+var createGameHandler = (logger, translator, useCase) => (command) => {
   logger.info(`Creating game with mode: ${command.mode}`);
-  const result = useCase(command.mode);
+  const result = useCase(command.mode, command.seed);
   if (isErr(result)) {
     logger.error(`Error creating game: ${result.error}`);
-    throw new StepExecutionError(result.error);
+    const code = result.error;
+    throw new StepExecutionError(translateErrorCode(translator, code), code, {
+      mode: command.mode
+    });
   }
   logger.info(`Game created: ${result.value.id}`);
   return result.value;
 };
 
 // src/application/handlers/discardDominoHandler.ts
-var discardDominoHandler = (logger, useCase) => (command) => {
+var discardDominoHandler = (logger, translator, useCase) => (command) => {
   const { game, lordId } = command;
   logger.info(`Discarding domino for lord: ${lordId} in game: ${game.id}`);
   if (!isGameWithNextAction(game)) {
@@ -858,19 +1400,32 @@ var discardDominoHandler = (logger, useCase) => (command) => {
       `Invalid game, required nextAction type: 'action' but got: ${game.nextAction.type}`
     );
     throw new InvalidStepError(
-      "Required game with nextAction type: 'action'"
+      translateErrorCode(translator, ErrorCode.INVALID_STEP),
+      { expected: "action", actual: game.nextAction.type, gameId: game.id }
     );
   }
   if (game.nextAction.nextAction !== "placeDomino") {
     logger.error(
       `Required game with placeDomino action but got: ${game.nextAction.nextAction}`
     );
-    throw new InvalidStepError("Required game with placeDomino action");
+    throw new InvalidStepError(
+      translateErrorCode(translator, ErrorCode.INVALID_STEP),
+      {
+        expected: "placeDomino",
+        actual: game.nextAction.nextAction,
+        gameId: game.id
+      }
+    );
   }
   const result = useCase(game, lordId);
   if (isErr(result)) {
     logger.error(`Error discarding domino: ${result.error}`);
-    throw new ActionExecutionError(result.error);
+    const code = result.error;
+    throw new ActionExecutionError(
+      translateErrorCode(translator, code),
+      code,
+      { gameId: game.id, lordId: command.lordId }
+    );
   }
   if (isGameWithNextAction(result.value)) {
     logger.info(`Domino discarded: ${lordId} in game: ${game.id}`);
@@ -880,8 +1435,20 @@ var discardDominoHandler = (logger, useCase) => (command) => {
   return result.value;
 };
 
+// src/application/handlers/getDynastyResultHandler.ts
+var getDynastyResultHandler = (logger, translator, useCase) => {
+  return (command) => {
+    logger.info(
+      `Calculating dynasty results for ${command.games.length} games`
+    );
+    const results = useCase(command.games);
+    logger.info(`Dynasty results calculated`);
+    return results;
+  };
+};
+
 // src/application/handlers/getExtraRulesHandler.ts
-var getExtraRulesHandler = (logger, useCase) => (command) => {
+var getExtraRulesHandler = (logger, translator, useCase) => (command) => {
   const { mode, players } = command;
   logger.info(
     `Getting extra rules for mode: ${mode} and players: ${players}`
@@ -889,26 +1456,30 @@ var getExtraRulesHandler = (logger, useCase) => (command) => {
   const result = useCase(mode, players);
   if (isErr(result)) {
     logger.error(`Error getting extra rules: ${result.error}`);
-    throw new NotFoundError(result.error);
+    const code = result.error;
+    throw new NotFoundError(translateErrorCode(translator, code), code, {
+      mode: command.mode
+    });
   }
   logger.info(`Extra rules retrieved: ${result.value}`);
   return result.value;
 };
 
 // src/application/handlers/getModesHandler.ts
-var getModesHandler = (logger, useCase) => (_command) => {
+var getModesHandler = (logger, translator, useCase) => (_command) => {
   logger.info("Getting modes");
   const result = useCase();
   if (isErr(result)) {
     logger.error(`Error getting modes: ${result.error}`);
-    throw new NotFoundError(result.error);
+    const code = result.error;
+    throw new NotFoundError(translateErrorCode(translator, code), code);
   }
   logger.info(`Modes retrieved: ${result.value}`);
   return result.value;
 };
 
 // src/application/handlers/getResultHandler.ts
-var getResultHandler = (logger, useCases) => (command) => {
+var getResultHandler = (logger, translator, useCases) => (command) => {
   const { getResultUseCase: getResultUseCase2, calculateScoreUseCase: calculateScoreUseCase2 } = useCases;
   const { game } = command;
   logger.info(`Getting result for game: ${game.id}`);
@@ -916,22 +1487,34 @@ var getResultHandler = (logger, useCases) => (command) => {
     logger.error(
       `Invalid game, required nextAction type: 'step' but got: ${game.nextAction.type}`
     );
-    throw new InvalidStepError("Required game with nextAction type: 'step'");
+    throw new InvalidStepError(
+      translateErrorCode(translator, ErrorCode.INVALID_STEP),
+      { expected: "step", actual: game.nextAction.type, gameId: game.id }
+    );
   }
   if (game.nextAction.step !== "result") {
     logger.error(
       `Required game with result step but got: ${game.nextAction.step}`
     );
-    throw new InvalidStepError("Required game with result step");
+    throw new InvalidStepError(
+      translateErrorCode(translator, ErrorCode.INVALID_STEP),
+      { expected: "result", actual: game.nextAction.step, gameId: game.id }
+    );
   }
-  let scoreResult;
   const { players } = game;
-  scoreResult = players.map((player) => {
+  const scoreResult = players.map((player) => {
     const { kingdom } = player;
     const result2 = calculateScoreUseCase2(kingdom);
     if (isErr(result2)) {
       logger.error(`Error when calculating score: ${result2.error}`);
-      throw new StepExecutionError(result2.error);
+      const code = result2.error;
+      throw new StepExecutionError(
+        translateErrorCode(translator, code),
+        code,
+        {
+          gameId: game.id
+        }
+      );
     }
     return {
       playerId: player.id,
@@ -944,14 +1527,33 @@ var getResultHandler = (logger, useCases) => (command) => {
   const result = getResultUseCase2(game, scoreResult);
   if (isErr(result)) {
     logger.error(`Error getting result: ${result.error}`);
-    throw new NotFoundError(result.error);
+    const code = result.error;
+    throw new NotFoundError(translateErrorCode(translator, code), code, {
+      gameId: game.id
+    });
   }
   logger.info(`Result retrieved for game: ${game.id}`);
   return result.value;
 };
 
+// src/application/handlers/getValidPlacementsHandler.ts
+var getValidPlacementsHandler = (logger, translator, useCase) => {
+  return (command) => {
+    logger.info(
+      `Getting valid placements for domino: ${command.domino.number}`
+    );
+    const placements = useCase(
+      command.kingdom,
+      command.domino,
+      command.maxKingdomSize
+    );
+    logger.info(`Found ${placements.length} valid placements`);
+    return placements;
+  };
+};
+
 // src/application/handlers/placeDominoHandler.ts
-var placeDominoHandler = (logger, useCase) => (command) => {
+var placeDominoHandler = (logger, translator, useCase) => (command) => {
   const { game, lordId, position, rotation } = command;
   logger.info(
     `Placing domino: ${lordId} in position: ${JSON.stringify(
@@ -963,19 +1565,37 @@ var placeDominoHandler = (logger, useCase) => (command) => {
       `Invalid game, required nextAction type: 'action' but got: ${game.nextAction.type}`
     );
     throw new InvalidStepError(
-      "Required game with nextAction type: 'action'"
+      translateErrorCode(translator, ErrorCode.INVALID_STEP),
+      { expected: "action", actual: game.nextAction.type, gameId: game.id }
     );
   }
   if (game.nextAction.nextAction !== "placeDomino") {
     logger.error(
       `Required game with placeDomino action but got: ${game.nextAction.nextAction}`
     );
-    throw new InvalidStepError("Required game with placeDomino step");
+    throw new InvalidStepError(
+      translateErrorCode(translator, ErrorCode.INVALID_STEP),
+      {
+        expected: "placeDomino",
+        actual: game.nextAction.nextAction,
+        gameId: game.id
+      }
+    );
   }
   const result = useCase(game, lordId, position, rotation);
   if (isErr(result)) {
     logger.error(`Error placing domino: ${result.error}`);
-    throw new ActionExecutionError(result.error);
+    const code = result.error;
+    throw new ActionExecutionError(
+      translateErrorCode(translator, code),
+      code,
+      {
+        gameId: game.id,
+        lordId: command.lordId,
+        position: command.position,
+        rotation: command.rotation
+      }
+    );
   }
   if (isGameWithNextAction(result.value)) {
     logger.info(
@@ -993,48 +1613,113 @@ var placeDominoHandler = (logger, useCase) => (command) => {
   return result.value;
 };
 
+// src/core/useCases/serialization.ts
+var SERIALIZATION_VERSION = 1;
+var serializeGame = (game) => {
+  const serialized = {
+    version: SERIALIZATION_VERSION,
+    data: game,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  return JSON.stringify(serialized);
+};
+var deserializeGame = (json) => {
+  try {
+    const parsed = JSON.parse(json);
+    if (!parsed.version || !parsed.data) {
+      return err("Invalid serialized game format");
+    }
+    if (parsed.version > SERIALIZATION_VERSION) {
+      return err(
+        `Unsupported serialization version: ${parsed.version}. Current version: ${SERIALIZATION_VERSION}`
+      );
+    }
+    const game = parsed.data;
+    if (!game.id || !game.players || !game.lords || !game.nextAction) {
+      return err("Invalid game state structure");
+    }
+    return ok(game);
+  } catch (error) {
+    return err(`Failed to parse game JSON: ${error.message}`);
+  }
+};
+var createSavePoint = (game) => {
+  return {
+    serialized: serializeGame(game),
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    gameId: game.id,
+    turn: game.turn
+  };
+};
+var restoreFromSavePoint = (savePoint) => {
+  return deserializeGame(savePoint.serialized);
+};
+
+// src/application/handlers/serializeGameHandler.ts
+var serializeGameHandler = (logger, _translator) => {
+  return (command) => {
+    logger.info(`Serializing game: ${command.game.id}`);
+    const serialized = serializeGame(command.game);
+    logger.info(`Game serialized successfully`);
+    return serialized;
+  };
+};
+var deserializeGameHandler = (logger, translator) => {
+  return (command) => {
+    logger.info(`Deserializing game from JSON`);
+    const result = deserializeGame(command.json);
+    if (isErr(result)) {
+      logger.error(`Failed to deserialize game: ${result.error}`);
+      const code = result.error;
+      throw new StepExecutionError(translateErrorCode(translator, code), code);
+    }
+    const game = unwrap(result);
+    logger.info(`Game deserialized successfully: ${game.id}`);
+    return game;
+  };
+};
+
 // src/application/handlers/startGameHandler.ts
-var startGameHandler = (logger, useCase) => (command) => {
+var startGameHandler = (logger, translator, useCase) => (command) => {
   const { game } = command;
   logger.info(`Starting game: ${game.id}`);
   if (!isGameWithNextStep(game)) {
     logger.error(
       `Invalid game, required nextAction type: 'step' but got: ${game.nextAction.type}`
     );
-    throw new InvalidStepError("Required game with nextAction type: 'step'");
+    throw new InvalidStepError(
+      translateErrorCode(translator, ErrorCode.INVALID_STEP),
+      { expected: "step", actual: game.nextAction.type, gameId: game.id }
+    );
   }
   if (game.nextAction.step !== "start" && game.nextAction.step !== "options") {
     logger.error(
       `Required game with start step or options step but got: ${game.nextAction.step}`
     );
     throw new InvalidStepError(
-      "Required game with start step or options step"
+      translateErrorCode(translator, ErrorCode.INVALID_STEP),
+      {
+        expected: "start|options",
+        actual: game.nextAction.step,
+        gameId: game.id
+      }
     );
   }
   const result = useCase(game);
   if (isErr(result)) {
     logger.error(`Error starting game: ${result.error}`);
-    throw new StepExecutionError(result.error);
+    const code = result.error;
+    throw new StepExecutionError(translateErrorCode(translator, code), code, {
+      gameId: game.id
+    });
   }
   logger.info(`Game started: ${game.id}`);
   return result.value;
 };
 
-// src/application/handlers/calculateScoreHandler.ts
-var calculateScoreHandler = (logger, useCase) => (command) => {
-  const { kingdom } = command;
-  logger.info(`Calculating score for kingdom`);
-  const result = useCase(kingdom);
-  if (isErr(result)) {
-    logger.error(`Error calculating score: ${result.error}`);
-    throw new Error(result.error);
-  }
-  logger.info(`Score calculated: ${result.value}`);
-  return result.value;
-};
-
 // src/core/domain/types/kingdom.ts
 var GRIDSIZE = 9;
+var MAX_KINGDOM_SIZE = 5;
 
 // src/core/domain/types/domino.ts
 var GROUND = [
@@ -1049,8 +1734,11 @@ var GROUND = [
 
 // src/core/domain/types/player.ts
 var playerActions = {
+  /** Place a previously picked domino on the kingdom */
   placeDomino: "placeDomino",
+  /** Pick a domino from the revealed set */
   pickDomino: "pickDomino",
+  /** Pass/discard when no valid placement exists */
   pass: "pass"
 };
 
@@ -1060,21 +1748,53 @@ var getAvailablesExtraRules = (extraRules, mode, numberOfPlayers) => {
     return rule.mode.filter((m) => m.name === mode).length > 0 && (!rule.playersLimit || rule.playersLimit === numberOfPlayers);
   });
   if (availableExtraRules.length === 0) {
-    return err("No extra rules found");
+    return err(ErrorCode.STEP_EXECUTION_FAILED);
   }
   return ok(availableExtraRules);
 };
 var toExtraRule = (rule, extraRules) => {
   const foundRule = extraRules.find((r) => r.name === rule);
   if (!foundRule) {
-    return err(`Rule not found: ${rule}`);
+    return err(ErrorCode.STEP_EXECUTION_FAILED);
   }
   return ok(foundRule);
 };
 
+// src/utils/seededShuffle.ts
+var hashSeed = (str) => {
+  let hash = 2166136261;
+  for (let i = 0; i < str.length; i++) {
+    hash ^= str.charCodeAt(i);
+    hash = Math.imul(hash, 16777619);
+  }
+  return hash >>> 0;
+};
+var mulberry32 = (seed) => {
+  let state = seed;
+  return () => {
+    state |= 0;
+    state = state + 1831565813 | 0;
+    let t = Math.imul(state ^ state >>> 15, 1 | state);
+    t = t + Math.imul(t ^ t >>> 7, 61 | t) ^ t;
+    return ((t ^ t >>> 14) >>> 0) / 4294967296;
+  };
+};
+var createSeededShuffle = (seed, salt) => {
+  const numericSeed = hashSeed(`${seed}|${salt}`);
+  const random = mulberry32(numericSeed);
+  return (array) => {
+    const result = [...array];
+    for (let i = result.length - 1; i > 0; i--) {
+      const j = Math.floor(random() * (i + 1));
+      [result[i], result[j]] = [result[j], result[i]];
+    }
+    return result;
+  };
+};
+
 // src/core/useCases/addExtraRules.ts
 var addExtraRulesUseCase = (deps) => (game, rules) => {
-  const { ruleRepository } = deps;
+  const { ruleRepository, dominoesRepository, shuffleMethod: shuffleMethod2 } = deps;
   const availableExtraRules = ruleRepository.getAllExtra();
   const newExtraRules = [];
   for (const rule of rules) {
@@ -1084,8 +1804,24 @@ var addExtraRulesUseCase = (deps) => (game, rules) => {
     }
     newExtraRules.push(result.value);
   }
+  let updatedBasic = game.rules.basic;
+  let updatedDominoes = game.dominoes;
+  const hasMightyDuel = newExtraRules.some((r) => r.name === "The Mighty Duel");
+  if (hasMightyDuel) {
+    updatedBasic = {
+      ...updatedBasic,
+      maxDominoes: 48,
+      maxTurns: 12,
+      maxKingdomSize: 7
+    };
+    const allDominoes = dominoesRepository.getForMode(game.mode);
+    if (allDominoes) {
+      const shuffle = game.seed ? createSeededShuffle(game.seed, "mighty-duel") : shuffleMethod2;
+      updatedDominoes = shuffle(allDominoes);
+    }
+  }
   const updatedRules = {
-    basic: game.rules.basic,
+    basic: updatedBasic,
     extra: newExtraRules
   };
   const next = {
@@ -1094,6 +1830,7 @@ var addExtraRulesUseCase = (deps) => (game, rules) => {
   };
   const updatedGame = {
     ...game,
+    dominoes: updatedDominoes,
     rules: updatedRules,
     nextAction: next
   };
@@ -1133,7 +1870,7 @@ var placeTile = (kingdom, position, tile) => {
 var getTile = (kingdom, position) => {
   const tile = kingdom[position.y]?.[position.x];
   if (!tile) {
-    return err("Invalid placement (not fit into the grid)");
+    return err(ErrorCode.PLACEMENT_OUT_OF_BOUNDS);
   }
   return ok(tile);
 };
@@ -1208,7 +1945,7 @@ var calculateDominoPosition = (position, rotation, domino) => {
   }
   return [firstTile, secondTile];
 };
-var placeDomino = (kingdom, position, rotation, domino) => {
+var placeDomino = (kingdom, position, rotation, domino, maxKingdomSize = MAX_KINGDOM_SIZE) => {
   const [firstTile, secondTile] = calculateDominoPosition(
     position,
     rotation,
@@ -1222,20 +1959,23 @@ var placeDomino = (kingdom, position, rotation, domino) => {
   if (isErr(isFreePlaceResult)) {
     return isFreePlaceResult;
   }
+  if (exceedsMaxSize(kingdom, firstTile.position, secondTile.position, maxKingdomSize)) {
+    return err(ErrorCode.PLACEMENT_EXCEEDS_KINGDOM_SIZE);
+  }
   const adjacentTiles = isAdjacent(
     kingdom,
     firstTile.position,
     secondTile.position
   );
   if (adjacentTiles.length === 0) {
-    return err("Invalid placement (not adjacent)");
+    return err(ErrorCode.PLACEMENT_NOT_ADJACENT);
   }
   const hasValidAdjacentTiles = hasValidAdjacent(adjacentTiles, [
     firstTile.tile,
     secondTile.tile
   ]);
   if (!hasValidAdjacentTiles) {
-    return err("Invalid placement (not valid adjacent)");
+    return err(ErrorCode.PLACEMENT_INVALID_TERRAIN);
   }
   return ok(placeTiles(kingdom, [firstTile, secondTile]));
 };
@@ -1256,46 +1996,30 @@ var isFreePlace = (kingdom, firstPosition, secondPosition) => {
     return secondTile;
   }
   if (firstTile.value.type !== "empty" || secondTile.value.type !== "empty") {
-    return err("Invalid placement (not empty)");
+    return err(ErrorCode.PLACEMENT_NOT_EMPTY);
   }
   return ok(true);
 };
 var isAdjacent = (kingdom, firstPosition, secondPosition) => {
-  const xFirstPosition = firstPosition.x;
-  const yFirstPosition = firstPosition.y;
-  const xSecondPosition = secondPosition.x;
-  const ySecondPosition = secondPosition.y;
-  const adjacentTiles = [];
-  const adjacentTilesKeys = [
-    { x: xFirstPosition - 1, y: yFirstPosition },
-    { x: xFirstPosition, y: yFirstPosition - 1 },
-    { x: xFirstPosition + 1, y: yFirstPosition },
-    { x: xFirstPosition, y: yFirstPosition + 1 },
-    { x: xSecondPosition - 1, y: ySecondPosition },
-    { x: xSecondPosition, y: ySecondPosition - 1 },
-    { x: xSecondPosition + 1, y: ySecondPosition },
-    { x: xSecondPosition, y: ySecondPosition + 1 }
+  const offsets = [
+    { x: -1, y: 0 },
+    { x: 1, y: 0 },
+    { x: 0, y: -1 },
+    { x: 0, y: 1 }
   ];
-  adjacentTilesKeys.splice(
-    adjacentTilesKeys.findIndex((pos) => {
-      return pos.x === xFirstPosition && pos.y === yFirstPosition;
-    }),
-    1
-  );
-  adjacentTilesKeys.splice(
-    adjacentTilesKeys.findIndex((pos) => {
-      return pos.x === xSecondPosition && pos.y === ySecondPosition;
-    }),
-    1
-  );
-  adjacentTilesKeys.forEach((key) => {
-    const tile = getTile(kingdom, key);
-    if (isOk(tile)) {
-      if (tile.value.type !== "empty") {
+  const isOwnPosition = (x, y) => x === firstPosition.x && y === firstPosition.y || x === secondPosition.x && y === secondPosition.y;
+  const adjacentTiles = [];
+  for (const pos of [firstPosition, secondPosition]) {
+    for (const offset of offsets) {
+      const nx = pos.x + offset.x;
+      const ny = pos.y + offset.y;
+      if (isOwnPosition(nx, ny)) continue;
+      const tile = getTile(kingdom, { x: nx, y: ny });
+      if (isOk(tile) && tile.value.type !== "empty") {
         adjacentTiles.push(tile.value);
       }
     }
-  });
+  }
   return adjacentTiles;
 };
 var hasValidAdjacent = (adjacentTiles, tiles) => {
@@ -1306,22 +2030,56 @@ var hasValidAdjacent = (adjacentTiles, tiles) => {
   });
 };
 var checkCastleIsInMiddle = (kingdom) => {
-  const castlePosition = kingdom.map((row) => row.findIndex((tile) => tile.type === "castle")).find((index) => index !== -1);
-  const leftTiles = castlePosition !== void 0 ? kingdom[castlePosition].slice(0, castlePosition) : [];
-  const leftTilesCount = leftTiles.filter(
-    (tile) => tile.type !== "empty"
-  ).length;
-  const rightTiles = castlePosition !== void 0 ? kingdom[castlePosition].slice(castlePosition + 1) : [];
-  const rightTilesCount = rightTiles.filter(
-    (tile) => tile.type !== "empty"
-  ).length;
-  const topTiles = castlePosition !== void 0 ? kingdom[castlePosition].slice(0, castlePosition) : [];
-  const topTilesCount = topTiles.filter((tile) => tile.type !== "empty").length;
-  const bottomTiles = castlePosition != void 0 ? kingdom[castlePosition].slice(castlePosition + 1) : [];
-  const bottomTilesCount = bottomTiles.filter(
-    (tile) => tile.type !== "empty"
-  ).length;
-  return leftTilesCount === rightTilesCount && topTilesCount === bottomTilesCount && leftTilesCount === topTilesCount;
+  let castleX;
+  let castleY;
+  for (let y = 0; y < kingdom.length; y++) {
+    const x = kingdom[y].findIndex((tile) => tile.type === "castle");
+    if (x !== -1) {
+      castleX = x;
+      castleY = y;
+      break;
+    }
+  }
+  if (castleX === void 0 || castleY === void 0) {
+    return false;
+  }
+  const bbox = getBoundingBox(kingdom);
+  if (!bbox) return false;
+  const centerX = (bbox.minX + bbox.maxX) / 2;
+  const centerY = (bbox.minY + bbox.maxY) / 2;
+  return castleX === centerX && castleY === centerY;
+};
+var getBoundingBox = (kingdom) => {
+  let minX = Infinity;
+  let maxX = -Infinity;
+  let minY = Infinity;
+  let maxY = -Infinity;
+  for (let y = 0; y < kingdom.length; y++) {
+    for (let x = 0; x < kingdom[y].length; x++) {
+      if (kingdom[y][x].type !== "empty") {
+        if (x < minX) minX = x;
+        if (x > maxX) maxX = x;
+        if (y < minY) minY = y;
+        if (y > maxY) maxY = y;
+      }
+    }
+  }
+  if (minX === Infinity) return null;
+  return { minX, maxX, minY, maxY };
+};
+var exceedsMaxSize = (kingdom, firstPosition, secondPosition, maxSize = MAX_KINGDOM_SIZE) => {
+  const bbox = getBoundingBox(kingdom);
+  let minX = bbox?.minX ?? Infinity;
+  let maxX = bbox?.maxX ?? -Infinity;
+  let minY = bbox?.minY ?? Infinity;
+  let maxY = bbox?.maxY ?? -Infinity;
+  for (const pos of [firstPosition, secondPosition]) {
+    if (pos.x < minX) minX = pos.x;
+    if (pos.x > maxX) maxX = pos.x;
+    if (pos.y < minY) minY = pos.y;
+    if (pos.y > maxY) maxY = pos.y;
+  }
+  return maxX - minX + 1 > maxSize || maxY - minY + 1 > maxSize;
 };
 var countDominoes = (kingdom) => {
   const notEmpties = kingdom.flat().filter((tile) => tile.type !== "empty");
@@ -1335,11 +2093,11 @@ var deepCopyKingdom = (kingdom) => {
 var MINPLAYERSNAMELENGTH = 3;
 var validatePlayer = (name) => {
   if (!name || name.trim().length < MINPLAYERSNAMELENGTH) {
-    return err(`Invalid player name: ${name}`);
+    return err(ErrorCode.INVALID_PLAYER_NAME);
   }
   return ok(name);
 };
-var createPlayer = (playerName, id, kingdom) => {
+var createPlayer = (playerName, id, kingdom, bot) => {
   const name = validatePlayer(playerName);
   if (isErr(name)) {
     return name;
@@ -1347,22 +2105,30 @@ var createPlayer = (playerName, id, kingdom) => {
   return ok({
     name: name.value,
     id,
-    kingdom
+    kingdom,
+    ...bot && { bot }
   });
 };
 
 // src/core/useCases/addPlayers.ts
+var normalizePlayerInput = (input) => {
+  if (typeof input === "string") {
+    return { name: input };
+  }
+  return { name: input.name, bot: input.bot };
+};
 var addPlayersUseCase = (deps) => (game, players) => {
   const { uuidMethod: uuidMethod2, shuffleMethod: shuffleMethod2, ruleRepository } = deps;
-  if (!players || players.length < 2 || players.length > 4) {
-    return err("Invalid number of players");
+  if (!players || players.length < 1 || players.length > 4) {
+    return err(ErrorCode.INVALID_PLAYER_COUNT);
   }
   const newPlayers = [];
   for (const player of players) {
+    const { name, bot } = normalizePlayerInput(player);
     let kingdom = createEmptyKingdom();
     kingdom = placeCastle(kingdom);
     let id = uuidMethod2();
-    const newPlayer = createPlayer(player, id, kingdom);
+    const newPlayer = createPlayer(name, id, kingdom, bot);
     if (isErr(newPlayer)) {
       return newPlayer;
     }
@@ -1371,11 +2137,12 @@ var addPlayersUseCase = (deps) => (game, players) => {
   const rules = ruleRepository.getAll();
   const basicRules = rules.basic[newPlayers.length];
   if (!basicRules) {
-    return err("No base rules found");
+    return err(ErrorCode.STEP_EXECUTION_FAILED);
   }
   const dominoes = game.dominoes;
   const { maxDominoes } = basicRules;
-  const shuffledDominoes = shuffleMethod2(dominoes);
+  const shuffle = game.seed ? createSeededShuffle(game.seed, "dominoes") : shuffleMethod2;
+  const shuffledDominoes = shuffle(dominoes);
   const splicedDominoes = shuffledDominoes.slice(0, maxDominoes);
   const next = {
     type: "step",
@@ -1394,6 +2161,70 @@ var addPlayersUseCase = (deps) => (game, players) => {
   return ok(updatedGame);
 };
 
+// src/core/useCases/calculateScore.ts
+var calculateScoreUseCase = (kingdom) => {
+  const rows = kingdom.length;
+  const cols = kingdom[0].length;
+  const visited = kingdom.map((row) => row.map(() => false));
+  const properties = [];
+  const directions = [
+    [-1, 0],
+    [1, 0],
+    [0, -1],
+    [0, 1]
+  ];
+  for (let y = 0; y < rows; y++) {
+    for (let x = 0; x < cols; x++) {
+      const tile = kingdom[y][x];
+      if (visited[y][x] || tile.type === "empty" || tile.type === "castle") {
+        continue;
+      }
+      const type = tile.type;
+      let size = 0;
+      let crowns = 0;
+      const queue = [[x, y]];
+      visited[y][x] = true;
+      while (queue.length > 0) {
+        const [cx, cy] = queue.pop();
+        const current = kingdom[cy][cx];
+        size++;
+        crowns += current.crowns;
+        for (const [dx, dy] of directions) {
+          const nx = cx + dx;
+          const ny = cy + dy;
+          if (nx >= 0 && ny >= 0 && nx < cols && ny < rows && !visited[ny][nx] && kingdom[ny][nx].type === type) {
+            visited[ny][nx] = true;
+            queue.push([nx, ny]);
+          }
+        }
+      }
+      properties.push({ size, crowns });
+    }
+  }
+  if (properties.length === 0) {
+    return ok({
+      points: 0,
+      maxPropertiesSize: 0,
+      totalCrowns: 0
+    });
+  }
+  let points = 0;
+  let maxPropertiesSize = 0;
+  let totalCrowns = 0;
+  for (const property of properties) {
+    points += property.size * property.crowns;
+    if (property.size > maxPropertiesSize) {
+      maxPropertiesSize = property.size;
+    }
+    totalCrowns += property.crowns;
+  }
+  return ok({
+    points,
+    maxPropertiesSize,
+    totalCrowns
+  });
+};
+
 // src/core/domain/entities/lord.ts
 var createLord = (id, playerId) => {
   return {
@@ -1417,18 +2248,17 @@ var canPlaceAndDominoPickedIsDefined = (lord) => {
   return !hasPick(lord) && !hasPlace(lord) && !hasTurnEnded(lord) && lord.dominoPicked !== void 0;
 };
 var updateLordOrder = (lords) => {
-  return lords.sort((a, b) => {
-    return a.dominoPicked.number - b.dominoPicked.number;
+  return [...lords].sort((a, b) => {
+    return (a.dominoPicked?.number ?? 0) - (b.dominoPicked?.number ?? 0);
   });
 };
-var resetLordsActions = (lord) => {
-  const lordsCopy = [...lord];
-  for (const lord2 of lordsCopy) {
-    lord2.turnEnded = false;
-    lord2.hasPick = false;
-    lord2.hasPlace = false;
-  }
-  return lordsCopy;
+var resetLordsActions = (lords) => {
+  return lords.map((lord) => ({
+    ...lord,
+    turnEnded: false,
+    hasPick: false,
+    hasPlace: false
+  }));
 };
 var nextLordWithAction = (lords) => {
   const nextLord = findNextLord(lords);
@@ -1455,38 +2285,29 @@ var chooseDominoUseCase = (game, lordId, dominoPick) => {
     (lord) => lord.id === game.nextAction.nextLord
   );
   if (!currentLord) {
-    return err("Lord not found");
+    return err(ErrorCode.LORD_NOT_FOUND);
   }
   if (currentLord.id !== lordId) {
-    return err("Not your turn");
+    return err(ErrorCode.NOT_YOUR_TURN);
   }
   if (!canPick(currentLord)) {
-    return err("Lord can't pick");
+    return err(ErrorCode.CANNOT_PICK);
   }
   const selectedDomino = game.currentDominoes.find(
     (domino) => domino.domino.number === dominoPick
   );
   if (!selectedDomino) {
-    return err("Domino not found");
+    return err(ErrorCode.DOMINO_NOT_FOUND);
   }
   if (selectedDomino.picked) {
-    return err("Domino already picked");
+    return err(ErrorCode.DOMINO_ALREADY_PICKED);
   }
-  const updatedCurrentDominoes = game.currentDominoes.map((domino) => {
-    if (domino.domino.number === dominoPick) {
-      domino.picked = true;
-      domino.lordId = currentLord.id;
-    }
-    return domino;
-  });
-  const updatedLords = game.lords.map((lord) => {
-    if (lord.id === currentLord.id) {
-      lord.hasPick = true;
-      lord.turnEnded = true;
-      lord.dominoPicked = selectedDomino.domino;
-    }
-    return lord;
-  });
+  const updatedCurrentDominoes = game.currentDominoes.map(
+    (domino) => domino.domino.number === dominoPick ? { ...domino, picked: true, lordId: currentLord.id } : domino
+  );
+  const updatedLords = game.lords.map(
+    (lord) => lord.id === currentLord.id ? { ...lord, hasPick: true, turnEnded: true, dominoPicked: selectedDomino.domino } : lord
+  );
   const turnEnded = allLordsHavePlayed(updatedLords);
   if (turnEnded) {
     const lords = resetLordsActions(updateLordOrder(updatedLords));
@@ -1527,7 +2348,7 @@ var chooseDominoUseCase = (game, lordId, dominoPick) => {
 
 // src/core/domain/entities/game.ts
 var create = (payload) => {
-  const { id, mode, dominoes } = payload;
+  const { id, mode, dominoes, seed } = payload;
   return {
     id,
     dominoes,
@@ -1544,11 +2365,13 @@ var create = (payload) => {
         lords: 0,
         maxDominoes: 0,
         dominoesPerTurn: 0,
-        maxTurns: 0
+        maxTurns: 0,
+        maxKingdomSize: 5
       },
       extra: []
     },
-    mode
+    mode,
+    ...seed !== void 0 && { seed }
   };
 };
 
@@ -1561,13 +2384,14 @@ var createMode = (mode, availableMode) => {
   if (foundMode) {
     return ok(foundMode);
   }
-  return err(`Invalid mode: ${mode}`);
+  return err(ErrorCode.MODE_NOT_FOUND);
 };
 
 // src/core/useCases/createGame.ts
-var createGameUseCase = (deps) => (mode) => {
+var createGameUseCase = (deps) => (mode, seed) => {
   const { modeRepository, dominoesRepository, uuidMethod: uuidMethod2 } = deps;
   const id = uuidMethod2();
+  const gameSeed = seed ?? uuidMethod2();
   const availableMode = modeRepository.getAvailables();
   const newMode = createMode(mode, availableMode);
   if (isErr(newMode)) {
@@ -1575,17 +2399,51 @@ var createGameUseCase = (deps) => (mode) => {
   }
   const dominoes = dominoesRepository.getForMode(newMode.value);
   if (!dominoes || dominoes.length === 0) {
-    return err(`No dominoes found for mode ${newMode.value.name}`);
+    return err(ErrorCode.DOMINO_NOT_FOUND);
   }
   const payload = {
     id,
     mode: newMode.value,
-    dominoes
+    dominoes,
+    seed: gameSeed
   };
   const newGame = create(payload);
   return ok(newGame);
 };
 
+// src/core/useCases/getValidPlacements.ts
+var getValidPlacementsUseCase = (kingdom, domino, maxKingdomSize = MAX_KINGDOM_SIZE) => {
+  const validPlacements = [];
+  const rotations = [0, 90, 180, 270];
+  for (let y = 0; y < GRIDSIZE; y++) {
+    for (let x = 0; x < GRIDSIZE; x++) {
+      const position = { x, y };
+      for (const rotation of rotations) {
+        const result = placeDomino(kingdom, position, rotation, domino, maxKingdomSize);
+        if (isOk(result)) {
+          validPlacements.push({ position, rotation });
+        }
+      }
+    }
+  }
+  return validPlacements;
+};
+var canPlaceDominoUseCase = (kingdom, domino, maxKingdomSize = MAX_KINGDOM_SIZE) => {
+  const rotations = [0, 90, 180, 270];
+  for (let y = 0; y < GRIDSIZE; y++) {
+    for (let x = 0; x < GRIDSIZE; x++) {
+      const position = { x, y };
+      for (const rotation of rotations) {
+        const result = placeDomino(kingdom, position, rotation, domino, maxKingdomSize);
+        if (isOk(result)) {
+          return true;
+        }
+      }
+    }
+  }
+  return false;
+};
+
 // src/core/useCases/discardDomino.ts
 var discardDominoUseCase = (game, lordId) => {
   const nextAction = game.nextAction;
@@ -1593,13 +2451,21 @@ var discardDominoUseCase = (game, lordId) => {
     (lord) => lord.id === nextAction.nextLord
   );
   if (!currentLord) {
-    return err("Lord not found");
+    return err(ErrorCode.LORD_NOT_FOUND);
   }
   if (currentLord.id !== lordId) {
-    return err("Not your turn");
+    return err(ErrorCode.NOT_YOUR_TURN);
   }
   if (!canPass(currentLord)) {
-    return err("Lord can't pass");
+    return err(ErrorCode.CANNOT_PLACE);
+  }
+  if (currentLord.dominoPicked) {
+    const currentPlayer = game.players.find(
+      (player) => player.id === currentLord.playerId
+    );
+    if (currentPlayer && canPlaceDominoUseCase(currentPlayer.kingdom, currentLord.dominoPicked, game.rules.basic.maxKingdomSize)) {
+      return err(ErrorCode.CANNOT_PLACE);
+    }
   }
   const maxTurns = game.rules.basic.maxTurns;
   const currentTurn = game.turn;
@@ -1641,12 +2507,48 @@ var discardDominoUseCase = (game, lordId) => {
   return ok(updatedGame);
 };
 
+// src/core/useCases/getDynastyResult.ts
+var getDynastyResultUseCase = (games) => {
+  const playerMap = /* @__PURE__ */ new Map();
+  for (const game of games) {
+    for (const result of game.result) {
+      const existing = playerMap.get(result.playerId);
+      if (existing) {
+        existing.points.push(result.details.points);
+      } else {
+        playerMap.set(result.playerId, {
+          name: result.playerName,
+          points: [result.details.points]
+        });
+      }
+    }
+  }
+  const results = [];
+  for (const [playerId, data] of playerMap) {
+    results.push({
+      playerId,
+      playerName: data.name,
+      totalPoints: data.points.reduce((sum, p) => sum + p, 0),
+      gamesPoints: data.points
+    });
+  }
+  results.sort((a, b) => b.totalPoints - a.totalPoints);
+  const finalResults = [];
+  for (let i = 0; i < results.length; i++) {
+    const current = results[i];
+    const previous = i > 0 ? finalResults[i - 1] : null;
+    const position = previous && current.totalPoints === previous.totalPoints ? previous.position : i + 1;
+    finalResults.push({ ...current, position });
+  }
+  return finalResults;
+};
+
 // src/core/useCases/getExtraRules.ts
 var getExtraRulesUseCase = (deps) => (mode, players) => {
   const { ruleRepository } = deps;
   const allExtraRules = ruleRepository.getAllExtra();
   if (!allExtraRules) {
-    return err("No rules found");
+    return err(ErrorCode.STEP_EXECUTION_FAILED);
   }
   return getAvailablesExtraRules(allExtraRules, mode, players);
 };
@@ -1663,11 +2565,11 @@ var getResultUseCase = (game, scoreResult) => {
   const { basic, extra } = rules;
   const finalScoreResult = scoreResult.map((score) => {
     let finalScore = score.details.points;
-    const kingdom = game.players.find((player) => {
-      if (player.id === score.playerId) {
-        return player;
-      }
-    })?.kingdom;
+    const player = game.players.find((p) => p.id === score.playerId);
+    if (!player) {
+      return score;
+    }
+    const { kingdom } = player;
     if (extra.length > 0) {
       extra.forEach((extraRule) => {
         if (extraRule.name === "The middle Kingdom") {
@@ -1699,10 +2601,7 @@ var getResultUseCase = (game, scoreResult) => {
     if (a.details.points !== b.details.points) {
       return b.details.points - a.details.points;
     }
-    if (a.details.maxPropertiesSize !== b.details.maxPropertiesSize) {
-      return b.details.maxPropertiesSize - a.details.maxPropertiesSize;
-    }
-    return b.details.totalCrowns - a.details.totalCrowns;
+    return b.details.maxPropertiesSize - a.details.maxPropertiesSize;
   });
   const result = [];
   let isTie = false;
@@ -1715,7 +2614,7 @@ var getResultUseCase = (game, scoreResult) => {
   for (let i = 1; i < finalScoreResult.length; i++) {
     const currentScore = finalScoreResult[i];
     const previousScore = finalScoreResult[i - 1];
-    if (previousScore && currentScore && currentScore.details.points === previousScore.details.points && currentScore.details.maxPropertiesSize === previousScore.details.maxPropertiesSize && currentScore.details.totalCrowns === previousScore.details.totalCrowns) {
+    if (previousScore && currentScore && currentScore.details.points === previousScore.details.points && currentScore.details.maxPropertiesSize === previousScore.details.maxPropertiesSize) {
       isTie = true;
     }
     if (isTie) {
@@ -1744,26 +2643,27 @@ var placeDominoUseCase = (game, lordId, position, rotation) => {
     (lord) => lord.id === nextAction.nextLord
   );
   if (!currentLord) {
-    return err("Lord not found");
+    return err(ErrorCode.LORD_NOT_FOUND);
   }
   if (currentLord.id !== lordId) {
-    return err("Not your turn");
+    return err(ErrorCode.NOT_YOUR_TURN);
   }
   if (!canPlaceAndDominoPickedIsDefined(currentLord)) {
-    return err("Lord can't place");
+    return err(ErrorCode.CANNOT_PLACE);
   }
   const domino = currentLord.dominoPicked;
   const currentPlayer = game.players.find(
     (player) => player.id === currentLord.playerId
   );
   if (!currentPlayer) {
-    return err("Player not found");
+    return err(ErrorCode.PLAYER_NOT_FOUND);
   }
   const updatedKingdom = placeDomino(
     currentPlayer.kingdom,
     position,
     rotation,
-    domino
+    domino,
+    game.rules.basic.maxKingdomSize
   );
   if (isErr(updatedKingdom)) {
     return updatedKingdom;
@@ -1834,7 +2734,8 @@ var startGameUseCase = (deps) => (game) => {
       newLords.push(lord);
     }
   }
-  const shuffledLords = shuffleMethod2(newLords);
+  const shuffle = game.seed ? createSeededShuffle(game.seed, "lords") : shuffleMethod2;
+  const shuffledLords = shuffle(newLords);
   const dominoesCopy = [...dominoes];
   const dominoesDrawn = dominoesCopy.splice(0, dominoesPerTurn);
   dominoesDrawn.sort((a, b) => a.number - b.number);
@@ -1860,82 +2761,6 @@ var startGameUseCase = (deps) => (game) => {
   return ok(newState);
 };
 
-// src/core/useCases/calculateScore.ts
-var calculateScoreUseCase = (kingdom) => {
-  const visited = kingdom.map((row) => row.map(() => false));
-  const properties = [];
-  const directions = [
-    [-1, 0],
-    [1, 0],
-    [0, -1],
-    [0, 1]
-  ];
-  const markZone = (x, y, type, crowns) => {
-    if (x < 0 || y < 0 || x >= kingdom[0].length || y >= kingdom.length || visited[y][x] || kingdom[y][x].type !== type || kingdom[y][x].type === "empty" || kingdom[y][x].type === "castle") {
-      return;
-    }
-    visited[y][x] = true;
-    const currentZone = properties.find(
-      (property) => property.type === type && property.tiles.some(([tx, ty]) => {
-        for (let [dx, dy] of directions) {
-          if (tx + dx === x && ty + dy === y) {
-            return true;
-          }
-        }
-        return false;
-      })
-    );
-    if (currentZone) {
-      currentZone.size += 1;
-      currentZone.tiles.push([x, y]);
-      currentZone.crowns += crowns;
-    } else {
-      properties.push({
-        type,
-        crowns,
-        size: 1,
-        tiles: [[x, y]]
-      });
-    }
-    directions.forEach(([dx, dy]) => {
-      const nx = x + dx;
-      const ny = y + dy;
-      if (nx >= 0 && ny >= 0 && nx < kingdom[0].length && ny < kingdom.length && kingdom[ny][nx].type === type) {
-        markZone(nx, ny, kingdom[ny][nx].type, kingdom[ny][nx].crowns);
-      }
-    });
-  };
-  kingdom.forEach((row, y) => {
-    row.forEach((tile, x) => {
-      if (!visited[y][x]) {
-        markZone(x, y, tile.type, tile.crowns);
-      }
-    });
-  });
-  if (properties.length === 0) {
-    return ok({
-      points: 0,
-      maxPropertiesSize: 0,
-      totalCrowns: 0
-    });
-  }
-  let points = properties.reduce((acc, property) => {
-    return acc + property.size * property.crowns;
-  }, 0);
-  const maxPropertiesSize = Math.max(
-    ...properties.map((property) => property.size)
-  );
-  const totalCrowns = properties.reduce(
-    (acc, property) => acc + property.crowns,
-    0
-  );
-  return ok({
-    points,
-    maxPropertiesSize,
-    totalCrowns
-  });
-};
-
 // src/config.ts
 var configureEngine = (config) => {
   const modeRepository = jsonModes_default();
@@ -1943,10 +2768,12 @@ var configureEngine = (config) => {
   const ruleRepository = jsonRules_default();
   const uuid = config.uuidMethod || uuidMethod;
   const shuffle = config.shuffleMethod || shuffleMethod;
-  const logger = config.logging ? winstonLogger(true) : winstonLogger(false);
+  const translator = config.translator || defaultTranslator;
+  const logger = config.logger ? config.logger : config.logging ? consoleLogger(true) : silentLogger;
   return {
     createGameHandler: createGameHandler(
       logger,
+      translator,
       createGameUseCase({
         modeRepository,
         dominoesRepository,
@@ -1955,14 +2782,17 @@ var configureEngine = (config) => {
     ),
     getModesHandler: getModesHandler(
       logger,
+      translator,
       getModesUseCase({ modeRepository })
     ),
     getExtraRulesHandler: getExtraRulesHandler(
       logger,
+      translator,
       getExtraRulesUseCase({ ruleRepository })
     ),
     addPlayersHandler: addPlayersHandler(
       logger,
+      translator,
       addPlayersUseCase({
         uuidMethod: uuid,
         shuffleMethod: shuffle,
@@ -1971,22 +2801,903 @@ var configureEngine = (config) => {
     ),
     addExtraRulesHandler: addExtraRulesHandler(
       logger,
-      addExtraRulesUseCase({ ruleRepository })
+      translator,
+      addExtraRulesUseCase({
+        ruleRepository,
+        dominoesRepository,
+        shuffleMethod: shuffle
+      })
     ),
     startGameHandler: startGameHandler(
       logger,
+      translator,
       startGameUseCase({ uuidMethod: uuid, shuffleMethod: shuffle })
     ),
-    chooseDominoHandler: chooseDominoHandler(logger, chooseDominoUseCase),
-    placeDominoHandler: placeDominoHandler(logger, placeDominoUseCase),
-    discardDominoHandler: discardDominoHandler(logger, discardDominoUseCase),
-    getResultHandler: getResultHandler(logger, {
+    chooseDominoHandler: chooseDominoHandler(
+      logger,
+      translator,
+      chooseDominoUseCase
+    ),
+    placeDominoHandler: placeDominoHandler(
+      logger,
+      translator,
+      placeDominoUseCase
+    ),
+    discardDominoHandler: discardDominoHandler(
+      logger,
+      translator,
+      discardDominoUseCase
+    ),
+    getResultHandler: getResultHandler(logger, translator, {
       getResultUseCase,
       calculateScoreUseCase
     }),
-    calculateScoreHandler: calculateScoreHandler(logger, calculateScoreUseCase)
+    calculateScoreHandler: calculateScoreHandler(
+      logger,
+      translator,
+      calculateScoreUseCase
+    ),
+    getValidPlacementsHandler: getValidPlacementsHandler(
+      logger,
+      translator,
+      getValidPlacementsUseCase
+    ),
+    canPlaceDominoHandler: canPlaceDominoHandler(
+      logger,
+      translator,
+      canPlaceDominoUseCase
+    ),
+    serializeGameHandler: serializeGameHandler(logger, translator),
+    deserializeGameHandler: deserializeGameHandler(logger, translator),
+    getDynastyResultHandler: getDynastyResultHandler(
+      logger,
+      translator,
+      getDynastyResultUseCase
+    )
+  };
+};
+
+// src/core/domain/entities/validateGameState.ts
+var issue = (path, code, message, severity = "error") => ({ path, code, message, severity });
+var isNonEmptyString = (value) => typeof value === "string" && value.length > 0;
+var isNonNegativeInteger = (value) => typeof value === "number" && Number.isInteger(value) && value >= 0;
+var isPositiveInteger = (value) => typeof value === "number" && Number.isInteger(value) && value > 0;
+var validGrounds = /* @__PURE__ */ new Set([...GROUND, "empty"]);
+var validPlayerActions = new Set(Object.values(playerActions));
+var validGameSteps = new Set(Object.values(gameSteps));
+var validateGameStructure = (game) => {
+  const issues = [];
+  if (!isNonEmptyString(game.id)) {
+    issues.push(issue("id", "INVALID_ID", "Game id must be a non-empty string"));
+  }
+  if (!isNonNegativeInteger(game.turn)) {
+    issues.push(issue("turn", "INVALID_TURN", "Turn must be a non-negative integer"));
+  }
+  if (!Array.isArray(game.dominoes)) {
+    issues.push(issue("dominoes", "INVALID_DOMINOES", "Dominoes must be an array"));
+  }
+  if (!Array.isArray(game.currentDominoes)) {
+    issues.push(issue("currentDominoes", "INVALID_CURRENT_DOMINOES", "CurrentDominoes must be an array"));
+  }
+  if (!Array.isArray(game.players)) {
+    issues.push(issue("players", "INVALID_PLAYERS", "Players must be an array"));
+  }
+  if (!Array.isArray(game.lords)) {
+    issues.push(issue("lords", "INVALID_LORDS", "Lords must be an array"));
+  }
+  if (!game.rules || typeof game.rules !== "object") {
+    issues.push(issue("rules", "INVALID_RULES", "Rules must be an object"));
+  } else {
+    if (!game.rules.basic || typeof game.rules.basic !== "object") {
+      issues.push(issue("rules.basic", "INVALID_BASIC_RULES", "Rules.basic must be an object"));
+    }
+    if (!Array.isArray(game.rules.extra)) {
+      issues.push(issue("rules.extra", "INVALID_EXTRA_RULES", "Rules.extra must be an array"));
+    }
+  }
+  if (!game.mode || typeof game.mode !== "object") {
+    issues.push(issue("mode", "INVALID_MODE", "Mode must be an object"));
+  } else {
+    if (!isNonEmptyString(game.mode.name)) {
+      issues.push(issue("mode.name", "INVALID_MODE_NAME", "Mode name must be a non-empty string"));
+    }
+  }
+  if (!game.nextAction || typeof game.nextAction !== "object") {
+    issues.push(issue("nextAction", "INVALID_NEXT_ACTION", "NextAction must be an object"));
+  } else if (game.nextAction.type !== "action" && game.nextAction.type !== "step") {
+    issues.push(issue("nextAction.type", "INVALID_NEXT_ACTION_TYPE", "NextAction.type must be 'action' or 'step'"));
+  }
+  return issues;
+};
+var validateTile = (tile, path) => {
+  const issues = [];
+  if (!tile || typeof tile !== "object") {
+    issues.push(issue(path, "INVALID_TILE", `Tile at ${path} must be an object`));
+    return issues;
+  }
+  const t = tile;
+  if (typeof t.type !== "string" || !validGrounds.has(t.type)) {
+    issues.push(issue(`${path}.type`, "INVALID_TILE_TYPE", `Invalid terrain type at ${path}`));
+  }
+  if (typeof t.crowns !== "number" || t.crowns < 0) {
+    issues.push(issue(`${path}.crowns`, "INVALID_TILE_CROWNS", `Invalid crowns at ${path}`));
+  }
+  return issues;
+};
+var validatePlayers = (game) => {
+  const issues = [];
+  if (!Array.isArray(game.players)) return issues;
+  const playerIds = /* @__PURE__ */ new Set();
+  for (let i = 0; i < game.players.length; i++) {
+    const player = game.players[i];
+    const path = `players[${i}]`;
+    if (!isNonEmptyString(player.id)) {
+      issues.push(issue(`${path}.id`, "INVALID_PLAYER_ID", `Player id must be a non-empty string`));
+    } else if (playerIds.has(player.id)) {
+      issues.push(issue(`${path}.id`, "DUPLICATE_PLAYER_ID", `Duplicate player id: ${player.id}`));
+    } else {
+      playerIds.add(player.id);
+    }
+    if (typeof player.name !== "string" || player.name.length < 3) {
+      issues.push(issue(`${path}.name`, "INVALID_PLAYER_NAME", `Player name must be at least 3 characters`));
+    }
+    if (!Array.isArray(player.kingdom)) {
+      issues.push(issue(`${path}.kingdom`, "INVALID_KINGDOM", `Kingdom must be a 2D array`));
+      continue;
+    }
+    if (player.kingdom.length !== GRIDSIZE) {
+      issues.push(issue(`${path}.kingdom`, "INVALID_KINGDOM_GRID", `Kingdom must have ${GRIDSIZE} rows, got ${player.kingdom.length}`));
+      continue;
+    }
+    let castleCount = 0;
+    for (let y = 0; y < player.kingdom.length; y++) {
+      const row = player.kingdom[y];
+      if (!Array.isArray(row) || row.length !== GRIDSIZE) {
+        issues.push(issue(`${path}.kingdom[${y}]`, "INVALID_KINGDOM_ROW", `Kingdom row ${y} must have ${GRIDSIZE} columns`));
+        continue;
+      }
+      for (let x = 0; x < row.length; x++) {
+        const cell = row[x];
+        issues.push(...validateTile(cell, `${path}.kingdom[${y}][${x}]`));
+        if (cell && typeof cell === "object" && cell.type === "castle") {
+          castleCount++;
+        }
+      }
+    }
+    if (castleCount === 0) {
+      issues.push(issue(`${path}.kingdom`, "MISSING_CASTLE", `Kingdom must have exactly one castle tile`, "warning"));
+    } else if (castleCount > 1) {
+      issues.push(issue(`${path}.kingdom`, "MULTIPLE_CASTLES", `Kingdom has ${castleCount} castle tiles, expected 1`));
+    }
+  }
+  return issues;
+};
+var validateDominoes = (game) => {
+  const issues = [];
+  const allNumbers = /* @__PURE__ */ new Set();
+  if (Array.isArray(game.dominoes)) {
+    for (let i = 0; i < game.dominoes.length; i++) {
+      const domino = game.dominoes[i];
+      const path = `dominoes[${i}]`;
+      if (!isPositiveInteger(domino.number)) {
+        issues.push(issue(`${path}.number`, "INVALID_DOMINO_NUMBER", `Domino number must be a positive integer`));
+      } else if (allNumbers.has(domino.number)) {
+        issues.push(issue(`${path}.number`, "DUPLICATE_DOMINO_NUMBER", `Duplicate domino number: ${domino.number}`));
+      } else {
+        allNumbers.add(domino.number);
+      }
+      issues.push(...validateTile(domino.left, `${path}.left`));
+      issues.push(...validateTile(domino.right, `${path}.right`));
+    }
+  }
+  if (Array.isArray(game.currentDominoes)) {
+    for (let i = 0; i < game.currentDominoes.length; i++) {
+      const revealed = game.currentDominoes[i];
+      const path = `currentDominoes[${i}]`;
+      if (!revealed.domino || typeof revealed.domino !== "object") {
+        issues.push(issue(`${path}.domino`, "INVALID_REVEALED_DOMINO", `Revealed domino must be an object`));
+        continue;
+      }
+      const domino = revealed.domino;
+      if (!isPositiveInteger(domino.number)) {
+        issues.push(issue(`${path}.domino.number`, "INVALID_DOMINO_NUMBER", `Domino number must be a positive integer`));
+      } else if (allNumbers.has(domino.number)) {
+        issues.push(issue(`${path}.domino.number`, "DUPLICATE_DOMINO_NUMBER", `Duplicate domino number: ${domino.number}`));
+      } else {
+        allNumbers.add(domino.number);
+      }
+      issues.push(...validateTile(domino.left, `${path}.domino.left`));
+      issues.push(...validateTile(domino.right, `${path}.domino.right`));
+      if (revealed.picked && revealed.lordId === null) {
+        issues.push(issue(`${path}`, "PICKED_WITHOUT_LORD", `Domino is marked as picked but has no lordId`));
+      }
+      if (!revealed.picked && revealed.lordId !== null) {
+        issues.push(issue(`${path}`, "UNPICKED_WITH_LORD", `Domino is not picked but has a lordId`));
+      }
+    }
+  }
+  if (Array.isArray(game.lords)) {
+    const lordPickedNumbers = /* @__PURE__ */ new Set();
+    for (let i = 0; i < game.lords.length; i++) {
+      const lord = game.lords[i];
+      if (lord.dominoPicked) {
+        const path = `lords[${i}].dominoPicked`;
+        const domino = lord.dominoPicked;
+        if (!isPositiveInteger(domino.number)) {
+          issues.push(issue(`${path}.number`, "INVALID_DOMINO_NUMBER", `Domino number must be a positive integer`));
+        } else if (lordPickedNumbers.has(domino.number)) {
+          issues.push(issue(`${path}.number`, "DUPLICATE_DOMINO_NUMBER", `Duplicate domino number among lords: ${domino.number}`));
+        } else {
+          lordPickedNumbers.add(domino.number);
+        }
+        issues.push(...validateTile(domino.left, `${path}.left`));
+        issues.push(...validateTile(domino.right, `${path}.right`));
+      }
+    }
+  }
+  return issues;
+};
+var validateLords = (game) => {
+  const issues = [];
+  if (!Array.isArray(game.lords)) return issues;
+  const playerIds = new Set(
+    Array.isArray(game.players) ? game.players.map((p) => p.id) : []
+  );
+  const lordIds = /* @__PURE__ */ new Set();
+  for (let i = 0; i < game.lords.length; i++) {
+    const lord = game.lords[i];
+    const path = `lords[${i}]`;
+    if (!isNonEmptyString(lord.id)) {
+      issues.push(issue(`${path}.id`, "INVALID_LORD_ID", `Lord id must be a non-empty string`));
+    } else if (lordIds.has(lord.id)) {
+      issues.push(issue(`${path}.id`, "DUPLICATE_LORD_ID", `Duplicate lord id: ${lord.id}`));
+    } else {
+      lordIds.add(lord.id);
+    }
+    if (!isNonEmptyString(lord.playerId)) {
+      issues.push(issue(`${path}.playerId`, "INVALID_LORD_PLAYER_ID", `Lord playerId must be a non-empty string`));
+    } else if (playerIds.size > 0 && !playerIds.has(lord.playerId)) {
+      issues.push(issue(`${path}.playerId`, "LORD_PLAYER_NOT_FOUND", `Lord references non-existent player: ${lord.playerId}`));
+    }
+    if (lord.turnEnded && (!lord.hasPick || !lord.hasPlace)) {
+      issues.push(issue(path, "INCONSISTENT_LORD_FLAGS", `Lord has turnEnded=true but hasPick=${lord.hasPick}, hasPlace=${lord.hasPlace}`, "warning"));
+    }
+  }
+  return issues;
+};
+var validateGameFlow = (game) => {
+  const issues = [];
+  if (!game.nextAction || typeof game.nextAction !== "object") return issues;
+  const nextAction = game.nextAction;
+  if (nextAction.type === "action") {
+    const action = nextAction;
+    if (!isNonEmptyString(action.nextLord)) {
+      issues.push(issue("nextAction.nextLord", "INVALID_NEXT_LORD", "nextLord must be a non-empty string"));
+    } else if (Array.isArray(game.lords) && !game.lords.some((l) => l.id === action.nextLord)) {
+      issues.push(issue("nextAction.nextLord", "NEXT_LORD_NOT_FOUND", `nextLord references non-existent lord: ${action.nextLord}`));
+    }
+    if (typeof action.nextAction !== "string" || !validPlayerActions.has(action.nextAction)) {
+      issues.push(issue("nextAction.nextAction", "INVALID_PLAYER_ACTION", `nextAction must be one of: ${[...validPlayerActions].join(", ")}`));
+    }
+  } else if (nextAction.type === "step") {
+    const step = nextAction;
+    if (typeof step.step !== "string" || !validGameSteps.has(step.step)) {
+      issues.push(issue("nextAction.step", "INVALID_GAME_STEP", `step must be one of: ${[...validGameSteps].join(", ")}`));
+    }
+  }
+  return issues;
+};
+var isSetupPhase = (game) => {
+  if (game.nextAction?.type !== "step") return false;
+  const step = game.nextAction.step;
+  return step === "addPlayers" || step === "options" || step === "start";
+};
+var validateRules = (game) => {
+  const issues = [];
+  if (!game.rules || typeof game.rules !== "object") return issues;
+  const allowZero = isSetupPhase(game);
+  const basic = game.rules.basic;
+  if (basic && typeof basic === "object") {
+    const fields = ["lords", "maxDominoes", "dominoesPerTurn", "maxTurns", "maxKingdomSize"];
+    for (const field of fields) {
+      const check = allowZero ? isNonNegativeInteger : isPositiveInteger;
+      if (!check(basic[field])) {
+        issues.push(issue(`rules.basic.${field}`, "INVALID_BASIC_RULE_VALUE", `rules.basic.${field} must be a positive integer`));
+      }
+    }
+  }
+  if (Array.isArray(game.rules.extra)) {
+    for (let i = 0; i < game.rules.extra.length; i++) {
+      const rule = game.rules.extra[i];
+      if (!isNonEmptyString(rule.name)) {
+        issues.push(issue(`rules.extra[${i}].name`, "INVALID_EXTRA_RULE_NAME", `Extra rule name must be a non-empty string`));
+      }
+    }
+  }
+  return issues;
+};
+var validateGameState = (game) => {
+  const issues = [];
+  issues.push(...validateGameStructure(game));
+  issues.push(...validatePlayers(game));
+  issues.push(...validateDominoes(game));
+  issues.push(...validateLords(game));
+  issues.push(...validateGameFlow(game));
+  issues.push(...validateRules(game));
+  return issues;
+};
+
+// src/core/useCases/botRegistry.ts
+var defaultStrategies = {
+  random: randomStrategy,
+  greedy: greedyStrategy,
+  advanced: advancedStrategy,
+  expert: expertStrategy
+};
+var getStrategy = (name, custom) => {
+  return custom?.[name] ?? defaultStrategies[name];
+};
+var getStrategyNames = () => Object.keys(defaultStrategies);
+
+// src/core/useCases/bot.ts
+var scoreKingdom = (kingdom) => {
+  const result = calculateScoreUseCase(kingdom);
+  return isOk(result) ? result.value.points : 0;
+};
+var simulatePlacement = (kingdom, domino, placement, maxKingdomSize) => {
+  const result = placeDomino(
+    kingdom,
+    placement.position,
+    placement.rotation,
+    domino,
+    maxKingdomSize
+  );
+  return isOk(result) ? result.value : null;
+};
+var bestPlacementScore = (kingdom, domino, placements, maxKingdomSize) => {
+  let best = null;
+  for (const placement of placements) {
+    const newKingdom = simulatePlacement(kingdom, domino, placement, maxKingdomSize);
+    if (!newKingdom) continue;
+    const score = scoreKingdom(newKingdom);
+    if (!best || score > best.score) {
+      best = { placement, score, kingdom: newKingdom };
+    }
+  }
+  return best;
+};
+var getMaxKingdomSize = (game) => game.rules.basic.maxKingdomSize;
+var getLordAndPlayer = (game, lordId) => {
+  const lord = game.lords.find((l) => l.id === lordId);
+  const player = lord ? game.players.find((p) => p.id === lord.playerId) : void 0;
+  return { lord, player };
+};
+var getNextBatchDominoes = (game) => {
+  const perTurn = game.rules.basic.dominoesPerTurn;
+  return [...game.dominoes].slice(0, perTurn).sort((a, b) => a.number - b.number);
+};
+var randomStrategy = {
+  chooseDomino: (context) => {
+    const { availableDominoes } = context;
+    const idx = Math.floor(Math.random() * availableDominoes.length);
+    return availableDominoes[idx].domino.number;
+  },
+  choosePlacement: (context) => {
+    const { validPlacements } = context;
+    if (validPlacements.length === 0) return null;
+    const idx = Math.floor(Math.random() * validPlacements.length);
+    return validPlacements[idx];
+  }
+};
+var greedyStrategy = {
+  chooseDomino: (context) => {
+    const { game, lordId, availableDominoes } = context;
+    const { player } = getLordAndPlayer(game, lordId);
+    if (!player) return availableDominoes[0].domino.number;
+    const maxSize = getMaxKingdomSize(game);
+    let bestScore = -1;
+    let bestPick = availableDominoes[0].domino.number;
+    for (const rd of availableDominoes) {
+      const placements = getValidPlacementsUseCase(
+        player.kingdom,
+        rd.domino,
+        maxSize
+      );
+      const result = bestPlacementScore(
+        player.kingdom,
+        rd.domino,
+        placements,
+        maxSize
+      );
+      const score = result ? result.score : 0;
+      if (score > bestScore) {
+        bestScore = score;
+        bestPick = rd.domino.number;
+      }
+    }
+    return bestPick;
+  },
+  choosePlacement: (context) => {
+    const { game, domino, kingdom, validPlacements } = context;
+    if (validPlacements.length === 0) return null;
+    const maxSize = getMaxKingdomSize(game);
+    const result = bestPlacementScore(kingdom, domino, validPlacements, maxSize);
+    return result ? result.placement : validPlacements[0];
+  }
+};
+var evaluateWithLookahead = (kingdom, maxSize, nextDominoes) => {
+  if (nextDominoes.length === 0) return 0;
+  let bestNextScore = 0;
+  for (const nextDomino of nextDominoes) {
+    const nextPlacements = getValidPlacementsUseCase(kingdom, nextDomino, maxSize);
+    const result = bestPlacementScore(kingdom, nextDomino, nextPlacements, maxSize);
+    if (result && result.score > bestNextScore) {
+      bestNextScore = result.score;
+    }
+  }
+  return bestNextScore;
+};
+var advancedStrategy = {
+  chooseDomino: (context) => {
+    const { game, lordId, availableDominoes } = context;
+    const { player } = getLordAndPlayer(game, lordId);
+    if (!player) return availableDominoes[0].domino.number;
+    const maxSize = getMaxKingdomSize(game);
+    const nextBatch = getNextBatchDominoes(game);
+    let bestCombinedScore = -1;
+    let bestPick = availableDominoes[0].domino.number;
+    for (const rd of availableDominoes) {
+      const placements = getValidPlacementsUseCase(
+        player.kingdom,
+        rd.domino,
+        maxSize
+      );
+      const result = bestPlacementScore(
+        player.kingdom,
+        rd.domino,
+        placements,
+        maxSize
+      );
+      const immediateScore = result ? result.score : scoreKingdom(player.kingdom);
+      const kingdomAfter = result ? result.kingdom : player.kingdom;
+      const futureScore = evaluateWithLookahead(kingdomAfter, maxSize, nextBatch);
+      const combined = immediateScore + futureScore * 0.8;
+      if (combined > bestCombinedScore) {
+        bestCombinedScore = combined;
+        bestPick = rd.domino.number;
+      }
+    }
+    return bestPick;
+  },
+  choosePlacement: (context) => {
+    const { game, domino, kingdom, validPlacements } = context;
+    if (validPlacements.length === 0) return null;
+    const maxSize = getMaxKingdomSize(game);
+    const nextBatch = getNextBatchDominoes(game);
+    let bestCombinedScore = -1;
+    let bestPlacement = validPlacements[0];
+    for (const placement of validPlacements) {
+      const newKingdom = simulatePlacement(kingdom, domino, placement, maxSize);
+      if (!newKingdom) continue;
+      const immediateScore = scoreKingdom(newKingdom);
+      const futureScore = evaluateWithLookahead(newKingdom, maxSize, nextBatch);
+      const combined = immediateScore + futureScore * 0.8;
+      if (combined > bestCombinedScore) {
+        bestCombinedScore = combined;
+        bestPlacement = placement;
+      }
+    }
+    return bestPlacement;
+  }
+};
+var EXPERT_BEAM_WIDTH = 2;
+var EXPERT_MAX_DEPTH = 2;
+var topPlacements = (kingdom, domino, placements, maxSize, limit) => {
+  if (placements.length <= limit) return placements;
+  const scored = placements.map((p) => {
+    const k = simulatePlacement(kingdom, domino, p, maxSize);
+    return { placement: p, score: k ? scoreKingdom(k) : 0 };
+  }).sort((a, b) => b.score - a.score);
+  return scored.slice(0, limit).map((s) => s.placement);
+};
+var expertEvaluate = (kingdom, remainingDominoes, dominoesPerTurn, maxSize, depth) => {
+  if (depth <= 0 || remainingDominoes.length === 0) {
+    return scoreKingdom(kingdom);
+  }
+  const batch = [...remainingDominoes].slice(0, dominoesPerTurn).sort((a, b) => a.number - b.number);
+  const afterBatch = remainingDominoes.slice(dominoesPerTurn);
+  let bestScore = scoreKingdom(kingdom);
+  for (const domino of batch) {
+    const allPlacements = getValidPlacementsUseCase(kingdom, domino, maxSize);
+    if (allPlacements.length === 0) {
+      const score = expertEvaluate(
+        kingdom,
+        afterBatch,
+        dominoesPerTurn,
+        maxSize,
+        depth - 1
+      );
+      if (score > bestScore) bestScore = score;
+      continue;
+    }
+    const candidates = topPlacements(
+      kingdom,
+      domino,
+      allPlacements,
+      maxSize,
+      EXPERT_BEAM_WIDTH
+    );
+    for (const placement of candidates) {
+      const newKingdom = simulatePlacement(kingdom, domino, placement, maxSize);
+      if (!newKingdom) continue;
+      const score = expertEvaluate(
+        newKingdom,
+        afterBatch,
+        dominoesPerTurn,
+        maxSize,
+        depth - 1
+      );
+      if (score > bestScore) bestScore = score;
+    }
+  }
+  return bestScore;
+};
+var expertStrategy = {
+  chooseDomino: (context) => {
+    const { game, lordId, availableDominoes } = context;
+    const { player } = getLordAndPlayer(game, lordId);
+    if (!player) return availableDominoes[0].domino.number;
+    const maxSize = getMaxKingdomSize(game);
+    const perTurn = game.rules.basic.dominoesPerTurn;
+    const turnsLeft = Math.min(
+      game.rules.basic.maxTurns - game.turn,
+      EXPERT_MAX_DEPTH
+    );
+    let bestScore = -1;
+    let bestPick = availableDominoes[0].domino.number;
+    for (const rd of availableDominoes) {
+      const allPlacements = getValidPlacementsUseCase(
+        player.kingdom,
+        rd.domino,
+        maxSize
+      );
+      if (allPlacements.length === 0) {
+        const score = expertEvaluate(
+          player.kingdom,
+          game.dominoes,
+          perTurn,
+          maxSize,
+          turnsLeft
+        );
+        if (score > bestScore) {
+          bestScore = score;
+          bestPick = rd.domino.number;
+        }
+        continue;
+      }
+      const candidates = topPlacements(
+        player.kingdom,
+        rd.domino,
+        allPlacements,
+        maxSize,
+        EXPERT_BEAM_WIDTH
+      );
+      for (const placement of candidates) {
+        const newKingdom = simulatePlacement(
+          player.kingdom,
+          rd.domino,
+          placement,
+          maxSize
+        );
+        if (!newKingdom) continue;
+        const score = expertEvaluate(
+          newKingdom,
+          game.dominoes,
+          perTurn,
+          maxSize,
+          turnsLeft
+        );
+        if (score > bestScore) {
+          bestScore = score;
+          bestPick = rd.domino.number;
+        }
+      }
+    }
+    return bestPick;
+  },
+  choosePlacement: (context) => {
+    const { game, domino, kingdom, validPlacements } = context;
+    if (validPlacements.length === 0) return null;
+    const maxSize = getMaxKingdomSize(game);
+    const perTurn = game.rules.basic.dominoesPerTurn;
+    const turnsLeft = Math.min(
+      game.rules.basic.maxTurns - game.turn,
+      EXPERT_MAX_DEPTH
+    );
+    let bestScore = -1;
+    let bestPlacement = validPlacements[0];
+    for (const placement of validPlacements) {
+      const newKingdom = simulatePlacement(kingdom, domino, placement, maxSize);
+      if (!newKingdom) continue;
+      const score = expertEvaluate(
+        newKingdom,
+        game.dominoes,
+        perTurn,
+        maxSize,
+        turnsLeft
+      );
+      if (score > bestScore) {
+        bestScore = score;
+        bestPlacement = placement;
+      }
+    }
+    return bestPlacement;
+  }
+};
+var playBotTurn = (engine, game, strategy) => {
+  const lordId = game.nextAction.nextLord;
+  const action = game.nextAction.nextAction;
+  if (action === "pickDomino") {
+    const availableDominoes = game.currentDominoes.filter((d) => !d.picked);
+    const dominoPick = strategy.chooseDomino({
+      game,
+      lordId,
+      availableDominoes
+    });
+    return engine.chooseDomino({ game, lordId, dominoPick });
+  }
+  if (action === "placeDomino") {
+    const { lord, player } = getLordAndPlayer(game, lordId);
+    if (!lord?.dominoPicked || !player) {
+      return engine.discardDomino({ game, lordId });
+    }
+    const domino = lord.dominoPicked;
+    const kingdom = player.kingdom;
+    const maxSize = getMaxKingdomSize(game);
+    const validPlacements = getValidPlacementsUseCase(kingdom, domino, maxSize);
+    const placement = strategy.choosePlacement({
+      game,
+      lordId,
+      domino,
+      kingdom,
+      validPlacements
+    });
+    if (!placement) {
+      return engine.discardDomino({ game, lordId });
+    }
+    return engine.placeDomino({
+      game,
+      lordId,
+      position: placement.position,
+      rotation: placement.rotation
+    });
+  }
+  return engine.discardDomino({ game, lordId });
+};
+var isBotTurn = (game) => {
+  const lordId = game.nextAction.nextLord;
+  const lord = game.lords.find((l) => l.id === lordId);
+  const player = lord ? game.players.find((p) => p.id === lord.playerId) : void 0;
+  return !!player?.bot;
+};
+var playBotTurns = (engine, game, customStrategies) => {
+  let current = game;
+  while (isGameWithNextAction(current) && isBotTurn(current)) {
+    const lordId = current.nextAction.nextLord;
+    const lord = current.lords.find((l) => l.id === lordId);
+    const player = lord ? current.players.find((p) => p.id === lord.playerId) : void 0;
+    const strategyName = player?.bot?.strategyName ?? "random";
+    const strategy = getStrategy(strategyName, customStrategies) ?? randomStrategy;
+    current = playBotTurn(engine, current, strategy);
+  }
+  return current;
+};
+
+// src/core/useCases/gameActionLog.ts
+var createActionLog = (gameId) => ({
+  gameId,
+  entries: []
+});
+var appendAction = (log, entry) => ({
+  ...log,
+  entries: [
+    ...log.entries,
+    {
+      ...entry,
+      id: log.entries.length,
+      timestamp: Date.now()
+    }
+  ]
+});
+var getActions = (log) => log.entries;
+var getActionsByType = (log, type) => log.entries.filter((e) => e.action === type);
+var getActionsByTurn = (log, turn) => log.entries.filter((e) => e.turn === turn);
+var wrapWithActionLog = (engine) => {
+  let log = createActionLog("");
+  const record = (action, payload, turn) => {
+    log = appendAction(log, { action, payload, turn });
+  };
+  const wrappedEngine = {
+    // Read-only methods — pass through
+    getModes: (cmd) => engine.getModes(cmd),
+    getExtraRules: (cmd) => engine.getExtraRules(cmd),
+    calculateScore: (cmd) => engine.calculateScore(cmd),
+    getValidPlacements: (cmd) => engine.getValidPlacements(cmd),
+    canPlaceDomino: (cmd) => engine.canPlaceDomino(cmd),
+    serialize: (cmd) => engine.serialize(cmd),
+    deserialize: (cmd) => engine.deserialize(cmd),
+    getResults: (cmd) => engine.getResults(cmd),
+    getDynastyResults: (cmd) => engine.getDynastyResults(cmd),
+    // State-changing methods — record after execution
+    createGame: (cmd) => {
+      const game = engine.createGame(cmd);
+      log = createActionLog(game.id);
+      record("createGame", { mode: cmd.mode, seed: cmd.seed }, game.turn);
+      return game;
+    },
+    addPlayers: (cmd) => {
+      const game = engine.addPlayers(cmd);
+      record("addPlayers", { players: cmd.players }, game.turn);
+      return game;
+    },
+    addExtraRules: (cmd) => {
+      const game = engine.addExtraRules(cmd);
+      record("addExtraRules", { extraRules: cmd.extraRules }, game.turn);
+      return game;
+    },
+    startGame: (cmd) => {
+      const game = engine.startGame(cmd);
+      record("startGame", {}, game.turn);
+      return game;
+    },
+    chooseDomino: (cmd) => {
+      const game = engine.chooseDomino(cmd);
+      record(
+        "chooseDomino",
+        { lordId: cmd.lordId, dominoPick: cmd.dominoPick },
+        game.turn
+      );
+      return game;
+    },
+    placeDomino: (cmd) => {
+      const game = engine.placeDomino(cmd);
+      record(
+        "placeDomino",
+        {
+          lordId: cmd.lordId,
+          position: cmd.position,
+          rotation: cmd.rotation
+        },
+        game.turn
+      );
+      return game;
+    },
+    discardDomino: (cmd) => {
+      const game = engine.discardDomino(cmd);
+      record("discardDomino", { lordId: cmd.lordId }, game.turn);
+      return game;
+    }
+  };
+  return {
+    engine: wrappedEngine,
+    getLog: () => log
   };
 };
+var replayActions = (engine, log) => {
+  if (log.entries.length === 0) {
+    throw new Error("Cannot replay an empty action log");
+  }
+  const firstEntry = log.entries[0];
+  if (firstEntry?.action !== "createGame") {
+    throw new Error("Action log must start with a createGame action");
+  }
+  const firstPayload = firstEntry.payload;
+  let game = engine.createGame({
+    mode: firstPayload.mode,
+    seed: firstPayload.seed
+  });
+  for (let i = 1; i < log.entries.length; i++) {
+    const entry = log.entries[i];
+    if (!entry) continue;
+    switch (entry.action) {
+      case "createGame": {
+        const payload = entry.payload;
+        game = engine.createGame({ mode: payload.mode, seed: payload.seed });
+        break;
+      }
+      case "addPlayers": {
+        const payload = entry.payload;
+        game = engine.addPlayers({ game, players: payload.players });
+        break;
+      }
+      case "addExtraRules": {
+        const payload = entry.payload;
+        game = engine.addExtraRules({
+          game,
+          extraRules: payload.extraRules
+        });
+        break;
+      }
+      case "startGame": {
+        game = engine.startGame({ game });
+        break;
+      }
+      case "chooseDomino": {
+        const payload = entry.payload;
+        game = engine.chooseDomino({
+          game,
+          lordId: payload.lordId,
+          dominoPick: payload.dominoPick
+        });
+        break;
+      }
+      case "placeDomino": {
+        const payload = entry.payload;
+        game = engine.placeDomino({
+          game,
+          lordId: payload.lordId,
+          position: payload.position,
+          rotation: payload.rotation
+        });
+        break;
+      }
+      case "discardDomino": {
+        const payload = entry.payload;
+        game = engine.discardDomino({
+          game,
+          lordId: payload.lordId
+        });
+        break;
+      }
+    }
+  }
+  return game;
+};
+
+// src/core/useCases/gameHistory.ts
+var createGameHistory = (initialState) => ({
+  current: initialState,
+  past: [],
+  future: []
+});
+var pushState = (history, newState) => ({
+  current: newState,
+  past: [...history.past, history.current],
+  future: []
+});
+var undo = (history) => {
+  if (history.past.length === 0) {
+    throw new UndoError();
+  }
+  const previous = history.past[history.past.length - 1];
+  return {
+    current: previous,
+    past: history.past.slice(0, -1),
+    future: [...history.future, history.current]
+  };
+};
+var redo = (history) => {
+  if (history.future.length === 0) {
+    throw new RedoError();
+  }
+  const next = history.future[history.future.length - 1];
+  return {
+    current: next,
+    past: [...history.past, history.current],
+    future: history.future.slice(0, -1)
+  };
+};
+var canUndo = (history) => history.past.length > 0;
+var canRedo = (history) => history.future.length > 0;
+var clearHistory = (history) => ({
+  current: history.current,
+  past: [],
+  future: []
+});
+var getHistorySize = (history) => ({
+  past: history.past.length,
+  future: history.future.length
+});
 
 // src/index.ts
 var createGameEngine = (config) => {
@@ -2001,9 +3712,14 @@ var createGameEngine = (config) => {
     placeDominoHandler: placeDominoHandler2,
     discardDominoHandler: discardDominoHandler2,
     getResultHandler: getResultHandler2,
-    calculateScoreHandler: calculateScoreHandler2
+    calculateScoreHandler: calculateScoreHandler2,
+    getValidPlacementsHandler: getValidPlacementsHandler2,
+    canPlaceDominoHandler: canPlaceDominoHandler2,
+    serializeGameHandler: serializeGameHandler2,
+    deserializeGameHandler: deserializeGameHandler2,
+    getDynastyResultHandler: getDynastyResultHandler2
   } = configureEngine(config);
-  return {
+  let engine = {
     getModes: (command) => getModesHandler2(command),
     getExtraRules: (command) => getExtraRulesHandler2(command),
     createGame: (command) => createGameHandler2(command),
@@ -2014,16 +3730,78 @@ var createGameEngine = (config) => {
     placeDomino: (command) => placeDominoHandler2(command),
     discardDomino: (command) => discardDominoHandler2(command),
     getResults: (command) => getResultHandler2(command),
-    calculateScore: (command) => calculateScoreHandler2(command)
+    calculateScore: (command) => calculateScoreHandler2(command),
+    getValidPlacements: (command) => getValidPlacementsHandler2(command),
+    canPlaceDomino: (command) => canPlaceDominoHandler2(command),
+    serialize: (command) => serializeGameHandler2(command),
+    deserialize: (command) => deserializeGameHandler2(command),
+    getDynastyResults: (command) => getDynastyResultHandler2(command)
   };
+  if (config.events) {
+    engine = wrapWithEvents(engine, config.events);
+  }
+  if (config.debug) {
+    const debugOptions = typeof config.debug === "object" ? config.debug : void 0;
+    engine = wrapWithDebug(engine, debugOptions);
+  }
+  return engine;
 };
 export {
+  ActionExecutionError,
+  DomainException,
+  ErrorCode,
   GRIDSIZE,
   GROUND,
+  InvalidStepError,
+  MAX_KINGDOM_SIZE,
+  NotFoundError,
+  RedoError,
+  StepExecutionError,
+  TranslationKey,
+  UndoError,
+  ValidationError,
+  advancedStrategy,
+  appendAction,
+  canRedo,
+  canUndo,
+  clearHistory,
+  createActionLog,
+  createDomainError,
   createGameEngine,
+  createGameHistory,
+  createSavePoint,
+  createTranslator,
+  defaultTranslations,
+  defaultTranslator,
+  deserializeGame,
+  errorCodeToTranslationKey,
+  expertStrategy,
   gameSteps,
+  getActions,
+  getActionsByTurn,
+  getActionsByType,
+  getHistorySize,
+  getStrategy,
+  getStrategyNames,
+  greedyStrategy,
+  isBotTurn,
   isGameWithNextAction,
   isGameWithNextStep,
-  playerActions
+  playBotTurn,
+  playBotTurns,
+  playerActions,
+  pushState,
+  randomStrategy,
+  redo,
+  replayActions,
+  restoreFromSavePoint,
+  serializeGame,
+  summarizeGameState,
+  translateErrorCode,
+  undo,
+  validateGameState,
+  wrapWithActionLog,
+  wrapWithDebug,
+  wrapWithEvents
 };
 //# sourceMappingURL=index.js.map