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

@pompidup/kingdomino-engine 3.2.0 → 3.3.0

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

Files changed (5) hide show

package/dist/index.js +1 -2
package/dist/index.js.map +1 -1
package/dist/index.universal.js +3805 -0
package/dist/wasm-bridge.js +2928 -0
package/package.json +3 -2

package/dist/wasm-bridge.js ADDED Viewed

@@ -0,0 +1,2928 @@
+// 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
+    )
+  };
+};
+// 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;
+  }
+});
+// src/adapterServerside/consoleLogger.ts
+var consoleLogger = (isLoggingEnabled) => {
+  const formatMessage = (level, message) => {
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+    return `${timestamp} [KDomino_Engine] ${level}: ${message}`;
+  };
+  return {
+    info: (message) => {
+      if (isLoggingEnabled) {
+        console.log(formatMessage("info", message));
+      }
+    },
+    error: (message) => {
+      if (isLoggingEnabled) {
+        console.error(formatMessage("error", message));
+      }
+    }
+  };
+};
+var silentLogger = {
+  info: () => {
+  },
+  error: () => {
+  }
+};
+// src/datasources/dominoes.json
+var dominoes_default = {
+  Classic: [
+    {
+      left: {
+        type: "wheat",
+        crowns: 0
+      },
+      right: {
+        type: "wheat",
+        crowns: 0
+      },
+      number: 1
+    },
+    {
+      left: {
+        type: "wheat",
+        crowns: 0
+      },
+      right: {
+        type: "wheat",
+        crowns: 0
+      },
+      number: 2
+    },
+    {
+      left: {
+        type: "forest",
+        crowns: 0
+      },
+      right: {
+        type: "forest",
+        crowns: 0
+      },
+      number: 3
+    },
+    {
+      left: {
+        type: "forest",
+        crowns: 0
+      },
+      right: {
+        type: "forest",
+        crowns: 0
+      },
+      number: 4
+    },
+    {
+      left: {
+        type: "forest",
+        crowns: 0
+      },
+      right: {
+        type: "forest",
+        crowns: 0
+      },
+      number: 5
+    },
+    {
+      left: {
+        type: "forest",
+        crowns: 0
+      },
+      right: {
+        type: "forest",
+        crowns: 0
+      },
+      number: 6
+    },
+    {
+      left: {
+        type: "sea",
+        crowns: 0
+      },
+      right: {
+        type: "sea",
+        crowns: 0
+      },
+      number: 7
+    },
+    {
+      left: {
+        type: "sea",
+        crowns: 0
+      },
+      right: {
+        type: "sea",
+        crowns: 0
+      },
+      number: 8
+    },
+    {
+      left: {
+        type: "sea",
+        crowns: 0
+      },
+      right: {
+        type: "sea",
+        crowns: 0
+      },
+      number: 9
+    },
+    {
+      left: {
+        type: "plain",
+        crowns: 0
+      },
+      right: {
+        type: "plain",
+        crowns: 0
+      },
+      number: 10
+    },
+    {
+      left: {
+        type: "plain",
+        crowns: 0
+      },
+      right: {
+        type: "plain",
+        crowns: 0
+      },
+      number: 11
+    },
+    {
+      left: {
+        type: "swamp",
+        crowns: 0
+      },
+      right: {
+        type: "swamp",
+        crowns: 0
+      },
+      number: 12
+    },
+    {
+      left: {
+        type: "wheat",
+        crowns: 0
+      },
+      right: {
+        type: "forest",
+        crowns: 0
+      },
+      number: 13
+    },
+    {
+      left: {
+        type: "wheat",
+        crowns: 0
+      },
+      right: {
+        type: "sea",
+        crowns: 0
+      },
+      number: 14
+    },
+    {
+      left: {
+        type: "wheat",
+        crowns: 0
+      },
+      right: {
+        type: "plain",
+        crowns: 0
+      },
+      number: 15
+    },
+    {
+      left: {
+        type: "wheat",
+        crowns: 0
+      },
+      right: {
+        type: "swamp",
+        crowns: 0
+      },
+      number: 16
+    },
+    {
+      left: {
+        type: "forest",
+        crowns: 0
+      },
+      right: {
+        type: "sea",
+        crowns: 0
+      },
+      number: 17
+    },
+    {
+      left: {
+        type: "forest",
+        crowns: 0
+      },
+      right: {
+        type: "plain",
+        crowns: 0
+      },
+      number: 18
+    },
+    {
+      left: {
+        type: "wheat",
+        crowns: 1
+      },
+      right: {
+        type: "forest",
+        crowns: 0
+      },
+      number: 19
+    },
+    {
+      left: {
+        type: "wheat",
+        crowns: 1
+      },
+      right: {
+        type: "sea",
+        crowns: 0
+      },
+      number: 20
+    },
+    {
+      left: {
+        type: "wheat",
+        crowns: 1
+      },
+      right: {
+        type: "plain",
+        crowns: 0
+      },
+      number: 21
+    },
+    {
+      left: {
+        type: "wheat",
+        crowns: 1
+      },
+      right: {
+        type: "swamp",
+        crowns: 0
+      },
+      number: 22
+    },
+    {
+      left: {
+        type: "wheat",
+        crowns: 1
+      },
+      right: {
+        type: "mine",
+        crowns: 0
+      },
+      number: 23
+    },
+    {
+      left: {
+        type: "forest",
+        crowns: 1
+      },
+      right: {
+        type: "wheat",
+        crowns: 0
+      },
+      number: 24
+    },
+    {
+      left: {
+        type: "forest",
+        crowns: 1
+      },
+      right: {
+        type: "wheat",
+        crowns: 0
+      },
+      number: 25
+    },
+    {
+      left: {
+        type: "forest",
+        crowns: 1
+      },
+      right: {
+        type: "wheat",
+        crowns: 0
+      },
+      number: 26
+    },
+    {
+      left: {
+        type: "forest",
+        crowns: 1
+      },
+      right: {
+        type: "wheat",
+        crowns: 0
+      },
+      number: 27
+    },
+    {
+      left: {
+        type: "forest",
+        crowns: 1
+      },
+      right: {
+        type: "sea",
+        crowns: 0
+      },
+      number: 28
+    },
+    {
+      left: {
+        type: "forest",
+        crowns: 1
+      },
+      right: {
+        type: "plain",
+        crowns: 0
+      },
+      number: 29
+    },
+    {
+      left: {
+        type: "sea",
+        crowns: 1
+      },
+      right: {
+        type: "wheat",
+        crowns: 0
+      },
+      number: 30
+    },
+    {
+      left: {
+        type: "sea",
+        crowns: 1
+      },
+      right: {
+        type: "wheat",
+        crowns: 0
+      },
+      number: 31
+    },
+    {
+      left: {
+        type: "sea",
+        crowns: 1
+      },
+      right: {
+        type: "forest",
+        crowns: 0
+      },
+      number: 32
+    },
+    {
+      left: {
+        type: "sea",
+        crowns: 1
+      },
+      right: {
+        type: "forest",
+        crowns: 0
+      },
+      number: 33
+    },
+    {
+      left: {
+        type: "sea",
+        crowns: 1
+      },
+      right: {
+        type: "forest",
+        crowns: 0
+      },
+      number: 34
+    },
+    {
+      left: {
+        type: "sea",
+        crowns: 1
+      },
+      right: {
+        type: "forest",
+        crowns: 0
+      },
+      number: 35
+    },
+    {
+      left: {
+        type: "wheat",
+        crowns: 0
+      },
+      right: {
+        type: "plain",
+        crowns: 1
+      },
+      number: 36
+    },
+    {
+      left: {
+        type: "sea",
+        crowns: 0
+      },
+      right: {
+        type: "plain",
+        crowns: 1
+      },
+      number: 37
+    },
+    {
+      left: {
+        type: "wheat",
+        crowns: 0
+      },
+      right: {
+        type: "swamp",
+        crowns: 1
+      },
+      number: 38
+    },
+    {
+      left: {
+        type: "plain",
+        crowns: 0
+      },
+      right: {
+        type: "swamp",
+        crowns: 0
+      },
+      number: 39
+    },
+    {
+      left: {
+        type: "mine",
+        crowns: 1
+      },
+      right: {
+        type: "wheat",
+        crowns: 0
+      },
+      number: 40
+    },
+    {
+      left: {
+        type: "wheat",
+        crowns: 0
+      },
+      right: {
+        type: "plain",
+        crowns: 2
+      },
+      number: 41
+    },
+    {
+      left: {
+        type: "sea",
+        crowns: 0
+      },
+      right: {
+        type: "plain",
+        crowns: 2
+      },
+      number: 42
+    },
+    {
+      left: {
+        type: "wheat",
+        crowns: 0
+      },
+      right: {
+        type: "swamp",
+        crowns: 2
+      },
+      number: 43
+    },
+    {
+      left: {
+        type: "plain",
+        crowns: 0
+      },
+      right: {
+        type: "swamp",
+        crowns: 2
+      },
+      number: 44
+    },
+    {
+      left: {
+        type: "mine",
+        crowns: 2
+      },
+      right: {
+        type: "wheat",
+        crowns: 0
+      },
+      number: 45
+    },
+    {
+      left: {
+        type: "swamp",
+        crowns: 0
+      },
+      right: {
+        type: "mine",
+        crowns: 2
+      },
+      number: 46
+    },
+    {
+      left: {
+        type: "swamp",
+        crowns: 0
+      },
+      right: {
+        type: "mine",
+        crowns: 2
+      },
+      number: 47
+    },
+    {
+      left: {
+        type: "wheat",
+        crowns: 0
+      },
+      right: {
+        type: "mine",
+        crowns: 3
+      },
+      number: 48
+    }
+  ]
+};
+// src/adapterServerside/jsonDominoes.ts
+var jsonDominoes = () => {
+  const dominoes = {};
+  for (const [key, value] of Object.entries(dominoes_default)) {
+    const currentDominoes = [];
+    value.forEach((domino) => {
+      currentDominoes.push({
+        left: {
+          type: domino.left.type,
+          crowns: domino.left.crowns
+        },
+        right: {
+          type: domino.right.type,
+          crowns: domino.right.crowns
+        },
+        number: domino.number
+      });
+    });
+    dominoes[key] = currentDominoes;
+  }
+  return {
+    getForMode: (mode) => {
+      return dominoes[mode.name] || [];
+    }
+  };
+};
+var jsonDominoes_default = jsonDominoes;
+// src/datasources/modes.json
+var modes_default = [
+  {
+    name: "Classic",
+    description: "Original KingDomino rules"
+  }
+];
+// src/adapterServerside/jsonModes.ts
+var jsonModes = () => {
+  const modes = [];
+  modes_default.forEach((mode) => {
+    modes.push({
+      name: mode.name,
+      description: mode.description
+    });
+  });
+  return {
+    getAvailables: () => {
+      return modes;
+    }
+  };
+};
+var jsonModes_default = jsonModes;
+// src/datasources/rules.json
+var rules_default = {
+  commun: [
+    {
+      playersLimit: 1,
+      lordsPerPlayer: 1,
+      maxDominoes: 48,
+      dominoesPerTurn: 4,
+      maxTurns: 12,
+      maxKingdomSize: 5
+    },
+    {
+      playersLimit: 2,
+      lordsPerPlayer: 2,
+      maxDominoes: 24,
+      dominoesPerTurn: 4,
+      maxTurns: 6,
+      maxKingdomSize: 5
+    },
+    {
+      playersLimit: 3,
+      lordsPerPlayer: 1,
+      maxDominoes: 48,
+      dominoesPerTurn: 4,
+      maxTurns: 12,
+      maxKingdomSize: 5
+    },
+    {
+      playersLimit: 4,
+      lordsPerPlayer: 1,
+      maxDominoes: 48,
+      dominoesPerTurn: 4,
+      maxTurns: 12,
+      maxKingdomSize: 5
+    }
+  ],
+  extra: [
+    {
+      name: "The middle Kingdom",
+      description: "Gain 10 additional points if your castle is in the middle of the kingdom.",
+      mode: [{ name: "Classic", description: "King Domino classic mode" }]
+    },
+    {
+      name: "Harmony",
+      description: "Gain 5 additional points if your kingdom is complete (no discarded dominoes).",
+      mode: [{ name: "Classic", description: "King Domino classic mode" }]
+    },
+    {
+      name: "The Mighty Duel",
+      description: "Use all 48 dominoes and build a 7x7 kingdom. For 2 players only.",
+      mode: [{ name: "Classic", description: "King Domino classic mode" }],
+      playersLimit: 2
+    },
+    {
+      name: "Dynasty",
+      description: "Play 3 games in a row. The player with the highest total points wins.",
+      mode: [{ name: "Classic", description: "King Domino classic mode" }]
+    }
+  ]
+};
+// src/adapterServerside/jsonRules.ts
+var jsonRules = () => {
+  const rules = {
+    basic: {},
+    extraRules: []
+  };
+  const commonRules = rules_default.commun;
+  const extraRules = rules_default.extra;
+  commonRules.forEach((rule) => {
+    rules.basic[rule.playersLimit] = {
+      lords: rule.lordsPerPlayer,
+      maxDominoes: rule.maxDominoes,
+      dominoesPerTurn: rule.dominoesPerTurn,
+      maxTurns: rule.maxTurns,
+      maxKingdomSize: rule.maxKingdomSize
+    };
+  });
+  extraRules.forEach((rule) => {
+    rules.extraRules.push({
+      name: rule.name,
+      description: rule.description,
+      mode: rule.mode,
+      ..."playersLimit" in rule && { playersLimit: rule.playersLimit }
+    });
+  });
+  return {
+    getAll: () => {
+      return rules;
+    },
+    getAllExtra: () => {
+      return rules.extraRules;
+    }
+  };
+};
+var jsonRules_default = jsonRules;
+// src/adapterServerside/shuffle.ts
+var shuffleMethod = (array) => {
+  for (let i = array.length - 1; i > 0; i--) {
+    const j = Math.floor(Math.random() * (i + 1));
+    [array[i], array[j]] = [array[j], array[i]];
+  }
+  return array;
+};
+// src/adapterServerside/uuid.ts
+var uuidMethod = () => {
+  return globalThis.crypto.randomUUID();
+};
+// src/core/domain/errors/domainErrors.ts
+var ErrorCode = {
+  // Game flow errors
+  INVALID_STEP: "INVALID_STEP",
+  STEP_EXECUTION_FAILED: "STEP_EXECUTION_FAILED",
+  ACTION_EXECUTION_FAILED: "ACTION_EXECUTION_FAILED",
+  // Entity not found errors
+  LORD_NOT_FOUND: "LORD_NOT_FOUND",
+  PLAYER_NOT_FOUND: "PLAYER_NOT_FOUND",
+  DOMINO_NOT_FOUND: "DOMINO_NOT_FOUND",
+  MODE_NOT_FOUND: "MODE_NOT_FOUND",
+  // Validation errors
+  INVALID_PLAYER_COUNT: "INVALID_PLAYER_COUNT",
+  INVALID_PLAYER_NAME: "INVALID_PLAYER_NAME",
+  INVALID_PLACEMENT: "INVALID_PLACEMENT",
+  PLACEMENT_NOT_EMPTY: "PLACEMENT_NOT_EMPTY",
+  PLACEMENT_NOT_ADJACENT: "PLACEMENT_NOT_ADJACENT",
+  PLACEMENT_INVALID_TERRAIN: "PLACEMENT_INVALID_TERRAIN",
+  PLACEMENT_OUT_OF_BOUNDS: "PLACEMENT_OUT_OF_BOUNDS",
+  PLACEMENT_EXCEEDS_KINGDOM_SIZE: "PLACEMENT_EXCEEDS_KINGDOM_SIZE",
+  // Action errors
+  NOT_YOUR_TURN: "NOT_YOUR_TURN",
+  CANNOT_PICK: "CANNOT_PICK",
+  CANNOT_PLACE: "CANNOT_PLACE",
+  DOMINO_ALREADY_PICKED: "DOMINO_ALREADY_PICKED",
+  // History errors
+  UNDO_UNAVAILABLE: "UNDO_UNAVAILABLE",
+  REDO_UNAVAILABLE: "REDO_UNAVAILABLE"
+};
+var 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"
+};
+var defaultTranslations = {
+  // Error messages
+  [TranslationKey.ERROR_INVALID_STEP]: "Invalid game step",
+  [TranslationKey.ERROR_STEP_EXECUTION_FAILED]: "Step execution failed",
+  [TranslationKey.ERROR_ACTION_EXECUTION_FAILED]: "Action execution failed",
+  [TranslationKey.ERROR_LORD_NOT_FOUND]: "Lord not found",
+  [TranslationKey.ERROR_PLAYER_NOT_FOUND]: "Player not found",
+  [TranslationKey.ERROR_DOMINO_NOT_FOUND]: "Domino not found",
+  [TranslationKey.ERROR_MODE_NOT_FOUND]: "Game mode not found",
+  [TranslationKey.ERROR_INVALID_PLACEMENT]: "Invalid placement",
+  [TranslationKey.ERROR_PLACEMENT_NOT_EMPTY]: "Position is not empty",
+  [TranslationKey.ERROR_PLACEMENT_NOT_ADJACENT]: "Not adjacent to existing tiles",
+  [TranslationKey.ERROR_PLACEMENT_INVALID_TERRAIN]: "Terrain type does not match",
+  [TranslationKey.ERROR_PLACEMENT_OUT_OF_BOUNDS]: "Placement is out of bounds",
+  [TranslationKey.ERROR_PLACEMENT_EXCEEDS_KINGDOM_SIZE]: "Placement exceeds kingdom size",
+  [TranslationKey.ERROR_NOT_YOUR_TURN]: "It is not your turn",
+  [TranslationKey.ERROR_CANNOT_PICK]: "Cannot pick a domino now",
+  [TranslationKey.ERROR_CANNOT_PLACE]: "Cannot place a domino now",
+  [TranslationKey.ERROR_DOMINO_ALREADY_PICKED]: "Domino has already been picked",
+  [TranslationKey.ERROR_INVALID_PLAYER_COUNT]: "Invalid number of players (1-4 required)",
+  [TranslationKey.ERROR_INVALID_PLAYER_NAME]: "Player name must be at least 3 characters",
+  [TranslationKey.ERROR_UNDO_UNAVAILABLE]: "No state to undo",
+  [TranslationKey.ERROR_REDO_UNAVAILABLE]: "No state to redo",
+  // Game mode names
+  [TranslationKey.MODE_CLASSIC]: "Classic",
+  // Extra rule names
+  [TranslationKey.RULE_MIDDLE_KINGDOM]: "The Middle Kingdom",
+  [TranslationKey.RULE_HARMONY]: "Harmony",
+  // Ground types
+  [TranslationKey.GROUND_CASTLE]: "Castle",
+  [TranslationKey.GROUND_WHEAT]: "Wheat Field",
+  [TranslationKey.GROUND_FOREST]: "Forest",
+  [TranslationKey.GROUND_SEA]: "Sea",
+  [TranslationKey.GROUND_PLAIN]: "Plain",
+  [TranslationKey.GROUND_SWAMP]: "Swamp",
+  [TranslationKey.GROUND_MINE]: "Mine",
+  // Game phases
+  [TranslationKey.PHASE_ADD_PLAYERS]: "Add Players",
+  [TranslationKey.PHASE_OPTIONS]: "Game Options",
+  [TranslationKey.PHASE_START]: "Start Game",
+  [TranslationKey.PHASE_RESULT]: "Game Results",
+  // Actions
+  [TranslationKey.ACTION_PICK_DOMINO]: "Pick Domino",
+  [TranslationKey.ACTION_PLACE_DOMINO]: "Place Domino",
+  [TranslationKey.ACTION_PASS]: "Pass"
+};
+var errorCodeToTranslationKey = {
+  [ErrorCode.INVALID_STEP]: TranslationKey.ERROR_INVALID_STEP,
+  [ErrorCode.STEP_EXECUTION_FAILED]: TranslationKey.ERROR_STEP_EXECUTION_FAILED,
+  [ErrorCode.ACTION_EXECUTION_FAILED]: TranslationKey.ERROR_ACTION_EXECUTION_FAILED,
+  [ErrorCode.LORD_NOT_FOUND]: TranslationKey.ERROR_LORD_NOT_FOUND,
+  [ErrorCode.PLAYER_NOT_FOUND]: TranslationKey.ERROR_PLAYER_NOT_FOUND,
+  [ErrorCode.DOMINO_NOT_FOUND]: TranslationKey.ERROR_DOMINO_NOT_FOUND,
+  [ErrorCode.MODE_NOT_FOUND]: TranslationKey.ERROR_MODE_NOT_FOUND,
+  [ErrorCode.INVALID_PLAYER_COUNT]: TranslationKey.ERROR_INVALID_PLAYER_COUNT,
+  [ErrorCode.INVALID_PLAYER_NAME]: TranslationKey.ERROR_INVALID_PLAYER_NAME,
+  [ErrorCode.INVALID_PLACEMENT]: TranslationKey.ERROR_INVALID_PLACEMENT,
+  [ErrorCode.PLACEMENT_NOT_EMPTY]: TranslationKey.ERROR_PLACEMENT_NOT_EMPTY,
+  [ErrorCode.PLACEMENT_NOT_ADJACENT]: TranslationKey.ERROR_PLACEMENT_NOT_ADJACENT,
+  [ErrorCode.PLACEMENT_INVALID_TERRAIN]: TranslationKey.ERROR_PLACEMENT_INVALID_TERRAIN,
+  [ErrorCode.PLACEMENT_OUT_OF_BOUNDS]: TranslationKey.ERROR_PLACEMENT_OUT_OF_BOUNDS,
+  [ErrorCode.PLACEMENT_EXCEEDS_KINGDOM_SIZE]: TranslationKey.ERROR_PLACEMENT_EXCEEDS_KINGDOM_SIZE,
+  [ErrorCode.NOT_YOUR_TURN]: TranslationKey.ERROR_NOT_YOUR_TURN,
+  [ErrorCode.CANNOT_PICK]: TranslationKey.ERROR_CANNOT_PICK,
+  [ErrorCode.CANNOT_PLACE]: TranslationKey.ERROR_CANNOT_PLACE,
+  [ErrorCode.DOMINO_ALREADY_PICKED]: TranslationKey.ERROR_DOMINO_ALREADY_PICKED,
+  [ErrorCode.UNDO_UNAVAILABLE]: TranslationKey.ERROR_UNDO_UNAVAILABLE,
+  [ErrorCode.REDO_UNAVAILABLE]: TranslationKey.ERROR_REDO_UNAVAILABLE
+};
+var translateErrorCode = (translator, code, params) => {
+  const key = errorCodeToTranslationKey[code];
+  return translator.t(key, params);
+};
+var createTranslator = (translations = {}) => {
+  const mergedTranslations = { ...defaultTranslations, ...translations };
+  return {
+    t(key, params) {
+      let text = mergedTranslations[key] || key;
+      if (params) {
+        for (const [paramKey, value] of Object.entries(params)) {
+          text = text.replace(
+            new RegExp(`\\{\\{${paramKey}\\}\\}`, "g"),
+            String(value)
+          );
+        }
+      }
+      return text;
+    }
+  };
+};
+var defaultTranslator = createTranslator();
+// src/utils/result.ts
+var ok = (value) => ({ tag: "Ok", value });
+var err = (error) => ({ tag: "Err", error });
+var isOk = (result) => result.tag === "Ok";
+var isErr = (result) => result.tag === "Err";
+var unwrap = (result) => {
+  if (result.tag === "Err") {
+    throw new Error(result.error);
+  }
+  return result.value;
+};
+// src/application/handlers/addExtraRulesHandler.ts
+var addExtraRulesHandler = (logger, translator, useCase) => (command) => {
+  const { game, extraRules } = command;
+  logger.info(`Adding extra rules to game: ${game.id}`);
+  logger.info(`Extra rules: ${extraRules}`);
+  if (!isGameWithNextStep(game)) {
+    logger.error(
+      `Invalid game, required nextAction type: 'step' but got: ${game.nextAction.type}`
+    );
+    throw new InvalidStepError(
+      translateErrorCode(translator, ErrorCode.INVALID_STEP),
+      { expected: "step", actual: game.nextAction.type, gameId: game.id }
+    );
+  }
+  if (game.nextAction.step !== "options") {
+    logger.error(
+      `Required game with options step but got: ${game.nextAction.step}`
+    );
+    throw new InvalidStepError(
+      translateErrorCode(translator, ErrorCode.INVALID_STEP),
+      { expected: "options", actual: game.nextAction.step, gameId: game.id }
+    );
+  }
+  const result = useCase(game, extraRules);
+  if (isErr(result)) {
+    logger.error(`Error adding extra rules: ${result.error}`);
+    const code = result.error;
+    throw new StepExecutionError(translateErrorCode(translator, code), code, {
+      gameId: game.id,
+      extraRules: command.extraRules
+    });
+  }
+  logger.info(`Extra rules added to game: ${game.id}`);
+  return result.value;
+};
+// src/application/handlers/addPlayersHandler.ts
+var addPlayersHandler = (logger, translator, useCase) => (command) => {
+  const { game, players } = command;
+  logger.info(`Adding players to game: ${game.id}`);
+  if (!isGameWithNextStep(game)) {
+    logger.error(
+      `Invalid game, required nextAction type: 'step' but got: ${game.nextAction.type}`
+    );
+    throw new InvalidStepError(
+      translateErrorCode(translator, ErrorCode.INVALID_STEP),
+      { expected: "step", actual: game.nextAction.type, gameId: game.id }
+    );
+  }
+  if (game.nextAction.step !== "addPlayers") {
+    logger.error(
+      `Required game with addPlayers step but got: ${game.nextAction.step}`
+    );
+    throw new InvalidStepError(
+      translateErrorCode(translator, ErrorCode.INVALID_STEP),
+      {
+        expected: "addPlayers",
+        actual: game.nextAction.step,
+        gameId: game.id
+      }
+    );
+  }
+  const result = useCase(game, players);
+  if (isErr(result)) {
+    logger.error(`Error adding players: ${result.error}`);
+    const code = result.error;
+    throw new StepExecutionError(translateErrorCode(translator, code), code, {
+      gameId: game.id,
+      players: command.players
+    });
+  }
+  logger.info(`Players added to game: ${game.id}`);
+  return result.value;
+};
+// src/application/handlers/calculateScoreHandler.ts
+var calculateScoreHandler = (logger, translator, useCase) => (command) => {
+  const { kingdom } = command;
+  logger.info(`Calculating score for kingdom`);
+  const result = useCase(kingdom);
+  if (isErr(result)) {
+    logger.error(`Error calculating score: ${result.error}`);
+    throw new Error(result.error);
+  }
+  logger.info(`Score calculated: ${result.value}`);
+  return result.value;
+};
+// src/application/handlers/canPlaceDominoHandler.ts
+var canPlaceDominoHandler = (logger, translator, useCase) => {
+  return (command) => {
+    logger.info(`Checking if domino ${command.domino.number} can be placed`);
+    const canPlace = useCase(
+      command.kingdom,
+      command.domino,
+      command.maxKingdomSize
+    );
+    logger.info(`Can place domino: ${canPlace}`);
+    return canPlace;
+  };
+};
+// src/application/handlers/chooseDominoHandler.ts
+var chooseDominoHandler = (logger, translator, useCase) => (command) => {
+  const { game, lordId, dominoPick } = command;
+  logger.info(
+    `Choosing domino: ${dominoPick} for lord: ${lordId} in game: ${game.id}`
+  );
+  if (!isGameWithNextAction(game)) {
+    logger.error(
+      `Invalid game, required nextAction type: 'action' but got: ${game.nextAction.type}`
+    );
+    throw new InvalidStepError(
+      translateErrorCode(translator, ErrorCode.INVALID_STEP),
+      { expected: "action", actual: game.nextAction.type, gameId: game.id }
+    );
+  }
+  if (game.nextAction.nextAction !== "pickDomino") {
+    logger.error(
+      `Required game with pickDomino action but got: ${game.nextAction.nextAction}`
+    );
+    throw new InvalidStepError(
+      translateErrorCode(translator, ErrorCode.INVALID_STEP),
+      {
+        expected: "pickDomino",
+        actual: game.nextAction.nextAction,
+        gameId: game.id
+      }
+    );
+  }
+  const result = useCase(game, lordId, dominoPick);
+  if (isErr(result)) {
+    logger.error(`Error choosing domino: ${result.error}`);
+    const code = result.error;
+    throw new ActionExecutionError(
+      translateErrorCode(translator, code),
+      code,
+      {
+        gameId: game.id,
+        lordId: command.lordId,
+        dominoPick: command.dominoPick
+      }
+    );
+  }
+  logger.info(
+    `Domino chosen: ${dominoPick} for lord: ${lordId} in game: ${game.id}`
+  );
+  return result.value;
+};
+// src/application/handlers/createGameHandler.ts
+var createGameHandler = (logger, translator, useCase) => (command) => {
+  logger.info(`Creating game with mode: ${command.mode}`);
+  const result = useCase(command.mode, command.seed);
+  if (isErr(result)) {
+    logger.error(`Error creating game: ${result.error}`);
+    const code = result.error;
+    throw new StepExecutionError(translateErrorCode(translator, code), code, {
+      mode: command.mode
+    });
+  }
+  logger.info(`Game created: ${result.value.id}`);
+  return result.value;
+};
+// src/application/handlers/discardDominoHandler.ts
+var discardDominoHandler = (logger, translator, useCase) => (command) => {
+  const { game, lordId } = command;
+  logger.info(`Discarding domino for lord: ${lordId} in game: ${game.id}`);
+  if (!isGameWithNextAction(game)) {
+    logger.error(
+      `Invalid game, required nextAction type: 'action' but got: ${game.nextAction.type}`
+    );
+    throw new InvalidStepError(
+      translateErrorCode(translator, ErrorCode.INVALID_STEP),
+      { expected: "action", actual: game.nextAction.type, gameId: game.id }
+    );
+  }
+  if (game.nextAction.nextAction !== "placeDomino") {
+    logger.error(
+      `Required game with placeDomino action but got: ${game.nextAction.nextAction}`
+    );
+    throw new InvalidStepError(
+      translateErrorCode(translator, ErrorCode.INVALID_STEP),
+      {
+        expected: "placeDomino",
+        actual: game.nextAction.nextAction,
+        gameId: game.id
+      }
+    );
+  }
+  const result = useCase(game, lordId);
+  if (isErr(result)) {
+    logger.error(`Error discarding domino: ${result.error}`);
+    const code = result.error;
+    throw new ActionExecutionError(
+      translateErrorCode(translator, code),
+      code,
+      { gameId: game.id, lordId: command.lordId }
+    );
+  }
+  if (isGameWithNextAction(result.value)) {
+    logger.info(`Domino discarded: ${lordId} in game: ${game.id}`);
+    return result.value;
+  }
+  logger.info(`Domino discarded: ${lordId} in game: ${game.id}`);
+  return result.value;
+};
+// src/application/handlers/getDynastyResultHandler.ts
+var getDynastyResultHandler = (logger, translator, useCase) => {
+  return (command) => {
+    logger.info(
+      `Calculating dynasty results for ${command.games.length} games`
+    );
+    const results = useCase(command.games);
+    logger.info(`Dynasty results calculated`);
+    return results;
+  };
+};
+// src/application/handlers/getExtraRulesHandler.ts
+var getExtraRulesHandler = (logger, translator, useCase) => (command) => {
+  const { mode, players } = command;
+  logger.info(
+    `Getting extra rules for mode: ${mode} and players: ${players}`
+  );
+  const result = useCase(mode, players);
+  if (isErr(result)) {
+    logger.error(`Error getting extra rules: ${result.error}`);
+    const code = result.error;
+    throw new NotFoundError(translateErrorCode(translator, code), code, {
+      mode: command.mode
+    });
+  }
+  logger.info(`Extra rules retrieved: ${result.value}`);
+  return result.value;
+};
+// src/application/handlers/getModesHandler.ts
+var getModesHandler = (logger, translator, useCase) => (_command) => {
+  logger.info("Getting modes");
+  const result = useCase();
+  if (isErr(result)) {
+    logger.error(`Error getting modes: ${result.error}`);
+    const code = result.error;
+    throw new NotFoundError(translateErrorCode(translator, code), code);
+  }
+  logger.info(`Modes retrieved: ${result.value}`);
+  return result.value;
+};
+// src/application/handlers/getResultHandler.ts
+var getResultHandler = (logger, translator, useCases) => (command) => {
+  const { getResultUseCase: getResultUseCase2, calculateScoreUseCase: calculateScoreUseCase2 } = useCases;
+  const { game } = command;
+  logger.info(`Getting result for game: ${game.id}`);
+  if (!isGameWithNextStep(game)) {
+    logger.error(
+      `Invalid game, required nextAction type: 'step' but got: ${game.nextAction.type}`
+    );
+    throw new InvalidStepError(
+      translateErrorCode(translator, ErrorCode.INVALID_STEP),
+      { expected: "step", actual: game.nextAction.type, gameId: game.id }
+    );
+  }
+  if (game.nextAction.step !== "result") {
+    logger.error(
+      `Required game with result step but got: ${game.nextAction.step}`
+    );
+    throw new InvalidStepError(
+      translateErrorCode(translator, ErrorCode.INVALID_STEP),
+      { expected: "result", actual: game.nextAction.step, gameId: game.id }
+    );
+  }
+  const { players } = game;
+  const scoreResult = players.map((player) => {
+    const { kingdom } = player;
+    const result2 = calculateScoreUseCase2(kingdom);
+    if (isErr(result2)) {
+      logger.error(`Error when calculating score: ${result2.error}`);
+      const code = result2.error;
+      throw new StepExecutionError(
+        translateErrorCode(translator, code),
+        code,
+        {
+          gameId: game.id
+        }
+      );
+    }
+    return {
+      playerId: player.id,
+      playerName: player.name,
+      details: {
+        ...result2.value
+      }
+    };
+  });
+  const result = getResultUseCase2(game, scoreResult);
+  if (isErr(result)) {
+    logger.error(`Error getting result: ${result.error}`);
+    const code = result.error;
+    throw new NotFoundError(translateErrorCode(translator, code), code, {
+      gameId: game.id
+    });
+  }
+  logger.info(`Result retrieved for game: ${game.id}`);
+  return result.value;
+};
+// src/application/handlers/getValidPlacementsHandler.ts
+var getValidPlacementsHandler = (logger, translator, useCase) => {
+  return (command) => {
+    logger.info(
+      `Getting valid placements for domino: ${command.domino.number}`
+    );
+    const placements = useCase(
+      command.kingdom,
+      command.domino,
+      command.maxKingdomSize
+    );
+    logger.info(`Found ${placements.length} valid placements`);
+    return placements;
+  };
+};
+// src/application/handlers/placeDominoHandler.ts
+var placeDominoHandler = (logger, translator, useCase) => (command) => {
+  const { game, lordId, position, rotation } = command;
+  logger.info(
+    `Placing domino: ${lordId} in position: ${JSON.stringify(
+      position
+    )} with rotation: ${rotation} in game: ${game.id}`
+  );
+  if (!isGameWithNextAction(game)) {
+    logger.error(
+      `Invalid game, required nextAction type: 'action' but got: ${game.nextAction.type}`
+    );
+    throw new InvalidStepError(
+      translateErrorCode(translator, ErrorCode.INVALID_STEP),
+      { expected: "action", actual: game.nextAction.type, gameId: game.id }
+    );
+  }
+  if (game.nextAction.nextAction !== "placeDomino") {
+    logger.error(
+      `Required game with placeDomino action but got: ${game.nextAction.nextAction}`
+    );
+    throw new InvalidStepError(
+      translateErrorCode(translator, ErrorCode.INVALID_STEP),
+      {
+        expected: "placeDomino",
+        actual: game.nextAction.nextAction,
+        gameId: game.id
+      }
+    );
+  }
+  const result = useCase(game, lordId, position, rotation);
+  if (isErr(result)) {
+    logger.error(`Error placing domino: ${result.error}`);
+    const code = result.error;
+    throw new ActionExecutionError(
+      translateErrorCode(translator, code),
+      code,
+      {
+        gameId: game.id,
+        lordId: command.lordId,
+        position: command.position,
+        rotation: command.rotation
+      }
+    );
+  }
+  if (isGameWithNextAction(result.value)) {
+    logger.info(
+      `Domino placed: ${lordId} in position: ${JSON.stringify(
+        position
+      )} with rotation: ${rotation} in game: ${game.id}`
+    );
+    return result.value;
+  }
+  logger.info(
+    `Domino placed: ${lordId} in position: ${JSON.stringify(
+      position
+    )} with rotation: ${rotation} in game: ${game.id}`
+  );
+  return result.value;
+};
+// src/core/useCases/serialization.ts
+var SERIALIZATION_VERSION = 1;
+var serializeGame = (game) => {
+  const serialized = {
+    version: SERIALIZATION_VERSION,
+    data: game,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  return JSON.stringify(serialized);
+};
+var deserializeGame = (json) => {
+  try {
+    const parsed = JSON.parse(json);
+    if (!parsed.version || !parsed.data) {
+      return err("Invalid serialized game format");
+    }
+    if (parsed.version > SERIALIZATION_VERSION) {
+      return err(
+        `Unsupported serialization version: ${parsed.version}. Current version: ${SERIALIZATION_VERSION}`
+      );
+    }
+    const game = parsed.data;
+    if (!game.id || !game.players || !game.lords || !game.nextAction) {
+      return err("Invalid game state structure");
+    }
+    return ok(game);
+  } catch (error) {
+    return err(`Failed to parse game JSON: ${error.message}`);
+  }
+};
+// src/application/handlers/serializeGameHandler.ts
+var serializeGameHandler = (logger, _translator) => {
+  return (command) => {
+    logger.info(`Serializing game: ${command.game.id}`);
+    const serialized = serializeGame(command.game);
+    logger.info(`Game serialized successfully`);
+    return serialized;
+  };
+};
+var deserializeGameHandler = (logger, translator) => {
+  return (command) => {
+    logger.info(`Deserializing game from JSON`);
+    const result = deserializeGame(command.json);
+    if (isErr(result)) {
+      logger.error(`Failed to deserialize game: ${result.error}`);
+      const code = result.error;
+      throw new StepExecutionError(translateErrorCode(translator, code), code);
+    }
+    const game = unwrap(result);
+    logger.info(`Game deserialized successfully: ${game.id}`);
+    return game;
+  };
+};
+// src/application/handlers/startGameHandler.ts
+var startGameHandler = (logger, translator, useCase) => (command) => {
+  const { game } = command;
+  logger.info(`Starting game: ${game.id}`);
+  if (!isGameWithNextStep(game)) {
+    logger.error(
+      `Invalid game, required nextAction type: 'step' but got: ${game.nextAction.type}`
+    );
+    throw new InvalidStepError(
+      translateErrorCode(translator, ErrorCode.INVALID_STEP),
+      { expected: "step", actual: game.nextAction.type, gameId: game.id }
+    );
+  }
+  if (game.nextAction.step !== "start" && game.nextAction.step !== "options") {
+    logger.error(
+      `Required game with start step or options step but got: ${game.nextAction.step}`
+    );
+    throw new InvalidStepError(
+      translateErrorCode(translator, ErrorCode.INVALID_STEP),
+      {
+        expected: "start|options",
+        actual: game.nextAction.step,
+        gameId: game.id
+      }
+    );
+  }
+  const result = useCase(game);
+  if (isErr(result)) {
+    logger.error(`Error starting game: ${result.error}`);
+    const code = result.error;
+    throw new StepExecutionError(translateErrorCode(translator, code), code, {
+      gameId: game.id
+    });
+  }
+  logger.info(`Game started: ${game.id}`);
+  return result.value;
+};
+// src/core/domain/types/kingdom.ts
+var GRIDSIZE = 9;
+var MAX_KINGDOM_SIZE = 5;
+// src/core/domain/types/domino.ts
+var GROUND = [
+  "castle",
+  "wheat",
+  "forest",
+  "sea",
+  "plain",
+  "swamp",
+  "mine"
+];
+// src/core/domain/types/player.ts
+var playerActions = {
+  /** Place a previously picked domino on the kingdom */
+  placeDomino: "placeDomino",
+  /** Pick a domino from the revealed set */
+  pickDomino: "pickDomino",
+  /** Pass/discard when no valid placement exists */
+  pass: "pass"
+};
+// src/core/domain/entities/rule.ts
+var getAvailablesExtraRules = (extraRules, mode, numberOfPlayers) => {
+  const availableExtraRules = extraRules.filter((rule) => {
+    return rule.mode.filter((m) => m.name === mode).length > 0 && (!rule.playersLimit || rule.playersLimit === numberOfPlayers);
+  });
+  if (availableExtraRules.length === 0) {
+    return err(ErrorCode.STEP_EXECUTION_FAILED);
+  }
+  return ok(availableExtraRules);
+};
+var toExtraRule = (rule, extraRules) => {
+  const foundRule = extraRules.find((r) => r.name === rule);
+  if (!foundRule) {
+    return err(ErrorCode.STEP_EXECUTION_FAILED);
+  }
+  return ok(foundRule);
+};
+// src/utils/seededShuffle.ts
+var hashSeed = (str) => {
+  let hash = 2166136261;
+  for (let i = 0; i < str.length; i++) {
+    hash ^= str.charCodeAt(i);
+    hash = Math.imul(hash, 16777619);
+  }
+  return hash >>> 0;
+};
+var mulberry32 = (seed) => {
+  let state = seed;
+  return () => {
+    state |= 0;
+    state = state + 1831565813 | 0;
+    let t = Math.imul(state ^ state >>> 15, 1 | state);
+    t = t + Math.imul(t ^ t >>> 7, 61 | t) ^ t;
+    return ((t ^ t >>> 14) >>> 0) / 4294967296;
+  };
+};
+var createSeededShuffle = (seed, salt) => {
+  const numericSeed = hashSeed(`${seed}|${salt}`);
+  const random = mulberry32(numericSeed);
+  return (array) => {
+    const result = [...array];
+    for (let i = result.length - 1; i > 0; i--) {
+      const j = Math.floor(random() * (i + 1));
+      [result[i], result[j]] = [result[j], result[i]];
+    }
+    return result;
+  };
+};
+// src/core/useCases/addExtraRules.ts
+var addExtraRulesUseCase = (deps) => (game, rules) => {
+  const { ruleRepository, dominoesRepository, shuffleMethod: shuffleMethod2 } = deps;
+  const availableExtraRules = ruleRepository.getAllExtra();
+  const newExtraRules = [];
+  for (const rule of rules) {
+    const result = toExtraRule(rule, availableExtraRules);
+    if (isErr(result)) {
+      return result;
+    }
+    newExtraRules.push(result.value);
+  }
+  let updatedBasic = game.rules.basic;
+  let updatedDominoes = game.dominoes;
+  const hasMightyDuel = newExtraRules.some((r) => r.name === "The Mighty Duel");
+  if (hasMightyDuel) {
+    updatedBasic = {
+      ...updatedBasic,
+      maxDominoes: 48,
+      maxTurns: 12,
+      maxKingdomSize: 7
+    };
+    const allDominoes = dominoesRepository.getForMode(game.mode);
+    if (allDominoes) {
+      const shuffle = game.seed ? createSeededShuffle(game.seed, "mighty-duel") : shuffleMethod2;
+      updatedDominoes = shuffle(allDominoes);
+    }
+  }
+  const updatedRules = {
+    basic: updatedBasic,
+    extra: newExtraRules
+  };
+  const next = {
+    type: "step",
+    step: gameSteps.start
+  };
+  const updatedGame = {
+    ...game,
+    dominoes: updatedDominoes,
+    rules: updatedRules,
+    nextAction: next
+  };
+  return ok(updatedGame);
+};
+// src/core/domain/entities/domino.ts
+var isGround = (ground) => {
+  return GROUND.includes(ground);
+};
+var createTile = (ground, crowns = 0) => {
+  if (isGround(ground)) {
+    return { type: ground, crowns };
+  }
+  return { type: ground, crowns: 0 };
+};
+// src/core/domain/entities/kingdom.ts
+var createEmptyKingdom = () => {
+  const emptyTile = createTile("empty");
+  return Array.from(
+    { length: GRIDSIZE },
+    () => Array.from({ length: GRIDSIZE }, () => emptyTile)
+  );
+};
+var placeCastle = (kingdom) => {
+  const castle = createTile("castle");
+  const newKingdom = deepCopyKingdom(kingdom);
+  newKingdom[4][4] = castle;
+  return newKingdom;
+};
+var placeTile = (kingdom, position, tile) => {
+  const newKingdom = deepCopyKingdom(kingdom);
+  newKingdom[position.y][position.x] = tile;
+  return newKingdom;
+};
+var getTile = (kingdom, position) => {
+  const tile = kingdom[position.y]?.[position.x];
+  if (!tile) {
+    return err(ErrorCode.PLACEMENT_OUT_OF_BOUNDS);
+  }
+  return ok(tile);
+};
+var calculateDominoPosition = (position, rotation, domino) => {
+  let firstTile;
+  let secondTile;
+  switch (rotation) {
+    case 0:
+      firstTile = {
+        tile: domino.left,
+        position: {
+          x: position.x,
+          y: position.y
+        }
+      };
+      secondTile = {
+        tile: domino.right,
+        position: {
+          x: position.x + 1,
+          y: position.y
+        }
+      };
+      break;
+    case 90:
+      firstTile = {
+        tile: domino.left,
+        position: {
+          x: position.x,
+          y: position.y
+        }
+      };
+      secondTile = {
+        tile: domino.right,
+        position: {
+          x: position.x,
+          y: position.y + 1
+        }
+      };
+      break;
+    case 180:
+      firstTile = {
+        tile: domino.right,
+        position: {
+          x: position.x,
+          y: position.y
+        }
+      };
+      secondTile = {
+        tile: domino.left,
+        position: {
+          x: position.x + 1,
+          y: position.y
+        }
+      };
+      break;
+    case 270:
+      firstTile = {
+        tile: domino.right,
+        position: {
+          x: position.x,
+          y: position.y
+        }
+      };
+      secondTile = {
+        tile: domino.left,
+        position: {
+          x: position.x,
+          y: position.y + 1
+        }
+      };
+      break;
+  }
+  return [firstTile, secondTile];
+};
+var placeDomino = (kingdom, position, rotation, domino, maxKingdomSize = MAX_KINGDOM_SIZE) => {
+  const [firstTile, secondTile] = calculateDominoPosition(
+    position,
+    rotation,
+    domino
+  );
+  const isFreePlaceResult = isFreePlace(
+    kingdom,
+    firstTile.position,
+    secondTile.position
+  );
+  if (isErr(isFreePlaceResult)) {
+    return isFreePlaceResult;
+  }
+  if (exceedsMaxSize(kingdom, firstTile.position, secondTile.position, maxKingdomSize)) {
+    return err(ErrorCode.PLACEMENT_EXCEEDS_KINGDOM_SIZE);
+  }
+  const adjacentTiles = isAdjacent(
+    kingdom,
+    firstTile.position,
+    secondTile.position
+  );
+  if (adjacentTiles.length === 0) {
+    return err(ErrorCode.PLACEMENT_NOT_ADJACENT);
+  }
+  const hasValidAdjacentTiles = hasValidAdjacent(adjacentTiles, [
+    firstTile.tile,
+    secondTile.tile
+  ]);
+  if (!hasValidAdjacentTiles) {
+    return err(ErrorCode.PLACEMENT_INVALID_TERRAIN);
+  }
+  return ok(placeTiles(kingdom, [firstTile, secondTile]));
+};
+var placeTiles = (kingdom, tiles) => {
+  let newKingdom = deepCopyKingdom(kingdom);
+  for (const { tile, position } of tiles) {
+    newKingdom = placeTile(newKingdom, position, tile);
+  }
+  return newKingdom;
+};
+var isFreePlace = (kingdom, firstPosition, secondPosition) => {
+  const firstTile = getTile(kingdom, firstPosition);
+  const secondTile = getTile(kingdom, secondPosition);
+  if (isErr(firstTile)) {
+    return firstTile;
+  }
+  if (isErr(secondTile)) {
+    return secondTile;
+  }
+  if (firstTile.value.type !== "empty" || secondTile.value.type !== "empty") {
+    return err(ErrorCode.PLACEMENT_NOT_EMPTY);
+  }
+  return ok(true);
+};
+var isAdjacent = (kingdom, firstPosition, secondPosition) => {
+  const offsets = [
+    { x: -1, y: 0 },
+    { x: 1, y: 0 },
+    { x: 0, y: -1 },
+    { x: 0, y: 1 }
+  ];
+  const isOwnPosition = (x, y) => x === firstPosition.x && y === firstPosition.y || x === secondPosition.x && y === secondPosition.y;
+  const adjacentTiles = [];
+  for (const pos of [firstPosition, secondPosition]) {
+    for (const offset of offsets) {
+      const nx = pos.x + offset.x;
+      const ny = pos.y + offset.y;
+      if (isOwnPosition(nx, ny)) continue;
+      const tile = getTile(kingdom, { x: nx, y: ny });
+      if (isOk(tile) && tile.value.type !== "empty") {
+        adjacentTiles.push(tile.value);
+      }
+    }
+  }
+  return adjacentTiles;
+};
+var hasValidAdjacent = (adjacentTiles, tiles) => {
+  return adjacentTiles.some((adjacentTile) => {
+    return tiles.some((tile) => {
+      return tile.type === adjacentTile.type || adjacentTile.type === "castle";
+    });
+  });
+};
+var checkCastleIsInMiddle = (kingdom) => {
+  let castleX;
+  let castleY;
+  for (let y = 0; y < kingdom.length; y++) {
+    const x = kingdom[y].findIndex((tile) => tile.type === "castle");
+    if (x !== -1) {
+      castleX = x;
+      castleY = y;
+      break;
+    }
+  }
+  if (castleX === void 0 || castleY === void 0) {
+    return false;
+  }
+  const bbox = getBoundingBox(kingdom);
+  if (!bbox) return false;
+  const centerX = (bbox.minX + bbox.maxX) / 2;
+  const centerY = (bbox.minY + bbox.maxY) / 2;
+  return castleX === centerX && castleY === centerY;
+};
+var getBoundingBox = (kingdom) => {
+  let minX = Infinity;
+  let maxX = -Infinity;
+  let minY = Infinity;
+  let maxY = -Infinity;
+  for (let y = 0; y < kingdom.length; y++) {
+    for (let x = 0; x < kingdom[y].length; x++) {
+      if (kingdom[y][x].type !== "empty") {
+        if (x < minX) minX = x;
+        if (x > maxX) maxX = x;
+        if (y < minY) minY = y;
+        if (y > maxY) maxY = y;
+      }
+    }
+  }
+  if (minX === Infinity) return null;
+  return { minX, maxX, minY, maxY };
+};
+var exceedsMaxSize = (kingdom, firstPosition, secondPosition, maxSize = MAX_KINGDOM_SIZE) => {
+  const bbox = getBoundingBox(kingdom);
+  let minX = bbox?.minX ?? Infinity;
+  let maxX = bbox?.maxX ?? -Infinity;
+  let minY = bbox?.minY ?? Infinity;
+  let maxY = bbox?.maxY ?? -Infinity;
+  for (const pos of [firstPosition, secondPosition]) {
+    if (pos.x < minX) minX = pos.x;
+    if (pos.x > maxX) maxX = pos.x;
+    if (pos.y < minY) minY = pos.y;
+    if (pos.y > maxY) maxY = pos.y;
+  }
+  return maxX - minX + 1 > maxSize || maxY - minY + 1 > maxSize;
+};
+var countDominoes = (kingdom) => {
+  const notEmpties = kingdom.flat().filter((tile) => tile.type !== "empty");
+  return (notEmpties.length - 1) / 2;
+};
+var deepCopyKingdom = (kingdom) => {
+  return kingdom.map((line) => line.map((tile) => ({ ...tile })));
+};
+// src/core/domain/entities/player.ts
+var MINPLAYERSNAMELENGTH = 3;
+var validatePlayer = (name) => {
+  if (!name || name.trim().length < MINPLAYERSNAMELENGTH) {
+    return err(ErrorCode.INVALID_PLAYER_NAME);
+  }
+  return ok(name);
+};
+var createPlayer = (playerName, id, kingdom, bot) => {
+  const name = validatePlayer(playerName);
+  if (isErr(name)) {
+    return name;
+  }
+  return ok({
+    name: name.value,
+    id,
+    kingdom,
+    ...bot && { bot }
+  });
+};
+// src/core/useCases/addPlayers.ts
+var normalizePlayerInput = (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;
+    }
+    newPlayers.push(newPlayer.value);
+  }
+  const rules = ruleRepository.getAll();
+  const basicRules = rules.basic[newPlayers.length];
+  if (!basicRules) {
+    return err(ErrorCode.STEP_EXECUTION_FAILED);
+  }
+  const dominoes = game.dominoes;
+  const { maxDominoes } = basicRules;
+  const shuffle = game.seed ? createSeededShuffle(game.seed, "dominoes") : shuffleMethod2;
+  const shuffledDominoes = shuffle(dominoes);
+  const splicedDominoes = shuffledDominoes.slice(0, maxDominoes);
+  const next = {
+    type: "step",
+    step: "options"
+  };
+  const updatedGame = {
+    ...game,
+    players: newPlayers,
+    dominoes: splicedDominoes,
+    rules: {
+      ...game.rules,
+      basic: basicRules
+    },
+    nextAction: next
+  };
+  return ok(updatedGame);
+};
+// src/core/useCases/calculateScore.ts
+var calculateScoreUseCase = (kingdom) => {
+  const rows = kingdom.length;
+  const cols = kingdom[0].length;
+  const visited = kingdom.map((row) => row.map(() => false));
+  const properties = [];
+  const directions = [
+    [-1, 0],
+    [1, 0],
+    [0, -1],
+    [0, 1]
+  ];
+  for (let y = 0; y < rows; y++) {
+    for (let x = 0; x < cols; x++) {
+      const tile = kingdom[y][x];
+      if (visited[y][x] || tile.type === "empty" || tile.type === "castle") {
+        continue;
+      }
+      const type = tile.type;
+      let size = 0;
+      let crowns = 0;
+      const queue = [[x, y]];
+      visited[y][x] = true;
+      while (queue.length > 0) {
+        const [cx, cy] = queue.pop();
+        const current = kingdom[cy][cx];
+        size++;
+        crowns += current.crowns;
+        for (const [dx, dy] of directions) {
+          const nx = cx + dx;
+          const ny = cy + dy;
+          if (nx >= 0 && ny >= 0 && nx < cols && ny < rows && !visited[ny][nx] && kingdom[ny][nx].type === type) {
+            visited[ny][nx] = true;
+            queue.push([nx, ny]);
+          }
+        }
+      }
+      properties.push({ size, crowns });
+    }
+  }
+  if (properties.length === 0) {
+    return ok({
+      points: 0,
+      maxPropertiesSize: 0,
+      totalCrowns: 0
+    });
+  }
+  let points = 0;
+  let maxPropertiesSize = 0;
+  let totalCrowns = 0;
+  for (const property of properties) {
+    points += property.size * property.crowns;
+    if (property.size > maxPropertiesSize) {
+      maxPropertiesSize = property.size;
+    }
+    totalCrowns += property.crowns;
+  }
+  return ok({
+    points,
+    maxPropertiesSize,
+    totalCrowns
+  });
+};
+// src/core/domain/entities/lord.ts
+var createLord = (id, playerId) => {
+  return {
+    id,
+    playerId,
+    turnEnded: false,
+    hasPick: false,
+    hasPlace: true
+  };
+};
+var hasPick = (lord) => lord.hasPick;
+var hasPlace = (lord) => lord.hasPlace;
+var hasTurnEnded = (lord) => lord.turnEnded;
+var canPass = (lord) => {
+  return !hasPick(lord) && !hasPlace(lord) && !hasTurnEnded(lord);
+};
+var canPick = (lord) => {
+  return !hasPick(lord) && hasPlace(lord) && !hasTurnEnded(lord);
+};
+var canPlaceAndDominoPickedIsDefined = (lord) => {
+  return !hasPick(lord) && !hasPlace(lord) && !hasTurnEnded(lord) && lord.dominoPicked !== void 0;
+};
+var updateLordOrder = (lords) => {
+  return [...lords].sort((a, b) => {
+    return (a.dominoPicked?.number ?? 0) - (b.dominoPicked?.number ?? 0);
+  });
+};
+var resetLordsActions = (lords) => {
+  return lords.map((lord) => ({
+    ...lord,
+    turnEnded: false,
+    hasPick: false,
+    hasPlace: false
+  }));
+};
+var nextLordWithAction = (lords) => {
+  const nextLord = findNextLord(lords);
+  return {
+    type: "action",
+    nextLord: nextLord.id,
+    nextAction: hasPlace(nextLord) ? playerActions.pickDomino : playerActions.placeDomino
+  };
+};
+var findNextLord = (lords) => {
+  const lord = lords.find((lord2) => !hasTurnEnded(lord2));
+  if (!lord) {
+    return lords[0];
+  }
+  return lord;
+};
+var allLordsHavePlayed = (lords) => {
+  return lords.every((lord) => lord.turnEnded);
+};
+// src/core/useCases/chooseDomino.ts
+var chooseDominoUseCase = (game, lordId, dominoPick) => {
+  const currentLord = game.lords.find(
+    (lord) => lord.id === game.nextAction.nextLord
+  );
+  if (!currentLord) {
+    return err(ErrorCode.LORD_NOT_FOUND);
+  }
+  if (currentLord.id !== lordId) {
+    return err(ErrorCode.NOT_YOUR_TURN);
+  }
+  if (!canPick(currentLord)) {
+    return err(ErrorCode.CANNOT_PICK);
+  }
+  const selectedDomino = game.currentDominoes.find(
+    (domino) => domino.domino.number === dominoPick
+  );
+  if (!selectedDomino) {
+    return err(ErrorCode.DOMINO_NOT_FOUND);
+  }
+  if (selectedDomino.picked) {
+    return err(ErrorCode.DOMINO_ALREADY_PICKED);
+  }
+  const updatedCurrentDominoes = game.currentDominoes.map(
+    (domino) => domino.domino.number === dominoPick ? { ...domino, picked: true, lordId: currentLord.id } : domino
+  );
+  const updatedLords = game.lords.map(
+    (lord) => lord.id === currentLord.id ? { ...lord, hasPick: true, turnEnded: true, dominoPicked: selectedDomino.domino } : lord
+  );
+  const turnEnded = allLordsHavePlayed(updatedLords);
+  if (turnEnded) {
+    const lords = resetLordsActions(updateLordOrder(updatedLords));
+    const updatedTurn = game.turn + 1;
+    const next2 = nextLordWithAction(lords);
+    const dominoesCopy = [...game.dominoes];
+    const dominoesDrawn = dominoesCopy.splice(
+      0,
+      game.rules.basic.dominoesPerTurn
+    );
+    dominoesDrawn.sort((a, b) => a.number - b.number);
+    const updatedCurrentDominoes2 = dominoesDrawn.map((domino, index) => {
+      return {
+        domino,
+        picked: false,
+        lordId: null,
+        position: index + 1
+      };
+    });
+    return ok({
+      ...game,
+      currentDominoes: updatedCurrentDominoes2,
+      dominoes: dominoesCopy,
+      lords,
+      turn: updatedTurn,
+      nextAction: next2
+    });
+  }
+  const next = nextLordWithAction(updatedLords);
+  const updatedState = {
+    ...game,
+    currentDominoes: updatedCurrentDominoes,
+    lords: updatedLords,
+    nextAction: next
+  };
+  return ok(updatedState);
+};
+// src/core/domain/entities/game.ts
+var create = (payload) => {
+  const { id, mode, dominoes, seed } = payload;
+  return {
+    id,
+    dominoes,
+    currentDominoes: [],
+    players: [],
+    lords: [],
+    turn: 0,
+    nextAction: {
+      type: "step",
+      step: gameSteps.addPlayers
+    },
+    rules: {
+      basic: {
+        lords: 0,
+        maxDominoes: 0,
+        dominoesPerTurn: 0,
+        maxTurns: 0,
+        maxKingdomSize: 5
+      },
+      extra: []
+    },
+    mode,
+    ...seed !== void 0 && { seed }
+  };
+};
+// src/core/domain/entities/mode.ts
+var findMode = (mode, availableMode) => {
+  return availableMode.find((m) => m.name === mode);
+};
+var createMode = (mode, availableMode) => {
+  const foundMode = findMode(mode, availableMode);
+  if (foundMode) {
+    return ok(foundMode);
+  }
+  return err(ErrorCode.MODE_NOT_FOUND);
+};
+// src/core/useCases/createGame.ts
+var createGameUseCase = (deps) => (mode, seed) => {
+  const { modeRepository, dominoesRepository, uuidMethod: uuidMethod3 } = 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 payload = {
+    id,
+    mode: newMode.value,
+    dominoes,
+    seed: gameSeed
+  };
+  const newGame = create(payload);
+  return ok(newGame);
+};
+// src/core/useCases/getValidPlacements.ts
+var getValidPlacementsUseCase = (kingdom, domino, maxKingdomSize = MAX_KINGDOM_SIZE) => {
+  const validPlacements = [];
+  const rotations = [0, 90, 180, 270];
+  for (let y = 0; y < GRIDSIZE; y++) {
+    for (let x = 0; x < GRIDSIZE; x++) {
+      const position = { x, y };
+      for (const rotation of rotations) {
+        const result = placeDomino(kingdom, position, rotation, domino, maxKingdomSize);
+        if (isOk(result)) {
+          validPlacements.push({ position, rotation });
+        }
+      }
+    }
+  }
+  return validPlacements;
+};
+var canPlaceDominoUseCase = (kingdom, domino, maxKingdomSize = MAX_KINGDOM_SIZE) => {
+  const rotations = [0, 90, 180, 270];
+  for (let y = 0; y < GRIDSIZE; y++) {
+    for (let x = 0; x < GRIDSIZE; x++) {
+      const position = { x, y };
+      for (const rotation of rotations) {
+        const result = placeDomino(kingdom, position, rotation, domino, maxKingdomSize);
+        if (isOk(result)) {
+          return true;
+        }
+      }
+    }
+  }
+  return false;
+};
+// src/core/useCases/discardDomino.ts
+var discardDominoUseCase = (game, lordId) => {
+  const nextAction = game.nextAction;
+  const currentLord = game.lords.find(
+    (lord) => lord.id === nextAction.nextLord
+  );
+  if (!currentLord) {
+    return err(ErrorCode.LORD_NOT_FOUND);
+  }
+  if (currentLord.id !== lordId) {
+    return err(ErrorCode.NOT_YOUR_TURN);
+  }
+  if (!canPass(currentLord)) {
+    return err(ErrorCode.CANNOT_PLACE);
+  }
+  if (currentLord.dominoPicked) {
+    const currentPlayer = game.players.find(
+      (player) => player.id === currentLord.playerId
+    );
+    if (currentPlayer && canPlaceDominoUseCase(currentPlayer.kingdom, currentLord.dominoPicked, game.rules.basic.maxKingdomSize)) {
+      return err(ErrorCode.CANNOT_PLACE);
+    }
+  }
+  const maxTurns = game.rules.basic.maxTurns;
+  const currentTurn = game.turn;
+  const isLastTurn = currentTurn === maxTurns;
+  const updatedLord = game.lords.map((lord) => {
+    if (lord.id === currentLord.id) {
+      if (isLastTurn) {
+        return {
+          ...lord,
+          turnEnded: true,
+          hasPlace: true
+        };
+      }
+      return {
+        ...lord,
+        hasPlace: true
+      };
+    }
+    return lord;
+  });
+  let updatedGame;
+  const resultStep = {
+    type: "step",
+    step: gameSteps.result
+  };
+  if (isLastTurn && allLordsHavePlayed(updatedLord)) {
+    updatedGame = {
+      ...game,
+      lords: updatedLord,
+      nextAction: resultStep
+    };
+  } else {
+    updatedGame = {
+      ...game,
+      lords: updatedLord,
+      nextAction: nextLordWithAction(updatedLord)
+    };
+  }
+  return ok(updatedGame);
+};
+// src/core/useCases/getDynastyResult.ts
+var getDynastyResultUseCase = (games) => {
+  const playerMap = /* @__PURE__ */ new Map();
+  for (const game of games) {
+    for (const result of game.result) {
+      const existing = playerMap.get(result.playerId);
+      if (existing) {
+        existing.points.push(result.details.points);
+      } else {
+        playerMap.set(result.playerId, {
+          name: result.playerName,
+          points: [result.details.points]
+        });
+      }
+    }
+  }
+  const results = [];
+  for (const [playerId, data] of playerMap) {
+    results.push({
+      playerId,
+      playerName: data.name,
+      totalPoints: data.points.reduce((sum, p) => sum + p, 0),
+      gamesPoints: data.points
+    });
+  }
+  results.sort((a, b) => b.totalPoints - a.totalPoints);
+  const finalResults = [];
+  for (let i = 0; i < results.length; i++) {
+    const current = results[i];
+    const previous = i > 0 ? finalResults[i - 1] : null;
+    const position = previous && current.totalPoints === previous.totalPoints ? previous.position : i + 1;
+    finalResults.push({ ...current, position });
+  }
+  return finalResults;
+};
+// src/core/useCases/getExtraRules.ts
+var getExtraRulesUseCase = (deps) => (mode, players) => {
+  const { ruleRepository } = deps;
+  const allExtraRules = ruleRepository.getAllExtra();
+  if (!allExtraRules) {
+    return err(ErrorCode.STEP_EXECUTION_FAILED);
+  }
+  return getAvailablesExtraRules(allExtraRules, mode, players);
+};
+// src/core/useCases/getModes.ts
+var getModesUseCase = (deps) => () => {
+  const { modeRepository } = deps;
+  return ok(modeRepository.getAvailables());
+};
+// src/core/useCases/getResult.ts
+var getResultUseCase = (game, scoreResult) => {
+  const { rules } = game;
+  const { basic, extra } = rules;
+  const finalScoreResult = scoreResult.map((score) => {
+    let finalScore = score.details.points;
+    const player = game.players.find((p) => p.id === score.playerId);
+    if (!player) {
+      return score;
+    }
+    const { kingdom } = player;
+    if (extra.length > 0) {
+      extra.forEach((extraRule) => {
+        if (extraRule.name === "The middle Kingdom") {
+          const castleIsInMiddle = checkCastleIsInMiddle(kingdom);
+          if (castleIsInMiddle) {
+            finalScore += 10;
+          }
+        }
+        if (extraRule.name === "Harmony") {
+          const totalDominoes = countDominoes(kingdom);
+          const dominoLimit = basic.maxDominoes;
+          const totalPlayers = game.players.length;
+          const dominoesPerPlayer = dominoLimit / totalPlayers;
+          if (totalDominoes === dominoesPerPlayer) {
+            finalScore += 5;
+          }
+        }
+      });
+    }
+    return {
+      ...score,
+      details: {
+        ...score.details,
+        points: finalScore
+      }
+    };
+  });
+  finalScoreResult.sort((a, b) => {
+    if (a.details.points !== b.details.points) {
+      return b.details.points - a.details.points;
+    }
+    return b.details.maxPropertiesSize - a.details.maxPropertiesSize;
+  });
+  const result = [];
+  let isTie = false;
+  result.push({
+    playerId: finalScoreResult[0].playerId,
+    playerName: finalScoreResult[0].playerName,
+    details: finalScoreResult[0].details,
+    position: 1
+  });
+  for (let i = 1; i < finalScoreResult.length; i++) {
+    const currentScore = finalScoreResult[i];
+    const previousScore = finalScoreResult[i - 1];
+    if (previousScore && currentScore && currentScore.details.points === previousScore.details.points && currentScore.details.maxPropertiesSize === previousScore.details.maxPropertiesSize) {
+      isTie = true;
+    }
+    if (isTie) {
+      result.push({
+        ...currentScore,
+        position: result[i - 1].position
+      });
+    } else {
+      result.push({
+        ...currentScore,
+        position: i + 1
+      });
+    }
+    isTie = false;
+  }
+  return ok({
+    ...game,
+    result
+  });
+};
+// src/core/useCases/placeDomino.ts
+var placeDominoUseCase = (game, lordId, position, rotation) => {
+  const nextAction = game.nextAction;
+  const currentLord = game.lords.find(
+    (lord) => lord.id === nextAction.nextLord
+  );
+  if (!currentLord) {
+    return err(ErrorCode.LORD_NOT_FOUND);
+  }
+  if (currentLord.id !== lordId) {
+    return err(ErrorCode.NOT_YOUR_TURN);
+  }
+  if (!canPlaceAndDominoPickedIsDefined(currentLord)) {
+    return err(ErrorCode.CANNOT_PLACE);
+  }
+  const domino = currentLord.dominoPicked;
+  const currentPlayer = game.players.find(
+    (player) => player.id === currentLord.playerId
+  );
+  if (!currentPlayer) {
+    return err(ErrorCode.PLAYER_NOT_FOUND);
+  }
+  const updatedKingdom = placeDomino(
+    currentPlayer.kingdom,
+    position,
+    rotation,
+    domino,
+    game.rules.basic.maxKingdomSize
+  );
+  if (isErr(updatedKingdom)) {
+    return updatedKingdom;
+  }
+  const updatedPlayers = game.players.map((player) => {
+    if (player.id === currentPlayer.id) {
+      player.kingdom = updatedKingdom.value;
+    }
+    return player;
+  });
+  const maxTurns = game.rules.basic.maxTurns;
+  const currentTurn = game.turn;
+  const isLastTurn = currentTurn === maxTurns;
+  const updatedLords = game.lords.map((lord) => {
+    if (lord.id === currentLord.id) {
+      if (isLastTurn) {
+        return {
+          ...lord,
+          turnEnded: true,
+          hasPlace: true
+        };
+      }
+      return {
+        ...lord,
+        hasPlace: true
+      };
+    }
+    return lord;
+  });
+  let updatedGame;
+  const resultStep = {
+    type: "step",
+    step: gameSteps.result
+  };
+  if (isLastTurn && allLordsHavePlayed(updatedLords)) {
+    updatedGame = {
+      ...game,
+      lords: updatedLords,
+      nextAction: resultStep,
+      players: updatedPlayers
+    };
+  } else {
+    updatedGame = {
+      ...game,
+      lords: updatedLords,
+      nextAction: nextLordWithAction(updatedLords),
+      players: updatedPlayers
+    };
+  }
+  return ok(updatedGame);
+};
+// src/core/useCases/startGame.ts
+var startGameUseCase = (deps) => (game) => {
+  const { uuidMethod: 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
+  };
+  const newState = {
+    ...game,
+    lords: shuffledLords,
+    nextAction,
+    dominoes: dominoesCopy,
+    currentDominoes: dominoesDrawn.map((domino, index) => {
+      return {
+        domino,
+        picked: false,
+        lordId: null,
+        position: index + 1
+      };
+    })
+  };
+  return ok(newState);
+};
+// src/config.ts
+var configureEngine = (config) => {
+  const modeRepository = jsonModes_default();
+  const dominoesRepository = jsonDominoes_default();
+  const ruleRepository = jsonRules_default();
+  const uuid = config.uuidMethod || uuidMethod;
+  const shuffle = config.shuffleMethod || shuffleMethod;
+  const translator = config.translator || defaultTranslator;
+  const logger = config.logger ? config.logger : config.logging ? consoleLogger(true) : silentLogger;
+  return {
+    createGameHandler: createGameHandler(
+      logger,
+      translator,
+      createGameUseCase({
+        modeRepository,
+        dominoesRepository,
+        uuidMethod: uuid
+      })
+    ),
+    getModesHandler: getModesHandler(
+      logger,
+      translator,
+      getModesUseCase({ modeRepository })
+    ),
+    getExtraRulesHandler: getExtraRulesHandler(
+      logger,
+      translator,
+      getExtraRulesUseCase({ ruleRepository })
+    ),
+    addPlayersHandler: addPlayersHandler(
+      logger,
+      translator,
+      addPlayersUseCase({
+        uuidMethod: uuid,
+        shuffleMethod: shuffle,
+        ruleRepository
+      })
+    ),
+    addExtraRulesHandler: addExtraRulesHandler(
+      logger,
+      translator,
+      addExtraRulesUseCase({
+        ruleRepository,
+        dominoesRepository,
+        shuffleMethod: shuffle
+      })
+    ),
+    startGameHandler: startGameHandler(
+      logger,
+      translator,
+      startGameUseCase({ uuidMethod: uuid, shuffleMethod: shuffle })
+    ),
+    chooseDominoHandler: chooseDominoHandler(
+      logger,
+      translator,
+      chooseDominoUseCase
+    ),
+    placeDominoHandler: placeDominoHandler(
+      logger,
+      translator,
+      placeDominoUseCase
+    ),
+    discardDominoHandler: discardDominoHandler(
+      logger,
+      translator,
+      discardDominoUseCase
+    ),
+    getResultHandler: getResultHandler(logger, translator, {
+      getResultUseCase,
+      calculateScoreUseCase
+    }),
+    calculateScoreHandler: calculateScoreHandler(
+      logger,
+      translator,
+      calculateScoreUseCase
+    ),
+    getValidPlacementsHandler: getValidPlacementsHandler(
+      logger,
+      translator,
+      getValidPlacementsUseCase
+    ),
+    canPlaceDominoHandler: canPlaceDominoHandler(
+      logger,
+      translator,
+      canPlaceDominoUseCase
+    ),
+    serializeGameHandler: serializeGameHandler(logger, translator),
+    deserializeGameHandler: deserializeGameHandler(logger, translator),
+    getDynastyResultHandler: getDynastyResultHandler(
+      logger,
+      translator,
+      getDynastyResultUseCase
+    )
+  };
+};
+// src/core/domain/entities/validateGameState.ts
+var 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
+  } = 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)
+  };
+  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)));