@dxos/react-ui-gameboard 0.8.4-main.fd6878d → 0.8.4-main.fffef41

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dxos/react-ui-gameboard",
-  "version": "0.8.4-main.fd6878d",
+  "version": "0.8.4-main.fffef41",
   "description": "Game board.",
   "homepage": "https://dxos.org",
   "bugs": "https://github.com/dxos/dxos/issues",
@@ -27,34 +27,34 @@
     "@atlaskit/pragmatic-drag-and-drop": "^1.4.0",
     "@atlaskit/pragmatic-drag-and-drop-hitbox": "^1.0.3",
     "@preact-signals/safe-react": "^0.9.0",
-    "@preact/signals-core": "^1.9.0",
+    "@preact/signals-core": "^1.12.1",
     "@radix-ui/react-context": "1.1.1",
     "chess.js": "^1.4.0",
     "react-resize-detector": "^11.0.1",
-    "@dxos/invariant": "0.8.4-main.fd6878d",
-    "@dxos/debug": "0.8.4-main.fd6878d",
-    "@dxos/log": "0.8.4-main.fd6878d",
-    "@dxos/node-std": "0.8.4-main.fd6878d",
-    "@dxos/util": "0.8.4-main.fd6878d"
+    "@dxos/invariant": "0.8.4-main.fffef41",
+    "@dxos/debug": "0.8.4-main.fffef41",
+    "@dxos/log": "0.8.4-main.fffef41",
+    "@dxos/node-std": "0.8.4-main.fffef41",
+    "@dxos/util": "0.8.4-main.fffef41"
   },
   "devDependencies": {
     "@svgr/cli": "^8.1.0",
     "@types/lodash.defaultsdeep": "^4.6.6",
-    "@types/react": "~18.2.0",
-    "@types/react-dom": "~18.2.0",
+    "@types/react": "~19.2.2",
+    "@types/react-dom": "~19.2.2",
     "lodash.defaultsdeep": "^4.6.1",
-    "react": "~18.2.0",
-    "react-dom": "~18.2.0",
-    "vite": "5.4.7",
-    "@dxos/react-ui": "0.8.4-main.fd6878d",
-    "@dxos/react-ui-theme": "0.8.4-main.fd6878d",
-    "@dxos/storybook-utils": "0.8.4-main.fd6878d"
+    "react": "~19.2.0",
+    "react-dom": "~19.2.0",
+    "vite": "7.1.9",
+    "@dxos/react-ui-theme": "0.8.4-main.fffef41",
+    "@dxos/react-ui": "0.8.4-main.fffef41",
+    "@dxos/storybook-utils": "0.8.4-main.fffef41"
   },
   "peerDependencies": {
-    "react": "~18.2.0",
-    "react-dom": "~18.2.0",
-    "@dxos/react-ui": "0.8.4-main.fd6878d",
-    "@dxos/react-ui-theme": "0.8.4-main.fd6878d"
+    "react": "^19.0.0",
+    "react-dom": "^19.0.0",
+    "@dxos/react-ui": "0.8.4-main.fffef41",
+    "@dxos/react-ui-theme": "0.8.4-main.fffef41"
   },
   "publishConfig": {
     "access": "public"

package/src/components/Chessboard/Chessboard.stories.tsx

@@ -2,13 +2,11 @@
 // Copyright 2024 DXOS.org
 //
 
-import '@dxos-theme';
-
-import type { Meta, StoryObj } from '@storybook/react-vite';
+import { type Meta, type StoryObj } from '@storybook/react-vite';
 import React, { useCallback, useEffect, useMemo, useState } from 'react';
 
 import { Button, Toolbar } from '@dxos/react-ui';
-import { withLayout, withTheme } from '@dxos/storybook-utils';
+import { withLayout, withTheme } from '@dxos/react-ui/testing';
 
 import { Gameboard, type GameboardRootProps, type Move, type Player } from '../Gameboard';
 
@@ -64,7 +62,7 @@ const GridStory = () => {
   }, []);
 
   return (
-    <div className='h-full aspect-square mx-auto'>
+    <div className='bs-full aspect-square mx-auto'>
       <div className='grid grid-cols-3 gap-2'>
         {models.map((model, i) => (
           <div key={i} className='aspect-square'>
@@ -78,34 +76,34 @@ const GridStory = () => {
   );
 };
 
-const meta: Meta<typeof DefaultStory> = {
+const meta = {
   title: 'ui/react-ui-gameboard/Chessboard',
   component: Chessboard,
   render: DefaultStory,
-  decorators: [withTheme, withLayout({ fullscreen: true, classNames: '' })],
-};
+  decorators: [withTheme, withLayout({ container: 'column' })],
+} satisfies Meta<typeof Chessboard>;
 
 export default meta;
 
-type Story = StoryObj<typeof DefaultStory>;
+type Story = StoryObj<typeof meta>;
 
-export const Default = {} satisfies Story;
+export const Default: Story = {};
 
-export const Promotion = {
+export const Promotion: Story = {
   args: {
     pgn: '1. e4 e5 2. Nf3 Nc6 3. Bc4 Bc5 4. c3 Nf6 5. d4 exd4 6. cxd4 Bb4+ 7. Nc3 d5 8. exd5 Nxd5 9. O-O Be6 10. Qb3 Na5 11. Qa4+ c6 12. Bxd5 Bxc3 13. Bxe6 fxe6 14. d5 Qg5 15. dxe6 Kf8 16. e7+ Kg8 *',
   },
-} satisfies Story;
+};
 
-export const Debug = {
+export const Debug: Story = {
   args: {
     pgn: '1. e4 e5 2. Nf3 Nc6 3. Bc4 Bc5 4. c3 Nf6 5. d4 exd4 6. cxd4 Bb4+ 7. Nc3 d5 8. exd5 Nxd5 9. O-O Be6 10. Qb3 Na5 11. Qa4+ c6 12. Bxd5 Bxc3 13. Bxe6 fxe6 *',
     orientation: 'black',
     showLabels: true,
     debug: true,
   },
-} satisfies Story;
+};
 
 export const Grid = {
   render: GridStory,
-} satisfies Story;
+};

package/src/components/Chessboard/Chessboard.tsx

@@ -2,12 +2,12 @@
 // Copyright 2025 DXOS.org
 //
 
-import React, { Fragment, type PropsWithChildren, memo, useEffect, useMemo, useRef, useState } from 'react';
+import React, { type PropsWithChildren, forwardRef, memo, useEffect, useMemo, useRef, useState } from 'react';
 import { useResizeDetector } from 'react-resize-detector';
 
-import { type ThemedClassName, useTrackProps } from '@dxos/react-ui';
+import { type ThemedClassName, useForwardedRef } from '@dxos/react-ui';
 import { mx } from '@dxos/react-ui-theme';
-import { isNotFalsy } from '@dxos/util';
+import { isNonNullable } from '@dxos/util';
 
 import {
   type DOMRectBounds,
@@ -35,13 +35,14 @@ export type ChessboardProps = ThemedClassName<
 /**
  * Chessboard layout.
  */
-export const Chessboard = memo(
-  ({ orientation, showLabels, debug, rows = 8, cols = 8, classNames }: ChessboardProps) => {
-    useTrackProps({ orientation, showLabels, debug }, Chessboard.displayName, false);
-    const { ref: containerRef, width, height } = useResizeDetector({ refreshRate: 200 });
+const ChessboardComponent = forwardRef<HTMLDivElement, ChessboardProps>(
+  ({ classNames, orientation, showLabels, debug, rows = 8, cols = 8 }, forwardedRef) => {
+    const targetRef = useForwardedRef(forwardedRef);
+    const { width, height } = useResizeDetector({ targetRef, refreshRate: 200 });
     const { model, promoting, onPromotion } = useGameboardContext<ChessModel>(Chessboard.displayName!);
 
-    const locations = useMemo<Location[]>(() => {
+    // Board squares.
+    const squares = useMemo<Location[]>(() => {
       return Array.from({ length: rows }, (_, i) => (orientation === 'black' ? i : rows - 1 - i)).flatMap((row) =>
         Array.from({ length: cols }).map((_, col) => [row, col] as Location),
       );
@@ -49,7 +50,7 @@ export const Chessboard = memo(
 
     // Use DOM grid layout to position squares.
     const layout = useMemo(() => {
-      return locations.map((location) => {
+      return squares.map((location) => {
         return (
           <div
             key={locationToString(location)}
@@ -59,14 +60,14 @@ export const Chessboard = memo(
           />
         );
       });
-    }, [locations]);
+    }, [squares]);
 
     // Build map of square locations to bounds.
     const [grid, setGrid] = useState<Record<string, DOMRectBounds>>({});
     const gridRef = useRef<HTMLDivElement>(null);
     useEffect(() => {
       setGrid(
-        locations.reduce(
+        squares.reduce(
           (acc, location) => {
             const square = getSquareLocation(gridRef.current!, location)!;
             const bounds = getRelativeBounds(gridRef.current!, square);
@@ -75,7 +76,7 @@ export const Chessboard = memo(
           {} as Record<string, DOMRectBounds>,
         ),
       );
-    }, [locations, width, height]);
+    }, [squares, width, height]);
 
     // Get the bounds of each square and piece.
     const positions = useMemo<{ piece: PieceRecord; bounds: DOMRectBounds }[]>(() => {
@@ -92,16 +93,18 @@ export const Chessboard = memo(
           const bounds = grid[locationToString(piece.location)];
           return { piece, bounds };
         })
-        .filter(isNotFalsy);
+        .filter(isNonNullable);
     }, [grid, model?.pieces.value, promoting]);
 
     return (
-      <div ref={containerRef} className={mx('relative', classNames)}>
+      <div ref={targetRef} tabIndex={0} className={mx('relative outline-none', classNames)}>
+        {/* DOM Layout. */}
         <div ref={gridRef} className='grid grid-rows-8 grid-cols-8 aspect-square select-none'>
           {layout}
         </div>
+        {/* Squares. */}
         <div>
-          {locations.map((location) => (
+          {squares.map((location) => (
             <Gameboard.Square
               key={locationToString(location)}
               location={location}
@@ -111,6 +114,7 @@ export const Chessboard = memo(
             />
           ))}
         </div>
+        {/* Pieces. */}
         <div className={mx(promoting && 'opacity-50')}>
           {positions.map(({ bounds, piece }) => (
             <Gameboard.Piece
@@ -123,13 +127,14 @@ export const Chessboard = memo(
             />
           ))}
         </div>
+        {/* Promotion selector. */}
         {promoting && (
           <PromotionSelector
             grid={grid}
             piece={promoting}
             onSelect={(piece) => {
               onPromotion({
-                from: Object.values(model!.pieces.value).find((p) => p.id === promoting.id)!.location,
+                from: Object.values(model.pieces.value).find((p) => p.id === promoting.id)!.location,
                 to: piece.location,
                 piece: promoting.type,
                 promotion: piece.type,
@@ -142,11 +147,9 @@ export const Chessboard = memo(
   },
 );
 
-Chessboard.displayName = 'Chessboard';
+ChessboardComponent.displayName = 'Chessboard';
 
-const getSquareLocation = (container: HTMLElement, location: Location): HTMLElement | null => {
-  return container.querySelector(`[data-location="${locationToString(location)}"]`);
-};
+export const Chessboard = memo(ChessboardComponent);
 
 const PromotionSelector = ({
   grid,
@@ -179,13 +182,17 @@ const PromotionSelector = ({
       {positions.map(({ piece, bounds }) => (
         <Gameboard.Piece
           key={piece.id}
+          classNames={mx('border-2 border-neutral-700 rounded-full', boardStyles.promotion)}
           piece={piece}
           bounds={bounds}
           Component={ChessPieces[piece.type as ChessPiece]}
-          classNames={mx('border-2 border-neutral-700 rounded-full', boardStyles.promotion)}
           onClick={() => handleSelect(piece)}
         />
       ))}
     </>
   );
 };
+
+const getSquareLocation = (container: HTMLElement, location: Location): HTMLElement | null => {
+  return container.querySelector(`[data-location="${locationToString(location)}"]`);
+};

package/src/components/Chessboard/chess.test.ts

@@ -0,0 +1,19 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { Chess as ChessJS } from 'chess.js';
+import { describe, it } from 'vitest';
+
+import { createPieceMap } from './chess';
+
+describe('ChessModel', () => {
+  it('should update pieces', ({ expect }) => {
+    const chess = new ChessJS();
+    chess.loadPgn(
+      '1. e4 e5 2. Nf3 Nc6 3. Bc4 Bc5 4. c3 Nf6 5. d4 exd4 6. cxd4 Bb4+ 7. Nc3 d5 8. exd5 Nxd5 9. O-O Be6 10. Qb3 Na5 11. Qa4+ c6 12. Bxd5 Bxc3 13. Bxe6 fxe6 *',
+    );
+    const pieces = createPieceMap(chess);
+    expect(pieces).to.exist;
+  });
+});

package/src/components/Chessboard/chess.ts

@@ -6,6 +6,7 @@ import { type ReadonlySignal, signal } from '@preact/signals-core';
 import { Chess as ChessJS } from 'chess.js';
 import { type FC, type SVGProps } from 'react';
 
+import { invariant } from '@dxos/invariant';
 import { log } from '@dxos/log';
 
 import * as Alpha from '../../gen/pieces/chess/alpha';
@@ -33,6 +34,10 @@ export const locationToPos = ([row, col]: Location): string => {
   return String.fromCharCode(col + 'a'.charCodeAt(0)) + (row + 1);
 };
 
+export const getRawPgn = (pgn: string) => {
+  return pgn.replace(/\[.*?\]/g, '').trim();
+};
+
 const styles = {
   neutral: {
     black: 'bg-neutral-50',
@@ -62,7 +67,7 @@ export const getSquareColor = ([row, col]: Location) => {
   return (col + row) % 2 === 0 ? boardStyles.black : boardStyles.white;
 };
 
-export const createChess = (pgn?: string) => {
+export const createChess = (pgn?: string): ChessJS => {
   const chess = new ChessJS();
   if (pgn) {
     try {
@@ -75,43 +80,40 @@ export const createChess = (pgn?: string) => {
   return chess;
 };
 
-/**
- * Attempt move.
- */
-const tryMove = (chess: ChessJS, move: Move): ChessJS | null => {
-  const from = locationToPos(move.from);
-  const to = locationToPos(move.to);
-  try {
-    const promotion = move.promotion ? move.promotion[1].toLowerCase() : 'q';
-    chess.move({ from, to, promotion }, { strict: false });
-    return chess;
-  } catch {
-    // Ignore.
-    return null;
-  }
-};
-
 /**
  * Chess model.
  */
 export class ChessModel implements GameboardModel<ChessPiece> {
   private readonly _chess = new ChessJS();
   private readonly _pieces = signal<PieceMap<ChessPiece>>({});
+  private readonly _moveIndex = signal(0);
 
   constructor(pgn?: string) {
     this.update(pgn);
   }
 
+  get readonly(): boolean {
+    return this._moveIndex.value !== this._chess.history().length;
+  }
+
   get turn(): Player {
     return this._chess.turn() === 'w' ? 'white' : 'black';
   }
 
+  get game(): ChessJS {
+    return this._chess;
+  }
+
   get pieces(): ReadonlySignal<PieceMap<ChessPiece>> {
     return this._pieces;
   }
 
-  get game(): ChessJS {
-    return this._chess;
+  get moveIndex(): ReadonlySignal<number> {
+    return this._moveIndex;
+  }
+
+  get fen() {
+    return this._chess.fen();
   }
 
   /**
@@ -127,11 +129,16 @@ export class ChessModel implements GameboardModel<ChessPiece> {
    */
   // TODO(burdon): Update headers.
   get pgn(): string {
-    return this._chess.pgn();
+    return getRawPgn(this._chess.pgn());
   }
 
-  get fen(): string {
-    return this._chess.fen();
+  setMoveIndex(index: number) {
+    const temp = new ChessJS();
+    const history = this._chess.history({ verbose: true });
+    for (let i = 0; i < index && i < history.length; i++) {
+      temp.move(history[i]);
+    }
+    this._updateBoard(temp);
   }
 
   update(pgn = ''): void {
@@ -154,7 +161,7 @@ export class ChessModel implements GameboardModel<ChessPiece> {
       this._pieces.value = {};
     }
 
-    this._update();
+    this._updateBoard(this._chess);
   }
 
   isValidMove(move: Move): boolean {
@@ -173,7 +180,7 @@ export class ChessModel implements GameboardModel<ChessPiece> {
       return false;
     }
 
-    this._update();
+    this._updateBoard(this._chess);
     return true;
   }
 
@@ -185,37 +192,35 @@ export class ChessModel implements GameboardModel<ChessPiece> {
 
     const move = moves[Math.floor(Math.random() * moves.length)];
     this._chess.move(move);
-    this._update();
+
+    this._updateBoard(this._chess);
     return true;
   }
 
   /**
    * Update pieces preserving identity.
    */
-  private _update(): void {
-    const pieces: PieceMap<ChessPiece> = {};
-    this._chess.board().flatMap((row) =>
-      row.forEach((record) => {
-        if (!record) {
-          return;
-        }
-
-        const { square, type, color } = record;
-        const pieceType = `${color.toUpperCase()}${type.toUpperCase()}` as ChessPiece;
-        const location = posToLocation(square);
-        pieces[locationToString(location)] = {
-          id: `${square}-${pieceType}`,
-          type: pieceType,
-          side: color === 'w' ? 'white' : 'black',
-          location,
-        };
-      }),
-    );
-
-    this._pieces.value = mapPieces(this._pieces.value, pieces);
+  private _updateBoard(chess: ChessJS): void {
+    this._pieces.value = createPieceMap(chess);
+    this._moveIndex.value = chess.history().length;
   }
 }
 
+/**
+ * Attempt move.
+ */
+const tryMove = (chess: ChessJS, move: Move): ChessJS | null => {
+  const from = locationToPos(move.from);
+  const to = locationToPos(move.to);
+  try {
+    const promotion = move.promotion ? move.promotion[1].toLowerCase() : 'q';
+    chess.move({ from, to, promotion }, { strict: false });
+    return chess;
+  } catch {
+    return null;
+  }
+};
+
 const isValidNextMove = (previous: string[], current: string[]) => {
   if (current.length > previous.length + 1) {
     return false;
@@ -230,21 +235,71 @@ const isValidNextMove = (previous: string[], current: string[]) => {
   return true;
 };
 
+/**
+ * Starting from a new game, assign piece IDs based on their starting position.
+ * Then iterate through the history of the provided game and update the piece map.
+ */
+export const createPieceMap = (chess: ChessJS): PieceMap<ChessPiece> => {
+  const temp = new ChessJS();
+  let pieces = _createPieceMap(temp);
+  const history = chess.history({ verbose: true });
+  for (let i = 0; i < history.length; i++) {
+    const move = history[i];
+    temp.move(move);
+    pieces = _diffPieces(pieces, _createPieceMap(temp));
+    const test = new Set();
+    Object.values(pieces).forEach((piece) => {
+      invariant(!test.has(piece.id), 'Duplicate: ' + piece.id);
+      test.add(piece.id);
+    });
+  }
+
+  return pieces;
+};
+
+/**
+ * Create a map of pieces from the board positions; assign each piece the ID of the current square.
+ */
+const _createPieceMap = (chess: ChessJS): PieceMap<ChessPiece> => {
+  const pieces: PieceMap<ChessPiece> = {};
+  chess.board().flatMap((row) =>
+    row.forEach((record) => {
+      if (!record) {
+        return;
+      }
+
+      const { square, type, color } = record;
+      const pieceType = `${color.toUpperCase()}${type.toUpperCase()}` as ChessPiece;
+      const location = posToLocation(square);
+      pieces[locationToString(location)] = {
+        id: `${square}-${pieceType}`,
+        type: pieceType,
+        side: color === 'w' ? 'white' : 'black',
+        location,
+      };
+    }),
+  );
+
+  return pieces;
+};
+
 /**
  * Preserve the original piece objects (and IDs).
  */
-export const mapPieces = <T extends PieceType>(before: PieceMap<T>, after: PieceMap<T>): PieceMap<T> => {
+const _diffPieces = <T extends PieceType>(before: PieceMap<T>, after: PieceMap<T>): PieceMap<T> => {
   const difference: { added: PieceMap; removed: PieceMap } = {
     removed: {},
     added: {},
   };
 
+  // Removed.
   (Object.keys(before) as Array<keyof typeof before>).forEach((square) => {
     if (after[square]?.type !== before[square]?.type) {
       difference.removed[square] = before[square];
     }
   });
 
+  // Added.
   (Object.keys(after) as Array<keyof typeof after>).forEach((square) => {
     if (before[square]?.type !== after[square]?.type) {
       difference.added[square] = after[square];
@@ -253,6 +308,7 @@ export const mapPieces = <T extends PieceType>(before: PieceMap<T>, after: Piece
     }
   });
 
+  // Preserve IDs.
   for (const piece of Object.values(difference.added)) {
     const previous = Object.values(difference.removed).find((p) => p.type === piece.type);
     if (previous) {
@@ -260,13 +316,6 @@ export const mapPieces = <T extends PieceType>(before: PieceMap<T>, after: Piece
     }
   }
 
-  log('delta', {
-    before: Object.keys(before).length,
-    after: Object.keys(after).length,
-    removed: Object.keys(difference.removed).length,
-    added: Object.keys(difference.added).length,
-  });
-
   return after;
 };
 

package/src/components/Gameboard/Gameboard.tsx

@@ -33,13 +33,14 @@ const useGameboardContext = <M extends GameboardModel>(consumerName: string): Ga
 
 type GameboardRootProps<M extends GameboardModel> = PropsWithChildren<{
   model?: M;
+  moveNumber?: number;
   onDrop?: (move: Move) => boolean;
 }>;
 
 /**
  * Generic board container.
  */
-const GameboardRoot = <M extends GameboardModel>({ children, model, onDrop }: GameboardRootProps<M>) => {
+const GameboardRoot = <M extends GameboardModel>({ children, model, moveNumber, onDrop }: GameboardRootProps<M>) => {
   const [dragging, setDragging] = useState(false);
   const [promoting, setPromoting] = useState<PieceRecord | undefined>();
 

package/src/components/Gameboard/Piece.tsx

@@ -10,7 +10,7 @@ import { createPortal } from 'react-dom';
 
 import { invariant } from '@dxos/invariant';
 import { log } from '@dxos/log';
-import { type ThemedClassName, useDynamicRef, useTrackProps } from '@dxos/react-ui';
+import { type ThemedClassName, useDynamicRef } from '@dxos/react-ui';
 import { mx } from '@dxos/react-ui-theme';
 
 import { useGameboardContext } from './Gameboard';
@@ -26,8 +26,7 @@ export type PieceProps = ThemedClassName<{
   onClick?: () => void;
 }>;
 
-export const Piece = memo(({ classNames, Component, piece, orientation, bounds, label, onClick }: PieceProps) => {
-  useTrackProps({ classNames, Component, piece, orientation, bounds, label }, Piece.displayName, false);
+export const Piece = memo(({ classNames, Component, piece, bounds, label, onClick }: PieceProps) => {
   const { model, dragging: isDragging, promoting } = useGameboardContext(Piece.displayName!);
   const promotingRef = useDynamicRef(promoting);
   const [dragging, setDragging] = useState(false);
@@ -38,6 +37,10 @@ export const Piece = memo(({ classNames, Component, piece, orientation, bounds,
 
   const ref = useRef<HTMLDivElement>(null);
   useEffect(() => {
+    if (!model) {
+      return;
+    }
+
     const el = ref.current;
     invariant(el);
 
@@ -60,7 +63,7 @@ export const Piece = memo(({ classNames, Component, piece, orientation, bounds,
           nativeSetDragImage,
         });
       },
-      canDrag: () => !promotingRef.current && model?.turn === piece.side,
+      canDrag: () => !promotingRef.current && !model.readonly && model.turn === piece.side,
       onDragStart: () => setDragging(true),
       onDrop: ({ location: { current } }) => {
         // TODO(burdon): Create wrapper function to catch errors.
@@ -87,7 +90,7 @@ export const Piece = memo(({ classNames, Component, piece, orientation, bounds,
 
       // Check if piece moved.
       if (!current.location || !isEqualLocation(current.location, piece.location)) {
-        ref.current.style.transition = 'top 400ms ease-out, left 400ms ease-out';
+        ref.current.style.transition = 'top 250ms ease-out, left 250ms ease-out';
         ref.current.style.top = bounds.top + 'px';
         ref.current.style.left = bounds.left + 'px';
         setCurrent({ location: piece.location, bounds });

package/src/components/Gameboard/types.ts

@@ -52,6 +52,7 @@ export const isEqualLocation = (l1: Location, l2: Location): boolean => l1[0] ==
  * Generic board model.
  */
 export interface GameboardModel<T extends PieceType = PieceType> {
+  readonly: boolean;
   turn: Player;
   /** @reactive */
   pieces: ReadonlySignal<PieceMap<T>>;