@wsabol/sudoku-solver 0.1.0

package/README.md

@@ -0,0 +1,132 @@
+# Sudoku Solver (Node Module)
+
+TypeScript module for Sudoku solve, next move, describe, and validate operations.
+
+## Install
+
+```bash
+npm install
+```
+
+## Build
+
+```bash
+npm run build
+```
+
+Build output is written to `dist/`.
+
+## Usage
+
+```ts
+import Sudoku from "sudoku-solver";
+
+const board =
+    "000010080302607000070000003080070500004000600003050010200000050000705108060040000";
+
+const solved = Sudoku.solve(board);
+console.log(solved.isValid); // true
+console.log(solved.board);   // number[][]
+
+const next = Sudoku.nextMove(board);
+console.log(next.status);  // "In progress"
+console.log(next.message); // e.g. "Place 4 in r1c3" or "Eliminate 5 from 2 cell(s) (Pointing Pair/Triple)"
+if (next.move?.type === "placement") {
+    console.log(next.move.row, next.move.col, next.move.value);
+} else if (next.move?.type === "elimination") {
+    console.log(next.move.eliminations); // [{ row, col, value }, ...]
+}
+
+const check = Sudoku.validate(board);
+console.log(check.isValid);  // true/false
+console.log(check.reasons);  // ValidationReason[]
+
+const info = Sudoku.describe(board);
+console.log(info.difficulty); // "Easy" | "Medium" | "Hard" | "Diabolical" | "Impossible"
+console.log(info.solutions);  // 0 | 1
+```
+
+## API
+
+### `Sudoku.solve(boardInput)`
+
+Accepts `string | number[][]`.
+
+Returns:
+
+```ts
+{
+    isValid: boolean;
+    board: number[][];
+}
+```
+
+`isValid` is `false` when the board is structurally invalid or has no solution.
+
+### `Sudoku.nextMove(boardInput)`
+
+Accepts `string | number[][]`.
+
+Returns:
+
+```ts
+{
+    status: "Complete" | "In progress" | "Invalid";
+    move: PlacementMove | EliminationMove | null;
+    message: string;
+}
+```
+
+`move` is a discriminated union:
+
+```ts
+// digit placement
+{ type: "placement"; row: number; col: number; value: number; algorithm: Algorithm }
+
+// candidate elimination (e.g. Pointing Pair/Triple)
+{ type: "elimination"; eliminations: Array<{ row: number; col: number; value: number }>; algorithm: Algorithm }
+```
+
+Notes:
+- `move` is `null` when the board is complete or invalid.
+- `move.type` must be checked before accessing placement-specific fields (`row`, `col`, `value`).
+- `message` is human-readable: `"Place 4 in r1c3"` for placements, `"Eliminate 5 from 2 cell(s) (Pointing Pair/Triple)"` for eliminations.
+
+### `Sudoku.validate(boardInput)`
+
+Accepts `string | number[][]`.
+
+Returns:
+
+```ts
+{
+    isValid: boolean;
+    message: string;
+    reasons: ValidationReason[];
+}
+```
+
+### `Sudoku.describe(boardInput)`
+
+Accepts `string | number[][]`.
+
+Returns:
+
+```ts
+{
+    isValid: boolean;
+    isComplete: boolean;
+    message: string;
+    difficulty: "Easy" | "Medium" | "Hard" | "Diabolical" | "Impossible";
+    solutions: number;
+}
+```
+
+`difficulty` is derived from empty cell count. `solutions` is `0` when the board is invalid/unsolvable, `1` when a unique solution exists.
+
+## Development
+
+```bash
+npm test
+npm run typecheck
+```

package/dist/index.d.ts

@@ -0,0 +1,33 @@
+import SudokuSolver, { type Algorithm, type Board, type Move, type PlacementMove, type EliminationMove } from "./sudokuSolver";
+import { type ValidationReason, type ValidationResult } from "./validate";
+interface SolveResult {
+    isValid: boolean;
+    board: Board;
+}
+interface DescribeResult {
+    isValid: boolean;
+    isComplete: boolean;
+    message: string;
+    difficulty: string;
+    solutions: number;
+}
+type MoveStatus = "Complete" | "In progress" | "Invalid";
+interface MoveResult {
+    status: MoveStatus;
+    move: Move | null;
+    message: string;
+}
+declare function solve(boardInput: string | Board): SolveResult;
+declare function nextMove(boardInput: string | Board): MoveResult;
+declare function validate(boardInput: string | Board): ValidationResult;
+declare function describeBoard(boardInput: string | Board): DescribeResult;
+declare const Sudoku: {
+    solve: typeof solve;
+    nextMove: typeof nextMove;
+    validate: typeof validate;
+    describe: typeof describeBoard;
+};
+export { SudokuSolver };
+export type { Algorithm, Board, Move, PlacementMove, EliminationMove, ValidationReason, ValidationResult, SolveResult, MoveResult, MoveStatus, DescribeResult };
+export default Sudoku;
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,YAAY,EAAE,EAAE,KAAK,SAAS,EAAE,KAAK,KAAK,EAAE,KAAK,IAAI,EAAE,KAAK,aAAa,EAAE,KAAK,eAAe,EAAE,MAAM,gBAAgB,CAAC;AAC/H,OAAO,EAA8C,KAAK,gBAAgB,EAAE,KAAK,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAEtH,UAAU,WAAW;IACjB,OAAO,EAAE,OAAO,CAAC;IACjB,KAAK,EAAE,KAAK,CAAC;CAChB;AAED,UAAU,cAAc;IACpB,OAAO,EAAE,OAAO,CAAC;IACjB,UAAU,EAAE,OAAO,CAAC;IACpB,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,EAAE,MAAM,CAAC;CACrB;AAED,KAAK,UAAU,GAAG,UAAU,GAAG,aAAa,GAAG,SAAS,CAAC;AAEzD,UAAU,UAAU;IAChB,MAAM,EAAE,UAAU,CAAC;IACnB,IAAI,EAAE,IAAI,GAAG,IAAI,CAAC;IAClB,OAAO,EAAE,MAAM,CAAC;CACnB;AAED,iBAAS,KAAK,CAAC,UAAU,EAAE,MAAM,GAAG,KAAK,GAAG,WAAW,CAOtD;AAED,iBAAS,QAAQ,CAAC,UAAU,EAAE,MAAM,GAAG,KAAK,GAAG,UAAU,CA8BxD;AAED,iBAAS,QAAQ,CAAC,UAAU,EAAE,MAAM,GAAG,KAAK,GAAG,gBAAgB,CAY9D;AAED,iBAAS,aAAa,CAAC,UAAU,EAAE,MAAM,GAAG,KAAK,GAAG,cAAc,CAoCjE;AAED,QAAA,MAAM,MAAM;;;;;CAKX,CAAC;AAEF,OAAO,EACH,YAAY,EACf,CAAA;AAGD,YAAY,EACR,SAAS,EACT,KAAK,EACL,IAAI,EACJ,aAAa,EACb,eAAe,EACf,gBAAgB,EAChB,gBAAgB,EAChB,WAAW,EACX,UAAU,EACV,UAAU,EACV,cAAc,EACjB,CAAC;AAEF,eAAe,MAAM,CAAC"}

package/dist/index.js

@@ -0,0 +1,95 @@
+import SudokuSolver from "./sudokuSolver";
+import { invalidBoardLength, invalidBoardCharacters } from "./validate";
+function solve(boardInput) {
+    const sudoku = new SudokuSolver(boardInput);
+    const isValid = sudoku.solve();
+    return {
+        isValid: isValid,
+        board: sudoku.toArray(),
+    };
+}
+function nextMove(boardInput) {
+    const sudoku = new SudokuSolver(boardInput);
+    const validation = sudoku.validate();
+    if (!validation.isValid) {
+        return {
+            status: "Invalid",
+            move: null,
+            message: `Invalid Puzzle: ${validation.message}`,
+        };
+    }
+    const move = sudoku.getNextMove();
+    let message;
+    if (!move) {
+        message = "No more moves";
+    }
+    else if (move.type === "placement") {
+        message = `Place ${move.value} in r${move.row + 1}c${move.col + 1} (${move.algorithm})`;
+        sudoku.setSquareValue(move.row, move.col, move.value);
+    }
+    else {
+        const digit = move.eliminations[0].value;
+        message = `Eliminate ${digit} from ${move.eliminations.length} cell(s) (${move.algorithm})`;
+        sudoku.applyElimination(move);
+    }
+    return {
+        status: sudoku.isComplete() ? "Complete" : "In progress",
+        move,
+        message,
+    };
+}
+function validate(boardInput) {
+    if (typeof boardInput === "string") {
+        if (boardInput.length !== 81) {
+            return invalidBoardLength(boardInput.length);
+        }
+        if (!/^[0-9.]{81}$/.test(boardInput)) {
+            return invalidBoardCharacters();
+        }
+    }
+    const test = new SudokuSolver(boardInput);
+    return test.validate();
+}
+function describeBoard(boardInput) {
+    const sudoku = new SudokuSolver(boardInput);
+    const initValidation = sudoku.validate();
+    if (!initValidation.isValid) {
+        return {
+            isValid: false,
+            isComplete: false,
+            message: initValidation.message,
+            difficulty: '',
+            solutions: 0,
+        };
+    }
+    let result = {
+        isValid: true,
+        isComplete: sudoku.isComplete(),
+        message: '',
+        difficulty: sudoku.difficulty(),
+        solutions: 0,
+    };
+    if (result.isComplete) {
+        result.solutions = 1;
+        result.message = 'Solvable with a single solution';
+    }
+    else {
+        sudoku.solve();
+        if (sudoku.isComplete()) {
+            result.solutions = 1;
+            result.message = 'Unique Solution';
+        }
+        else {
+            result.message = 'Invalid Puzzle (\"no unique solution\")';
+        }
+    }
+    return result;
+}
+const Sudoku = {
+    solve: solve,
+    nextMove: nextMove,
+    validate: validate,
+    describe: describeBoard,
+};
+export { SudokuSolver };
+export default Sudoku;

package/dist/sudoku.d.ts

@@ -0,0 +1,35 @@
+export type Board = number[][];
+export interface Move {
+    row: number;
+    col: number;
+    value: number;
+}
+export declare function parseBoardString(board: string): Board;
+export declare class Sudoku {
+    private board;
+    private possiblesGrid;
+    private numGivens;
+    constructor(input: string | Board);
+    toJSONBoard(): Board;
+    private boxIndex;
+    private boxToPuzzle;
+    private getRow;
+    private getColumn;
+    private getBox;
+    private valuesMissing;
+    possibles(row: number, col: number): number[];
+    private calcSquarePossibles;
+    calcPossibles(): void;
+    setSquareValue(row: number, col: number, value: number): void;
+    isValid(): boolean;
+    isComplete(): boolean;
+    private findNakedSingle;
+    private findHiddenSingleInRow;
+    private findHiddenSingleInCol;
+    private findHiddenSingleInBox;
+    getNextMove(): Move | null;
+    private simpleSolve;
+    private uniPossiblesSolve;
+    solve(): string;
+}
+//# sourceMappingURL=sudoku.d.ts.map

package/dist/sudoku.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sudoku.d.ts","sourceRoot":"","sources":["../src/sudoku.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,KAAK,GAAG,MAAM,EAAE,EAAE,CAAC;AAE/B,MAAM,WAAW,IAAI;IACjB,GAAG,EAAE,MAAM,CAAC;IACZ,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,MAAM,CAAC;CACjB;AAcD,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,MAAM,GAAG,KAAK,CAmBrD;AAED,qBAAa,MAAM;IACf,OAAO,CAAC,KAAK,CAAQ;IACrB,OAAO,CAAC,aAAa,CAAe;IACpC,OAAO,CAAC,SAAS,CAAS;gBAEd,KAAK,EAAE,MAAM,GAAG,KAAK;IAmBjC,WAAW,IAAI,KAAK;IAIpB,OAAO,CAAC,QAAQ;IAIhB,OAAO,CAAC,WAAW;IAOnB,OAAO,CAAC,MAAM;IAId,OAAO,CAAC,SAAS;IAIjB,OAAO,CAAC,MAAM;IAYd,OAAO,CAAC,aAAa;IAIrB,SAAS,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,EAAE;IAI7C,OAAO,CAAC,mBAAmB;IAU3B,aAAa,IAAI,IAAI;IAQrB,cAAc,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI;IAa7D,OAAO,IAAI,OAAO;IAiFlB,UAAU,IAAI,OAAO;IAIrB,OAAO,CAAC,eAAe;IAcvB,OAAO,CAAC,qBAAqB;IAe7B,OAAO,CAAC,qBAAqB;IAe7B,OAAO,CAAC,qBAAqB;IAgB7B,WAAW,IAAI,IAAI,GAAG,IAAI;IAgC1B,OAAO,CAAC,WAAW;IAQnB,OAAO,CAAC,iBAAiB;IA2BzB,KAAK,IAAI,MAAM;CAqClB"}

package/dist/sudoku.js

@@ -0,0 +1,332 @@
+const COMPLETE = [1, 2, 3, 4, 5, 6, 7, 8, 9];
+function cloneBoard(board) {
+    return board.map((row) => [...row]);
+}
+function assertBoardShape(board) {
+    if (board.length !== 9 || board.some((row) => row.length !== 9)) {
+        throw new Error("Board must be a 9x9 matrix");
+    }
+}
+export function parseBoardString(board) {
+    if (board.length !== 81) {
+        throw new Error(`Board must be 81 characters, got ${board.length}`);
+    }
+    const rows = Array.from({ length: 9 }, () => Array(9).fill(0));
+    for (let i = 0; i < 81; i += 1) {
+        const ch = board[i];
+        const row = Math.floor(i / 9);
+        const col = i % 9;
+        if (ch >= "1" && ch <= "9") {
+            rows[row][col] = Number(ch);
+        }
+        else if (ch === "0" || ch === ".") {
+            rows[row][col] = 0;
+        }
+        else {
+            throw new Error(`Invalid character '${ch}' at position ${i}`);
+        }
+    }
+    return rows;
+}
+export class Sudoku {
+    board;
+    possiblesGrid;
+    numGivens;
+    constructor(input) {
+        this.board = typeof input === "string" ? parseBoardString(input) : cloneBoard(input);
+        assertBoardShape(this.board);
+        this.numGivens = 0;
+        for (let r = 0; r < 9; r += 1) {
+            for (let c = 0; c < 9; c += 1) {
+                if (COMPLETE.includes(this.board[r][c])) {
+                    this.numGivens += 1;
+                }
+            }
+        }
+        this.possiblesGrid = Array.from({ length: 9 }, () => Array.from({ length: 9 }, () => []));
+        this.calcPossibles();
+    }
+    toJSONBoard() {
+        return cloneBoard(this.board);
+    }
+    boxIndex(row, col) {
+        return Math.floor(row / 3) * 3 + Math.floor(col / 3);
+    }
+    boxToPuzzle(ibox, idx) {
+        return {
+            row: Math.floor(ibox / 3) * 3 + Math.floor(idx / 3),
+            col: (ibox % 3) * 3 + (idx % 3),
+        };
+    }
+    getRow(row) {
+        return [...this.board[row]];
+    }
+    getColumn(col) {
+        return this.board.map((row) => row[col]);
+    }
+    getBox(ibox) {
+        const startRow = Math.floor(ibox / 3) * 3;
+        const startCol = (ibox % 3) * 3;
+        const out = [];
+        for (let r = startRow; r < startRow + 3; r += 1) {
+            for (let c = startCol; c < startCol + 3; c += 1) {
+                out.push(this.board[r][c]);
+            }
+        }
+        return out;
+    }
+    valuesMissing(values) {
+        return COMPLETE.filter((n) => !values.includes(n));
+    }
+    possibles(row, col) {
+        return [...this.possiblesGrid[row][col]];
+    }
+    calcSquarePossibles(row, col) {
+        if (this.board[row][col] > 0) {
+            return [];
+        }
+        const rowPossible = this.valuesMissing(this.getRow(row));
+        const colPossible = this.valuesMissing(this.getColumn(col));
+        const boxPossible = this.valuesMissing(this.getBox(this.boxIndex(row, col)));
+        return rowPossible.filter((n) => colPossible.includes(n) && boxPossible.includes(n));
+    }
+    calcPossibles() {
+        for (let r = 0; r < 9; r += 1) {
+            for (let c = 0; c < 9; c += 1) {
+                this.possiblesGrid[r][c] = this.calcSquarePossibles(r, c);
+            }
+        }
+    }
+    setSquareValue(row, col, value) {
+        const original = this.board[row][col];
+        if (!this.possibles(row, col).includes(value)) {
+            return;
+        }
+        this.board[row][col] = value;
+        this.calcPossibles();
+        if (!this.isValid()) {
+            this.board[row][col] = original;
+            this.calcPossibles();
+        }
+    }
+    isValid() {
+        for (let i = 0; i < 9; i += 1) {
+            const row = this.getRow(i).filter((v) => v > 0);
+            if (row.some((v) => v < 1 || v > 9)) {
+                return false;
+            }
+            if (new Set(row).size !== row.length) {
+                return false;
+            }
+        }
+        for (let i = 0; i < 9; i += 1) {
+            const col = this.getColumn(i).filter((v) => v > 0);
+            if (col.some((v) => v < 1 || v > 9)) {
+                return false;
+            }
+            if (new Set(col).size !== col.length) {
+                return false;
+            }
+        }
+        for (let i = 0; i < 9; i += 1) {
+            const box = this.getBox(i).filter((v) => v > 0);
+            if (box.some((v) => v < 1 || v > 9)) {
+                return false;
+            }
+            if (new Set(box).size !== box.length) {
+                return false;
+            }
+        }
+        for (let row = 0; row < 9; row += 1) {
+            for (let col = 0; col < 9; col += 1) {
+                if (this.board[row][col] === 0 && this.possibles(row, col).length === 0) {
+                    return false;
+                }
+            }
+        }
+        for (let row = 0; row < 9; row += 1) {
+            const rowValues = this.getRow(row);
+            for (let n = 1; n <= 9; n += 1) {
+                const hasCandidate = rowValues.some((v, col) => v === n || (v === 0 && this.possibles(row, col).includes(n)));
+                if (!hasCandidate) {
+                    return false;
+                }
+            }
+        }
+        for (let col = 0; col < 9; col += 1) {
+            const colValues = this.getColumn(col);
+            for (let n = 1; n <= 9; n += 1) {
+                const hasCandidate = colValues.some((v, row) => v === n || (v === 0 && this.possibles(row, col).includes(n)));
+                if (!hasCandidate) {
+                    return false;
+                }
+            }
+        }
+        for (let ibox = 0; ibox < 9; ibox += 1) {
+            const boxValues = this.getBox(ibox);
+            for (let n = 1; n <= 9; n += 1) {
+                let hasCandidate = false;
+                for (let idx = 0; idx < 9 && !hasCandidate; idx += 1) {
+                    const { row, col } = this.boxToPuzzle(ibox, idx);
+                    const value = boxValues[idx];
+                    hasCandidate = value === n || (value === 0 && this.possibles(row, col).includes(n));
+                }
+                if (!hasCandidate) {
+                    return false;
+                }
+            }
+        }
+        return true;
+    }
+    isComplete() {
+        return this.isValid() && this.board.every((row) => row.every((v) => v !== 0));
+    }
+    findNakedSingle() {
+        for (let row = 0; row < 9; row += 1) {
+            for (let col = 0; col < 9; col += 1) {
+                if (this.board[row][col] === 0) {
+                    const p = this.possibles(row, col);
+                    if (p.length === 1) {
+                        return { row, col, value: p[0] };
+                    }
+                }
+            }
+        }
+        return null;
+    }
+    findHiddenSingleInRow(row) {
+        for (let value = 1; value <= 9; value += 1) {
+            const candidates = [];
+            for (let col = 0; col < 9; col += 1) {
+                if (this.board[row][col] === 0 && this.possibles(row, col).includes(value)) {
+                    candidates.push(col);
+                }
+            }
+            if (candidates.length === 1) {
+                return { row, col: candidates[0], value };
+            }
+        }
+        return null;
+    }
+    findHiddenSingleInCol(col) {
+        for (let value = 1; value <= 9; value += 1) {
+            const candidates = [];
+            for (let row = 0; row < 9; row += 1) {
+                if (this.board[row][col] === 0 && this.possibles(row, col).includes(value)) {
+                    candidates.push(row);
+                }
+            }
+            if (candidates.length === 1) {
+                return { row: candidates[0], col, value };
+            }
+        }
+        return null;
+    }
+    findHiddenSingleInBox(ibox) {
+        for (let value = 1; value <= 9; value += 1) {
+            const candidates = [];
+            for (let idx = 0; idx < 9; idx += 1) {
+                const { row, col } = this.boxToPuzzle(ibox, idx);
+                if (this.board[row][col] === 0 && this.possibles(row, col).includes(value)) {
+                    candidates.push({ row, col });
+                }
+            }
+            if (candidates.length === 1) {
+                return { row: candidates[0].row, col: candidates[0].col, value };
+            }
+        }
+        return null;
+    }
+    getNextMove() {
+        if (this.isComplete() || !this.isValid()) {
+            return null;
+        }
+        const naked = this.findNakedSingle();
+        if (naked) {
+            return naked;
+        }
+        for (let row = 0; row < 9; row += 1) {
+            const move = this.findHiddenSingleInRow(row);
+            if (move) {
+                return move;
+            }
+        }
+        for (let col = 0; col < 9; col += 1) {
+            const move = this.findHiddenSingleInCol(col);
+            if (move) {
+                return move;
+            }
+        }
+        for (let box = 0; box < 9; box += 1) {
+            const move = this.findHiddenSingleInBox(box);
+            if (move) {
+                return move;
+            }
+        }
+        return null;
+    }
+    simpleSolve() {
+        let move = this.findNakedSingle();
+        while (move) {
+            this.setSquareValue(move.row, move.col, move.value);
+            move = this.findNakedSingle();
+        }
+    }
+    uniPossiblesSolve() {
+        for (let row = 0; row < 9; row += 1) {
+            let move = this.findHiddenSingleInRow(row);
+            while (move) {
+                this.setSquareValue(move.row, move.col, move.value);
+                this.simpleSolve();
+                move = this.findHiddenSingleInRow(row);
+            }
+        }
+        for (let col = 0; col < 9; col += 1) {
+            let move = this.findHiddenSingleInCol(col);
+            while (move) {
+                this.setSquareValue(move.row, move.col, move.value);
+                this.simpleSolve();
+                move = this.findHiddenSingleInCol(col);
+            }
+        }
+        for (let box = 0; box < 9; box += 1) {
+            let move = this.findHiddenSingleInBox(box);
+            while (move) {
+                this.setSquareValue(move.row, move.col, move.value);
+                this.simpleSolve();
+                move = this.findHiddenSingleInBox(box);
+            }
+        }
+    }
+    solve() {
+        if (!this.isValid()) {
+            return 'Invalid Puzzle ("no solution")';
+        }
+        this.simpleSolve();
+        if (this.isComplete()) {
+            return "Unique Solution";
+        }
+        let boardChanged = true;
+        while (!this.isComplete() && boardChanged) {
+            const before = JSON.stringify(this.board);
+            this.uniPossiblesSolve();
+            const after = JSON.stringify(this.board);
+            boardChanged = before !== after;
+        }
+        if (this.isComplete()) {
+            return "Unique Solution";
+        }
+        const valid = this.isValid();
+        const complete = this.isComplete();
+        if (!valid) {
+            return 'Invalid Puzzle ("no solution")';
+        }
+        if (this.numGivens < 17 && valid && !complete) {
+            return 'Invalid Puzzle ("not enough givens" / "multiple solutions")';
+        }
+        if (valid && !complete) {
+            return 'Invalid Puzzle ("no unique solution")';
+        }
+        return 'Invalid Puzzle ("unknown")';
+    }
+}

package/dist/sudokuSolver.d.ts

@@ -0,0 +1,56 @@
+import { ValidationResult } from "./validate";
+export type Board = number[][];
+export type Algorithm = "Full House" | "Naked Single" | "Hidden Single" | "Pointing Pair/Triple";
+export interface PlacementMove {
+    type: "placement";
+    row: number;
+    col: number;
+    value: number;
+    algorithm: Algorithm;
+}
+export interface EliminationMove {
+    type: "elimination";
+    eliminations: Array<{
+        row: number;
+        col: number;
+        value: number;
+    }>;
+    algorithm: Algorithm;
+}
+export type Move = PlacementMove | EliminationMove;
+export type DifficultyLevel = "Easy" | "Medium" | "Hard" | "Diabolical" | "Impossible";
+export default class SudokuSolver {
+    static readonly ALGORITHMS: Algorithm[];
+    private board;
+    private possiblesGrid;
+    constructor(input: string | Board);
+    setBoard(board: Board): void;
+    toArray(): Board;
+    getPossibles(row: number, col: number): number[];
+    setSquareValue(row: number, col: number, value: number): void;
+    applyElimination(move: EliminationMove): void;
+    isComplete(): boolean;
+    countEmptyCells(): number;
+    validate(): ValidationResult;
+    isValid(): boolean;
+    difficulty(): DifficultyLevel;
+    getNextMove(): Move | null;
+    solve(): boolean;
+    private boxIndex;
+    private boxToPuzzle;
+    private getRow;
+    private getColumn;
+    private getBox;
+    private valuesMissing;
+    private calcSquarePossibles;
+    private calcPossibles;
+    private findBestMove;
+    private findNextPlacement;
+    private findNakedSingle;
+    private findHiddenSingleInRow;
+    private findHiddenSingleInCol;
+    private findHiddenSingleInBox;
+    private findPointingPairTriple;
+    private findHiddenSingle;
+}
+//# sourceMappingURL=sudokuSolver.d.ts.map

package/dist/sudokuSolver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sudokuSolver.d.ts","sourceRoot":"","sources":["../src/sudokuSolver.ts"],"names":[],"mappings":"AACA,OAAO,EAAoB,gBAAgB,EAAoB,MAAM,YAAY,CAAC;AAElF,MAAM,MAAM,KAAK,GAAG,MAAM,EAAE,EAAE,CAAC;AAE/B,MAAM,MAAM,SAAS,GAAG,YAAY,GAAG,cAAc,GAAG,eAAe,GAAG,sBAAsB,CAAC;AAEjG,MAAM,WAAW,aAAa;IAC1B,IAAI,EAAE,WAAW,CAAC;IAClB,GAAG,EAAE,MAAM,CAAC;IACZ,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,EAAE,SAAS,CAAC;CACxB;AAED,MAAM,WAAW,eAAe;IAC5B,IAAI,EAAE,aAAa,CAAC;IACpB,YAAY,EAAE,KAAK,CAAC;QAAE,GAAG,EAAE,MAAM,CAAC;QAAC,GAAG,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IACjE,SAAS,EAAE,SAAS,CAAC;CACxB;AAED,MAAM,MAAM,IAAI,GAAG,aAAa,GAAG,eAAe,CAAC;AAEnD,MAAM,MAAM,eAAe,GAAG,MAAM,GAAG,QAAQ,GAAG,MAAM,GAAG,YAAY,GAAG,YAAY,CAAC;AAIvF,MAAM,CAAC,OAAO,OAAO,YAAY;IAC7B,MAAM,CAAC,QAAQ,CAAC,UAAU,EAAE,SAAS,EAAE,CAA2E;IAElH,OAAO,CAAC,KAAK,CAAQ;IACrB,OAAO,CAAC,aAAa,CAAe;gBAExB,KAAK,EAAE,MAAM,GAAG,KAAK;IAOjC,QAAQ,CAAC,KAAK,EAAE,KAAK,GAAG,IAAI;IAS5B,OAAO,IAAI,KAAK;IAIhB,YAAY,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,EAAE;IAIhD,cAAc,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI;IAmB7D,gBAAgB,CAAC,IAAI,EAAE,eAAe,GAAG,IAAI;IAM7C,UAAU,IAAI,OAAO;IAIrB,eAAe,IAAI,MAAM;IAIzB,QAAQ,IAAI,gBAAgB;IAiG5B,OAAO,IAAI,OAAO;IAKlB,UAAU,IAAI,eAAe;IAiB7B,WAAW,IAAI,IAAI,GAAG,IAAI;IAO1B,KAAK,IAAI,OAAO;IAkBhB,OAAO,CAAC,QAAQ;IAIhB,OAAO,CAAC,WAAW;IAOnB,OAAO,CAAC,MAAM;IAId,OAAO,CAAC,SAAS;IAIjB,OAAO,CAAC,MAAM;IAYd,OAAO,CAAC,aAAa;IAIrB,OAAO,CAAC,mBAAmB;IAU3B,OAAO,CAAC,aAAa;IAQrB,OAAO,CAAC,YAAY;IAQpB,OAAO,CAAC,iBAAiB;IAiBzB,OAAO,CAAC,eAAe;IA+BvB,OAAO,CAAC,qBAAqB;IAe7B,OAAO,CAAC,qBAAqB;IAe7B,OAAO,CAAC,qBAAqB;IAgB7B,OAAO,CAAC,sBAAsB;IAgD9B,OAAO,CAAC,gBAAgB;CAe3B"}

package/dist/sudokuSolver.js

@@ -0,0 +1,389 @@
+import { cloneBoard, assertBoardShape, parseBoardString, duplicateValues } from "./utils";
+import { pushUniqueReason } from "./validate";
+const COMPLETE = [1, 2, 3, 4, 5, 6, 7, 8, 9];
+export default class SudokuSolver {
+    static ALGORITHMS = ["Full House", "Naked Single", "Hidden Single", "Pointing Pair/Triple"];
+    board;
+    possiblesGrid;
+    constructor(input) {
+        this.board = [];
+        this.possiblesGrid = [];
+        let inputBoard = typeof input === "string" ? parseBoardString(input) : cloneBoard(input);
+        this.setBoard(inputBoard);
+    }
+    setBoard(board) {
+        this.board = cloneBoard(board);
+        assertBoardShape(this.board);
+        this.possiblesGrid = Array.from({ length: 9 }, () => Array.from({ length: 9 }, () => []));
+        this.calcPossibles();
+    }
+    toArray() {
+        return cloneBoard(this.board);
+    }
+    getPossibles(row, col) {
+        return [...this.possiblesGrid[row][col]];
+    }
+    setSquareValue(row, col, value) {
+        this.board[row][col] = value;
+        this.possiblesGrid[row][col] = [];
+        const ibox = this.boxIndex(row, col);
+        const startRow = Math.floor(ibox / 3) * 3;
+        const startCol = (ibox % 3) * 3;
+        for (let c = 0; c < 9; c++) {
+            this.possiblesGrid[row][c] = this.possiblesGrid[row][c].filter((v) => v !== value);
+        }
+        for (let r = 0; r < 9; r++) {
+            this.possiblesGrid[r][col] = this.possiblesGrid[r][col].filter((v) => v !== value);
+        }
+        for (let r = startRow; r < startRow + 3; r++) {
+            for (let c = startCol; c < startCol + 3; c++) {
+                this.possiblesGrid[r][c] = this.possiblesGrid[r][c].filter((v) => v !== value);
+            }
+        }
+    }
+    applyElimination(move) {
+        for (const { row, col, value } of move.eliminations) {
+            this.possiblesGrid[row][col] = this.possiblesGrid[row][col].filter((v) => v !== value);
+        }
+    }
+    isComplete() {
+        return this.board.every((row) => row.every((v) => v !== 0));
+    }
+    countEmptyCells() {
+        return this.board.flat().filter((v) => v === 0).length;
+    }
+    validate() {
+        const reasons = [];
+        if (this.board.length !== 9 || this.board.some((row) => row.length !== 9)) {
+            reasons.push({
+                type: "invalid_board_length",
+                detail: "Board must be a 9x9 matrix",
+            });
+            return { isValid: false, message: reasons[0].detail, reasons };
+        }
+        if (this.countEmptyCells() > 64) {
+            reasons.push({
+                type: "too_many_empty_cells",
+                detail: "Board has too many empty cells, normal Sudoku must have at least 17 given values",
+            });
+        }
+        for (let row = 0; row < 9; row++) {
+            for (let col = 0; col < 9; col++) {
+                const value = this.board[row][col];
+                if (!Number.isInteger(value) || value < 0 || value > 9) {
+                    pushUniqueReason(reasons, {
+                        type: "invalid_value",
+                        detail: `Invalid value ${value} at row ${row}, col ${col}`,
+                        row,
+                        col,
+                        value,
+                    });
+                }
+            }
+        }
+        for (let row = 0; row < 9; row++) {
+            for (const value of duplicateValues(this.board[row])) {
+                pushUniqueReason(reasons, {
+                    type: "duplicate_in_row",
+                    detail: `Duplicate value ${value} in row ${row}`,
+                    row,
+                    value,
+                });
+            }
+        }
+        for (let col = 0; col < 9; col++) {
+            const colVals = this.board.map((row) => row[col]);
+            for (const value of duplicateValues(colVals)) {
+                pushUniqueReason(reasons, {
+                    type: "duplicate_in_column",
+                    detail: `Duplicate value ${value} in column ${col}`,
+                    col,
+                    value,
+                });
+            }
+        }
+        for (let box = 0; box < 9; box++) {
+            const startRow = Math.floor(box / 3) * 3;
+            const startCol = (box % 3) * 3;
+            const values = [];
+            for (let row = startRow; row < startRow + 3; row++) {
+                for (let col = startCol; col < startCol + 3; col++) {
+                    values.push(this.board[row][col]);
+                }
+            }
+            for (const value of duplicateValues(values)) {
+                pushUniqueReason(reasons, {
+                    type: "duplicate_in_box",
+                    detail: `Duplicate value ${value} in box ${box}`,
+                    box,
+                    value,
+                });
+            }
+        }
+        if (reasons.length === 0) {
+            for (let row = 0; row < 9; row++) {
+                for (let col = 0; col < 9; col++) {
+                    if (this.board[row][col] === 0 && this.possiblesGrid[row][col].length === 0) {
+                        pushUniqueReason(reasons, {
+                            type: "empty_cell_no_candidates",
+                            detail: `Empty cell at row ${row}, col ${col} has no valid candidates`,
+                            row,
+                            col,
+                        });
+                    }
+                }
+            }
+        }
+        return {
+            isValid: reasons.length === 0,
+            message: reasons[0]?.detail ?? "Valid",
+            reasons,
+        };
+    }
+    isValid() {
+        const result = this.validate();
+        return result.isValid;
+    }
+    difficulty() {
+        const emptyCells = this.countEmptyCells();
+        if (emptyCells <= 17) {
+            return "Easy";
+        }
+        if (emptyCells <= 30) {
+            return "Medium";
+        }
+        if (emptyCells <= 40) {
+            return "Hard";
+        }
+        if (emptyCells <= 55) {
+            return "Diabolical";
+        }
+        return "Impossible";
+    }
+    getNextMove() {
+        if (this.isComplete() || !this.isValid()) {
+            return null;
+        }
+        return this.findBestMove();
+    }
+    solve() {
+        if (!this.isValid()) {
+            return false;
+        }
+        let move = this.findBestMove();
+        while (move) {
+            if (move.type === "placement") {
+                this.setSquareValue(move.row, move.col, move.value);
+            }
+            else {
+                this.applyElimination(move);
+            }
+            move = this.findBestMove();
+        }
+        return this.isComplete();
+    }
+    boxIndex(row, col) {
+        return Math.floor(row / 3) * 3 + Math.floor(col / 3);
+    }
+    boxToPuzzle(ibox, idx) {
+        return {
+            row: Math.floor(ibox / 3) * 3 + Math.floor(idx / 3),
+            col: (ibox % 3) * 3 + (idx % 3),
+        };
+    }
+    getRow(row) {
+        return [...this.board[row]];
+    }
+    getColumn(col) {
+        return this.board.map((row) => row[col]);
+    }
+    getBox(ibox) {
+        const startRow = Math.floor(ibox / 3) * 3;
+        const startCol = (ibox % 3) * 3;
+        const out = [];
+        for (let r = startRow; r < startRow + 3; r++) {
+            for (let c = startCol; c < startCol + 3; c++) {
+                out.push(this.board[r][c]);
+            }
+        }
+        return out;
+    }
+    valuesMissing(values) {
+        return COMPLETE.filter((n) => !values.includes(n));
+    }
+    calcSquarePossibles(row, col) {
+        if (this.board[row][col] > 0) {
+            return [];
+        }
+        const rowPossible = this.valuesMissing(this.getRow(row));
+        const colPossible = this.valuesMissing(this.getColumn(col));
+        const boxPossible = this.valuesMissing(this.getBox(this.boxIndex(row, col)));
+        return rowPossible.filter((n) => colPossible.includes(n) && boxPossible.includes(n));
+    }
+    calcPossibles() {
+        for (let r = 0; r < 9; r++) {
+            for (let c = 0; c < 9; c++) {
+                this.possiblesGrid[r][c] = this.calcSquarePossibles(r, c);
+            }
+        }
+    }
+    findBestMove() {
+        for (const algorithm of SudokuSolver.ALGORITHMS) {
+            const move = this.findNextPlacement(algorithm);
+            if (move)
+                return move;
+        }
+        return null;
+    }
+    findNextPlacement(algorithm) {
+        switch (algorithm) {
+            case "Full House":
+            case "Naked Single": {
+                const move = this.findNakedSingle();
+                if (algorithm === "Full House") {
+                    return move?.algorithm === "Full House" ? move : null;
+                }
+                return move;
+            }
+            case "Hidden Single":
+                return this.findHiddenSingle();
+            case "Pointing Pair/Triple":
+                return this.findPointingPairTriple();
+        }
+    }
+    findNakedSingle() {
+        for (let row = 0; row < 9; row++) {
+            for (let col = 0; col < 9; col++) {
+                if (this.board[row][col] === 0) {
+                    const p = this.possiblesGrid[row][col];
+                    if (p.length === 1) {
+                        const placeValue = p[0];
+                        let algo = "Naked Single";
+                        // check if full house
+                        const rowValues = this.getRow(row);
+                        if (rowValues.filter((v) => v === 0).length === 1) {
+                            algo = "Full House";
+                        }
+                        const colValues = this.getColumn(col);
+                        if (colValues.filter((v) => v === 0).length === 1) {
+                            algo = "Full House";
+                        }
+                        const boxValues = this.getBox(this.boxIndex(row, col));
+                        if (boxValues.filter((v) => v === 0).length === 1) {
+                            algo = "Full House";
+                        }
+                        return { type: "placement", row, col, value: placeValue, algorithm: algo };
+                    }
+                }
+            }
+        }
+        return null;
+    }
+    findHiddenSingleInRow(row) {
+        for (let value = 1; value <= 9; value++) {
+            const candidates = [];
+            for (let col = 0; col < 9; col++) {
+                if (this.board[row][col] === 0 && this.possiblesGrid[row][col].includes(value)) {
+                    candidates.push(col);
+                }
+            }
+            if (candidates.length === 1) {
+                return { type: "placement", row, col: candidates[0], value, algorithm: "Hidden Single" };
+            }
+        }
+        return null;
+    }
+    findHiddenSingleInCol(col) {
+        for (let value = 1; value <= 9; value++) {
+            const candidates = [];
+            for (let row = 0; row < 9; row++) {
+                if (this.board[row][col] === 0 && this.possiblesGrid[row][col].includes(value)) {
+                    candidates.push(row);
+                }
+            }
+            if (candidates.length === 1) {
+                return { type: "placement", row: candidates[0], col, value, algorithm: "Hidden Single" };
+            }
+        }
+        return null;
+    }
+    findHiddenSingleInBox(ibox) {
+        for (let value = 1; value <= 9; value++) {
+            const candidates = [];
+            for (let idx = 0; idx < 9; idx++) {
+                const { row, col } = this.boxToPuzzle(ibox, idx);
+                if (this.board[row][col] === 0 && this.possiblesGrid[row][col].includes(value)) {
+                    candidates.push({ row, col });
+                }
+            }
+            if (candidates.length === 1) {
+                return { type: "placement", row: candidates[0].row, col: candidates[0].col, value, algorithm: "Hidden Single" };
+            }
+        }
+        return null;
+    }
+    findPointingPairTriple() {
+        for (let ibox = 0; ibox < 9; ibox++) {
+            const boxStartRow = Math.floor(ibox / 3) * 3;
+            const boxStartCol = (ibox % 3) * 3;
+            for (let digit = 1; digit <= 9; digit++) {
+                const cells = [];
+                for (let idx = 0; idx < 9; idx++) {
+                    const { row, col } = this.boxToPuzzle(ibox, idx);
+                    if (this.board[row][col] === 0 && this.possiblesGrid[row][col].includes(digit)) {
+                        cells.push({ row, col });
+                    }
+                }
+                if (cells.length < 2)
+                    continue;
+                if (cells.every((c) => c.row === cells[0].row)) {
+                    const sharedRow = cells[0].row;
+                    const eliminations = [];
+                    for (let c = 0; c < 9; c++) {
+                        if (c < boxStartCol || c >= boxStartCol + 3) {
+                            if (this.board[sharedRow][c] === 0 && this.possiblesGrid[sharedRow][c].includes(digit)) {
+                                eliminations.push({ row: sharedRow, col: c, value: digit });
+                            }
+                        }
+                    }
+                    if (eliminations.length > 0) {
+                        return { type: "elimination", eliminations, algorithm: "Pointing Pair/Triple" };
+                    }
+                }
+                if (cells.every((c) => c.col === cells[0].col)) {
+                    const sharedCol = cells[0].col;
+                    const eliminations = [];
+                    for (let r = 0; r < 9; r++) {
+                        if (r < boxStartRow || r >= boxStartRow + 3) {
+                            if (this.board[r][sharedCol] === 0 && this.possiblesGrid[r][sharedCol].includes(digit)) {
+                                eliminations.push({ row: r, col: sharedCol, value: digit });
+                            }
+                        }
+                    }
+                    if (eliminations.length > 0) {
+                        return { type: "elimination", eliminations, algorithm: "Pointing Pair/Triple" };
+                    }
+                }
+            }
+        }
+        return null;
+    }
+    findHiddenSingle() {
+        for (let row = 0; row < 9; row++) {
+            const move = this.findHiddenSingleInRow(row);
+            if (move)
+                return move;
+        }
+        for (let col = 0; col < 9; col++) {
+            const move = this.findHiddenSingleInCol(col);
+            if (move)
+                return move;
+        }
+        for (let box = 0; box < 9; box++) {
+            const move = this.findHiddenSingleInBox(box);
+            if (move)
+                return move;
+        }
+        return null;
+    }
+}

package/dist/utils.d.ts

@@ -0,0 +1,8 @@
+import { type Board } from "./sudokuSolver";
+export declare function cloneBoard(board: Board): Board;
+export declare function assertBoardShape(board: Board): void;
+export declare function assertBoardValues(board: Board): void;
+export declare function parseBoardString(board: string): Board;
+export declare function duplicateValues(values: number[]): number[];
+export declare function rowLetter(row: number): string;
+//# sourceMappingURL=utils.d.ts.map

package/dist/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../src/utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,KAAK,EAAE,MAAM,gBAAgB,CAAC;AAE5C,wBAAgB,UAAU,CAAC,KAAK,EAAE,KAAK,GAAG,KAAK,CAE9C;AAED,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,KAAK,GAAG,IAAI,CAInD;AAED,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,KAAK,GAAG,IAAI,CASpD;AAED,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,MAAM,GAAG,KAAK,CAmBrD;AAED,wBAAgB,eAAe,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,MAAM,EAAE,CAS1D;AAID,wBAAgB,SAAS,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAE7C"}

package/dist/utils.js

@@ -0,0 +1,53 @@
+export function cloneBoard(board) {
+    return board.map((row) => [...row]);
+}
+export function assertBoardShape(board) {
+    if (board.length !== 9 || board.some((row) => row.length !== 9)) {
+        throw new Error("Board must be a 9x9 matrix");
+    }
+}
+export function assertBoardValues(board) {
+    for (let row = 0; row < 9; row += 1) {
+        for (let col = 0; col < 9; col += 1) {
+            const value = board[row][col];
+            if (!Number.isInteger(value) || value < 0 || value > 9) {
+                throw new Error(`Invalid value ${value} at row ${row}, col ${col}`);
+            }
+        }
+    }
+}
+export function parseBoardString(board) {
+    if (board.length !== 81) {
+        throw new Error(`Board must be 81 characters, got ${board.length}`);
+    }
+    const rows = Array.from({ length: 9 }, () => Array(9).fill(0));
+    for (let i = 0; i < 81; i += 1) {
+        const ch = board[i];
+        const row = Math.floor(i / 9);
+        const col = i % 9;
+        if (ch >= "1" && ch <= "9") {
+            rows[row][col] = Number(ch);
+        }
+        else if (ch === "0" || ch === ".") {
+            rows[row][col] = 0;
+        }
+        else {
+            throw new Error(`Invalid character '${ch}' at position ${i}`);
+        }
+    }
+    return rows;
+}
+export function duplicateValues(values) {
+    const counts = new Map();
+    for (const value of values) {
+        if (value === 0) {
+            continue;
+        }
+        counts.set(value, (counts.get(value) ?? 0) + 1);
+    }
+    return [...counts.entries()].filter(([, count]) => count > 1).map(([value]) => value);
+}
+const LABELS = 'ABCDEFGHJ';
+export function rowLetter(row) {
+    return LABELS[row];
+}

package/dist/validate.d.ts

@@ -0,0 +1,18 @@
+export type ValidationReasonType = "duplicate_in_row" | "duplicate_in_column" | "duplicate_in_box" | "invalid_value" | "invalid_board_length" | "invalid_board_characters" | "empty_cell_no_candidates" | "too_many_empty_cells";
+export interface ValidationReason {
+    type: ValidationReasonType;
+    detail: string;
+    row?: number;
+    col?: number;
+    box?: number;
+    value?: number;
+}
+export interface ValidationResult {
+    isValid: boolean;
+    message: string;
+    reasons: ValidationReason[];
+}
+export declare function pushUniqueReason(reasons: ValidationReason[], reason: ValidationReason): void;
+export declare function invalidBoardLength(length: number): ValidationResult;
+export declare function invalidBoardCharacters(): ValidationResult;
+//# sourceMappingURL=validate.d.ts.map

package/dist/validate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validate.d.ts","sourceRoot":"","sources":["../src/validate.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,oBAAoB,GAC1B,kBAAkB,GAClB,qBAAqB,GACrB,kBAAkB,GAClB,eAAe,GACf,sBAAsB,GACtB,0BAA0B,GAC1B,0BAA0B,GAC1B,sBAAsB,CAAC;AAE7B,MAAM,WAAW,gBAAgB;IAC7B,IAAI,EAAE,oBAAoB,CAAC;IAC3B,MAAM,EAAE,MAAM,CAAC;IACf,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,KAAK,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,gBAAgB;IAC7B,OAAO,EAAE,OAAO,CAAC;IACjB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,gBAAgB,EAAE,CAAC;CAC/B;AAED,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,gBAAgB,EAAE,EAAE,MAAM,EAAE,gBAAgB,GAAG,IAAI,CAY5F;AAED,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,MAAM,GAAG,gBAAgB,CAWnE;AAED,wBAAgB,sBAAsB,IAAI,gBAAgB,CAWzD"}

package/dist/validate.js

@@ -0,0 +1,34 @@
+export function pushUniqueReason(reasons, reason) {
+    const found = reasons.some((r) => r.type === reason.type &&
+        r.row === reason.row &&
+        r.col === reason.col &&
+        r.box === reason.box &&
+        r.value === reason.value);
+    if (!found) {
+        reasons.push(reason);
+    }
+}
+export function invalidBoardLength(length) {
+    return {
+        isValid: false,
+        message: "Board must be 81 characters",
+        reasons: [
+            {
+                type: "invalid_board_length",
+                detail: `Board must be 81 characters, got ${length}`,
+            },
+        ],
+    };
+}
+export function invalidBoardCharacters() {
+    return {
+        isValid: false,
+        message: "Board contains invalid characters",
+        reasons: [
+            {
+                type: "invalid_board_characters",
+                detail: "Only digits 0-9 and '.' are allowed",
+            },
+        ],
+    };
+}

package/package.json

@@ -0,0 +1,41 @@
+{
+    "name": "@wsabol/sudoku-solver",
+    "version": "0.1.0",
+    "description": "TypeScript Sudoku solver module with solve, next move, describe, and validate APIs.",
+    "main": "./dist/index.js",
+    "types": "./dist/index.d.ts",
+    "exports": {
+        ".": {
+            "types": "./dist/index.d.ts",
+            "import": "./dist/index.js"
+        }
+    },
+    "files": [
+        "dist"
+    ],
+    "scripts": {
+        "build": "tsc -p tsconfig.build.json",
+        "prepublishOnly": "npm run build",
+        "test": "vitest run",
+        "test:coverage": "vitest run --coverage",
+        "test:watch": "vitest",
+        "typecheck": "tsc --noEmit"
+    },
+    "keywords": [
+        "sudoku",
+        "solver",
+        "puzzle",
+        "sudoku engine",
+        "sudoku solver"
+    ],
+    "author": "Will Sabol",
+    "license": "MIT",
+    "type": "module",
+    "devDependencies": {
+        "@types/node": "^25.5.0",
+        "@vitest/coverage-v8": "^4.1.0",
+        "tsx": "^4.21.0",
+        "typescript": "^5.9.3",
+        "vitest": "^4.1.0"
+    }
+}