Enable fsf builtin betza premoves

Author: gbtami

client/cataloguedPremove.ts

@@ -8,6 +8,7 @@ interface CataloguedPremoveMetadata {
     readonly source?: 'user' | 'fairy-stockfish-builtin';
     readonly ini?: string;
     readonly baseVariant?: string;
+    readonly betzaPieces?: Readonly<Record<string, string>>;
 }
 
 interface CataloguedPremoveDefinition {
@@ -65,6 +66,11 @@ function parsePremoveDefinition(meta: CataloguedPremoveMetadata): CataloguedPrem
     const movements = new Map<string, BetzaPremove>();
     let kingRoleLetter: string | undefined;
 
+    for (const [roleLetter, betza] of Object.entries(meta.betzaPieces ?? {})) {
+        const normalizedRole = normalRoleLetter(roleLetter);
+        if (normalizedRole) movements.set(normalizedRole, createBetzaPremove(betza));
+    }
+
     for (const { key, value } of options) {
         const normalizedKey = key.toLowerCase();
         if (!(normalizedKey === 'king' || /^custompiece\d+$/i.test(key)) || value === '-') continue;
@@ -85,13 +91,10 @@ function parsePremoveDefinition(meta: CataloguedPremoveMetadata): CataloguedPrem
 }
 
 export function registerCataloguedPremove(meta: CataloguedPremoveMetadata): void {
-    // Site variants and catalogued Fairy-Stockfish built-ins continue to use
-    // chessgroundx's established hard-coded premoves. The generic Betza path is
-    // intentionally limited to user-defined variants.
-    if (!meta.name || meta.source === 'fairy-stockfish-builtin') {
-        cataloguedPremoveDefinitions.delete(meta.name);
-        return;
-    }
+    // Site variants never register here and keep chessgroundx's established
+    // premoves. Catalogued variants can supplement their base-variant fallback
+    // with Betza movement definitions resolved by the server.
+    if (!meta.name) return;
     cataloguedPremoveDefinitions.set(meta.name, parsePremoveDefinition(meta));
 }
 

client/variants.ts

@@ -2041,6 +2041,7 @@ export interface CataloguedVariantClientDocument {
     readonly displayName: string;
     readonly tooltip?: string;
     readonly pieceNames?: Readonly<Record<string, string>>;
+    readonly betzaPieces?: Readonly<Record<string, string>>;
     readonly ini: string;
     readonly baseVariant?: string;
     readonly startFen: string;

server/catalogued_betza.py

@@ -411,11 +411,9 @@ def _cached_catalogued_betza_diagrams(
     return tuple(diagrams)
 
 
-def catalogued_betza_diagrams(doc: Mapping[str, Any]) -> list[CataloguedBetzaDiagram]:
-    """Return inline SVG movement diagrams for custom and known FSF built-in pieces."""
-
+def _piece_definitions_for_doc(doc: Mapping[str, Any]) -> tuple[_PieceDiagramDefinition, ...]:
     ini = str(doc.get("rulesIni") or doc.get("ini") or "")
-    definitions = _cached_piece_diagram_definitions(
+    return _cached_piece_diagram_definitions(
         ini,
         _doc_piece_letters_key(doc),
         _doc_piece_names_key(doc),
@@ -424,6 +422,18 @@ def catalogued_betza_diagrams(doc: Mapping[str, Any]) -> list[CataloguedBetzaDia
         _doc_variant_name(doc.get("baseVariant")),
         BETZA_DIAGRAM_RENDERER_VERSION,
     )
+
+
+def catalogued_betza_pieces(doc: Mapping[str, Any]) -> dict[str, str]:
+    """Return resolved Betza movement definitions needed by catalogued clients."""
+
+    return {definition.piece: definition.betza for definition in _piece_definitions_for_doc(doc)}
+
+
+def catalogued_betza_diagrams(doc: Mapping[str, Any]) -> list[CataloguedBetzaDiagram]:
+    """Return inline SVG movement diagrams for custom and known FSF built-in pieces."""
+
+    definitions = _piece_definitions_for_doc(doc)
     board_width = _preview_dimension(doc.get("width"))
     board_height = _preview_dimension(doc.get("height"))
     return list(

server/catalogued_variants.py

@@ -16,7 +16,7 @@
 
 import aiohttp_session
 from aiohttp import web
-from catalogued_betza import catalogued_betza_diagrams
+from catalogued_betza import catalogued_betza_diagrams, catalogued_betza_pieces
 from catalogued_board import catalogued_start_board_preview
 from catalogued_rules import catalogued_rule_summary
 from compress import MAX_COMPRESSED_BOARD_HEIGHT, MAX_COMPRESSED_BOARD_WIDTH
@@ -1062,6 +1062,7 @@ class CataloguedVariantClientDocument(TypedDict):
     displayName: str
     tooltip: str
     pieceNames: NotRequired[dict[str, str]]
+    betzaPieces: NotRequired[dict[str, str]]
     ini: str
     baseVariant: str
     startFen: str
@@ -2744,6 +2745,9 @@ def _client_doc(
     piece_names = parse_catalogued_piece_names(doc.get("pieceNames"))
     if piece_names:
         client_doc["pieceNames"] = piece_names
+    betza_pieces = catalogued_betza_pieces(doc)
+    if betza_pieces:
+        client_doc["betzaPieces"] = betza_pieces
     if _is_fsf_builtin_catalogued_doc(doc):
         client_doc["fsfBuiltinVariant"] = _fsf_builtin_variant_name(doc)
         references = _catalogued_references_for_display(doc)

tests/cataloguedPremove.test.ts

@@ -42,6 +42,23 @@ describe('catalogued variant premoves', () => {
         expect(destinations).toEqual(new Set(['d5', 'd6', 'd7', 'd8', 'c6', 'e6']));
     });
 
+    test('catalogued Fairy-Stockfish built-in pieces use server-resolved Betza movement', () => {
+        registerCataloguedPremove({
+            name: 'betza-test',
+            source: 'fairy-stockfish-builtin',
+            baseVariant: 'capablanca',
+            ini: '',
+            betzaPieces: { j: 'BN' },
+        });
+        const state = board(['d4', 'j', 'white']);
+        const destinations = premoveForVariant('betza-test', false, dimensions)(state, 'd4', false);
+        const expected = createBetzaPremove('BN')({ origin: [3, 3], color: 'white', board: dimensions }).map(
+            position => util.pos2key([position[0], position[1]]),
+        );
+
+        expect(new Set(destinations)).toEqual(new Set(expected));
+    });
+
     test('directional custom movement rotates for black', () => {
         registerCataloguedPremove({
             name: 'betza-test',

tests/test_catalogued_betza.py

@@ -4,7 +4,7 @@
 from unittest.mock import patch
 
 import catalogued_betza
-from catalogued_betza import catalogued_betza_diagrams
+from catalogued_betza import catalogued_betza_diagrams, catalogued_betza_pieces
 
 
 class CataloguedBetzaDiagramTestCase(unittest.TestCase):
@@ -84,6 +84,31 @@ def test_custom_king_with_betza_is_rendered_but_bare_king_is_ignored(self):
         self.assertEqual(with_custom_king[0]["betza"], "KN")
         self.assertEqual(bare_king, [])
 
+    def test_resolved_piece_map_includes_fsf_builtin_betza(self):
+        pieces = catalogued_betza_pieces(
+            {
+                "name": "janus",
+                "fsfBuiltinVariant": "janus",
+                "baseVariant": "capablanca",
+                "ini": "",
+                "pieces": ["p", "n", "b", "r", "q", "k", "j"],
+            }
+        )
+
+        self.assertEqual(pieces, {"j": "BN"})
+
+    def test_custom_piece_overrides_inherited_fsf_builtin_betza(self):
+        pieces = catalogued_betza_pieces(
+            {
+                "name": "custom-janus",
+                "baseVariant": "janus",
+                "ini": "[custom-janus:janus]\ncustomPiece1 = j:W",
+                "pieces": ["p", "n", "b", "r", "q", "k", "j"],
+            }
+        )
+
+        self.assertEqual(pieces, {"j": "W"})
+
     def test_custom_piece_diagram_list_is_cached_by_ini_and_preview_size(self):
         doc = {
             "ini": """

tests/test_catalogued_fsf_rules_ini.py

@@ -29,6 +29,10 @@ def test_yarishogi_rules_ini_is_documentation_only(self) -> None:
         self.assertEqual(client_doc["ini"], "")
         self.assertNotIn("rulesIni", client_doc)
         self.assertEqual(client_doc["fsfBuiltinVariant"], "yarishogi")
+        self.assertEqual(
+            client_doc["betzaPieces"],
+            {"n": "fRffN", "b": "fFfR", "r": "frlR", "g": "WfFbR", "s": "fKbR"},
+        )
 
         rule_context = catalogued_variant_rule_context(doc)
         self.assertTrue(rule_context["system"])