@connectorvol/chess-widgets 1.0.0

package/dist/position-editor/EditPanel.svelte

@@ -0,0 +1,164 @@
+<script lang="ts">
+  import type { BoardApi } from "@connectorvol/chessboard";
+
+  interface Props {
+    color: "w" | "b";
+    api: BoardApi;
+  }
+
+  const { color, api }: Props = $props();
+
+  function onSelect(
+    promotion: "q" | "r" | "b" | "n" | "k" | "p" | "delete" | "drag"
+  ) {
+    if (promotion === "delete") {
+      api.editState = {
+        mode: {
+          type: "delete",
+          piece: null,
+          color: null,
+        },
+      };
+    } else if (promotion === "drag") {
+      api.editState = {
+        mode: {
+          type: "drag",
+          piece: null,
+          color: null,
+        },
+      };
+    } else {
+      api.editState = {
+        mode: {
+          type: "insert",
+          piece: promotion,
+          color,
+        },
+      };
+    }
+  }
+</script>
+
+{#if api.editState?.mode}
+  <div style="max-width: {api.getBoardSize()}rem; " class="flex">
+    <div
+      class="flex h-full w-full border"
+      style=" border-color: {api.theme.b}; "
+    >
+      <button
+        data-testid="edit-panel-drag-{color}"
+        aria-label="Edit mode"
+        style="background-color: {api.editState?.mode?.type === 'drag'
+          ? 'pink'
+          : api.theme.b}"
+        class=" flex aspect-square h-full w-1/8 hover:contrast-125"
+        onclick={() => onSelect("drag")}
+      >
+        <svg
+          xmlns="http://www.w3.org/2000/svg"
+          fill="none"
+          viewBox="0 0 24 24"
+          stroke-width="1.5"
+          stroke="currentColor"
+          class="p-2 md:p-3 text-white"
+        >
+          <path
+            stroke-linecap="round"
+            stroke-linejoin="round"
+            d="M10.05 4.575a1.575 1.575 0 1 0-3.15 0v3m3.15-3v-1.5a1.575 1.575 0 0 1 3.15 0v1.5m-3.15 0 .075 5.925m3.075.75V4.575m0 0a1.575 1.575 0 0 1 3.15 0V15M6.9 7.575a1.575 1.575 0 1 0-3.15 0v8.175a6.75 6.75 0 0 0 6.75 6.75h2.018a5.25 5.25 0 0 0 3.712-1.538l1.732-1.732a5.25 5.25 0 0 0 1.538-3.712l.003-2.024a.668.668 0 0 1 .198-.471 1.575 1.575 0 1 0-2.228-2.228 3.818 3.818 0 0 0-1.12 2.687M6.9 7.575V12m6.27 4.318A4.49 4.49 0 0 1 16.35 15m.002 0h-.002"
+          />
+        </svg>
+      </button>
+      <button
+        data-testid="edit-panel-pawn-{color}"
+        style="background-color: {api.editState?.mode?.piece === 'p' &&
+        api.editState?.mode?.color === color
+          ? 'pink'
+          : api.theme.w}"
+        class="flex aspect-square w-1/8"
+        onclick={() => onSelect("p")}
+      >
+        {@render api.chessSet?.pawn(color === "w" ? "w" : "b")}
+      </button>
+      <button
+        data-testid="edit-panel-knight-{color}"
+        style="background-color: {api.editState?.mode?.piece === 'n' &&
+        api.editState?.mode?.color === color
+          ? 'pink'
+          : api.theme.b}"
+        class="flex aspect-square w-1/8"
+        onclick={() => onSelect("n")}
+      >
+        {@render api.chessSet?.knight(color)}
+      </button>
+      <button
+        data-testid="edit-panel-bishop-{color}"
+        style="background-color: {api.editState?.mode?.piece === 'b' &&
+        api.editState?.mode?.color === color
+          ? 'pink'
+          : api.theme.w}"
+        class="flex aspect-square w-1/8"
+        onclick={() => onSelect("b")}
+      >
+        {@render api.chessSet?.bishop(color)}
+      </button>
+      <button
+        data-testid="edit-panel-rook-{color}"
+        style="background-color: {api.editState?.mode?.piece === 'r' &&
+        api.editState?.mode?.color === color
+          ? 'pink'
+          : api.theme.b}"
+        class="flex aspect-square w-1/8"
+        onclick={() => onSelect("r")}
+      >
+        {@render api.chessSet?.rook(color)}
+      </button>
+      <button
+        data-testid="edit-panel-queen-{color}"
+        style="background-color: {api.editState?.mode?.piece === 'q' &&
+        api.editState?.mode?.color === color
+          ? 'pink'
+          : api.theme.w}"
+        class="flex aspect-square w-1/8"
+        onclick={() => onSelect("q")}
+      >
+        {@render api.chessSet?.queen(color)}
+      </button>
+      <button
+        data-testid="edit-panel-king-{color}"
+        style="background-color: {api.editState?.mode?.piece === 'k' &&
+        api.editState?.mode?.color === color
+          ? 'pink'
+          : api.theme.b}"
+        class="flex aspect-square w-1/8"
+        onclick={() => onSelect("k")}
+      >
+        {@render api.chessSet?.king(color)}
+      </button>
+      <button
+        aria-label="Delete piece"
+        data-testid="edit-panel-delete-{color}"
+        style="background-color: {api.editState?.mode?.type === 'delete'
+          ? 'pink'
+          : api.theme.w}"
+        class="flex aspect-square w-1/8"
+        onclick={() => onSelect("delete")}
+      >
+        <svg
+          xmlns="http://www.w3.org/2000/svg"
+          fill="none"
+          viewBox="0 0 24 24"
+          stroke-width="1.5"
+          stroke="currentColor"
+          class="p-2 md:p-3 text-white"
+        >
+          <path
+            stroke-linecap="round"
+            stroke-linejoin="round"
+            d="m14.74 9-.346 9m-4.788 0L9.26 9m9.968-3.21c.342.052.682.107 1.022.166m-1.022-.165L18.16 19.673a2.25 2.25 0 0 1-2.244 2.077H8.084a2.25 2.25 0 0 1-2.244-2.077L4.772 5.79m14.456 0a48.108 48.108 0 0 0-3.478-.397m-12 .562c.34-.059.68-.114 1.022-.165m0 0a48.11 48.11 0 0 1 3.478-.397m7.5 0v-.916c0-1.18-.91-2.164-2.09-2.201a51.964 51.964 0 0 0-3.32 0c-1.18.037-2.09 1.022-2.09 2.201v.916m7.5 0a48.667 48.667 0 0 0-7.5 0"
+          />
+        </svg>
+      </button>
+    </div>
+  </div>
+{/if}

package/dist/position-editor/EditPanel.svelte.d.ts

@@ -0,0 +1,8 @@
+import type { BoardApi } from "@connectorvol/chessboard";
+interface Props {
+    color: "w" | "b";
+    api: BoardApi;
+}
+declare const EditPanel: import("svelte").Component<Props, {}, "">;
+type EditPanel = ReturnType<typeof EditPanel>;
+export default EditPanel;

package/dist/position-editor/fen.svelte.d.ts

@@ -0,0 +1,26 @@
+import type { BoardApi } from "@connectorvol/chessboard";
+export type Castling = `${"K" | "Q" | "k" | "q" | ""}${"Q" | "k" | "q" | ""}${"k" | "q" | ""}${"q" | ""}` | "-";
+export declare class Fen {
+    private api;
+    position: string;
+    move: "w" | "b";
+    castling: Castling;
+    enPassant: string;
+    halfmove: number;
+    fullmove: number;
+    constructor(api: BoardApi);
+    get fullFen(): string;
+    set fullFen(fen: string);
+    validateFullFen(fen: string): boolean;
+    validateMove(move: string): boolean;
+    validateEnPassant(enPassant: string): boolean;
+    validateHalfmove(halfmove: string): boolean;
+    validateFullmove(fullmove: string): boolean;
+    validatePosition(position: string): boolean;
+    validateCastling(castling: Castling): boolean;
+    /**
+     * Представляет генерацию возможных ходов en passant.
+     * Возвращает коллекцию возможных полей для взятия на проходе.
+     */
+    genPossibleEnPassantMoves(): string[];
+}

package/dist/position-editor/fen.svelte.js

@@ -0,0 +1,177 @@
+export class Fen {
+    api;
+    position;
+    move = $state("w");
+    castling = $state("KQkq");
+    enPassant = $state("-");
+    halfmove = $state(0);
+    fullmove = $state(1);
+    constructor(api) {
+        this.api = api;
+        this.position = $derived(this.api.fen);
+    }
+    get fullFen() {
+        return `${this.position} ${this.move} ${this.castling} ${this.enPassant} ${this.halfmove} ${this.fullmove}`;
+    }
+    set fullFen(fen) {
+        const [position, move, castling, enPassant, halfmove, fullmove] = fen.split(" ");
+        if (!this.validateFullFen(fen)) {
+            throw new Error("Invalid FEN");
+        }
+        this.api.fen = position;
+        this.move = move;
+        this.castling = castling;
+        this.enPassant = enPassant ? enPassant : "-";
+        this.halfmove = Number(halfmove) || 0;
+        this.fullmove = Number(fullmove) || 1;
+    }
+    validateFullFen(fen) {
+        const [position, move, castling, enPassant, halfmove, fullmove] = fen.split(" ");
+        return (this.validatePosition(position) &&
+            this.validateCastling(castling) &&
+            this.validateMove(move) &&
+            this.validateEnPassant(enPassant) &&
+            this.validateHalfmove(halfmove) &&
+            this.validateFullmove(fullmove));
+    }
+    validateMove(move) {
+        return move === "w" || move === "b";
+    }
+    validateEnPassant(enPassant) {
+        return enPassant === "-" || enPassant.length === 2;
+    }
+    validateHalfmove(halfmove) {
+        return Number(halfmove) >= 0;
+    }
+    validateFullmove(fullmove) {
+        return Number(fullmove) >= 1;
+    }
+    validatePosition(position) {
+        const rows = position.split("/");
+        if (rows.length !== 8)
+            return false;
+        for (const row of rows) {
+            let counter = 0;
+            for (const cell of row) {
+                if (cell !== "P" &&
+                    cell !== "p" &&
+                    cell !== "N" &&
+                    cell !== "n" &&
+                    cell !== "B" &&
+                    cell !== "b" &&
+                    cell !== "R" &&
+                    cell !== "r" &&
+                    cell !== "Q" &&
+                    cell !== "q" &&
+                    cell !== "K" &&
+                    cell !== "k" &&
+                    cell !== "1" &&
+                    cell !== "2" &&
+                    cell !== "3" &&
+                    cell !== "4" &&
+                    cell !== "5" &&
+                    cell !== "6" &&
+                    cell !== "7" &&
+                    cell !== "8") {
+                    return false;
+                }
+                if (cell === "1" ||
+                    cell === "2" ||
+                    cell === "3" ||
+                    cell === "4" ||
+                    cell === "5" ||
+                    cell === "6" ||
+                    cell === "7" ||
+                    cell === "8") {
+                    counter += Number(cell);
+                }
+                else {
+                    counter++;
+                }
+            }
+            if (counter > 8)
+                return false;
+        }
+        return true;
+    }
+    validateCastling(castling) {
+        if (castling === "-")
+            return true;
+        if (castling.length > 4)
+            return false;
+        const castlingArray = castling.split("");
+        for (const c of castlingArray) {
+            if (c !== "K" && c !== "Q" && c !== "k" && c !== "q")
+                return false;
+        }
+        return true;
+    }
+    /**
+     * Представляет генерацию возможных ходов en passant.
+     * Возвращает коллекцию возможных полей для взятия на проходе.
+     */
+    genPossibleEnPassantMoves() {
+        const fenPosition = this.position.split(" ")[0];
+        const rows = fenPosition.split("/");
+        function toSquare(file, rank) {
+            return String.fromCharCode("a".charCodeAt(0) + file) + (8 - rank);
+        }
+        function parseFenRow(row) {
+            const result = [];
+            for (const c of row) {
+                if (/\d/.test(c)) {
+                    for (let i = 0; i < Number(c); i++)
+                        result.push(null);
+                }
+                else {
+                    result.push(c);
+                }
+            }
+            return result;
+        }
+        const result = [];
+        const row6 = parseFenRow(rows[6] || "");
+        const row5 = parseFenRow(rows[5] || "");
+        const row4 = parseFenRow(rows[4] || "");
+        const row3 = parseFenRow(rows[3] || "");
+        const row2 = parseFenRow(rows[2] || "");
+        const row1 = parseFenRow(rows[1] || "");
+        if (this.move === "b") {
+            for (let file = 0; file < 8; file++) {
+                if (row4[file] === "P" && !row5[file] && !row6[file]) {
+                    if (file > 0 && row4[file - 1] === "p") {
+                        const square = toSquare(file, 5);
+                        if (!result.includes(square)) {
+                            result.push(square);
+                        }
+                    }
+                    if (file < 7 && row4[file + 1] === "p") {
+                        const square = toSquare(file, 5);
+                        if (!result.includes(square)) {
+                            result.push(square);
+                        }
+                    }
+                }
+            }
+        }
+        else {
+            for (let file = 0; file < 8; file++) {
+                if (row3[file] === "p" && !row2[file] && !row1[file]) {
+                    if (file > 0 && row3[file - 1] === "P") {
+                        const square = toSquare(file, 2);
+                        if (!result.includes(square)) {
+                            result.push(square);
+                        }
+                    }
+                    if (file < 7 && row3[file + 1] === "P") {
+                        const square = toSquare(file, 2);
+                        if (!result.includes(square)) {
+                            result.push(square);
+                        }
+                    }
+                }
+            }
+        }
+        return result;
+    }
+}

package/dist/puzzle/puzzleCreatedPayload.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Представляет данные задачи, передаваемые колбэку после завершения мастера.
+ */
+export interface TPuzzleCreatedPayload {
+    /**
+     * Возвращает строку только с ходами и результатом (без тегов заголовка PGN).
+     */
+    puzzlePgn: string;
+    /**
+     * Возвращает начальный FEN задачи (из тега FEN или начальная позиция по умолчанию).
+     */
+    fen: string;
+}
+/**
+ * Представляет разбор полного PGN из дерева задачи на FEN и чистую строку ходов.
+ */
+export declare function puzzlePartsFromFullPgn(fullPgn: string): TPuzzleCreatedPayload;

package/dist/puzzle/puzzleCreatedPayload.js

@@ -0,0 +1,24 @@
+import { INITIAL_FEN } from "@connectorvol/chessops/fen";
+import { makePgn, parsePgn, } from "@connectorvol/chessops/pgn";
+/**
+ * Представляет разбор полного PGN из дерева задачи на FEN и чистую строку ходов.
+ */
+export function puzzlePartsFromFullPgn(fullPgn) {
+    const trimmed = fullPgn.trim();
+    if (!trimmed) {
+        return { puzzlePgn: "", fen: INITIAL_FEN };
+    }
+    const games = parsePgn(trimmed);
+    const game = games[0];
+    if (!game) {
+        return { puzzlePgn: "", fen: INITIAL_FEN };
+    }
+    const fen = game.headers.get("FEN") ?? INITIAL_FEN;
+    const movesOnly = {
+        headers: new Map(),
+        comments: game.comments,
+        moves: game.moves,
+    };
+    const puzzlePgn = makePgn(movesOnly).trim();
+    return { puzzlePgn, fen };
+}

package/dist/puzzle/puzzleData.d.ts

@@ -0,0 +1,32 @@
+import type { TChessTree } from "@connectorvol/tree";
+/** Полный FEN пустой доски (используется как начальное состояние мастера без входного FEN). */
+export declare const PUZZLE_EMPTY_BOARD_FEN = "8/8/8/8/8/8/8/8 w - - 0 1";
+/**
+ * Представляет данные шахматного puzzle.
+ */
+export interface PuzzleData {
+    /**
+     * Возвращает начальную позицию в формате FEN.
+     */
+    initialFen: string;
+    /**
+     * Возвращает массив ходов решения в нотации SAN.
+     */
+    moves: string[];
+}
+/**
+ * Возвращает начальные данные для создания puzzle.
+ *
+ * @param initialFen полный FEN; если не передан — пустая доска (`PUZZLE_EMPTY_BOARD_FEN`).
+ */
+export declare function createInitialPuzzleData(initialFen?: string): PuzzleData;
+/**
+ * Представляет создание пустого дерева ходов из начальной позиции FEN.
+ * Возвращает корень дерева (TChessTree) для использования в ChessTree.
+ */
+export declare function createEmptyTreeFromFen(initialFen: string): TChessTree;
+/**
+ * Представляет извлечение главной линии (первого варианта) из дерева ходов.
+ * Возвращает массив ходов в нотации SAN.
+ */
+export declare function getMainLineFromTree(rootNode: TChessTree): string[];

package/dist/puzzle/puzzleData.js

@@ -0,0 +1,51 @@
+import { defaultHeaders } from "@connectorvol/chessops/pgn";
+import { generateId } from "@connectorvol/shared";
+/** Полный FEN пустой доски (используется как начальное состояние мастера без входного FEN). */
+export const PUZZLE_EMPTY_BOARD_FEN = "8/8/8/8/8/8/8/8 w - - 0 1";
+/**
+ * Возвращает начальные данные для создания puzzle.
+ *
+ * @param initialFen полный FEN; если не передан — пустая доска (`PUZZLE_EMPTY_BOARD_FEN`).
+ */
+export function createInitialPuzzleData(initialFen) {
+    return {
+        initialFen: initialFen ?? PUZZLE_EMPTY_BOARD_FEN,
+        moves: [],
+    };
+}
+/**
+ * Представляет создание пустого дерева ходов из начальной позиции FEN.
+ * Возвращает корень дерева (TChessTree) для использования в ChessTree.
+ */
+export function createEmptyTreeFromFen(initialFen) {
+    const headers = defaultHeaders();
+    headers.set("FEN", initialFen);
+    const rootNode = {
+        id: generateId(),
+        children: [],
+        data: {
+            fen: initialFen,
+            san: "",
+            ply: 0,
+            fullMoves: 0,
+        },
+    };
+    return {
+        moves: rootNode,
+        headers,
+    };
+}
+/**
+ * Представляет извлечение главной линии (первого варианта) из дерева ходов.
+ * Возвращает массив ходов в нотации SAN.
+ */
+export function getMainLineFromTree(rootNode) {
+    const line = [];
+    let node = rootNode.moves;
+    while (node.children.length > 0) {
+        node = node.children[0];
+        if (node.data.san)
+            line.push(node.data.san);
+    }
+    return line;
+}

package/dist/puzzle/puzzleSolverForkAnnotations.d.ts

@@ -0,0 +1,14 @@
+import type { ChessTree } from "@connectorvol/tree";
+import { Color } from "@connectorvol/shared";
+/**
+ * Представляет проверку линии решения задачи: метки ✓/✗ только на ходах из развилки,
+ * запрет ✓/✗ ниже по дереву после ✗ на ходе решателя, разметка развилок со стороны
+ * решателя и окончание вариантов на развилке соперника ходом решателя вне поддерева
+ * после хода решателя с меткой «неверное решение».
+ */
+export declare function validatePuzzleSolverForkAnnotations(tree: ChessTree, solverColor: Color): {
+    ok: true;
+} | {
+    ok: false;
+    reason: string;
+};

package/dist/puzzle/puzzleSolverForkAnnotations.js

@@ -0,0 +1,94 @@
+import { Color, PUZZLE_BRANCH_CORRECT_NAG_ID, PUZZLE_BRANCH_WRONG_NAG_ID, } from "@connectorvol/shared";
+/**
+ * Представляет извлечение стороны, имеющей ход, из полной строки FEN.
+ */
+function sideToMoveFromFullFen(fullFen) {
+    const token = fullFen.trim().split(/\s+/)[1];
+    return token === "b" ? Color.BLACK : Color.WHITE;
+}
+/**
+ * Представляет узел конца главной линии от указанного узла (цепочка первых детей до листа).
+ */
+function tailAlongFirstVariation(node) {
+    let n = node;
+    while (n.children.length > 0) {
+        n = n.children[0];
+    }
+    return n;
+}
+/**
+ * Представляет проверку: в позиции после последнего хода на линии последним ходил решатель (теперь ходит соперник).
+ */
+function solverJustPlayedLastOnLine(fullFen, solverColor) {
+    return sideToMoveFromFullFen(fullFen) !== solverColor;
+}
+/**
+ * Представляет проверку линии решения задачи: метки ✓/✗ только на ходах из развилки,
+ * запрет ✓/✗ ниже по дереву после ✗ на ходе решателя, разметка развилок со стороны
+ * решателя и окончание вариантов на развилке соперника ходом решателя вне поддерева
+ * после хода решателя с меткой «неверное решение».
+ */
+export function validatePuzzleSolverForkAnnotations(tree, solverColor) {
+    function walk(node, parent, ancestorsContainWrongMarkedSolver) {
+        const puzzleForkNags = node.data.nags ?? [];
+        const hasPuzzleForkMarker = puzzleForkNags.includes(PUZZLE_BRANCH_CORRECT_NAG_ID) ||
+            puzzleForkNags.includes(PUZZLE_BRANCH_WRONG_NAG_ID);
+        if (hasPuzzleForkMarker && (!parent || parent.children.length <= 1)) {
+            return {
+                ok: false,
+                reason: "Метки верного или неверного хода задачи (✓ / ✗) можно ставить только на ход из развилки: у родительской позиции должно быть несколько вариантов хода.",
+            };
+        }
+        if (ancestorsContainWrongMarkedSolver && hasPuzzleForkMarker) {
+            return {
+                ok: false,
+                reason: "Внутри продолжения после хода решателя с меткой ✗ «неверное решение» не ставьте метки ✓ и ✗ на последующих развилках.",
+            };
+        }
+        if (node.children.length > 1) {
+            const mover = sideToMoveFromFullFen(node.data.fen);
+            if (mover === solverColor && !ancestorsContainWrongMarkedSolver) {
+                for (const child of node.children) {
+                    const nags = child.data.nags ?? [];
+                    const markedCorrect = nags.includes(PUZZLE_BRANCH_CORRECT_NAG_ID);
+                    const markedWrong = nags.includes(PUZZLE_BRANCH_WRONG_NAG_ID);
+                    if (markedCorrect === markedWrong) {
+                        return {
+                            ok: false,
+                            reason: "На каждой развилке со стороны решателя отметьте каждый вариант: ✓ верное решение или ✗ неверное.",
+                        };
+                    }
+                    if (markedCorrect) {
+                        const leaf = tailAlongFirstVariation(child);
+                        if (!solverJustPlayedLastOnLine(leaf.data.fen, solverColor)) {
+                            return {
+                                ok: false,
+                                reason: "Ветка с ✓ должна заканчиваться ходом решателя: продолжите главный вариант после верного хода, пока полуход решателя не станет последним на этой линии.",
+                            };
+                        }
+                    }
+                }
+            }
+            else if (mover !== solverColor && !ancestorsContainWrongMarkedSolver) {
+                for (const child of node.children) {
+                    const leaf = tailAlongFirstVariation(child);
+                    if (!solverJustPlayedLastOnLine(leaf.data.fen, solverColor)) {
+                        return {
+                            ok: false,
+                            reason: "На развилке со стороны соперника каждый вариант должен заканчиваться ходом решателя: продолжите линию после ответа соперника, пока последним не походит решатель.",
+                        };
+                    }
+                }
+            }
+        }
+        const wrongMarkedAmongAncestorsForChildren = ancestorsContainWrongMarkedSolver ||
+            (node.data.nags ?? []).includes(PUZZLE_BRANCH_WRONG_NAG_ID);
+        for (const child of node.children) {
+            const sub = walk(child, node, wrongMarkedAmongAncestorsForChildren);
+            if (!sub.ok)
+                return sub;
+        }
+        return { ok: true };
+    }
+    return walk(tree.rootNode.moves, null, false);
+}

package/dist/puzzle/puzzleStepPreviewSolver.d.ts

@@ -0,0 +1,39 @@
+import type { ChessTree, ChessTreeNode } from "@connectorvol/tree";
+import { PgnOps } from "@connectorvol/chessops/pgnOps.svelte";
+import { Color } from "@connectorvol/shared";
+/**
+ * Представляет результат разбора хода решателя относительно вариантов в узле дерева задачи.
+ */
+export type TSolverMoveOutcome = {
+    kind: "no_matching_variant";
+} | {
+    kind: "wrong_marked_variant";
+    wrongBranchRoot: ChessTreeNode;
+} | {
+    kind: "correct";
+    childIndex: number;
+};
+/**
+ * Представляет извлечение стороны, имеющей ход, из полной строки FEN.
+ */
+export declare function puzzlePreviewSideToMoveFromFen(fullFen: string): Color;
+/**
+ * Представляет получение узла дерева по пути индексов детей от корня партии.
+ */
+export declare function puzzlePreviewNodeAtPath(rootMoves: ChessTreeNode, path: number[]): ChessTreeNode;
+/**
+ * Представляет поиск индекса ребёнка, чей SAN даёт ту же результирующую позицию, что и сыгранный SAN.
+ */
+export declare function puzzlePreviewFindChildIndexForPlayedSan(cursorFen: string, children: ChessTreeNode[], playedSan: string): number;
+/**
+ * Представляет классификацию хода решателя на развилке (или на единственном продолжении).
+ */
+export declare function puzzlePreviewClassifySolverMove(cursorNode: ChessTreeNode, cursorFen: string, playedSan: string, solverColor: Color): TSolverMoveOutcome;
+/**
+ * Представляет проверку: линия закончилась ключевым ходом решателя (ход соперника, лист дерева).
+ */
+export declare function puzzlePreviewIsSolvedPosition(previewChess: PgnOps, leafNode: ChessTreeNode, solverColor: Color): boolean;
+/**
+ * Представляет рекурсивное клонирование поддерева варианта под текущим узлом студенческого дерева (новые id обеспечивает ChessTree.addNodeToCurrent).
+ */
+export declare function puzzlePreviewDupSubtreeUnderStudentCursor(studentTree: ChessTree, sourceNode: ChessTreeNode): void;