gomoku-cli 0.0.0-stage → 0.1.0

package/dist/domain/engine.js

@@ -0,0 +1,98 @@
+import { cloneBoard, createEmptyBoard, inBounds, isBoardFull } from './board.js';
+import { findWinningLine } from './win.js';
+export function createInitialState() {
+    return {
+        board: createEmptyBoard(),
+        currentPlayer: 'X',
+        status: 'playing',
+        winner: null,
+        moves: [],
+    };
+}
+export function validateMove(state, row, col, player) {
+    if (state.status !== 'playing') {
+        return 'game-over';
+    }
+    if (!inBounds(row, col)) {
+        return 'out-of-bounds';
+    }
+    if (state.board[row][col] !== null) {
+        return 'occupied';
+    }
+    if (player !== state.currentPlayer) {
+        return 'not-your-turn';
+    }
+    return null;
+}
+/**
+ * Scans every occupied cell for a winning line. Only reached when the board is
+ * full, so the cost is bounded to a single pass per completed draw.
+ */
+function boardHasAnyWin(board) {
+    for (let row = 0; row < board.length; row += 1) {
+        for (let col = 0; col < board[row].length; col += 1) {
+            if (board[row][col] !== null &&
+                findWinningLine(board, row, col) !== null) {
+                return true;
+            }
+        }
+    }
+    return false;
+}
+function applyMoveCore(state, row, col, player) {
+    const error = validateMove(state, row, col, player);
+    if (error !== null) {
+        return { ok: false, reason: error };
+    }
+    const board = cloneBoard(state.board);
+    board[row][col] = player;
+    const move = { row, col, player };
+    const base = { ...state, board, moves: [...state.moves, move] };
+    if (findWinningLine(board, row, col) !== null) {
+        return { ok: true, state: { ...base, status: 'won', winner: player }, move };
+    }
+    if (isBoardFull(board) && !boardHasAnyWin(board)) {
+        return { ok: true, state: { ...base, status: 'draw', winner: null }, move };
+    }
+    return {
+        ok: true,
+        state: { ...base, currentPlayer: player === 'X' ? 'O' : 'X' },
+        move,
+    };
+}
+export function applyMove(state, row, col) {
+    return applyMoveCore(state, row, col, state.currentPlayer);
+}
+export function applyMoveAs(state, row, col, player) {
+    return applyMoveCore(state, row, col, player);
+}
+/** The latest human decision is the last X in a valid alternating history. */
+export function latestHumanMove(state) {
+    return state.moves.findLast((move) => move.player === 'X') ?? null;
+}
+/**
+ * Undo the last human decision and any machine reply to it. Replay the
+ * surviving legal history through the normal engine so board, status and turn
+ * cannot disagree. Empty history is a no-op; the input is never mutated.
+ */
+export function undoHumanTurn(state) {
+    const lastHumanIndex = state.moves.findLastIndex((move) => move.player === 'X');
+    if (lastHumanIndex === -1) {
+        return state;
+    }
+    let rebuilt = createInitialState();
+    for (const move of state.moves.slice(0, lastHumanIndex)) {
+        const result = applyMoveAs(rebuilt, move.row, move.col, move.player);
+        if (!result.ok) {
+            throw new Error(`undoHumanTurn: unreplayable move ${move.row},${move.col}`);
+        }
+        rebuilt = result.state;
+    }
+    return rebuilt;
+}
+export function latestMove(state) {
+    return state.moves.at(-1) ?? null;
+}
+export function moveCount(state) {
+    return state.moves.length;
+}

package/dist/domain/types.js

@@ -0,0 +1,3 @@
+export const BOARD_SIZE = 15;
+export const HUMAN = 'X';
+export const MACHINE = 'O';

package/dist/domain/win.js

@@ -0,0 +1,78 @@
+import { inBounds } from './board.js';
+export const WIN_LENGTH = 5;
+export const DIRECTIONS = [
+    [0, 1],
+    [1, 0],
+    [1, 1],
+    [1, -1],
+];
+/**
+ * Counts how many marks `player` would have consecutively through `(row, col)`
+ * in direction `(dr, dc)`, including `(row, col)` itself. Turn-agnostic.
+ */
+function countHypothetical(board, row, col, player, dr, dc) {
+    let count = 1;
+    let startRow = row;
+    let startCol = col;
+    let endRow = row;
+    let endCol = col;
+    let r = row + dr;
+    let c = col + dc;
+    while (inBounds(r, c) && board[r][c] === player) {
+        count += 1;
+        endRow = r;
+        endCol = c;
+        r += dr;
+        c += dc;
+    }
+    r = row - dr;
+    c = col - dc;
+    while (inBounds(r, c) && board[r][c] === player) {
+        count += 1;
+        startRow = r;
+        startCol = c;
+        r -= dr;
+        c -= dc;
+    }
+    return {
+        count,
+        start: { row: startRow, col: startCol },
+        end: { row: endRow, col: endCol },
+    };
+}
+/**
+ * Reads the mark already at `(row, col)` and returns the first direction in
+ * which that mark forms a line of `WIN_LENGTH` or more; otherwise `null`.
+ */
+export function findWinningLine(board, row, col) {
+    if (!inBounds(row, col)) {
+        return null;
+    }
+    const player = board[row][col];
+    if (player === null) {
+        return null;
+    }
+    for (const [dr, dc] of DIRECTIONS) {
+        const { count, start, end } = countHypothetical(board, row, col, player, dr, dc);
+        if (count >= WIN_LENGTH) {
+            return { player, direction: [dr, dc], count, start, end };
+        }
+    }
+    return null;
+}
+/**
+ * Returns `true` when placing `player` at `(row, col)` would immediately create
+ * a winning line. Turn-agnostic: no check against `currentPlayer`.
+ */
+export function isWinningMove(board, row, col, player) {
+    if (!inBounds(row, col) || board[row][col] !== null) {
+        return false;
+    }
+    for (const [dr, dc] of DIRECTIONS) {
+        const { count } = countHypothetical(board, row, col, player, dr, dc);
+        if (count >= WIN_LENGTH) {
+            return true;
+        }
+    }
+    return false;
+}

package/dist/opponent/candidates.js

@@ -0,0 +1,47 @@
+import { emptyCells, inBounds } from '../domain/board.js';
+import { BOARD_SIZE } from '../domain/types.js';
+export const CENTER = (BOARD_SIZE - 1) / 2;
+export function centerDistance(row, col) {
+    const dr = row - CENTER;
+    const dc = col - CENTER;
+    return dr * dr + dc * dc;
+}
+/** Stable tie order, independent of board traversal and insertion order. */
+export function compareCells(a, b) {
+    return (centerDistance(a[0], a[1]) - centerDistance(b[0], b[1]) ||
+        a[0] - b[0] ||
+        a[1] - b[1]);
+}
+/**
+ * Every empty square within two steps of an existing stone. Any immediate win
+ * or block necessarily falls in this neighborhood. Dense positions simply
+ * include every available cell. Neither the input board nor its rows change.
+ */
+export function candidateCells(board) {
+    const nearby = new Set();
+    let hasStones = false;
+    for (let row = 0; row < BOARD_SIZE; row += 1) {
+        for (let col = 0; col < BOARD_SIZE; col += 1) {
+            if (board[row][col] === null)
+                continue;
+            hasStones = true;
+            for (let dr = -2; dr <= 2; dr += 1) {
+                for (let dc = -2; dc <= 2; dc += 1) {
+                    const r = row + dr;
+                    const c = col + dc;
+                    if (inBounds(r, c) && board[r][c] === null) {
+                        nearby.add(r * BOARD_SIZE + c);
+                    }
+                }
+            }
+        }
+    }
+    if (!hasStones)
+        return [[CENTER, CENTER]];
+    // A nonterminal board with no nearby empties is possible in a contrived
+    // state. Fall back to all empty cells rather than failing to make a move.
+    const cells = nearby.size
+        ? [...nearby].map((key) => [Math.floor(key / BOARD_SIZE), key % BOARD_SIZE])
+        : emptyCells(board);
+    return cells.sort(compareCells);
+}

package/dist/opponent/evaluation.js

@@ -0,0 +1,140 @@
+import { inBounds } from '../domain/board.js';
+import { DIRECTIONS, WIN_LENGTH } from '../domain/win.js';
+/** Count a contiguous line including a hypothetical stone at an empty cell. */
+export function countRun(board, row, col, player, dr, dc) {
+    let run = 1;
+    let r = row + dr;
+    let c = col + dc;
+    while (inBounds(r, c) && board[r][c] === player) {
+        run += 1;
+        r += dr;
+        c += dc;
+    }
+    const forwardOpen = inBounds(r, c) && board[r][c] === null;
+    r = row - dr;
+    c = col - dc;
+    while (inBounds(r, c) && board[r][c] === player) {
+        run += 1;
+        r -= dr;
+        c -= dc;
+    }
+    const backwardOpen = inBounds(r, c) && board[r][c] === null;
+    return { run, openEnds: Number(forwardOpen) + Number(backwardOpen) };
+}
+export function createsOpenThree(board, row, col, player, dr, dc) {
+    const { run, openEnds } = countRun(board, row, col, player, dr, dc);
+    return run === 3 && openEnds === 2;
+}
+/** Get the hypothetical stone without modifying the board. */
+function markAt(board, row, col, player, placedRow, placedCol) {
+    if (!inBounds(row, col))
+        return undefined;
+    return row === placedRow && col === placedCol ? player : board[row][col];
+}
+/**
+ * Recognize one internal gap between two stones, without mistaking a board
+ * edge or an opponent-capped sequence for an open threat. The strongest shape
+ * in a direction wins, avoiding multiple counts of the same line.
+ */
+function gappedShape(board, row, col, player, dr, dc) {
+    for (const [length, stones] of [
+        [WIN_LENGTH, WIN_LENGTH - 1],
+        [WIN_LENGTH - 1, WIN_LENGTH - 2],
+    ]) {
+        for (let offset = -(length - 1); offset <= 0; offset += 1) {
+            if (markAt(board, row + offset * dr, col + offset * dc, player, row, col) !== player ||
+                markAt(board, row + (offset + length - 1) * dr, col + (offset + length - 1) * dc, player, row, col) !== player)
+                continue;
+            let stonesFound = 0;
+            let emptyFound = 0;
+            for (let index = 0; index < length; index += 1) {
+                const cell = markAt(board, row + (offset + index) * dr, col + (offset + index) * dc, player, row, col);
+                if (cell === player)
+                    stonesFound += 1;
+                else if (cell === null)
+                    emptyFound += 1;
+            }
+            if (stonesFound !== stones || emptyFound !== 1)
+                continue;
+            if (length === WIN_LENGTH)
+                return 'broken-four';
+            const before = markAt(board, row + (offset - 1) * dr, col + (offset - 1) * dc, player, row, col);
+            const after = markAt(board, row + (offset + length) * dr, col + (offset + length) * dc, player, row, col);
+            if (before === null && after === null)
+                return 'broken-three';
+        }
+    }
+    return 'none';
+}
+const SHAPE_VALUE = {
+    win: 1_000_000,
+    'open-four': 120_000,
+    'broken-four': 42_000,
+    'closed-four': 35_000,
+    'open-three': 7_500,
+    'broken-three': 4_500,
+    'closed-three': 500,
+    'open-two': 160,
+    'closed-two': 35,
+    none: 0,
+};
+function bestShape(board, row, col, player, dr, dc) {
+    const { run, openEnds } = countRun(board, row, col, player, dr, dc);
+    if (run >= WIN_LENGTH)
+        return 'win';
+    const contiguous = run === 4 && openEnds === 2
+        ? 'open-four'
+        : run === 4 && openEnds === 1
+            ? 'closed-four'
+            : run === 3 && openEnds === 2
+                ? 'open-three'
+                : run === 3 && openEnds === 1
+                    ? 'closed-three'
+                    : run === 2 && openEnds === 2
+                        ? 'open-two'
+                        : run === 2 && openEnds === 1
+                            ? 'closed-two'
+                            : 'none';
+    const broken = gappedShape(board, row, col, player, dr, dc);
+    return SHAPE_VALUE[broken] > SHAPE_VALUE[contiguous] ? broken : contiguous;
+}
+/** Symmetric, turn-agnostic evaluation of placing either X or O at an empty cell. */
+export function evaluatePlacement(board, row, col, player) {
+    if (!inBounds(row, col) || board[row][col] !== null) {
+        return { score: 0, openThrees: 0, openFours: 0, brokenFours: 0 };
+    }
+    let score = 0;
+    let openThrees = 0;
+    let openFours = 0;
+    let brokenFours = 0;
+    for (const [dr, dc] of DIRECTIONS) {
+        const shape = bestShape(board, row, col, player, dr, dc);
+        score += SHAPE_VALUE[shape];
+        if (shape === 'open-three')
+            openThrees += 1;
+        if (shape === 'open-four')
+            openFours += 1;
+        if (shape === 'broken-four')
+            brokenFours += 1;
+    }
+    // Two independent open threes force distinct replies. Prefer the fork to
+    // isolated open threes; this is positional assessment, not a reply search.
+    if (openThrees >= 2)
+        score += 25_000;
+    if (openFours + brokenFours >= 2)
+        score += 40_000;
+    // Nearby connections are only a tie-breaking positional signal. They must
+    // never override a live tactical shape. Edge/blocked lines earn no openness.
+    for (let dr = -2; dr <= 2; dr += 1) {
+        for (let dc = -2; dc <= 2; dc += 1) {
+            if (dr === 0 && dc === 0)
+                continue;
+            const r = row + dr;
+            const c = col + dc;
+            if (inBounds(r, c) && board[r][c] === player) {
+                score += Math.max(Math.abs(dr), Math.abs(dc)) === 1 ? 8 : 2;
+            }
+        }
+    }
+    return { score, openThrees, openFours, brokenFours };
+}

package/dist/opponent/opponent.js

@@ -0,0 +1,18 @@
+import { validateMove } from '../domain/engine.js';
+import { MACHINE } from '../domain/types.js';
+import { DIRECTIONS } from '../domain/win.js';
+import { CENTER, centerDistance } from './candidates.js';
+import { createsOpenThree } from './evaluation.js';
+import { DEFAULT_DIFFICULTY, SEARCH_PROFILES, } from './profiles.js';
+import { searchMove } from './search.js';
+export { CENTER, centerDistance };
+/** Retain the original machine-turn and legality contract for forkCell. */
+export function forkCell(state, row, col) {
+    return (validateMove(state, row, col, MACHINE) === null &&
+        DIRECTIONS.filter(([dr, dc]) => createsOpenThree(state.board, row, col, MACHINE, dr, dc)).length >= 2);
+}
+/** The default call retains the pre-difficulty Normal search policy. */
+export function chooseMove(state, options = {}) {
+    const difficulty = options.difficulty ?? DEFAULT_DIFFICULTY;
+    return searchMove(state, SEARCH_PROFILES[difficulty]).move;
+}

package/dist/opponent/profiles.js

@@ -0,0 +1,28 @@
+import { DEFAULT_SEARCH_LIMITS } from './search.js';
+export const DIFFICULTIES = ['easy', 'normal', 'hard'];
+export const DEFAULT_DIFFICULTY = 'normal';
+/** Each difficulty uses the same evaluator and legal-move search. */
+export const SEARCH_PROFILES = {
+    easy: {
+        maxNodes: 32,
+        maxDepth: 2,
+        rootWidth: 5,
+        replyWidth: 2,
+        forcingWidth: 1,
+    },
+    normal: DEFAULT_SEARCH_LIMITS,
+    hard: {
+        maxNodes: 320,
+        maxDepth: 6,
+        rootWidth: 12,
+        replyWidth: 6,
+        forcingWidth: 5,
+    },
+};
+export function nextDifficulty(current) {
+    const index = DIFFICULTIES.indexOf(current);
+    return DIFFICULTIES[(index + 1) % DIFFICULTIES.length];
+}
+export function difficultyLabel(difficulty) {
+    return difficulty[0].toUpperCase() + difficulty.slice(1);
+}

package/dist/opponent/search.js

@@ -0,0 +1,170 @@
+import { applyMove } from '../domain/engine.js';
+import { HUMAN, MACHINE, } from '../domain/types.js';
+import { candidateCells, compareCells } from './candidates.js';
+import { evaluatePlacement } from './evaluation.js';
+export const DEFAULT_SEARCH_LIMITS = {
+    maxNodes: 120,
+    maxDepth: 4,
+    rootWidth: 10,
+    replyWidth: 5,
+    forcingWidth: 4,
+};
+const WIN_SCORE = 100_000_000;
+// After a forcing placement, inspect the reply and the next counter-move.
+// A quiet continuation must not inherit the forcing flag indefinitely.
+const FORCING_REPLY_WINDOW = 2;
+const OPPONENT = {
+    X: MACHINE,
+    O: HUMAN,
+};
+/** Rank both players with the same evaluator, keeping tactical moves first. */
+function inspect(state) {
+    const actor = state.currentPlayer;
+    const ranked = [];
+    const ownWins = [];
+    const enemyWins = [];
+    for (const cell of candidateCells(state.board)) {
+        const [row, col] = cell;
+        const own = evaluatePlacement(state.board, row, col, actor);
+        const enemy = evaluatePlacement(state.board, row, col, OPPONENT[actor]);
+        // Includes capped fours (35k), open/broken fours, and multi-three forks.
+        const makesThreat = own.score >= 35_000;
+        const move = {
+            cell,
+            attack: own.score,
+            defense: enemy.score,
+            priority: own.score + enemy.score * 1.15,
+            forcing: makesThreat,
+        };
+        ranked.push(move);
+        if (own.score >= 1_000_000)
+            ownWins.push(move);
+        if (enemy.score >= 1_000_000)
+            enemyWins.push(move);
+    }
+    ranked.sort((a, b) => b.priority - a.priority || compareCells(a.cell, b.cell));
+    // Tactical moves are mandatory. With two distinct threats there may be no
+    // saving reply, but blocking one is preferable to ignoring both.
+    return ownWins.length ? ownWins : enemyWins.length ? enemyWins : ranked;
+}
+function terminalScore(state, ply) {
+    if (state.status === 'draw')
+        return 0;
+    if (state.status === 'won') {
+        return state.winner === MACHINE ? WIN_SCORE - ply : -WIN_SCORE + ply;
+    }
+    throw new Error('terminalScore requires a finished game');
+}
+/** A bounded heuristic for a move. Only the engine decides actual wins. */
+function moveValue(move, player) {
+    const value = move.attack + move.defense * 0.03;
+    return player === MACHINE ? value : -value;
+}
+function nextForcingWindow(move, remaining) {
+    return move.forcing ? FORCING_REPLY_WINDOW : Math.max(0, remaining - 1);
+}
+/** Score from O's perspective: O maximizes, X minimizes. */
+function search(state, ply, forcingRepliesLeft, alpha, beta, context, heuristic) {
+    if (context.stats.nodes >= context.limits.maxNodes) {
+        context.stats.budgetExhausted = true;
+        return { score: 0, complete: false };
+    }
+    context.stats.nodes += 1;
+    context.stats.maxDepth = Math.max(context.stats.maxDepth, ply);
+    if (state.status !== 'playing') {
+        return { score: terminalScore(state, ply), complete: true };
+    }
+    if (ply >= context.limits.maxDepth ||
+        (ply >= 2 && forcingRepliesLeft === 0)) {
+        return { score: heuristic, complete: true };
+    }
+    const ranked = inspect(state);
+    const maximize = state.currentPlayer === MACHINE;
+    const width = ply === 1 ? context.limits.replyWidth : context.limits.forcingWidth;
+    let best = maximize ? -Infinity : Infinity;
+    let evaluated = false;
+    for (const choice of ranked.slice(0, width)) {
+        if (context.stats.nodes >= context.limits.maxNodes) {
+            context.stats.budgetExhausted = true;
+            return { score: best, complete: false };
+        }
+        const applied = applyMove(state, ...choice.cell);
+        if (!applied.ok)
+            throw new Error('search generated an illegal move');
+        const outcome = search(applied.state, ply + 1, nextForcingWindow(choice, forcingRepliesLeft), alpha, beta, context, heuristic + moveValue(choice, state.currentPlayer));
+        if (!outcome.complete)
+            return { score: best, complete: false };
+        evaluated = true;
+        best = maximize
+            ? Math.max(best, outcome.score)
+            : Math.min(best, outcome.score);
+        if (maximize)
+            alpha = Math.max(alpha, best);
+        else
+            beta = Math.min(beta, best);
+        if (beta <= alpha)
+            break;
+    }
+    return { score: evaluated ? best : heuristic, complete: true };
+}
+/**
+ * Search from an active machine turn. Terminal/wrong-turn states throw, as
+ * chooseMove has always done. This function does not mutate the input state.
+ * When the work budget is exhausted, the best fully checked move is returned;
+ * if no candidate was fully searched, the deterministic top-ranked move wins.
+ */
+export function searchMove(state, limits = DEFAULT_SEARCH_LIMITS) {
+    if (state.status !== 'playing' || state.currentPlayer !== MACHINE) {
+        throw new Error('no legal move available');
+    }
+    if (!Number.isInteger(limits.maxNodes) ||
+        limits.maxNodes < 1 ||
+        !Number.isInteger(limits.maxDepth) ||
+        limits.maxDepth < 2 ||
+        limits.maxDepth > 6 ||
+        !Number.isInteger(limits.rootWidth) ||
+        limits.rootWidth < 1 ||
+        !Number.isInteger(limits.replyWidth) ||
+        limits.replyWidth < 1 ||
+        !Number.isInteger(limits.forcingWidth) ||
+        limits.forcingWidth < 1) {
+        throw new Error('invalid search limits');
+    }
+    const ranked = inspect(state);
+    if (!ranked.length)
+        throw new Error('no legal move available');
+    const context = {
+        limits: { ...limits },
+        stats: { nodes: 0, maxDepth: 0, budgetExhausted: false },
+    };
+    let bestMove = ranked[0];
+    let bestScore = -Infinity;
+    let completed = false;
+    for (const choice of ranked.slice(0, limits.rootWidth)) {
+        if (context.stats.nodes >= limits.maxNodes) {
+            context.stats.budgetExhausted = true;
+            break;
+        }
+        const applied = applyMove(state, ...choice.cell);
+        if (!applied.ok)
+            throw new Error('search generated an illegal move');
+        // A win is absolute. Earlier wins outrank delayed ones and all heuristics.
+        const outcome = search(applied.state, 1, nextForcingWindow(choice, 0), bestScore, Infinity, context, moveValue(choice, MACHINE));
+        if (!outcome.complete)
+            break;
+        if (!completed ||
+            outcome.score > bestScore ||
+            (outcome.score === bestScore &&
+                compareCells(choice.cell, bestMove.cell) < 0)) {
+            bestMove = choice;
+            bestScore = outcome.score;
+        }
+        completed = true;
+        if (bestScore >= WIN_SCORE - 1)
+            break;
+    }
+    return {
+        move: { row: bestMove.cell[0], col: bestMove.cell[1], player: MACHINE },
+        stats: context.stats,
+    };
+}

package/dist/terminal/fullscreen.js

@@ -0,0 +1,95 @@
+const ENTER_SCREEN = '\u001b[?1049h\u001b[H';
+const LEAVE_SCREEN = '\u001b[?25h\u001b[?1049l';
+const ENABLE_MOUSE = '\u001b[?1006h\u001b[?1000h';
+const DISABLE_MOUSE = '\u001b[?1000l\u001b[?1006l';
+const SHUTDOWN_SIGNALS = [
+    'SIGINT',
+    'SIGTERM',
+    'SIGHUP',
+];
+export class AlternateScreen {
+    streams;
+    active = false;
+    constructor(streams) {
+        this.streams = streams;
+    }
+    enter() {
+        if (this.active)
+            return true;
+        if (this.streams.stdin.isTTY !== true ||
+            this.streams.stdout.isTTY !== true) {
+            return false;
+        }
+        this.streams.stdout.write(ENTER_SCREEN + ENABLE_MOUSE);
+        this.active = true;
+        return true;
+    }
+    leave() {
+        if (!this.active)
+            return;
+        this.active = false;
+        this.streams.stdout.write(DISABLE_MOUSE + LEAVE_SCREEN);
+    }
+}
+/** Ink must stop rendering before the original terminal screen is restored. */
+export async function runFullscreenApp({ stdin, stdout, signals, mount, input, }) {
+    const screen = new AlternateScreen({ stdin, stdout });
+    if (!screen.enter())
+        return 'not-interactive';
+    let app;
+    let shutdown;
+    let exited = false;
+    let unmountRequested = false;
+    const installed = [];
+    const requestUnmount = () => {
+        if (!app || unmountRequested)
+            return;
+        unmountRequested = true;
+        app.unmount();
+    };
+    const onSignal = (signal) => () => {
+        if (shutdown || exited)
+            return;
+        shutdown = signal;
+        requestUnmount();
+    };
+    const listeners = SHUTDOWN_SIGNALS.map((signal) => ({
+        signal,
+        listener: onSignal(signal),
+    }));
+    try {
+        input?.start();
+        for (const { signal, listener } of listeners) {
+            signals.on(signal, listener);
+            installed.push(signal);
+        }
+        app = mount();
+        if (shutdown)
+            requestUnmount();
+        await app.waitUntilExit();
+        exited = true;
+        return shutdown ?? 'completed';
+    }
+    finally {
+        try {
+            if (!exited)
+                requestUnmount();
+        }
+        finally {
+            try {
+                for (const { signal, listener } of listeners) {
+                    if (installed.includes(signal))
+                        signals.off(signal, listener);
+                }
+            }
+            finally {
+                try {
+                    input?.stop();
+                }
+                finally {
+                    screen.leave();
+                }
+            }
+        }
+    }
+}