feat: NCS-31 FastParse FEN (#22)

Summary

  - Added fastparse_3:3.0.2 dependency to modules/io
  - Implemented FenParserFastParse as a second alternative FEN parser using FastParse, with the same public API as
  FenParser and FenParserCombinators
  - Parsers are built bottom-up using (using P[Any]) Scala 3 syntax with NoWhitespace.* to prevent implicit whitespace
  skipping; rank sum validation uses Pass/Fail inside .flatMap
  - Added FenParserFastParseTest mirroring FenParserCombinatorsTest to prove behavioural equivalence across all three
  implementations

  Test plan

  - All existing tests pass — FenParser, FenParserCombinators, and all other modules untouched
  - FenParserFastParseTest covers all cases: valid FEN, invalid color, invalid castling, invalid board shapes, en
  passant, rank overflow, round-trip via FenExporter
  - All parser logic branches genuinely covered — known scoverage gap documented in docs/unresolved.md (FastParse inline
   macro generates synthetic proxy methods that scoverage instruments but that never execute at runtime)

Co-authored-by: LQ63 <lkhermann@web.de>
Reviewed-on: #22
Reviewed-by: Janis <janis-e@gmx.de>
Co-authored-by: Leon Hermann <lq@blackhole.local>
Co-committed-by: Leon Hermann <lq@blackhole.local>

.claude/memory/MEMORY.md

@@ -1,9 +0,0 @@
-# Memory Index
-
-## Feedback
-- [feedback_keep_structure_updated.md](feedback_keep_structure_updated.md) — Update structure memory files whenever source files are added, removed, or changed
-
-## Project Structure
-- [project_structure_root.md](project_structure_root.md) — Top-level layout, modules list, VERSIONS map, navigation rules (skip `build/`, `.gradle/`, `.idea/`)
-- [project_structure_api.md](project_structure_api.md) — `modules/api`: all files and types (Board, Piece, Square, GameState, Move, ApiResponse, PlayerInfo)
-- [project_structure_core.md](project_structure_core.md) — `modules/core`: all files and types (GameContext, GameRules, MoveValidator, GameController, Parser, Renderer)

.claude/memory/feedback_keep_structure_updated.md

@@ -1,16 +0,0 @@
----
-name: keep-structure-memory-updated
-description: Always update the project structure memory files when adding, removing, or changing source files
-type: feedback
----
-
-After any change that adds, removes, renames, or significantly alters a source file, update the relevant structure memory file:
-
-- New/renamed/deleted file in `modules/api` → update `project_structure_api.md`
-- New/renamed/deleted file in `modules/core` → update `project_structure_core.md`
-- New module, dependency version change, or new top-level directory → update `project_structure_root.md`
-- New module added → create a new `project_structure_<module>.md` and add it to `MEMORY.md`
-
-**Why:** Structure memories are the primary navigation aid. Stale entries cause wasted exploration.
-
-**How to apply:** Treat the structure memory update as part of completing any implementation task — do it in the same session, not as a follow-up.

.claude/memory/project_structure_api.md

@@ -1,51 +0,0 @@
----
-name: module-api-structure
-description: File and type overview for the modules/api module (shared domain types)
-type: project
----
-
-# Module: `modules/api`
-
-**Purpose:** Shared domain model — pure data types with no game logic. Depended on by `modules/core`.
-
-**Gradle:** `id("scala")`, no `application` plugin. No Quarkus. Uses scoverage plugin.
-
-**Package root:** `de.nowchess.api`
-
-## Source files (`src/main/scala/de/nowchess/api/`)
-
-### `board/`
-| File | Contents |
-|------|----------|
-| `Board.scala` | `opaque type Board = Map[Square, Piece]` — extensions: `pieceAt`, `withMove`, `pieces`; `Board.initial` sets up start position |
-| `Color.scala` | `enum Color { White, Black }` — `.opposite`, `.label` |
-| `Piece.scala` | `case class Piece(color, pieceType)` — convenience vals `WhitePawn`…`BlackKing` |
-| `PieceType.scala` | `enum PieceType { Pawn, Knight, Bishop, Rook, Queen, King }` — `.label` |
-| `Square.scala` | `enum File { A–H }`, `enum Rank { R1–R8 }`, `case class Square(file, rank)` — `.toString` algebraic, `Square.fromAlgebraic(s)` |
-
-### `game/`
-| File | Contents |
-|------|----------|
-| `GameState.scala` | `case class CastlingRights(kingSide, queenSide)` + `.None`/`.Both`; `enum GameResult { WhiteWins, BlackWins, Draw }`; `enum GameStatus { NotStarted, InProgress, Finished(result) }`; `case class GameState(piecePlacement, activeColor, castlingWhite, castlingBlack, enPassantTarget, halfMoveClock, fullMoveNumber, status)` — FEN-compatible snapshot |
-
-### `move/`
-| File | Contents |
-|------|----------|
-| `Move.scala` | `enum PromotionPiece { Knight, Bishop, Rook, Queen }`; `enum MoveType { Normal, CastleKingside, CastleQueenside, EnPassant, Promotion(piece) }`; `case class Move(from, to, moveType = Normal)` |
-
-### `player/`
-| File | Contents |
-|------|----------|
-| `PlayerInfo.scala` | `opaque type PlayerId = String`; `case class PlayerInfo(id: PlayerId, displayName: String)` |
-
-### `response/`
-| File | Contents |
-|------|----------|
-| `ApiResponse.scala` | `sealed trait ApiResponse[+A]` → `Success[A](data)` / `Failure(errors)`; `case class ApiError(code, message, field?)`; `case class Pagination(page, pageSize, totalItems)` + `.totalPages`; `case class PagedResponse[A](items, pagination)` |
-
-## Test files (`src/test/scala/de/nowchess/api/`)
-Mirror of main structure — one `*Test.scala` per source file using `AnyFunSuite with Matchers`.
-
-## Notes
-- `GameState` is FEN-style but `Board` (in `core`) is a `Map[Square,Piece]` — the two are separate representations
-- `CastlingRights` is defined here in `api`; the castling logic lives in `core`

.claude/memory/project_structure_core.md

@@ -1,48 +0,0 @@
----
-name: module-core-structure
-description: File and type overview for the modules/core module (TUI chess engine)
-type: project
----
-
-# Module: `modules/core`
-
-**Purpose:** Standalone TUI chess application. All game logic, move validation, rendering. Depends on `modules/api`.
-
-**Gradle:** `id("scala")` + `application` plugin. Main class: `de.nowchess.chess.Main`. Uses scoverage plugin.
-
-**Package root:** `de.nowchess.chess`
-
-## Source files (`src/main/scala/de/nowchess/chess/`)
-
-### Root
-| File | Contents |
-|------|----------|
-| `Main.scala` | Entry point — prints welcome, starts `GameController.gameLoop(GameContext.initial, Color.White)` |
-
-### `controller/`
-| File | Contents |
-|------|----------|
-| `GameController.scala` | `sealed trait MoveResult` ADT: `Quit`, `InvalidFormat`, `NoPiece`, `WrongColor`, `IllegalMove`, `Moved`, `MovedInCheck`, `Checkmate`, `Stalemate`; `object GameController` — `processMove(ctx, turn, raw): MoveResult` (pure), `gameLoop(ctx, turn)` (I/O loop), `applyRightsRevocation(...)` (castling rights bookkeeping) |
-| `Parser.scala` | `object Parser` — `parseMove(input): Option[(Square, Square)]` parses coordinate notation e.g. `"e2e4"` |
-
-### `logic/`
-| File | Contents |
-|------|----------|
-| `GameContext.scala` | `enum CastleSide { Kingside, Queenside }`; `case class GameContext(board, whiteCastling, blackCastling)` — `.castlingFor(color)`, `.withUpdatedRights(color, rights)`; `GameContext.initial`; `extension (Board).withCastle(color, side)` moves king+rook atomically |
-| `GameRules.scala` | `enum PositionStatus { Normal, InCheck, Mated, Drawn }`; `object GameRules` — `isInCheck(board, color)`, `legalMoves(ctx, color): Set[(Square,Square)]`, `gameStatus(ctx, color): PositionStatus` |
-| `MoveValidator.scala` | `object MoveValidator` — `isLegal(board, from, to)`, `legalTargets(board, from): Set[Square]` (board-only, no castling), `legalTargets(ctx, from)` (context-aware, includes castling), `isCastle`, `castleSide`, `castlingTargets(ctx, color)` — full castling legality (empty squares, no check through transit) |
-
-### `view/`
-| File | Contents |
-|------|----------|
-| `Renderer.scala` | `object Renderer` — `render(board): String` outputs ANSI-colored board with file/rank labels |
-| `PieceUnicode.scala` | `extension (Piece).unicode: String` maps each piece to its Unicode chess symbol |
-
-## Test files (`src/test/scala/de/nowchess/chess/`)
-Mirror of main structure — one `*Test.scala` per source file using `AnyFunSuite with Matchers`.
-
-## Key design notes
-- `MoveValidator` has two overloaded `legalTargets`: one takes `Board` (geometry only), one takes `GameContext` (adds castling)
-- `GameRules.legalMoves` filters by check — it calls `MoveValidator.legalTargets(ctx, from)` then simulates each move
-- Castling rights revocation is in `GameController.applyRightsRevocation`, triggered after every move
-- No `@QuarkusTest` — this module is a plain Scala application, not a Quarkus service

.claude/memory/project_structure_root.md

@@ -1,55 +0,0 @@
----
-name: project-root-structure
-description: Top-level project structure, modules list, and navigation notes for NowChessSystems
-type: project
----
-
-# NowChessSystems — Root Structure
-
-## Directory layout (skip `build/`, `.gradle/`, `.idea/`)
-
-```
-NowChessSystems/
-├── build.gradle.kts          # Root: sonarqube plugin, VERSIONS map
-├── settings.gradle.kts       # include(":modules:core", ":modules:api")
-├── gradlew / gradlew.bat
-├── CLAUDE.md                 # Project instructions for Claude Code
-├── .claude/
-│   ├── CLAUDE.MD             # Working agreement (plan/verify/unresolved)
-│   ├── settings.json
-│   └── agents/               # architect, code-reviewer, gradle-builder, scala-implementer, test-writer
-├── docs/
-│   ├── Claude-Skills.md
-│   ├── Security.md
-│   └── unresolved.md
-├── jacoco-reporter/          # Python scripts for coverage gap reporting
-└── modules/
-    ├── api/                  # Shared domain types (no logic)
-    └── core/                 # TUI chess engine + game logic
-```
-
-## Modules
-
-| Module | Gradle path | Purpose |
-|--------|-------------|---------|
-| `api` | `:modules:api` | Shared domain model: Board, Piece, Move, GameState, ApiResponse |
-| `core` | `:modules:core` | TUI chess app: game logic, move validation, rendering |
-
-`core` depends on `api` via `implementation(project(":modules:api"))`.
-
-## VERSIONS (root `build.gradle.kts`)
-
-| Key | Value |
-|-----|-------|
-| `QUARKUS_SCALA3` | 1.0.0 |
-| `SCALA3` | 3.5.1 |
-| `SCALA_LIBRARY` | 2.13.18 |
-| `SCALATEST` | 3.2.19 |
-| `SCALATEST_JUNIT` | 0.1.11 |
-| `SCOVERAGE` | 2.1.1 |
-
-## Navigation rules
-- **Always skip** `build/`, `.gradle/`, `.idea/` when exploring — they are generated artifacts
-- Tests use `AnyFunSuite with Matchers` (ScalaTest), not JUnit `@Test`
-- No Quarkus in current modules — Quarkus is planned for future services
-- Agent workflow: architect → scala-implementer → test-writer → gradle-builder → code-reviewer

CLAUDE.md

@@ -1,58 +1,50 @@
-# CLAUDE.md — NowChessSystems
+# Now-Chess
 
-## Stack
-Scala 3.5.x · Quarkus + quarkus-scala3 · Hibernate/Jakarta · Lanterna TUI · K8s + ArgoCD + Kargo · Frontend TBD (Vite/React/Angular/Vue)
-
-### Memory
-
-Your memory is saved under .claude/memory/MEMORY.md.
-
-## Structure
-```
-build.gradle.kts / settings.gradle.kts   # root; include(":modules:<svc>") per service
-modules/<svc>/build.gradle.kts + src/
-docs/adr/  docs/api/  docs/unresolved.md
-```
-Versions in root `extra["VERSIONS"]`; modules read via `rootProject.extra["VERSIONS"] as Map<String,String>`.
+Scala 3.5.1 · Gradle 9
 
 ## Commands
-```bash
-./gradlew build
-./gradlew :modules:<svc>:build|test
-./gradlew :modules:<svc>:test --tests "de.nowchess.<svc>.<Class>"
+
 ```
-
-## Workflow
-1. **Plan** — restate requirement, list files, flag risks. Proceed unless genuine ambiguity.
-2. **Tests first** — cover only new behaviour.
-3. **Implement** — no scope creep.
-4. **Verify** — check each requirement; confirm green build.
-
-## Scala/Quarkus Rules
-- `given`/`using` only (no `implicit`); `Option`/`Either`/`Try` (no `null`/`.get`)
-- `jakarta.*` only; reactive I/O (`Uni`/`Multi`), no blocking on event loop
-- Always exclude `org.scala-lang:scala-library` from Quarkus BOM
-- Unit tests: `extends AnyFunSuite with Matchers` — no `@Test`, no `: Unit`
-- Integration tests: `@QuarkusTest` + JUnit 5 — `@Test` methods need explicit `: Unit`
-
-## Coverage
-Line = 100% · Branch = 100% · Method = 100% · Regression tests · document exceptions
-Check: `jacoco-reporter/scoverage_coverage_gaps.py modules/{svc}/build/reports/scoverageTest/scoverage.xml`
-⚠️ Use `scoverageTest/`, NOT `scoverage/`.
-
-## Bug Fixing
-Fix failures immediately without asking. After 3 failed attempts → log in `docs/unresolved.md` + surface summary.
-
-## Agents (new service)
-Sequential: architect → scala-implementer → test-writer → gradle-builder → code-reviewer (review only, no self-fix)
-Parallel: only when services are fully independent (no shared contracts/state).
-
-## Unresolved (`docs/unresolved.md`)
-Append only, never delete:
-```
-## [YYYY-MM-DD] <title>
-**Requirement/Bug:** **Root Cause:** **Attempted Fixes:** **Next Step:**
+./clean      # Clear build dirs — only when necessary
+./compile    # Compile all modules — always run
+./test       # Run all tests
+./coverage   # Check coverage
 ```
+Try to stick to these commands for consistency.
 
-## Done Checklist
-- [ ] Plan written · files created/modified · tests green · requirements verified · unresolved logged
+## Modules
+
+| Module | Role | Depends on |
+|--------|------|-----------|
+| `api`  | Model / shared types | (none) |
+| `core` | Primary business logic | api, rule |
+| `rule` | Game rules | api |
+| `io`   | Export formats | api, core |
+| `ui`   | Entrypoint & UI | core, io |
+
+## Style
+
+- Use immutable data and pure functions.
+- Keep functions under 30 lines. If you need "and" to describe it, split it.
+- Keep cyclomatic complexity under 15.
+- Avoid comments. Let names carry intent; comment only non-obvious algorithms.
+- Scan for duplicated logic before finishing. Extract it.
+- Follow default Sonar style for Scala.
+- Use `Option` or `Either` for fallible operations; avoid exceptions for control flow.
+- Naming: types are PascalCase, functions/values are camelCase.
+
+## Code Quality
+
+- **Coverage:** 100% condition coverage required in `api`, `core`, `rule`, `io` (mandatory); `ui` exempt.
+
+## Architecture Decisions
+
+- **Immutable state as primary model:** GameContext (api) holds board, history, player state — immutable, passed through the system. Each move creates a new GameContext, enabling undo/redo without side effects.
+- **Observer pattern for UI decoupling:** GameEngine publishes move/state events; CommandInvoker queues moves; UI listens to events, not polling. GameEngine never imports UI code.
+- **RuleSet trait encapsulates rules:** Move generation, check, castling, en passant all in RuleSet impl. GameEngine calls rules as a black box; rules don't know about the rest of core.
+
+## Rules
+
+- **Tests are the spec.** Never modify tests to pass; modify requirements or code. Update tests only if requirements change.
+- Never read build folders. Ask permission if needed.
+- Keep this file up to date with any important decisions or conventions.

build.gradle.kts

@@ -32,7 +32,9 @@ val versions = mapOf(
     "SCOVERAGE"             to "2.1.1",
     "SCALAFX"               to "21.0.0-R32",
     "JAVAFX"                to "21.0.1",
-    "JUNIT_BOM"             to "5.13.4"
+    "JUNIT_BOM"             to "5.13.4",
+    "SCALA_PARSER_COMBINATORS" to "2.4.0",
+    "FASTPARSE" to "3.0.2"
 )
 extra["VERSIONS"] = versions
 

docs/unresolved.md

@@ -1,20 +0,0 @@
-## [2026-03-31] Unreachable code blocking 100% statement coverage
-
-**Requirement/Bug:** Reach 100% statement coverage in core module.
-
-**Root Cause:** 4 remaining uncovered statements (99.6% coverage) are unreachable code:
-1. **PgnParser.scala:160** (`case _ => None` in extractPromotion) - Regex `=([QRBN])` only matches those 4 characters; fallback case can never execute
-2. **GameHistory.scala:29** (`addMove$default$4` compiler-generated method) - Method overload 3 without defaults shadows the 4-param version, making promotionPiece default accessor unreachable
-3. **GameEngine.scala:201-202** (`case _` in completePromotion) - GameController.completePromotion always returns one of 4 expected MoveResult types; catch-all is defensive code
-
-**Attempted Fixes:**
-1. Added comprehensive PGN parsing tests (all 4 promotion types) - PgnParser improved from 95.8% to 99.4%
-2. Added GameHistory tests using named parameters - hit `addMove$default$3` (castleSide) but not `$default$4` (promotionPiece)
-3. Named parameter approach: `addMove(from=..., to=..., promotionPiece=...)` triggers 4-param with castleSide default ✓
-4. Positional approach: `addMove(f, t, None, None)` requires all 4 args (explicit, no defaults used) - doesn't hit $default$4
-5. Root issue: Scala's overload resolution prefers more-specific non-default overloads (2-param, 3-param) over the 4-param with defaults
-
-**Recommendation:** 99.6% (1029/1033) is maximum achievable without refactoring method overloads. Unreachable code design patterns:
-- **Pattern 1 (unreachable regex fallback):** Defensive pattern match against exhaustive regex
-- **Pattern 2 (overshadowed defaults):** Method overloads shadow default parameters in parent signature
-- **Pattern 3 (defensive catch-all):** Error handling for impossible external API returns

modules/api/CHANGELOG.md

@@ -16,3 +16,8 @@
 ### Features
 
 * NCS-21 Write Scripts to automate certain tasks ([#15](https://git.janis-eccarius.de/NowChess/NowChessSystems/issues/15)) ([8051871](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/80518719d536a087d339fe02530825dc07f8b388))
+##  (2026-04-07)
+
+### Features
+
+* NCS-21 Write Scripts to automate certain tasks ([#15](https://git.janis-eccarius.de/NowChess/NowChessSystems/issues/15)) ([8051871](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/80518719d536a087d339fe02530825dc07f8b388))

modules/api/versions.env

@@ -1,3 +1,3 @@
 MAJOR=0
-MINOR=2
+MINOR=3
 PATCH=0

modules/core/CHANGELOG.md

@@ -188,3 +188,26 @@
 * correct test board positions and captureOutput/withInput interaction ([f0481e2](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/f0481e2561b779df00925b46ee281dc36a795150))
 * update main class path in build configuration and adjust VCS directory mapping ([7b1f8b1](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/7b1f8b117623d327232a1a92a8a44d18582e0189))
 * update move validation to check for king safety ([#13](https://git.janis-eccarius.de/NowChess/NowChessSystems/issues/13)) ([e5e20c5](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/e5e20c566e368b12ca1dc59680c34e9112bf6762))
+##  (2026-04-07)
+
+### Features
+
+* add GameRules stub with PositionStatus enum ([76d4168](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/76d4168038de23e5d6083d4e8f0504fbf31d15a3))
+* add MovedInCheck/Checkmate/Stalemate MoveResult variants (stub dispatch) ([8b7ec57](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/8b7ec57e5ea6ee1615a1883848a426dc07d26364))
+* implement GameRules with isInCheck, legalMoves, gameStatus ([94a02ff](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/94a02ff6849436d9496c70a0f16c21666dae8e4e))
+* implement legal castling ([#1](https://git.janis-eccarius.de/NowChess/NowChessSystems/issues/1)) ([00d326c](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/00d326c1ba67711fbe180f04e1100c3f01dd0254))
+* NCS-10 Implement Pawn Promotion ([#12](https://git.janis-eccarius.de/NowChess/NowChessSystems/issues/12)) ([13bfc16](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/13bfc16cfe25db78ec607db523ca6d993c13430c))
+* NCS-11 50-move rule ([#9](https://git.janis-eccarius.de/NowChess/NowChessSystems/issues/9)) ([412ed98](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/412ed986a95703a3b282276540153480ceed229d))
+* NCS-16 Core Separation via Patterns ([#10](https://git.janis-eccarius.de/NowChess/NowChessSystems/issues/10)) ([1361dfc](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/1361dfc89553b146864fb8ff3526cf12cf3f293a))
+* NCS-17 Implement basic ScalaFX UI ([#14](https://git.janis-eccarius.de/NowChess/NowChessSystems/issues/14)) ([3ff8031](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/3ff80318b4f16c59733a46498581a5c27f048287))
+* NCS-21 Write Scripts to automate certain tasks ([#15](https://git.janis-eccarius.de/NowChess/NowChessSystems/issues/15)) ([8051871](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/80518719d536a087d339fe02530825dc07f8b388))
+* NCS-6 Implementing FEN & PGN ([#7](https://git.janis-eccarius.de/NowChess/NowChessSystems/issues/7)) ([f28e69d](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/f28e69dc181416aa2f221fdc4b45c2cda5efbf07))
+* NCS-9 En passant implementation ([#8](https://git.janis-eccarius.de/NowChess/NowChessSystems/issues/8)) ([919beb3](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/919beb3b4bfa8caf2f90976a415fe9b19b7e9747))
+* wire check/checkmate/stalemate into processMove and gameLoop ([5264a22](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/5264a225418b885c5e6ea6411b96f85e38837f6c))
+
+### Bug Fixes
+
+* add missing kings to gameLoop capture test board ([aedd787](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/aedd787b77203c2af934751dba7b784eaf165032))
+* correct test board positions and captureOutput/withInput interaction ([f0481e2](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/f0481e2561b779df00925b46ee281dc36a795150))
+* update main class path in build configuration and adjust VCS directory mapping ([7b1f8b1](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/7b1f8b117623d327232a1a92a8a44d18582e0189))
+* update move validation to check for king safety ([#13](https://git.janis-eccarius.de/NowChess/NowChessSystems/issues/13)) ([e5e20c5](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/e5e20c566e368b12ca1dc59680c34e9112bf6762))

modules/core/src/main/scala/de/nowchess/chess/engine/GameEngine.scala

@@ -88,7 +88,7 @@ class GameEngine(
       case Some(piece) if piece.color != currentContext.turn =>
         notifyObservers(InvalidMoveEvent(currentContext, "That is not your piece."))
       case Some(piece) =>
-        val legal = ruleSet.legalMoves(currentContext, from)
+        val legal = ruleSet.legalMoves(currentContext)(from)
         // Find all legal moves going to `to`
         val candidates = legal.filter(_.to == to)
         candidates match
@@ -119,7 +119,7 @@ class GameEngine(
         pendingPromotion = None
         val move = Move(pending.from, pending.to, MoveType.Promotion(piece))
         // Verify it's actually legal
-        val legal = ruleSet.legalMoves(currentContext, pending.from)
+        val legal = ruleSet.legalMoves(currentContext)(pending.from)
         if legal.contains(move) then
           executeMove(move)
         else
@@ -203,7 +203,7 @@ class GameEngine(
 
   private def executeMove(move: Move): Unit =
     val contextBefore = currentContext
-    val nextContext = ruleSet.applyMove(currentContext, move)
+    val nextContext = ruleSet.applyMove(currentContext)(move)
     val captured = computeCaptured(currentContext, move)
 
     val cmd = MoveCommand(

modules/core/src/test/scala/de/nowchess/chess/engine/GameEngineIntegrationTest.scala

@@ -89,8 +89,8 @@ class GameEngineIntegrationTest extends AnyFunSuite with Matchers:
     val promotionMove = Move(sq("e2"), sq("e8"), MoveType.Promotion(PromotionPiece.Queen))
 
     val permissiveRules = new RuleSet:
-      def candidateMoves(context: GameContext, square: Square): List[Move] = legalMoves(context, square)
-      def legalMoves(context: GameContext, square: Square): List[Move] =
+      def candidateMoves(context: GameContext)(square: Square): List[Move] = legalMoves(context)(square)
+      def legalMoves(context: GameContext)(square: Square): List[Move] =
         if square == sq("e2") then List(promotionMove) else List.empty
       def allLegalMoves(context: GameContext): List[Move] = List(promotionMove)
       def isCheck(context: GameContext): Boolean = false
@@ -98,7 +98,7 @@ class GameEngineIntegrationTest extends AnyFunSuite with Matchers:
       def isStalemate(context: GameContext): Boolean = false
       def isInsufficientMaterial(context: GameContext): Boolean = false
       def isFiftyMoveRule(context: GameContext): Boolean = false
-      def applyMove(context: GameContext, move: Move): GameContext = DefaultRules.applyMove(context, move)
+      def applyMove(context: GameContext)(move: Move): GameContext = DefaultRules.applyMove(context)(move)
 
     val engine = new GameEngine(ruleSet = permissiveRules)
     val importer = new GameContextImport:
@@ -111,15 +111,15 @@ class GameEngineIntegrationTest extends AnyFunSuite with Matchers:
   test("loadGame replay restores previous context when promotion cannot be completed"):
     val promotionMove = Move(sq("e2"), sq("e8"), MoveType.Promotion(PromotionPiece.Queen))
     val noLegalMoves = new RuleSet:
-      def candidateMoves(context: GameContext, square: Square): List[Move] = List.empty
-      def legalMoves(context: GameContext, square: Square): List[Move] = List.empty
+      def candidateMoves(context: GameContext)(square: Square): List[Move] = List.empty
+      def legalMoves(context: GameContext)(square: Square): List[Move] = List.empty
       def allLegalMoves(context: GameContext): List[Move] = List.empty
       def isCheck(context: GameContext): Boolean = false
       def isCheckmate(context: GameContext): Boolean = false
       def isStalemate(context: GameContext): Boolean = false
       def isInsufficientMaterial(context: GameContext): Boolean = false
       def isFiftyMoveRule(context: GameContext): Boolean = false
-      def applyMove(context: GameContext, move: Move): GameContext = context
+      def applyMove(context: GameContext)(move: Move): GameContext = context
 
     val engine = new GameEngine(ruleSet = noLegalMoves)
     engine.processUserInput("e2e4")

modules/core/src/test/scala/de/nowchess/chess/engine/GameEnginePromotionTest.scala

@@ -153,10 +153,10 @@ class GameEnginePromotionTest extends AnyFunSuite with Matchers:
     // This makes completePromotion unable to find Move(from, to, Promotion(Queen)),
     // triggering the "Error completing promotion." branch.
     val delegatingRuleSet: RuleSet = new RuleSet:
-      def candidateMoves(context: GameContext, square: Square): List[Move] =
-        DefaultRules.candidateMoves(context, square)
-      def legalMoves(context: GameContext, square: Square): List[Move] =
-        DefaultRules.legalMoves(context, square).map { m =>
+      def candidateMoves(context: GameContext)(square: Square): List[Move] =
+        DefaultRules.candidateMoves(context)(square)
+      def legalMoves(context: GameContext)(square: Square): List[Move] =
+        DefaultRules.legalMoves(context)(square).map { m =>
           m.moveType match
             case MoveType.Promotion(_) => Move(m.from, m.to, MoveType.Normal())
             case _                     => m
@@ -173,8 +173,8 @@ class GameEnginePromotionTest extends AnyFunSuite with Matchers:
         DefaultRules.isInsufficientMaterial(context)
       def isFiftyMoveRule(context: GameContext): Boolean =
         DefaultRules.isFiftyMoveRule(context)
-      def applyMove(context: GameContext, move: Move): GameContext =
-        DefaultRules.applyMove(context, move)
+      def applyMove(context: GameContext)(move: Move): GameContext =
+        DefaultRules.applyMove(context)(move)
 
     val promotionBoard = FenParser.parseBoard("8/4P3/4k3/8/8/8/8/8").get
     val initialCtx = GameContext.initial.withBoard(promotionBoard).withTurn(Color.White)

modules/core/versions.env

@@ -1,3 +1,3 @@
 MAJOR=0
-MINOR=10
+MINOR=11
 PATCH=0

modules/io/CHANGELOG.md

@@ -0,0 +1,7 @@
+##  (2026-04-06)
+##  (2026-04-07)
+##  (2026-04-07)
+
+### Features
+
+* NCS-30 FEN Parser using ParserCombinators ([#21](https://git.janis-eccarius.de/NowChess/NowChessSystems/issues/21)) ([b4bc72f](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/b4bc72f7e49f94d6e1bc805c68680e5fe8ef8e36))

modules/io/build.gradle.kts

@@ -38,6 +38,9 @@ dependencies {
         }
     }
 
+    implementation("org.scala-lang.modules:scala-parser-combinators_3:${versions["SCALA_PARSER_COMBINATORS"]!!}")
+    implementation("com.lihaoyi:fastparse_3:${versions["FASTPARSE"]!!}")
+
     implementation(project(":modules:api"))
     implementation(project(":modules:rule"))
 

modules/io/src/main/scala/de/nowchess/io/fen/FenParserCombinators.scala

@@ -0,0 +1,120 @@
+package de.nowchess.io.fen
+
+import de.nowchess.api.board.*
+import de.nowchess.api.game.GameContext
+import de.nowchess.io.GameContextImport
+import scala.util.parsing.combinator.RegexParsers
+import FenParserSupport.*
+
+object FenParserCombinators extends RegexParsers with GameContextImport:
+
+  override val skipWhitespace: Boolean = false
+
+  // ── Piece character ──────────────────────────────────────────────────────
+
+  private def pieceChar: Parser[Piece] =
+    "[prnbqkPRNBQK]".r ^^ { s =>
+      val c = s.head
+      val color = if c.isUpper then Color.White else Color.Black
+      Piece(color, charToPieceType(c.toLower))
+    }
+
+  private def emptyCount: Parser[Int] =
+    "[1-8]".r ^^ { s => s.toInt }
+
+  // ── Rank parser ──────────────────────────────────────────────────────────
+
+  private def rankToken: Parser[RankToken] =
+    pieceChar ^^ PieceToken.apply | emptyCount ^^ EmptyToken.apply
+
+  private def rankTokens: Parser[List[RankToken]] = rep1(rankToken)
+
+  /** Parse rank string for a given Rank, producing (Square, Piece) pairs.
+   *  Fails if total file count != 8 or any piece placement exceeds board bounds. */
+  private def rankParser(rank: Rank): Parser[List[(Square, Piece)]] =
+    rankTokens >> { tokens =>
+      buildSquares(rank, tokens) match
+        case Some(squares) => success(squares)
+        case None          => failure(s"Rank $rank is invalid")
+    }
+
+  // ── Board parser ─────────────────────────────────────────────────────────
+
+  private def rankSep: Parser[String] = "/"
+
+  /** Parse all 8 rank strings separated by '/', rank 8 down to rank 1. */
+  private def boardParser: Parser[Board] =
+    rankParser(Rank.R8) ~
+    (rankSep ~> rankParser(Rank.R7)) ~
+    (rankSep ~> rankParser(Rank.R6)) ~
+    (rankSep ~> rankParser(Rank.R5)) ~
+    (rankSep ~> rankParser(Rank.R4)) ~
+    (rankSep ~> rankParser(Rank.R3)) ~
+    (rankSep ~> rankParser(Rank.R2)) ~
+    (rankSep ~> rankParser(Rank.R1)) ^^ {
+      case r8 ~ r7 ~ r6 ~ r5 ~ r4 ~ r3 ~ r2 ~ r1 =>
+        Board((r8 ++ r7 ++ r6 ++ r5 ++ r4 ++ r3 ++ r2 ++ r1).toMap)
+    }
+
+  // ── Color parser ─────────────────────────────────────────────────────────
+
+  private def colorParser: Parser[Color] =
+    ("w" | "b") ^^ {
+      case "w" => Color.White
+      case _   => Color.Black
+    }
+
+  // ── Castling parser ──────────────────────────────────────────────────────
+
+  private def castlingParser: Parser[CastlingRights] =
+    "-" ^^^ CastlingRights.None |
+    "[KQkq]{1,4}".r ^^ { s =>
+      CastlingRights(
+        whiteKingSide  = s.contains('K'),
+        whiteQueenSide = s.contains('Q'),
+        blackKingSide  = s.contains('k'),
+        blackQueenSide = s.contains('q')
+      )
+    }
+
+  // ── En passant parser ────────────────────────────────────────────────────
+
+  private def enPassantParser: Parser[Option[Square]] =
+    "-" ^^^ Option.empty[Square] |
+    "[a-h][1-8]".r ^^ { s => Square.fromAlgebraic(s) }
+
+  // ── Clock parser ─────────────────────────────────────────────────────────
+
+  private def clockParser: Parser[Int] =
+    """\d+""".r ^^ { _.toInt }
+
+  // ── Full FEN parser ──────────────────────────────────────────────────────
+
+  private def fenParser: Parser[GameContext] =
+    boardParser ~ (" " ~> colorParser) ~ (" " ~> castlingParser) ~
+    (" " ~> enPassantParser) ~ (" " ~> clockParser) ~ (" " ~> clockParser) ^^ {
+      case board ~ color ~ castling ~ ep ~ halfMove ~ _ =>
+        GameContext(
+          board          = board,
+          turn           = color,
+          castlingRights = castling,
+          enPassantSquare = ep,
+          halfMoveClock  = halfMove,
+          moves          = List.empty
+        )
+    }
+
+  // ── Public API ───────────────────────────────────────────────────────────
+
+  def parseFen(fen: String): Either[String, GameContext] =
+    parseAll(fenParser, fen) match
+      case Success(ctx, _) => Right(ctx)
+      case other           => Left(s"Invalid FEN: ${other.toString}")
+
+  def parseBoard(fen: String): Option[Board] =
+    parseAll(boardParser, fen) match
+      case Success(board, _) => Some(board)
+      case _                 => None
+
+  def importGameContext(input: String): Either[String, GameContext] =
+    parseFen(input)

modules/io/src/main/scala/de/nowchess/io/fen/FenParserFastParse.scala

@@ -0,0 +1,120 @@
+package de.nowchess.io.fen
+
+import fastparse.*
+import fastparse.NoWhitespace.*
+import de.nowchess.api.board.*
+import de.nowchess.api.game.GameContext
+import de.nowchess.io.GameContextImport
+import FenParserSupport.*
+
+object FenParserFastParse extends GameContextImport:
+
+  // ── Low-level parsers ────────────────────────────────────────────────────
+
+  private def pieceChar(using P[Any]): P[Piece] =
+    CharIn("prnbqkPRNBQK").!.map { s =>
+      val c = s.head
+      val color = if c.isUpper then Color.White else Color.Black
+      Piece(color, charToPieceType(c.toLower))
+    }
+
+  private def emptyCount(using P[Any]): P[Int] =
+    CharIn("1-8").!.map(_.toInt)
+
+  private def rankToken(using P[Any]): P[RankToken] =
+    pieceChar.map(PieceToken.apply) | emptyCount.map(EmptyToken.apply)
+
+  // ── Rank parser ──────────────────────────────────────────────────────────
+
+  private def rankParser(rank: Rank)(using P[Any]): P[List[(Square, Piece)]] =
+    rankToken.rep(1).flatMap { tokens =>
+      buildSquares(rank, tokens) match
+        case Some(squares) => Pass(squares)
+        case None          => Fail
+    }
+
+  // ── Board parser ─────────────────────────────────────────────────────────
+
+  private def sep(using P[Any]): P[Unit] = LiteralStr("/").map(_ => ())
+
+  private def boardParser(using P[Any]): P[Board] =
+    (rankParser(Rank.R8) ~ sep ~
+     rankParser(Rank.R7) ~ sep ~
+     rankParser(Rank.R6) ~ sep ~
+     rankParser(Rank.R5) ~ sep ~
+     rankParser(Rank.R4) ~ sep ~
+     rankParser(Rank.R3) ~ sep ~
+     rankParser(Rank.R2) ~ sep ~
+     rankParser(Rank.R1)).map { case (r8, r7, r6, r5, r4, r3, r2, r1) =>
+      Board((r8 ++ r7 ++ r6 ++ r5 ++ r4 ++ r3 ++ r2 ++ r1).toMap)
+    }
+
+  // ── Color parser ─────────────────────────────────────────────────────────
+
+  private def colorParser(using P[Any]): P[Color] =
+    (LiteralStr("w") | LiteralStr("b")).!.map {
+      case "w" => Color.White
+      case _   => Color.Black
+    }
+
+  // ── Castling parser ──────────────────────────────────────────────────────
+
+  private def castlingParser(using P[Any]): P[CastlingRights] =
+    LiteralStr("-").map(_ => CastlingRights.None) |
+    CharsWhileIn("KQkq").!.map { s =>
+      CastlingRights(
+        whiteKingSide  = s.contains('K'),
+        whiteQueenSide = s.contains('Q'),
+        blackKingSide  = s.contains('k'),
+        blackQueenSide = s.contains('q')
+      )
+    }
+
+  // ── En passant parser ────────────────────────────────────────────────────
+
+  private def enPassantParser(using P[Any]): P[Option[Square]] =
+    LiteralStr("-").map(_ => Option.empty[Square]) |
+    (CharIn("a-h") ~ CharIn("1-8")).!.map(s => Square.fromAlgebraic(s))
+
+  // ── Clock parser ─────────────────────────────────────────────────────────
+
+  private def clockParser(using P[Any]): P[Int] =
+    CharsWhileIn("0-9").!.map(_.toInt)
+
+  // ── Space helper ─────────────────────────────────────────────────────────
+
+  private def sp(using P[Any]): P[Unit] = LiteralStr(" ").map(_ => ())
+
+  // ── Full FEN parser ──────────────────────────────────────────────────────
+
+  private def fenParser(using P[Any]): P[GameContext] =
+    (boardParser ~ sp ~ colorParser ~ sp ~ castlingParser ~ sp ~
+     enPassantParser ~ sp ~ clockParser ~ sp ~ clockParser ~ End).map {
+      case (board, color, castling, ep, halfMove, _) =>
+        GameContext(
+          board           = board,
+          turn            = color,
+          castlingRights  = castling,
+          enPassantSquare = ep,
+          halfMoveClock   = halfMove,
+          moves           = List.empty
+        )
+    }
+
+  // ── Public API ───────────────────────────────────────────────────────────
+
+  def parseFen(fen: String): Either[String, GameContext] =
+    parse(fen, fenParser(using _)) match
+      case Parsed.Success(ctx, _) => Right(ctx)
+      case f: Parsed.Failure      => Left(s"Invalid FEN: ${f.msg}")
+
+  private def boardParserFull(using P[Any]): P[Board] =
+    boardParser ~ End
+
+  def parseBoard(fen: String): Option[Board] =
+    parse(fen, boardParserFull(using _)) match
+      case Parsed.Success(board, _) => Some(board)
+      case _                        => None
+
+  def importGameContext(input: String): Either[String, GameContext] =
+    parseFen(input)

modules/io/src/main/scala/de/nowchess/io/fen/FenParserSupport.scala

@@ -0,0 +1,32 @@
+package de.nowchess.io.fen
+
+import de.nowchess.api.board.*
+
+private[fen] object FenParserSupport:
+
+  sealed trait RankToken
+  case class PieceToken(piece: Piece) extends RankToken
+  case class EmptyToken(count: Int)   extends RankToken
+
+  val charToPieceType: Map[Char, PieceType] = Map(
+    'p' -> PieceType.Pawn,
+    'r' -> PieceType.Rook,
+    'n' -> PieceType.Knight,
+    'b' -> PieceType.Bishop,
+    'q' -> PieceType.Queen,
+    'k' -> PieceType.King
+  )
+
+  def buildSquares(rank: Rank, tokens: Seq[RankToken]): Option[List[(Square, Piece)]] =
+    tokens.foldLeft(Option((List.empty[(Square, Piece)], 0))):
+      case (None, _) => None
+      case (Some((acc, fileIdx)), PieceToken(piece)) =>
+        if fileIdx > 7 then None
+        else
+          val sq = Square(File.values(fileIdx), rank)
+          Some((acc :+ (sq -> piece), fileIdx + 1))
+      case (Some((acc, fileIdx)), EmptyToken(n)) =>
+        val next = fileIdx + n
+        if next > 8 then None
+        else Some((acc, next))
+    .flatMap { case (squares, total) => if total == 8 then Some(squares) else None }

modules/io/src/main/scala/de/nowchess/io/pgn/PgnExporter.scala

@@ -30,7 +30,7 @@ object PgnExporter extends GameContextExport:
       var ctx = GameContext.initial
       val sanMoves = moves.map { move =>
         val algebraic = moveToAlgebraic(move, ctx.board)
-        ctx = DefaultRules.applyMove(ctx, move)
+        ctx = DefaultRules.applyMove(ctx)(move)
         algebraic
       }
 

modules/io/src/main/scala/de/nowchess/io/pgn/PgnParser.scala

@@ -29,7 +29,7 @@ object PgnParser extends GameContextImport:
    *  Returns Left(error message) if validation fails or move replay encounters an issue. */
   def importGameContext(input: String): Either[String, GameContext] =
     validatePgn(input).flatMap { game =>
-      Right(game.moves.foldLeft(GameContext.initial)(DefaultRules.applyMove))
+      Right(game.moves.foldLeft(GameContext.initial)((ctx, move) => DefaultRules.applyMove(ctx)(move)))
     }
 
   /** Parse a complete PGN text into a PgnGame with headers and moves.
@@ -59,7 +59,7 @@ object PgnParser extends GameContextImport:
           parseAlgebraicMove(token, ctx, color) match
             case None       => state
             case Some(move) =>
-              val nextCtx    = DefaultRules.applyMove(ctx, move)
+              val nextCtx    = DefaultRules.applyMove(ctx)(move)
               (nextCtx, color.opposite, acc :+ move)
     moves
 
@@ -77,12 +77,12 @@ object PgnParser extends GameContextImport:
       case "O-O" | "O-O+" | "O-O#" =>
         val rank = if color == Color.White then Rank.R1 else Rank.R8
         val move = Move(Square(File.E, rank), Square(File.G, rank), MoveType.CastleKingside)
-        Option.when(DefaultRules.legalMoves(ctx, Square(File.E, rank)).contains(move))(move)
+        Option.when(DefaultRules.legalMoves(ctx)(Square(File.E, rank)).contains(move))(move)
 
       case "O-O-O" | "O-O-O+" | "O-O-O#" =>
         val rank = if color == Color.White then Rank.R1 else Rank.R8
         val move = Move(Square(File.E, rank), Square(File.C, rank), MoveType.CastleQueenside)
-        Option.when(DefaultRules.legalMoves(ctx, Square(File.E, rank)).contains(move))(move)
+        Option.when(DefaultRules.legalMoves(ctx)(Square(File.E, rank)).contains(move))(move)
 
       case _ =>
         parseRegularMove(notation, ctx, color)
@@ -176,7 +176,7 @@ object PgnParser extends GameContextImport:
             parseAlgebraicMove(token, ctx, color) match
               case None       => Left(s"Illegal or impossible move: '$token'")
               case Some(move) =>
-                val nextCtx  = DefaultRules.applyMove(ctx, move)
+                val nextCtx  = DefaultRules.applyMove(ctx)(move)
                 Right((nextCtx, color.opposite, moves :+ move))
         }
     }.map(_._3)

modules/io/src/test/scala/de/nowchess/io/fen/FenParserCombinatorsTest.scala

@@ -0,0 +1,60 @@
+package de.nowchess.io.fen
+
+import de.nowchess.api.board.*
+import org.scalatest.funsuite.AnyFunSuite
+import org.scalatest.matchers.should.Matchers
+
+class FenParserCombinatorsTest extends AnyFunSuite with Matchers:
+
+  test("parseBoard parses canonical positions and supports round-trip"):
+    val initial = "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR"
+    val empty = "8/8/8/8/8/8/8/8"
+    val partial = "8/8/4k3/8/4K3/8/8/8"
+
+    FenParserCombinators.parseBoard(initial).map(_.pieceAt(Square(File.E, Rank.R2))) shouldBe Some(Some(Piece.WhitePawn))
+    FenParserCombinators.parseBoard(initial).map(_.pieceAt(Square(File.E, Rank.R8))) shouldBe Some(Some(Piece.BlackKing))
+    FenParserCombinators.parseBoard(empty).map(_.pieces.size) shouldBe Some(0)
+    FenParserCombinators.parseBoard(partial).map(_.pieceAt(Square(File.E, Rank.R6))) shouldBe Some(Some(Piece.BlackKing))
+
+    FenParserCombinators.parseBoard(initial).map(FenExporter.boardToFen) shouldBe Some(initial)
+    FenParserCombinators.parseBoard(empty).map(FenExporter.boardToFen) shouldBe Some(empty)
+
+  test("parseFen parses full state for common valid inputs"):
+    FenParserCombinators.parseFen("rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1").fold(_ => fail(), ctx =>
+      ctx.turn shouldBe Color.White
+      ctx.castlingRights.whiteKingSide shouldBe true
+      ctx.enPassantSquare shouldBe None
+      ctx.halfMoveClock shouldBe 0
+    )
+
+    FenParserCombinators.parseFen("rnbqkbnr/pppppppp/8/8/4P3/8/PPPP1PPP/RNBQKBNR b KQkq e3 0 1").fold(_ => fail(), ctx =>
+      ctx.turn shouldBe Color.Black
+      ctx.enPassantSquare shouldBe Some(Square(File.E, Rank.R3))
+    )
+
+    FenParserCombinators.parseFen("rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w - - 0 1").fold(_ => fail(), ctx =>
+      ctx.castlingRights.whiteKingSide shouldBe false
+      ctx.castlingRights.blackQueenSide shouldBe false
+    )
+
+  test("parseFen rejects invalid color and castling tokens"):
+    FenParserCombinators.parseFen("rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR x KQkq - 0 1").isLeft shouldBe true
+    FenParserCombinators.parseFen("rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w XYZ - 0 1").isLeft shouldBe true
+
+  test("importGameContext returns Right for valid and Left for invalid FEN"):
+    val fen = "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1"
+    FenParserCombinators.importGameContext(fen).isRight shouldBe true
+    FenParserCombinators.importGameContext("invalid fen string").isLeft shouldBe true
+
+  test("parseBoard rejects malformed board shapes and invalid piece symbols"):
+    FenParserCombinators.parseBoard("8/8/8/8/8/8/8") shouldBe None
+    FenParserCombinators.parseBoard("9/8/8/8/8/8/8/8") shouldBe None
+    FenParserCombinators.parseBoard("8p/8/8/8/8/8/8/8") shouldBe None
+    FenParserCombinators.parseBoard("7/8/8/8/8/8/8/8") shouldBe None
+    FenParserCombinators.parseBoard("8/8/8/8/8/8/8/7X") shouldBe None
+
+  test("parseBoard rejects ranks that overflow via multiple tokens"):
+    // EmptyToken overflow: piece then 8 empties = 9 total
+    FenParserCombinators.parseBoard("p8/8/8/8/8/8/8/8") shouldBe None
+    // fold short-circuit: 8 empties followed by two pieces = 10 total, exercises the None-propagation path
+    FenParserCombinators.parseBoard("8pp/8/8/8/8/8/8/8") shouldBe None

modules/io/src/test/scala/de/nowchess/io/fen/FenParserFastParseTest.scala

@@ -0,0 +1,58 @@
+package de.nowchess.io.fen
+
+import de.nowchess.api.board.*
+import org.scalatest.funsuite.AnyFunSuite
+import org.scalatest.matchers.should.Matchers
+
+class FenParserFastParseTest extends AnyFunSuite with Matchers:
+
+  test("parseBoard parses canonical positions and supports round-trip"):
+    val initial = "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR"
+    val empty = "8/8/8/8/8/8/8/8"
+    val partial = "8/8/4k3/8/4K3/8/8/8"
+
+    FenParserFastParse.parseBoard(initial).map(_.pieceAt(Square(File.E, Rank.R2))) shouldBe Some(Some(Piece.WhitePawn))
+    FenParserFastParse.parseBoard(initial).map(_.pieceAt(Square(File.E, Rank.R8))) shouldBe Some(Some(Piece.BlackKing))
+    FenParserFastParse.parseBoard(empty).map(_.pieces.size) shouldBe Some(0)
+    FenParserFastParse.parseBoard(partial).map(_.pieceAt(Square(File.E, Rank.R6))) shouldBe Some(Some(Piece.BlackKing))
+
+    FenParserFastParse.parseBoard(initial).map(FenExporter.boardToFen) shouldBe Some(initial)
+    FenParserFastParse.parseBoard(empty).map(FenExporter.boardToFen) shouldBe Some(empty)
+
+  test("parseFen parses full state for common valid inputs"):
+    FenParserFastParse.parseFen("rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1").fold(_ => fail(), ctx =>
+      ctx.turn shouldBe Color.White
+      ctx.castlingRights.whiteKingSide shouldBe true
+      ctx.enPassantSquare shouldBe None
+      ctx.halfMoveClock shouldBe 0
+    )
+
+    FenParserFastParse.parseFen("rnbqkbnr/pppppppp/8/8/4P3/8/PPPP1PPP/RNBQKBNR b KQkq e3 0 1").fold(_ => fail(), ctx =>
+      ctx.turn shouldBe Color.Black
+      ctx.enPassantSquare shouldBe Some(Square(File.E, Rank.R3))
+    )
+
+    FenParserFastParse.parseFen("rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w - - 0 1").fold(_ => fail(), ctx =>
+      ctx.castlingRights.whiteKingSide shouldBe false
+      ctx.castlingRights.blackQueenSide shouldBe false
+    )
+
+  test("parseFen rejects invalid color and castling tokens"):
+    FenParserFastParse.parseFen("rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR x KQkq - 0 1").isLeft shouldBe true
+    FenParserFastParse.parseFen("rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w XYZ - 0 1").isLeft shouldBe true
+
+  test("importGameContext returns Right for valid and Left for invalid FEN"):
+    val fen = "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1"
+    FenParserFastParse.importGameContext(fen).isRight shouldBe true
+    FenParserFastParse.importGameContext("invalid fen string").isLeft shouldBe true
+
+  test("parseBoard rejects malformed board shapes and invalid piece symbols"):
+    FenParserFastParse.parseBoard("8/8/8/8/8/8/8") shouldBe None
+    FenParserFastParse.parseBoard("9/8/8/8/8/8/8/8") shouldBe None
+    FenParserFastParse.parseBoard("8p/8/8/8/8/8/8/8") shouldBe None
+    FenParserFastParse.parseBoard("7/8/8/8/8/8/8/8") shouldBe None
+    FenParserFastParse.parseBoard("8/8/8/8/8/8/8/7X") shouldBe None
+
+  test("parseBoard rejects ranks that overflow via multiple tokens"):
+    FenParserFastParse.parseBoard("p8/8/8/8/8/8/8/8") shouldBe None
+    FenParserFastParse.parseBoard("8pp/8/8/8/8/8/8/8") shouldBe None

modules/io/versions.env

@@ -0,0 +1,3 @@
+MAJOR=0
+MINOR=1
+PATCH=0

modules/rule/CHANGELOG.md

@@ -0,0 +1,7 @@
+##  (2026-04-06)
+##  (2026-04-07)
+##  (2026-04-07)
+
+### Bug Fixes
+
+* NCS-32 Queenside Castle doesn't care about pieces in the way ([#23](https://git.janis-eccarius.de/NowChess/NowChessSystems/issues/23)) ([fe8e3c0](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/fe8e3c05397f433bfa34d1999e9738c82790adf7))

modules/rule/src/main/scala/de/nowchess/rules/RuleSet.scala

@@ -9,10 +9,10 @@ import de.nowchess.api.move.Move
  */
 trait RuleSet:
   /** All pseudo-legal moves for the piece on `square` (ignores check). */
-  def candidateMoves(context: GameContext, square: Square): List[Move]
+  def candidateMoves(context: GameContext)(square: Square): List[Move]
 
   /** Legal moves for `square`: candidates that don't leave own king in check. */
-  def legalMoves(context: GameContext, square: Square): List[Move]
+  def legalMoves(context: GameContext)(square: Square): List[Move]
 
   /** All legal moves for the side to move. */
   def allLegalMoves(context: GameContext): List[Move]
@@ -36,4 +36,4 @@ trait RuleSet:
    *  Handles all special move types: castling, en passant, promotion.
    *  Updates castling rights, en passant square, half-move clock, turn, and move history.
    */
-  def applyMove(context: GameContext, move: Move): GameContext
+  def applyMove(context: GameContext)(move: Move): GameContext

modules/rule/src/main/scala/de/nowchess/rules/sets/DefaultRules.scala

@@ -26,7 +26,7 @@ object DefaultRules extends RuleSet:
 
   // ── Public API ─────────────────────────────────────────────────────
 
-  override def candidateMoves(context: GameContext, square: Square): List[Move] =
+  override def candidateMoves(context: GameContext)(square: Square): List[Move] =
     context.board.pieceAt(square).fold(List.empty[Move]) { piece =>
       if piece.color != context.turn then List.empty[Move]
       else piece.pieceType match
@@ -38,13 +38,13 @@ object DefaultRules extends RuleSet:
         case PieceType.King => kingCandidates(context, square, piece.color)
     }
 
-  override def legalMoves(context: GameContext, square: Square): List[Move] =
-    candidateMoves(context, square).filter { move =>
+  override def legalMoves(context: GameContext)(square: Square): List[Move] =
+    candidateMoves(context)(square).filter { move =>
       !leavesKingInCheck(context, move)
     }
 
   override def allLegalMoves(context: GameContext): List[Move] =
-    Square.all.flatMap(sq => legalMoves(context, sq)).toList
+    Square.all.flatMap(sq => legalMoves(context)(sq)).toList
 
   override def isCheck(context: GameContext): Boolean =
     kingSquare(context.board, context.turn)
@@ -163,6 +163,12 @@ object DefaultRules extends RuleSet:
         CastlingMove("e8", "c8", "d8", "a8", MoveType.CastleQueenside))
       moves.toList
 
+  private def queensideBSquare(kingToAlg: String): List[String] =
+    kingToAlg match
+      case "c1" => List("b1")
+      case "c8" => List("b8")
+      case _    => List.empty
+
   private def addCastleMove(
     context: GameContext,
     moves: scala.collection.mutable.ListBuffer[Move],
@@ -170,7 +176,8 @@ object DefaultRules extends RuleSet:
     castlingMove: CastlingMove
   ): Unit =
     if castlingRight then
-      val clearSqs = List(castlingMove.middleAlg, castlingMove.kingToAlg).flatMap(Square.fromAlgebraic)
+      val clearSqs = (List(castlingMove.middleAlg, castlingMove.kingToAlg) ++ queensideBSquare(castlingMove.kingToAlg))
+        .flatMap(Square.fromAlgebraic)
       if squaresEmpty(context.board, clearSqs) then
         for
           kf <- Square.fromAlgebraic(castlingMove.kingFromAlg)
@@ -284,7 +291,7 @@ object DefaultRules extends RuleSet:
 
   // ── Move application ───────────────────────────────────────────────
 
-  override def applyMove(context: GameContext, move: Move): GameContext =
+  override def applyMove(context: GameContext)(move: Move): GameContext =
     val color = context.turn
     val board  = context.board
 

modules/rule/src/test/scala/de/nowchess/rule/DefaultRulesStateTransitionsTest.scala

@@ -52,14 +52,14 @@ class DefaultRulesStateTransitionsTest extends AnyFunSuite with Matchers:
 
   test("applyMove toggles turn and records move"):
     val move = Move(sq("e2"), sq("e4"))
-    val next = DefaultRules.applyMove(GameContext.initial, move)
+    val next = DefaultRules.applyMove(GameContext.initial)(move)
 
     next.turn shouldBe Color.Black
     next.moves.lastOption shouldBe Some(move)
 
   test("applyMove sets en passant square after double pawn push"):
     val move = Move(sq("e2"), sq("e4"))
-    val next = DefaultRules.applyMove(GameContext.initial, move)
+    val next = DefaultRules.applyMove(GameContext.initial)(move)
 
     next.enPassantSquare shouldBe Some(sq("e3"))
 
@@ -67,7 +67,7 @@ class DefaultRulesStateTransitionsTest extends AnyFunSuite with Matchers:
     val context = contextFromFen("4k3/8/8/8/8/8/4P3/4K3 w - d6 3 1")
     val move = Move(sq("e2"), sq("e3"))
 
-    val next = DefaultRules.applyMove(context, move)
+    val next = DefaultRules.applyMove(context)(move)
 
     next.enPassantSquare shouldBe None
 
@@ -75,7 +75,7 @@ class DefaultRulesStateTransitionsTest extends AnyFunSuite with Matchers:
     val context = contextFromFen("4k3/8/8/8/8/8/4P3/4K3 w - - 12 1")
     val move = Move(sq("e2"), sq("e4"))
 
-    val next = DefaultRules.applyMove(context, move)
+    val next = DefaultRules.applyMove(context)(move)
 
     next.halfMoveClock shouldBe 0
 
@@ -83,7 +83,7 @@ class DefaultRulesStateTransitionsTest extends AnyFunSuite with Matchers:
     val context = contextFromFen("4k3/8/8/8/8/8/8/4K1N1 w - - 7 1")
     val move = Move(sq("g1"), sq("f3"))
 
-    val next = DefaultRules.applyMove(context, move)
+    val next = DefaultRules.applyMove(context)(move)
 
     next.halfMoveClock shouldBe 8
 
@@ -91,7 +91,7 @@ class DefaultRulesStateTransitionsTest extends AnyFunSuite with Matchers:
     val context = contextFromFen("r3k3/8/8/8/8/8/8/R3K3 w Qq - 9 1")
     val move = Move(sq("a1"), sq("a8"), MoveType.Normal(isCapture = true))
 
-    val next = DefaultRules.applyMove(context, move)
+    val next = DefaultRules.applyMove(context)(move)
 
     next.halfMoveClock shouldBe 0
     next.board.pieceAt(sq("a8")) shouldBe Some(Piece(Color.White, PieceType.Rook))
@@ -100,7 +100,7 @@ class DefaultRulesStateTransitionsTest extends AnyFunSuite with Matchers:
     val context = contextFromFen("r3k2r/8/8/8/8/8/8/R3K2R w KQkq - 0 1")
     val move = Move(sq("e1"), sq("e2"))
 
-    val next = DefaultRules.applyMove(context, move)
+    val next = DefaultRules.applyMove(context)(move)
 
     next.castlingRights.whiteKingSide shouldBe false
     next.castlingRights.whiteQueenSide shouldBe false
@@ -111,7 +111,7 @@ class DefaultRulesStateTransitionsTest extends AnyFunSuite with Matchers:
     val context = contextFromFen("r3k2r/8/8/8/8/8/8/4K2R w KQkq - 0 1")
     val move = Move(sq("h1"), sq("h2"))
 
-    val next = DefaultRules.applyMove(context, move)
+    val next = DefaultRules.applyMove(context)(move)
 
     next.castlingRights.whiteKingSide shouldBe false
     next.castlingRights.whiteQueenSide shouldBe true
@@ -120,7 +120,7 @@ class DefaultRulesStateTransitionsTest extends AnyFunSuite with Matchers:
     val context = contextFromFen("r3k3/8/8/8/8/8/8/R3K3 w Qq - 2 1")
     val move = Move(sq("a1"), sq("a8"), MoveType.Normal(isCapture = true))
 
-    val next = DefaultRules.applyMove(context, move)
+    val next = DefaultRules.applyMove(context)(move)
 
     next.castlingRights.blackQueenSide shouldBe false
 
@@ -128,7 +128,7 @@ class DefaultRulesStateTransitionsTest extends AnyFunSuite with Matchers:
     val context = contextFromFen("4k2r/8/8/8/8/8/8/R3K2R w KQk - 0 1")
     val move = Move(sq("e1"), sq("g1"), MoveType.CastleKingside)
 
-    val next = DefaultRules.applyMove(context, move)
+    val next = DefaultRules.applyMove(context)(move)
 
     next.board.pieceAt(sq("g1")) shouldBe Some(Piece(Color.White, PieceType.King))
     next.board.pieceAt(sq("f1")) shouldBe Some(Piece(Color.White, PieceType.Rook))
@@ -139,7 +139,7 @@ class DefaultRulesStateTransitionsTest extends AnyFunSuite with Matchers:
     val context = contextFromFen("r3k3/8/8/8/8/8/8/R3K2R w KQq - 0 1")
     val move = Move(sq("e1"), sq("c1"), MoveType.CastleQueenside)
 
-    val next = DefaultRules.applyMove(context, move)
+    val next = DefaultRules.applyMove(context)(move)
 
     next.board.pieceAt(sq("c1")) shouldBe Some(Piece(Color.White, PieceType.King))
     next.board.pieceAt(sq("d1")) shouldBe Some(Piece(Color.White, PieceType.Rook))
@@ -150,7 +150,7 @@ class DefaultRulesStateTransitionsTest extends AnyFunSuite with Matchers:
     val context = contextFromFen("k7/8/8/3pP3/8/8/8/7K w - d6 0 1")
     val move = Move(sq("e5"), sq("d6"), MoveType.EnPassant)
 
-    val next = DefaultRules.applyMove(context, move)
+    val next = DefaultRules.applyMove(context)(move)
 
     next.board.pieceAt(sq("d6")) shouldBe Some(Piece(Color.White, PieceType.Pawn))
     next.board.pieceAt(sq("d5")) shouldBe None
@@ -160,7 +160,7 @@ class DefaultRulesStateTransitionsTest extends AnyFunSuite with Matchers:
     val context = contextFromFen("4k3/P7/8/8/8/8/8/4K3 w - - 0 1")
     val move = Move(sq("a7"), sq("a8"), MoveType.Promotion(PromotionPiece.Knight))
 
-    val next = DefaultRules.applyMove(context, move)
+    val next = DefaultRules.applyMove(context)(move)
 
     next.board.pieceAt(sq("a8")) shouldBe Some(Piece(Color.White, PieceType.Knight))
     next.board.pieceAt(sq("a7")) shouldBe None
@@ -168,12 +168,12 @@ class DefaultRulesStateTransitionsTest extends AnyFunSuite with Matchers:
   test("candidateMoves returns empty for opponent piece on selected square"):
     val context = GameContext.initial.withTurn(Color.Black)
 
-    DefaultRules.candidateMoves(context, sq("e2")) shouldBe empty
+    DefaultRules.candidateMoves(context)(sq("e2")) shouldBe empty
 
   test("legalMoves keeps king safe by filtering pinned bishop moves"):
     val context = contextFromFen("8/8/8/8/8/8/r1B1K3/8 w - - 0 1")
 
-    val bishopMoves = DefaultRules.legalMoves(context, sq("c2"))
+    val bishopMoves = DefaultRules.legalMoves(context)(sq("c2"))
 
     bishopMoves shouldBe empty
 
@@ -181,7 +181,7 @@ class DefaultRulesStateTransitionsTest extends AnyFunSuite with Matchers:
     val context = contextFromFen("r3k2r/8/8/8/8/8/8/R3K2R w KQkq - 0 1")
     val move = Move(sq("e1"), sq("g1"), MoveType.CastleKingside)
 
-    val next = DefaultRules.applyMove(context, move)
+    val next = DefaultRules.applyMove(context)(move)
 
     next.castlingRights.whiteKingSide shouldBe false
     next.castlingRights.whiteQueenSide shouldBe false
@@ -198,8 +198,8 @@ class DefaultRulesStateTransitionsTest extends AnyFunSuite with Matchers:
       moves = List.empty
     )
 
-    val afterA1Capture = DefaultRules.applyMove(context, Move(sq("a8"), sq("a1"), MoveType.Normal(isCapture = true)))
-    val afterH1Capture = DefaultRules.applyMove(afterA1Capture, Move(sq("a1"), sq("h1"), MoveType.Normal(isCapture = true)))
+    val afterA1Capture = DefaultRules.applyMove(context)(Move(sq("a8"), sq("a1"), MoveType.Normal(isCapture = true)))
+    val afterH1Capture = DefaultRules.applyMove(afterA1Capture)(Move(sq("a1"), sq("h1"), MoveType.Normal(isCapture = true)))
 
     afterH1Capture.castlingRights.whiteKingSide shouldBe false
     afterH1Capture.castlingRights.whiteQueenSide shouldBe false
@@ -212,21 +212,21 @@ class DefaultRulesStateTransitionsTest extends AnyFunSuite with Matchers:
   test("candidateMoves for rook includes enemy capture move"):
     val context = contextFromFen("4k3/8/8/8/8/8/4K3/R6r w - - 0 1")
 
-    val rookMoves = DefaultRules.candidateMoves(context, sq("a1"))
+    val rookMoves = DefaultRules.candidateMoves(context)(sq("a1"))
 
     rookMoves.exists(m => m.to == sq("h1") && m.moveType == MoveType.Normal(isCapture = true)) shouldBe true
 
   test("candidateMoves for knight includes enemy capture move"):
     val context = contextFromFen("4k3/8/8/8/8/3p4/5N2/4K3 w - - 0 1")
 
-    val knightMoves = DefaultRules.candidateMoves(context, sq("f2"))
+    val knightMoves = DefaultRules.candidateMoves(context)(sq("f2"))
 
     knightMoves.exists(m => m.to == sq("d3") && m.moveType == MoveType.Normal(isCapture = true)) shouldBe true
 
   test("candidateMoves includes black kingside and queenside castling options"):
     val context = contextFromFen("r3k2r/8/8/8/8/8/8/4K3 b kq - 0 1")
 
-    val kingMoves = DefaultRules.candidateMoves(context, sq("e8"))
+    val kingMoves = DefaultRules.candidateMoves(context)(sq("e8"))
 
     kingMoves.exists(_.moveType == MoveType.CastleKingside) shouldBe true
     kingMoves.exists(_.moveType == MoveType.CastleQueenside) shouldBe true
@@ -235,7 +235,7 @@ class DefaultRulesStateTransitionsTest extends AnyFunSuite with Matchers:
     val context = contextFromFen("r3k2r/8/8/8/8/8/8/4K3 b kq - 0 1")
     val move = Move(sq("e8"), sq("g8"), MoveType.CastleKingside)
 
-    val next = DefaultRules.applyMove(context, move)
+    val next = DefaultRules.applyMove(context)(move)
 
     next.board.pieceAt(sq("g8")) shouldBe Some(Piece(Color.Black, PieceType.King))
     next.board.pieceAt(sq("f8")) shouldBe Some(Piece(Color.Black, PieceType.Rook))
@@ -246,7 +246,7 @@ class DefaultRulesStateTransitionsTest extends AnyFunSuite with Matchers:
     val context = contextFromFen("r3k2r/8/8/8/8/8/8/4K3 b kq - 0 1")
     val move = Move(sq("h8"), sq("h7"))
 
-    val next = DefaultRules.applyMove(context, move)
+    val next = DefaultRules.applyMove(context)(move)
 
     next.castlingRights.blackKingSide shouldBe false
     next.castlingRights.blackQueenSide shouldBe true
@@ -255,7 +255,7 @@ class DefaultRulesStateTransitionsTest extends AnyFunSuite with Matchers:
     val context = contextFromFen("r3k2r/8/8/8/8/8/8/4K3 b kq - 0 1")
     val move = Move(sq("a8"), sq("a7"))
 
-    val next = DefaultRules.applyMove(context, move)
+    val next = DefaultRules.applyMove(context)(move)
 
     next.castlingRights.blackKingSide shouldBe true
     next.castlingRights.blackQueenSide shouldBe false
@@ -264,7 +264,7 @@ class DefaultRulesStateTransitionsTest extends AnyFunSuite with Matchers:
     val context = contextFromFen("4k2r/8/8/8/8/8/8/4K2R w Kk - 0 1")
     val move = Move(sq("h1"), sq("h8"), MoveType.Normal(isCapture = true))
 
-    val next = DefaultRules.applyMove(context, move)
+    val next = DefaultRules.applyMove(context)(move)
 
     next.castlingRights.blackKingSide shouldBe false
 
@@ -272,7 +272,7 @@ class DefaultRulesStateTransitionsTest extends AnyFunSuite with Matchers:
     val context = contextFromFen("4k3/8/8/8/8/8/p7/4K3 b - - 0 1")
     val to = sq("a1")
 
-    val pawnMoves = DefaultRules.candidateMoves(context, sq("a2"))
+    val pawnMoves = DefaultRules.candidateMoves(context)(sq("a2"))
     val promotions = pawnMoves.collect { case Move(_, `to`, MoveType.Promotion(piece)) => piece }
 
     promotions.toSet shouldBe Set(
@@ -285,9 +285,9 @@ class DefaultRulesStateTransitionsTest extends AnyFunSuite with Matchers:
   test("applyMove promotion supports queen rook and bishop targets"):
     val base = contextFromFen("4k3/P7/8/8/8/8/8/4K3 w - - 0 1")
 
-    val queen = DefaultRules.applyMove(base, Move(sq("a7"), sq("a8"), MoveType.Promotion(PromotionPiece.Queen)))
-    val rook = DefaultRules.applyMove(base, Move(sq("a7"), sq("a8"), MoveType.Promotion(PromotionPiece.Rook)))
-    val bishop = DefaultRules.applyMove(base, Move(sq("a7"), sq("a8"), MoveType.Promotion(PromotionPiece.Bishop)))
+    val queen = DefaultRules.applyMove(base)(Move(sq("a7"), sq("a8"), MoveType.Promotion(PromotionPiece.Queen)))
+    val rook = DefaultRules.applyMove(base)(Move(sq("a7"), sq("a8"), MoveType.Promotion(PromotionPiece.Rook)))
+    val bishop = DefaultRules.applyMove(base)(Move(sq("a7"), sq("a8"), MoveType.Promotion(PromotionPiece.Bishop)))
 
     queen.board.pieceAt(sq("a8")) shouldBe Some(Piece(Color.White, PieceType.Queen))
     rook.board.pieceAt(sq("a8")) shouldBe Some(Piece(Color.White, PieceType.Rook))

modules/rule/src/test/scala/de/nowchess/rule/DefaultRulesTest.scala

@@ -52,7 +52,7 @@ class DefaultRulesTest extends AnyFunSuite with Matchers:
     val moves = rules.allLegalMoves(context)
 
     // King must move; e2 should be valid but d1 might be blocked by rook if still on same file
-    moves.filter(m => m.from == Square(File.E, Rank.R1)).nonEmpty shouldBe true
+    moves.exists(m => m.from == Square(File.E, Rank.R1)) shouldBe true
 
   test("king cannot move to square attacked by opponent"):
     // FEN: white king e1, black rook e2 defended by black king e3
@@ -109,6 +109,28 @@ class DefaultRulesTest extends AnyFunSuite with Matchers:
     val castles = moves.filter(m => m.moveType == MoveType.CastleKingside)
     castles.isEmpty shouldBe true
 
+  test("castling queenside is illegal when knight blocks on b8"):
+    // Black king e8, black rook a8, black knight b8 (blocks queenside path)
+    val board = Board(Map(
+      Square(File.A, Rank.R8) -> Piece(Color.Black, PieceType.Rook),
+      Square(File.B, Rank.R8) -> Piece(Color.Black, PieceType.Knight),
+      Square(File.E, Rank.R8) -> Piece(Color.Black, PieceType.King),
+      Square(File.A, Rank.R1) -> Piece(Color.White, PieceType.Rook),
+      Square(File.E, Rank.R1) -> Piece(Color.White, PieceType.King)
+    ))
+    val context = GameContext(
+      board = board,
+      turn = Color.Black,
+      castlingRights = CastlingRights(whiteKingSide = true, whiteQueenSide = true, blackKingSide = true, blackQueenSide = true),
+      enPassantSquare = None,
+      halfMoveClock = 0,
+      moves = List.empty
+    )
+    val moves = rules.allLegalMoves(context)
+
+    val castles = moves.filter(m => m.moveType == MoveType.CastleQueenside)
+    castles.isEmpty shouldBe true
+
   // ── En passant legality ──────────────────────────────────────────
 
   test("en passant is legal when en passant square is set"):

modules/rule/versions.env

@@ -0,0 +1,3 @@
+MAJOR=0
+MINOR=0
+PATCH=3

modules/ui/CHANGELOG.md

@@ -33,3 +33,19 @@
 * NCS-16 Core Separation via Patterns ([#10](https://git.janis-eccarius.de/NowChess/NowChessSystems/issues/10)) ([1361dfc](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/1361dfc89553b146864fb8ff3526cf12cf3f293a))
 * NCS-17 Implement basic ScalaFX UI ([#14](https://git.janis-eccarius.de/NowChess/NowChessSystems/issues/14)) ([3ff8031](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/3ff80318b4f16c59733a46498581a5c27f048287))
 * NCS-21 Write Scripts to automate certain tasks ([#15](https://git.janis-eccarius.de/NowChess/NowChessSystems/issues/15)) ([8051871](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/80518719d536a087d339fe02530825dc07f8b388))
+##  (2026-04-07)
+
+### Features
+
+* NCS-10 Implement Pawn Promotion ([#12](https://git.janis-eccarius.de/NowChess/NowChessSystems/issues/12)) ([13bfc16](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/13bfc16cfe25db78ec607db523ca6d993c13430c))
+* NCS-16 Core Separation via Patterns ([#10](https://git.janis-eccarius.de/NowChess/NowChessSystems/issues/10)) ([1361dfc](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/1361dfc89553b146864fb8ff3526cf12cf3f293a))
+* NCS-17 Implement basic ScalaFX UI ([#14](https://git.janis-eccarius.de/NowChess/NowChessSystems/issues/14)) ([3ff8031](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/3ff80318b4f16c59733a46498581a5c27f048287))
+* NCS-21 Write Scripts to automate certain tasks ([#15](https://git.janis-eccarius.de/NowChess/NowChessSystems/issues/15)) ([8051871](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/80518719d536a087d339fe02530825dc07f8b388))
+##  (2026-04-07)
+
+### Features
+
+* NCS-10 Implement Pawn Promotion ([#12](https://git.janis-eccarius.de/NowChess/NowChessSystems/issues/12)) ([13bfc16](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/13bfc16cfe25db78ec607db523ca6d993c13430c))
+* NCS-16 Core Separation via Patterns ([#10](https://git.janis-eccarius.de/NowChess/NowChessSystems/issues/10)) ([1361dfc](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/1361dfc89553b146864fb8ff3526cf12cf3f293a))
+* NCS-17 Implement basic ScalaFX UI ([#14](https://git.janis-eccarius.de/NowChess/NowChessSystems/issues/14)) ([3ff8031](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/3ff80318b4f16c59733a46498581a5c27f048287))
+* NCS-21 Write Scripts to automate certain tasks ([#15](https://git.janis-eccarius.de/NowChess/NowChessSystems/issues/15)) ([8051871](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/80518719d536a087d339fe02530825dc07f8b388))

modules/ui/src/main/scala/de/nowchess/ui/gui/ChessBoardView.scala

@@ -178,7 +178,7 @@ class ChessBoardView(val stage: Stage, private val engine: GameEngine) extends B
             selectedSquare = Some(clickedSquare)
             highlightSquare(rank, file, PieceSprites.SquareColors.Selected)
 
-            val legalDests = engine.ruleSet.legalMoves(engine.context, clickedSquare)
+            val legalDests = engine.ruleSet.legalMoves(engine.context)(clickedSquare)
                .collect { case move if move.from == clickedSquare => move.to }
             legalDests.foreach { sq =>
                highlightSquare(sq.rank.ordinal, sq.file.ordinal, PieceSprites.SquareColors.ValidMove)

modules/ui/versions.env

@@ -1,3 +1,3 @@
 MAJOR=0
-MINOR=5
+MINOR=7
 PATCH=0