release: @echecs/game@2.0.1

Author: mormubis

AGENTS.md

@@ -1,8 +1,8 @@
 # AGENTS.md
 
 Agent guidance for the `@echecs/game` repository — a TypeScript chess game
-engine depending on `@echecs/position` and `@echecs/fen`, providing legal move
-generation, undo/redo, and game-state detection.
+engine depending on `@echecs/position`, providing legal move generation,
+undo/redo, and game-state detection.
 
 **Backlog:** tracked in
 [GitHub Issues](https://github.com/mormubis/game/issues).
@@ -12,9 +12,9 @@ generation, undo/redo, and game-state detection.
 ## Project Overview
 
 `@echecs/game` exposes a single mutable `Game` class. The internal state is a
-`Position` object (from `@echecs/position`) plus castling rights, en passant
-target, halfmove clock, and fullmove number. Runtime dependencies are
-`@echecs/position` and `@echecs/fen`; no SAN notation, no PGN.
+`Position` object (from `@echecs/position`) which contains the board, castling
+rights, en passant target, halfmove clock, fullmove number, and turn. Single
+runtime dependency: `@echecs/position`. No SAN notation, no PGN.
 
 ---
 
@@ -23,7 +23,8 @@ target, halfmove clock, and fullmove number. Runtime dependencies are
 | Package            | Type    | Purpose                                                                                                                             |
 | ------------------ | ------- | ----------------------------------------------------------------------------------------------------------------------------------- |
 | `@echecs/position` | Runtime | `Position` class, types (`Color`, `Piece`, `Square`, etc.), `reach()` for pseudo-legal targets, `derive()` for position transitions |
-| `@echecs/fen`      | Runtime | FEN parsing (`parse`) and serialization (`stringify`)                                                                               |
+| `@echecs/fen`      | Dev     | FEN parsing (`parse`) and serialization (`stringify`) — used in tests only                                                          |
+| `@echecs/san`      | Dev     | SAN move parsing — used in playthrough tests only                                                                                   |
 
 ---
 
@@ -49,13 +50,15 @@ Key source files:
 | ----------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
 | `src/index.ts`                      | Public re-exports (`Game` class, `Position` class, and all public types from `@echecs/position`)                                                                      |
 | `src/types.ts`                      | Local `Move` and `PromotionPieceType` types (removed from `@echecs/position` v3)                                                                                      |
-| `src/fen.ts`                        | FEN conversion layer between `@echecs/fen` v1 types and position v3 types                                                                                             |
 | `src/game.ts`                       | `Game` class — public API, undo/redo stacks, history, wraps `Position` from `@echecs/position`                                                                        |
 | `src/moves.ts`                      | Legal move generation, `move` (applies move to Position), uses `position.reach()` for pseudo-legal targets and `position.derive()` + `isCheck` for legality filtering |
 | `src/detection.ts`                  | `isCheckmate`, `isStalemate`, `isDraw`, `isThreefoldRepetition` — all take `Position` + `Move[]`                                                                      |
 | `src/__tests__/game.spec.ts`        | Unit tests for the `Game` class                                                                                                                                       |
 | `src/__tests__/moves.spec.ts`       | Unit tests for move generation, including perft                                                                                                                       |
 | `src/__tests__/detection.spec.ts`   | Unit tests for game-state detection                                                                                                                                   |
+| `src/__tests__/playthrough.spec.ts` | Full game playthrough test (Fischer-Spassky 1972 Game 6) via `@echecs/san`                                                                                            |
+| `src/__tests__/hash.spec.ts`        | Zobrist hash consistency tests (move/undo cycles, transpositions)                                                                                                     |
+| `src/__tests__/regression.spec.ts`  | Regression edge-case tests ported from chess.js                                                                                                                       |
 | `src/__tests__/helpers.ts`          | Test helper: `fromFen` utility for constructing Position from FEN strings                                                                                             |
 | `src/__tests__/comparison.bench.ts` | Comparative benchmarks vs `chess.js`                                                                                                                                  |
 
@@ -170,14 +173,14 @@ Groups, separated by a blank line, in this order:
 
 ## Naming Conventions
 
-| Construct              | Convention             | Examples                                            |
-| ---------------------- | ---------------------- | --------------------------------------------------- |
-| Classes                | `PascalCase`           | `Game`                                              |
-| Functions              | `camelCase`            | `generateMoves`, `parseFen`, `squareToIndex`        |
-| Types / Interfaces     | `PascalCase`           | `Color`, `Move`, `Piece`, `FenState`                |
-| Module-level constants | `SCREAMING_SNAKE_CASE` | `STARTING_FEN`, `INITIAL_BOARD`, `PROMOTION_PIECES` |
-| Variables / Parameters | `camelCase`            | `state`, `move`, `square`, `depth`                  |
-| Source files           | `camelCase.ts`         | `index.ts`, `moves.ts`, `board.ts`                  |
+| Construct              | Convention             | Examples                                      |
+| ---------------------- | ---------------------- | --------------------------------------------- |
+| Classes                | `PascalCase`           | `Game`                                        |
+| Functions              | `camelCase`            | `generateMoves`, `enemyColor`, `boardChanges` |
+| Types / Interfaces     | `PascalCase`           | `Color`, `Move`, `Piece`, `HistoryEntry`      |
+| Module-level constants | `SCREAMING_SNAKE_CASE` | `STARTING_POSITION`, `PROMOTION_PIECES`       |
+| Variables / Parameters | `camelCase`            | `state`, `move`, `square`, `depth`            |
+| Source files           | `camelCase.ts`         | `index.ts`, `moves.ts`, `game.ts`             |
 
 ---
 
@@ -225,7 +228,6 @@ position state used internally by all modules:
 
 - Board: `Map<Square, Piece>` (public API) / 0x88 array (internal)
 - `castlingRights`, `enPassantSquare`, `fullmoveNumber`, `halfmoveClock`, `turn`
-- Attack queries: `isAttacked(square, by)`, `attackers(square, by)`
 - State queries: `isCheck`, `isInsufficientMaterial`, `isValid`, `hash`
 - Piece access: `at(square)` returns `Piece | undefined`
 - Pseudo-legal targets: `reach(square)` returns target squares for the piece on
@@ -243,8 +245,9 @@ value object — `derive()` returns new instances, never mutates. `Move` and
 `generateMoves(position, square?)` produces legal moves only:
 
 1. Generate pseudo-legal moves per piece type for the active color.
-2. For each pseudo-legal move, apply it via `applyMoveToState` and check if the
-   active color's king is in check. Discard if so.
+2. For each pseudo-legal move, apply board changes via `boardChanges` +
+   `position.derive({ changes })` and check if the active color's king is in
+   check. Discard if so.
 
 `isInCheck` uses a separate `isKingAttackedOn` path that does **not** generate
 castling moves — this breaks the infinite recursion that would otherwise occur
@@ -283,10 +286,11 @@ Private fields:
 
 **Caching:** `#cache` is populated lazily via the private `#cachedState` getter
 on the first call to `moves()`, `isCheck()`, `isCheckmate()`, `isStalemate()`,
-`isDraw()`, or `isGameOver()` from a given position. It is invalidated
-(`#cache = undefined`) at the start of `move()`, `undo()`, and `redo()` — but
-only after confirming the operation is not a no-op. Repeated queries from the
-same position are O(1) after the first call.
+`isDraw()`, or `isGameOver()` from a given position. `move()` reads the cache
+for legality validation, then invalidates after applying. `undo()` and `redo()`
+check whether the history stack is empty before invalidating, so no-op calls do
+not evict the cache. Repeated queries from the same position are O(1) after the
+first call.
 
 ### Detection (`src/detection.ts`)
 

CHANGELOG.md

@@ -8,6 +8,21 @@ and this project adheres to
 
 ## [Unreleased]
 
+## [2.0.1] - 2026-04-09
+
+### Fixed
+
+- Corrected README to match 2.0.0 API: removed nonexistent `Game.fromFen()` and
+  `game.fen()`, documented `new Game(position)` constructor, fixed `undo()` /
+  `redo()` return types (`void`, not `this`), fixed `Move.promotion` signature,
+  removed `MoveInput` from exports listing.
+- Updated `AGENTS.md` to reflect single runtime dependency (`@echecs/position`),
+  removed nonexistent `src/fen.ts`, added missing test files, removed stale
+  references to `isAttacked` / `applyMoveToState`, updated naming convention
+  examples.
+- Changed `package.json` keyword from `no-dependencies` to
+  `minimal-dependencies`.
+
 ## [2.0.0] - 2026-04-09
 
 ### Changed

README.md

@@ -8,8 +8,8 @@
 [ECHECS](https://github.com/mormubis) project.
 
 It provides a single mutable `Game` class that manages board state, generates
-legal moves, and detects game-ending conditions. Depends on `@echecs/position`
-and `@echecs/fen` at runtime.
+legal moves, and detects game-ending conditions. Single runtime dependency:
+[`@echecs/position`](https://www.npmjs.com/package/@echecs/position).
 
 ## Installation
 
@@ -29,7 +29,6 @@ game.move({ from: 'e7', to: 'e5' });
 
 console.log(game.turn()); // 'white'
 console.log(game.moves()); // all legal moves for white
-console.log(game.fen()); // current position as FEN string
 ```
 
 ## API
@@ -44,15 +43,14 @@ Creates a new game from the standard starting position.
 const game = new Game();
 ```
 
-#### `Game.fromFen(fen)`
+#### `new Game(position)`
 
-Creates a game from an arbitrary FEN string. Throws `Error` if the FEN is
-invalid.
+Creates a game from an existing `Position` object (from `@echecs/position`).
 
 ```typescript
-const game = Game.fromFen(
-  'rnbqkbnr/pppppppp/8/8/4P3/8/PPPP1PPP/RNBQKBNR b KQkq e3 0 1',
-);
+import { Position } from '@echecs/game';
+
+const game = new Game(position);
 ```
 
 ### Board queries
@@ -79,10 +77,6 @@ with `board()[0]` = rank 1 (a1–h1) and `board()[7]` = rank 8.
 game.board()[0]?.[4]; // { color: 'white', type: 'king' }  (e1)
 ```
 
-#### `game.fen()`
-
-Returns the current position as a FEN string.
-
 #### `game.position()`
 
 Returns the underlying `Position` object. Useful for direct access to castling
@@ -113,7 +107,7 @@ Each `Move` object has the shape:
 interface Move {
   from: Square;
   to: Square;
-  promotion: PromotionPieceType | undefined;
+  promotion?: PromotionPieceType;
 }
 ```
 
@@ -134,12 +128,12 @@ game.move({ from: 'e7', to: 'e8', promotion: 'queen' }); // promotion
 
 #### `game.undo()`
 
-Steps back one move. Returns `this`. No-op at the start of the game.
+Steps back one move. No-op at the start of the game.
 
 #### `game.redo()`
 
-Steps forward one move (after an undo). Returns `this`. No-op at the end of
-history. Cleared whenever a new `move()` is made.
+Steps forward one move (after an undo). No-op at the end of history. Cleared
+whenever a new `move()` is made.
 
 ```typescript
 game.move({ from: 'e2', to: 'e4' });
@@ -155,7 +149,7 @@ Returns the list of moves played so far. Undone moves are not included.
 
 ```typescript
 game.move({ from: 'e2', to: 'e4' });
-game.history(); // [{ from: 'e2', to: 'e4', promotion: undefined }]
+game.history(); // [{ from: 'e2', to: 'e4' }]
 ```
 
 ### State detection
@@ -201,8 +195,7 @@ import type {
   CastlingRights, // { white: SideCastlingRights, black: SideCastlingRights }
   Color, // 'white' | 'black'
   EnPassantSquare, // typed en passant target square
-  Move, // { from: Square, to: Square, promotion: PromotionPieceType | undefined }
-  MoveInput, // input shape for game.move()
+  Move, // { from: Square, to: Square, promotion?: PromotionPieceType }
   Piece, // { color: Color, type: PieceType }
   PieceType, // 'pawn' | 'knight' | 'bishop' | 'rook' | 'queen' | 'king'
   PromotionPieceType, // 'queen' | 'rook' | 'bishop' | 'knight'

package.json

@@ -52,7 +52,7 @@
     "game",
     "legal-moves",
     "move-generation",
-    "no-dependencies",
+    "minimal-dependencies",
     "redo",
     "stalemate",
     "typescript",
@@ -83,7 +83,7 @@
   },
   "type": "module",
   "types": "dist/index.d.ts",
-  "version": "2.0.0",
+  "version": "2.0.1",
   "dependencies": {
     "@echecs/position": "^3.0.3"
   }