@pompidup/kingdomino-engine 3.2.0 → 3.4.0

package/dist/wasm-bridge.js

@@ -0,0 +1,4287 @@
+// 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 = (engine2, options) => {
+  const logger = options?.logger ?? defaultDebugLogger;
+  const level = options?.level ?? "standard";
+  return {
+    getModes: wrapMethod("getModes", engine2.getModes, logger, level),
+    getExtraRules: wrapMethod(
+      "getExtraRules",
+      engine2.getExtraRules,
+      logger,
+      level
+    ),
+    createGame: wrapMethod("createGame", engine2.createGame, logger, level),
+    addPlayers: wrapMethod("addPlayers", engine2.addPlayers, logger, level),
+    addExtraRules: wrapMethod(
+      "addExtraRules",
+      engine2.addExtraRules,
+      logger,
+      level
+    ),
+    startGame: wrapMethod("startGame", engine2.startGame, logger, level),
+    chooseDomino: wrapMethod(
+      "chooseDomino",
+      engine2.chooseDomino,
+      logger,
+      level
+    ),
+    placeDomino: wrapMethod("placeDomino", engine2.placeDomino, logger, level),
+    discardDomino: wrapMethod(
+      "discardDomino",
+      engine2.discardDomino,
+      logger,
+      level
+    ),
+    getResults: wrapMethod("getResults", engine2.getResults, logger, level),
+    calculateScore: wrapMethod(
+      "calculateScore",
+      engine2.calculateScore,
+      logger,
+      level
+    ),
+    getValidPlacements: wrapMethod(
+      "getValidPlacements",
+      engine2.getValidPlacements,
+      logger,
+      level
+    ),
+    canPlaceDomino: wrapMethod(
+      "canPlaceDomino",
+      engine2.canPlaceDomino,
+      logger,
+      level
+    ),
+    serialize: wrapMethod("serialize", engine2.serialize, logger, level),
+    deserialize: wrapMethod("deserialize", engine2.deserialize, logger, level),
+    getDynastyResults: wrapMethod(
+      "getDynastyResults",
+      engine2.getDynastyResults,
+      logger,
+      level
+    ),
+    placeKnight: wrapMethod(
+      "placeKnight",
+      engine2.placeKnight,
+      logger,
+      level
+    ),
+    constructBuilding: wrapMethod(
+      "constructBuilding",
+      engine2.constructBuilding,
+      logger,
+      level
+    ),
+    useDragon: wrapMethod("useDragon", engine2.useDragon, logger, level),
+    skipOptionalAction: wrapMethod(
+      "skipOptionalAction",
+      engine2.skipOptionalAction,
+      logger,
+      level
+    )
+  };
+};
+
+// src/core/useCases/gameEvents.ts
+var isGameEnded = (game) => isGameWithNextStep(game) && game.nextAction.step === "result";
+var wrapWithEvents = (engine2, callbacks) => ({
+  // Read-only methods — pass through
+  getModes: (cmd) => engine2.getModes(cmd),
+  getExtraRules: (cmd) => engine2.getExtraRules(cmd),
+  calculateScore: (cmd) => engine2.calculateScore(cmd),
+  getValidPlacements: (cmd) => engine2.getValidPlacements(cmd),
+  canPlaceDomino: (cmd) => engine2.canPlaceDomino(cmd),
+  serialize: (cmd) => engine2.serialize(cmd),
+  deserialize: (cmd) => engine2.deserialize(cmd),
+  getResults: (cmd) => engine2.getResults(cmd),
+  getDynastyResults: (cmd) => engine2.getDynastyResults(cmd),
+  // State-changing methods — emit events after execution
+  createGame: (cmd) => {
+    const game = engine2.createGame(cmd);
+    callbacks.onGameCreated?.({ game });
+    return game;
+  },
+  addPlayers: (cmd) => {
+    const game = engine2.addPlayers(cmd);
+    callbacks.onPlayersAdded?.({ game });
+    return game;
+  },
+  addExtraRules: (cmd) => engine2.addExtraRules(cmd),
+  startGame: (cmd) => {
+    const game = engine2.startGame(cmd);
+    callbacks.onGameStarted?.({ game });
+    callbacks.onTurnStart?.({ game, turn: game.turn });
+    return game;
+  },
+  chooseDomino: (cmd) => {
+    const turnBefore = cmd.game.turn;
+    const game = engine2.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 = engine2.placeDomino(cmd);
+    callbacks.onDominoPlaced?.({ game, lordId: cmd.lordId });
+    if (isGameEnded(game)) {
+      callbacks.onGameEnd?.({ game });
+    }
+    return game;
+  },
+  discardDomino: (cmd) => {
+    const game = engine2.discardDomino(cmd);
+    callbacks.onDominoDiscarded?.({ game, lordId: cmd.lordId });
+    if (isGameEnded(game)) {
+      callbacks.onGameEnd?.({ game });
+    }
+    return game;
+  },
+  // Queendomino methods — pass through (no specific events yet)
+  placeKnight: (cmd) => engine2.placeKnight(cmd),
+  constructBuilding: (cmd) => engine2.constructBuilding(cmd),
+  useDragon: (cmd) => engine2.useDragon(cmd),
+  skipOptionalAction: (cmd) => engine2.skipOptionalAction(cmd)
+});
+
+// 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/buildings.json
+var buildings_default = [
+  { id: 1, name: "The Bakery", cost: 1, immediateBonus: { type: "coins", amount: 2 }, crowns: 0, towers: 0 },
+  { id: 2, name: "The Bakery", cost: 1, immediateBonus: { type: "coins", amount: 2 }, crowns: 0, towers: 0 },
+  { id: 3, name: "The Sawmill", cost: 2, crowns: 0, towers: 0, endGameScoring: { type: "perTerrain", terrain: "forest", points: 1 } },
+  { id: 4, name: "The Fishmonger's", cost: 2, immediateBonus: { type: "coins", amount: 1 }, crowns: 0, towers: 0, endGameScoring: { type: "perTerrain", terrain: "sea", points: 1 } },
+  { id: 5, name: "The Fishmonger's", cost: 2, immediateBonus: { type: "coins", amount: 1 }, crowns: 0, towers: 0, endGameScoring: { type: "perTerrain", terrain: "sea", points: 1 } },
+  { id: 6, name: "The Weaving Shop", cost: 3, crowns: 1, towers: 0, endGameScoring: { type: "perTerrain", terrain: "wheat", points: 1 } },
+  { id: 7, name: "The Magic School", cost: 4, crowns: 1, towers: 0, endGameScoring: { type: "perCrown", points: 1 } },
+  { id: 8, name: "The Fountain", cost: 3, crowns: 0, towers: 1, endGameScoring: { type: "perTower", points: 2 } },
+  { id: 9, name: "The Church", cost: 4, crowns: 1, towers: 0, endGameScoring: { type: "perBuilding", points: 2 } },
+  { id: 10, name: "The Bath", cost: 2, immediateBonus: { type: "coins", amount: 1 }, crowns: 0, towers: 0, endGameScoring: { type: "flat", points: 4 } },
+  { id: 11, name: "The Guard Tower", cost: 1, crowns: 0, towers: 1, endGameScoring: { type: "flat", points: 2 } },
+  { id: 12, name: "The Guard Tower", cost: 1, crowns: 0, towers: 1, endGameScoring: { type: "flat", points: 2 } },
+  { id: 13, name: "The Big Tower", cost: 3, crowns: 0, towers: 2, endGameScoring: { type: "flat", points: 4 } },
+  { id: 14, name: "The Guardhouse", cost: 2, crowns: 0, towers: 1, endGameScoring: { type: "perBuilding", points: 1 } },
+  { id: 15, name: "The Fortified Castle", cost: 5, crowns: 2, towers: 1, endGameScoring: { type: "flat", points: 6 } },
+  { id: 16, name: "The Travelling Castle", cost: 3, crowns: 1, towers: 1, endGameScoring: { type: "perTower", points: 1 } },
+  { id: 17, name: "The Travelling Group", cost: 2, immediateBonus: { type: "coins", amount: 1 }, crowns: 0, towers: 0, endGameScoring: { type: "perBuilding", points: 1 } },
+  { id: 18, name: "The Harbour", cost: 3, crowns: 0, towers: 0, endGameScoring: { type: "perTerrain", terrain: "sea", points: 2 } }
+];
+
+// src/adapterServerside/jsonBuildings.ts
+var jsonBuildings = () => {
+  const buildings = buildings_default.map((b) => {
+    const tile = {
+      id: b.id,
+      name: b.name,
+      cost: b.cost,
+      crowns: b.crowns,
+      towers: b.towers
+    };
+    if (b.immediateBonus) {
+      tile.immediateBonus = {
+        type: b.immediateBonus.type,
+        amount: b.immediateBonus.amount
+      };
+    }
+    if ("endGameScoring" in b && b.endGameScoring) {
+      tile.endGameScoring = {
+        type: b.endGameScoring.type,
+        points: b.endGameScoring.points,
+        ..."terrain" in b.endGameScoring && {
+          terrain: b.endGameScoring.terrain
+        }
+      };
+    }
+    return tile;
+  });
+  return {
+    getAll: () => buildings
+  };
+};
+var jsonBuildings_default = jsonBuildings;
+
+// 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
+    }
+  ],
+  QueenDomino: [
+    {
+      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: "sea",
+        crowns: 0
+      },
+      right: {
+        type: "sea",
+        crowns: 0
+      },
+      number: 5
+    },
+    {
+      left: {
+        type: "sea",
+        crowns: 0
+      },
+      right: {
+        type: "sea",
+        crowns: 0
+      },
+      number: 6
+    },
+    {
+      left: {
+        type: "plain",
+        crowns: 0
+      },
+      right: {
+        type: "plain",
+        crowns: 0
+      },
+      number: 7
+    },
+    {
+      left: {
+        type: "plain",
+        crowns: 0
+      },
+      right: {
+        type: "plain",
+        crowns: 0
+      },
+      number: 8
+    },
+    {
+      left: {
+        type: "swamp",
+        crowns: 0
+      },
+      right: {
+        type: "swamp",
+        crowns: 0
+      },
+      number: 9
+    },
+    {
+      left: {
+        type: "swamp",
+        crowns: 0
+      },
+      right: {
+        type: "swamp",
+        crowns: 0
+      },
+      number: 10
+    },
+    {
+      left: {
+        type: "mine",
+        crowns: 0
+      },
+      right: {
+        type: "mine",
+        crowns: 0
+      },
+      number: 11
+    },
+    {
+      left: {
+        type: "wheat",
+        crowns: 0
+      },
+      right: {
+        type: "forest",
+        crowns: 0
+      },
+      number: 12
+    },
+    {
+      left: {
+        type: "wheat",
+        crowns: 0,
+        hasConstructionSquare: true
+      },
+      right: {
+        type: "sea",
+        crowns: 0
+      },
+      number: 13
+    },
+    {
+      left: {
+        type: "wheat",
+        crowns: 0
+      },
+      right: {
+        type: "plain",
+        crowns: 0,
+        hasConstructionSquare: true
+      },
+      number: 14
+    },
+    {
+      left: {
+        type: "forest",
+        crowns: 0,
+        hasConstructionSquare: true
+      },
+      right: {
+        type: "sea",
+        crowns: 0
+      },
+      number: 15
+    },
+    {
+      left: {
+        type: "forest",
+        crowns: 0
+      },
+      right: {
+        type: "plain",
+        crowns: 0
+      },
+      number: 16
+    },
+    {
+      left: {
+        type: "sea",
+        crowns: 0
+      },
+      right: {
+        type: "plain",
+        crowns: 0,
+        hasConstructionSquare: true
+      },
+      number: 17
+    },
+    {
+      left: {
+        type: "wheat",
+        crowns: 0
+      },
+      right: {
+        type: "swamp",
+        crowns: 0
+      },
+      number: 18
+    },
+    {
+      left: {
+        type: "wheat",
+        crowns: 1,
+        hasConstructionSquare: true
+      },
+      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,
+        hasConstructionSquare: true
+      },
+      number: 21
+    },
+    {
+      left: {
+        type: "forest",
+        crowns: 1
+      },
+      right: {
+        type: "wheat",
+        crowns: 0,
+        hasConstructionSquare: true
+      },
+      number: 22
+    },
+    {
+      left: {
+        type: "forest",
+        crowns: 1
+      },
+      right: {
+        type: "sea",
+        crowns: 0
+      },
+      number: 23
+    },
+    {
+      left: {
+        type: "forest",
+        crowns: 1,
+        hasConstructionSquare: true
+      },
+      right: {
+        type: "plain",
+        crowns: 0
+      },
+      number: 24
+    },
+    {
+      left: {
+        type: "sea",
+        crowns: 1
+      },
+      right: {
+        type: "wheat",
+        crowns: 0
+      },
+      number: 25
+    },
+    {
+      left: {
+        type: "sea",
+        crowns: 1
+      },
+      right: {
+        type: "forest",
+        crowns: 0,
+        hasConstructionSquare: true
+      },
+      number: 26
+    },
+    {
+      left: {
+        type: "plain",
+        crowns: 1
+      },
+      right: {
+        type: "wheat",
+        crowns: 0
+      },
+      number: 27
+    },
+    {
+      left: {
+        type: "plain",
+        crowns: 1,
+        hasConstructionSquare: true
+      },
+      right: {
+        type: "forest",
+        crowns: 0
+      },
+      number: 28
+    },
+    {
+      left: {
+        type: "wheat",
+        crowns: 1
+      },
+      right: {
+        type: "mine",
+        crowns: 0
+      },
+      number: 29
+    },
+    {
+      left: {
+        type: "sea",
+        crowns: 1
+      },
+      right: {
+        type: "plain",
+        crowns: 0,
+        hasConstructionSquare: true
+      },
+      number: 30
+    },
+    {
+      left: {
+        type: "wheat",
+        crowns: 1,
+        hasConstructionSquare: true
+      },
+      right: {
+        type: "swamp",
+        crowns: 1
+      },
+      number: 31
+    },
+    {
+      left: {
+        type: "forest",
+        crowns: 1
+      },
+      right: {
+        type: "sea",
+        crowns: 1,
+        hasConstructionSquare: true
+      },
+      number: 32
+    },
+    {
+      left: {
+        type: "sea",
+        crowns: 1
+      },
+      right: {
+        type: "plain",
+        crowns: 1
+      },
+      number: 33
+    },
+    {
+      left: {
+        type: "plain",
+        crowns: 1,
+        hasConstructionSquare: true
+      },
+      right: {
+        type: "swamp",
+        crowns: 1
+      },
+      number: 34
+    },
+    {
+      left: {
+        type: "forest",
+        crowns: 1,
+        hasConstructionSquare: true
+      },
+      right: {
+        type: "mine",
+        crowns: 1
+      },
+      number: 35
+    },
+    {
+      left: {
+        type: "wheat",
+        crowns: 2,
+        hasConstructionSquare: true
+      },
+      right: {
+        type: "forest",
+        crowns: 0
+      },
+      number: 36
+    },
+    {
+      left: {
+        type: "sea",
+        crowns: 2
+      },
+      right: {
+        type: "wheat",
+        crowns: 0,
+        hasConstructionSquare: true
+      },
+      number: 37
+    },
+    {
+      left: {
+        type: "plain",
+        crowns: 2
+      },
+      right: {
+        type: "forest",
+        crowns: 0
+      },
+      number: 38
+    },
+    {
+      left: {
+        type: "swamp",
+        crowns: 2
+      },
+      right: {
+        type: "wheat",
+        crowns: 0
+      },
+      number: 39
+    },
+    {
+      left: {
+        type: "mine",
+        crowns: 2,
+        hasConstructionSquare: true
+      },
+      right: {
+        type: "wheat",
+        crowns: 0
+      },
+      number: 40
+    },
+    {
+      left: {
+        type: "wheat",
+        crowns: 2
+      },
+      right: {
+        type: "plain",
+        crowns: 2
+      },
+      number: 41
+    },
+    {
+      left: {
+        type: "sea",
+        crowns: 2
+      },
+      right: {
+        type: "forest",
+        crowns: 1,
+        hasConstructionSquare: true
+      },
+      number: 42
+    },
+    {
+      left: {
+        type: "swamp",
+        crowns: 2
+      },
+      right: {
+        type: "plain",
+        crowns: 1
+      },
+      number: 43
+    },
+    {
+      left: {
+        type: "mine",
+        crowns: 2
+      },
+      right: {
+        type: "swamp",
+        crowns: 1
+      },
+      number: 44
+    },
+    {
+      left: {
+        type: "wheat",
+        crowns: 2
+      },
+      right: {
+        type: "mine",
+        crowns: 2
+      },
+      number: 45
+    },
+    {
+      left: {
+        type: "forest",
+        crowns: 2
+      },
+      right: {
+        type: "mine",
+        crowns: 2,
+        hasConstructionSquare: true
+      },
+      number: 46
+    },
+    {
+      left: {
+        type: "swamp",
+        crowns: 2
+      },
+      right: {
+        type: "mine",
+        crowns: 3
+      },
+      number: 47
+    },
+    {
+      left: {
+        type: "plain",
+        crowns: 2
+      },
+      right: {
+        type: "mine",
+        crowns: 3
+      },
+      number: 48
+    }
+  ]
+};
+
+// src/adapterServerside/jsonDominoes.ts
+var mapTile = (raw) => {
+  const tile = {
+    type: raw.type,
+    crowns: raw.crowns
+  };
+  if (raw.hasConstructionSquare) {
+    tile.hasConstructionSquare = true;
+  }
+  return tile;
+};
+var jsonDominoes = () => {
+  const dominoes = {};
+  for (const [key, value] of Object.entries(dominoes_default)) {
+    const currentDominoes = [];
+    value.forEach((domino) => {
+      currentDominoes.push({
+        left: mapTile(domino.left),
+        right: mapTile(domino.right),
+        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"
+  },
+  {
+    name: "QueenDomino",
+    description: "Queendomino expansion with buildings, knights, coins, the Queen and the Dragon"
+  }
+];
+
+// 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: "QueenDomino", description: "Queendomino expansion with buildings, knights, coins, the Queen and the Dragon" }
+      ]
+    },
+    {
+      name: "Harmony",
+      description: "Gain 5 additional points if your kingdom is complete (no discarded dominoes).",
+      mode: [
+        { name: "Classic", description: "King Domino classic mode" },
+        { name: "QueenDomino", description: "Queendomino expansion with buildings, knights, coins, the Queen and the Dragon" }
+      ]
+    },
+    {
+      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" },
+        { name: "QueenDomino", description: "Queendomino expansion with buildings, knights, coins, the Queen and the Dragon" }
+      ],
+      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" },
+        { name: "QueenDomino", description: "Queendomino expansion with buildings, knights, coins, the Queen and the Dragon" }
+      ]
+    }
+  ]
+};
+
+// 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",
+  // Queendomino errors
+  CANNOT_PLACE_KNIGHT: "CANNOT_PLACE_KNIGHT",
+  MAX_KNIGHTS_REACHED: "MAX_KNIGHTS_REACHED",
+  KNIGHT_TERRITORY_OCCUPIED: "KNIGHT_TERRITORY_OCCUPIED",
+  CANNOT_AFFORD_BUILDING: "CANNOT_AFFORD_BUILDING",
+  NO_CONSTRUCTION_SQUARE: "NO_CONSTRUCTION_SQUARE",
+  DRAGON_UNAVAILABLE: "DRAGON_UNAVAILABLE",
+  QUEEN_HOLDER_CANNOT_USE_DRAGON: "QUEEN_HOLDER_CANNOT_USE_DRAGON",
+  BUILDING_NOT_FOUND: "BUILDING_NOT_FOUND",
+  INVALID_OPTIONAL_ACTION: "INVALID_OPTIONAL_ACTION"
+};
+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";
+  }
+};
+
+// 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",
+  // Queendomino errors
+  ERROR_CANNOT_PLACE_KNIGHT: "error.cannotPlaceKnight",
+  ERROR_MAX_KNIGHTS_REACHED: "error.maxKnightsReached",
+  ERROR_KNIGHT_TERRITORY_OCCUPIED: "error.knightTerritoryOccupied",
+  ERROR_CANNOT_AFFORD_BUILDING: "error.cannotAffordBuilding",
+  ERROR_NO_CONSTRUCTION_SQUARE: "error.noConstructionSquare",
+  ERROR_DRAGON_UNAVAILABLE: "error.dragonUnavailable",
+  ERROR_QUEEN_HOLDER_CANNOT_USE_DRAGON: "error.queenHolderCannotUseDragon",
+  ERROR_BUILDING_NOT_FOUND: "error.buildingNotFound",
+  ERROR_INVALID_OPTIONAL_ACTION: "error.invalidOptionalAction"
+};
+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",
+  // Queendomino errors
+  [TranslationKey.ERROR_CANNOT_PLACE_KNIGHT]: "Cannot place knight here",
+  [TranslationKey.ERROR_MAX_KNIGHTS_REACHED]: "Maximum number of knights reached (3)",
+  [TranslationKey.ERROR_KNIGHT_TERRITORY_OCCUPIED]: "This territory already has a knight",
+  [TranslationKey.ERROR_CANNOT_AFFORD_BUILDING]: "Not enough coins to purchase this building",
+  [TranslationKey.ERROR_NO_CONSTRUCTION_SQUARE]: "No open construction square available",
+  [TranslationKey.ERROR_DRAGON_UNAVAILABLE]: "The Dragon is not available this round",
+  [TranslationKey.ERROR_QUEEN_HOLDER_CANNOT_USE_DRAGON]: "The Queen holder cannot use the Dragon",
+  [TranslationKey.ERROR_BUILDING_NOT_FOUND]: "Building not found on the Builders Board",
+  [TranslationKey.ERROR_INVALID_OPTIONAL_ACTION]: "Invalid optional action for this game state"
+};
+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,
+  [ErrorCode.CANNOT_PLACE_KNIGHT]: TranslationKey.ERROR_CANNOT_PLACE_KNIGHT,
+  [ErrorCode.MAX_KNIGHTS_REACHED]: TranslationKey.ERROR_MAX_KNIGHTS_REACHED,
+  [ErrorCode.KNIGHT_TERRITORY_OCCUPIED]: TranslationKey.ERROR_KNIGHT_TERRITORY_OCCUPIED,
+  [ErrorCode.CANNOT_AFFORD_BUILDING]: TranslationKey.ERROR_CANNOT_AFFORD_BUILDING,
+  [ErrorCode.NO_CONSTRUCTION_SQUARE]: TranslationKey.ERROR_NO_CONSTRUCTION_SQUARE,
+  [ErrorCode.DRAGON_UNAVAILABLE]: TranslationKey.ERROR_DRAGON_UNAVAILABLE,
+  [ErrorCode.QUEEN_HOLDER_CANNOT_USE_DRAGON]: TranslationKey.ERROR_QUEEN_HOLDER_CANNOT_USE_DRAGON,
+  [ErrorCode.BUILDING_NOT_FOUND]: TranslationKey.ERROR_BUILDING_NOT_FOUND,
+  [ErrorCode.INVALID_OPTIONAL_ACTION]: TranslationKey.ERROR_INVALID_OPTIONAL_ACTION
+};
+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}`);
+  }
+};
+
+// 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/application/handlers/placeKnightHandler.ts
+var placeKnightHandler = (logger, translator, useCase) => (command) => {
+  const { game, lordId, position } = command;
+  logger.info(
+    `Placing knight for lord: ${lordId} at position: ${JSON.stringify(
+      position
+    )} in game: ${game.id}`
+  );
+  if (game.nextAction.nextAction !== "placeKnight") {
+    logger.error(
+      `Required game with placeKnight action but got: ${game.nextAction.nextAction}`
+    );
+    throw new InvalidStepError(
+      translateErrorCode(translator, ErrorCode.INVALID_STEP),
+      {
+        expected: "placeKnight",
+        actual: game.nextAction.nextAction,
+        gameId: game.id
+      }
+    );
+  }
+  const result = useCase(game, lordId, position);
+  if (isErr(result)) {
+    logger.error(`Error placing knight: ${result.error}`);
+    const code = result.error;
+    throw new ActionExecutionError(
+      translateErrorCode(translator, code),
+      code,
+      {
+        gameId: game.id,
+        lordId: command.lordId,
+        position: command.position
+      }
+    );
+  }
+  logger.info(
+    `Knight placed for lord: ${lordId} at position: ${JSON.stringify(
+      position
+    )} in game: ${game.id}`
+  );
+  return result.value;
+};
+
+// src/application/handlers/constructBuildingHandler.ts
+var constructBuildingHandler = (logger, translator, useCase) => (command) => {
+  const { game, lordId, buildingId, position } = command;
+  logger.info(
+    `Constructing building: ${buildingId} for lord: ${lordId} at position: ${JSON.stringify(
+      position
+    )} in game: ${game.id}`
+  );
+  if (game.nextAction.nextAction !== "constructBuilding") {
+    logger.error(
+      `Required game with constructBuilding action but got: ${game.nextAction.nextAction}`
+    );
+    throw new InvalidStepError(
+      translateErrorCode(translator, ErrorCode.INVALID_STEP),
+      {
+        expected: "constructBuilding",
+        actual: game.nextAction.nextAction,
+        gameId: game.id
+      }
+    );
+  }
+  const result = useCase(game, lordId, buildingId, position);
+  if (isErr(result)) {
+    logger.error(`Error constructing building: ${result.error}`);
+    const code = result.error;
+    throw new ActionExecutionError(
+      translateErrorCode(translator, code),
+      code,
+      {
+        gameId: game.id,
+        lordId: command.lordId,
+        buildingId: command.buildingId,
+        position: command.position
+      }
+    );
+  }
+  logger.info(
+    `Building constructed: ${buildingId} for lord: ${lordId} at position: ${JSON.stringify(
+      position
+    )} in game: ${game.id}`
+  );
+  return result.value;
+};
+
+// src/application/handlers/useDragonHandler.ts
+var useDragonHandler = (logger, translator, useCase) => (command) => {
+  const { game, lordId, buildingId } = command;
+  logger.info(
+    `Using dragon on building: ${buildingId} for lord: ${lordId} in game: ${game.id}`
+  );
+  if (game.nextAction.nextAction !== "useDragon") {
+    logger.error(
+      `Required game with useDragon action but got: ${game.nextAction.nextAction}`
+    );
+    throw new InvalidStepError(
+      translateErrorCode(translator, ErrorCode.INVALID_STEP),
+      {
+        expected: "useDragon",
+        actual: game.nextAction.nextAction,
+        gameId: game.id
+      }
+    );
+  }
+  const result = useCase(game, lordId, buildingId);
+  if (isErr(result)) {
+    logger.error(`Error using dragon: ${result.error}`);
+    const code = result.error;
+    throw new ActionExecutionError(
+      translateErrorCode(translator, code),
+      code,
+      {
+        gameId: game.id,
+        lordId: command.lordId,
+        buildingId: command.buildingId
+      }
+    );
+  }
+  logger.info(
+    `Dragon used on building: ${buildingId} for lord: ${lordId} in game: ${game.id}`
+  );
+  return result.value;
+};
+
+// src/application/handlers/skipOptionalActionHandler.ts
+var skipOptionalActionHandler = (logger, translator, useCase) => (command) => {
+  const { game, lordId } = command;
+  logger.info(
+    `Skipping optional action for lord: ${lordId} in game: ${game.id}`
+  );
+  const result = useCase(game, lordId);
+  if (isErr(result)) {
+    logger.error(`Error skipping optional action: ${result.error}`);
+    const code = result.error;
+    throw new ActionExecutionError(
+      translateErrorCode(translator, code),
+      code,
+      { gameId: game.id, lordId: command.lordId }
+    );
+  }
+  logger.info(
+    `Optional action skipped for lord: ${lordId} in game: ${game.id}`
+  );
+  return result.value;
+};
+
+// src/core/domain/types/domino.ts
+var GROUND = [
+  "castle",
+  "wheat",
+  "forest",
+  "sea",
+  "plain",
+  "swamp",
+  "mine"
+];
+
+// src/core/domain/types/kingdom.ts
+var GRIDSIZE = 9;
+var MAX_KINGDOM_SIZE = 5;
+
+// 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",
+  /** Place a knight on the just-placed domino (Queendomino, optional) */
+  placeKnight: "placeKnight",
+  /** Construct a building on a construction square (Queendomino, optional) */
+  constructBuilding: "constructBuilding",
+  /** Use the Dragon to burn a building tile (Queendomino, optional) */
+  useDragon: "useDragon",
+  /** Skip the current optional action (Queendomino) */
+  skipOptionalAction: "skipOptionalAction"
+};
+
+// 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/economy.ts
+var STARTING_COINS = 7;
+var MAX_KNIGHTS = 3;
+var addCoins = (player, amount) => ({
+  ...player,
+  coins: (player.coins ?? 0) + amount
+});
+var removeCoins = (player, amount) => ({
+  ...player,
+  coins: (player.coins ?? 0) - amount
+});
+var canAfford = (player, cost) => (player.coins ?? 0) >= cost;
+var addTowers = (player, amount) => ({
+  ...player,
+  towers: (player.towers ?? 0) + amount
+});
+var getTowerCount = (player) => player.towers ?? 0;
+
+// 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 = (input2) => {
+  if (typeof input2 === "string") {
+    return { name: input2 };
+  }
+  return { name: input2.name, bot: input2.bot };
+};
+var addPlayersUseCase = (deps) => (game, players) => {
+  const { uuidMethod: uuidMethod3, 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 = uuidMethod3();
+    const newPlayer = createPlayer(name, id, kingdom, bot);
+    if (isErr(newPlayer)) {
+      return newPlayer;
+    }
+    if (game.mode.name === "QueenDomino") {
+      newPlayer.value.coins = STARTING_COINS;
+      newPlayer.value.towers = 0;
+      newPlayer.value.knights = [];
+      newPlayer.value.buildings = [];
+    }
+    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);
+};
+var QUEENDOMINO_ACTION_SEQUENCE = [
+  playerActions.placeKnight,
+  playerActions.constructBuilding,
+  playerActions.useDragon,
+  playerActions.pickDomino
+];
+var nextQueenDominoAction = (currentAction) => {
+  const index = QUEENDOMINO_ACTION_SEQUENCE.indexOf(currentAction);
+  if (index === -1 || index >= QUEENDOMINO_ACTION_SEQUENCE.length - 1) {
+    return playerActions.pickDomino;
+  }
+  return QUEENDOMINO_ACTION_SEQUENCE[index + 1];
+};
+
+// 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, buildings } = payload;
+  let queendomino;
+  if (mode.name === "QueenDomino" && buildings) {
+    queendomino = {
+      buildersBoard: {
+        slots: [],
+        drawPile: buildings
+      },
+      queenHolderId: null,
+      dragonAvailable: true,
+      dragonUsedThisRound: false
+    };
+  }
+  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 },
+    ...queendomino !== void 0 && { queendomino }
+  };
+};
+
+// 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: uuidMethod3, buildingsRepository } = deps;
+  const id = uuidMethod3();
+  const gameSeed = seed ?? uuidMethod3();
+  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 isQueenDomino = newMode.value.name === "QueenDomino";
+  let buildings;
+  if (isQueenDomino && buildingsRepository) {
+    buildings = buildingsRepository.getAll();
+  }
+  const payload = {
+    id,
+    mode: newMode.value,
+    dominoes,
+    seed: gameSeed,
+    buildings
+  };
+  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
+  };
+  const isQueenDomino = game.mode.name === "QueenDomino";
+  if (isLastTurn && allLordsHavePlayed(updatedLords)) {
+    updatedGame = {
+      ...game,
+      lords: updatedLords,
+      nextAction: resultStep,
+      players: updatedPlayers
+    };
+  } else if (isQueenDomino && !isLastTurn) {
+    updatedGame = {
+      ...game,
+      lords: updatedLords,
+      nextAction: {
+        type: "action",
+        nextLord: currentLord.id,
+        nextAction: playerActions.placeKnight
+      },
+      players: updatedPlayers
+    };
+  } else if (isQueenDomino && isLastTurn) {
+    const queenDominoAction = {
+      type: "action",
+      nextLord: currentLord.id,
+      nextAction: playerActions.placeKnight
+    };
+    updatedGame = {
+      ...game,
+      lords: updatedLords,
+      nextAction: queenDominoAction,
+      players: updatedPlayers
+    };
+  } else {
+    updatedGame = {
+      ...game,
+      lords: updatedLords,
+      nextAction: nextLordWithAction(updatedLords),
+      players: updatedPlayers
+    };
+  }
+  return ok(updatedGame);
+};
+
+// src/core/domain/entities/knight.ts
+var countConstructionSquaresInTerritory = (kingdom, position) => {
+  const rows = kingdom.length;
+  const cols = kingdom[0]?.length ?? 0;
+  const startTile = kingdom[position.y]?.[position.x];
+  if (!startTile || startTile.type === "empty" || startTile.type === "castle") {
+    return 0;
+  }
+  const terrainType = startTile.type;
+  const visited = kingdom.map((row) => row.map(() => false));
+  const queue = [[position.x, position.y]];
+  visited[position.y][position.x] = true;
+  let count = 0;
+  const directions = [
+    [-1, 0],
+    [1, 0],
+    [0, -1],
+    [0, 1]
+  ];
+  while (queue.length > 0) {
+    const [cx, cy] = queue.pop();
+    const tile = kingdom[cy][cx];
+    if (tile.type !== "empty" && tile.type !== "castle" && "hasConstructionSquare" in tile && tile.hasConstructionSquare) {
+      count++;
+    }
+    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 === terrainType) {
+        visited[ny][nx] = true;
+        queue.push([nx, ny]);
+      }
+    }
+  }
+  return count;
+};
+var getTerritoryTerrain = (kingdom, position) => {
+  const tile = kingdom[position.y]?.[position.x];
+  if (!tile || tile.type === "empty" || tile.type === "castle") return null;
+  return tile.type;
+};
+var territoryHasKnight = (kingdom, position, knights) => {
+  const terrain = getTerritoryTerrain(kingdom, position);
+  if (!terrain) return false;
+  const rows = kingdom.length;
+  const cols = kingdom[0]?.length ?? 0;
+  const visited = kingdom.map((row) => row.map(() => false));
+  const queue = [[position.x, position.y]];
+  visited[position.y][position.x] = true;
+  const territoryPositions = /* @__PURE__ */ new Set();
+  const directions = [
+    [-1, 0],
+    [1, 0],
+    [0, -1],
+    [0, 1]
+  ];
+  while (queue.length > 0) {
+    const [cx, cy] = queue.pop();
+    territoryPositions.add(`${cx},${cy}`);
+    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 === terrain) {
+        visited[ny][nx] = true;
+        queue.push([nx, ny]);
+      }
+    }
+  }
+  return knights.some(
+    (k) => territoryPositions.has(`${k.position.x},${k.position.y}`)
+  );
+};
+var canPlaceKnight = (player, kingdom, position) => {
+  const knights = player.knights ?? [];
+  if (knights.length >= MAX_KNIGHTS) return false;
+  const tile = kingdom[position.y]?.[position.x];
+  if (!tile || tile.type === "empty" || tile.type === "castle") return false;
+  if (territoryHasKnight(kingdom, position, knights)) return false;
+  return true;
+};
+var placeKnight = (player, kingdom, position) => {
+  const knight = { playerId: player.id, position };
+  const knights = [...player.knights ?? [], knight];
+  const taxAmount = countConstructionSquaresInTerritory(kingdom, position);
+  const updatedPlayer = addCoins({ ...player, knights }, taxAmount);
+  return updatedPlayer;
+};
+
+// src/core/useCases/placeKnight.ts
+var placeKnightUseCase = (game, lordId, position) => {
+  const currentAction = game.nextAction;
+  if (currentAction.nextLord !== lordId) {
+    return err(ErrorCode.NOT_YOUR_TURN);
+  }
+  if (currentAction.nextAction !== playerActions.placeKnight) {
+    return err(ErrorCode.INVALID_OPTIONAL_ACTION);
+  }
+  const currentLord = game.lords.find((l) => l.id === lordId);
+  if (!currentLord) return err(ErrorCode.LORD_NOT_FOUND);
+  const currentPlayer = game.players.find(
+    (p) => p.id === currentLord.playerId
+  );
+  if (!currentPlayer) return err(ErrorCode.PLAYER_NOT_FOUND);
+  if (!canPlaceKnight(currentPlayer, currentPlayer.kingdom, position)) {
+    return err(ErrorCode.CANNOT_PLACE_KNIGHT);
+  }
+  const updatedPlayer = placeKnight(
+    currentPlayer,
+    currentPlayer.kingdom,
+    position
+  );
+  const updatedPlayers = game.players.map(
+    (p) => p.id === currentPlayer.id ? updatedPlayer : p
+  );
+  const nextAction = nextQueenDominoAction(playerActions.placeKnight);
+  return ok({
+    ...game,
+    players: updatedPlayers,
+    nextAction: {
+      type: "action",
+      nextLord: lordId,
+      nextAction
+    }
+  });
+};
+
+// src/core/domain/entities/building.ts
+var BOARD_SLOTS = 4;
+var createBuildersBoard = (tiles, shuffle) => {
+  const shuffled = shuffle([...tiles]);
+  const slots = shuffled.slice(0, BOARD_SLOTS);
+  const drawPile = shuffled.slice(BOARD_SLOTS);
+  return {
+    slots,
+    drawPile
+  };
+};
+var findBuildingOnBoard = (board, buildingId) => {
+  for (let i = 0; i < board.slots.length; i++) {
+    const slot = board.slots[i];
+    if (slot && slot.id === buildingId) {
+      return { building: slot, slotIndex: i };
+    }
+  }
+  return null;
+};
+var removeBuildingFromBoard = (board, slotIndex) => {
+  const newSlots = [...board.slots];
+  newSlots[slotIndex] = null;
+  return { ...board, slots: newSlots };
+};
+var purchaseBuilding = (board, player, buildingId) => {
+  const found = findBuildingOnBoard(board, buildingId);
+  if (!found) return null;
+  const { building, slotIndex } = found;
+  if (!canAfford(player, building.cost)) return null;
+  let updatedPlayer = removeCoins(player, building.cost);
+  if (building.immediateBonus) {
+    switch (building.immediateBonus.type) {
+      case "coins":
+        updatedPlayer = addCoins(updatedPlayer, building.immediateBonus.amount);
+        break;
+      case "tower":
+        updatedPlayer = addTowers(
+          updatedPlayer,
+          building.immediateBonus.amount
+        );
+        break;
+    }
+  }
+  if (building.towers > 0) {
+    updatedPlayer = addTowers(updatedPlayer, building.towers);
+  }
+  const updatedBoard = removeBuildingFromBoard(board, slotIndex);
+  return { updatedBoard, updatedPlayer, building };
+};
+var isValidConstructionPosition = (kingdom, placedBuildings, position) => {
+  const tile = kingdom[position.y]?.[position.x];
+  if (!tile || tile.type === "empty" || tile.type === "castle") return false;
+  if (!("hasConstructionSquare" in tile) || !tile.hasConstructionSquare)
+    return false;
+  const occupied = placedBuildings.some(
+    (b) => b.position.x === position.x && b.position.y === position.y
+  );
+  return !occupied;
+};
+var placeBuildingOnKingdom = (kingdom, building, position) => {
+  const newKingdom = kingdom.map((row) => [...row]);
+  const tile = newKingdom[position.y][position.x];
+  if (tile.type !== "empty" && tile.type !== "castle") {
+    newKingdom[position.y][position.x] = {
+      ...tile,
+      crowns: tile.crowns + building.crowns
+    };
+  }
+  return newKingdom;
+};
+var destroyWithDragon = (board, buildingId, player) => {
+  const found = findBuildingOnBoard(board, buildingId);
+  if (!found) return null;
+  const { building, slotIndex } = found;
+  if (!canAfford(player, building.cost)) return null;
+  const updatedPlayer = removeCoins(player, building.cost);
+  const updatedBoard = removeBuildingFromBoard(board, slotIndex);
+  return { updatedBoard, updatedPlayer };
+};
+
+// src/core/domain/entities/queen.ts
+var determineQueenHolder = (players, currentHolderId) => {
+  let maxTowers = 0;
+  let leaderId = null;
+  let isTied = false;
+  for (const player of players) {
+    const towers = getTowerCount(player);
+    if (towers > maxTowers) {
+      maxTowers = towers;
+      leaderId = player.id;
+      isTied = false;
+    } else if (towers === maxTowers && towers > 0 && leaderId !== null) {
+      isTied = true;
+    }
+  }
+  if (isTied || maxTowers === 0) {
+    return currentHolderId;
+  }
+  return leaderId;
+};
+
+// src/core/useCases/constructBuilding.ts
+var constructBuildingUseCase = (game, lordId, buildingId, position) => {
+  const currentAction = game.nextAction;
+  if (currentAction.nextLord !== lordId) {
+    return err(ErrorCode.NOT_YOUR_TURN);
+  }
+  if (currentAction.nextAction !== playerActions.constructBuilding) {
+    return err(ErrorCode.INVALID_OPTIONAL_ACTION);
+  }
+  if (!game.queendomino) {
+    return err(ErrorCode.INVALID_OPTIONAL_ACTION);
+  }
+  const currentLord = game.lords.find((l) => l.id === lordId);
+  if (!currentLord) return err(ErrorCode.LORD_NOT_FOUND);
+  const currentPlayer = game.players.find(
+    (p) => p.id === currentLord.playerId
+  );
+  if (!currentPlayer) return err(ErrorCode.PLAYER_NOT_FOUND);
+  if (!isValidConstructionPosition(
+    currentPlayer.kingdom,
+    currentPlayer.buildings ?? [],
+    position
+  )) {
+    return err(ErrorCode.NO_CONSTRUCTION_SQUARE);
+  }
+  const purchaseResult = purchaseBuilding(
+    game.queendomino.buildersBoard,
+    currentPlayer,
+    buildingId
+  );
+  if (!purchaseResult) {
+    return err(ErrorCode.CANNOT_AFFORD_BUILDING);
+  }
+  const { updatedBoard, updatedPlayer, building } = purchaseResult;
+  const updatedKingdom = placeBuildingOnKingdom(
+    updatedPlayer.kingdom,
+    building,
+    position
+  );
+  const placedBuilding = { building, position };
+  const finalPlayer = {
+    ...updatedPlayer,
+    kingdom: updatedKingdom,
+    buildings: [...updatedPlayer.buildings ?? [], placedBuilding]
+  };
+  const updatedPlayers = game.players.map(
+    (p) => p.id === currentPlayer.id ? finalPlayer : p
+  );
+  const newQueenHolder = determineQueenHolder(
+    updatedPlayers,
+    game.queendomino.queenHolderId
+  );
+  const nextAction = nextQueenDominoAction(playerActions.constructBuilding);
+  return ok({
+    ...game,
+    players: updatedPlayers,
+    queendomino: {
+      ...game.queendomino,
+      buildersBoard: updatedBoard,
+      queenHolderId: newQueenHolder
+    },
+    nextAction: {
+      type: "action",
+      nextLord: lordId,
+      nextAction
+    }
+  });
+};
+
+// src/core/useCases/useDragon.ts
+var useDragonUseCase = (game, lordId, buildingId) => {
+  const currentAction = game.nextAction;
+  if (currentAction.nextLord !== lordId) {
+    return err(ErrorCode.NOT_YOUR_TURN);
+  }
+  if (currentAction.nextAction !== playerActions.useDragon) {
+    return err(ErrorCode.INVALID_OPTIONAL_ACTION);
+  }
+  if (!game.queendomino) {
+    return err(ErrorCode.INVALID_OPTIONAL_ACTION);
+  }
+  if (!game.queendomino.dragonAvailable || game.queendomino.dragonUsedThisRound) {
+    return err(ErrorCode.DRAGON_UNAVAILABLE);
+  }
+  const currentLord = game.lords.find((l) => l.id === lordId);
+  if (!currentLord) return err(ErrorCode.LORD_NOT_FOUND);
+  const currentPlayer = game.players.find(
+    (p) => p.id === currentLord.playerId
+  );
+  if (!currentPlayer) return err(ErrorCode.PLAYER_NOT_FOUND);
+  if (game.queendomino.queenHolderId === currentPlayer.id) {
+    return err(ErrorCode.QUEEN_HOLDER_CANNOT_USE_DRAGON);
+  }
+  const result = destroyWithDragon(
+    game.queendomino.buildersBoard,
+    buildingId,
+    currentPlayer
+  );
+  if (!result) {
+    return err(ErrorCode.BUILDING_NOT_FOUND);
+  }
+  const { updatedBoard, updatedPlayer } = result;
+  const updatedPlayers = game.players.map(
+    (p) => p.id === currentPlayer.id ? updatedPlayer : p
+  );
+  const maxTurns = game.rules.basic.maxTurns;
+  const isLastTurn = game.turn === maxTurns;
+  if (isLastTurn && allLordsHavePlayed(game.lords)) {
+    return ok({
+      ...game,
+      players: updatedPlayers,
+      queendomino: {
+        ...game.queendomino,
+        buildersBoard: updatedBoard,
+        dragonUsedThisRound: true
+      },
+      nextAction: { type: "step", step: gameSteps.result }
+    });
+  }
+  return ok({
+    ...game,
+    players: updatedPlayers,
+    queendomino: {
+      ...game.queendomino,
+      buildersBoard: updatedBoard,
+      dragonUsedThisRound: true
+    },
+    nextAction: nextLordWithAction(game.lords)
+  });
+};
+
+// src/core/useCases/skipOptionalAction.ts
+var skipOptionalActionUseCase = (game, lordId) => {
+  const currentAction = game.nextAction;
+  if (currentAction.nextLord !== lordId) {
+    return err(ErrorCode.NOT_YOUR_TURN);
+  }
+  const action = currentAction.nextAction;
+  const isOptional = action === playerActions.placeKnight || action === playerActions.constructBuilding || action === playerActions.useDragon;
+  if (!isOptional) {
+    return err(ErrorCode.INVALID_OPTIONAL_ACTION);
+  }
+  const nextAction = nextQueenDominoAction(action);
+  if (nextAction === playerActions.pickDomino) {
+    const maxTurns = game.rules.basic.maxTurns;
+    const isLastTurn = game.turn === maxTurns;
+    if (isLastTurn && allLordsHavePlayed(game.lords)) {
+      return ok({
+        ...game,
+        nextAction: { type: "step", step: gameSteps.result }
+      });
+    }
+    return ok({
+      ...game,
+      nextAction: nextLordWithAction(game.lords)
+    });
+  }
+  return ok({
+    ...game,
+    nextAction: {
+      type: "action",
+      nextLord: lordId,
+      nextAction
+    }
+  });
+};
+
+// src/core/useCases/startGame.ts
+var startGameUseCase = (deps) => (game) => {
+  const { uuidMethod: uuidMethod3, 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(uuidMethod3(), 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
+  };
+  let queendomino = game.queendomino;
+  if (queendomino && game.mode.name === "QueenDomino") {
+    const buildingShuffle = game.seed ? createSeededShuffle(game.seed, "buildings") : shuffleMethod2;
+    const board = createBuildersBoard(
+      queendomino.buildersBoard.drawPile,
+      buildingShuffle
+    );
+    queendomino = { ...queendomino, buildersBoard: board };
+  }
+  const newState = {
+    ...game,
+    lords: shuffledLords,
+    nextAction,
+    dominoes: dominoesCopy,
+    currentDominoes: dominoesDrawn.map((domino, index) => {
+      return {
+        domino,
+        picked: false,
+        lordId: null,
+        position: index + 1
+      };
+    }),
+    ...queendomino !== void 0 && { queendomino }
+  };
+  return ok(newState);
+};
+
+// src/config.ts
+var configureEngine = (config) => {
+  const modeRepository = jsonModes_default();
+  const dominoesRepository = jsonDominoes_default();
+  const buildingsRepository = jsonBuildings_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,
+        buildingsRepository
+      })
+    ),
+    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
+    ),
+    placeKnightHandler: placeKnightHandler(
+      logger,
+      translator,
+      placeKnightUseCase
+    ),
+    constructBuildingHandler: constructBuildingHandler(
+      logger,
+      translator,
+      constructBuildingUseCase
+    ),
+    useDragonHandler: useDragonHandler(
+      logger,
+      translator,
+      useDragonUseCase
+    ),
+    skipOptionalActionHandler: skipOptionalActionHandler(
+      logger,
+      translator,
+      skipOptionalActionUseCase
+    )
+  };
+};
+
+// src/core/domain/entities/validateGameState.ts
+var validGrounds = /* @__PURE__ */ new Set([...GROUND, "empty"]);
+var validPlayerActions = new Set(Object.values(playerActions));
+var validGameSteps = new Set(Object.values(gameSteps));
+
+// 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,
+    placeKnightHandler: placeKnightHandler2,
+    constructBuildingHandler: constructBuildingHandler2,
+    useDragonHandler: useDragonHandler2,
+    skipOptionalActionHandler: skipOptionalActionHandler2
+  } = configureEngine(config);
+  let engine2 = {
+    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),
+    placeKnight: (command) => placeKnightHandler2(command),
+    constructBuilding: (command) => constructBuildingHandler2(command),
+    useDragon: (command) => useDragonHandler2(command),
+    skipOptionalAction: (command) => skipOptionalActionHandler2(command)
+  };
+  if (config.events) {
+    engine2 = wrapWithEvents(engine2, config.events);
+  }
+  if (config.debug) {
+    const debugOptions = typeof config.debug === "object" ? config.debug : void 0;
+    engine2 = wrapWithDebug(engine2, debugOptions);
+  }
+  return engine2;
+};
+
+// src/wasm/dispatch.ts
+var ENGINE_METHODS = /* @__PURE__ */ new Set([
+  "getModes",
+  "getExtraRules",
+  "createGame",
+  "addPlayers",
+  "addExtraRules",
+  "startGame",
+  "chooseDomino",
+  "placeDomino",
+  "discardDomino",
+  "getResults",
+  "calculateScore",
+  "getValidPlacements",
+  "canPlaceDomino",
+  "serialize",
+  "deserialize",
+  "getDynastyResults"
+]);
+var dispatch = (engine2, request2) => {
+  const { method, params } = request2;
+  if (!ENGINE_METHODS.has(method)) {
+    return {
+      error: {
+        code: "UNKNOWN_METHOD",
+        message: `Unknown method: ${method}`
+      }
+    };
+  }
+  try {
+    const fn = engine2[method];
+    const result = fn(params);
+    return { result };
+  } catch (err3) {
+    const code = isDomainException(err3) ? err3.code : "INTERNAL_ERROR";
+    const message = err3 instanceof Error ? err3.message : String(err3);
+    return { error: { code, message } };
+  }
+};
+var isDomainException = (err3) => {
+  return err3 instanceof Error && "code" in err3 && typeof err3.code === "string";
+};
+
+// src/wasm/bridge.ts
+var uuidFallback = () => "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
+  const r = Math.random() * 16 | 0;
+  return (c === "x" ? r : r & 3 | 8).toString(16);
+});
+var uuidMethod2 = typeof globalThis.crypto?.randomUUID === "function" ? () => globalThis.crypto.randomUUID() : uuidFallback;
+var engine = createGameEngine({ uuidMethod: uuidMethod2 });
+var chunks = [];
+var buf = new Uint8Array(4096);
+for (; ; ) {
+  const bytesRead = Javy.IO.readSync(0, buf);
+  if (bytesRead <= 0) break;
+  chunks.push(buf.slice(0, bytesRead));
+}
+var decoder = new TextDecoder();
+var input = chunks.map((c) => decoder.decode(c)).join("");
+var request = JSON.parse(input);
+var response = dispatch(engine, request);
+var encoder = new TextEncoder();
+Javy.IO.writeSync(1, encoder.encode(JSON.stringify(response)));