bridges-cli 0.0.1 → 0.2.0

package/src/components/__tests__/HashiRow.test.tsx

@@ -1,119 +1,12 @@
 import { render } from 'ink-testing-library'
 import { describe, expect, it } from 'vitest'
-
-import type { HashiNodeData } from '../../types.ts'
-import HashiRow, { constructNode } from '../HashiRow.tsx'
-
-describe('constructNode()', () => {
-    describe('empty node', () => {
-        it('renders space value with no lines', () => {
-            const node: HashiNodeData = { value: ' ' }
-            expect(constructNode(node, 0)).toEqual('     ')
-            expect(constructNode(node, 1)).toEqual('     ')
-            expect(constructNode(node, 2)).toEqual('     ')
-        })
-    })
-
-    describe('horizontal line node', () => {
-        it('renders a horizontal line in the middle', () => {
-            const node: HashiNodeData = { value: '-' }
-            expect(constructNode(node, 0)).toEqual('     ')
-            expect(constructNode(node, 1)).toEqual('─────')
-            expect(constructNode(node, 2)).toEqual('     ')
-        })
-
-        it('renders a double horizontal line in the middle', () => {
-            const node: HashiNodeData = { value: '=' }
-            expect(constructNode(node, 0)).toEqual('     ')
-            expect(constructNode(node, 1)).toEqual('═════')
-            expect(constructNode(node, 2)).toEqual('     ')
-        })
-    })
-
-    describe('vertical line node', () => {
-        it('renders a vertical line in the center', () => {
-            const node: HashiNodeData = { value: '|' }
-            expect(constructNode(node, 0)).toEqual('  │  ')
-            expect(constructNode(node, 1)).toEqual('  │  ')
-            expect(constructNode(node, 2)).toEqual('  │  ')
-        })
-
-        it('renders a double vertical line in the center', () => {
-            const node: HashiNodeData = { value: '#' }
-            expect(constructNode(node, 0)).toEqual('  ║  ')
-            expect(constructNode(node, 1)).toEqual('  ║  ')
-            expect(constructNode(node, 2)).toEqual('  ║  ')
-        })
-    })
-
-    describe('node with value', () => {
-        describe('TOP_ROW', () => {
-            it('renders top border', () => {
-                const node: HashiNodeData = { value: 5 }
-                expect(constructNode(node, 0)).toEqual('╭───╮')
-            })
-
-            it('renders border with vertical line up', () => {
-                const node: HashiNodeData = { value: 5, lineUp: 1 }
-                expect(constructNode(node, 0)).toEqual('╭─┴─╮')
-            })
-
-            it('renders border with double vertical line up', () => {
-                const node: HashiNodeData = { value: 5, lineUp: 2 }
-                expect(constructNode(node, 0)).toEqual('╭─╨─╮')
-            })
-        })
-
-        describe('MIDDLE_ROW', () => {
-            it('renders middle row - value with vertical borders', () => {
-                const node: HashiNodeData = { value: 5 }
-                expect(constructNode(node, 1)).toEqual('│ 5 │')
-            })
-
-            it('renders value with horizontal line on left', () => {
-                const node: HashiNodeData = { value: 5, lineLeft: 1 }
-                expect(constructNode(node, 1)).toEqual('┤ 5 │')
-            })
-
-            it('renders value with horizontal line on right', () => {
-                const node: HashiNodeData = { value: 5, lineRight: 1 }
-                expect(constructNode(node, 1)).toEqual('│ 5 ├')
-            })
-
-            it('renders value with horizontal lines on both sides', () => {
-                const node: HashiNodeData = { value: 5, lineLeft: 1, lineRight: 1 }
-                expect(constructNode(node, 1)).toEqual('┤ 5 ├')
-            })
-
-            it('renders value with double horizontal lines on both sides', () => {
-                const node: HashiNodeData = { value: 5, lineLeft: 2, lineRight: 2 }
-                expect(constructNode(node, 1)).toEqual('╡ 5 ╞')
-            })
-        })
-
-        describe('BOTTOM_ROW', () => {
-            it('renders bottom border without lines', () => {
-                const node: HashiNodeData = { value: 5 }
-                expect(constructNode(node, 2)).toEqual('╰───╯')
-            })
-
-            it('renders border with vertical line down', () => {
-                const node: HashiNodeData = { value: 5, lineDown: 1 }
-                expect(constructNode(node, 2)).toEqual('╰─┬─╯')
-            })
-
-            it('renders border with double vertical line down', () => {
-                const node: HashiNodeData = { value: 5, lineDown: 2 }
-                expect(constructNode(node, 2)).toEqual('╰─╥─╯')
-            })
-        })
-    })
-})
+import HashiRow from '../../components/HashiRow.tsx'
+import type { SelectionState } from '../../types.ts'
 
 describe('HashiRow component', () => {
     it('renders three nodes', () => {
         const { lastFrame } = render(
-            <HashiRow nodes={[{ value: 1 }, { value: 2 }, { value: 3 }]} />
+            <HashiRow nodes={[{ value: 1 }, { value: 2 }, { value: 3 }]} rowIndex={0} />
         )
         expect(lastFrame()).toEqual(
             ` ╭───╮╭───╮╭───╮
@@ -126,16 +19,17 @@ describe('HashiRow component', () => {
         const { lastFrame } = render(
             <HashiRow
                 nodes={[{ value: 1, lineRight: 1 }, { value: '-' }, { value: 3, lineLeft: 1 }]}
+                rowIndex={0}
             />
         )
-        expect(lastFrame()).toEqual(` ╭───╮     ╭───╮
- │ 1 ├─────┤ 3 │
- ╰───╯     ╰───╯`)
+        expect(lastFrame()).toEqual(` \x1b[32m╭───╮\x1b[39m     ╭───╮
+ \x1b[32m│ 1 ├\x1b[39m─────┤ 3 │
+ \x1b[32m╰───╯\x1b[39m     ╰───╯`)
     })
 
     it('renders a vertical node', () => {
         const { lastFrame } = render(
-            <HashiRow nodes={[{ value: 1 }, { value: '|' }, { value: 3 }]} />
+            <HashiRow nodes={[{ value: 1 }, { value: '|' }, { value: 3 }]} rowIndex={0} />
         )
         expect(lastFrame()).toEqual(` ╭───╮  │  ╭───╮
  │ 1 │  │  │ 3 │
@@ -144,7 +38,7 @@ describe('HashiRow component', () => {
 
     it('renders empty positions as spaces', () => {
         const { lastFrame } = render(
-            <HashiRow nodes={[{ value: 1 }, { value: ' ' }, { value: 3 }]} />
+            <HashiRow nodes={[{ value: 1 }, { value: ' ' }, { value: 3 }]} rowIndex={0} />
         )
         expect(lastFrame()).toEqual(
             ` ╭───╮     ╭───╮
@@ -152,4 +46,123 @@ describe('HashiRow component', () => {
  ╰───╯     ╰───╯`
         )
     })
+
+    describe('highlighted nodes', () => {
+        it('renders highlighted node with bold when value matches', () => {
+            const { lastFrame } = render(
+                <HashiRow nodes={[{ value: 1 }]} rowIndex={0} highlightedNode={1} />
+            )
+            expect(lastFrame()).toEqual(
+                ` \x1b[1m╭───╮\x1b[22m
+ \x1b[1m│ 1 │\x1b[22m
+ \x1b[1m╰───╯\x1b[22m`
+            )
+        })
+
+        it('renders dimmed node when value does not match', () => {
+            const { lastFrame } = render(
+                <HashiRow nodes={[{ value: 1 }]} rowIndex={0} highlightedNode={2} />
+            )
+            expect(lastFrame()).toEqual(
+                ` \x1b[2m╭───╮\x1b[22m
+ \x1b[2m│ 1 │\x1b[22m
+ \x1b[2m╰───╯\x1b[22m`
+            )
+        })
+
+        it('renders multiple nodes with one highlighted and others dimmed', () => {
+            const { lastFrame } = render(
+                <HashiRow
+                    nodes={[{ value: 1 }, { value: 2 }, { value: 3 }]}
+                    rowIndex={0}
+                    highlightedNode={2}
+                />
+            )
+            expect(lastFrame()).toEqual(
+                ` \x1b[2m╭───╮\x1b[22m\x1b[1m╭───╮\x1b[22m\x1b[2m╭───╮\x1b[22m
+ \x1b[2m│ 1 │\x1b[22m\x1b[1m│ 2 │\x1b[22m\x1b[2m│ 3 │\x1b[22m
+ \x1b[2m╰───╯\x1b[22m\x1b[1m╰───╯\x1b[22m\x1b[2m╰───╯\x1b[22m`
+            )
+        })
+
+        it('renders normal when highlightedNode is undefined', () => {
+            const { lastFrame } = render(<HashiRow nodes={[{ value: 1 }]} rowIndex={0} />)
+            expect(lastFrame()).toEqual(
+                ` ╭───╮
+ │ 1 │
+ ╰───╯`
+            )
+        })
+
+        it('highlights only specific node in selecting-node mode', () => {
+            const selectionState: SelectionState = {
+                mode: 'selecting-node',
+                selectedNumber: 1,
+                direction: null,
+                matchingNodes: [{ row: 0, col: 1 }],
+                disambiguationLabels: [],
+                selectedNode: { row: 0, col: 1 },
+            }
+            const { lastFrame } = render(
+                <HashiRow
+                    nodes={[{ value: 1 }, { value: 1 }, { value: 1 }]}
+                    rowIndex={0}
+                    selectionState={selectionState}
+                />
+            )
+            expect(lastFrame()).toEqual(
+                ` \x1b[2m╭───╮\x1b[22m\x1b[1m╭───╮\x1b[22m\x1b[2m╭───╮\x1b[22m
+ \x1b[2m│ 1 │\x1b[22m\x1b[1m│ 1 │\x1b[22m\x1b[2m│ 1 │\x1b[22m
+ \x1b[2m╰───╯\x1b[22m\x1b[1m╰───╯\x1b[22m\x1b[2m╰───╯\x1b[22m`
+            )
+        })
+
+        it('dims non-selected nodes in invalid mode but keeps selected highlighted', () => {
+            const selectionState: SelectionState = {
+                mode: 'invalid',
+                selectedNumber: 1,
+                direction: 'h',
+                matchingNodes: [{ row: 0, col: 1 }],
+                disambiguationLabels: [],
+                selectedNode: { row: 0, col: 1 },
+            }
+            const { lastFrame } = render(
+                <HashiRow
+                    nodes={[{ value: 1 }, { value: 1 }, { value: 1 }]}
+                    rowIndex={0}
+                    selectionState={selectionState}
+                />
+            )
+            expect(lastFrame()).toEqual(
+                ` \x1b[2m╭───╮\x1b[22m\x1b[1m╭───╮\x1b[22m\x1b[2m╭───╮\x1b[22m
+ \x1b[2m│ 1 │\x1b[22m\x1b[1m│ 1 │\x1b[22m\x1b[2m│ 1 │\x1b[22m
+ \x1b[2m╰───╯\x1b[22m\x1b[1m╰───╯\x1b[22m\x1b[2m╰───╯\x1b[22m`
+            )
+        })
+    })
+
+    describe('validation state colors', () => {
+        it('shows green on valid nodes in selected mode', () => {
+            const selectionState: SelectionState = {
+                mode: 'selected',
+                selectedNumber: 1,
+                direction: 'h',
+                matchingNodes: [{ row: 0, col: 0 }],
+                disambiguationLabels: [],
+                selectedNode: { row: 0, col: 0 },
+            }
+            const { lastFrame } = render(
+                <HashiRow
+                    nodes={[{ value: 1, lineRight: 1 }, { value: ' ' }, { value: 1, lineLeft: 1 }]}
+                    rowIndex={0}
+                    selectionState={selectionState}
+                />
+            )
+            expect(lastFrame()).toEqual(
+                ` \x1b[32m\x1b[1m╭───╮\x1b[22m\x1b[39m     \x1b[32m\x1b[2m╭───╮\x1b[22m\x1b[39m
+ \x1b[32m\x1b[1m│ 1 ├\x1b[22m\x1b[39m     \x1b[32m\x1b[2m┤ 1 │\x1b[22m\x1b[39m
+ \x1b[32m\x1b[1m╰───╯\x1b[22m\x1b[39m     \x1b[32m\x1b[2m╰───╯\x1b[22m\x1b[39m`
+            )
+        })
+    })
 })

package/src/components/__tests__/Header.test.tsx

@@ -0,0 +1,156 @@
+import { render } from 'ink-testing-library'
+import { describe, expect, it } from 'vitest'
+import type { SelectionState } from '../../types.ts'
+import Header from '../Header.tsx'
+
+describe('Header', () => {
+    it('shows idle message when no selection state and no number range', () => {
+        const { lastFrame } = render(<Header puzzleIndex={0} puzzle="5x5:1a1" />)
+        expect(lastFrame()).toContain('Type a number to select a node')
+    })
+
+    it('shows dynamic number range when provided', () => {
+        const { lastFrame } = render(
+            <Header puzzleIndex={0} puzzle="5x5:1a1" minNumber={2} maxNumber={7} />
+        )
+        expect(lastFrame()).toContain('Type a number [2-7] to select a node')
+    })
+
+    describe('selection state messages', () => {
+        it('shows "select direction" message after we disambiguate which node', () => {
+            const selectionState: SelectionState = {
+                mode: 'selecting-node',
+                selectedNumber: 1,
+                direction: null,
+                matchingNodes: [
+                    { row: 0, col: 0 },
+                    { row: 1, col: 1 },
+                ],
+                disambiguationLabels: [],
+                selectedNode: { row: 0, col: 0 },
+            }
+            const { lastFrame } = render(
+                <Header puzzleIndex={0} puzzle="5x5:1a1" selectionState={selectionState} />
+            )
+            expect(lastFrame()).toContain(`Select direction with`)
+        })
+
+        it('shows disambiguation message without direction', () => {
+            const selectionState: SelectionState = {
+                mode: 'disambiguation',
+                selectedNumber: 1,
+                direction: null,
+                matchingNodes: [
+                    { row: 0, col: 0 },
+                    { row: 1, col: 2 },
+                ],
+                disambiguationLabels: ['a', 'b'],
+                selectedNode: null,
+            }
+            const { lastFrame } = render(
+                <Header puzzleIndex={0} puzzle="5x5:1a1" selectionState={selectionState} />
+            )
+            expect(lastFrame()).toContain('Press label shown to select that node')
+        })
+
+        it('shows disambiguation message with direction', () => {
+            const selectionState: SelectionState = {
+                mode: 'disambiguation',
+                selectedNumber: 1,
+                direction: 'h',
+                matchingNodes: [
+                    { row: 0, col: 0 },
+                    { row: 1, col: 2 },
+                ],
+                disambiguationLabels: ['a', 'b'],
+                selectedNode: null,
+            }
+            const { lastFrame } = render(
+                <Header puzzleIndex={0} puzzle="5x5:1a1" selectionState={selectionState} />
+            )
+            expect(lastFrame()).toContain('Press label shown to select that node')
+        })
+
+        it('shows selected message with direction (horizontal)', () => {
+            const selectionState: SelectionState = {
+                mode: 'selected',
+                selectedNumber: 1,
+                direction: 'l',
+                matchingNodes: [{ row: 0, col: 0 }],
+                disambiguationLabels: [],
+                selectedNode: { row: 0, col: 0 },
+            }
+            const { lastFrame } = render(
+                <Header puzzleIndex={0} puzzle="5x5:1a1" selectionState={selectionState} />
+            )
+            expect(lastFrame()).toContain('Drew horizontal bridge')
+        })
+
+        it('shows selected message with direction (vertical)', () => {
+            const selectionState: SelectionState = {
+                mode: 'selected',
+                selectedNumber: 1,
+                direction: 'k',
+                matchingNodes: [{ row: 0, col: 0 }],
+                disambiguationLabels: [],
+                selectedNode: { row: 0, col: 0 },
+            }
+            const { lastFrame } = render(
+                <Header puzzleIndex={0} puzzle="5x5:1a1" selectionState={selectionState} />
+            )
+            expect(lastFrame()).toContain('Drew vertical bridge')
+        })
+
+        it('shows erased bridge message when bridgeErased is true', () => {
+            const selectionState: SelectionState = {
+                mode: 'selected',
+                selectedNumber: 1,
+                direction: 'l',
+                matchingNodes: [{ row: 0, col: 0 }],
+                disambiguationLabels: [],
+                selectedNode: { row: 0, col: 0 },
+                bridgeErased: true,
+            }
+            const { lastFrame } = render(
+                <Header puzzleIndex={0} puzzle="5x5:1a1" selectionState={selectionState} />
+            )
+            expect(lastFrame()).toContain('Erased bridge')
+        })
+
+        it('shows invalid message when no node in direction', () => {
+            const selectionState: SelectionState = {
+                mode: 'invalid',
+                selectedNumber: 1,
+                direction: 'h',
+                matchingNodes: [{ row: 0, col: 0 }],
+                disambiguationLabels: [],
+                selectedNode: { row: 0, col: 0 },
+            }
+            const { lastFrame } = render(
+                <Header puzzleIndex={0} puzzle="5x5:1a1" selectionState={selectionState} />
+            )
+            expect(lastFrame()).toContain('Cannot draw bridge left from node')
+        })
+    })
+
+    describe('puzzle display', () => {
+        it('shows puzzle number for indexed puzzles', () => {
+            const { lastFrame } = render(<Header puzzleIndex={2} puzzle="5x5:1a1" />)
+            expect(lastFrame()).toContain('Bridges: Puzzle #3')
+        })
+
+        it('shows solution suffix when showSolution is true', () => {
+            const { lastFrame } = render(
+                <Header puzzleIndex={0} puzzle="5x5:1a1" showSolution={true} />
+            )
+            expect(lastFrame()).toContain('Viewing solution (press s to return to puzzle)')
+        })
+
+        it('shows custom puzzle label for custom puzzles', () => {
+            const { lastFrame } = render(
+                <Header puzzleIndex={0} puzzle="5x5:1a1" isCustomPuzzle={true} />
+            )
+            expect(lastFrame()).toContain('Bridges: Puzzle - 5x5:1a1')
+        })
+    })
+})

package/src/components/__tests__/Messages.test.tsx

@@ -1,14 +1,82 @@
 import { render } from 'ink-testing-library'
 import { describe, expect, it } from 'vitest'
 
-import Messages from '../Messages.tsx'
+import Messages, { legendItems } from '../Messages.tsx'
 
 describe('Messages', () => {
-    it('renders the legend', () => {
-        const { lastFrame } = render(<Messages />)
+    it('does not show solution option when enableSolutions is false', () => {
+        const { lastFrame } = render(<Messages enableSolutions={false} />)
         expect(lastFrame()).toContain('Controls:')
         expect(lastFrame()).toContain('p: Previous puzzle')
         expect(lastFrame()).toContain('n: Next puzzle')
+        expect(lastFrame()).not.toContain('s: Show solution')
         expect(lastFrame()).toContain('q: Quit')
     })
+
+    it('shows solution option when enableSolutions is true', () => {
+        const { lastFrame } = render(<Messages enableSolutions={true} />)
+        expect(lastFrame()).toContain('Controls:')
+        expect(lastFrame()).toContain('p: Previous puzzle')
+        expect(lastFrame()).toContain('n: Next puzzle')
+        expect(lastFrame()).toContain('s: Show solution')
+        expect(lastFrame()).toContain('q: Quit')
+    })
+
+    describe('legendItems', () => {
+        describe('when enableSolutions is false', () => {
+            it('shows n/p as enabled when idle', () => {
+                const items = legendItems(true, false, false)
+                const p = items.find(i => i.key === 'p')
+                const n = items.find(i => i.key === 'n')
+                const s = items.find(i => i.key === 's')
+                expect(p?.disabled).toBe(false)
+                expect(n?.disabled).toBe(false)
+                expect(s).toBeUndefined()
+            })
+
+            it('shows n/p as disabled in selecting-node mode', () => {
+                const items = legendItems(true, false, true)
+                const p = items.find(i => i.key === 'p')
+                const n = items.find(i => i.key === 'n')
+                const s = items.find(i => i.key === 's')
+                expect(p?.disabled).toBe(true)
+                expect(n?.disabled).toBe(true)
+                expect(s).toBeUndefined()
+            })
+        })
+
+        describe('when enableSolutions is true', () => {
+            it('shows n/p/s as enabled when idle', () => {
+                const items = legendItems(true, true, false)
+                const p = items.find(i => i.key === 'p')
+                const n = items.find(i => i.key === 'n')
+                const s = items.find(i => i.key === 's')
+                expect(p?.disabled).toBe(false)
+                expect(n?.disabled).toBe(false)
+                expect(s?.disabled).toBe(false)
+            })
+
+            it('shows n/p/s as disabled in selecting-node mode', () => {
+                const items = legendItems(true, true, true)
+                const p = items.find(i => i.key === 'p')
+                const n = items.find(i => i.key === 'n')
+                const s = items.find(i => i.key === 's')
+                expect(p?.disabled).toBe(true)
+                expect(n?.disabled).toBe(true)
+                expect(s?.disabled).toBe(true)
+            })
+
+            it('shows s as disabled when no solution exists', () => {
+                const items = legendItems(false, true, false)
+                const s = items.find(i => i.key === 's')
+                expect(s?.disabled).toBe(true)
+            })
+
+            it('shows s as enabled when solution exists', () => {
+                const items = legendItems(true, true, false)
+                const s = items.find(i => i.key === 's')
+                expect(s?.disabled).toBe(false)
+            })
+        })
+    })
 })

package/src/demo.tsx

@@ -0,0 +1,20 @@
+#!/usr/bin/env -S bun run
+
+import { render } from 'ink'
+
+import HashiRow from './components/HashiRow.tsx'
+
+render(
+    <HashiRow
+        nodes={[
+            { value: 1 },
+            { value: '-' },
+            { value: 2 },
+            { value: '#' },
+            { value: 2 },
+            { value: 3 },
+        ]}
+        rowIndex={0}
+        highlightedNode={2}
+    />
+)

package/src/index.tsx

@@ -1,14 +1,18 @@
 #!/usr/bin/env -S bun run
 
+import { readFileSync } from 'node:fs'
+import { resolve } from 'node:path'
 import { Command } from 'commander'
 import { render } from 'ink'
 
 import Game from './Game.tsx'
-import { type PuzzleData, samplePuzzles } from './utils/samplePuzzles.ts'
+import { type PuzzleData, samplePuzzles } from './utils/puzzle-encoding.ts'
+
+const packageJson = JSON.parse(readFileSync(resolve(__dirname, '../package.json'), 'utf8'))
 
 type CliOptions = {
-    stdout: boolean
     puzzle: string | undefined
+    enableSolutions: boolean
 }
 
 const program = new Command()
@@ -16,8 +20,26 @@ const program = new Command()
 program
     .name('bridges')
     .description('Bridges (Hashiwokakero) puzzle game')
-    .option('-s, --stdout', 'Output to stdout and exit (for testing)')
-    .option('-p, --puzzle <puzzle>', 'Puzzle shorthand encoding')
+    .version(packageJson.version, '-v, --version')
+    .option(
+        '-p, --puzzle <puzzle>',
+        `Puzzle shorthand encoding
+  Format: "WIDTHxHEIGHT:row1.row2.row3..."
+
+  Node encoding:
+    - Digits (1-8): island with that value
+    - Letters (a-z): space between islands (b=2, etc.)
+
+  Bridge encoding (optional):
+    - "-": single horizontal bridge
+    - "=": double horizontal bridge
+    - "|": single vertical bridge
+    - "#": double vertical bridge
+
+  Example (3x3 with corner islands):
+    --puzzle "3x3:1a2.c.1a2"`
+    )
+    .option('--enable-solutions', 'Enable the solution viewing feature', false)
     .parse(process.argv)
 
 const options = program.opts<CliOptions>()
@@ -30,5 +52,9 @@ if (options.puzzle) {
 }
 
 render(
-    <Game puzzles={puzzles} hasCustomPuzzle={hasCustomPuzzle} stdout={options.stdout || false} />
+    <Game
+        puzzles={puzzles}
+        hasCustomPuzzle={hasCustomPuzzle}
+        enableSolutions={options.enableSolutions}
+    />
 )

package/src/types.ts

@@ -1,3 +1,6 @@
+/**
+ * HashiNode types
+ */
 export type HashiNodeData = {
     value: number | '-' | '=' | '#' | ' ' | '|'
     /** Num lines connected on left, undefined if 0. */
@@ -9,3 +12,34 @@ export type HashiNodeData = {
     /** Num lines connected below, undefined if 0. */
     lineDown?: 1 | 2
 }
+
+export type HashiNodeDisplayMode = 'normal' | 'highlight' | 'dim'
+
+export type HashiNodeOptions = {
+    displayMode?: HashiNodeDisplayMode
+    label?: string
+}
+
+/**
+ * Game operation types
+ */
+export type SelectionMode = 'idle' | 'selecting-node' | 'disambiguation' | 'selected' | 'invalid'
+
+export type Direction = 'h' | 'j' | 'k' | 'l'
+
+export type PlacedBridge = {
+    from: { row: number; col: number }
+    to: { row: number; col: number }
+    count?: number
+}
+
+export type SelectionState = {
+    mode: SelectionMode
+    selectedNumber: number | null
+    direction: Direction | null
+    matchingNodes: { row: number; col: number }[]
+    disambiguationLabels: string[]
+    selectedNode: { row: number; col: number } | null
+    bridgeErased?: boolean
+    isDoubleBridge?: boolean
+}