Bugfix: ⌘A in ByteSeek-no-index mode no longer freezes the viewer

- `selectionAnnouncement`'s per-line loop ran `for (let i = start.line + 1; i < end.line; i++)`. In ByteSeek-no-index mode the ⌘A path sets `focus.line = Number.MAX_SAFE_INTEGER` (the sentinel that maps to `RangeEnd::Eof` at the IPC boundary), so the loop iterated 9e15 times and froze the viewer for many seconds.
- Extracted the announcement logic to a pure `describeSelectionForAt(sel, getLineLength)` helper in `selection.svelte.ts`. New `MAX_ANNOUNCE_LINES = 10_000` cap: past that, returns `"Selected from line N to the end of the file"` without touching the line-length lookup at all. 10k lines is plenty for an actionable AT announcement; ⌘A on a typical log file lands well under.
- The page wires the helper through `$derived`. Same announcement format as before; the only behavioural change is the cap.
- 8 new tests cover: null selection, caret-only, single-line, multi-line, the `Number.MAX_SAFE_INTEGER` sentinel (asserts the lookup is never called), exact-cap boundary, reversed-selection symmetry, and missing-line-length graceful degradation.

Author: vdavid

apps/desktop/src/routes/viewer/+page.svelte

@@ -28,6 +28,7 @@
     import { handleNavigationKey, handleToggleKey } from './viewer-keyboard'
     import {
         createViewerSelection,
+        describeSelectionForAt,
         estimateSelectionBytes,
         getLineSegmentBounds,
         normaliseSelection,
@@ -151,28 +152,9 @@
      * there's nothing selected (the live region stays silent). The format names the
      * selected line range and a UTF-16 character count for orientation.
      */
-    const selectionAnnouncement = $derived.by((): string => {
-        const sel = selection.selection
-        if (sel === null) return ''
-        const { start, end } = normaliseSelection(sel)
-        if (start.line === end.line && start.offset === end.offset) return ''
-
-        const totalChars = (() => {
-            if (start.line === end.line) return end.offset - start.offset
-            const startLineLen = scroll.lineCache.get(start.line)?.length ?? 0
-            let chars = startLineLen - start.offset
-            for (let i = start.line + 1; i < end.line; i++) {
-                chars += scroll.lineCache.get(i)?.length ?? 0
-            }
-            chars += end.offset
-            return chars
-        })()
-
-        if (start.line === end.line) {
-            return `Selected ${String(totalChars)} characters on line ${String(start.line + 1)}`
-        }
-        return `Selected lines ${String(start.line + 1)} to ${String(end.line + 1)}, ${String(totalChars)} characters`
-    })
+    const selectionAnnouncement = $derived(
+        describeSelectionForAt(selection.selection, (line) => scroll.lineCache.get(line)?.length ?? null),
+    )
 
     /**
      * Converts a `Selection` to the `(anchor, focus)` `RangeEnd`s the IPC layer accepts.

apps/desktop/src/routes/viewer/selection.svelte.ts

@@ -138,6 +138,52 @@ export function makeSelectAll(totalLines: number, lastLineLength: number): Selec
   }
 }
 
+/**
+ * Maximum number of intermediate lines the AT (VoiceOver) announcement loop walks
+ * before falling back to a generic "extends past visible content" message. Caps the
+ * 9e15-line worst case from ⌘A in ByteSeek-no-index mode (where `focus.line` is set
+ * to `Number.MAX_SAFE_INTEGER`).
+ */
+export const MAX_ANNOUNCE_LINES = 10_000
+
+/**
+ * Builds the live-region announcement string for the current selection. Pure: takes
+ * a selection and a per-line length lookup, returns the string the screen reader will
+ * speak. Empty string means "nothing to announce".
+ *
+ * Caps the line-span at `MAX_ANNOUNCE_LINES`; past that, returns a generic message
+ * so the announcement work stays bounded (the alternative would freeze the UI on
+ * ⌘A in ByteSeek-no-index mode where the focus line is `Number.MAX_SAFE_INTEGER`).
+ */
+export function describeSelectionForAt(sel: Selection | null, getLineLength: (line: number) => number | null): string {
+  if (sel === null) return ''
+  const { start, end } = normaliseSelection(sel)
+  if (start.line === end.line && start.offset === end.offset) return ''
+
+  const lineSpan = end.line - start.line
+  if (lineSpan > MAX_ANNOUNCE_LINES) {
+    return `Selected from line ${String(start.line + 1)} to the end of the file`
+  }
+
+  let totalChars: number
+  if (start.line === end.line) {
+    totalChars = end.offset - start.offset
+  } else {
+    const startLineLen = getLineLength(start.line) ?? 0
+    let chars = startLineLen - start.offset
+    for (let i = start.line + 1; i < end.line; i++) {
+      chars += getLineLength(i) ?? 0
+    }
+    chars += end.offset
+    totalChars = chars
+  }
+
+  if (start.line === end.line) {
+    return `Selected ${String(totalChars)} characters on line ${String(start.line + 1)}`
+  }
+  return `Selected lines ${String(start.line + 1)} to ${String(end.line + 1)}, ${String(totalChars)} characters`
+}
+
 /**
  * Shift-click extension: returns a new selection that runs from the current selection's
  * anchor (or `point` if there's no current selection) to `point`. Caller-owned

apps/desktop/src/routes/viewer/selection.test.ts

@@ -2,13 +2,15 @@ import { describe, it, expect } from 'vitest'
 
 import {
   compareLineOffset,
+  describeSelectionForAt,
   estimateSelectionBytes,
   extendSelection,
   getLineSegmentBounds,
   isEmpty,
   isLineInRange,
   lineOffsetEquals,
   makeSelectAll,
+  MAX_ANNOUNCE_LINES,
   normaliseSelection,
   type Selection,
 } from './selection.svelte'
@@ -324,3 +326,71 @@ describe('estimateSelectionBytes', () => {
     )
   })
 })
+
+describe('describeSelectionForAt', () => {
+  // Test-local lookups for the line-length argument.
+  const allOnes = (): number | null => 1
+  const empty = (): number | null => null
+
+  it('null selection returns empty string', () => {
+    expect(describeSelectionForAt(null, empty)).toBe('')
+  })
+
+  it('caret-only (start == end) returns empty string', () => {
+    const sel: Selection = { anchor: { line: 3, offset: 4 }, focus: { line: 3, offset: 4 } }
+    expect(describeSelectionForAt(sel, empty)).toBe('')
+  })
+
+  it('single-line selection: announces character count and line number (1-indexed)', () => {
+    const sel: Selection = { anchor: { line: 4, offset: 2 }, focus: { line: 4, offset: 7 } }
+    expect(describeSelectionForAt(sel, allOnes)).toBe('Selected 5 characters on line 5')
+  })
+
+  it('multi-line selection: announces line range and total chars', () => {
+    // Lines 0..3, each "hello" (5 chars). Select from (0,2) to (3,3):
+    //   line 0 contributes "llo" (3), line 1 + 2 each contribute 5, line 3 contributes 3. Total 16.
+    const sel: Selection = { anchor: { line: 0, offset: 2 }, focus: { line: 3, offset: 3 } }
+    const getLen = (n: number) => (n >= 0 && n < 4 ? 5 : null)
+    expect(describeSelectionForAt(sel, getLen)).toBe('Selected lines 1 to 4, 16 characters')
+  })
+
+  it('ByteSeek-no-index ⌘A sentinel: line span > MAX_ANNOUNCE_LINES falls back to generic message', () => {
+    // The ⌘A path sets focus.line = Number.MAX_SAFE_INTEGER when totalLines is null.
+    // The pure function must not iterate 9e15 times.
+    const sel: Selection = {
+      anchor: { line: 0, offset: 0 },
+      focus: { line: Number.MAX_SAFE_INTEGER, offset: 0 },
+    }
+    let calls = 0
+    const counting = () => {
+      calls++
+      return 1
+    }
+    expect(describeSelectionForAt(sel, counting)).toBe('Selected from line 1 to the end of the file')
+    // The fallback path must not invoke the line-length lookup at all.
+    expect(calls).toBe(0)
+  })
+
+  it('line span exactly at the cap (MAX_ANNOUNCE_LINES) still itemises', () => {
+    const sel: Selection = {
+      anchor: { line: 0, offset: 0 },
+      focus: { line: MAX_ANNOUNCE_LINES, offset: 0 },
+    }
+    // Just verify we don't fall back; the exact char count isn't the point.
+    const result = describeSelectionForAt(sel, allOnes)
+    expect(result.startsWith('Selected lines')).toBe(true)
+  })
+
+  it('reversed selection: same result as the normalised version', () => {
+    const forward: Selection = { anchor: { line: 1, offset: 0 }, focus: { line: 3, offset: 2 } }
+    const reversed: Selection = { anchor: { line: 3, offset: 2 }, focus: { line: 1, offset: 0 } }
+    expect(describeSelectionForAt(forward, allOnes)).toBe(describeSelectionForAt(reversed, allOnes))
+  })
+
+  it('missing line length in lookup contributes 0 to the count (degrades gracefully)', () => {
+    const sel: Selection = { anchor: { line: 0, offset: 0 }, focus: { line: 2, offset: 0 } }
+    const result = describeSelectionForAt(sel, empty)
+    // line 0 contributes (0 - 0) = 0, intermediate line 1 contributes 0, line 2 contributes 0.
+    expect(result).toBe('Selected lines 1 to 3, 0 characters')
+  })
+})