human-sudoku-solver 0.1.1 → 1.0.1

package/dist/index.cjs

@@ -0,0 +1,2313 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#region src/humanSolverNotation.ts
+const cellRow$1 = (cell) => Math.floor(cell / 9);
+const cellCol$1 = (cell) => cell % 9;
+const cellBox$1 = (cell) => Math.floor(cellRow$1(cell) / 3) * 3 + Math.floor(cellCol$1(cell) / 3);
+const eurekaCell = (cell) => `r${cellRow$1(cell) + 1}c${cellCol$1(cell) + 1}`;
+const conclusionStr = (hint) => {
+	const parts = [];
+	for (const { cell, digit } of hint.placements) parts.push(`${eurekaCell(cell)}=${digit}`);
+	for (const { cell, digit } of hint.eliminations) parts.push(`${eurekaCell(cell)}<>${digit}`);
+	return parts.join(", ");
+};
+const renderChainPath = (path) => {
+	if (path.length === 0) return "";
+	const parts = [];
+	for (let i = 0; i < path.length; i++) {
+		const node = path[i];
+		const next = path[i + 1];
+		const cells = node.cells ?? [node.cell];
+		let nodeStr;
+		if (cells.length === 1) nodeStr = `(${node.digit})${eurekaCell(cells[0])}`;
+		else {
+			const rows = [...new Set(cells.map(cellRow$1))];
+			const cols = [...new Set(cells.map(cellCol$1))];
+			if (rows.length === 1) {
+				const colStr = cols.map((c) => c + 1).join("");
+				nodeStr = `(${node.digit})r${rows[0] + 1}c[${colStr}]`;
+			} else if (cols.length === 1) {
+				const rowStr = rows.map((r) => r + 1).join("");
+				nodeStr = `(${node.digit})r[${rowStr}]c${cols[0] + 1}`;
+			} else nodeStr = `(${node.digit})${cells.map(eurekaCell).join("|")}`;
+		}
+		parts.push(nodeStr);
+		if (next !== void 0) {
+			const link = node.linkToNext ?? (node.isOn ? "weak" : "strong");
+			parts.push(link === "strong" ? "=" : "-");
+		}
+	}
+	return parts.join("");
+};
+const buildEureka = (hint) => {
+	const conc = conclusionStr(hint);
+	if ([
+		"uniqueRectangleType5",
+		"nishio",
+		"nishioNet",
+		"cellRegionForcingChain",
+		"cellRegionForcingNet",
+		"forcingChain"
+	].includes(hint.technique)) return "";
+	switch (hint.technique) {
+		case "nakedSingle": {
+			const { cell, digit } = hint.placements[0];
+			return `(${digit})${eurekaCell(cell)} => ${eurekaCell(cell)}=${digit}`;
+		}
+		case "hiddenSingleBox":
+		case "hiddenSingleRow":
+		case "hiddenSingleCol": {
+			const { cell, digit } = hint.placements[0];
+			return `(${digit})${eurekaCell(cell)} => ${eurekaCell(cell)}=${digit}`;
+		}
+		case "lockedCandidatePointing": {
+			const digit = hint.eliminations[0]?.digit ?? 0;
+			const cells = hint.patternCells;
+			return `(${digit})${`box${cellBox$1(cells[0]) + 1}`} => ${conc}`;
+		}
+		case "lockedCandidateClaiming": {
+			const digit = hint.eliminations[0]?.digit ?? 0;
+			const cells = hint.patternCells;
+			const rows = [...new Set(cells.map(cellRow$1))];
+			const cols = [...new Set(cells.map(cellCol$1))];
+			let lineStr;
+			if (rows.length === 1) lineStr = `r${rows[0] + 1}`;
+			else lineStr = `c${cols[0] + 1}`;
+			return `(${digit})${lineStr} => ${conc}`;
+		}
+		case "nakedPair":
+		case "nakedTriple":
+		case "nakedQuad": {
+			const digits = [...new Set(hint.eliminations.map((e) => e.digit))].sort();
+			const cellsStr = hint.patternCells.map(eurekaCell).join(",");
+			return `(${digits.join(",")})${cellsStr} => ${conc}`;
+		}
+		case "hiddenPair":
+		case "hiddenTriple":
+		case "hiddenQuad": {
+			const digits = hint.hiddenDigits ?? [];
+			const cellsStr = hint.patternCells.map(eurekaCell).join(",");
+			return `(${digits.join(",")})${cellsStr} => ${conc}`;
+		}
+		case "xWing":
+		case "swordfish":
+		case "jellyfish": {
+			const digit = hint.eliminations[0]?.digit ?? 0;
+			const cells = hint.patternCells;
+			const rows = [...new Set(cells.map(cellRow$1))].sort((a, b) => a - b);
+			const cols = [...new Set(cells.map(cellCol$1))].sort((a, b) => a - b);
+			if (rows.length <= cols.length) {
+				const rowStr = rows.map((r) => r + 1).join("");
+				return `${cols.map((c) => `(${digit})r[${rowStr}]c${c + 1}`).join("-")} => ${conc}`;
+			} else {
+				const colStr = cols.map((c) => c + 1).join("");
+				return `${rows.map((r) => `(${digit})r${r + 1}c[${colStr}]`).join("-")} => ${conc}`;
+			}
+		}
+		case "finnedXWing":
+		case "finnedSwordfish":
+		case "finnedJellyfish": {
+			const digit = hint.eliminations[0]?.digit ?? 0;
+			return `${hint.patternCells.map((c) => `(${digit})${eurekaCell(c)}`).join("|")} => ${conc}`;
+		}
+		case "skyscraper": {
+			const digit = hint.eliminations[0]?.digit ?? 0;
+			const [c0, c1, c2, c3] = hint.patternCells;
+			return `${`(${digit})${eurekaCell(c0)}=(${digit})${eurekaCell(c1)}-(${digit})${eurekaCell(c2)}=(${digit})${eurekaCell(c3)}`} => ${conc}`;
+		}
+		case "twoStringKite": {
+			const digit = hint.eliminations[0]?.digit ?? 0;
+			const [colCell, rowCell, colRoof, rowRoof] = hint.patternCells;
+			return `${`(${digit})${eurekaCell(colCell)}=(${digit})${eurekaCell(rowCell)}-(${digit})${eurekaCell(colRoof)}=(${digit})${eurekaCell(rowRoof)}`} => ${conc}`;
+		}
+		case "emptyRectangle": {
+			const digit = hint.eliminations[0]?.digit ?? 0;
+			const pivot = hint.patternCells[hint.patternCells.length - 2];
+			const strongEnd = hint.patternCells[hint.patternCells.length - 1];
+			return `(${digit})box${cellBox$1(hint.patternCells.slice(0, hint.patternCells.length - 2)[0]) + 1}-(${digit})${eurekaCell(pivot)}=(${digit})${eurekaCell(strongEnd)} => ${conc}`;
+		}
+		case "wWing": {
+			const [c1, c2, lc1, lc2] = hint.patternCells;
+			const elimDigit = hint.eliminations[0]?.digit ?? 0;
+			const linkDigit = hint.patternDigits?.[0] ?? elimDigit;
+			return `${`(${elimDigit})${eurekaCell(c1)}-(${linkDigit})${eurekaCell(lc1)}=(${linkDigit})${eurekaCell(lc2)}-(${elimDigit})${eurekaCell(c2)}`} => ${conc}`;
+		}
+		case "yWing": {
+			const [pivot, p1, p2] = hint.patternCells;
+			const elimDigit = hint.eliminations[0]?.digit ?? 0;
+			if (hint.chainPath && hint.chainPath.length >= 3) return `${renderChainPath(hint.chainPath)} => ${conc}`;
+			return `(?)${eurekaCell(pivot)}-(?)${eurekaCell(p1)}-(?)${eurekaCell(p2)} => ${eurekaCell(hint.eliminations[0]?.cell ?? 0)}<>${elimDigit}`;
+		}
+		case "xyzWing": {
+			const [pivot, p1, p2] = hint.patternCells;
+			const elimDigit = hint.eliminations[0]?.digit ?? 0;
+			if (hint.chainPath && hint.chainPath.length >= 3) return `${renderChainPath(hint.chainPath)} => ${conc}`;
+			return `(?)${eurekaCell(pivot)}-(?)${eurekaCell(p1)}-(?)${eurekaCell(p2)} => ${eurekaCell(hint.eliminations[0]?.cell ?? 0)}<>${elimDigit}`;
+		}
+		case "xyChain": {
+			if (hint.chainPath && hint.chainPath.length >= 2) return `${renderChainPath(hint.chainPath)} => ${conc}`;
+			const digit = hint.eliminations[0]?.digit ?? 0;
+			return `${hint.patternCells.map((c) => `(?)${eurekaCell(c)}`).join("-")} => ${eurekaCell(hint.eliminations[0]?.cell ?? 0)}<>${digit}`;
+		}
+		case "aic":
+		case "aicRing":
+		case "groupedAIC": {
+			if (hint.chainPath && hint.chainPath.length >= 2) {
+				const chainStr = renderChainPath(hint.chainPath);
+				if (hint.technique === "aicRing") {
+					const firstNode = hint.chainPath[0];
+					const lastNode = hint.chainPath[hint.chainPath.length - 1];
+					const lastLink = lastNode.linkToNext === "strong" ? "=" : lastNode.linkToNext === "weak" ? "-" : lastNode.isOn ? "-" : "=";
+					const firstCells = firstNode.cells ?? [firstNode.cell];
+					let firstNodeStr;
+					if (firstCells.length === 1) firstNodeStr = `(${firstNode.digit})${eurekaCell(firstCells[0])}`;
+					else firstNodeStr = `(${firstNode.digit})${firstCells.map(eurekaCell).join("|")}`;
+					return `${chainStr}${lastLink}${firstNodeStr} => ${conc}`;
+				}
+				return `${chainStr} => ${conc}`;
+			}
+			const digit = hint.eliminations[0]?.digit ?? 0;
+			return `${hint.patternCells.map((c) => `(${digit})${eurekaCell(c)}`).join("-")} => ${conc}`;
+		}
+		case "uniqueRectangleType1":
+		case "uniqueRectangleType2":
+		case "uniqueRectangleType3":
+		case "uniqueRectangleType4": {
+			const rows = [...new Set(hint.patternCells.map(cellRow$1))].sort().map((r) => r + 1).join("");
+			const cols = [...new Set(hint.patternCells.map(cellCol$1))].sort().map((c) => c + 1).join("");
+			return `UR(${(hint.patternDigits ?? []).join(",")})r${rows}c${cols} => ${conc}`;
+		}
+		case "bug": {
+			const { cell, digit } = hint.placements[0];
+			return `BUG+1 => ${eurekaCell(cell)}=${digit}`;
+		}
+		case "alsXZ": {
+			const digit = hint.eliminations[0]?.digit ?? 0;
+			const elimCells = hint.eliminations.map((e) => eurekaCell(e.cell)).join(",");
+			return `A(${hint.als1Cells ? hint.als1Cells.map(eurekaCell).join(",") : ""}) - B(${hint.als2Cells ? hint.als2Cells.map(eurekaCell).join(",") : ""}) => ${elimCells}<>${digit}`;
+		}
+		case "sueDeCoq": return `SDC(${hint.patternCells.map(eurekaCell).join(",")}) => ${conc}`;
+		case "deathBlossom": return `DB: stem=${hint.stemCell !== void 0 ? eurekaCell(hint.stemCell) : ""} | ${hint.petalCells ? hint.petalCells.map((cells, i) => `Petal${String.fromCharCode(65 + i)}(${cells.map(eurekaCell).join(",")})`).join(" | ") : ""} => ${conc}`;
+		default: return "";
+	}
+};
+const buildExplanation = (hint) => {
+	switch (hint.technique) {
+		case "nakedSingle": {
+			const { cell, digit } = hint.placements[0];
+			return `${digit} is the only remaining candidate in the cell ${eurekaCell(cell)}. This is a Naked Single.`;
+		}
+		case "hiddenSingleBox": {
+			const { cell, digit } = hint.placements[0];
+			const box = cellBox$1(cell);
+			return `${digit} can only go in ${eurekaCell(cell)} within box ${box + 1}. This is a Hidden Single.`;
+		}
+		case "hiddenSingleRow": {
+			const { cell, digit } = hint.placements[0];
+			const row = cellRow$1(cell);
+			return `${digit} can only go in ${eurekaCell(cell)} within row ${row + 1}. This is a Hidden Single.`;
+		}
+		case "hiddenSingleCol": {
+			const { cell, digit } = hint.placements[0];
+			const col = cellCol$1(cell);
+			return `${digit} can only go in ${eurekaCell(cell)} within column ${col + 1}. This is a Hidden Single.`;
+		}
+		case "lockedCandidatePointing": {
+			const digit = hint.eliminations[0]?.digit ?? 0;
+			const cells = hint.patternCells;
+			const box = cellBox$1(cells[0]);
+			const rows = [...new Set(cells.map(cellRow$1))];
+			const cols = [...new Set(cells.map(cellCol$1))];
+			const line = rows.length === 1 ? `row ${rows[0] + 1}` : `column ${cols[0] + 1}`;
+			const elimCells = hint.eliminations.map((e) => eurekaCell(e.cell)).join(", ");
+			return `${digit} in box ${box + 1} is confined to ${line}, eliminating ${digit} from ${elimCells}. This is the Locked Candidates Pointing technique.`;
+		}
+		case "lockedCandidateClaiming": {
+			const digit = hint.eliminations[0]?.digit ?? 0;
+			const cells = hint.patternCells;
+			const rows = [...new Set(cells.map(cellRow$1))];
+			const cols = [...new Set(cells.map(cellCol$1))];
+			const line = rows.length === 1 ? `row ${rows[0] + 1}` : `column ${cols[0] + 1}`;
+			const box = cellBox$1(hint.eliminations[0]?.cell ?? 0);
+			const elimCells = hint.eliminations.map((e) => eurekaCell(e.cell)).join(", ");
+			return `${digit} in ${line} is confined to box ${box + 1}, eliminating ${digit} from ${elimCells}. This is the Locked Candidates Claiming technique.`;
+		}
+		case "nakedPair": {
+			const digits = [...new Set(hint.eliminations.map((e) => e.digit))].sort();
+			return `${hint.patternCells.map(eurekaCell).join(" and ")} share candidates {${digits.join(",")}}, eliminating those from the rest of their shared house. This is a Naked Pair.`;
+		}
+		case "nakedTriple": {
+			const digits = [...new Set(hint.eliminations.map((e) => e.digit))].sort();
+			return `${hint.patternCells.map(eurekaCell).join(", ")} share candidates {${digits.join(",")}}, eliminating those from the rest of their shared house. This is a Naked Triple.`;
+		}
+		case "nakedQuad": {
+			const digits = [...new Set(hint.eliminations.map((e) => e.digit))].sort();
+			return `${hint.patternCells.map(eurekaCell).join(", ")} share candidates {${digits.join(",")}}, eliminating those from the rest of their shared house. This is a Naked Quad.`;
+		}
+		case "hiddenPair": {
+			const digits = hint.hiddenDigits ?? [];
+			return `${hint.patternCells.map(eurekaCell).join(" and ")} are the only cells for digits {${digits.join(",")}}, so other candidates can be eliminated from those cells. This is a Hidden Pair.`;
+		}
+		case "hiddenTriple": {
+			const digits = hint.hiddenDigits ?? [];
+			return `${hint.patternCells.map(eurekaCell).join(", ")} are the only cells for digits {${digits.join(",")}}, so other candidates can be eliminated from those cells. This is a Hidden Triple.`;
+		}
+		case "hiddenQuad": {
+			const digits = hint.hiddenDigits ?? [];
+			return `${hint.patternCells.map(eurekaCell).join(", ")} are the only cells for digits {${digits.join(",")}}, so other candidates can be eliminated from those cells. This is a Hidden Quad.`;
+		}
+		case "xWing": {
+			const digit = hint.eliminations[0]?.digit ?? 0;
+			const cells = hint.patternCells;
+			const rows = [...new Set(cells.map(cellRow$1))].sort((a, b) => a - b);
+			const cols = [...new Set(cells.map(cellCol$1))].sort((a, b) => a - b);
+			if (rows.length === 2 && cols.length === 2) return `${digit} forms an X-Wing pattern, in rows ${rows.map((r) => r + 1).join(" and ")} is confined to columns ${cols.map((c) => c + 1).join(" and ")}, eliminating ${digit} from the rest of those columns.`;
+			return `${digit} forms an X-Wing pattern, eliminating ${digit} from ${hint.eliminations.map((e) => eurekaCell(e.cell)).join(", ")}.`;
+		}
+		case "swordfish": {
+			const digit = hint.eliminations[0]?.digit ?? 0;
+			return `${digit} forms a Swordfish pattern, eliminating ${digit} from ${hint.eliminations.map((e) => eurekaCell(e.cell)).join(", ")}.`;
+		}
+		case "jellyfish": {
+			const digit = hint.eliminations[0]?.digit ?? 0;
+			return `${digit} forms a Jellyfish pattern, eliminating ${digit} from ${hint.eliminations.map((e) => eurekaCell(e.cell)).join(", ")}.`;
+		}
+		case "finnedXWing": {
+			const digit = hint.eliminations[0]?.digit ?? 0;
+			return `${digit} forms a Finned X-Wing pattern. Eliminates ${digit} from ${hint.eliminations.map((e) => eurekaCell(e.cell)).join(", ")}.`;
+		}
+		case "finnedSwordfish": {
+			const digit = hint.eliminations[0]?.digit ?? 0;
+			return `${digit} forms a Finned Swordfish pattern. Eliminates ${digit} from ${hint.eliminations.map((e) => eurekaCell(e.cell)).join(", ")}.`;
+		}
+		case "finnedJellyfish": {
+			const digit = hint.eliminations[0]?.digit ?? 0;
+			return `${digit} forms a Finned Jellyfish pattern. Eliminates ${digit} from ${hint.eliminations.map((e) => eurekaCell(e.cell)).join(", ")}.`;
+		}
+		case "skyscraper": {
+			const digit = hint.eliminations[0]?.digit ?? 0;
+			const cells = hint.patternCells;
+			const rows = [...new Set(cells.map(cellRow$1))].sort((a, b) => a - b);
+			const cols = [...new Set(cells.map(cellCol$1))].sort((a, b) => a - b);
+			if (rows.length === 2) return `${digit} forms a skyscraper in rows ${rows.map((r) => r + 1).join(" and ")} with a shared column. Eliminates ${digit} from cells seeing both roof cells.`;
+			return `${digit} forms a skyscraper in columns ${cols.map((c) => c + 1).join(" and ")} with a shared row. Eliminates ${digit} from cells seeing both roof cells.`;
+		}
+		case "twoStringKite": {
+			const digit = hint.eliminations[0]?.digit ?? 0;
+			return `${digit} forms a kite with a conjugate row and column sharing a box. Eliminates ${digit} from ${hint.eliminations.map((e) => eurekaCell(e.cell)).join(", ")}.`;
+		}
+		case "emptyRectangle": {
+			const digit = hint.eliminations[0]?.digit ?? 0;
+			return `${digit} in box ${cellBox$1(hint.patternCells.slice(0, hint.patternCells.length - 2)[0]) + 1} forms an empty rectangle. Eliminates ${digit} from ${hint.eliminations.map((e) => eurekaCell(e.cell)).join(", ")}.`;
+		}
+		case "wWing": {
+			const [c1, c2] = hint.patternCells;
+			const elimDigit = hint.eliminations[0]?.digit ?? 0;
+			return `W-Wing cells ${eurekaCell(c1)} and ${eurekaCell(c2)} share candidates connected via a strong link. Eliminates ${elimDigit} from ${hint.eliminations.map((e) => eurekaCell(e.cell)).join(", ")}.`;
+		}
+		case "yWing": {
+			const [pivot, p1, p2] = hint.patternCells;
+			const elimDigit = hint.eliminations[0]?.digit ?? 0;
+			return `Y-Wing pivot ${eurekaCell(pivot)} links pincers ${eurekaCell(p1)} and ${eurekaCell(p2)}. Eliminates ${elimDigit} from cells seeing both pincers.`;
+		}
+		case "xyzWing": {
+			const [pivot, p1, p2] = hint.patternCells;
+			const elimDigit = hint.eliminations[0]?.digit ?? 0;
+			return `XYZ-Wing pivot ${eurekaCell(pivot)} with wings ${eurekaCell(p1)} and ${eurekaCell(p2)}. Eliminates ${elimDigit} from ${hint.eliminations.map((e) => eurekaCell(e.cell)).join(", ")}.`;
+		}
+		case "uniqueRectangleType1": {
+			const rows = [...new Set(hint.patternCells.map(cellRow$1))].sort().map((r) => r + 1);
+			const cols = [...new Set(hint.patternCells.map(cellCol$1))].sort().map((c) => c + 1);
+			return `The UR(${(hint.patternDigits ?? []).join(",")}) pattern in rows ${rows.join(",")} cols ${cols.join(",")} has floor digits that cannot all be the solution. Eliminates ${hint.eliminations.map((e) => `${e.digit} from ${eurekaCell(e.cell)}`).join(", ")}.`;
+		}
+		case "uniqueRectangleType2": return `The UR(${(hint.patternDigits ?? []).join(",")}) Type 2 pattern forces an extra digit. Eliminates ${hint.eliminations.map((e) => `${e.digit} from ${eurekaCell(e.cell)}`).join(", ")}.`;
+		case "uniqueRectangleType3": return `The UR(${(hint.patternDigits ?? []).join(",")}) Type 3 pattern forms a naked group. Eliminates ${hint.eliminations.map((e) => `${e.digit} from ${eurekaCell(e.cell)}`).join(", ")}.`;
+		case "uniqueRectangleType4": return `A floor digit is locked within the UR(${(hint.patternDigits ?? []).join(",")}) Type 4, eliminating the other floor digit from extra cells. Eliminates ${hint.eliminations.map((e) => `${e.digit} from ${eurekaCell(e.cell)}`).join(", ")}.`;
+		case "uniqueRectangleType5": return `Unique Rectangle Type 5: Eliminates ${hint.eliminations.map((e) => `${e.digit} from ${eurekaCell(e.cell)}`).join(", ")}.`;
+		case "bug": {
+			const { cell, digit } = hint.placements[0];
+			return `BUG+1: All unsolved cells are bivalue except ${eurekaCell(cell)}. Placing ${digit} in ${eurekaCell(cell)} resolves the BUG.`;
+		}
+		case "xyChain": return `XY-Chain: The alternating bivalue chain eliminates ${hint.eliminations.map((e) => `${e.digit} from ${eurekaCell(e.cell)}`).join(", ")}.`;
+		case "aic": return `AIC: The alternating inference chain eliminates ${hint.eliminations.map((e) => `${e.digit} from ${eurekaCell(e.cell)}`).join(", ")}.`;
+		case "aicRing": return `AIC Ring: The chain forms a closed loop. Eliminates ${hint.eliminations.map((e) => `${e.digit} from ${eurekaCell(e.cell)}`).join(", ")}.`;
+		case "groupedAIC": return `Grouped AIC: The grouped alternating inference chain eliminates ${hint.eliminations.map((e) => `${e.digit} from ${eurekaCell(e.cell)}`).join(", ")}.`;
+		case "alsXZ": return `ALS-XZ: Two Almost Locked Sets share a restricted common, eliminating ${hint.eliminations[0]?.digit ?? 0} from ${hint.eliminations.map((e) => eurekaCell(e.cell)).join(", ")}.`;
+		case "sueDeCoq": return `Sue de Coq: The two-sector disjoint subset pattern eliminates ${hint.eliminations.map((e) => `${e.digit} from ${eurekaCell(e.cell)}`).join(", ")}.`;
+		case "deathBlossom": return `Death Blossom: The stem cell's ALS petals lock digits, eliminating ${hint.eliminations.map((e) => `${e.digit} from ${eurekaCell(e.cell)}`).join(", ")}.`;
+		case "nishio": return `Nishio: Assuming ${hint.eliminations[0]?.digit} in ${eurekaCell(hint.eliminations[0]?.cell ?? 0)} leads to a contradiction.`;
+		case "nishioNet": return `Nishio Net: Assuming ${hint.eliminations[0]?.digit} in ${eurekaCell(hint.eliminations[0]?.cell ?? 0)} leads to a contradiction via full propagation.`;
+		case "cellRegionForcingChain":
+			if (hint.placements.length > 0) {
+				const { cell, digit } = hint.placements[0];
+				return `Cell/Region Forcing Chain: All branches force ${digit} into ${eurekaCell(cell)}.`;
+			}
+			return `Cell/Region Forcing Chain: Eliminates ${hint.eliminations.map((e) => `${e.digit} from ${eurekaCell(e.cell)}`).join(", ")}.`;
+		case "cellRegionForcingNet":
+			if (hint.placements.length > 0) {
+				const { cell, digit } = hint.placements[0];
+				return `Cell/Region Forcing Net: All branches force ${digit} into ${eurekaCell(cell)}.`;
+			}
+			return `Cell/Region Forcing Net: Eliminates ${hint.eliminations.map((e) => `${e.digit} from ${eurekaCell(e.cell)}`).join(", ")}.`;
+		case "forcingChain":
+			if (hint.placements.length > 0) {
+				const { cell, digit } = hint.placements[0];
+				return `Forcing Chain: Both branches from the bivalue cell force ${digit} into ${eurekaCell(cell)}.`;
+			}
+			return `Forcing Chain: Eliminates ${hint.eliminations.map((e) => `${e.digit} from ${eurekaCell(e.cell)}`).join(", ")}.`;
+		default: return "";
+	}
+};
+//#endregion
+//#region src/humanSolver.ts
+const withNotation = (hint) => {
+	if (hint === null) return null;
+	return {
+		...hint,
+		eureka: buildEureka(hint),
+		explanation: buildExplanation(hint)
+	};
+};
+const cellRow = (cell) => Math.floor(cell / 9);
+const cellCol = (cell) => cell % 9;
+const cellBox = (cell) => Math.floor(cellRow(cell) / 3) * 3 + Math.floor(cellCol(cell) / 3);
+const buildHouses = () => {
+	const houses = [];
+	for (let r = 0; r < 9; r++) {
+		const row = [];
+		for (let c = 0; c < 9; c++) row.push(r * 9 + c);
+		houses.push(row);
+	}
+	for (let c = 0; c < 9; c++) {
+		const col = [];
+		for (let r = 0; r < 9; r++) col.push(r * 9 + c);
+		houses.push(col);
+	}
+	for (let br = 0; br < 3; br++) for (let bc = 0; bc < 3; bc++) {
+		const box = [];
+		for (let r = 0; r < 3; r++) for (let c = 0; c < 3; c++) box.push((br * 3 + r) * 9 + (bc * 3 + c));
+		houses.push(box);
+	}
+	return houses;
+};
+const HOUSES = buildHouses();
+const ROW_HOUSES = HOUSES.slice(0, 9);
+const COL_HOUSES = HOUSES.slice(9, 18);
+const BOX_HOUSES = HOUSES.slice(18, 27);
+const buildPeers = () => {
+	const peers = [];
+	for (let cell = 0; cell < 81; cell++) {
+		const p = /* @__PURE__ */ new Set();
+		const r = cellRow(cell), c = cellCol(cell), b = cellBox(cell);
+		for (const c2 of [
+			...ROW_HOUSES[r],
+			...COL_HOUSES[c],
+			...BOX_HOUSES[b]
+		]) if (c2 !== cell) p.add(c2);
+		peers.push(p);
+	}
+	return peers;
+};
+const PEERS = buildPeers();
+const puzzleToGrid = (puzzle) => {
+	const grid = new Array(81).fill(0);
+	for (let row = 0; row < 9; row++) for (let col = 0; col < 9; col++) {
+		const boxX = Math.floor(col / 3);
+		const boxY = Math.floor(row / 3);
+		const cellX = col % 3;
+		const cellY = row % 3;
+		const val = puzzle[boxX][boxY][cellX][cellY];
+		grid[row * 9 + col] = typeof val === "number" ? val : 0;
+	}
+	return grid;
+};
+const gridToPuzzle = (grid) => {
+	const puzzle = {
+		0: {
+			0: {
+				0: [],
+				1: [],
+				2: []
+			},
+			1: {
+				0: [],
+				1: [],
+				2: []
+			},
+			2: {
+				0: [],
+				1: [],
+				2: []
+			}
+		},
+		1: {
+			0: {
+				0: [],
+				1: [],
+				2: []
+			},
+			1: {
+				0: [],
+				1: [],
+				2: []
+			},
+			2: {
+				0: [],
+				1: [],
+				2: []
+			}
+		},
+		2: {
+			0: {
+				0: [],
+				1: [],
+				2: []
+			},
+			1: {
+				0: [],
+				1: [],
+				2: []
+			},
+			2: {
+				0: [],
+				1: [],
+				2: []
+			}
+		}
+	};
+	for (let row = 0; row < 9; row++) for (let col = 0; col < 9; col++) {
+		const boxX = Math.floor(col / 3);
+		const boxY = Math.floor(row / 3);
+		const cellX = col % 3;
+		const cellY = row % 3;
+		if (!puzzle[boxX][boxY][cellX]) puzzle[boxX][boxY][cellX] = [];
+		puzzle[boxX][boxY][cellX][cellY] = grid[row * 9 + col];
+	}
+	return puzzle;
+};
+const buildCandidates = (grid) => {
+	const candidates = [];
+	for (let cell = 0; cell < 81; cell++) {
+		if (grid[cell] !== 0) {
+			candidates.push(/* @__PURE__ */ new Set());
+			continue;
+		}
+		const possible = new Set([
+			1,
+			2,
+			3,
+			4,
+			5,
+			6,
+			7,
+			8,
+			9
+		]);
+		for (const peer of PEERS[cell]) if (grid[peer] !== 0) possible.delete(grid[peer]);
+		candidates.push(possible);
+	}
+	return candidates;
+};
+const isGridInvalid = (grid) => {
+	for (let cell = 0; cell < 81; cell++) {
+		const val = grid[cell];
+		if (val === 0) continue;
+		for (const peer of PEERS[cell]) if (grid[peer] === val) return true;
+	}
+	return false;
+};
+const combinations = (arr, size) => {
+	if (size === 0) return [[]];
+	if (arr.length < size) return [];
+	const [first, ...rest] = arr;
+	return [...combinations(rest, size - 1).map((c) => [first, ...c]), ...combinations(rest, size)];
+};
+const findNakedSingle = (candidates) => {
+	for (let cell = 0; cell < 81; cell++) if (candidates[cell].size === 1) {
+		const digit = [...candidates[cell]][0];
+		return {
+			technique: "nakedSingle",
+			placements: [{
+				cell,
+				digit
+			}],
+			eliminations: [],
+			patternCells: [cell]
+		};
+	}
+	return null;
+};
+const findHiddenSingle = (candidates, houses, technique) => {
+	for (const house of houses) for (let digit = 1; digit <= 9; digit++) {
+		const cells = house.filter((c) => candidates[c].has(digit));
+		if (cells.length === 1) return {
+			technique,
+			placements: [{
+				cell: cells[0],
+				digit
+			}],
+			eliminations: [],
+			patternCells: house
+		};
+	}
+	return null;
+};
+const findNakedGroup = (candidates, size) => {
+	const techMap = {
+		2: "nakedPair",
+		3: "nakedTriple",
+		4: "nakedQuad"
+	};
+	for (const house of HOUSES) {
+		const emptyCells = house.filter((c) => candidates[c].size > 0);
+		if (emptyCells.length <= size) continue;
+		for (const group of combinations(emptyCells, size)) {
+			const union = /* @__PURE__ */ new Set();
+			for (const c of group) for (const d of candidates[c]) union.add(d);
+			if (union.size !== size) continue;
+			if (group.some((c) => candidates[c].size === 0)) continue;
+			const eliminations = [];
+			for (const c of house) {
+				if (group.includes(c)) continue;
+				for (const d of union) if (candidates[c].has(d)) eliminations.push({
+					cell: c,
+					digit: d
+				});
+			}
+			if (eliminations.length > 0) return {
+				technique: techMap[size],
+				placements: [],
+				eliminations,
+				patternCells: group
+			};
+		}
+	}
+	return null;
+};
+const findHiddenGroup = (candidates, size) => {
+	const techMap = {
+		2: "hiddenPair",
+		3: "hiddenTriple",
+		4: "hiddenQuad"
+	};
+	for (const house of HOUSES) {
+		const digitCells = /* @__PURE__ */ new Map();
+		for (let d = 1; d <= 9; d++) {
+			const cells = house.filter((c) => candidates[c].has(d));
+			if (cells.length >= 2 && cells.length <= size) digitCells.set(d, cells);
+		}
+		if (digitCells.size < size) continue;
+		for (const digits of combinations([...digitCells.keys()], size)) {
+			const cellSet = /* @__PURE__ */ new Set();
+			for (const d of digits) for (const c of digitCells.get(d)) cellSet.add(c);
+			if (cellSet.size !== size) continue;
+			const digitSet = new Set(digits);
+			const eliminations = [];
+			for (const c of cellSet) for (const d of candidates[c]) if (!digitSet.has(d)) eliminations.push({
+				cell: c,
+				digit: d
+			});
+			if (eliminations.length > 0) return {
+				technique: techMap[size],
+				placements: [],
+				eliminations,
+				patternCells: [...cellSet],
+				hiddenDigits: [...digitSet].sort((a, b) => a - b)
+			};
+		}
+	}
+	return null;
+};
+const findLockedCandidates = (candidates) => {
+	for (const box of BOX_HOUSES) for (let digit = 1; digit <= 9; digit++) {
+		const cells = box.filter((c) => candidates[c].has(digit));
+		if (cells.length < 2) continue;
+		const rows = new Set(cells.map(cellRow));
+		const cols = new Set(cells.map(cellCol));
+		if (rows.size === 1) {
+			const eliminations = ROW_HOUSES[[...rows][0]].filter((c) => !box.includes(c) && candidates[c].has(digit)).map((c) => ({
+				cell: c,
+				digit
+			}));
+			if (eliminations.length > 0) return {
+				technique: "lockedCandidatePointing",
+				placements: [],
+				eliminations,
+				patternCells: cells
+			};
+		}
+		if (cols.size === 1) {
+			const eliminations = COL_HOUSES[[...cols][0]].filter((c) => !box.includes(c) && candidates[c].has(digit)).map((c) => ({
+				cell: c,
+				digit
+			}));
+			if (eliminations.length > 0) return {
+				technique: "lockedCandidatePointing",
+				placements: [],
+				eliminations,
+				patternCells: cells
+			};
+		}
+	}
+	for (const line of [...ROW_HOUSES, ...COL_HOUSES]) for (let digit = 1; digit <= 9; digit++) {
+		const cells = line.filter((c) => candidates[c].has(digit));
+		if (cells.length < 2) continue;
+		const boxes = new Set(cells.map(cellBox));
+		if (boxes.size === 1) {
+			const eliminations = BOX_HOUSES[[...boxes][0]].filter((c) => !line.includes(c) && candidates[c].has(digit)).map((c) => ({
+				cell: c,
+				digit
+			}));
+			if (eliminations.length > 0) return {
+				technique: "lockedCandidateClaiming",
+				placements: [],
+				eliminations,
+				patternCells: cells
+			};
+		}
+	}
+	return null;
+};
+const findFish = (candidates, size) => {
+	const techMap = {
+		2: "xWing",
+		3: "swordfish",
+		4: "jellyfish"
+	};
+	for (let digit = 1; digit <= 9; digit++) {
+		const linePairs = [[ROW_HOUSES, COL_HOUSES], [COL_HOUSES, ROW_HOUSES]];
+		for (const [baseLines, coverLines] of linePairs) {
+			const qualifying = baseLines.map((line, idx) => ({
+				idx,
+				cells: line.filter((c) => candidates[c].has(digit))
+			})).filter((l) => l.cells.length >= 2 && l.cells.length <= size);
+			if (qualifying.length < size) continue;
+			for (const baseCombo of combinations(qualifying, size)) {
+				const baseCells = baseCombo.flatMap((l) => l.cells);
+				const coverIdxSet = new Set(baseLines === ROW_HOUSES ? baseCells.map(cellCol) : baseCells.map(cellRow));
+				if (coverIdxSet.size !== size) continue;
+				const eliminations = [];
+				for (const coverIdx of coverIdxSet) for (const c of coverLines[coverIdx]) if (!baseCells.includes(c) && candidates[c].has(digit)) eliminations.push({
+					cell: c,
+					digit
+				});
+				if (eliminations.length > 0) return {
+					technique: techMap[size],
+					placements: [],
+					eliminations,
+					patternCells: baseCells
+				};
+			}
+		}
+	}
+	return null;
+};
+const findFinnedFish = (candidates, size) => {
+	const techMap = {
+		2: "finnedXWing",
+		3: "finnedSwordfish",
+		4: "finnedJellyfish"
+	};
+	for (let digit = 1; digit <= 9; digit++) for (const [baseLines, coverLines] of [[ROW_HOUSES, COL_HOUSES], [COL_HOUSES, ROW_HOUSES]]) {
+		const coverPerp = baseLines === ROW_HOUSES ? (c) => cellCol(c) : (c) => cellRow(c);
+		const qualifying = baseLines.map((line, idx) => ({
+			idx,
+			cells: line.filter((c) => candidates[c].has(digit))
+		})).filter((l) => l.cells.length >= 2);
+		if (qualifying.length < size) continue;
+		for (const baseCombo of combinations(qualifying, size)) {
+			const allBaseCells = baseCombo.flatMap((l) => l.cells);
+			const allCoverArr = [...new Set(allBaseCells.map(coverPerp))];
+			for (const coreCoverCombo of combinations(allCoverArr.map((idx) => ({ idx })), size)) {
+				const coreCoverIdxs = new Set(coreCoverCombo.map((x) => x.idx));
+				if (baseCombo.some((l) => !l.cells.some((c) => coreCoverIdxs.has(coverPerp(c))))) continue;
+				const finCells = allBaseCells.filter((c) => !coreCoverIdxs.has(coverPerp(c)));
+				if (finCells.length === 0) continue;
+				const finBoxes = new Set(finCells.map(cellBox));
+				if (finBoxes.size !== 1) continue;
+				const finBox = [...finBoxes][0];
+				const baseIdxs = baseCombo.map((l) => l.idx);
+				let anchorFound = false;
+				anchorLoop: for (const baseIdx of baseIdxs) for (const coverIdx of coreCoverIdxs) if (cellBox(baseLines === ROW_HOUSES ? baseIdx * 9 + coverIdx : coverIdx * 9 + baseIdx) === finBox) {
+					anchorFound = true;
+					break anchorLoop;
+				}
+				if (!anchorFound) continue;
+				const eliminations = [];
+				for (const coverIdx of coreCoverIdxs) for (const c of coverLines[coverIdx]) {
+					if (allBaseCells.includes(c)) continue;
+					if (!candidates[c].has(digit)) continue;
+					if (cellBox(c) === finBox) eliminations.push({
+						cell: c,
+						digit
+					});
+				}
+				if (eliminations.length > 0) return {
+					technique: techMap[size],
+					placements: [],
+					eliminations,
+					patternCells: [...allBaseCells]
+				};
+			}
+		}
+	}
+	return null;
+};
+const findSkyscraper = (candidates) => {
+	for (let digit = 1; digit <= 9; digit++) for (const [baseLines, perpFn] of [[ROW_HOUSES, cellCol], [COL_HOUSES, cellRow]]) {
+		const qualifying = baseLines.map((line, idx) => ({
+			idx,
+			cells: line.filter((c) => candidates[c].has(digit))
+		})).filter((l) => l.cells.length === 2);
+		for (let i = 0; i < qualifying.length - 1; i++) for (let j = i + 1; j < qualifying.length; j++) {
+			const lineA = qualifying[i];
+			const lineB = qualifying[j];
+			const aPerp = lineA.cells.map(perpFn);
+			const bPerp = lineB.cells.map(perpFn);
+			let sharedPerp = -1;
+			let aRoof = -1;
+			let bRoof = -1;
+			for (let ai = 0; ai < 2; ai++) for (let bi = 0; bi < 2; bi++) if (aPerp[ai] === bPerp[bi]) {
+				sharedPerp = aPerp[ai];
+				aRoof = lineA.cells[1 - ai];
+				bRoof = lineB.cells[1 - bi];
+			}
+			if (sharedPerp === -1) continue;
+			const eliminations = [];
+			for (let c = 0; c < 81; c++) {
+				if (c === aRoof || c === bRoof) continue;
+				if (candidates[c].has(digit) && PEERS[aRoof].has(c) && PEERS[bRoof].has(c)) eliminations.push({
+					cell: c,
+					digit
+				});
+			}
+			if (eliminations.length > 0) return {
+				technique: "skyscraper",
+				placements: [],
+				eliminations,
+				patternCells: [...lineA.cells, ...lineB.cells]
+			};
+		}
+	}
+	return null;
+};
+const findTwoStringKite = (candidates) => {
+	for (let digit = 1; digit <= 9; digit++) for (const col of COL_HOUSES) {
+		const colCells = col.filter((c) => candidates[c].has(digit));
+		if (colCells.length !== 2) continue;
+		for (const row of ROW_HOUSES) {
+			const rowCells = row.filter((c) => candidates[c].has(digit));
+			if (rowCells.length !== 2) continue;
+			for (const colCell of colCells) for (const rowCell of rowCells) {
+				if (colCell === rowCell) continue;
+				if (cellBox(colCell) !== cellBox(rowCell)) continue;
+				const colRoof = colCells.find((c) => c !== colCell);
+				const rowRoof = rowCells.find((c) => c !== rowCell);
+				if (colRoof === rowRoof) continue;
+				const eliminations = [];
+				for (let c = 0; c < 81; c++) {
+					if (c === colRoof || c === rowRoof) continue;
+					if (candidates[c].has(digit) && PEERS[colRoof].has(c) && PEERS[rowRoof].has(c)) eliminations.push({
+						cell: c,
+						digit
+					});
+				}
+				if (eliminations.length > 0) return {
+					technique: "twoStringKite",
+					placements: [],
+					eliminations,
+					patternCells: [
+						colCell,
+						rowCell,
+						colRoof,
+						rowRoof
+					]
+				};
+			}
+		}
+	}
+	return null;
+};
+const findEmptyRectangle = (candidates) => {
+	for (let digit = 1; digit <= 9; digit++) for (let boxIdx = 0; boxIdx < 9; boxIdx++) {
+		const box = BOX_HOUSES[boxIdx];
+		const boxCells = box.filter((c) => candidates[c].has(digit));
+		if (boxCells.length < 2 || boxCells.length > 4) continue;
+		const rows = new Set(boxCells.map(cellRow));
+		const cols = new Set(boxCells.map(cellCol));
+		const erCandidates = [];
+		for (const erRow of rows) for (const erCol of cols) if (boxCells.every((c) => cellRow(c) === erRow || cellCol(c) === erCol)) erCandidates.push({
+			erRow,
+			erCol
+		});
+		for (const { erRow, erCol } of erCandidates) {
+			for (let col = 0; col < 9; col++) {
+				const colCells = COL_HOUSES[col].filter((c) => candidates[c].has(digit));
+				if (colCells.length !== 2) continue;
+				const [ca, cb] = colCells;
+				for (const [pivot, strongEnd] of [[ca, cb], [cb, ca]]) {
+					if (cellRow(pivot) !== erRow) continue;
+					if (box.includes(pivot)) continue;
+					if (box.includes(strongEnd)) continue;
+					const target = cellRow(strongEnd) * 9 + erCol;
+					if (box.includes(target)) continue;
+					if (target === pivot || target === strongEnd) continue;
+					if (!candidates[target].has(digit)) continue;
+					return {
+						technique: "emptyRectangle",
+						placements: [],
+						eliminations: [{
+							cell: target,
+							digit
+						}],
+						patternCells: [
+							...boxCells,
+							pivot,
+							strongEnd
+						]
+					};
+				}
+			}
+			for (let row = 0; row < 9; row++) {
+				const rowCells = ROW_HOUSES[row].filter((c) => candidates[c].has(digit));
+				if (rowCells.length !== 2) continue;
+				const [ca, cb] = rowCells;
+				for (const [pivot, strongEnd] of [[ca, cb], [cb, ca]]) {
+					if (cellCol(pivot) !== erCol) continue;
+					if (box.includes(pivot)) continue;
+					if (box.includes(strongEnd)) continue;
+					const targetCol = cellCol(strongEnd);
+					const target = erRow * 9 + targetCol;
+					if (box.includes(target)) continue;
+					if (target === pivot || target === strongEnd) continue;
+					if (!candidates[target].has(digit)) continue;
+					return {
+						technique: "emptyRectangle",
+						placements: [],
+						eliminations: [{
+							cell: target,
+							digit
+						}],
+						patternCells: [
+							...boxCells,
+							pivot,
+							strongEnd
+						]
+					};
+				}
+			}
+		}
+	}
+	return null;
+};
+const findWWing = (candidates) => {
+	const bivalue = Array.from({ length: 81 }, (_, c) => c).filter((c) => candidates[c].size === 2);
+	for (let i = 0; i < bivalue.length - 1; i++) for (let j = i + 1; j < bivalue.length; j++) {
+		const c1 = bivalue[i];
+		const c2 = bivalue[j];
+		const cands1 = [...candidates[c1]];
+		const cands2 = [...candidates[c2]];
+		if (cands1[0] !== cands2[0] || cands1[1] !== cands2[1]) continue;
+		const [dA, dB] = cands1;
+		for (const linkDigit of [dA, dB]) {
+			const elimDigit = linkDigit === dA ? dB : dA;
+			for (const house of HOUSES) {
+				const linkCells = house.filter((c) => candidates[c].has(linkDigit));
+				if (linkCells.length !== 2) continue;
+				const [lc1, lc2] = linkCells;
+				if (lc1 === c1 || lc1 === c2 || lc2 === c1 || lc2 === c2) continue;
+				if (!(PEERS[lc1].has(c1) && PEERS[lc2].has(c2) || PEERS[lc1].has(c2) && PEERS[lc2].has(c1))) continue;
+				const eliminations = [];
+				for (let c = 0; c < 81; c++) {
+					if (c === c1 || c === c2) continue;
+					if (candidates[c].has(elimDigit) && PEERS[c1].has(c) && PEERS[c2].has(c)) eliminations.push({
+						cell: c,
+						digit: elimDigit
+					});
+				}
+				if (eliminations.length > 0) return {
+					technique: "wWing",
+					placements: [],
+					eliminations,
+					patternCells: [
+						c1,
+						c2,
+						lc1,
+						lc2
+					],
+					patternDigits: [linkDigit]
+				};
+			}
+		}
+	}
+	return null;
+};
+const findYWing = (candidates) => {
+	const bivalue = Array.from({ length: 81 }, (_, c) => c).filter((c) => candidates[c].size === 2);
+	for (const pivot of bivalue) {
+		const [a, b] = [...candidates[pivot]];
+		const pincers = bivalue.filter((c) => c !== pivot && PEERS[pivot].has(c) && (candidates[c].has(a) || candidates[c].has(b)));
+		for (const p1 of pincers) for (const p2 of pincers) {
+			if (p2 <= p1) continue;
+			const p1other = [...candidates[p1]].find((d) => d !== a && d !== b);
+			const p2other = [...candidates[p2]].find((d) => d !== a && d !== b);
+			if (p1other === void 0 || p2other === void 0 || p1other !== p2other) continue;
+			if (candidates[p1].has(a) && candidates[p1].has(b) || candidates[p2].has(a) && candidates[p2].has(b)) continue;
+			if (candidates[p1].has(a) === candidates[p2].has(a)) continue;
+			const elimDigit = p1other;
+			const eliminations = [];
+			for (let c = 0; c < 81; c++) {
+				if (c === pivot || c === p1 || c === p2) continue;
+				if (PEERS[p1].has(c) && PEERS[p2].has(c) && candidates[c].has(elimDigit)) eliminations.push({
+					cell: c,
+					digit: elimDigit
+				});
+			}
+			if (eliminations.length > 0) {
+				const p1shared = candidates[p1].has(a) ? a : b;
+				const p2shared = p1shared === a ? b : a;
+				return {
+					technique: "yWing",
+					placements: [],
+					eliminations,
+					patternCells: [
+						pivot,
+						p1,
+						p2
+					],
+					chainPath: [
+						{
+							cell: p1,
+							digit: elimDigit,
+							isOn: false,
+							linkToNext: "strong"
+						},
+						{
+							cell: p1,
+							digit: p1shared,
+							isOn: true,
+							linkToNext: "weak"
+						},
+						{
+							cell: pivot,
+							digit: p1shared,
+							isOn: false,
+							linkToNext: "strong"
+						},
+						{
+							cell: pivot,
+							digit: p2shared,
+							isOn: true,
+							linkToNext: "weak"
+						},
+						{
+							cell: p2,
+							digit: p2shared,
+							isOn: false,
+							linkToNext: "strong"
+						},
+						{
+							cell: p2,
+							digit: elimDigit,
+							isOn: true
+						}
+					]
+				};
+			}
+		}
+	}
+	return null;
+};
+const findXYZWing = (candidates) => {
+	for (let pivot = 0; pivot < 81; pivot++) {
+		if (candidates[pivot].size !== 3) continue;
+		const [a, b, c] = [...candidates[pivot]];
+		const eligiblePincers = [];
+		for (const p of PEERS[pivot]) if (candidates[p].size === 2 && [...candidates[p]].every((d) => d === a || d === b || d === c)) eligiblePincers.push(p);
+		if (eligiblePincers.length < 2) continue;
+		for (const p1 of eligiblePincers) for (const p2 of eligiblePincers) {
+			if (p2 <= p1) continue;
+			if ([
+				a,
+				b,
+				c
+			].find((d) => !candidates[p1].has(d)) === [
+				a,
+				b,
+				c
+			].find((d) => !candidates[p2].has(d))) continue;
+			let elimDigit = null;
+			for (const d of [
+				a,
+				b,
+				c
+			]) if (candidates[pivot].has(d) && candidates[p1].has(d) && candidates[p2].has(d)) {
+				elimDigit = d;
+				break;
+			}
+			if (elimDigit === null) continue;
+			const elim = elimDigit;
+			const eliminations = [];
+			for (let cell = 0; cell < 81; cell++) {
+				if (cell === pivot || cell === p1 || cell === p2) continue;
+				if (PEERS[pivot].has(cell) && PEERS[p1].has(cell) && PEERS[p2].has(cell) && candidates[cell].has(elim)) eliminations.push({
+					cell,
+					digit: elim
+				});
+			}
+			if (eliminations.length > 0) {
+				const notZ1 = [...candidates[p1]].find((d) => d !== elim);
+				const notZ2 = [...candidates[p2]].find((d) => d !== elim);
+				return {
+					technique: "xyzWing",
+					placements: [],
+					eliminations,
+					patternCells: [
+						pivot,
+						p1,
+						p2
+					],
+					chainPath: [
+						{
+							cell: p1,
+							digit: elim,
+							isOn: false,
+							linkToNext: "strong"
+						},
+						{
+							cell: p1,
+							digit: notZ1,
+							isOn: true,
+							linkToNext: "weak"
+						},
+						{
+							cell: pivot,
+							digit: notZ1,
+							isOn: false,
+							linkToNext: "strong"
+						},
+						{
+							cell: pivot,
+							digit: notZ2,
+							isOn: true,
+							linkToNext: "weak"
+						},
+						{
+							cell: p2,
+							digit: notZ2,
+							isOn: false,
+							linkToNext: "strong"
+						},
+						{
+							cell: p2,
+							digit: elim,
+							isOn: true
+						}
+					]
+				};
+			}
+		}
+	}
+	return null;
+};
+const buildURCells = () => {
+	const rects = [];
+	for (let r1 = 0; r1 < 9; r1++) for (let r2 = r1 + 1; r2 < 9; r2++) for (let c1 = 0; c1 < 9; c1++) for (let c2 = c1 + 1; c2 < 9; c2++) {
+		const cells = [
+			r1 * 9 + c1,
+			r1 * 9 + c2,
+			r2 * 9 + c1,
+			r2 * 9 + c2
+		];
+		if (new Set(cells.map(cellBox)).size === 2) rects.push(cells);
+	}
+	return rects;
+};
+const UR_RECTS = buildURCells();
+const findUniqueRectangle = (grid, candidates) => {
+	for (const [c0, c1, c2, c3] of UR_RECTS) {
+		if (grid[c0] !== 0 || grid[c1] !== 0 || grid[c2] !== 0 || grid[c3] !== 0) continue;
+		const cands = [
+			candidates[c0],
+			candidates[c1],
+			candidates[c2],
+			candidates[c3]
+		];
+		const floor = new Set([
+			1,
+			2,
+			3,
+			4,
+			5,
+			6,
+			7,
+			8,
+			9
+		]);
+		for (const s of cands) for (const d of floor) if (!s.has(d)) floor.delete(d);
+		if (floor.size !== 2) continue;
+		const extras = cands.map((s) => [...s].filter((d) => !floor.has(d)));
+		const cells = [
+			c0,
+			c1,
+			c2,
+			c3
+		];
+		for (let i = 0; i < 4; i++) if (extras[i].length > 0 && extras.filter((_, j) => j !== i && extras[j].length === 0).length === 3) {
+			const eliminations = [...floor].map((d) => ({
+				cell: cells[i],
+				digit: d
+			}));
+			if (eliminations.length > 0) return {
+				technique: "uniqueRectangleType1",
+				placements: [],
+				eliminations,
+				patternCells: cells,
+				patternDigits: [...floor].sort((a, b) => a - b)
+			};
+		}
+		const extraCells = cells.filter((_, i) => extras[i].length === 1);
+		const floorOnlyCount = cells.filter((_, i) => extras[i].length === 0).length;
+		if (extraCells.length === 2 && floorOnlyCount === 2) {
+			const [ec0, ec1] = extraCells;
+			const i0 = cells.indexOf(ec0), i1 = cells.indexOf(ec1);
+			if (extras[i0][0] === extras[i1][0]) {
+				const extraDigit = extras[i0][0];
+				const eliminations = [];
+				for (let cell = 0; cell < 81; cell++) {
+					if (cells.includes(cell)) continue;
+					if (PEERS[ec0].has(cell) && PEERS[ec1].has(cell) && candidates[cell].has(extraDigit)) eliminations.push({
+						cell,
+						digit: extraDigit
+					});
+				}
+				if (eliminations.length > 0) return {
+					technique: "uniqueRectangleType2",
+					placements: [],
+					eliminations,
+					patternCells: cells,
+					patternDigits: [...floor].sort((a, b) => a - b)
+				};
+			}
+		}
+		if (extraCells.length === 2 && floorOnlyCount === 2) {
+			const [ec0, ec1] = extraCells;
+			const i0 = cells.indexOf(ec0), i1 = cells.indexOf(ec1);
+			const combinedExtras = new Set([...extras[i0], ...extras[i1]]);
+			const sharedHouses = HOUSES.filter((h) => h.includes(ec0) && h.includes(ec1));
+			for (const house of sharedHouses) {
+				const groupSize = combinedExtras.size;
+				if (groupSize < 1 || groupSize > 4) continue;
+				const otherCells = house.filter((c) => !cells.includes(c) && candidates[c].size > 0);
+				for (const extra of combinations(otherCells, groupSize - 1)) {
+					const groupUnion = new Set(combinedExtras);
+					for (const c of extra) for (const d of candidates[c]) groupUnion.add(d);
+					if (groupUnion.size !== groupSize) continue;
+					const groupCells = [
+						ec0,
+						ec1,
+						...extra
+					];
+					const eliminations = [];
+					for (const c of house) {
+						if (groupCells.includes(c)) continue;
+						for (const d of groupUnion) if (candidates[c].has(d)) eliminations.push({
+							cell: c,
+							digit: d
+						});
+					}
+					if (eliminations.length > 0) return {
+						technique: "uniqueRectangleType3",
+						placements: [],
+						eliminations,
+						patternCells: cells,
+						patternDigits: [...floor].sort((a, b) => a - b)
+					};
+				}
+			}
+		}
+		if (extraCells.length === 2 && floorOnlyCount === 2) {
+			const [ec0, ec1] = extraCells;
+			const sharedHouses = HOUSES.filter((h) => h.includes(ec0) && h.includes(ec1));
+			for (const house of sharedHouses) for (const floorDigit of floor) {
+				const otherFloorDigit = [...floor].find((d) => d !== floorDigit);
+				if (house.filter((c) => !cells.includes(c)).every((c) => !candidates[c].has(floorDigit))) {
+					const eliminations = [ec0, ec1].filter((c) => candidates[c].has(otherFloorDigit)).map((c) => ({
+						cell: c,
+						digit: otherFloorDigit
+					}));
+					if (eliminations.length > 0) return {
+						technique: "uniqueRectangleType4",
+						placements: [],
+						eliminations,
+						patternCells: cells,
+						patternDigits: [...floor].sort((a, b) => a - b)
+					};
+				}
+			}
+		}
+		if (cells.filter((_, i) => extras[i].length === 0).length === 3) {
+			const extraCell = cells.find((_, i) => extras[i].length > 0);
+			const extraIdx = cells.indexOf(extraCell);
+			const diagCell = cells[extraIdx < 2 ? extraIdx + 2 : extraIdx - 2];
+			for (const d of extras[extraIdx]) {
+				const eliminations = [];
+				for (let cell = 0; cell < 81; cell++) {
+					if (cells.includes(cell)) continue;
+					if (PEERS[extraCell].has(cell) && PEERS[diagCell].has(cell) && candidates[cell].has(d)) eliminations.push({
+						cell,
+						digit: d
+					});
+				}
+				if (eliminations.length > 0) return {
+					technique: "uniqueRectangleType5",
+					placements: [],
+					eliminations,
+					patternCells: cells
+				};
+			}
+		}
+	}
+	return null;
+};
+const findBUG = (candidates) => {
+	let trivialCell = -1;
+	let trivialDigit = -1;
+	for (let cell = 0; cell < 81; cell++) {
+		if (candidates[cell].size === 0) continue;
+		if (candidates[cell].size > 3) return null;
+		if (candidates[cell].size === 3) {
+			if (trivialCell !== -1) return null;
+			trivialCell = cell;
+		}
+	}
+	if (trivialCell === -1) return null;
+	for (const d of candidates[trivialCell]) {
+		let valid = true;
+		for (const house of HOUSES) {
+			if (!house.includes(trivialCell)) continue;
+			if (house.filter((c) => candidates[c].has(d)).length !== 3) {
+				valid = false;
+				break;
+			}
+		}
+		if (valid) {
+			if (Array.from({ length: 81 }, (_, c) => c).filter((c) => c !== trivialCell && candidates[c].size > 0).every((c) => candidates[c].size === 2)) {
+				trivialDigit = d;
+				break;
+			}
+		}
+	}
+	if (trivialDigit === -1) return null;
+	return {
+		technique: "bug",
+		placements: [{
+			cell: trivialCell,
+			digit: trivialDigit
+		}],
+		eliminations: [],
+		patternCells: [trivialCell]
+	};
+};
+const findXYChain = (candidates) => {
+	const bivalue = Array.from({ length: 81 }, (_, c) => c).filter((c) => candidates[c].size === 2);
+	for (const start of bivalue) {
+		const [dA, dB] = [...candidates[start]];
+		for (const exitDigit of [dA, dB]) {
+			const enterDigit = exitDigit === dA ? dB : dA;
+			const stack = [{
+				cell: start,
+				exit: exitDigit,
+				path: [start],
+				exits: [exitDigit]
+			}];
+			while (stack.length > 0) {
+				const { cell, exit, path, exits } = stack.pop();
+				for (const next of bivalue) {
+					if (path.includes(next)) continue;
+					if (!PEERS[cell].has(next)) continue;
+					if (!candidates[next].has(exit)) continue;
+					const nextExit = [...candidates[next]].find((d) => d !== exit);
+					const newPath = [...path, next];
+					const newExits = [...exits, nextExit];
+					if (newPath.length >= 4 && enterDigit === nextExit) {
+						const elimDigit = enterDigit;
+						const eliminations = [];
+						for (let c = 0; c < 81; c++) {
+							if (newPath.includes(c) || !candidates[c].has(elimDigit)) continue;
+							if (PEERS[start].has(c) && PEERS[next].has(c)) eliminations.push({
+								cell: c,
+								digit: elimDigit
+							});
+						}
+						if (eliminations.length > 0) {
+							const chainPath = [];
+							for (let ci = 0; ci < newPath.length; ci++) {
+								const c = newPath[ci];
+								const cellEnter = ci === 0 ? enterDigit : newExits[ci - 1];
+								const cellExit = newExits[ci];
+								chainPath.push({
+									cell: c,
+									digit: cellEnter,
+									isOn: false,
+									linkToNext: "strong"
+								});
+								const isLast = ci === newPath.length - 1;
+								chainPath.push({
+									cell: c,
+									digit: cellExit,
+									isOn: true,
+									linkToNext: isLast ? void 0 : "weak"
+								});
+							}
+							return {
+								technique: "xyChain",
+								placements: [],
+								eliminations,
+								patternCells: newPath,
+								chainPath
+							};
+						}
+					}
+					stack.push({
+						cell: next,
+						exit: nextExit,
+						path: newPath,
+						exits: newExits
+					});
+				}
+			}
+		}
+	}
+	return null;
+};
+const findAIC = (candidates, grid) => {
+	const encode = (cell, digit) => cell * 9 + (digit - 1);
+	const decodeCell = (node) => Math.floor(node / 9);
+	const decodeDigit = (node) => node % 9 + 1;
+	const strongLinks = /* @__PURE__ */ new Map();
+	const addStrong = (a, b) => {
+		if (!strongLinks.has(a)) strongLinks.set(a, /* @__PURE__ */ new Set());
+		if (!strongLinks.has(b)) strongLinks.set(b, /* @__PURE__ */ new Set());
+		strongLinks.get(a).add(b);
+		strongLinks.get(b).add(a);
+	};
+	for (const house of HOUSES) for (let digit = 1; digit <= 9; digit++) {
+		const cells = house.filter((c) => candidates[c].has(digit));
+		if (cells.length === 2) addStrong(encode(cells[0], digit), encode(cells[1], digit));
+	}
+	for (let cell = 0; cell < 81; cell++) if (candidates[cell].size === 2) {
+		const [d1, d2] = [...candidates[cell]];
+		addStrong(encode(cell, d1), encode(cell, d2));
+	}
+	const weakNeighbors = (node) => {
+		const cell = decodeCell(node);
+		const digit = decodeDigit(node);
+		const result = [];
+		for (const peer of PEERS[cell]) if (candidates[peer].has(digit)) result.push(encode(peer, digit));
+		for (const d of candidates[cell]) if (d !== digit) result.push(encode(cell, d));
+		return result;
+	};
+	const allNodes = [];
+	for (let cell = 0; cell < 81; cell++) for (const digit of candidates[cell]) allNodes.push(encode(cell, digit));
+	const MAX_CHAIN = 12;
+	for (const startNode of allNodes) {
+		if (!strongLinks.has(startNode)) continue;
+		const queue = [{
+			node: startNode,
+			isOn: true,
+			path: [startNode]
+		}];
+		while (queue.length > 0) {
+			const { node, isOn, path } = queue.shift();
+			if (path.length > MAX_CHAIN) continue;
+			const next_nodes = isOn ? weakNeighbors(node) : [...strongLinks.get(node) ?? []];
+			for (const next of next_nodes) {
+				if (path.includes(next)) continue;
+				const newPath = [...path, next];
+				if (!isOn && newPath.length >= 4) {
+					if (weakNeighbors(next).includes(startNode)) {
+						const onNodes = newPath.filter((_, i) => i % 2 === 0);
+						const offNodes = newPath.filter((_, i) => i % 2 === 1);
+						const hasWeakConflict = (nodes, allowedPair) => nodes.some((a, i) => nodes.slice(i + 1).some((b) => {
+							if (allowedPair === `${Math.min(a, b)},${Math.max(a, b)}`) return false;
+							return weakNeighbors(a).includes(b);
+						}));
+						if (!!hasWeakConflict(onNodes, `${Math.min(startNode, next)},${Math.max(startNode, next)}`)) continue;
+						const weakLinks = [];
+						for (let i = 0; i < newPath.length - 1; i += 2) weakLinks.push([newPath[i], newPath[i + 1]]);
+						const eliminations = [];
+						const pathCells = new Set(newPath.map(decodeCell));
+						const offDigitConflict = (digit) => hasWeakConflict(offNodes.filter((node) => decodeDigit(node) === digit), null);
+						for (const [onNode, offNode] of weakLinks) {
+							const onCell = decodeCell(onNode);
+							const onDigit = decodeDigit(onNode);
+							const offCell = decodeCell(offNode);
+							if (onDigit === decodeDigit(offNode)) {
+								const d = onDigit;
+								if (offDigitConflict(d)) continue;
+								for (let c = 0; c < 81; c++) {
+									if (pathCells.has(c)) continue;
+									if (candidates[c].has(d) && PEERS[onCell].has(c) && PEERS[offCell].has(c)) eliminations.push({
+										cell: c,
+										digit: d
+									});
+								}
+							}
+						}
+						const seen = /* @__PURE__ */ new Set();
+						const unique = eliminations.filter((e) => {
+							const key = `${e.cell},${e.digit}`;
+							if (seen.has(key)) return false;
+							seen.add(key);
+							return true;
+						});
+						const validated = !(grid !== void 0) ? unique : unique.filter(({ cell, digit }) => propagateDeep(cell, digit, grid, candidates) === null);
+						if (validated.length > 0) {
+							const chainPath = newPath.map((n, i) => {
+								const isOn = i % 2 === 0;
+								return {
+									cell: decodeCell(n),
+									digit: decodeDigit(n),
+									isOn,
+									linkToNext: i < newPath.length - 1 ? isOn ? "weak" : "strong" : "weak"
+								};
+							});
+							return {
+								technique: "aicRing",
+								placements: [],
+								eliminations: validated,
+								patternCells: [...new Set([...newPath, startNode].map(decodeCell))],
+								chainPath
+							};
+						}
+					}
+					const startCell = decodeCell(startNode);
+					const startDigit = decodeDigit(startNode);
+					const endCell = decodeCell(next);
+					const eliminations = [];
+					if (startCell === endCell) {
+						if (candidates[startCell].has(startDigit)) eliminations.push({
+							cell: startCell,
+							digit: startDigit
+						});
+					}
+					if (eliminations.length > 0) {
+						const chainPath = newPath.map((n, i) => {
+							const isOn = i % 2 === 0;
+							return {
+								cell: decodeCell(n),
+								digit: decodeDigit(n),
+								isOn,
+								linkToNext: i < newPath.length - 1 ? isOn ? "weak" : "strong" : void 0
+							};
+						});
+						return {
+							technique: "aic",
+							placements: [],
+							eliminations,
+							patternCells: [...new Set(newPath.map(decodeCell))],
+							chainPath
+						};
+					}
+				}
+				queue.push({
+					node: next,
+					isOn: !isOn,
+					path: newPath
+				});
+			}
+		}
+	}
+	for (const startNode of allNodes) {
+		if (!strongLinks.has(startNode)) continue;
+		const queue = [{
+			node: startNode,
+			isOn: false,
+			path: [startNode]
+		}];
+		while (queue.length > 0) {
+			const { node, isOn, path } = queue.shift();
+			if (path.length > MAX_CHAIN) continue;
+			const next_nodes = isOn ? weakNeighbors(node) : [...strongLinks.get(node) ?? []];
+			for (const next of next_nodes) {
+				if (path.includes(next)) continue;
+				const newPath = [...path, next];
+				if (!isOn && newPath.length >= 4) {
+					const startCell = decodeCell(startNode);
+					const startDigit = decodeDigit(startNode);
+					const endCell = decodeCell(next);
+					const endDigit = decodeDigit(next);
+					const eliminations = [];
+					if (startDigit === endDigit) {
+						const d = startDigit;
+						for (let c = 0; c < 81; c++) {
+							if (newPath.some((n) => decodeCell(n) === c)) continue;
+							if (candidates[c].has(d) && PEERS[startCell].has(c) && PEERS[endCell].has(c)) eliminations.push({
+								cell: c,
+								digit: d
+							});
+						}
+					}
+					if (eliminations.length > 0) {
+						const chainPath = newPath.map((n, i) => {
+							const isOn = i % 2 !== 0;
+							return {
+								cell: decodeCell(n),
+								digit: decodeDigit(n),
+								isOn,
+								linkToNext: i < newPath.length - 1 ? isOn ? "weak" : "strong" : void 0
+							};
+						});
+						return {
+							technique: "aic",
+							placements: [],
+							eliminations,
+							patternCells: [...new Set(newPath.map(decodeCell))],
+							chainPath
+						};
+					}
+				}
+				queue.push({
+					node: next,
+					isOn: !isOn,
+					path: newPath
+				});
+			}
+		}
+	}
+	return null;
+};
+const findGroupedAIC = (candidates, grid) => {
+	const nodes = [];
+	const nodeById = /* @__PURE__ */ new Map();
+	let nextId = 0;
+	for (let cell = 0; cell < 81; cell++) for (const digit of candidates[cell]) {
+		const id = nextId++;
+		const nd = {
+			type: "cell",
+			cell,
+			digit,
+			id
+		};
+		nodes.push(nd);
+		nodeById.set(id, nd);
+	}
+	const groupNodes = [];
+	for (const box of BOX_HOUSES) for (let digit = 1; digit <= 9; digit++) {
+		const boxCells = box.filter((c) => candidates[c].has(digit));
+		if (boxCells.length < 2) continue;
+		const byRow = /* @__PURE__ */ new Map();
+		const byCol = /* @__PURE__ */ new Map();
+		for (const c of boxCells) {
+			const r = cellRow(c);
+			const col = cellCol(c);
+			if (!byRow.has(r)) byRow.set(r, []);
+			if (!byCol.has(col)) byCol.set(col, []);
+			byRow.get(r).push(c);
+			byCol.get(col).push(c);
+		}
+		for (const [, cells] of [...byRow, ...byCol]) {
+			if (cells.length < 2) continue;
+			const id = nextId++;
+			const nd = {
+				type: "group",
+				cells,
+				digit,
+				id
+			};
+			groupNodes.push(nd);
+			nodeById.set(id, nd);
+		}
+	}
+	const allNodes = [...nodes, ...groupNodes];
+	const strongLinks = /* @__PURE__ */ new Map();
+	const addStrong = (a, b) => {
+		if (!strongLinks.has(a)) strongLinks.set(a, /* @__PURE__ */ new Set());
+		if (!strongLinks.has(b)) strongLinks.set(b, /* @__PURE__ */ new Set());
+		strongLinks.get(a).add(b);
+		strongLinks.get(b).add(a);
+	};
+	for (const house of HOUSES) for (let digit = 1; digit <= 9; digit++) {
+		const houseCells = new Set(house.filter((c) => candidates[c].has(digit)));
+		if (houseCells.size < 2) continue;
+		const houseNodes = allNodes.filter((nd) => {
+			if (nd.digit !== digit) return false;
+			return (nd.type === "cell" ? [nd.cell] : nd.cells).every((c) => houseCells.has(c));
+		});
+		for (let i = 0; i < houseNodes.length - 1; i++) for (let j = i + 1; j < houseNodes.length; j++) {
+			const ni = houseNodes[i];
+			const nj = houseNodes[j];
+			const niCells = ni.type === "cell" ? [ni.cell] : ni.cells;
+			const njCells = nj.type === "cell" ? [nj.cell] : nj.cells;
+			if (niCells.some((c) => njCells.includes(c))) continue;
+			const covered = new Set([...niCells, ...njCells]);
+			if ([...houseCells].every((c) => covered.has(c))) addStrong(ni.id, nj.id);
+		}
+	}
+	for (let cell = 0; cell < 81; cell++) {
+		if (candidates[cell].size !== 2) continue;
+		const [d1, d2] = [...candidates[cell]];
+		const n1 = nodes.find((n) => n.type === "cell" && n.cell === cell && n.digit === d1);
+		const n2 = nodes.find((n) => n.type === "cell" && n.cell === cell && n.digit === d2);
+		if (n1 && n2) addStrong(n1.id, n2.id);
+	}
+	const weakNeighbors = (nodeId) => {
+		const nd = nodeById.get(nodeId);
+		const ndCells = nd.type === "cell" ? [nd.cell] : nd.cells;
+		const result = [];
+		for (const other of allNodes) {
+			if (other.id === nodeId || other.digit !== nd.digit) continue;
+			const otherCells = other.type === "cell" ? [other.cell] : other.cells;
+			if (ndCells.every((c1) => otherCells.every((c2) => c1 !== c2 && PEERS[c1].has(c2)))) result.push(other.id);
+		}
+		if (nd.type === "cell") for (const other of nodes) {
+			if (other.type !== "cell") continue;
+			if (other.cell === nd.cell && other.digit !== nd.digit) result.push(other.id);
+		}
+		return result;
+	};
+	const nodeCells = (id) => {
+		const nd = nodeById.get(id);
+		return nd.type === "cell" ? [nd.cell] : nd.cells;
+	};
+	const MAX_CHAIN = 12;
+	const buildGroupedChainPath = (path, startsOn) => path.map((id, i) => {
+		const nd = nodeById.get(id);
+		const isOn = startsOn ? i % 2 === 0 : i % 2 !== 0;
+		return {
+			cell: nd.type === "cell" ? nd.cell : nd.cells[0],
+			digit: nd.digit,
+			isOn,
+			cells: nd.type === "group" ? nd.cells : void 0,
+			linkToNext: i < path.length - 1 ? isOn ? "weak" : "strong" : void 0
+		};
+	});
+	const cellsInPathByDigit = (path) => {
+		const m = /* @__PURE__ */ new Map();
+		for (const id of path) {
+			const nd = nodeById.get(id);
+			if (!m.has(nd.digit)) m.set(nd.digit, /* @__PURE__ */ new Set());
+			for (const c of nodeCells(id)) m.get(nd.digit).add(c);
+		}
+		return m;
+	};
+	const wouldOverlapSameDigit = (path, next) => {
+		const nd = nodeById.get(next);
+		const usedCells = cellsInPathByDigit(path).get(nd.digit);
+		if (!usedCells) return false;
+		return nodeCells(next).some((c) => usedCells.has(c));
+	};
+	for (const startNode of allNodes) {
+		if (!strongLinks.has(startNode.id)) continue;
+		const queue = [{
+			id: startNode.id,
+			isOn: true,
+			path: [startNode.id]
+		}];
+		while (queue.length > 0) {
+			const { id, isOn, path } = queue.shift();
+			if (path.length > MAX_CHAIN) continue;
+			const nextIds = isOn ? weakNeighbors(id) : [...strongLinks.get(id) ?? []];
+			for (const next of nextIds) {
+				if (path.includes(next)) continue;
+				if (wouldOverlapSameDigit(path, next)) continue;
+				const newPath = [...path, next];
+				if (!isOn && newPath.length >= 4) {
+					if (weakNeighbors(next).includes(startNode.id)) {
+						const startNd = nodeById.get(startNode.id);
+						const endNd = nodeById.get(next);
+						const closingIsSameDigitPeer = startNd.digit === endNd.digit;
+						const onNodes = newPath.filter((_, i) => i % 2 === 0);
+						const allowedOnPair = `${Math.min(startNode.id, next)},${Math.max(startNode.id, next)}`;
+						const hasWeakConflict = (nodes) => nodes.some((a, i) => nodes.slice(i + 1).some((b) => {
+							if (allowedOnPair === `${Math.min(a, b)},${Math.max(a, b)}`) return false;
+							return weakNeighbors(a).includes(b);
+						}));
+						if (hasWeakConflict(onNodes)) continue;
+						const weakLinks = [];
+						for (let i = 0; i < newPath.length - 1; i += 2) weakLinks.push([newPath[i], newPath[i + 1]]);
+						const eliminations = [];
+						const pathCells = new Set(newPath.flatMap(nodeCells));
+						for (const [onId, offId] of weakLinks) {
+							const onNd = nodeById.get(onId);
+							const offNd = nodeById.get(offId);
+							if (onNd.digit !== offNd.digit) continue;
+							const d = onNd.digit;
+							const onCs = nodeCells(onId);
+							const offCs = nodeCells(offId);
+							for (let c = 0; c < 81; c++) {
+								if (pathCells.has(c)) continue;
+								if (candidates[c].has(d) && onCs.every((oc) => PEERS[oc].has(c)) && offCs.every((oc) => PEERS[oc].has(c))) eliminations.push({
+									cell: c,
+									digit: d
+								});
+							}
+						}
+						const seen = /* @__PURE__ */ new Set();
+						const unique = eliminations.filter((e) => {
+							const key = `${e.cell},${e.digit}`;
+							if (seen.has(key)) return false;
+							seen.add(key);
+							return true;
+						});
+						const hasInCellWeakLink = startNd.type === "cell" && endNd.type === "cell" && startNd.cell === endNd.cell || weakLinks.some(([onId, offId]) => {
+							const onNd = nodeById.get(onId);
+							const offNd = nodeById.get(offId);
+							return onNd.type === "cell" && offNd.type === "cell" && onNd.cell === offNd.cell;
+						});
+						const shouldValidate = (hasInCellWeakLink || closingIsSameDigitPeer) && grid !== void 0;
+						if ((hasInCellWeakLink || closingIsSameDigitPeer) && !grid) continue;
+						const validated = !shouldValidate ? unique : unique.filter(({ cell, digit }) => propagateDeep(cell, digit, grid, candidates) === null);
+						if (validated.length > 0) {
+							const chainPath = buildGroupedChainPath(newPath, true);
+							if (chainPath.length > 0) chainPath[chainPath.length - 1].linkToNext = "weak";
+							return {
+								technique: "groupedAIC",
+								placements: [],
+								eliminations: validated,
+								patternCells: [...new Set([...newPath, startNode.id].flatMap(nodeCells))],
+								chainPath
+							};
+						}
+					}
+					const startNd = nodeById.get(startNode.id);
+					const endNd = nodeById.get(next);
+					if (startNd.type === "cell" && endNd.type === "cell" && startNd.cell === endNd.cell && startNd.digit !== endNd.digit) {
+						if (candidates[startNd.cell].has(startNd.digit)) return {
+							technique: "groupedAIC",
+							placements: [],
+							eliminations: [{
+								cell: startNd.cell,
+								digit: startNd.digit
+							}],
+							patternCells: [...new Set(newPath.flatMap(nodeCells))],
+							chainPath: buildGroupedChainPath(newPath, true)
+						};
+					}
+				}
+				queue.push({
+					id: next,
+					isOn: !isOn,
+					path: newPath
+				});
+			}
+		}
+	}
+	for (const startNode of allNodes) {
+		if (!strongLinks.has(startNode.id)) continue;
+		const queue = [{
+			id: startNode.id,
+			isOn: false,
+			path: [startNode.id]
+		}];
+		while (queue.length > 0) {
+			const { id, isOn, path } = queue.shift();
+			if (path.length > MAX_CHAIN) continue;
+			const nextIds = isOn ? weakNeighbors(id) : [...strongLinks.get(id) ?? []];
+			for (const next of nextIds) {
+				if (path.includes(next)) continue;
+				if (wouldOverlapSameDigit(path, next)) continue;
+				const newPath = [...path, next];
+				if (!isOn && newPath.length >= 4) {
+					const startNd = nodeById.get(startNode.id);
+					const endNd = nodeById.get(next);
+					if (startNd.digit === endNd.digit) {
+						const d = startNd.digit;
+						const startCs = nodeCells(startNode.id);
+						const endCs = nodeCells(next);
+						const eliminations = [];
+						const pathCells = new Set(newPath.flatMap(nodeCells));
+						for (let c = 0; c < 81; c++) {
+							if (pathCells.has(c)) continue;
+							if (candidates[c].has(d) && startCs.every((sc) => PEERS[sc].has(c)) && endCs.every((ec) => PEERS[ec].has(c))) eliminations.push({
+								cell: c,
+								digit: d
+							});
+						}
+						if (eliminations.length > 0) return {
+							technique: "groupedAIC",
+							placements: [],
+							eliminations,
+							patternCells: [...new Set(newPath.flatMap(nodeCells))],
+							chainPath: buildGroupedChainPath(newPath, false)
+						};
+					}
+				}
+				queue.push({
+					id: next,
+					isOn: !isOn,
+					path: newPath
+				});
+			}
+		}
+	}
+	return null;
+};
+const propagate = (cell, digit, gridIn, candsIn) => {
+	const grid = [...gridIn];
+	const cands = candsIn.map((s) => new Set(s));
+	const queue = [[cell, digit]];
+	while (queue.length > 0) {
+		const [c, d] = queue.shift();
+		if (grid[c] !== 0) {
+			if (grid[c] !== d) return null;
+			continue;
+		}
+		if (!cands[c].has(d)) return null;
+		grid[c] = d;
+		cands[c] = /* @__PURE__ */ new Set();
+		for (const peer of PEERS[c]) {
+			if (grid[peer] !== 0) continue;
+			cands[peer].delete(d);
+			if (cands[peer].size === 0) return null;
+			if (cands[peer].size === 1) queue.push([peer, [...cands[peer]][0]]);
+		}
+		for (const house of HOUSES) {
+			if (!house.includes(c)) continue;
+			for (let hd = 1; hd <= 9; hd++) {
+				const cells = house.filter((hc) => grid[hc] === 0 && cands[hc].has(hd));
+				if (cells.length === 0 && !house.some((hc) => grid[hc] === hd)) return null;
+				if (cells.length === 1 && grid[cells[0]] === 0) queue.push([cells[0], hd]);
+			}
+		}
+	}
+	return {
+		grid,
+		candidates: cands
+	};
+};
+const propagateDeep = (cell, digit, gridIn, candsIn) => {
+	const base = propagate(cell, digit, gridIn, candsIn);
+	if (base === null) return null;
+	let { grid, candidates } = base;
+	for (;;) {
+		let changed = false;
+		const lockedHint = findLockedCandidates(candidates) ?? findNakedGroup(candidates, 2) ?? findHiddenGroup(candidates, 2);
+		if (lockedHint !== null) {
+			const newCands = candidates.map((s) => new Set(s));
+			for (const { cell: c, digit: d } of lockedHint.eliminations) {
+				newCands[c].delete(d);
+				if (newCands[c].size === 0 && grid[c] === 0) return null;
+			}
+			const forced = [];
+			for (let c = 0; c < 81; c++) if (grid[c] === 0 && newCands[c].size === 1) forced.push([c, [...newCands[c]][0]]);
+			if (forced.length > 0 || lockedHint.eliminations.length > 0) {
+				changed = true;
+				candidates = newCands;
+				for (const [fc, fd] of forced) {
+					if (grid[fc] !== 0) continue;
+					const r = propagate(fc, fd, grid, candidates);
+					if (r === null) return null;
+					grid = r.grid;
+					candidates = r.candidates;
+				}
+			}
+		}
+		if (!changed) break;
+	}
+	return {
+		grid,
+		candidates
+	};
+};
+const findNishio = (grid, candidates) => {
+	for (let cell = 0; cell < 81; cell++) {
+		if (candidates[cell].size === 0) continue;
+		for (const digit of candidates[cell]) if (propagateDeep(cell, digit, grid, candidates) === null) return {
+			technique: "nishio",
+			placements: [],
+			eliminations: [{
+				cell,
+				digit
+			}],
+			patternCells: [cell]
+		};
+	}
+	return null;
+};
+const findNishioNet = (grid, candidates) => {
+	for (let cell = 0; cell < 81; cell++) {
+		if (candidates[cell].size < 2) continue;
+		for (const digit of candidates[cell]) if (propagateDeep(cell, digit, grid, candidates) === null) return {
+			technique: "nishioNet",
+			placements: [],
+			eliminations: [{
+				cell,
+				digit
+			}],
+			patternCells: [cell]
+		};
+	}
+	return null;
+};
+const findCellRegionForcingChain = (grid, candidates) => {
+	for (let cell = 0; cell < 81; cell++) {
+		if (candidates[cell].size < 2) continue;
+		const branches = [];
+		for (const digit of candidates[cell]) branches.push(propagateDeep(cell, digit, grid, candidates));
+		if (branches.some((b) => b === null)) continue;
+		const validBranches = branches;
+		for (let c = 0; c < 81; c++) {
+			if (grid[c] !== 0) continue;
+			if (validBranches.every((b) => b.grid[c] !== 0 && b.grid[c] === validBranches[0].grid[c]) && validBranches[0].grid[c] !== 0) return {
+				technique: "cellRegionForcingChain",
+				placements: [{
+					cell: c,
+					digit: validBranches[0].grid[c]
+				}],
+				eliminations: [],
+				patternCells: [cell, c]
+			};
+			for (const digit of candidates[c]) if (validBranches.every((b) => !b.candidates[c].has(digit))) return {
+				technique: "cellRegionForcingChain",
+				placements: [],
+				eliminations: [{
+					cell: c,
+					digit
+				}],
+				patternCells: [cell, c]
+			};
+		}
+	}
+	for (const house of HOUSES) for (let digit = 1; digit <= 9; digit++) {
+		const cells = house.filter((c) => candidates[c].has(digit));
+		if (cells.length < 2) continue;
+		const branches = cells.map((c) => propagateDeep(c, digit, grid, candidates));
+		if (branches.some((b) => b === null)) continue;
+		const validBranches = branches;
+		for (let c = 0; c < 81; c++) {
+			if (grid[c] !== 0) continue;
+			if (validBranches.every((b) => b.grid[c] !== 0 && b.grid[c] === validBranches[0].grid[c]) && validBranches[0].grid[c] !== 0) return {
+				technique: "cellRegionForcingChain",
+				placements: [{
+					cell: c,
+					digit: validBranches[0].grid[c]
+				}],
+				eliminations: [],
+				patternCells: [...cells, c]
+			};
+			for (const d of candidates[c]) if (validBranches.every((b) => !b.candidates[c].has(d))) return {
+				technique: "cellRegionForcingChain",
+				placements: [],
+				eliminations: [{
+					cell: c,
+					digit: d
+				}],
+				patternCells: [...cells, c]
+			};
+		}
+	}
+	return null;
+};
+const findCellRegionForcingNet = (grid, candidates) => {
+	for (let cell = 0; cell < 81; cell++) {
+		if (candidates[cell].size < 3) continue;
+		const branches = [];
+		for (const digit of candidates[cell]) branches.push(propagateDeep(cell, digit, grid, candidates));
+		if (branches.some((b) => b === null)) continue;
+		const validBranches = branches;
+		for (let c = 0; c < 81; c++) {
+			if (grid[c] !== 0) continue;
+			if (validBranches.every((b) => b.grid[c] !== 0 && b.grid[c] === validBranches[0].grid[c]) && validBranches[0].grid[c] !== 0) return {
+				technique: "cellRegionForcingNet",
+				placements: [{
+					cell: c,
+					digit: validBranches[0].grid[c]
+				}],
+				eliminations: [],
+				patternCells: [cell, c]
+			};
+			for (const digit of candidates[c]) if (validBranches.every((b) => !b.candidates[c].has(digit))) return {
+				technique: "cellRegionForcingNet",
+				placements: [],
+				eliminations: [{
+					cell: c,
+					digit
+				}],
+				patternCells: [cell, c]
+			};
+		}
+	}
+	return null;
+};
+const findForcingChain = (grid, candidates) => {
+	for (let cell = 0; cell < 81; cell++) {
+		if (candidates[cell].size !== 2) continue;
+		const [d1, d2] = [...candidates[cell]];
+		const r1 = propagateDeep(cell, d1, grid, candidates);
+		const r2 = propagateDeep(cell, d2, grid, candidates);
+		if (!r1 || !r2) continue;
+		for (let c = 0; c < 81; c++) {
+			if (grid[c] !== 0) continue;
+			if (r1.grid[c] !== 0 && r1.grid[c] === r2.grid[c]) return {
+				technique: "forcingChain",
+				placements: [{
+					cell: c,
+					digit: r1.grid[c]
+				}],
+				eliminations: [],
+				patternCells: [cell, c]
+			};
+			for (const digit of candidates[c]) if (!r1.candidates[c].has(digit) && !r2.candidates[c].has(digit)) return {
+				technique: "forcingChain",
+				placements: [],
+				eliminations: [{
+					cell: c,
+					digit
+				}],
+				patternCells: [cell, c]
+			};
+		}
+	}
+	return null;
+};
+const findAlmostLockedSets = (candidates) => {
+	const als = [];
+	for (let sector = 0; sector < 27; sector++) {
+		const emptyCells = (sector < 9 ? ROW_HOUSES[sector] : sector < 18 ? COL_HOUSES[sector - 9] : BOX_HOUSES[sector - 18]).filter((c) => candidates[c].size > 0);
+		if (emptyCells.length === 0) continue;
+		for (let size = 1; size <= Math.min(8, emptyCells.length); size++) for (const cellCombo of combinations(emptyCells, size)) {
+			const allDigits = /* @__PURE__ */ new Set();
+			for (const cell of cellCombo) for (const d of candidates[cell]) allDigits.add(d);
+			if (allDigits.size === size + 1) als.push({
+				cells: new Set(cellCombo),
+				digits: allDigits,
+				sector
+			});
+		}
+	}
+	return als;
+};
+const cellSectors = (cell) => {
+	const row = cellRow(cell);
+	const col = cellCol(cell);
+	const box = cellBox(cell);
+	return new Set([
+		row,
+		col + 9,
+		box + 18
+	]);
+};
+const getRestrictedCommon = (als1, als2, candidates) => {
+	const rc = /* @__PURE__ */ new Set();
+	for (const digit of als1.digits) {
+		if (!als2.digits.has(digit)) continue;
+		const als1Cells = Array.from(als1.cells).filter((c) => candidates[c].has(digit));
+		const als2Cells = Array.from(als2.cells).filter((c) => candidates[c].has(digit));
+		if (als1Cells.some((c) => als2.cells.has(c))) continue;
+		if (als1Cells.length === 0 || als2Cells.length === 0) continue;
+		const allCells = [...als1Cells, ...als2Cells];
+		let commonSectors = new Set(Array.from({ length: 27 }, (_, i) => i));
+		for (const c of allCells) {
+			const cs = cellSectors(c);
+			commonSectors = new Set([...commonSectors].filter((s) => cs.has(s)));
+		}
+		if (commonSectors.size > 0 && commonSectors.size < 3) rc.add(digit);
+	}
+	return rc;
+};
+const findALSXZ = (candidates) => {
+	const alsList = findAlmostLockedSets(candidates);
+	for (let i = 0; i < alsList.length; i++) for (let j = i + 1; j < alsList.length; j++) {
+		const als1 = alsList[i];
+		const als2 = alsList[j];
+		if (Array.from(als1.cells).filter((c) => als2.cells.has(c)).length > 0) continue;
+		const commonDigits = Array.from(als1.digits).filter((d) => als2.digits.has(d));
+		if (commonDigits.length < 2) continue;
+		const rc = getRestrictedCommon(als1, als2, candidates);
+		if (rc.size !== 1) continue;
+		const restrictedDigit = Array.from(rc)[0];
+		const xDigits = commonDigits.filter((d) => d !== restrictedDigit);
+		for (const xDigit of xDigits) {
+			const eliminations = [];
+			const als1XCells = Array.from(als1.cells).filter((c) => candidates[c].has(xDigit));
+			const als2XCells = Array.from(als2.cells).filter((c) => candidates[c].has(xDigit));
+			for (let cell = 0; cell < 81; cell++) {
+				if (als1.cells.has(cell) || als2.cells.has(cell)) continue;
+				if (!candidates[cell].has(xDigit)) continue;
+				const seesAll1 = als1XCells.every((c) => PEERS[cell].has(c));
+				const seesAll2 = als2XCells.every((c) => PEERS[cell].has(c));
+				if (seesAll1 && seesAll2) eliminations.push({
+					cell,
+					digit: xDigit
+				});
+			}
+			if (eliminations.length > 0) return {
+				technique: "alsXZ",
+				placements: [],
+				eliminations,
+				patternCells: [...als1.cells, ...als2.cells],
+				als1Cells: Array.from(als1.cells),
+				als2Cells: Array.from(als2.cells)
+			};
+		}
+	}
+	return null;
+};
+const findSueDeCoq = (candidates) => {
+	const alsList = findAlmostLockedSets(candidates);
+	for (let box = 0; box < 9; box++) {
+		const boxCells = BOX_HOUSES[box];
+		for (let lineType = 0; lineType < 2; lineType++) {
+			const lineHouses = lineType === 0 ? ROW_HOUSES : COL_HOUSES;
+			for (let lineIdx = 0; lineIdx < 9; lineIdx++) {
+				const lineCells = lineHouses[lineIdx];
+				const intersection = boxCells.filter((c) => lineCells.includes(c) && candidates[c].size > 0);
+				if (intersection.length < 2 || intersection.length > 3) continue;
+				for (const stemCells of intersection.length === 2 ? [intersection] : [...combinations(intersection, 2), intersection]) {
+					const stemDigits = /* @__PURE__ */ new Set();
+					for (const c of stemCells) for (const d of candidates[c]) stemDigits.add(d);
+					if (stemDigits.size <= stemCells.length) continue;
+					const lineRest = lineCells.filter((c) => !boxCells.includes(c) && candidates[c].size > 0);
+					const boxRest = boxCells.filter((c) => !lineCells.includes(c) && candidates[c].size > 0);
+					const lineALSCandidates = alsList.filter((als) => {
+						if (!Array.from(als.cells).every((c) => lineRest.includes(c))) return false;
+						return Array.from(als.digits).filter((d) => stemDigits.has(d)).length >= 1;
+					});
+					const boxALSCandidates = alsList.filter((als) => {
+						if (!Array.from(als.cells).every((c) => boxRest.includes(c))) return false;
+						return Array.from(als.digits).filter((d) => stemDigits.has(d)).length >= 1;
+					});
+					for (const lineALS of lineALSCandidates) for (const boxALS of boxALSCandidates) {
+						const allCells = new Set([
+							...stemCells,
+							...lineALS.cells,
+							...boxALS.cells
+						]);
+						const allDigits = /* @__PURE__ */ new Set();
+						for (const c of allCells) for (const d of candidates[c]) allDigits.add(d);
+						if (allCells.size !== allDigits.size) continue;
+						if (!Array.from(allDigits).every((digit) => {
+							const cellsWithDigit = Array.from(allCells).filter((c) => candidates[c].has(digit));
+							return HOUSES.some((house) => cellsWithDigit.every((c) => house.includes(c)));
+						})) continue;
+						const eliminations = [];
+						for (const digit of allDigits) {
+							const cellsWithDigit = Array.from(allCells).filter((c) => candidates[c].has(digit));
+							for (let cell = 0; cell < 81; cell++) {
+								if (allCells.has(cell)) continue;
+								if (!candidates[cell].has(digit)) continue;
+								if (cellsWithDigit.every((c) => PEERS[cell].has(c))) eliminations.push({
+									cell,
+									digit
+								});
+							}
+						}
+						if (eliminations.length > 0) return {
+							technique: "sueDeCoq",
+							placements: [],
+							eliminations,
+							patternCells: Array.from(allCells)
+						};
+					}
+				}
+			}
+		}
+	}
+	return null;
+};
+const findDeathBlossom = (candidates, grid) => {
+	const alsList = findAlmostLockedSets(candidates);
+	for (let stemCell = 0; stemCell < 81; stemCell++) {
+		const stemCands = candidates[stemCell];
+		if (stemCands.size < 2 || stemCands.size > 4) continue;
+		const petalMap = /* @__PURE__ */ new Map();
+		for (const digit of stemCands) {
+			const petals = alsList.filter((als) => {
+				if (als.cells.has(stemCell)) return false;
+				if (!als.digits.has(digit)) return false;
+				return Array.from(als.cells).filter((c) => candidates[c].has(digit)).every((c) => PEERS[stemCell].has(c));
+			});
+			if (petals.length === 0) break;
+			petalMap.set(digit, petals);
+		}
+		if (petalMap.size !== stemCands.size) continue;
+		const stemDigits = Array.from(stemCands);
+		const petalArrays = stemDigits.map((d) => petalMap.get(d));
+		const search = (idx, usedCells, chosen) => {
+			if (idx === stemDigits.length) {
+				const allCells = new Set([stemCell, ...usedCells]);
+				const nonStemDigits = /* @__PURE__ */ new Set();
+				for (let pi = 0; pi < chosen.length; pi++) for (const d of chosen[pi].digits) if (!stemCands.has(d)) nonStemDigits.add(d);
+				const eliminations = [];
+				for (const digit of nonStemDigits) {
+					const allCellsWithDigit = [];
+					for (const als of chosen) {
+						if (!als.digits.has(digit)) continue;
+						for (const c of als.cells) if (candidates[c].has(digit)) allCellsWithDigit.push(c);
+					}
+					if (allCellsWithDigit.length === 0) continue;
+					for (let cell = 0; cell < 81; cell++) {
+						if (allCells.has(cell)) continue;
+						if (!candidates[cell].has(digit)) continue;
+						if (allCellsWithDigit.every((c) => PEERS[cell].has(c))) eliminations.push({
+							cell,
+							digit
+						});
+					}
+				}
+				const validated = grid === void 0 ? eliminations : eliminations.filter(({ cell, digit }) => propagateDeep(cell, digit, grid, candidates) === null);
+				if (validated.length > 0) return {
+					technique: "deathBlossom",
+					placements: [],
+					eliminations: validated,
+					patternCells: Array.from(allCells),
+					stemCell,
+					petalCells: chosen.map((als) => Array.from(als.cells))
+				};
+				return null;
+			}
+			for (const als of petalArrays[idx]) {
+				if (Array.from(als.cells).some((c) => usedCells.has(c))) continue;
+				const nextUsed = new Set([...usedCells, ...als.cells]);
+				const result = search(idx + 1, nextUsed, [...chosen, als]);
+				if (result) return result;
+			}
+			return null;
+		};
+		const result = search(0, /* @__PURE__ */ new Set(), []);
+		if (result) return result;
+	}
+	return null;
+};
+const applyHint = (grid, candidates, hint) => {
+	const newGrid = [...grid];
+	const newCandidates = candidates.map((s) => new Set(s));
+	for (const { cell, digit } of hint.placements) {
+		newGrid[cell] = digit;
+		newCandidates[cell] = /* @__PURE__ */ new Set();
+		for (const peer of PEERS[cell]) newCandidates[peer].delete(digit);
+	}
+	for (const { cell, digit } of hint.eliminations) newCandidates[cell].delete(digit);
+	return {
+		grid: newGrid,
+		candidates: newCandidates
+	};
+};
+const findHint = (grid, candidates) => withNotation(findNakedSingle(candidates) ?? findHiddenSingle(candidates, BOX_HOUSES, "hiddenSingleBox") ?? findHiddenSingle(candidates, ROW_HOUSES, "hiddenSingleRow") ?? findHiddenSingle(candidates, COL_HOUSES, "hiddenSingleCol") ?? findHiddenGroup(candidates, 2) ?? findLockedCandidates(candidates) ?? findHiddenGroup(candidates, 3) ?? findHiddenGroup(candidates, 4) ?? findNakedGroup(candidates, 2) ?? findNakedGroup(candidates, 3) ?? findNakedGroup(candidates, 4) ?? findFish(candidates, 2) ?? findFish(candidates, 3) ?? findSkyscraper(candidates) ?? findTwoStringKite(candidates) ?? findYWing(candidates) ?? findXYZWing(candidates) ?? findFinnedFish(candidates, 2) ?? findWWing(candidates) ?? findEmptyRectangle(candidates) ?? findUniqueRectangle(grid, candidates) ?? findFinnedFish(candidates, 3) ?? findFish(candidates, 4) ?? findBUG(candidates) ?? findFinnedFish(candidates, 4) ?? findXYChain(candidates) ?? findAIC(candidates, grid) ?? findGroupedAIC(candidates, grid) ?? findALSXZ(candidates) ?? findSueDeCoq(candidates) ?? findDeathBlossom(candidates, grid) ?? findNishio(grid, candidates) ?? findNishioNet(grid, candidates) ?? findCellRegionForcingChain(grid, candidates) ?? findCellRegionForcingNet(grid, candidates) ?? findForcingChain(grid, candidates));
+const humanSolve = (initialGrid) => {
+	let grid = [...initialGrid];
+	let candidates = buildCandidates(grid);
+	const steps = [];
+	while (true) {
+		const hint = findHint(grid, candidates);
+		if (!hint) break;
+		const next = applyHint(grid, candidates, hint);
+		grid = next.grid;
+		candidates = next.candidates;
+		steps.push(hint);
+	}
+	return {
+		grid,
+		candidates,
+		steps
+	};
+};
+//#endregion
+exports.applyHint = applyHint;
+exports.buildCandidates = buildCandidates;
+exports.findHint = findHint;
+exports.gridToPuzzle = gridToPuzzle;
+exports.humanSolve = humanSolve;
+exports.isGridInvalid = isGridInvalid;
+exports.puzzleToGrid = puzzleToGrid;