react-chess-core 0.1.0

package/README.md

@@ -0,0 +1,46 @@
+# react-chess-core
+
+```bash
+npm install
+npm run build
+```
+
+Shared **chessboard** (theme + `HighlightChessboard`) and **browser Stockfish** utilities. Used by `react-chess-puzzle-kit` and (planned) `react-chess-explorer`.
+
+Storybook: `npm run storybook` → http://localhost:6007
+
+---
+
+## Migration phases (Option B)
+
+| Phase | Status | Work |
+|-------|--------|------|
+| **1** | Done | Scaffold package, Rollup, Storybook |
+| **2** | Done | Board + engine source live in this repo |
+| **3** | Done | `react-chess-puzzle-kit` depends on `file:../react-chess-core`, re-export for compatibility |
+| **4** | Done | Remove duplicate shim files from puzzle-kit; slim public API (no core re-exports from puzzle-kit) |
+| **5** | In progress | `react-chess-explorer` scaffold (core only); requirements → `docs/REQUIREMENTS.md` |
+
+---
+
+## Install (consumers)
+
+```bash
+npm install react-chess-core
+```
+
+**Peer dependencies:** `react`, `react-chessboard`, `chess.js`
+
+For Stockfish in the browser:
+
+```bash
+npm install stockfish
+npm run copy:stockfish   # in your app, or copy WASM to public/stockfish/
+```
+
+---
+
+## Exports
+
+- **Chessboard:** `ThemeProvider`, `useChessboardTheme`, `HighlightChessboard`, `boardSquareHighlightColors`
+- **Engine:** `useAnalysisEngine`, `StockfishBrowserEngine`, `EngineEvaluationPanel`, `isAnalyzableFen`, types/helpers

package/dist/features/analysis/analysisBoardHighlightColors.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Square overlay colors for analysis board replay (last move highlight).
+ */
+export declare const analysisBoardHighlightColors: {
+    readonly lastMove: {
+        readonly light: "rgba(253, 216, 53, 0.55)";
+        readonly dark: "rgba(144, 202, 249, 0.5)";
+    };
+};
+export declare const getLastMoveSquareStyles: (from: string, to: string, theme: "light" | "dark") => Record<string, {
+    backgroundColor: string;
+}>;

package/dist/features/analysis/analysisUtils.d.ts

@@ -0,0 +1,4 @@
+import { Chess } from 'chess.js';
+/** Apply a UCI move (e.g. `e7e8q`) without throwing. */
+export declare function applyUciMove(chess: Chess, uci: string): boolean;
+export declare function getCheckSquareFromChess(chess: Chess): string;

package/dist/features/analysis/core/AnalysisBoardCore.d.ts

@@ -0,0 +1,28 @@
+import React from 'react';
+import { AnalysisContainerRenderProps, AnalysisMainRenderProps, AnalysisSidebarRenderProps, EngineEvaluationRenderProps } from './renderProps';
+import { AnalysisEngineOptions } from '../../engine/types';
+import { AnalysisBoardModel, UseAnalysisBoardModelArgs } from './useAnalysisBoardModel';
+export type AnalysisBoardCoreProps = UseAnalysisBoardModelArgs & {
+    engine?: AnalysisEngineOptions;
+    /** Host-owned shell (modal, page layout, etc.). */
+    renderContainer: (props: AnalysisContainerRenderProps) => React.ReactNode;
+    /** Host-owned grid/placement of board + sidebar (no library default). */
+    renderMain: (props: AnalysisMainRenderProps) => React.ReactNode;
+    renderSidebar: (props: AnalysisSidebarRenderProps) => React.ReactNode;
+    renderEngineEvaluation: (props: EngineEvaluationRenderProps) => React.ReactNode;
+};
+/**
+ * Analysis logic + composition only: hook, board node, sidebar/engine slots.
+ * No layout divs — use {@link renderMain} (e.g. `AnalysisBoardLayout` from `analysis/defaults` or a host layout).
+ */
+export declare const AnalysisBoardCore: ({ renderContainer, renderMain, renderSidebar, renderEngineEvaluation, ...modelArgs }: AnalysisBoardCoreProps) => React.JSX.Element;
+type AnalysisBoardCoreViewProps = {
+    model: AnalysisBoardModel;
+    renderContainer: AnalysisBoardCoreProps['renderContainer'];
+    renderMain: AnalysisBoardCoreProps['renderMain'];
+    renderSidebar: AnalysisBoardCoreProps['renderSidebar'];
+    renderEngineEvaluation: AnalysisBoardCoreProps['renderEngineEvaluation'];
+};
+/** Pure composition (no layout styles) for testing and reuse. */
+export declare const AnalysisBoardCoreView: ({ model, renderContainer, renderMain, renderSidebar, renderEngineEvaluation, }: AnalysisBoardCoreViewProps) => React.ReactNode;
+export type { AnalysisBoardModel, UseAnalysisBoardModelArgs };

package/dist/features/analysis/core/AnalysisChessboardView.d.ts

@@ -0,0 +1,5 @@
+import { AnalysisBoardModel } from './useAnalysisBoardModel';
+/** Draggable analysis board (no surrounding layout chrome). */
+export declare const AnalysisChessboardView: ({ model }: {
+    model: AnalysisBoardModel;
+}) => import("react").JSX.Element;

package/dist/features/analysis/core/AnalysisErrorBoundary.d.ts

@@ -0,0 +1,14 @@
+import { Component, ReactNode } from 'react';
+type AnalysisErrorBoundaryProps = {
+    children: ReactNode;
+    onClose?: () => void;
+};
+type AnalysisErrorBoundaryState = {
+    error: Error | null;
+};
+export declare class AnalysisErrorBoundary extends Component<AnalysisErrorBoundaryProps, AnalysisErrorBoundaryState> {
+    state: AnalysisErrorBoundaryState;
+    static getDerivedStateFromError(error: Error): AnalysisErrorBoundaryState;
+    render(): string | number | boolean | Iterable<ReactNode> | import("react").JSX.Element | null | undefined;
+}
+export {};

package/dist/features/analysis/core/AnalysisPosition.d.ts

@@ -0,0 +1,54 @@
+import type { AnalysisContext } from '../types';
+export type SolutionMoveDisplay = {
+    ply: number;
+    uci: string;
+    san: string;
+};
+export type AnalysisHistoryRow = {
+    key: string;
+    label: string;
+    indent: number;
+    kind: 'start' | 'main' | 'variation';
+    mainPly: number;
+    variationIndex: number;
+};
+export declare class AnalysisPosition {
+    private chess;
+    private readonly initialFen;
+    private readonly solutionMoves;
+    private readonly solutionSans;
+    private mainPly;
+    private variation;
+    private variationCursor;
+    constructor(context: AnalysisContext);
+    private static buildSolutionSans;
+    private static applySolutionMove;
+    private fenAtMainPly;
+    private rebuildChess;
+    private findLegalMove;
+    private uciFromVerboseMove;
+    private matchesMainMove;
+    getNavPly(): number;
+    getMaxNavPly(): number;
+    /** @deprecated Use getNavPly */
+    getPly(): number;
+    /** @deprecated Use getMaxNavPly */
+    getMaxPly(): number;
+    getSolutionSans(): SolutionMoveDisplay[];
+    getHistoryRows(): AnalysisHistoryRow[];
+    isHistoryRowSelected(row: AnalysisHistoryRow): boolean;
+    selectHistoryRow(row: AnalysisHistoryRow): void;
+    selectMainLine(ply: number): void;
+    /** @deprecated Use selectMainLine or goToNavPly */
+    goToPly(ply: number): void;
+    goToNavPly(navPly: number): void;
+    tryPlayMove(sourceSquare: string, targetSquare: string, piece: string): boolean;
+    next(): boolean;
+    prev(): boolean;
+    getLastMoveSquares(): {
+        from: string;
+        to: string;
+    } | null;
+    fen(): string;
+    getCheckSquare(): string;
+}

package/dist/features/analysis/core/analysisLayoutConfig.d.ts

@@ -0,0 +1,6 @@
+/** Host-provided dimensions for analysis board + sidebar grid (defaults package only). */
+export type AnalysisLayoutConfig = {
+    boardWidth: number;
+    sidebarWidth: number;
+    columnGap: number;
+};

package/dist/features/analysis/core/index.d.ts

@@ -0,0 +1,7 @@
+export * from './AnalysisErrorBoundary';
+export * from './analysisLayoutConfig';
+export * from './AnalysisBoardCore';
+export * from './AnalysisChessboardView';
+export * from './AnalysisPosition';
+export * from './renderProps';
+export * from './useAnalysisBoardModel';

package/dist/features/analysis/core/renderProps.d.ts

@@ -0,0 +1,39 @@
+import type { ReactNode } from 'react';
+import { EngineEvaluation } from '../../engine/types';
+import { AnalysisHistoryRow, SolutionMoveDisplay } from './AnalysisPosition';
+import { AnalysisBoardModel } from './useAnalysisBoardModel';
+export type AnalysisControls = {
+    visible: boolean;
+    openAnalysis: () => void;
+};
+export type EngineEvaluationRenderProps = {
+    fen: string;
+    evaluation: EngineEvaluation;
+    theme: 'light' | 'dark';
+};
+export type AnalysisSidebarRenderProps = {
+    /** Main-line moves (legacy; prefer historyRows). */
+    moves: SolutionMoveDisplay[];
+    historyRows: AnalysisHistoryRow[];
+    isHistoryRowSelected: (row: AnalysisHistoryRow) => boolean;
+    onSelectHistoryRow: (row: AnalysisHistoryRow) => void;
+    ply: number;
+    maxPly: number;
+    onSelectPly: (ply: number) => void;
+    theme: 'light' | 'dark';
+    /** Host-rendered engine UI from `renderEngineEvaluation`. */
+    engineEvaluationPanel: ReactNode | null;
+};
+export type AnalysisContainerRenderProps = {
+    theme: 'light' | 'dark';
+    onClose: () => void;
+    children: ReactNode;
+    /** Used by {@link DefaultAnalysisContainer} for overlay dismiss (ignored by most hosts). */
+    onBackdropMouseDown?: () => void;
+};
+/** Place board + sidebar inside the analysis shell (host or default grid). */
+export type AnalysisMainRenderProps = {
+    model: AnalysisBoardModel;
+    board: ReactNode;
+    sidebar: ReactNode;
+};

package/dist/features/analysis/core/useAnalysisBoardModel.d.ts

@@ -0,0 +1,36 @@
+import { AnalysisHistoryRow, SolutionMoveDisplay } from './AnalysisPosition';
+import type { AnalysisContext } from '../types';
+import { AnalysisEngineOptions, EngineEvaluation } from '../../engine';
+export type UseAnalysisBoardModelArgs = {
+    analysisContext: AnalysisContext;
+    onClose: () => void;
+    theme: 'light' | 'dark';
+    /** Chessboard pixel width (host-controlled). */
+    boardWidth: number;
+    engine?: AnalysisEngineOptions;
+};
+export type AnalysisBoardModel = {
+    theme: 'light' | 'dark';
+    boardWidth: number;
+    analysisContext: AnalysisContext;
+    fen: string;
+    ply: number;
+    maxPly: number;
+    historyRows: AnalysisHistoryRow[];
+    solutionSans: SolutionMoveDisplay[];
+    boardOrientation: 'white' | 'black';
+    engineEvaluation: EngineEvaluation;
+    engineEnabled: boolean;
+    lastMove: {
+        from: string;
+        to: string;
+    } | null;
+    checkSquare: string | null;
+    onSelectPly: (ply: number) => void;
+    onSelectHistoryRow: (row: AnalysisHistoryRow) => void;
+    isHistoryRowSelected: (row: AnalysisHistoryRow) => boolean;
+    onPieceDrop: (sourceSquare: string, targetSquare: string, piece: string) => boolean;
+    onBackdropMouseDown: () => void;
+    onClose: () => void;
+};
+export declare const useAnalysisBoardModel: ({ analysisContext, onClose, theme, boardWidth, engine, }: UseAnalysisBoardModelArgs) => AnalysisBoardModel;

package/dist/features/analysis/defaults/AnalysisBoard.d.ts

@@ -0,0 +1,16 @@
+import React from 'react';
+import { AnalysisBoardCoreProps } from '../core/AnalysisBoardCore';
+import { AnalysisLayoutConfig } from '../core/analysisLayoutConfig';
+import { AnalysisContainerRenderProps, AnalysisMainRenderProps, AnalysisSidebarRenderProps, EngineEvaluationRenderProps } from '../core/renderProps';
+export interface AnalysisBoardProps extends Omit<AnalysisBoardCoreProps, 'renderContainer' | 'renderMain' | 'renderSidebar' | 'renderEngineEvaluation' | 'boardWidth'> {
+    layout?: AnalysisLayoutConfig;
+    renderContainer?: (props: AnalysisContainerRenderProps) => React.ReactNode;
+    renderMain?: (props: AnalysisMainRenderProps) => React.ReactNode;
+    renderSidebar?: (props: AnalysisSidebarRenderProps) => React.ReactNode;
+    renderEngineEvaluation?: (props: EngineEvaluationRenderProps) => React.ReactNode;
+}
+/**
+ * Full analysis UI with library defaults: modal shell, grid layout, sidebar, engine panel.
+ * For host-owned UI only, use {@link AnalysisBoardCore} and pass all render props.
+ */
+export declare const AnalysisBoard: ({ layout, renderContainer, renderMain, renderSidebar, renderEngineEvaluation, engine, ...modelArgs }: AnalysisBoardProps) => React.JSX.Element;

package/dist/features/analysis/defaults/AnalysisBoardLayout.d.ts

@@ -0,0 +1,14 @@
+import React from 'react';
+import { AnalysisLayoutConfig } from '../core/analysisLayoutConfig';
+import { AnalysisBoardModel } from '../core/useAnalysisBoardModel';
+export type AnalysisBoardLayoutProps = {
+    layout: AnalysisLayoutConfig;
+    model: AnalysisBoardModel;
+    board: React.ReactNode;
+    sidebar: React.ReactNode;
+};
+/**
+ * Optional grid helper: board column + sidebar column.
+ * Hosts may use this in `renderMain` or supply their own layout.
+ */
+export declare const AnalysisBoardLayout: ({ layout, model, board, sidebar, }: AnalysisBoardLayoutProps) => React.JSX.Element;

package/dist/features/analysis/defaults/DefaultAnalysisContainer.d.ts

@@ -0,0 +1,4 @@
+import React from 'react';
+import { AnalysisContainerRenderProps } from '../core/renderProps';
+/** Default full-screen modal shell for analysis (library preset UI). */
+export declare const DefaultAnalysisContainer: ({ theme, onClose, onBackdropMouseDown, children, }: AnalysisContainerRenderProps) => React.JSX.Element;

package/dist/features/analysis/defaults/DefaultAnalysisSidebar.d.ts

@@ -0,0 +1,3 @@
+import React from 'react';
+import { AnalysisSidebarRenderProps } from '../core/renderProps';
+export declare const DefaultAnalysisSidebar: ({ historyRows, isHistoryRowSelected, onSelectHistoryRow, ply, maxPly, onSelectPly, theme, engineEvaluationPanel, }: AnalysisSidebarRenderProps) => React.JSX.Element;

package/dist/features/analysis/defaults/EngineEvaluationPanel.d.ts

@@ -0,0 +1,8 @@
+import React from 'react';
+import type { EngineEvaluation } from '../../engine/types';
+export interface EngineEvaluationPanelProps {
+    fen: string;
+    evaluation: EngineEvaluation;
+    theme: 'light' | 'dark';
+}
+export declare const EngineEvaluationPanel: ({ fen, evaluation, theme, }: EngineEvaluationPanelProps) => React.JSX.Element;

package/dist/features/analysis/defaults/analysisLayout.d.ts

@@ -0,0 +1,3 @@
+import { AnalysisLayoutConfig } from '../core/analysisLayoutConfig';
+/** Library default grid; hosts should pass their own {@link AnalysisLayoutConfig}. */
+export declare const DEFAULT_ANALYSIS_LAYOUT: AnalysisLayoutConfig;

package/dist/features/analysis/defaults/analysisModalStyles.d.ts

@@ -0,0 +1,7 @@
+import { CSSProperties } from 'react';
+export type AnalysisModalStyles = {
+    panel: CSSProperties;
+    title: CSSProperties;
+    closeButton: CSSProperties;
+};
+export declare const getAnalysisModalStyles: (theme: "light" | "dark") => AnalysisModalStyles;

package/dist/features/analysis/defaults/analysisSidebarColors.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Move-list colors for the analysis board sidebar.
+ * Tweak values here when iterating on history row striping.
+ */
+export declare const analysisSidebarColors: {
+    /** Selected move row */
+    readonly activeMove: {
+        readonly light: "rgba(119, 177, 212, 1)";
+        readonly dark: "rgba(90, 159, 190, 1)";
+    };
+    /** Start row */
+    readonly start: {
+        readonly light: "#e8e8e8";
+        readonly dark: "#262626";
+    };
+    /** Alternating main-line rows (index 0 = darker, 1 = lighter). */
+    readonly mainStripe: readonly [{
+        readonly light: "#c9c9c9";
+        readonly dark: "#1c1c1c";
+    }, {
+        readonly light: "#f2f2f2";
+        readonly dark: "#383838";
+    }];
+    /** Alternating user-variation rows (high-contrast striping like puzzle UI). */
+    readonly variationStripe: readonly [{
+        readonly light: "rgba(216, 216, 216, 1)";
+        readonly dark: "rgba(200, 200, 200, 1)";
+    }, {
+        readonly light: "rgba(255, 255, 255, 1)";
+        readonly dark: "rgba(255, 255, 255, 1)";
+    }];
+    /** Text on variation rows (light backgrounds need dark type). */
+    readonly variationText: {
+        readonly light: "rgba(0, 0, 0, 0.87)";
+        readonly dark: "rgba(0, 0, 0, 0.87)";
+    };
+};

package/dist/features/analysis/defaults/analysisSidebarRowStyle.d.ts

@@ -0,0 +1,8 @@
+import { AnalysisHistoryRow } from '../core/AnalysisPosition';
+export type SidebarRowBandCounters = {
+    main: number;
+    variation: number;
+};
+export declare const createSidebarRowBandCounters: () => SidebarRowBandCounters;
+/** Background for one analysis history row; mutates `bands` while iterating rows in order. */
+export declare const getSidebarRowBackground: (theme: "light" | "dark", row: AnalysisHistoryRow, bands: SidebarRowBandCounters) => string;

package/dist/features/analysis/defaults/index.d.ts

@@ -0,0 +1,9 @@
+export * from './analysisModalStyles';
+export * from './analysisSidebarColors';
+export * from './analysisSidebarRowStyle';
+export * from './analysisLayout';
+export * from './AnalysisBoard';
+export * from './AnalysisBoardLayout';
+export * from './DefaultAnalysisContainer';
+export * from './DefaultAnalysisSidebar';
+export * from './EngineEvaluationPanel';

package/dist/features/analysis/index.d.ts

@@ -0,0 +1,5 @@
+export * from './analysisBoardHighlightColors';
+export * from './analysisUtils';
+export * from './types';
+export * from './core';
+export * from './defaults';

package/dist/features/analysis/types.d.ts

@@ -0,0 +1,9 @@
+/** Input for {@link AnalysisPosition} and the analysis board UI. */
+export type AnalysisContext = {
+    initialFen: string;
+    /** Main line in UCI notation (e.g. full game or puzzle solution). */
+    solutionMoves: string[];
+    /** Ply index to open at (0 = start position). */
+    currentPly: number;
+    boardOrientation: 'white' | 'black';
+};

package/dist/features/chessboard/HighlightChessboard.d.ts

@@ -0,0 +1,7 @@
+export interface HighlightChessboardProps {
+    checkSquare: string;
+    hintSquare: string | null;
+    incorrectMoveSquare: string | null;
+    [key: string]: any;
+}
+export declare const HighlightChessboard: ({ checkSquare, hintSquare, incorrectMoveSquare, customSquareStyles: extraSquareStyles, ...props }: HighlightChessboardProps) => import("react").JSX.Element;

package/dist/features/chessboard/boardSquareHighlightColors.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Square overlay colors for puzzle boards (check, hint, incorrect).
+ */
+export declare const boardSquareHighlightColors: {
+    readonly check: "rgba(255, 127, 127, 0.8)";
+    readonly hint: "rgba(119, 177, 212, 0.75)";
+    /** Muted red — softer than the in-check highlight. */
+    readonly incorrect: "rgba(140, 38, 38, 0.82)";
+};

package/dist/features/chessboard/chessboardTheme.d.ts

@@ -0,0 +1,27 @@
+import { ReactNode } from 'react';
+interface ChessboardThemeContextType {
+    customDarkSquareStyle: {
+        backgroundColor: string;
+    };
+    customLightSquareStyle: {
+        backgroundColor: string;
+    };
+}
+export declare const ChessboardThemeContext: import("react").Context<ChessboardThemeContextType | undefined>;
+export declare const useChessboardTheme: () => ChessboardThemeContextType;
+/** @deprecated Use {@link useChessboardTheme}. */
+export declare const useTheme: () => ChessboardThemeContextType;
+export declare const getStylesForTheme: (theme: "light" | "dark") => {
+    customDarkSquareStyle: {
+        backgroundColor: string;
+    };
+    customLightSquareStyle: {
+        backgroundColor: string;
+    };
+};
+export type ThemeProviderProps = {
+    children?: ReactNode;
+    theme: 'light' | 'dark';
+};
+export declare const ThemeProvider: ({ children, theme }: ThemeProviderProps) => import("react").JSX.Element;
+export {};

package/dist/features/chessboard/index.d.ts

@@ -0,0 +1,3 @@
+export * from './chessboardTheme';
+export * from './HighlightChessboard';
+export * from './boardSquareHighlightColors';

package/dist/features/engine/StockfishBrowserEngine.d.ts

@@ -0,0 +1,32 @@
+import { EngineEvaluation } from './types';
+export declare const splitWorkerLines: (data: unknown) => string[];
+export { resolveStockfishWorkerUrl, resolveStockfishWasmUrl, resolveStockfishScriptUrl } from './stockfishUrls';
+export declare class StockfishBrowserEngine {
+    private readonly scriptUrl;
+    private worker;
+    private ready;
+    private disposed;
+    private lifecycleGeneration;
+    private evaluation;
+    private lineMap;
+    private listeners;
+    private analysisFen;
+    private analysisGeneration;
+    private pendingSearch;
+    private dispatchedSearchGeneration;
+    private searching;
+    constructor(scriptUrl: string);
+    subscribe(listener: (evaluation: EngineEvaluation) => void): () => void;
+    getEvaluation(): EngineEvaluation;
+    private assertWasmReachable;
+    init(): Promise<void>;
+    private handleWorkerFailure;
+    private handshake;
+    private waitForLine;
+    analyze(fen: string, depth: number, multiPv: number): void;
+    private dispatchPendingSearch;
+    stop(): void;
+    dispose(): void;
+    private handleLine;
+    private setEvaluation;
+}

package/dist/features/engine/formatEvaluation.d.ts

@@ -0,0 +1,18 @@
+/** Parse a UCI token (e2e4, e7e8q) into a chess.js move object. */
+export declare const parseUciMove: (uci: string) => {
+    from: string;
+    to: string;
+    promotion?: string;
+} | null;
+/** Coerce engine PV data to UCI move tokens (handles array or space-separated string). */
+export declare const normalizePvMoves: (pv: unknown) => string[];
+/** Apply UCI moves from a FEN and return SAN for each legal move in order. */
+export declare const uciPvToSan: (fen: string, pv: unknown) => string[];
+/** Normalize UCI eval (side to move) to White's perspective. */
+export declare const normalizeEvalForWhite: (fen: string, centipawns: number | null, mate: number | null) => {
+    centipawns: number | null;
+    mate: number | null;
+};
+export declare const formatEvaluation: (centipawns: number | null, mate: number | null) => string;
+/** Principal variation as space-separated SAN (from the given FEN). */
+export declare const formatPvPreview: (fen: string, pv: unknown, maxMoves?: number) => string;

package/dist/features/engine/index.d.ts

@@ -0,0 +1,7 @@
+export * from './types';
+export * from './stockfishUrls';
+export * from './formatEvaluation';
+export * from './parseUciInfo';
+export * from './StockfishBrowserEngine';
+export * from './isAnalyzableFen';
+export * from './useAnalysisEngine';

package/dist/features/engine/isAnalyzableFen.d.ts

@@ -0,0 +1,2 @@
+/** Stockfish can trap on finished positions; skip analysis when the game is over. */
+export declare const isAnalyzableFen: (fen: string) => boolean;

package/dist/features/engine/parseUciInfo.d.ts

@@ -0,0 +1,2 @@
+import { EngineLine } from './types';
+export declare const parseUciInfoLine: (line: string) => EngineLine | null;

package/dist/features/engine/stockfishUrls.d.ts

@@ -0,0 +1,8 @@
+/** Resolve a public asset path against the current page (honors CRA `PUBLIC_URL`). */
+export declare const resolveStockfishScriptUrl: (scriptUrl: string, baseHref?: string) => string;
+export declare const resolveStockfishWasmUrl: (scriptUrl: string, baseHref?: string) => string;
+/**
+ * Worker URL for stockfish.js (see examples/loadEngine.js in the stockfish package).
+ * Stockfish derives the sibling `.wasm` URL from the worker script pathname.
+ */
+export declare const resolveStockfishWorkerUrl: (scriptUrl: string, baseHref?: string) => string;

package/dist/features/engine/types.d.ts

@@ -0,0 +1,27 @@
+export type EngineStatus = 'idle' | 'loading' | 'analyzing' | 'error';
+export type EngineLine = {
+    multipv: number;
+    depth: number;
+    /** Centipawns from side to move (UCI). */
+    centipawns: number | null;
+    mate: number | null;
+    /** Principal variation in UCI notation. */
+    pv: string[];
+};
+export type EngineEvaluation = {
+    status: EngineStatus;
+    depth: number;
+    lines: EngineLine[];
+    /** FEN this evaluation was computed for (omit when unknown). */
+    fen?: string;
+    error?: string;
+};
+export declare const emptyEngineEvaluation: () => EngineEvaluation;
+export type AnalysisEngineOptions = {
+    enabled?: boolean;
+    depth?: number;
+    multiPv?: number;
+    /** URL to stockfish-18-lite-single.js (host must serve .wasm alongside it). */
+    scriptUrl?: string;
+};
+export declare const DEFAULT_STOCKFISH_SCRIPT_URL = "/stockfish/stockfish-18-lite-single.js";

package/dist/features/engine/useAnalysisEngine.d.ts

@@ -0,0 +1,2 @@
+import { AnalysisEngineOptions, EngineEvaluation } from './types';
+export declare const useAnalysisEngine: (fen: string, options?: AnalysisEngineOptions) => EngineEvaluation;

package/dist/features/navigation/DefaultPlyNavigation.d.ts

@@ -0,0 +1,4 @@
+import type { PlyNavigationRenderProps } from './types';
+/** Library-default ply navigation (inline styles). */
+export declare const DefaultPlyNavigation: ({ plyIndex, totalPly, canPrev, canNext, onGoFirst, onGoPrev, onGoNext, onGoLast, onGoTo, theme, showScrubber, showPlyLabel, }: PlyNavigationRenderProps) => import("react").JSX.Element;
+export declare const defaultRenderPlyNavigation: (props: PlyNavigationRenderProps) => import("react").JSX.Element;

package/dist/features/navigation/PlyNavigation.d.ts

@@ -0,0 +1,6 @@
+import type { PlyNavigationProps } from './types';
+/**
+ * Step through a fixed move list. Omit {@link PlyNavigationProps.renderPlyNavigation}
+ * for the default inline-styled UI, or pass a custom renderer (e.g. MUI controls).
+ */
+export declare const PlyNavigation: ({ plyIndex, totalPly, canPrev, canNext, onGoFirst, onGoPrev, onGoNext, onGoLast, onGoTo, theme, showScrubber, showPlyLabel, renderPlyNavigation, }: PlyNavigationProps) => import("react").ReactNode;

package/dist/features/navigation/index.d.ts

@@ -0,0 +1,4 @@
+export { PlyNavigation } from './PlyNavigation';
+export { DefaultPlyNavigation, defaultRenderPlyNavigation, } from './DefaultPlyNavigation';
+export { navRowStyle, navButtonStyle, scrubberInputStyle, plyLabelStyle, palette as plyNavigationPalette, } from './plyNavigationStyles';
+export type { PlyNavigationModel, PlyNavigationProps, PlyNavigationRenderProps, PlyNavigationTheme, } from './types';

package/dist/features/navigation/plyNavigationStyles.d.ts

@@ -0,0 +1,12 @@
+import type { CSSProperties } from 'react';
+import type { PlyNavigationTheme } from './types';
+export type PlyNavigationPalette = {
+    text: string;
+    border: string;
+    surface: string;
+};
+export declare const navRowStyle: CSSProperties;
+export declare const scrubberInputStyle: CSSProperties;
+export declare const plyLabelStyle: CSSProperties;
+export declare function palette(theme: PlyNavigationTheme): PlyNavigationPalette;
+export declare function navButtonStyle(colors: PlyNavigationPalette): CSSProperties;