@ankhorage/zora 21.1.4 → 22.0.1

package/src/features/chess/adapters/inbound/ChessBoard.tsx

@@ -1,9 +1,15 @@
 import React from 'react';
 import { Pressable, StyleSheet, Text, View } from 'react-native';
 
-import type { ChessBoardProps, ChessPieceState, ChessSquareId } from '../../../../types/chess';
+import type {
+  ChessBoardProps,
+  ChessMoveAttempt,
+  ChessPieceState,
+  ChessSquareId,
+} from '../../../../types/chess';
 import { withZoraThemeScope } from '../../../theme/adapters/inbound/withZoraThemeScope';
 import { useZoraTheme } from '../../../theme/composition/useZoraTheme';
+import { getLegalTargets, readChessPieces, tryMove } from '../../utils/chessEngine';
 import { createBoardSquares } from '../../utils/createBoardSquares';
 import { createChessBoardColorScheme } from '../../utils/createChessBoardColorScheme';
 import { isLightSquare } from '../../utils/isLightSquare';
@@ -23,21 +29,25 @@ const symbols = new Map<string, string>([
   ['black:k', '♚'],
 ]);
 
-/*** Renders caller-owned chess presentation state without chess rule execution. */
+/*** Renders caller-owned or FEN-backed chess state with optional legal-move validation. */
 export const ChessBoard = withZoraThemeScope(ChessBoardInner);
 
-/*** Renders the current presentation state without executing chess rules. */
+/*** Renders the current presentation state and delegates FEN validation to the core chess engine. */
 function ChessBoardInner({
-  pieces = [],
+  fen,
+  pieces,
   orientation = 'white',
   selectedSquare = null,
-  legalTargets = [],
+  legalTargets,
   lastMove = null,
   disabled = false,
   showCoordinates = false,
+  validateMoves = true,
   colorScheme,
   onSquarePress,
   onMoveAttempt,
+  onLegalMove,
+  onInvalidMove,
   renderPiece,
   interactionPolicy,
   testID,
@@ -45,15 +55,28 @@ function ChessBoardInner({
   const { theme } = useZoraTheme();
   const colors = createChessBoardColorScheme(theme, colorScheme);
   const squares = createBoardSquares(orientation);
-  const piecesBySquare = new Map<ChessSquareId, ChessPieceState>(
-    pieces.map((piece) => [piece.square, piece]),
-  );
-  const legalTargetSet = new Set(legalTargets);
+  const piecesBySquare =
+    pieces === undefined
+      ? fen === undefined
+        ? new Map<ChessSquareId, ChessPieceState>()
+        : new Map(readChessPieces(fen))
+      : new Map<ChessSquareId, ChessPieceState>(pieces.map((piece) => [piece.square, piece]));
+  const resolvedLegalTargets =
+    legalTargets ??
+    (fen !== undefined && selectedSquare !== null ? getLegalTargets(fen, selectedSquare) : []);
+  const legalTargetSet = new Set(resolvedLegalTargets);
   const pressSquare = (square: ChessSquareId) => {
     if (disabled || interactionPolicy === 'passive') return;
     onSquarePress?.(square);
-    if (selectedSquare !== null && selectedSquare !== square)
-      onMoveAttempt?.({ from: selectedSquare, to: square });
+    if (selectedSquare === null || selectedSquare === square) return;
+
+    const attempt: ChessMoveAttempt = { from: selectedSquare, to: square };
+    onMoveAttempt?.(attempt);
+    if (!validateMoves || fen === undefined) return;
+
+    const result = tryMove(fen, attempt);
+    if (result) onLegalMove?.(result);
+    else onInvalidMove?.(attempt);
   };
   return (
     <View

package/src/features/chess/meta.ts

@@ -9,7 +9,7 @@ export const chessBoardMeta = {
   allowedChildren: [],
   blueprint: {
     label: 'Chess board',
-    defaultProps: { pieces: [], orientation: 'white', showCoordinates: true },
+    defaultProps: { pieces: [], orientation: 'white', showCoordinates: true, validateMoves: true },
   },
   events: {
     squarePress: {
@@ -23,6 +23,28 @@ export const chessBoardMeta = {
       payloadFields: [
         { path: 'from', type: 'string', label: 'From' },
         { path: 'to', type: 'string', label: 'To' },
+        { path: 'promotion', type: 'string', label: 'Promotion' },
+      ],
+    },
+    legalMove: {
+      label: 'Legal move',
+      eventType: 'chess.legalMove',
+      payloadFields: [
+        { path: 'from', type: 'string', label: 'From' },
+        { path: 'to', type: 'string', label: 'To' },
+        { path: 'fen', type: 'string', label: 'Position' },
+        { path: 'san', type: 'string', label: 'SAN' },
+        { path: 'lan', type: 'string', label: 'LAN' },
+        { path: 'promotion', type: 'string', label: 'Promotion' },
+      ],
+    },
+    invalidMove: {
+      label: 'Invalid move',
+      eventType: 'chess.invalidMove',
+      payloadFields: [
+        { path: 'from', type: 'string', label: 'From' },
+        { path: 'to', type: 'string', label: 'To' },
+        { path: 'promotion', type: 'string', label: 'Promotion' },
       ],
     },
   },
@@ -43,6 +65,12 @@ export const chessBoardMeta = {
     },
   },
   props: {
+    fen: {
+      type: 'string',
+      category: 'Position',
+      label: 'FEN',
+      authoring: { authority: 'instance' },
+    },
     pieces: {
       type: 'array',
       category: 'Board',
@@ -78,6 +106,13 @@ export const chessBoardMeta = {
       default: false,
       authoring: { authority: 'instance' },
     },
+    validateMoves: {
+      type: 'boolean',
+      category: 'Behavior',
+      label: 'Validate moves',
+      default: true,
+      authoring: { authority: 'instance' },
+    },
     disabled: {
       type: 'boolean',
       category: 'State',

package/src/features/chess/public.test.tsx

@@ -7,6 +7,7 @@ import React, { act } from 'react';
 import { createRoot } from 'react-dom/client';
 import { renderToStaticMarkup } from 'react-dom/server';
 
+import { chessBoardMeta } from './meta';
 import type {
   ChessBoard as ChessBoardComponent,
   OpeningBook as OpeningBookComponent,
@@ -30,6 +31,24 @@ describe('Chess presentation', () => {
     expect(typeof createChessBoardColorScheme).toBe('function');
   });
 
+  test('preserves FEN and validated-move authoring metadata', () => {
+    expect(chessBoardMeta.props.fen.type).toBe('string');
+    expect(chessBoardMeta.props.validateMoves.default).toBe(true);
+    expect(chessBoardMeta.events.legalMove.payloadFields.map((field) => field.path)).toEqual([
+      'from',
+      'to',
+      'fen',
+      'san',
+      'lan',
+      'promotion',
+    ]);
+    expect(chessBoardMeta.events.invalidMove.payloadFields.map((field) => field.path)).toEqual([
+      'from',
+      'to',
+      'promotion',
+    ]);
+  });
+
   test('renders custom React nodes, square IDs, and opening metadata through independent artifacts', async () => {
     const { ChessBoard } = (await load('components/chess-board/index.js')) as {
       ChessBoard: typeof ChessBoardComponent;
@@ -88,6 +107,70 @@ describe('Chess presentation', () => {
     browser.close();
   });
 
+  test('preserves FEN-backed pieces, legal targets, and legal/invalid move callbacks', async () => {
+    const { ChessBoard } = (await load('components/chess-board/index.js')) as {
+      ChessBoard: typeof ChessBoardComponent;
+    };
+    const browser = new Window();
+    const keys = ['window', 'document', 'Node', 'navigator', 'IS_REACT_ACT_ENVIRONMENT'] as const;
+    const previous = keys.map(
+      (key) => [key, Object.getOwnPropertyDescriptor(globalThis, key)] as const,
+    );
+    Object.assign(globalThis, {
+      window: browser,
+      document: browser.document,
+      Node: browser.Node,
+      navigator: browser.navigator,
+      IS_REACT_ACT_ENVIRONMENT: true,
+    });
+    const host = document.createElement('div');
+    document.body.appendChild(host);
+    const legal: string[] = [];
+    const invalid: string[] = [];
+    const root = createRoot(host);
+
+    try {
+      act(() =>
+        root.render(
+          <ChessBoard
+            fen="rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1"
+            onInvalidMove={(move) => invalid.push(`${move.from}-${move.to}`)}
+            onLegalMove={(move) => legal.push(`${move.lan}:${move.san}`)}
+            selectedSquare="e2"
+            showCoordinates
+            testID="fen-board"
+          />,
+        ),
+      );
+
+      expect(host.querySelector('[data-testid="fen-board-square-e1"]')?.textContent).toContain('♔');
+      expect(
+        host.querySelector('[data-testid="fen-board-square-e4"]')?.getAttribute('style'),
+      ).toContain('background-color');
+
+      act(() => {
+        host
+          .querySelector('[data-testid="fen-board-square-e4"]')
+          ?.dispatchEvent(new browser.MouseEvent('click', { bubbles: true }));
+      });
+      expect(legal).toEqual(['e2e4:e4']);
+
+      act(() => {
+        host
+          .querySelector('[data-testid="fen-board-square-e5"]')
+          ?.dispatchEvent(new browser.MouseEvent('click', { bubbles: true }));
+      });
+      expect(invalid).toEqual(['e2-e5']);
+    } finally {
+      act(() => root.unmount());
+      browser.close();
+      for (const [key, descriptor] of previous) {
+        if (descriptor) Object.defineProperty(globalThis, key, descriptor);
+        else Reflect.deleteProperty(globalThis, key);
+      }
+    }
+  });
+
   test('emits only caller-owned intents in active mode and suppresses them in passive mode', async () => {
     const { ChessBoard } = (await load('components/chess-board/index.js')) as {
       ChessBoard: typeof ChessBoardComponent;

package/src/features/chess/public.ts

@@ -4,6 +4,7 @@ export type {
   ChessBoardOrientation,
   ChessBoardProps,
   ChessMoveAttempt,
+  ChessMoveResult,
   ChessPieceCode,
   ChessPieceRenderContext,
   ChessPieceRenderer,
@@ -17,6 +18,8 @@ export type {
 } from '../../types/chess';
 export { ChessBoard } from './adapters/inbound/ChessBoard';
 export { OpeningBook } from './adapters/inbound/OpeningBook';
+export { chessBoardMeta, openingBookMeta } from './meta';
+export { getLegalTargets, readChessPieces, tryMove } from './utils/chessEngine';
 export { chessSquares } from './utils/chessSquares';
 export { createBoardSquares } from './utils/createBoardSquares';
 export type { ChessColorThemeShape } from './utils/createChessBoardColorScheme';

package/src/features/chess/utils/chessEngine.test.ts

@@ -0,0 +1,35 @@
+import { describe, expect, it } from 'bun:test';
+
+import { getLegalTargets, readChessPieces, tryMove } from './chessEngine';
+
+const START_FEN = 'rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1';
+
+describe('core chess engine', () => {
+  it('reads pieces from FEN and preserves piece codes', () => {
+    const pieces = readChessPieces(START_FEN);
+
+    expect(pieces.size).toBe(32);
+    expect(pieces.get('e1')?.piece).toBe('K');
+    expect(pieces.get('e8')?.piece).toBe('k');
+  });
+
+  it('returns an empty map for invalid FEN', () => {
+    expect(readChessPieces('invalid').size).toBe(0);
+  });
+
+  it('returns legal target squares', () => {
+    expect(getLegalTargets(START_FEN, 'e2')).toEqual(['e3', 'e4']);
+  });
+
+  it('returns resulting move details for legal moves', () => {
+    const result = tryMove(START_FEN, { from: 'e2', to: 'e4' });
+
+    expect(result?.san).toBe('e4');
+    expect(result?.lan).toBe('e2e4');
+    expect(result?.fen).toContain(' b ');
+  });
+
+  it('returns null for invalid moves', () => {
+    expect(tryMove(START_FEN, { from: 'e2', to: 'e5' })).toBeNull();
+  });
+});

package/src/features/chess/utils/chessEngine.ts

@@ -0,0 +1,83 @@
+import { Chess, type Move } from 'chess.js';
+
+import type {
+  ChessMoveAttempt,
+  ChessMoveResult,
+  ChessPieceCode,
+  ChessPieceState,
+  ChessPromotionPiece,
+  ChessSquareId,
+} from '../../../types/chess';
+
+/*** Create a chess.js position from FEN without leaking invalid-position exceptions. */
+function createChess(fen: string): Chess | null {
+  try {
+    return new Chess(fen);
+  } catch {
+    return null;
+  }
+}
+
+/*** Convert a chess.js piece into the public ZORA piece code. */
+function toPieceCode(piece: { readonly color: 'b' | 'w'; readonly type: string }): ChessPieceCode {
+  return piece.color === 'w' ? piece.type.toUpperCase() : piece.type.toLowerCase();
+}
+
+/*** Normalize a chess.js promotion marker into the public promotion union. */
+function toPromotionPiece(piece: string | undefined): ChessPromotionPiece | undefined {
+  return piece === 'q' || piece === 'r' || piece === 'b' || piece === 'n' ? piece : undefined;
+}
+
+/*** Convert one successful chess.js move into the public result contract. */
+function toMoveResult(move: Move, fen: string): ChessMoveResult {
+  return {
+    fen,
+    from: move.from,
+    lan: move.lan,
+    promotion: toPromotionPiece(move.promotion),
+    san: move.san,
+    to: move.to,
+  };
+}
+
+/*** Read all pieces from a FEN-backed position. Invalid FEN produces an empty position. */
+export function readChessPieces(fen: string): ReadonlyMap<ChessSquareId, ChessPieceState> {
+  const chess = createChess(fen);
+  const pieces = new Map<ChessSquareId, ChessPieceState>();
+  if (!chess) return pieces;
+
+  for (const rank of chess.board()) {
+    for (const piece of rank) {
+      if (!piece) continue;
+      pieces.set(piece.square, {
+        color: piece.color === 'w' ? 'white' : 'black',
+        piece: toPieceCode(piece),
+        square: piece.square,
+      });
+    }
+  }
+  return pieces;
+}
+
+/*** Resolve legal destination squares from one FEN position and source square. */
+export function getLegalTargets(fen: string, from: ChessSquareId): readonly ChessSquareId[] {
+  const chess = createChess(fen);
+  return chess ? chess.moves({ square: from, verbose: true }).map((move) => move.to) : [];
+}
+
+/*** Attempt one legal chess move against FEN and return the resulting position/move notation. */
+export function tryMove(fen: string, attempt: ChessMoveAttempt): ChessMoveResult | null {
+  const chess = createChess(fen);
+  if (!chess) return null;
+
+  try {
+    const move = chess.move({
+      from: attempt.from,
+      promotion: attempt.promotion,
+      to: attempt.to,
+    });
+    return toMoveResult(move, chess.fen());
+  } catch {
+    return null;
+  }
+}

package/src/features/chessTabletopOwnership.test.ts

@@ -10,7 +10,7 @@ test('Chess and Tabletop implementation modules own one matching runtime export
   for (const featureRoot of featureRoots) {
     for (const directory of [join(featureRoot, 'adapters/inbound'), join(featureRoot, 'utils')]) {
       for (const name of readdirSync(directory)) {
-        if (!['.ts', '.tsx'].includes(extname(name))) continue;
+        if (!['.ts', '.tsx'].includes(extname(name)) || name.includes('.test.')) continue;
         const source = ts.createSourceFile(
           name,
           readFileSync(join(directory, name), 'utf8'),
@@ -32,13 +32,17 @@ test('Chess and Tabletop implementation modules own one matching runtime export
             );
           return [];
         });
-        expect(runtimeExports, join(directory, name)).toEqual([parse(name).name]);
+        const expectedExports =
+          name === 'chessEngine.ts'
+            ? ['getLegalTargets', 'readChessPieces', 'tryMove']
+            : [parse(name).name];
+        expect(runtimeExports.sort(), join(directory, name)).toEqual(expectedExports.sort());
       }
     }
   }
 });
 
-test('Chess and Tabletop source graphs contain no standalone package or game-service imports', () => {
+test('Chess and Tabletop source graphs depend only on their intentional runtime owners', () => {
   const sourcePaths = featureRoots.flatMap((featureRoot) => {
     const visit = (directory: string): string[] =>
       readdirSync(directory, { withFileTypes: true }).flatMap((entry) => {
@@ -63,7 +67,7 @@ test('Chess and Tabletop source graphs contain no standalone package or game-ser
     for (const specifier of imports) {
       if (specifier.startsWith('.')) continue;
       expect(
-        ['react', 'react-native', '@ankhorage/color-theory'],
+        ['react', 'react-native', 'chess.js', '@ankhorage/color-theory'],
         `${path}: ${specifier}`,
       ).toContain(specifier);
     }

package/src/features/tabletop/meta.ts

@@ -116,6 +116,24 @@ export const tabletopTableMeta = {
         acceptsFallback: true,
         acceptsTransforms: true,
       },
+      centerLabel: {
+        label: 'Center label',
+        value: { type: 'string' },
+        acceptsFallback: true,
+        acceptsTransforms: true,
+      },
+      centerSublabel: {
+        label: 'Center sublabel',
+        value: { type: 'string' },
+        acceptsFallback: true,
+        acceptsTransforms: true,
+      },
+      disabled: {
+        label: 'Disabled',
+        value: { type: 'boolean' },
+        acceptsFallback: true,
+        acceptsTransforms: true,
+      },
     },
   },
   props: {
@@ -211,6 +229,12 @@ export const pokerTrainingTableMeta = {
         },
         acceptsFallback: true,
       },
+      disabled: {
+        label: 'Disabled',
+        value: { type: 'boolean' },
+        acceptsFallback: true,
+        acceptsTransforms: true,
+      },
     },
   },
   props: {

package/src/features/tabletop/public.test.tsx

@@ -6,6 +6,7 @@ import { Window } from 'happy-dom';
 import React from 'react';
 import { renderToStaticMarkup } from 'react-dom/server';
 
+import { pokerTrainingTableMeta, tabletopTableMeta } from './meta';
 import type {
   CardHand as CardHandComponent,
   PokerTrainingTable as PokerTrainingTableComponent,
@@ -65,6 +66,17 @@ describe('Tabletop presentation', () => {
     ]);
   });
 
+  test('preserves the standalone Tabletop authoring bindings in core metadata', () => {
+    expect(Object.keys(tabletopTableMeta.bindings.props)).toEqual([
+      'seats',
+      'centerCards',
+      'centerLabel',
+      'centerSublabel',
+      'disabled',
+    ]);
+    expect(pokerTrainingTableMeta.bindings.props.disabled.value.type).toBe('boolean');
+  });
+
   test('renders card sizing, per-card IDs, seat accessibility, and table shapes', async () => {
     const { CardHand } = (await load('components/card-hand/index.js')) as {
       CardHand: typeof CardHandComponent;

package/src/features/tabletop/public.ts

@@ -27,6 +27,7 @@ export { CardHand } from './adapters/inbound/CardHand';
 export { PlayingCard } from './adapters/inbound/PlayingCard';
 export { PokerTrainingTable } from './adapters/inbound/PokerTrainingTable';
 export { TabletopTable } from './adapters/inbound/TabletopTable';
+export { pokerTrainingTableMeta, tabletopTableMeta } from './meta';
 export { createPokerTrainingTableState } from './utils/createPokerTrainingTableState';
 export { createTabletopColorScheme } from './utils/createTabletopColorScheme';
 export { createTabletopGameSeats } from './utils/createTabletopGameSeats';

package/src/index.ts

@@ -131,6 +131,7 @@ export type {
   ChessBoardOrientation,
   ChessBoardProps,
   ChessMoveAttempt,
+  ChessMoveResult,
   ChessPieceCode,
   ChessPieceRenderContext,
   ChessPieceRenderer,
@@ -143,15 +144,18 @@ export type {
   OpeningBookProps,
 } from './features/chess/public';
 export type { ChessColorThemeShape } from './features/chess/public';
-export { ChessBoard, OpeningBook } from './features/chess/public';
+export { ChessBoard, chessBoardMeta, OpeningBook, openingBookMeta } from './features/chess/public';
 export {
   chessSquares,
   createBoardSquares,
   createChessBoardColorScheme,
   createOpeningBookColorScheme,
+  getLegalTargets,
   getSquareFile,
   getSquareRank,
   isLightSquare,
+  readChessPieces,
+  tryMove,
 } from './features/chess/public';
 export type { ChipProps } from './features/chip/public';
 export type { ChipGroupItem, ChipGroupProps } from './features/chip/public';
@@ -319,12 +323,6 @@ export { MissingElement, type MissingElementProps } from './features/missing-ele
 export { Pagination, type PaginationProps } from './features/pagination/public';
 export type { PaletteItemProps } from './features/palette-item/public';
 export { PaletteItem } from './features/palette-item/public';
-export {
-  composeZoraPluginMetadata,
-  ZORA_CORE_PLUGIN_METADATA,
-  ZoraPluginCompositionError,
-} from './features/plugin/public';
-export { composeZoraPlugins, ZORA_CORE_PLUGIN } from './features/plugin/runtime';
 export {
   PopoverMenu,
   type PopoverMenuAction,
@@ -423,7 +421,9 @@ export {
   createTabletopGameSeats,
   PlayingCard,
   PokerTrainingTable,
+  pokerTrainingTableMeta,
   TabletopTable,
+  tabletopTableMeta,
 } from './features/tabletop/public';
 export {
   Tab,
@@ -495,12 +495,4 @@ export type {
   ValidateUploadAssetInput,
 } from './features/uploader/public';
 export { Uploader, validateUploadAsset } from './features/uploader/public';
-export type {
-  ComposedZoraPluginCatalog,
-  ComposedZoraPluginMetadataCatalog,
-  ZoraPluginCompositionErrorCode,
-  ZoraPluginDescriptor,
-  ZoraPluginMetadata,
-  ZoraPluginPlacement,
-} from './types/plugin';
 export type { ZoraComponentRegistry } from './types/registry';

package/src/structureOwnership.test.ts

@@ -26,10 +26,9 @@ describe('src ownership', () => {
     }
   });
 
-  test('keeps reusable authoring, plugin, registry, and theme types centralized', () => {
+  test('keeps reusable authoring, registry, and theme types centralized', () => {
     for (const path of [
       'src/types/authoring.ts',
-      'src/types/plugin.ts',
       'src/types/registry.ts',
       'src/types/theme.ts',
       'src/types/theme-recipe.ts',
@@ -49,8 +48,6 @@ describe('src ownership', () => {
 
   test('keeps deliberate feature facades instead of legacy catch-all implementation files', () => {
     for (const path of [
-      'src/features/plugin/public.ts',
-      'src/features/plugin/runtime.ts',
       'src/features/registry/public.ts',
       'src/features/theme/public.ts',
       'src/features/theme/runtime.ts',
@@ -59,9 +56,7 @@ describe('src ownership', () => {
     }
 
     for (const path of [
-      'src/features/plugin/pluginComposition.ts',
-      'src/features/plugin/corePlugin.ts',
-      'src/features/plugin/corePluginMetadata.ts',
+      'src/features/plugin',
       'src/features/registry/registry.ts',
       'src/features/theme/index.ts',
     ]) {

package/src/types/chess.ts

@@ -14,6 +14,13 @@ export interface ChessMoveAttempt {
   readonly promotion?: ChessPromotionPiece;
 }
 
+export interface ChessMoveResult extends Omit<ChessMoveAttempt, 'promotion'> {
+  readonly fen: string;
+  readonly lan: string;
+  readonly promotion?: ChessPromotionPiece;
+  readonly san: string;
+}
+
 export interface ChessPieceState {
   readonly color: 'black' | 'white';
   readonly piece: ChessPieceCode;
@@ -58,6 +65,7 @@ export interface OpeningBookColorScheme {
 export type OpeningBookColorOverrides = Partial<OpeningBookColorScheme>;
 
 export interface ChessBoardProps extends ZoraBaseProps {
+  readonly fen?: string;
   readonly pieces?: readonly ChessPieceState[];
   readonly orientation?: ChessBoardOrientation;
   readonly selectedSquare?: ChessSquareId | null;
@@ -65,9 +73,12 @@ export interface ChessBoardProps extends ZoraBaseProps {
   readonly lastMove?: ChessMoveAttempt | null;
   readonly disabled?: boolean;
   readonly showCoordinates?: boolean;
+  readonly validateMoves?: boolean;
   readonly colorScheme?: ChessBoardColorOverrides;
   readonly onSquarePress?: (square: ChessSquareId) => void;
   readonly onMoveAttempt?: (move: ChessMoveAttempt) => void;
+  readonly onLegalMove?: (move: ChessMoveResult) => void;
+  readonly onInvalidMove?: (move: ChessMoveAttempt) => void;
   readonly renderPiece?: ChessPieceRenderer;
 }