npm - @pompidup/kingdomino-engine - Versions diffs - 3.1.0 → 3.3.0 - Mend

@pompidup/kingdomino-engine 3.1.0 → 3.3.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (7) hide show

package/README.md +240 -110
package/dist/index.d.ts +597 -161
package/dist/index.js +2133 -747
package/dist/index.js.map +1 -1
package/dist/index.universal.js +3805 -0
package/dist/wasm-bridge.js +2928 -0
package/package.json +23 -10

package/dist/index.universal.js ADDED Viewed

@@ -0,0 +1,3805 @@
+// 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: [
+    {
+      left: {
+        type: "wheat",
+        crowns: 0
+      },
+      right: {
+        type: "wheat",
+        crowns: 0
+      },
+      number: 1
+    },
+    {
+      left: {
+        type: "wheat",
+        crowns: 0
+      },
+      right: {
+        type: "wheat",
+        crowns: 0
+      },
+      number: 2
+    },
+    {
+      left: {
+        type: "forest",
+        crowns: 0
+      },
+      right: {
+        type: "forest",
+        crowns: 0
+      },
+      number: 3
+    },
+    {
+      left: {
+        type: "forest",
+        crowns: 0
+      },
+      right: {
+        type: "forest",
+        crowns: 0
+      },
+      number: 4
+    },
+    {
+      left: {
+        type: "forest",
+        crowns: 0
+      },
+      right: {
+        type: "forest",
+        crowns: 0
+      },
+      number: 5
+    },
+    {
+      left: {
+        type: "forest",
+        crowns: 0
+      },
+      right: {
+        type: "forest",
+        crowns: 0
+      },
+      number: 6
+    },
+    {
+      left: {
+        type: "sea",
+        crowns: 0
+      },
+      right: {
+        type: "sea",
+        crowns: 0
+      },
+      number: 7
+    },
+    {
+      left: {
+        type: "sea",
+        crowns: 0
+      },
+      right: {
+        type: "sea",
+        crowns: 0
+      },
+      number: 8
+    },
+    {
+      left: {
+        type: "sea",
+        crowns: 0
+      },
+      right: {
+        type: "sea",
+        crowns: 0
+      },
+      number: 9
+    },
+    {
+      left: {
+        type: "plain",
+        crowns: 0
+      },
+      right: {
+        type: "plain",
+        crowns: 0
+      },
+      number: 10
+    },
+    {
+      left: {
+        type: "plain",
+        crowns: 0
+      },
+      right: {
+        type: "plain",
+        crowns: 0
+      },
+      number: 11
+    },
+    {
+      left: {
+        type: "swamp",
+        crowns: 0
+      },
+      right: {
+        type: "swamp",
+        crowns: 0
+      },
+      number: 12
+    },
+    {
+      left: {
+        type: "wheat",
+        crowns: 0
+      },
+      right: {
+        type: "forest",
+        crowns: 0
+      },
+      number: 13
+    },
+    {
+      left: {
+        type: "wheat",
+        crowns: 0
+      },
+      right: {
+        type: "sea",
+        crowns: 0
+      },
+      number: 14
+    },
+    {
+      left: {
+        type: "wheat",
+        crowns: 0
+      },
+      right: {
+        type: "plain",
+        crowns: 0
+      },
+      number: 15
+    },
+    {
+      left: {
+        type: "wheat",
+        crowns: 0
+      },
+      right: {
+        type: "swamp",
+        crowns: 0
+      },
+      number: 16
+    },
+    {
+      left: {
+        type: "forest",
+        crowns: 0
+      },
+      right: {
+        type: "sea",
+        crowns: 0
+      },
+      number: 17
+    },
+    {
+      left: {
+        type: "forest",
+        crowns: 0
+      },
+      right: {
+        type: "plain",
+        crowns: 0
+      },
+      number: 18
+    },
+    {
+      left: {
+        type: "wheat",
+        crowns: 1
+      },
+      right: {
+        type: "forest",
+        crowns: 0
+      },
+      number: 19
+    },
+    {
+      left: {
+        type: "wheat",
+        crowns: 1
+      },
+      right: {
+        type: "sea",
+        crowns: 0
+      },
+      number: 20
+    },
+    {
+      left: {
+        type: "wheat",
+        crowns: 1
+      },
+      right: {
+        type: "plain",
+        crowns: 0
+      },
+      number: 21
+    },
+    {
+      left: {
+        type: "wheat",
+        crowns: 1
+      },
+      right: {
+        type: "swamp",
+        crowns: 0
+      },
+      number: 22
+    },
+    {
+      left: {
+        type: "wheat",
+        crowns: 1
+      },
+      right: {
+        type: "mine",
+        crowns: 0
+      },
+      number: 23
+    },
+    {
+      left: {
+        type: "forest",
+        crowns: 1
+      },
+      right: {
+        type: "wheat",
+        crowns: 0
+      },
+      number: 24
+    },
+    {
+      left: {
+        type: "forest",
+        crowns: 1
+      },
+      right: {
+        type: "wheat",
+        crowns: 0
+      },
+      number: 25
+    },
+    {
+      left: {
+        type: "forest",
+        crowns: 1
+      },
+      right: {
+        type: "wheat",
+        crowns: 0
+      },
+      number: 26
+    },
+    {
+      left: {
+        type: "forest",
+        crowns: 1
+      },
+      right: {
+        type: "wheat",
+        crowns: 0
+      },
+      number: 27
+    },
+    {
+      left: {
+        type: "forest",
+        crowns: 1
+      },
+      right: {
+        type: "sea",
+        crowns: 0
+      },
+      number: 28
+    },
+    {
+      left: {
+        type: "forest",
+        crowns: 1
+      },
+      right: {
+        type: "plain",
+        crowns: 0
+      },
+      number: 29
+    },
+    {
+      left: {
+        type: "sea",
+        crowns: 1
+      },
+      right: {
+        type: "wheat",
+        crowns: 0
+      },
+      number: 30
+    },
+    {
+      left: {
+        type: "sea",
+        crowns: 1
+      },
+      right: {
+        type: "wheat",
+        crowns: 0
+      },
+      number: 31
+    },
+    {
+      left: {
+        type: "sea",
+        crowns: 1
+      },
+      right: {
+        type: "forest",
+        crowns: 0
+      },
+      number: 32
+    },
+    {
+      left: {
+        type: "sea",
+        crowns: 1
+      },
+      right: {
+        type: "forest",
+        crowns: 0
+      },
+      number: 33
+    },
+    {
+      left: {
+        type: "sea",
+        crowns: 1
+      },
+      right: {
+        type: "forest",
+        crowns: 0
+      },
+      number: 34
+    },
+    {
+      left: {
+        type: "sea",
+        crowns: 1
+      },
+      right: {
+        type: "forest",
+        crowns: 0
+      },
+      number: 35
+    },
+    {
+      left: {
+        type: "wheat",
+        crowns: 0
+      },
+      right: {
+        type: "plain",
+        crowns: 1
+      },
+      number: 36
+    },
+    {
+      left: {
+        type: "sea",
+        crowns: 0
+      },
+      right: {
+        type: "plain",
+        crowns: 1
+      },
+      number: 37
+    },
+    {
+      left: {
+        type: "wheat",
+        crowns: 0
+      },
+      right: {
+        type: "swamp",
+        crowns: 1
+      },
+      number: 38
+    },
+    {
+      left: {
+        type: "plain",
+        crowns: 0
+      },
+      right: {
+        type: "swamp",
+        crowns: 0
+      },
+      number: 39
+    },
+    {
+      left: {
+        type: "mine",
+        crowns: 1
+      },
+      right: {
+        type: "wheat",
+        crowns: 0
+      },
+      number: 40
+    },
+    {
+      left: {
+        type: "wheat",
+        crowns: 0
+      },
+      right: {
+        type: "plain",
+        crowns: 2
+      },
+      number: 41
+    },
+    {
+      left: {
+        type: "sea",
+        crowns: 0
+      },
+      right: {
+        type: "plain",
+        crowns: 2
+      },
+      number: 42
+    },
+    {
+      left: {
+        type: "wheat",
+        crowns: 0
+      },
+      right: {
+        type: "swamp",
+        crowns: 2
+      },
+      number: 43
+    },
+    {
+      left: {
+        type: "plain",
+        crowns: 0
+      },
+      right: {
+        type: "swamp",
+        crowns: 2
+      },
+      number: 44
+    },
+    {
+      left: {
+        type: "mine",
+        crowns: 2
+      },
+      right: {
+        type: "wheat",
+        crowns: 0
+      },
+      number: 45
+    },
+    {
+      left: {
+        type: "swamp",
+        crowns: 0
+      },
+      right: {
+        type: "mine",
+        crowns: 2
+      },
+      number: 46
+    },
+    {
+      left: {
+        type: "swamp",
+        crowns: 0
+      },
+      right: {
+        type: "mine",
+        crowns: 2
+      },
+      number: 47
+    },
+    {
+      left: {
+        type: "wheat",
+        crowns: 0
+      },
+      right: {
+        type: "mine",
+        crowns: 3
+      },
+      number: 48
+    }
+  ]
+};
+// src/adapterServerside/jsonDominoes.ts
+var jsonDominoes = () => {
+  const dominoes = {};
+  for (const [key, value] of Object.entries(dominoes_default)) {
+    const currentDominoes = [];
+    value.forEach((domino) => {
+      currentDominoes.push({
+        left: {
+          type: domino.left.type,
+          crowns: domino.left.crowns
+        },
+        right: {
+          type: domino.right.type,
+          crowns: domino.right.crowns
+        },
+        number: domino.number
+      });
+    });
+    dominoes[key] = currentDominoes;
+  }
+  return {
+    getForMode: (mode) => {
+      return dominoes[mode.name] || [];
+    }
+  };
+};
+var jsonDominoes_default = jsonDominoes;
+// src/datasources/modes.json
+var modes_default = [
+  {
+    name: "Classic",
+    description: "Original KingDomino rules"
+  }
+];
+// src/adapterServerside/jsonModes.ts
+var jsonModes = () => {
+  const modes = [];
+  modes_default.forEach((mode) => {
+    modes.push({
+      name: mode.name,
+      description: mode.description
+    });
+  });
+  return {
+    getAvailables: () => {
+      return modes;
+    }
+  };
+};
+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,
+      maxKingdomSize: 5
+    },
+    {
+      playersLimit: 3,
+      lordsPerPlayer: 1,
+      maxDominoes: 48,
+      dominoesPerTurn: 4,
+      maxTurns: 12,
+      maxKingdomSize: 5
+    },
+    {
+      playersLimit: 4,
+      lordsPerPlayer: 1,
+      maxDominoes: 48,
+      dominoesPerTurn: 4,
+      maxTurns: 12,
+      maxKingdomSize: 5
+    }
+  ],
+  extra: [
+    {
+      name: "The middle Kingdom",
+      description: "Gain 10 additional points if your castle is in the middle of the kingdom.",
+      mode: [{ name: "Classic", description: "King Domino classic mode" }]
+    },
+    {
+      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" }]
+    }
+  ]
+};
+// src/adapterServerside/jsonRules.ts
+var jsonRules = () => {
+  const rules = {
+    basic: {},
+    extraRules: []
+  };
+  const commonRules = rules_default.commun;
+  const extraRules = rules_default.extra;
+  commonRules.forEach((rule) => {
+    rules.basic[rule.playersLimit] = {
+      lords: rule.lordsPerPlayer,
+      maxDominoes: rule.maxDominoes,
+      dominoesPerTurn: rule.dominoesPerTurn,
+      maxTurns: rule.maxTurns,
+      maxKingdomSize: rule.maxKingdomSize
+    };
+  });
+  extraRules.forEach((rule) => {
+    rules.extraRules.push({
+      name: rule.name,
+      description: rule.description,
+      mode: rule.mode,
+      ..."playersLimit" in rule && { playersLimit: rule.playersLimit }
+    });
+  });
+  return {
+    getAll: () => {
+      return rules;
+    },
+    getAllExtra: () => {
+      return rules.extraRules;
+    }
+  };
+};
+var jsonRules_default = jsonRules;
+// src/adapterServerside/shuffle.ts
+var shuffleMethod = (array) => {
+  for (let i = array.length - 1; i > 0; i--) {
+    const j = Math.floor(Math.random() * (i + 1));
+    [array[i], array[j]] = [array[j], array[i]];
+  }
+  return array;
+};
+// src/adapterServerside/uuid.ts
+var uuidMethod = () => {
+  return globalThis.crypto.randomUUID();
+};
+// src/core/domain/errors/domainErrors.ts
+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 DomainException {
+  constructor(message, code = ErrorCode.STEP_EXECUTION_FAILED, context) {
+    super({
+      code,
+      message,
+      context
+    });
+    this.name = "StepExecutionError";
+  }
+};
+var ActionExecutionError = class extends DomainException {
+  constructor(message, code = ErrorCode.ACTION_EXECUTION_FAILED, context) {
+    super({
+      code,
+      message,
+      context
+    });
+    this.name = "ActionExecutionError";
+  }
+};
+var NotFoundError = class extends DomainException {
+  constructor(message, code = ErrorCode.LORD_NOT_FOUND, context) {
+    super({
+      code,
+      message,
+      context
+    });
+    this.name = "NotFoundError";
+  }
+};
+var ValidationError = class extends DomainException {
+  constructor(message, code, context) {
+    super({
+      code,
+      message,
+      context
+    });
+    this.name = "ValidationError";
+  }
+};
+var UndoError = class extends DomainException {
+  constructor(message = "No state to undo", context) {
+    super({
+      code: ErrorCode.UNDO_UNAVAILABLE,
+      message,
+      context
+    });
+    this.name = "UndoError";
+  }
+};
+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, translator, useCase) => (command) => {
+  const { game, extraRules } = command;
+  logger.info(`Adding extra rules to game: ${game.id}`);
+  logger.info(`Extra rules: ${extraRules}`);
+  if (!isGameWithNextStep(game)) {
+    logger.error(
+      `Invalid game, required nextAction type: 'step' but got: ${game.nextAction.type}`
+    );
+    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(
+      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}`);
+    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, 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(
+      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(
+      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}`);
+    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, translator, useCase) => (command) => {
+  const { game, lordId, dominoPick } = command;
+  logger.info(
+    `Choosing domino: ${dominoPick} for lord: ${lordId} in game: ${game.id}`
+  );
+  if (!isGameWithNextAction(game)) {
+    logger.error(
+      `Invalid game, required nextAction type: 'action' but got: ${game.nextAction.type}`
+    );
+    throw new InvalidStepError(
+      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(
+      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}`);
+    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}`
+  );
+  return result.value;
+};
+// src/application/handlers/createGameHandler.ts
+var createGameHandler = (logger, translator, useCase) => (command) => {
+  logger.info(`Creating game with mode: ${command.mode}`);
+  const result = useCase(command.mode, command.seed);
+  if (isErr(result)) {
+    logger.error(`Error creating game: ${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, translator, useCase) => (command) => {
+  const { game, lordId } = command;
+  logger.info(`Discarding domino for lord: ${lordId} in game: ${game.id}`);
+  if (!isGameWithNextAction(game)) {
+    logger.error(
+      `Invalid game, required nextAction type: 'action' but got: ${game.nextAction.type}`
+    );
+    throw new InvalidStepError(
+      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(
+      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}`);
+    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}`);
+    return result.value;
+  }
+  logger.info(`Domino discarded: ${lordId} in game: ${game.id}`);
+  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, translator, useCase) => (command) => {
+  const { mode, players } = command;
+  logger.info(
+    `Getting extra rules for mode: ${mode} and players: ${players}`
+  );
+  const result = useCase(mode, players);
+  if (isErr(result)) {
+    logger.error(`Error getting extra rules: ${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, translator, useCase) => (_command) => {
+  logger.info("Getting modes");
+  const result = useCase();
+  if (isErr(result)) {
+    logger.error(`Error getting modes: ${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, translator, useCases) => (command) => {
+  const { getResultUseCase: getResultUseCase2, calculateScoreUseCase: calculateScoreUseCase2 } = useCases;
+  const { game } = command;
+  logger.info(`Getting result for game: ${game.id}`);
+  if (!isGameWithNextStep(game)) {
+    logger.error(
+      `Invalid game, required nextAction type: 'step' but got: ${game.nextAction.type}`
+    );
+    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(
+      translateErrorCode(translator, ErrorCode.INVALID_STEP),
+      { expected: "result", actual: game.nextAction.step, gameId: game.id }
+    );
+  }
+  const { players } = game;
+  const scoreResult = players.map((player) => {
+    const { kingdom } = player;
+    const result2 = calculateScoreUseCase2(kingdom);
+    if (isErr(result2)) {
+      logger.error(`Error when calculating score: ${result2.error}`);
+      const code = result2.error;
+      throw new StepExecutionError(
+        translateErrorCode(translator, code),
+        code,
+        {
+          gameId: game.id
+        }
+      );
+    }
+    return {
+      playerId: player.id,
+      playerName: player.name,
+      details: {
+        ...result2.value
+      }
+    };
+  });
+  const result = getResultUseCase2(game, scoreResult);
+  if (isErr(result)) {
+    logger.error(`Error getting result: ${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, translator, useCase) => (command) => {
+  const { game, lordId, position, rotation } = command;
+  logger.info(
+    `Placing domino: ${lordId} in position: ${JSON.stringify(
+      position
+    )} with rotation: ${rotation} in game: ${game.id}`
+  );
+  if (!isGameWithNextAction(game)) {
+    logger.error(
+      `Invalid game, required nextAction type: 'action' but got: ${game.nextAction.type}`
+    );
+    throw new InvalidStepError(
+      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(
+      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}`);
+    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(
+      `Domino placed: ${lordId} in position: ${JSON.stringify(
+        position
+      )} with rotation: ${rotation} in game: ${game.id}`
+    );
+    return result.value;
+  }
+  logger.info(
+    `Domino placed: ${lordId} in position: ${JSON.stringify(
+      position
+    )} with rotation: ${rotation} in game: ${game.id}`
+  );
+  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, 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(
+      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(
+      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}`);
+    const code = result.error;
+    throw new StepExecutionError(translateErrorCode(translator, code), code, {
+      gameId: game.id
+    });
+  }
+  logger.info(`Game started: ${game.id}`);
+  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 = [
+  "castle",
+  "wheat",
+  "forest",
+  "sea",
+  "plain",
+  "swamp",
+  "mine"
+];
+// 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"
+};
+// src/core/domain/entities/rule.ts
+var getAvailablesExtraRules = (extraRules, mode, numberOfPlayers) => {
+  const availableExtraRules = extraRules.filter((rule) => {
+    return rule.mode.filter((m) => m.name === mode).length > 0 && (!rule.playersLimit || rule.playersLimit === numberOfPlayers);
+  });
+  if (availableExtraRules.length === 0) {
+    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(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, dominoesRepository, shuffleMethod: shuffleMethod2 } = deps;
+  const availableExtraRules = ruleRepository.getAllExtra();
+  const newExtraRules = [];
+  for (const rule of rules) {
+    const result = toExtraRule(rule, availableExtraRules);
+    if (isErr(result)) {
+      return result;
+    }
+    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: updatedBasic,
+    extra: newExtraRules
+  };
+  const next = {
+    type: "step",
+    step: gameSteps.start
+  };
+  const updatedGame = {
+    ...game,
+    dominoes: updatedDominoes,
+    rules: updatedRules,
+    nextAction: next
+  };
+  return ok(updatedGame);
+};
+// src/core/domain/entities/domino.ts
+var isGround = (ground) => {
+  return GROUND.includes(ground);
+};
+var createTile = (ground, crowns = 0) => {
+  if (isGround(ground)) {
+    return { type: ground, crowns };
+  }
+  return { type: ground, crowns: 0 };
+};
+// src/core/domain/entities/kingdom.ts
+var createEmptyKingdom = () => {
+  const emptyTile = createTile("empty");
+  return Array.from(
+    { length: GRIDSIZE },
+    () => Array.from({ length: GRIDSIZE }, () => emptyTile)
+  );
+};
+var placeCastle = (kingdom) => {
+  const castle = createTile("castle");
+  const newKingdom = deepCopyKingdom(kingdom);
+  newKingdom[4][4] = castle;
+  return newKingdom;
+};
+var placeTile = (kingdom, position, tile) => {
+  const newKingdom = deepCopyKingdom(kingdom);
+  newKingdom[position.y][position.x] = tile;
+  return newKingdom;
+};
+var getTile = (kingdom, position) => {
+  const tile = kingdom[position.y]?.[position.x];
+  if (!tile) {
+    return err(ErrorCode.PLACEMENT_OUT_OF_BOUNDS);
+  }
+  return ok(tile);
+};
+var calculateDominoPosition = (position, rotation, domino) => {
+  let firstTile;
+  let secondTile;
+  switch (rotation) {
+    case 0:
+      firstTile = {
+        tile: domino.left,
+        position: {
+          x: position.x,
+          y: position.y
+        }
+      };
+      secondTile = {
+        tile: domino.right,
+        position: {
+          x: position.x + 1,
+          y: position.y
+        }
+      };
+      break;
+    case 90:
+      firstTile = {
+        tile: domino.left,
+        position: {
+          x: position.x,
+          y: position.y
+        }
+      };
+      secondTile = {
+        tile: domino.right,
+        position: {
+          x: position.x,
+          y: position.y + 1
+        }
+      };
+      break;
+    case 180:
+      firstTile = {
+        tile: domino.right,
+        position: {
+          x: position.x,
+          y: position.y
+        }
+      };
+      secondTile = {
+        tile: domino.left,
+        position: {
+          x: position.x + 1,
+          y: position.y
+        }
+      };
+      break;
+    case 270:
+      firstTile = {
+        tile: domino.right,
+        position: {
+          x: position.x,
+          y: position.y
+        }
+      };
+      secondTile = {
+        tile: domino.left,
+        position: {
+          x: position.x,
+          y: position.y + 1
+        }
+      };
+      break;
+  }
+  return [firstTile, secondTile];
+};
+var placeDomino = (kingdom, position, rotation, domino, maxKingdomSize = MAX_KINGDOM_SIZE) => {
+  const [firstTile, secondTile] = calculateDominoPosition(
+    position,
+    rotation,
+    domino
+  );
+  const isFreePlaceResult = isFreePlace(
+    kingdom,
+    firstTile.position,
+    secondTile.position
+  );
+  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(ErrorCode.PLACEMENT_NOT_ADJACENT);
+  }
+  const hasValidAdjacentTiles = hasValidAdjacent(adjacentTiles, [
+    firstTile.tile,
+    secondTile.tile
+  ]);
+  if (!hasValidAdjacentTiles) {
+    return err(ErrorCode.PLACEMENT_INVALID_TERRAIN);
+  }
+  return ok(placeTiles(kingdom, [firstTile, secondTile]));
+};
+var placeTiles = (kingdom, tiles) => {
+  let newKingdom = deepCopyKingdom(kingdom);
+  for (const { tile, position } of tiles) {
+    newKingdom = placeTile(newKingdom, position, tile);
+  }
+  return newKingdom;
+};
+var isFreePlace = (kingdom, firstPosition, secondPosition) => {
+  const firstTile = getTile(kingdom, firstPosition);
+  const secondTile = getTile(kingdom, secondPosition);
+  if (isErr(firstTile)) {
+    return firstTile;
+  }
+  if (isErr(secondTile)) {
+    return secondTile;
+  }
+  if (firstTile.value.type !== "empty" || secondTile.value.type !== "empty") {
+    return err(ErrorCode.PLACEMENT_NOT_EMPTY);
+  }
+  return ok(true);
+};
+var isAdjacent = (kingdom, firstPosition, secondPosition) => {
+  const offsets = [
+    { x: -1, y: 0 },
+    { x: 1, y: 0 },
+    { x: 0, y: -1 },
+    { x: 0, y: 1 }
+  ];
+  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) => {
+  return adjacentTiles.some((adjacentTile) => {
+    return tiles.some((tile) => {
+      return tile.type === adjacentTile.type || adjacentTile.type === "castle";
+    });
+  });
+};
+var checkCastleIsInMiddle = (kingdom) => {
+  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");
+  return (notEmpties.length - 1) / 2;
+};
+var deepCopyKingdom = (kingdom) => {
+  return kingdom.map((line) => line.map((tile) => ({ ...tile })));
+};
+// src/core/domain/entities/player.ts
+var MINPLAYERSNAMELENGTH = 3;
+var validatePlayer = (name) => {
+  if (!name || name.trim().length < MINPLAYERSNAMELENGTH) {
+    return err(ErrorCode.INVALID_PLAYER_NAME);
+  }
+  return ok(name);
+};
+var createPlayer = (playerName, id, kingdom, bot) => {
+  const name = validatePlayer(playerName);
+  if (isErr(name)) {
+    return name;
+  }
+  return ok({
+    name: name.value,
+    id,
+    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 < 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(name, id, kingdom, bot);
+    if (isErr(newPlayer)) {
+      return newPlayer;
+    }
+    newPlayers.push(newPlayer.value);
+  }
+  const rules = ruleRepository.getAll();
+  const basicRules = rules.basic[newPlayers.length];
+  if (!basicRules) {
+    return err(ErrorCode.STEP_EXECUTION_FAILED);
+  }
+  const dominoes = game.dominoes;
+  const { maxDominoes } = basicRules;
+  const shuffle = game.seed ? createSeededShuffle(game.seed, "dominoes") : shuffleMethod2;
+  const shuffledDominoes = shuffle(dominoes);
+  const splicedDominoes = shuffledDominoes.slice(0, maxDominoes);
+  const next = {
+    type: "step",
+    step: "options"
+  };
+  const updatedGame = {
+    ...game,
+    players: newPlayers,
+    dominoes: splicedDominoes,
+    rules: {
+      ...game.rules,
+      basic: basicRules
+    },
+    nextAction: next
+  };
+  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 {
+    id,
+    playerId,
+    turnEnded: false,
+    hasPick: false,
+    hasPlace: true
+  };
+};
+var hasPick = (lord) => lord.hasPick;
+var hasPlace = (lord) => lord.hasPlace;
+var hasTurnEnded = (lord) => lord.turnEnded;
+var canPass = (lord) => {
+  return !hasPick(lord) && !hasPlace(lord) && !hasTurnEnded(lord);
+};
+var canPick = (lord) => {
+  return !hasPick(lord) && hasPlace(lord) && !hasTurnEnded(lord);
+};
+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 ?? 0) - (b.dominoPicked?.number ?? 0);
+  });
+};
+var resetLordsActions = (lords) => {
+  return lords.map((lord) => ({
+    ...lord,
+    turnEnded: false,
+    hasPick: false,
+    hasPlace: false
+  }));
+};
+var nextLordWithAction = (lords) => {
+  const nextLord = findNextLord(lords);
+  return {
+    type: "action",
+    nextLord: nextLord.id,
+    nextAction: hasPlace(nextLord) ? playerActions.pickDomino : playerActions.placeDomino
+  };
+};
+var findNextLord = (lords) => {
+  const lord = lords.find((lord2) => !hasTurnEnded(lord2));
+  if (!lord) {
+    return lords[0];
+  }
+  return lord;
+};
+var allLordsHavePlayed = (lords) => {
+  return lords.every((lord) => lord.turnEnded);
+};
+// src/core/useCases/chooseDomino.ts
+var chooseDominoUseCase = (game, lordId, dominoPick) => {
+  const currentLord = game.lords.find(
+    (lord) => lord.id === game.nextAction.nextLord
+  );
+  if (!currentLord) {
+    return err(ErrorCode.LORD_NOT_FOUND);
+  }
+  if (currentLord.id !== lordId) {
+    return err(ErrorCode.NOT_YOUR_TURN);
+  }
+  if (!canPick(currentLord)) {
+    return err(ErrorCode.CANNOT_PICK);
+  }
+  const selectedDomino = game.currentDominoes.find(
+    (domino) => domino.domino.number === dominoPick
+  );
+  if (!selectedDomino) {
+    return err(ErrorCode.DOMINO_NOT_FOUND);
+  }
+  if (selectedDomino.picked) {
+    return err(ErrorCode.DOMINO_ALREADY_PICKED);
+  }
+  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));
+    const updatedTurn = game.turn + 1;
+    const next2 = nextLordWithAction(lords);
+    const dominoesCopy = [...game.dominoes];
+    const dominoesDrawn = dominoesCopy.splice(
+      0,
+      game.rules.basic.dominoesPerTurn
+    );
+    dominoesDrawn.sort((a, b) => a.number - b.number);
+    const updatedCurrentDominoes2 = dominoesDrawn.map((domino, index) => {
+      return {
+        domino,
+        picked: false,
+        lordId: null,
+        position: index + 1
+      };
+    });
+    return ok({
+      ...game,
+      currentDominoes: updatedCurrentDominoes2,
+      dominoes: dominoesCopy,
+      lords,
+      turn: updatedTurn,
+      nextAction: next2
+    });
+  }
+  const next = nextLordWithAction(updatedLords);
+  const updatedState = {
+    ...game,
+    currentDominoes: updatedCurrentDominoes,
+    lords: updatedLords,
+    nextAction: next
+  };
+  return ok(updatedState);
+};
+// src/core/domain/entities/game.ts
+var create = (payload) => {
+  const { id, mode, dominoes, seed } = payload;
+  return {
+    id,
+    dominoes,
+    currentDominoes: [],
+    players: [],
+    lords: [],
+    turn: 0,
+    nextAction: {
+      type: "step",
+      step: gameSteps.addPlayers
+    },
+    rules: {
+      basic: {
+        lords: 0,
+        maxDominoes: 0,
+        dominoesPerTurn: 0,
+        maxTurns: 0,
+        maxKingdomSize: 5
+      },
+      extra: []
+    },
+    mode,
+    ...seed !== void 0 && { seed }
+  };
+};
+// src/core/domain/entities/mode.ts
+var findMode = (mode, availableMode) => {
+  return availableMode.find((m) => m.name === mode);
+};
+var createMode = (mode, availableMode) => {
+  const foundMode = findMode(mode, availableMode);
+  if (foundMode) {
+    return ok(foundMode);
+  }
+  return err(ErrorCode.MODE_NOT_FOUND);
+};
+// src/core/useCases/createGame.ts
+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)) {
+    return newMode;
+  }
+  const dominoes = dominoesRepository.getForMode(newMode.value);
+  if (!dominoes || dominoes.length === 0) {
+    return err(ErrorCode.DOMINO_NOT_FOUND);
+  }
+  const payload = {
+    id,
+    mode: newMode.value,
+    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;
+  const currentLord = game.lords.find(
+    (lord) => lord.id === nextAction.nextLord
+  );
+  if (!currentLord) {
+    return err(ErrorCode.LORD_NOT_FOUND);
+  }
+  if (currentLord.id !== lordId) {
+    return err(ErrorCode.NOT_YOUR_TURN);
+  }
+  if (!canPass(currentLord)) {
+    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;
+  const isLastTurn = currentTurn === maxTurns;
+  const updatedLord = game.lords.map((lord) => {
+    if (lord.id === currentLord.id) {
+      if (isLastTurn) {
+        return {
+          ...lord,
+          turnEnded: true,
+          hasPlace: true
+        };
+      }
+      return {
+        ...lord,
+        hasPlace: true
+      };
+    }
+    return lord;
+  });
+  let updatedGame;
+  const resultStep = {
+    type: "step",
+    step: gameSteps.result
+  };
+  if (isLastTurn && allLordsHavePlayed(updatedLord)) {
+    updatedGame = {
+      ...game,
+      lords: updatedLord,
+      nextAction: resultStep
+    };
+  } else {
+    updatedGame = {
+      ...game,
+      lords: updatedLord,
+      nextAction: nextLordWithAction(updatedLord)
+    };
+  }
+  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(ErrorCode.STEP_EXECUTION_FAILED);
+  }
+  return getAvailablesExtraRules(allExtraRules, mode, players);
+};
+// src/core/useCases/getModes.ts
+var getModesUseCase = (deps) => () => {
+  const { modeRepository } = deps;
+  return ok(modeRepository.getAvailables());
+};
+// src/core/useCases/getResult.ts
+var getResultUseCase = (game, scoreResult) => {
+  const { rules } = game;
+  const { basic, extra } = rules;
+  const finalScoreResult = scoreResult.map((score) => {
+    let finalScore = score.details.points;
+    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") {
+          const castleIsInMiddle = checkCastleIsInMiddle(kingdom);
+          if (castleIsInMiddle) {
+            finalScore += 10;
+          }
+        }
+        if (extraRule.name === "Harmony") {
+          const totalDominoes = countDominoes(kingdom);
+          const dominoLimit = basic.maxDominoes;
+          const totalPlayers = game.players.length;
+          const dominoesPerPlayer = dominoLimit / totalPlayers;
+          if (totalDominoes === dominoesPerPlayer) {
+            finalScore += 5;
+          }
+        }
+      });
+    }
+    return {
+      ...score,
+      details: {
+        ...score.details,
+        points: finalScore
+      }
+    };
+  });
+  finalScoreResult.sort((a, b) => {
+    if (a.details.points !== b.details.points) {
+      return b.details.points - a.details.points;
+    }
+    return b.details.maxPropertiesSize - a.details.maxPropertiesSize;
+  });
+  const result = [];
+  let isTie = false;
+  result.push({
+    playerId: finalScoreResult[0].playerId,
+    playerName: finalScoreResult[0].playerName,
+    details: finalScoreResult[0].details,
+    position: 1
+  });
+  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) {
+      isTie = true;
+    }
+    if (isTie) {
+      result.push({
+        ...currentScore,
+        position: result[i - 1].position
+      });
+    } else {
+      result.push({
+        ...currentScore,
+        position: i + 1
+      });
+    }
+    isTie = false;
+  }
+  return ok({
+    ...game,
+    result
+  });
+};
+// src/core/useCases/placeDomino.ts
+var placeDominoUseCase = (game, lordId, position, rotation) => {
+  const nextAction = game.nextAction;
+  const currentLord = game.lords.find(
+    (lord) => lord.id === nextAction.nextLord
+  );
+  if (!currentLord) {
+    return err(ErrorCode.LORD_NOT_FOUND);
+  }
+  if (currentLord.id !== lordId) {
+    return err(ErrorCode.NOT_YOUR_TURN);
+  }
+  if (!canPlaceAndDominoPickedIsDefined(currentLord)) {
+    return err(ErrorCode.CANNOT_PLACE);
+  }
+  const domino = currentLord.dominoPicked;
+  const currentPlayer = game.players.find(
+    (player) => player.id === currentLord.playerId
+  );
+  if (!currentPlayer) {
+    return err(ErrorCode.PLAYER_NOT_FOUND);
+  }
+  const updatedKingdom = placeDomino(
+    currentPlayer.kingdom,
+    position,
+    rotation,
+    domino,
+    game.rules.basic.maxKingdomSize
+  );
+  if (isErr(updatedKingdom)) {
+    return updatedKingdom;
+  }
+  const updatedPlayers = game.players.map((player) => {
+    if (player.id === currentPlayer.id) {
+      player.kingdom = updatedKingdom.value;
+    }
+    return player;
+  });
+  const maxTurns = game.rules.basic.maxTurns;
+  const currentTurn = game.turn;
+  const isLastTurn = currentTurn === maxTurns;
+  const updatedLords = game.lords.map((lord) => {
+    if (lord.id === currentLord.id) {
+      if (isLastTurn) {
+        return {
+          ...lord,
+          turnEnded: true,
+          hasPlace: true
+        };
+      }
+      return {
+        ...lord,
+        hasPlace: true
+      };
+    }
+    return lord;
+  });
+  let updatedGame;
+  const resultStep = {
+    type: "step",
+    step: gameSteps.result
+  };
+  if (isLastTurn && allLordsHavePlayed(updatedLords)) {
+    updatedGame = {
+      ...game,
+      lords: updatedLords,
+      nextAction: resultStep,
+      players: updatedPlayers
+    };
+  } else {
+    updatedGame = {
+      ...game,
+      lords: updatedLords,
+      nextAction: nextLordWithAction(updatedLords),
+      players: updatedPlayers
+    };
+  }
+  return ok(updatedGame);
+};
+// src/core/useCases/startGame.ts
+var startGameUseCase = (deps) => (game) => {
+  const { uuidMethod: uuidMethod2, shuffleMethod: shuffleMethod2 } = deps;
+  const {
+    rules: {
+      basic: { lords: maxLords, dominoesPerTurn }
+    },
+    players,
+    dominoes
+  } = game;
+  const numberOfPlayers = players.length;
+  const newLords = [];
+  for (let i = 0; i < numberOfPlayers; i++) {
+    for (let j = 0; j < maxLords; j++) {
+      const lord = createLord(uuidMethod2(), players[i].id);
+      newLords.push(lord);
+    }
+  }
+  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);
+  const nextAction = {
+    type: "action",
+    nextLord: shuffledLords[0].id,
+    nextAction: playerActions.pickDomino
+  };
+  const newState = {
+    ...game,
+    lords: shuffledLords,
+    nextAction,
+    dominoes: dominoesCopy,
+    currentDominoes: dominoesDrawn.map((domino, index) => {
+      return {
+        domino,
+        picked: false,
+        lordId: null,
+        position: index + 1
+      };
+    })
+  };
+  return ok(newState);
+};
+// src/config.ts
+var configureEngine = (config) => {
+  const modeRepository = jsonModes_default();
+  const dominoesRepository = jsonDominoes_default();
+  const ruleRepository = jsonRules_default();
+  const uuid = config.uuidMethod || uuidMethod;
+  const shuffle = config.shuffleMethod || shuffleMethod;
+  const translator = config.translator || defaultTranslator;
+  const logger = config.logger ? config.logger : config.logging ? consoleLogger(true) : silentLogger;
+  return {
+    createGameHandler: createGameHandler(
+      logger,
+      translator,
+      createGameUseCase({
+        modeRepository,
+        dominoesRepository,
+        uuidMethod: uuid
+      })
+    ),
+    getModesHandler: getModesHandler(
+      logger,
+      translator,
+      getModesUseCase({ modeRepository })
+    ),
+    getExtraRulesHandler: getExtraRulesHandler(
+      logger,
+      translator,
+      getExtraRulesUseCase({ ruleRepository })
+    ),
+    addPlayersHandler: addPlayersHandler(
+      logger,
+      translator,
+      addPlayersUseCase({
+        uuidMethod: uuid,
+        shuffleMethod: shuffle,
+        ruleRepository
+      })
+    ),
+    addExtraRulesHandler: addExtraRulesHandler(
+      logger,
+      translator,
+      addExtraRulesUseCase({
+        ruleRepository,
+        dominoesRepository,
+        shuffleMethod: shuffle
+      })
+    ),
+    startGameHandler: startGameHandler(
+      logger,
+      translator,
+      startGameUseCase({ uuidMethod: uuid, shuffleMethod: shuffle })
+    ),
+    chooseDominoHandler: chooseDominoHandler(
+      logger,
+      translator,
+      chooseDominoUseCase
+    ),
+    placeDominoHandler: placeDominoHandler(
+      logger,
+      translator,
+      placeDominoUseCase
+    ),
+    discardDominoHandler: discardDominoHandler(
+      logger,
+      translator,
+      discardDominoUseCase
+    ),
+    getResultHandler: getResultHandler(logger, translator, {
+      getResultUseCase,
+      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) => {
+  const {
+    createGameHandler: createGameHandler2,
+    getModesHandler: getModesHandler2,
+    getExtraRulesHandler: getExtraRulesHandler2,
+    addPlayersHandler: addPlayersHandler2,
+    addExtraRulesHandler: addExtraRulesHandler2,
+    startGameHandler: startGameHandler2,
+    chooseDominoHandler: chooseDominoHandler2,
+    placeDominoHandler: placeDominoHandler2,
+    discardDominoHandler: discardDominoHandler2,
+    getResultHandler: getResultHandler2,
+    calculateScoreHandler: calculateScoreHandler2,
+    getValidPlacementsHandler: getValidPlacementsHandler2,
+    canPlaceDominoHandler: canPlaceDominoHandler2,
+    serializeGameHandler: serializeGameHandler2,
+    deserializeGameHandler: deserializeGameHandler2,
+    getDynastyResultHandler: getDynastyResultHandler2
+  } = configureEngine(config);
+  let engine = {
+    getModes: (command) => getModesHandler2(command),
+    getExtraRules: (command) => getExtraRulesHandler2(command),
+    createGame: (command) => createGameHandler2(command),
+    addPlayers: (command) => addPlayersHandler2(command),
+    addExtraRules: (command) => addExtraRulesHandler2(command),
+    startGame: (command) => startGameHandler2(command),
+    chooseDomino: (command) => chooseDominoHandler2(command),
+    placeDomino: (command) => placeDominoHandler2(command),
+    discardDomino: (command) => discardDominoHandler2(command),
+    getResults: (command) => getResultHandler2(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,
+  playBotTurn,
+  playBotTurns,
+  playerActions,
+  pushState,
+  randomStrategy,
+  redo,
+  replayActions,
+  restoreFromSavePoint,
+  serializeGame,
+  summarizeGameState,
+  translateErrorCode,
+  undo,
+  validateGameState,
+  wrapWithActionLog,
+  wrapWithDebug,
+  wrapWithEvents
+};