feat(tests): enhance unit tests for AudioMixer, playbackRouter, songlengths, and source navigation

- Added tests for UltiSID 2 identity change and address handling in AudioMixer.
- Introduced tests for tryFetchUltimateSidBlob in playbackRouter, covering path normalization and error handling.
- Expanded songlengths tests to cover various edge cases, including empty durations and error handling during resolution.
- Enhanced InMemoryTextBackend tests to cover edge cases, including path normalization and duplicate entries.
- Improved ftpSourceAdapter tests to handle empty entries and cache expiration scenarios.
- Added localSourceAdapter tests for SAF entries and error handling.
- Enhanced LocalFsSongSource tests for duration resolution and error handling during metadata scans.
- Added fetchTrace and traceSession tests for event suppression and error handling.
- Introduced controlType tests for checkbox mapping and control kind inference.

Author: chrisgleissner

tests/unit/c64api.branches.test.ts

@@ -980,4 +980,104 @@ describe('c64api branches', () => {
     );
     consoleSpy.mockRestore();
   });
+
+  // #38: readMemory response not OK
+  it('throws when readMemory response is not ok', async () => {
+    const fetchMock = getFetchMock();
+    fetchMock.mockResolvedValue(
+      new Response('fail', { status: 404, statusText: 'Not Found' }),
+    );
+
+    const api = new C64API('http://c64u');
+    await expect(api.readMemory('0400', 4)).rejects.toThrow('readMemory failed: HTTP 404');
+  });
+
+  // #39: readMemory null content-type falls through to JSON path with no data
+  it('returns empty Uint8Array when readMemory JSON payload has no data field', async () => {
+    const fetchMock = getFetchMock();
+    fetchMock.mockResolvedValue(
+      new Response(JSON.stringify({}), {
+        status: 200,
+        // Intentionally no content-type header → null → coalesces to ''
+        headers: {},
+      }),
+    );
+
+    const api = new C64API('http://c64u');
+    const result = await api.readMemory('0400', 4);
+    expect(result).toBeInstanceOf(Uint8Array);
+    expect(result.length).toBe(0);
+  });
+
+  // #40: readMemory JSON payload with base64 string data
+  it('decodes base64 string data from readMemory JSON response', async () => {
+    const fetchMock = getFetchMock();
+    // btoa('\x00\x01\x02') → 'AAEC'
+    const encoded = btoa(String.fromCharCode(0, 1, 2));
+    fetchMock.mockResolvedValue(
+      new Response(JSON.stringify({ data: encoded }), {
+        status: 200,
+        headers: { 'content-type': 'application/json' },
+      }),
+    );
+
+    const api = new C64API('http://c64u');
+    const result = await api.readMemory('0400', 3);
+    expect(result).toBeInstanceOf(Uint8Array);
+    expect(result[0]).toBe(0);
+    expect(result[1]).toBe(1);
+    expect(result[2]).toBe(2);
+  });
+
+  // #41: readMemory JSON payload with number array data
+  it('returns Uint8Array from readMemory JSON number array data', async () => {
+    const fetchMock = getFetchMock();
+    fetchMock.mockResolvedValue(
+      new Response(JSON.stringify({ data: [10, 20, 30] }), {
+        status: 200,
+        headers: { 'content-type': 'application/json' },
+      }),
+    );
+
+    const api = new C64API('http://c64u');
+    const result = await api.readMemory('0400', 3);
+    expect(result).toBeInstanceOf(Uint8Array);
+    expect(result[0]).toBe(10);
+    expect(result[1]).toBe(20);
+    expect(result[2]).toBe(30);
+  });
+
+  // #42: readMemory octet-stream binary response
+  it('returns binary data from readMemory octet-stream response', async () => {
+    const fetchMock = getFetchMock();
+    const bytes = new Uint8Array([5, 6, 7, 8]);
+    fetchMock.mockResolvedValue(
+      new Response(bytes.buffer, {
+        status: 200,
+        headers: { 'content-type': 'application/octet-stream' },
+      }),
+    );
+
+    const api = new C64API('http://c64u');
+    const result = await api.readMemory('0400', 4);
+    expect(result).toBeInstanceOf(Uint8Array);
+    expect(Array.from(result)).toEqual([5, 6, 7, 8]);
+  });
+
+  // #43: readMemory application/binary response
+  it('returns binary data from readMemory application/binary response', async () => {
+    const fetchMock = getFetchMock();
+    const bytes = new Uint8Array([11, 22]);
+    fetchMock.mockResolvedValue(
+      new Response(bytes.buffer, {
+        status: 200,
+        headers: { 'content-type': 'application/binary' },
+      }),
+    );
+
+    const api = new C64API('http://c64u');
+    const result = await api.readMemory('0400', 2);
+    expect(result).toBeInstanceOf(Uint8Array);
+    expect(Array.from(result)).toEqual([11, 22]);
+  });
 });

tests/unit/components/AlphabetScrollbar.test.tsx

@@ -101,4 +101,258 @@ describe('AlphabetScrollbar', () => {
 
     vi.useRealTimers();
   });
+
+  it('maps items with numeric/symbol titles to # category', async () => {
+    const container = createScrollContainer();
+    setScrollMetrics(container, 1000, 100);
+    const onLetterSelect = vi.fn();
+    const items = [
+      { id: 'num', title: '1SongWithNumber' },
+      { id: 'empty', title: '' },
+    ];
+
+    render(
+      <AlphabetScrollbar
+        items={items}
+        scrollContainerRef={{ current: container }}
+        onLetterSelect={onLetterSelect}
+        onScrollToIndex={vi.fn()}
+      />,
+    );
+
+    const touchArea = await screen.findByTestId('alphabet-touch-area');
+    Object.defineProperty(touchArea, 'getBoundingClientRect', {
+      value: () => ({ top: 0, left: 0, right: 0, bottom: 260, width: 20, height: 260, x: 0, y: 0, toJSON: () => '' }),
+    });
+
+    // Touch at position that maps to '#' (first letter at top ~0 index)
+    fireEvent.touchStart(touchArea, { touches: [{ clientY: 1 }] });
+    expect(onLetterSelect).toHaveBeenCalledWith('#');
+  });
+
+  it('scrollToLetter returns early when letter has no items', async () => {
+    const container = createScrollContainer();
+    setScrollMetrics(container, 1000, 100);
+    const onLetterSelect = vi.fn();
+    const items = [
+      { id: 'alpha', title: 'Alpha' },
+    ];
+
+    render(
+      <AlphabetScrollbar
+        items={items}
+        scrollContainerRef={{ current: container }}
+        onLetterSelect={onLetterSelect}
+        onScrollToIndex={vi.fn()}
+      />,
+    );
+
+    const touchArea = await screen.findByTestId('alphabet-touch-area');
+    Object.defineProperty(touchArea, 'getBoundingClientRect', {
+      value: () => ({ top: 0, left: 0, right: 0, bottom: 260, width: 20, height: 260, x: 0, y: 0, toJSON: () => '' }),
+    });
+
+    // Touch at position that maps to 'Z' (last letter, near bottom)
+    fireEvent.touchStart(touchArea, { touches: [{ clientY: 255 }] });
+    // 'Z' is not in indices (only 'Alpha' starting with 'A' exists)
+    // scrollToLetter should return early with no call
+    // But note: '#' exists (empty title items don't exist here), and 'A' exists
+    // 'Z' at index 26 doesn't exist → early return
+    expect(onLetterSelect).not.toHaveBeenCalledWith('Z');
+  });
+
+  it('handles scroll event that shows and schedules hide', async () => {
+    vi.useFakeTimers();
+    const container = createScrollContainer();
+    setScrollMetrics(container, 1000, 100);
+
+    render(
+      <AlphabetScrollbar
+        items={[{ id: 'a', title: 'Alpha' }, { id: 'b', title: 'Beta' }]}
+        scrollContainerRef={{ current: container }}
+      />,
+    );
+
+    await act(async () => {
+      await Promise.resolve();
+    });
+
+    act(() => { container.dispatchEvent(new Event('scroll')); });
+
+    const overlay = screen.getByTestId('alphabet-overlay');
+    expect(overlay.className).toContain('opacity-100');
+
+    vi.useRealTimers();
+  });
+
+  it('uses onScrollToIndex callback when provided', async () => {
+    const container = createScrollContainer();
+    setScrollMetrics(container, 1000, 100);
+    const onScrollToIndex = vi.fn();
+    const items = [
+      { id: 'alpha', title: 'Alpha' },
+      { id: 'beta', title: 'Beta' },
+    ];
+
+    render(
+      <AlphabetScrollbar
+        items={items}
+        scrollContainerRef={{ current: container }}
+        onScrollToIndex={onScrollToIndex}
+      />,
+    );
+
+    const touchArea = await screen.findByTestId('alphabet-touch-area');
+    Object.defineProperty(touchArea, 'getBoundingClientRect', {
+      value: () => ({ top: 0, left: 0, right: 0, bottom: 260, width: 20, height: 260, x: 0, y: 0, toJSON: () => '' }),
+    });
+
+    // Touch at position that maps to 'A'
+    fireEvent.touchStart(touchArea, { touches: [{ clientY: 10 }] });
+    expect(onScrollToIndex).toHaveBeenCalledWith(0);
+  });
+
+  it('uses querySelector scrollIntoView when onScrollToIndex is not provided', async () => {
+    const container = createScrollContainer();
+    setScrollMetrics(container, 1000, 100);
+    const onLetterSelect = vi.fn();
+    const items = [
+      { id: 'alpha', title: 'Alpha' },
+    ];
+
+    render(
+      <AlphabetScrollbar
+        items={items}
+        scrollContainerRef={{ current: container }}
+        onLetterSelect={onLetterSelect}
+      />,
+    );
+
+    const touchArea = await screen.findByTestId('alphabet-touch-area');
+    Object.defineProperty(touchArea, 'getBoundingClientRect', {
+      value: () => ({ top: 0, left: 0, right: 0, bottom: 260, width: 20, height: 260, x: 0, y: 0, toJSON: () => '' }),
+    });
+
+    // Touch 'A' zone
+    fireEvent.touchStart(touchArea, { touches: [{ clientY: 10 }] });
+    // querySelector would look for [data-row-id="alpha"] in container
+    const alphaNode = container.querySelector('[data-row-id="alpha"]');
+    expect(alphaNode).not.toBeNull();
+    expect(onLetterSelect).toHaveBeenCalledWith('A');
+  });
+
+  it('handles pointer enter and leave events', async () => {
+    const container = createScrollContainer();
+    setScrollMetrics(container, 1000, 100);
+
+    render(
+      <AlphabetScrollbar
+        items={[{ id: 'a', title: 'Alpha' }, { id: 'b', title: 'Beta' }]}
+        scrollContainerRef={{ current: container }}
+      />,
+    );
+
+    const touchArea = await screen.findByTestId('alphabet-touch-area');
+    // pointer events should not throw
+    fireEvent.pointerEnter(touchArea);
+    fireEvent.pointerLeave(touchArea);
+
+    // overlay might be visible after pointer enter
+    const overlay = screen.getByTestId('alphabet-overlay');
+    expect(overlay).toBeInTheDocument();
+  });
+
+  it('handles touch move and end events', async () => {
+    const container = createScrollContainer();
+    setScrollMetrics(container, 1000, 100);
+    const onLetterSelect = vi.fn();
+
+    render(
+      <AlphabetScrollbar
+        items={[{ id: 'alpha', title: 'Alpha' }, { id: 'beta', title: 'Beta' }]}
+        scrollContainerRef={{ current: container }}
+        onLetterSelect={onLetterSelect}
+        onScrollToIndex={vi.fn()}
+      />,
+    );
+
+    const touchArea = await screen.findByTestId('alphabet-touch-area');
+    Object.defineProperty(touchArea, 'getBoundingClientRect', {
+      value: () => ({ top: 0, left: 0, right: 0, bottom: 260, width: 20, height: 260, x: 0, y: 0, toJSON: () => '' }),
+    });
+
+    fireEvent.touchStart(touchArea, { touches: [{ clientY: 10 }] });
+    fireEvent.touchMove(touchArea, { touches: [{ clientY: 30 }] });
+    fireEvent.touchEnd(touchArea);
+  });
+
+  it('handleScroll resets visibility when component is not eligible', async () => {
+    // 0 items + no overflowing container → isEligible stays false
+    const container = document.createElement('div');
+    setScrollMetrics(container, 100, 100); // not scrollable
+
+    render(
+      <AlphabetScrollbar
+        items={[]}
+        scrollContainerRef={{ current: container }}
+      />,
+    );
+
+    await act(async () => {
+      await Promise.resolve();
+    });
+
+    // touch area is NOT rendered (not eligible)
+    expect(screen.queryByTestId('alphabet-touch-area')).toBeNull();
+
+    // Fire scroll on the container — handleScroll should see isEligible=false
+    act(() => {
+      container.dispatchEvent(new Event('scroll'));
+    });
+    // No errors; overlay is not rendered
+    expect(screen.queryByTestId('alphabet-overlay')).toBeNull();
+  });
+
+  it('renders without crashing when ResizeObserver is unavailable', async () => {
+    const originalResizeObserver = window.ResizeObserver;
+    // Remove ResizeObserver to simulate unavailable environment (line 171 fallback)
+    Object.defineProperty(window, 'ResizeObserver', { value: undefined, configurable: true });
+
+    const container = createScrollContainer();
+    setScrollMetrics(container, 1000, 100);
+
+    render(
+      <AlphabetScrollbar
+        items={[{ id: 'alpha', title: 'Alpha' }]}
+        scrollContainerRef={{ current: container }}
+      />,
+    );
+
+    await act(async () => {
+      await Promise.resolve();
+    });
+
+    // Component still renders and becomes eligible
+    const overlay = screen.getByTestId('alphabet-overlay');
+    expect(overlay).toBeInTheDocument();
+
+    // Restore
+    Object.defineProperty(window, 'ResizeObserver', { value: originalResizeObserver, configurable: true });
+  });
+
+  it('handles null scrollContainerRef gracefully', async () => {
+    render(
+      <AlphabetScrollbar
+        items={[{ id: 'alpha', title: 'Alpha' }]}
+        scrollContainerRef={{ current: null }}
+      />,
+    );
+
+    await act(async () => {
+      await Promise.resolve();
+    });
+
+    // Component renders without crash; no touch area since not eligible
+    expect(screen.queryByTestId('alphabet-touch-area')).toBeNull();
+  });
 });