Update space

metadata.json

@@ -0,0 +1,46 @@
+{
+  "id": "af4a4e2d-dcd3-4f48-9ccb-a3345ff27cba",
+  "session_id": "c509d9f7-c51e-479c-b21a-49549dee6b5f",
+  "topic": "에이전트들은 1차 버전을 감정형 연출이 아닌 설명 가능한 학습형 수도쿠로 제한하고, solver 로그를 중심으로 hint-engine·difficulty-analyzer·gener",
+  "files": [
+    "index.html",
+    "style.css",
+    "script.js"
+  ],
+  "invariants": {
+    "file_set": [
+      "index.html",
+      "script.js",
+      "style.css"
+    ],
+    "keybinding_tokens": [
+      "ArrowUp",
+      "ArrowDown",
+      "ArrowLeft",
+      "ArrowRight"
+    ],
+    "ui_text_tokens": [
+      "배우면서 푸는 수도쿠",
+      "Explainable Sudoku MVP",
+      "정답만 맞히는 대신, 다음 한 수가 왜 성립하는지 바로 설명해 주는 학습형 수도쿠입니다.",
+      "새 퍼즐",
+      "힌트 보기",
+      "힌트 적용",
+      "오답 확인",
+      "초기화",
+      "현재 퍼즐",
+      "랜덤 변형 퍼즐을 준비하는 중입니다.",
+      "입문",
+      "퍼즐을 준비하는 중입니다.",
+      "방향키로 칸을 이동하고 숫자 1부터 9까지 입력할 수 있습니다.",
+      "학습 힌트",
+      "힌트 보기를 누르면 다음 논리 단계를 설명합니다.",
+      "분석 요약",
+      "채워진 칸",
+      "남은 칸",
+      "다음 기술",
+      "대기 중"
+    ]
+  },
+  "created_at": "2026-03-09T01:59:04.799921+00:00"
+}

script.js

@@ -0,0 +1,822 @@
+document.addEventListener('DOMContentLoaded', () => {
+  const BASE_PUZZLE = '530070000600195000098000060800060003400803001700020006060000280000419005000080079';
+  const TECHNIQUE_LABELS = {
+    'naked-single': '단일 후보',
+    'hidden-single-row': '행 숨은 싱글',
+    'hidden-single-col': '열 숨은 싱글',
+    'hidden-single-box': '박스 숨은 싱글'
+  };
+
+  const dom = {
+    board: document.getElementById('sudoku-board'),
+    newGameBtn: document.getElementById('new-game-btn'),
+    hintBtn: document.getElementById('hint-btn'),
+    applyHintBtn: document.getElementById('apply-hint-btn'),
+    checkBtn: document.getElementById('check-btn'),
+    resetBtn: document.getElementById('reset-btn'),
+    hintMessage: document.getElementById('hint-message'),
+    gameStatus: document.getElementById('game-status'),
+    puzzleMeta: document.getElementById('puzzle-meta'),
+    difficultyBadge: document.getElementById('difficulty-badge'),
+    filledCount: document.getElementById('filled-count'),
+    remainingCount: document.getElementById('remaining-count'),
+    nextTechnique: document.getElementById('next-technique'),
+    analysisSummary: document.getElementById('analysis-summary'),
+    logList: document.getElementById('log-list')
+  };
+
+  const state = {
+    board: [],
+    initial: [],
+    solution: [],
+    analysis: null,
+    pendingHint: null,
+    selected: null,
+    showMistakes: false,
+    hintMessage: '힌트 보기를 누르면 다음 논리 단계를 설명합니다.',
+    gameCount: 0,
+    learningLog: [],
+    cells: []
+  };
+
+  createBoard();
+  bindEvents();
+  startNewGame();
+
+  function bindEvents() {
+    dom.newGameBtn.addEventListener('click', startNewGame);
+    dom.hintBtn.addEventListener('click', requestHint);
+    dom.applyHintBtn.addEventListener('click', applyHint);
+    dom.checkBtn.addEventListener('click', toggleMistakes);
+    dom.resetBtn.addEventListener('click', resetBoard);
+  }
+
+  function createBoard() {
+    const fragment = document.createDocumentFragment();
+
+    for (let row = 0; row < 9; row += 1) {
+      const rowCells = [];
+      for (let col = 0; col < 9; col += 1) {
+        const input = document.createElement('input');
+        input.type = 'text';
+        input.className = 'cell';
+        input.maxLength = 1;
+        input.inputMode = 'numeric';
+        input.autocomplete = 'off';
+        input.pattern = '[1-9]';
+        input.spellcheck = false;
+        input.setAttribute('aria-describedby', 'sudoku-help');
+        input.dataset.row = String(row);
+        input.dataset.col = String(col);
+        input.setAttribute('role', 'gridcell');
+        input.setAttribute('aria-rowindex', String(row + 1));
+        input.setAttribute('aria-colindex', String(col + 1));
+
+        if (col === 2 || col === 5) {
+          input.classList.add('edge-right');
+        }
+        if (row === 2 || row === 5) {
+          input.classList.add('edge-bottom');
+        }
+
+        input.addEventListener('focus', onCellFocus);
+        input.addEventListener('click', onCellFocus);
+        input.addEventListener('input', onCellInput);
+        input.addEventListener('keydown', onCellKeyDown);
+
+        rowCells.push(input);
+        fragment.appendChild(input);
+      }
+      state.cells.push(rowCells);
+    }
+
+    dom.board.appendChild(fragment);
+  }
+
+  function startNewGame() {
+    const initial = generatePuzzle();
+    const solution = solveBoard(initial);
+
+    if (!solution) {
+      setStatus('퍼즐 생성에 실패했습니다. 새로고침 후 다시 시도하세요.');
+      return;
+    }
+
+    state.initial = cloneBoard(initial);
+    state.board = cloneBoard(initial);
+    state.solution = solution;
+    state.analysis = analyzePuzzle(initial);
+    state.pendingHint = null;
+    state.selected = findFirstEmpty(initial);
+    state.showMistakes = false;
+    state.hintMessage = '힌트 보기를 누르면 다음 논리 단계를 설명합니다.';
+    state.gameCount += 1;
+    state.learningLog = [
+      {
+        kind: '분석',
+        message: describeAnalysis(state.analysis)
+      }
+    ];
+
+    dom.checkBtn.textContent = '오답 확인';
+    setStatus('새 퍼즐을 불러왔습니다.');
+    render();
+    focusSelectedCell();
+  }
+
+  function resetBoard() {
+    state.board = cloneBoard(state.initial);
+    state.pendingHint = null;
+    state.showMistakes = false;
+    state.selected = findFirstEmpty(state.initial);
+    state.hintMessage = '퍼즐을 초기 상태로 되돌렸습니다. 다시 논리로 풀어보세요.';
+    state.learningLog.unshift({ kind: '초기화', message: '입력한 값을 지우고 시작 상태로 돌아갔습니다.' });
+    state.learningLog = state.learningLog.slice(0, 8);
+    dom.checkBtn.textContent = '오답 확인';
+    setStatus('퍼즐을 초기화했습니다.');
+    render();
+    focusSelectedCell();
+  }
+
+  function requestHint() {
+    const conflicts = collectConflicts(state.board);
+    const wrongCells = collectWrongCells(state.board, state.solution);
+
+    if (conflicts.size > 0) {
+      state.pendingHint = null;
+      state.hintMessage = '같은 행, 열 또는 박스에 중복된 숫자가 있습니다. 충돌을 먼저 정리하세요.';
+      setStatus('규칙 충돌이 있어 힌트를 중단했습니다.');
+      render();
+      return;
+    }
+
+    if (wrongCells.length > 0) {
+      state.pendingHint = null;
+      state.showMistakes = true;
+      dom.checkBtn.textContent = '오답 숨기기';
+      state.hintMessage = '정답과 다른 칸이 있어 힌트를 멈췄습니다. 붉은 표시를 먼저 고쳐보세요.';
+      setStatus('오답이 있어 힌트를 중단했습니다.');
+      render();
+      return;
+    }
+
+    if (isSolved(state.board)) {
+      state.pendingHint = null;
+      state.hintMessage = '이미 퍼즐을 모두 해결했습니다. 새 퍼즐을 시작할 수 있습니다.';
+      setStatus('퍼즐이 이미 완성되어 있습니다.');
+      render();
+      return;
+    }
+
+    const step = findNextLogicalStep(state.board);
+
+    if (!step) {
+      state.pendingHint = null;
+      state.hintMessage = '현재 MVP 규칙(단일 후보, 숨은 싱글)로는 다음 단계를 찾지 못했습니다.';
+      setStatus('추가 규칙이 필요한 구간입니다.');
+      render();
+      return;
+    }
+
+    state.pendingHint = step;
+    state.selected = { row: step.row, col: step.col };
+    state.hintMessage = `${TECHNIQUE_LABELS[step.type]}: ${step.detail}`;
+    recordLog('힌트', `${cellRef(step.row, step.col)} = ${step.value} · ${TECHNIQUE_LABELS[step.type]}`);
+    setStatus('다음 논리 단계를 찾았습니다.');
+    render();
+    focusSelectedCell();
+  }
+
+  function applyHint() {
+    if (!state.pendingHint) {
+      requestHint();
+      return;
+    }
+
+    const { row, col, value, type } = state.pendingHint;
+    state.board[row][col] = value;
+    state.selected = { row, col };
+    state.hintMessage = `${cellRef(row, col)}에 ${value}를 넣었습니다. 다음 단계가 필요하면 다시 힌트를 요청하세요.`;
+    recordLog('적용', `${cellRef(row, col)} = ${value} · ${TECHNIQUE_LABELS[type]}`);
+    state.pendingHint = null;
+
+    if (boardsEqual(state.board, state.solution)) {
+      state.hintMessage = '퍼즐을 해결했습니다. 새 퍼즐로 다시 시작할 수 있습니다.';
+      setStatus('완성했습니다. 모든 칸이 맞습니다.');
+      recordLog('완료', '모든 칸을 올바르게 채웠습니다.');
+    } else {
+      setStatus('힌트를 적용했습니다.');
+    }
+
+    render();
+    focusSelectedCell();
+  }
+
+  function toggleMistakes() {
+    state.showMistakes = !state.showMistakes;
+    dom.checkBtn.textContent = state.showMistakes ? '오답 숨기기' : '오답 확인';
+    setStatus(state.showMistakes ? '오답 표시를 켰습니다.' : '오답 표시를 껐습니다.');
+    render();
+  }
+
+  function onCellFocus(event) {
+    const row = Number(event.target.dataset.row);
+    const col = Number(event.target.dataset.col);
+    state.selected = { row, col };
+    renderBoard();
+  }
+
+  function onCellInput(event) {
+    const input = event.target;
+    const row = Number(input.dataset.row);
+    const col = Number(input.dataset.col);
+    const previousValue = state.board[row][col];
+
+    if (state.initial[row][col] !== 0) {
+      input.value = String(state.initial[row][col]);
+      return;
+    }
+
+    const raw = input.value.replace(/[^1-9]/g, '').slice(-1);
+    input.value = raw;
+    state.board[row][col] = raw ? Number(raw) : 0;
+    state.pendingHint = null;
+    state.selected = { row, col };
+    const conflicts = collectConflicts(state.board);
+    const wrongCells = collectWrongCells(state.board, state.solution);
+
+    if (boardsEqual(state.board, state.solution)) {
+      state.hintMessage = '퍼즐을 해결했습니다. 새 퍼즐로 다시 시작할 수 있습니다.';
+      setStatus('완성했습니다. 모든 칸이 맞습니다.');
+      recordLog('완료', '모든 칸을 올바르게 채웠습니다.');
+    } else if (!raw && previousValue !== 0) {
+      setStatus('칸을 비웠습니다.');
+    } else if (!raw) {
+      setStatus('1부터 9까지의 숫자만 입력할 수 있습니다.');
+    } else if (conflicts.size > 0) {
+      setStatus('규칙 충돌이 있습니다.');
+    } else if (wrongCells.length > 0 && countFilled(state.board) === 81) {
+      setStatus('오답이 있습니다. 오답 확인으로 점검하세요.');
+    } else {
+      const filled = countFilled(state.board);
+      setStatus(`${filled}칸을 채웠습니다.`);
+    }
+
+    render();
+  }
+
+  function onCellKeyDown(event) {
+    const row = Number(event.target.dataset.row);
+    const col = Number(event.target.dataset.col);
+    let nextRow = row;
+    let nextCol = col;
+
+    if (event.key === 'ArrowUp') {
+      nextRow = Math.max(0, row - 1);
+    } else if (event.key === 'ArrowDown') {
+      nextRow = Math.min(8, row + 1);
+    } else if (event.key === 'ArrowLeft') {
+      nextCol = Math.max(0, col - 1);
+    } else if (event.key === 'ArrowRight') {
+      nextCol = Math.min(8, col + 1);
+    } else if (event.key === 'Backspace' || event.key === 'Delete' || event.key === 'Escape' || event.key === '0' || event.key === ' ') {
+      if (state.initial[row][col] === 0) {
+        state.board[row][col] = 0;
+        state.pendingHint = null;
+        state.selected = { row, col };
+        setStatus('칸을 비웠습니다.');
+        render();
+      }
+      event.preventDefault();
+      return;
+    } else {
+      return;
+    }
+
+    event.preventDefault();
+    state.selected = { row: nextRow, col: nextCol };
+    focusSelectedCell();
+    renderBoard();
+  }
+
+  function render() {
+    renderBoard();
+    renderSidebar();
+    updateActionButtons();
+  }
+
+  function updateActionButtons() {
+    const isComplete = boardsEqual(state.board, state.solution);
+
+    dom.hintBtn.disabled = isComplete;
+    dom.applyHintBtn.disabled = !state.pendingHint || isComplete;
+    dom.resetBtn.disabled = boardsEqual(state.board, state.initial);
+    dom.checkBtn.textContent = state.showMistakes ? '오답 숨기기' : '오답 확인';
+    dom.checkBtn.setAttribute('aria-pressed', String(state.showMistakes));
+  }
+
+  function renderBoard() {
+    const conflicts = collectConflicts(state.board);
+    const wrongCells = state.showMistakes ? new Set(collectWrongCells(state.board, state.solution)) : new Set();
+
+    for (let row = 0; row < 9; row += 1) {
+      for (let col = 0; col < 9; col += 1) {
+        const input = state.cells[row][col];
+        const value = state.board[row][col];
+        const key = toKey(row, col);
+        const isGiven = state.initial[row][col] !== 0;
+        const isSelected = Boolean(state.selected && state.selected.row === row && state.selected.col === col);
+        const isHint = Boolean(state.pendingHint && state.pendingHint.row === row && state.pendingHint.col === col);
+        const hasConflict = conflicts.has(key);
+        const hasMistake = wrongCells.has(key);
+
+        input.value = value === 0 ? '' : String(value);
+        input.readOnly = isGiven;
+        input.classList.toggle('is-given', isGiven);
+        input.classList.toggle('is-selected', isSelected);
+        input.classList.toggle('is-hint', isHint);
+        input.classList.toggle('is-conflict', hasConflict);
+        input.classList.toggle('is-mistake', hasMistake);
+        input.setAttribute('aria-label', buildCellLabel(row, col, value, isGiven));
+        input.setAttribute('aria-selected', String(isSelected));
+        input.setAttribute('aria-invalid', String(hasConflict || hasMistake));
+        input.setAttribute('aria-readonly', String(isGiven));
+      }
+    }
+  }
+
+  function renderSidebar() {
+    const filled = countFilled(state.board);
+    const conflicts = collectConflicts(state.board);
+    const wrongCells = collectWrongCells(state.board, state.solution);
+    const isComplete = boardsEqual(state.board, state.solution);
+    let nextTechniqueLabel = '대기 중';
+
+    if (isComplete) {
+      nextTechniqueLabel = '완료';
+    } else if (conflicts.size > 0) {
+      nextTechniqueLabel = '충돌 정리 필요';
+    } else if (wrongCells.length > 0) {
+      nextTechniqueLabel = '오답 수정 필요';
+    } else {
+      const nextStep = findNextLogicalStep(state.board);
+      nextTechniqueLabel = nextStep ? TECHNIQUE_LABELS[nextStep.type] : '현재 규칙으로 찾지 못함';
+    }
+
+    dom.puzzleMeta.textContent = `${state.gameCount}번째 퍼즐 · 랜덤 변형 학습 퍼즐`;
+    dom.difficultyBadge.textContent = state.analysis.difficulty;
+    dom.hintMessage.textContent = state.hintMessage;
+    dom.filledCount.textContent = String(filled);
+    dom.remainingCount.textContent = String(81 - filled);
+    dom.nextTechnique.textContent = nextTechniqueLabel;
+    dom.analysisSummary.textContent = describeAnalysis(state.analysis);
+
+    dom.logList.innerHTML = '';
+    const items = state.learningLog.length > 0 ? state.learningLog : [{ kind: '안내', message: '힌트 로그가 여기에 표시됩니다.' }];
+    items.slice(0, 8).forEach((item) => {
+      const li = document.createElement('li');
+      li.textContent = `${item.kind} · ${item.message}`;
+      dom.logList.appendChild(li);
+    });
+  }
+
+  function setStatus(message) {
+    dom.gameStatus.textContent = message;
+  }
+
+  function recordLog(kind, message) {
+    const latest = `${kind}:${message}`;
+    const exists = state.learningLog.some((entry) => `${entry.kind}:${entry.message}` === latest);
+    if (!exists) {
+      state.learningLog.unshift({ kind, message });
+      state.learningLog = state.learningLog.slice(0, 8);
+    }
+  }
+
+  function buildCellLabel(row, col, value, isGiven) {
+    if (isGiven) {
+      return `${row + 1}행 ${col + 1}열, 고정 숫자 ${value}`;
+    }
+    if (value === 0) {
+      return `${row + 1}행 ${col + 1}열, 빈칸`;
+    }
+    return `${row + 1}행 ${col + 1}열, 입력값 ${value}`;
+  }
+
+  function focusSelectedCell() {
+    if (!state.selected) {
+      return;
+    }
+    const cell = state.cells[state.selected.row][state.selected.col];
+    if (cell) {
+      cell.focus();
+    }
+  }
+
+  function analyzePuzzle(board) {
+    const solverResult = buildSolverLog(board);
+    const counts = solverResult.steps.reduce((acc, step) => {
+      acc[step.type] = (acc[step.type] || 0) + 1;
+      return acc;
+    }, {});
+
+    return {
+      steps: solverResult.steps,
+      solved: solverResult.solved,
+      counts,
+      difficulty: classifyDifficulty(solverResult.solved, counts)
+    };
+  }
+
+  function describeAnalysis(analysis) {
+    const countSummary = formatTechniqueCounts(analysis.counts);
+    if (analysis.solved) {
+      return `${analysis.steps.length}단계 논리 풀이 · ${countSummary}`;
+    }
+    return `일부만 논리 풀이 가능 · ${countSummary}`;
+  }
+
+  function formatTechniqueCounts(counts) {
+    const parts = [];
+    if (counts['naked-single']) {
+      parts.push(`단일 후보 ${counts['naked-single']}회`);
+    }
+    if (counts['hidden-single-row']) {
+      parts.push(`행 숨은 싱글 ${counts['hidden-single-row']}회`);
+    }
+    if (counts['hidden-single-col']) {
+      parts.push(`열 숨은 싱글 ${counts['hidden-single-col']}회`);
+    }
+    if (counts['hidden-single-box']) {
+      parts.push(`박스 숨은 싱글 ${counts['hidden-single-box']}회`);
+    }
+    return parts.length > 0 ? parts.join(', ') : '기본 규칙 분석 없음';
+  }
+
+  function classifyDifficulty(solved, counts) {
+    const hiddenCount = (counts['hidden-single-row'] || 0) + (counts['hidden-single-col'] || 0) + (counts['hidden-single-box'] || 0);
+    if (!solved) {
+      return '연습';
+    }
+    if (hiddenCount === 0) {
+      return '입문';
+    }
+    if (hiddenCount <= 8) {
+      return '초급';
+    }
+    return '중급';
+  }
+
+  function buildSolverLog(board) {
+    const working = cloneBoard(board);
+    const steps = [];
+    let guard = 0;
+
+    while (guard < 100) {
+      if (isSolved(working)) {
+        return { solved: true, steps };
+      }
+
+      const next = findNextLogicalStep(working);
+      if (!next) {
+        break;
+      }
+
+      working[next.row][next.col] = next.value;
+      steps.push(next);
+      guard += 1;
+    }
+
+    return { solved: isSolved(working), steps };
+  }
+
+  function findNextLogicalStep(board) {
+    const candidates = [];
+
+    for (let row = 0; row < 9; row += 1) {
+      candidates[row] = [];
+      for (let col = 0; col < 9; col += 1) {
+        candidates[row][col] = board[row][col] === 0 ? getCandidates(board, row, col) : [];
+      }
+    }
+
+    for (let row = 0; row < 9; row += 1) {
+      for (let col = 0; col < 9; col += 1) {
+        if (board[row][col] !== 0) {
+          continue;
+        }
+        if (candidates[row][col].length === 1) {
+          const value = candidates[row][col][0];
+          return {
+            type: 'naked-single',
+            row,
+            col,
+            value,
+            detail: `${cellRef(row, col)}의 후보는 ${value} 하나뿐입니다. 행, 열, 박스에서 다른 숫자가 모두 제외됩니다.`
+          };
+        }
+      }
+    }
+
+    for (let row = 0; row < 9; row += 1) {
+      for (let value = 1; value <= 9; value += 1) {
+        const spots = [];
+        for (let col = 0; col < 9; col += 1) {
+          if (candidates[row][col].includes(value)) {
+            spots.push({ row, col });
+          }
+        }
+        if (spots.length === 1) {
+          return {
+            type: 'hidden-single-row',
+            row: spots[0].row,
+            col: spots[0].col,
+            value,
+            detail: `${row + 1}행에서 숫자 ${value}가 들어갈 수 있는 칸은 ${cellRef(spots[0].row, spots[0].col)} 하나뿐입니다.`
+          };
+        }
+      }
+    }
+
+    for (let col = 0; col < 9; col += 1) {
+      for (let value = 1; value <= 9; value += 1) {
+        const spots = [];
+        for (let row = 0; row < 9; row += 1) {
+          if (candidates[row][col].includes(value)) {
+            spots.push({ row, col });
+          }
+        }
+        if (spots.length === 1) {
+          return {
+            type: 'hidden-single-col',
+            row: spots[0].row,
+            col: spots[0].col,
+            value,
+            detail: `${col + 1}열에서 숫자 ${value}가 들어갈 수 있는 칸은 ${cellRef(spots[0].row, spots[0].col)} 하나뿐입니다.`
+          };
+        }
+      }
+    }
+
+    for (let box = 0; box < 9; box += 1) {
+      const startRow = Math.floor(box / 3) * 3;
+      const startCol = (box % 3) * 3;
+      for (let value = 1; value <= 9; value += 1) {
+        const spots = [];
+        for (let row = startRow; row < startRow + 3; row += 1) {
+          for (let col = startCol; col < startCol + 3; col += 1) {
+            if (candidates[row][col].includes(value)) {
+              spots.push({ row, col });
+            }
+          }
+        }
+        if (spots.length === 1) {
+          return {
+            type: 'hidden-single-box',
+            row: spots[0].row,
+            col: spots[0].col,
+            value,
+            detail: `${box + 1}번 박스에서 숫자 ${value}가 들어갈 수 있는 칸은 ${cellRef(spots[0].row, spots[0].col)} 하나뿐입니다.`
+          };
+        }
+      }
+    }
+
+    return null;
+  }
+
+  function generatePuzzle() {
+    let board = parseBoard(BASE_PUZZLE);
+    board = remapDigits(board);
+    board = shuffleRows(board);
+    board = shuffleCols(board);
+    if (Math.random() > 0.5) {
+      board = transpose(board);
+    }
+    return board;
+  }
+
+  function remapDigits(board) {
+    const digits = shuffle([1, 2, 3, 4, 5, 6, 7, 8, 9]);
+    const map = new Map();
+    for (let i = 1; i <= 9; i += 1) {
+      map.set(i, digits[i - 1]);
+    }
+    return board.map((row) => row.map((value) => (value === 0 ? 0 : map.get(value))));
+  }
+
+  function shuffleRows(board) {
+    const bands = shuffle([0, 1, 2]);
+    const order = [];
+    bands.forEach((band) => {
+      shuffle([0, 1, 2]).forEach((offset) => order.push(band * 3 + offset));
+    });
+    return order.map((rowIndex) => board[rowIndex].slice());
+  }
+
+  function shuffleCols(board) {
+    const stacks = shuffle([0, 1, 2]);
+    const order = [];
+    stacks.forEach((stack) => {
+      shuffle([0, 1, 2]).forEach((offset) => order.push(stack * 3 + offset));
+    });
+    return board.map((row) => order.map((colIndex) => row[colIndex]));
+  }
+
+  function transpose(board) {
+    return board[0].map((_, col) => board.map((row) => row[col]));
+  }
+
+  function shuffle(values) {
+    const copy = values.slice();
+    for (let i = copy.length - 1; i > 0; i -= 1) {
+      const j = Math.floor(Math.random() * (i + 1));
+      [copy[i], copy[j]] = [copy[j], copy[i]];
+    }
+    return copy;
+  }
+
+  function solveBoard(board) {
+    const working = cloneBoard(board);
+    return solveRecursive(working) ? working : null;
+  }
+
+  function solveRecursive(board) {
+    let bestCell = null;
+    let bestCandidates = null;
+
+    for (let row = 0; row < 9; row += 1) {
+      for (let col = 0; col < 9; col += 1) {
+        if (board[row][col] !== 0) {
+          continue;
+        }
+        const candidates = getCandidates(board, row, col);
+        if (candidates.length === 0) {
+          return false;
+        }
+        if (!bestCandidates || candidates.length < bestCandidates.length) {
+          bestCell = { row, col };
+          bestCandidates = candidates;
+        }
+      }
+    }
+
+    if (!bestCell) {
+      return true;
+    }
+
+    for (const value of bestCandidates) {
+      board[bestCell.row][bestCell.col] = value;
+      if (solveRecursive(board)) {
+        return true;
+      }
+    }
+
+    board[bestCell.row][bestCell.col] = 0;
+    return false;
+  }
+
+  function getCandidates(board, row, col) {
+    if (board[row][col] !== 0) {
+      return [];
+    }
+    const candidates = [];
+    for (let value = 1; value <= 9; value += 1) {
+      if (isValidPlacement(board, row, col, value)) {
+        candidates.push(value);
+      }
+    }
+    return candidates;
+  }
+
+  function isValidPlacement(board, row, col, value) {
+    for (let index = 0; index < 9; index += 1) {
+      if (board[row][index] === value) {
+        return false;
+      }
+      if (board[index][col] === value) {
+        return false;
+      }
+    }
+
+    const startRow = Math.floor(row / 3) * 3;
+    const startCol = Math.floor(col / 3) * 3;
+    for (let r = startRow; r < startRow + 3; r += 1) {
+      for (let c = startCol; c < startCol + 3; c += 1) {
+        if (board[r][c] === value) {
+          return false;
+        }
+      }
+    }
+    return true;
+  }
+
+  function collectConflicts(board) {
+    const conflicts = new Set();
+
+    for (let row = 0; row < 9; row += 1) {
+      markHouseConflicts(conflicts, Array.from({ length: 9 }, (_, col) => ({ row, col, value: board[row][col] })));
+    }
+    for (let col = 0; col < 9; col += 1) {
+      markHouseConflicts(conflicts, Array.from({ length: 9 }, (_, row) => ({ row, col, value: board[row][col] })));
+    }
+    for (let box = 0; box < 9; box += 1) {
+      const startRow = Math.floor(box / 3) * 3;
+      const startCol = (box % 3) * 3;
+      const cells = [];
+      for (let row = startRow; row < startRow + 3; row += 1) {
+        for (let col = startCol; col < startCol + 3; col += 1) {
+          cells.push({ row, col, value: board[row][col] });
+        }
+      }
+      markHouseConflicts(conflicts, cells);
+    }
+
+    return conflicts;
+  }
+
+  function markHouseConflicts(conflicts, cells) {
+    const buckets = new Map();
+    cells.forEach((cell) => {
+      if (cell.value === 0) {
+        return;
+      }
+      if (!buckets.has(cell.value)) {
+        buckets.set(cell.value, []);
+      }
+      buckets.get(cell.value).push(cell);
+    });
+
+    buckets.forEach((items) => {
+      if (items.length > 1) {
+        items.forEach((cell) => conflicts.add(toKey(cell.row, cell.col)));
+      }
+    });
+  }
+
+  function collectWrongCells(board, solution) {
+    const wrong = [];
+    for (let row = 0; row < 9; row += 1) {
+      for (let col = 0; col < 9; col += 1) {
+        if (board[row][col] !== 0 && board[row][col] !== solution[row][col]) {
+          wrong.push(toKey(row, col));
+        }
+      }
+    }
+    return wrong;
+  }
+
+  function findFirstEmpty(board) {
+    for (let row = 0; row < 9; row += 1) {
+      for (let col = 0; col < 9; col += 1) {
+        if (board[row][col] === 0) {
+          return { row, col };
+        }
+      }
+    }
+    return { row: 0, col: 0 };
+  }
+
+  function isSolved(board) {
+    return board.every((row) => row.every((value) => value !== 0));
+  }
+
+  function countFilled(board) {
+    return board.flat().filter((value) => value !== 0).length;
+  }
+
+  function boardsEqual(a, b) {
+    for (let row = 0; row < 9; row += 1) {
+      for (let col = 0; col < 9; col += 1) {
+        if (a[row][col] !== b[row][col]) {
+          return false;
+        }
+      }
+    }
+    return true;
+  }
+
+  function cloneBoard(board) {
+    return board.map((row) => row.slice());
+  }
+
+  function parseBoard(serialized) {
+    const board = [];
+    for (let row = 0; row < 9; row += 1) {
+      const currentRow = [];
+      for (let col = 0; col < 9; col += 1) {
+        currentRow.push(Number(serialized[row * 9 + col]));
+      }
+      board.push(currentRow);
+    }
+    return board;
+  }
+
+  function toKey(row, col) {
+    return `${row}-${col}`;
+  }
+
+  function cellRef(row, col) {
+    return `${row + 1}행 ${col + 1}열`;
+  }
+});