diff --git a/packages/demo/src/components/demo/nav.tsx b/packages/demo/src/components/demo/nav.tsx
index a5489109..0486a4b8 100644
--- a/packages/demo/src/components/demo/nav.tsx
+++ b/packages/demo/src/components/demo/nav.tsx
@@ -1,5 +1,6 @@
-import { useState, type MouseEvent } from "react";
+import { useEffect, useState, type MouseEvent } from "react";
 import {
+  Button,
   NavDrill,
   NavDrillLevel,
   NavList,
@@ -169,3 +170,66 @@ export function NavDemo() {
     </div>
   );
 }
+
+export function NavSwitcherErrorDemo() {
+  const [attempts, setAttempts] = useState(0);
+  const [retrying, setRetrying] = useState(false);
+  // The first retry fails too, so both outcomes show
+  const loaded = attempts >= 2;
+
+  useEffect(() => {
+    if (!retrying) return;
+    const timer = setTimeout(() => {
+      setRetrying(false);
+      setAttempts((count) => count + 1);
+    }, 1500);
+    return () => clearTimeout(timer);
+  }, [retrying]);
+
+  return (
+    <div
+      style={{
+        display: "flex",
+        flexDirection: "column",
+        alignItems: "start",
+        gap: 12,
+      }}
+    >
+      <div
+        style={{
+          width: 280,
+          borderRadius: 8,
+          border: "1px solid var(--color-border-raised)",
+        }}
+      >
+        <NavPanel
+          aria-label="Project: Ben Project"
+          header={
+            <NavSwitcher
+              label="Ben Project"
+              noun="project"
+              collection="projects"
+              options={loaded ? PROJECTS : []}
+              value="ben"
+              onValueChange={() => {}}
+              error={!loaded}
+              retrying={retrying}
+              onRetry={() => setRetrying(true)}
+            />
+          }
+        />
+      </div>
+      <Button
+        variant="secondary"
+        size="sm"
+        disabled={attempts === 0}
+        onClick={() => {
+          setRetrying(false);
+          setAttempts(0);
+        }}
+      >
+        Reset
+      </Button>
+    </div>
+  );
+}
diff --git a/packages/demo/src/content/docs/components/nav.mdx b/packages/demo/src/content/docs/components/nav.mdx
index d81ab6ee..3b442209 100644
--- a/packages/demo/src/content/docs/components/nav.mdx
+++ b/packages/demo/src/content/docs/components/nav.mdx
@@ -3,7 +3,7 @@ title: "Nav"
 description: "Sidebar navigation with an icon rail, a switcher and links that drill in and out"
 ---
 
-import { NavDemo } from "@demo/components/demo/nav";
+import { NavDemo, NavSwitcherErrorDemo } from "@demo/components/demo/nav";
 import { NavListDemo } from "@demo/components/demo/nav-list";
 
 ## Overview
@@ -206,6 +206,26 @@ A rail of top-level app sections in `NavRail` beside a `NavPanel`, with a switch
 
 The switcher's trigger stops a typed letter from picking an item while its list is closed: a switch navigates, and focus lands on the trigger afterwards. To do the same on your own `Select`, see [A select that navigates](/components/select#a-select-that-navigates).
 
+### When the List Fails to Load
+
+Pass `error` with `onRetry` when the list of items couldn't be read. The switcher stays a dropdown, and its list says so with a Retry row above any options it already has. Picking Retry calls `onRetry` and keeps the list open; pass `retrying` while that read runs, and the row reads "Retrying...". `error` stays true while the read runs, so `retrying` is what tells the switcher it has started.
+
+<NavSwitcherErrorDemo client:only="react" />
+
+```tsx
+<NavSwitcher
+  label={project.name}
+  noun="project"
+  collection="projects"
+  options={projects ?? []}
+  value={project.id}
+  onValueChange={switchProject}
+  error={projectsQuery.isError}
+  retrying={projectsQuery.isFetching}
+  onRetry={() => projectsQuery.refetch()}
+/>
+```
+
 ### Navigation in a Sheet
 
 On a phone, the sidebar comes in from the left in a [Sheet](/components/sheet). Give the sheet a title for screen readers. A sheet is at least a third of the screen wide, so set `minWidth: 0` to fit it to the list.
@@ -272,20 +292,23 @@ On a phone, the sidebar comes in from the left in a [Sheet](/components/sheet).
 
 ### NavSwitcher
 
-| Name             | Description                                                                                                                | Type                                      | Default | Required |
-| ---------------- | -------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------- | ------- | -------- |
-| `label`          | The current item's name, shown as the panel's heading                                                                      | `string`                                  |         | ✅       |
-| `noun`           | Singular, for the trigger's name: `{label}, switch {noun}`                                                                 | `string`                                  |         | ✅       |
-| `collection`     | Plural, for the search and empty copy                                                                                      | `string`                                  |         | ✅       |
-| `options`        | The items to switch between                                                                                                | `{ value, label, keywords? }[]`           |         | ✅       |
-| `value`          | The current item's value                                                                                                   | `string`                                  |         | ✅       |
-| `onValueChange`  | Called with the picked item's value                                                                                        | `(value: string) => void`                 |         | ✅       |
-| `onHighlight`    | Hover or focus on an option, to preload its destination                                                                    | `(value: string) => void`                 |         | ❌       |
-| `onHighlightEnd` | Hover or focus leaves an option, to cancel its preload                                                                     | `() => void`                              |         | ❌       |
-| `action`         | A command at the bottom of the list, kept while searching, such as "Create Project"; `onSelect` runs after the list closes | `{ label: string; onSelect: () => void }` |         | ❌       |
-| `loading`        | Holds the switcher's height while the current item loads                                                                   | `boolean`                                 | `false` | ❌       |
-
-With `loading`, the switcher takes no other props.
+| Name             | Description                                                                                                                | Type                                      | Default | Required     |
+| ---------------- | -------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------- | ------- | ------------ |
+| `label`          | The current item's name, shown as the panel's heading                                                                      | `string`                                  |         | ✅           |
+| `noun`           | Singular, for the trigger's name: `{label}, switch {noun}`                                                                 | `string`                                  |         | ✅           |
+| `collection`     | Plural, for the search and empty copy                                                                                      | `string`                                  |         | ✅           |
+| `options`        | The items to switch between                                                                                                | `{ value, label, keywords? }[]`           |         | ✅           |
+| `value`          | The current item's value                                                                                                   | `string`                                  |         | ✅           |
+| `onValueChange`  | Called with the picked item's value                                                                                        | `(value: string) => void`                 |         | ✅           |
+| `onHighlight`    | Hover or focus on an option, to preload its destination                                                                    | `(value: string) => void`                 |         | ❌           |
+| `onHighlightEnd` | Hover or focus leaves an option, to cancel its preload                                                                     | `() => void`                              |         | ❌           |
+| `action`         | A command at the bottom of the list, kept while searching, such as "Create Project"; `onSelect` runs after the list closes | `{ label: string; onSelect: () => void }` |         | ❌           |
+| `error`          | The list failed to load: the list says so and offers Retry; needs `onRetry`                                                | `boolean`                                 | `false` | ❌           |
+| `retrying`       | A retry is in flight: the Retry row reads "Retrying..."                                                                    | `boolean`                                 | `false` | ❌           |
+| `onRetry`        | Called when Retry is picked; the list stays open                                                                           | `() => void`                              |         | With `error` |
+| `loading`        | Holds the switcher's height while the current item loads                                                                   | `boolean`                                 | `false` | ❌           |
+
+With `loading`, the switcher takes no other props. With no `options`, no `action` and no `error`, it is a plain heading. One option is still a switcher, so the list shows it is the only one.
 
 ### NavListGroup
 
diff --git a/packages/ui/CHANGELOG.md b/packages/ui/CHANGELOG.md
index 2ef683ca..b44974ba 100644
--- a/packages/ui/CHANGELOG.md
+++ b/packages/ui/CHANGELOG.md
@@ -2,6 +2,23 @@
 
 Notable changes to Equality are recorded here, following [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
 
+## 5.0.2 - 2026-10-28
+
+### Added
+
+- `NavSwitcher` takes `error`, `retrying` and `onRetry`, and `error` needs `onRetry`. With `error`,
+  the list shows "Couldn't load {collection}." with a Retry row above any options it already has.
+  Picking Retry calls `onRetry` and keeps the list open; with `retrying` the row reads
+  "Retrying...". Screen readers hear the failure, the retry and its result, but not a refetch of a
+  list that never failed.
+
+### Changed
+
+- A `NavSwitcher` with one option is now a switcher where it was a plain heading, so a user with a
+  single project sees the switcher they will get with more. Apps showing one item will see a
+  dropdown appear. It is a plain heading only when it has no options, no `action` and no `error`.
+- `Spinner` renders spans, not divs, so it can sit inside text such as a select option.
+
 ## 5.0.1 - 2026-10-28
 
 ### Fixed
diff --git a/packages/ui/package.json b/packages/ui/package.json
index dd7be3b1..1e911d49 100644
--- a/packages/ui/package.json
+++ b/packages/ui/package.json
@@ -7,7 +7,7 @@
     "url": "git+https://github.com/eqtylab/equality.git",
     "directory": "packages/ui"
   },
-  "version": "5.0.1",
+  "version": "5.0.2",
   "license": "Apache-2.0",
   "keywords": [
     "component library",
diff --git a/packages/ui/src/components/nav/nav-switcher.tsx b/packages/ui/src/components/nav/nav-switcher.tsx
index 77f554b6..fcbf8c51 100644
--- a/packages/ui/src/components/nav/nav-switcher.tsx
+++ b/packages/ui/src/components/nav/nav-switcher.tsx
@@ -1,5 +1,5 @@
 import * as React from 'react';
-import { ChevronsUpDown } from 'lucide-react';
+import { ChevronsUpDown, TriangleAlert } from 'lucide-react';
 
 import { buttonVariants } from '@/components/button/button';
 import styles from '@/components/nav/nav.module.css';
@@ -14,6 +14,7 @@ import {
 } from '@/components/select/select';
 import { blockClosedTypeahead } from '@/components/select/select-typeahead';
 import { Skeleton } from '@/components/skeleton/skeleton';
+import { Spinner } from '@/components/spinner/spinner';
 import { cn } from '@/lib/utils';
 
 interface NavSwitcherOption {
@@ -32,7 +33,7 @@ interface NavSwitcherAction {
   onSelect: () => void;
 }
 
-interface NavSwitcherLoadedProps {
+interface NavSwitcherBaseProps {
   /** Shows a placeholder at the switcher's height while the current item loads */
   loading?: false;
   /** The current item's name, shown as the panel's heading */
@@ -55,6 +56,19 @@ interface NavSwitcherLoadedProps {
   action?: NavSwitcherAction;
 }
 
+type NavSwitcherRetryProps =
+  | { error?: false; retrying?: never; onRetry?: never }
+  | {
+      /** The list failed to load: the list says so and offers Retry */
+      error: boolean;
+      /** A retry is in flight: the Retry row reads "Retrying..." */
+      retrying?: boolean;
+      /** Called when Retry is picked; the list stays open */
+      onRetry: () => void;
+    };
+
+type NavSwitcherLoadedProps = NavSwitcherBaseProps & NavSwitcherRetryProps;
+
 interface NavSwitcherLoadingProps {
   loading: true;
 }
@@ -65,14 +79,53 @@ type NavSwitcherProps = NavSwitcherLoadedProps | NavSwitcherLoadingProps;
 // control does (WCAG 2.5.3)
 const NavSwitcherSelect = React.forwardRef<HTMLButtonElement, NavSwitcherLoadedProps>(
   (
-    { label, noun, collection, options, value, onValueChange, onHighlight, onHighlightEnd, action },
+    {
+      label,
+      noun,
+      collection,
+      options,
+      value,
+      onValueChange,
+      onHighlight,
+      onHighlightEnd,
+      action,
+      error,
+      retrying,
+      onRetry,
+    },
     ref
   ) => {
     const labelId = React.useId();
     const actionValue = React.useId();
+    const retryValue = React.useId();
+    const errorId = React.useId();
     const actionPending = React.useRef(false);
+    const [open, setOpen] = React.useState(false);
+    const keepOpen = React.useRef(false);
+    const [announcement, setAnnouncement] = React.useState('');
+    const [listState, setListState] = React.useState({ error, retrying });
+
+    if (listState.error !== error || listState.retrying !== retrying) {
+      setListState({ error, retrying });
+      // A background refetch toggles retrying with nothing to report
+      if (error || listState.error) {
+        setAnnouncement(
+          error
+            ? retrying
+              ? 'Retrying...'
+              : `Couldn't load ${collection}.`
+            : options.length > 0
+              ? `Loaded ${collection}.`
+              : `No ${collection} found.`
+        );
+      }
+    }
 
-    if (options.length <= 1 && !action) {
+    const empty = options.length === 0 && !action && !error;
+
+    // Open, the list stays until it closes: a retry that found nothing would otherwise unmount it
+    // under focus
+    if (empty && !open) {
       return (
         <h2 className={styles['nav-switcher-heading']}>
           <span
@@ -89,9 +142,27 @@ const NavSwitcherSelect = React.forwardRef<HTMLButtonElement, NavSwitcherLoadedP
       <h2 aria-labelledby={labelId} className={styles['nav-switcher-heading']}>
         <Select
           value={value}
+          open={open}
+          onOpenChange={(next) => {
+            if (!next && keepOpen.current) keepOpen.current = false;
+            else {
+              setOpen(next);
+              setAnnouncement('');
+            }
+          }}
           onValueChange={(next) => {
             if (next === actionValue) actionPending.current = true;
-            else onValueChange(next);
+            else if (next === retryValue) {
+              // Before the trigger mounts, or inside a form, Radix's hidden native select picks
+              // Retry when value matches no option; acting on that while closed refetches in a loop
+              if (!open) return;
+              keepOpen.current = true;
+              // Only an item pick is followed by a close to absorb
+              queueMicrotask(() => {
+                keepOpen.current = false;
+              });
+              if (!retrying) onRetry?.();
+            } else onValueChange(next);
           }}
         >
           <SelectTrigger
@@ -121,11 +192,46 @@ const NavSwitcherSelect = React.forwardRef<HTMLButtonElement, NavSwitcherLoadedP
               action?.onSelect();
             }}
           >
+            <div className={styles['nav-switcher-status']} role="status" aria-live="polite">
+              {announcement}
+            </div>
             <SelectSearch
               placeholder={`Search ${collection}...`}
               aria-label={`Search ${collection}`}
+              aria-describedby={error ? errorId : undefined}
             />
-            <SelectEmpty>No {collection} found</SelectEmpty>
+            {error && (
+              <SelectItem
+                value={retryValue}
+                textValue={`Couldn't load ${collection}. ${retrying ? 'Retrying' : 'Retry'}`}
+                persistent
+                aria-disabled={retrying || undefined}
+                className={styles['nav-switcher-retry']}
+              >
+                <span className={styles['nav-switcher-error']}>
+                  <span id={errorId} className={styles['nav-switcher-error-message']}>
+                    <TriangleAlert
+                      className={styles['nav-switcher-error-icon']}
+                      aria-hidden="true"
+                    />
+                    Couldn&apos;t load {collection}.
+                  </span>
+                  {retrying ? (
+                    <span className={styles['nav-switcher-error-message']}>
+                      <Spinner size="xs" variant="neutral" />
+                      Retrying...
+                    </span>
+                  ) : (
+                    <span className={buttonVariants({ variant: 'link', size: 'sm' })}>Retry</span>
+                  )}
+                </span>
+              </SelectItem>
+            )}
+            {empty ? (
+              <div className={styles['nav-switcher-empty']}>No {collection} found</div>
+            ) : (
+              (!error || options.length > 0) && <SelectEmpty>No {collection} found</SelectEmpty>
+            )}
             {options.map((option) => (
               <SelectItem
                 key={option.value}
diff --git a/packages/ui/src/components/nav/nav.module.css b/packages/ui/src/components/nav/nav.module.css
index f663ee35..abc5eb82 100644
--- a/packages/ui/src/components/nav/nav.module.css
+++ b/packages/ui/src/components/nav/nav.module.css
@@ -159,16 +159,38 @@
 }
 
 /* Two classes to outrank the Select's own item layout */
-.nav-switcher-list .nav-switcher-action {
+.nav-switcher-list .nav-switcher-action,
+.nav-switcher-list .nav-switcher-retry {
   @apply justify-center;
 }
 
-/* The action is never ticked, so its check column only pushes the label off centre. SelectItem
-   leaves that column an empty span; Studio's SW-019 fails if that changes */
-.nav-switcher-action > span:empty {
+/* The action and Retry are never ticked, so their check column only pushes them off centre.
+   SelectItem leaves that column an empty span; Studio's SW-019 fails if that changes */
+.nav-switcher-action > span:empty,
+.nav-switcher-retry > span:empty {
   @apply hidden;
 }
 
+.nav-switcher-error {
+  @apply text-text-secondary flex items-center gap-2 text-xs;
+}
+
+.nav-switcher-error-message {
+  @apply flex items-center gap-1.5;
+}
+
+.nav-switcher-error-icon {
+  @apply text-text-warning size-3.5 shrink-0;
+}
+
+.nav-switcher-status {
+  @apply sr-only;
+}
+
+.nav-switcher-empty {
+  @apply dropdown-empty;
+}
+
 .nav-rail-item:hover {
   @apply bg-list-item-hover text-text-primary;
 }
diff --git a/packages/ui/src/components/spinner/spinner.module.css b/packages/ui/src/components/spinner/spinner.module.css
index 600c5351..3bafd4cf 100644
--- a/packages/ui/src/components/spinner/spinner.module.css
+++ b/packages/ui/src/components/spinner/spinner.module.css
@@ -1,10 +1,11 @@
 @reference '../../theme/theme.module.css';
 
 .spinner-container {
-  @apply relative;
+  @apply relative block;
 }
 
 .spinner {
+  @apply block;
   @apply border-t-transparent;
   @apply rounded-full;
   @apply animate-spin;
diff --git a/packages/ui/src/components/spinner/spinner.tsx b/packages/ui/src/components/spinner/spinner.tsx
index b06c3013..11c56f43 100644
--- a/packages/ui/src/components/spinner/spinner.tsx
+++ b/packages/ui/src/components/spinner/spinner.tsx
@@ -8,9 +8,9 @@ interface SpinnerProps {
 
 export const Spinner = ({ size = 'md', variant = 'primary' }: SpinnerProps) => {
   return (
-    <div className={styles['spinner-container']}>
-      <div className={cn(styles['spinner'], styles[size], styles[variant])} />
-      <div className={cn(styles['spinner-background'], styles[size])} />
-    </div>
+    <span className={styles['spinner-container']}>
+      <span className={cn(styles['spinner'], styles[size], styles[variant])} />
+      <span className={cn(styles['spinner-background'], styles[size])} />
+    </span>
   );
 };
diff --git a/packages/ui/tests/nav.test.tsx b/packages/ui/tests/nav.test.tsx
index 6584ff39..e4c7bcb6 100644
--- a/packages/ui/tests/nav.test.tsx
+++ b/packages/ui/tests/nav.test.tsx
@@ -1,7 +1,8 @@
 import * as React from 'react';
 import { renderToString } from 'react-dom/server';
-import { render, screen } from '@testing-library/react';
-import { describe, expect, it } from 'vitest';
+import { fireEvent, render, screen } from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
+import { describe, expect, it, vi } from 'vitest';
 
 import { NavPanel } from '@/components/nav/nav-panel';
 import { NavRail, NavRailItem } from '@/components/nav/nav-rail';
@@ -87,13 +88,13 @@ describe('Nav shell', () => {
     expect(screen.getByRole('navigation').contains(scroller)).toBe(true);
   });
 
-  it('renders a plain heading when there is one option and no action', () => {
+  it('renders a plain heading when there are no options and no action', () => {
     render(
       <NavSwitcher
         label="Ben Project"
         noun="project"
         collection="projects"
-        options={[OPTIONS[0]]}
+        options={[]}
         value="ben"
         onValueChange={() => {}}
       />
@@ -102,6 +103,251 @@ describe('Nav shell', () => {
     expect(screen.queryByRole('combobox')).toBeNull();
   });
 
+  it('stays a switcher with one option', () => {
+    render(
+      <NavSwitcher
+        label="Ben Project"
+        noun="project"
+        collection="projects"
+        options={[OPTIONS[0]]}
+        value="ben"
+        onValueChange={() => {}}
+      />
+    );
+    expect(screen.getByRole('combobox', { name: 'Ben Project, switch project' })).toBeTruthy();
+  });
+
+  it('offers Retry after a failed list and keeps the list open when it is picked', async () => {
+    const user = userEvent.setup();
+    const onRetry = vi.fn();
+    const onValueChange = vi.fn();
+    render(
+      <NavSwitcher
+        label="Ben Project"
+        noun="project"
+        collection="projects"
+        options={[]}
+        value="ben"
+        onValueChange={onValueChange}
+        error
+        onRetry={onRetry}
+      />
+    );
+    screen.getByRole('combobox', { name: 'Ben Project, switch project' }).focus();
+    await user.keyboard('{Enter}');
+    await screen.findByRole('listbox');
+    const message = screen.getByText("Couldn't load projects.");
+    expect(screen.getByText('Retry')).toBeTruthy();
+    expect(screen.queryByText('No projects found')).toBeNull();
+    expect(screen.getByPlaceholderText('Search projects...').getAttribute('aria-describedby')).toBe(
+      message.id
+    );
+
+    await user.keyboard('{ArrowDown}{Enter}');
+    expect(onRetry).toHaveBeenCalledTimes(1);
+    expect(onValueChange).not.toHaveBeenCalled();
+    expect(screen.getByRole('listbox')).toBeTruthy();
+  });
+
+  it('keeps the list open when Retry is clicked', async () => {
+    const user = userEvent.setup();
+    const onRetry = vi.fn();
+    render(
+      <NavSwitcher
+        label="Ben Project"
+        noun="project"
+        collection="projects"
+        options={[]}
+        value="ben"
+        onValueChange={() => {}}
+        error
+        onRetry={onRetry}
+      />
+    );
+    await user.click(screen.getByRole('combobox', { name: 'Ben Project, switch project' }));
+    await screen.findByRole('listbox');
+    await user.click(screen.getByText('Retry'));
+    expect(onRetry).toHaveBeenCalledTimes(1);
+    expect(screen.getByRole('listbox')).toBeTruthy();
+  });
+
+  it('still closes on Escape after a Retry pick that the list never closes for', async () => {
+    const user = userEvent.setup();
+    const onRetry = vi.fn();
+    render(
+      <form>
+        <NavSwitcher
+          label="Ben Project"
+          noun="project"
+          collection="projects"
+          options={[]}
+          value="ben"
+          onValueChange={() => {}}
+          error
+          onRetry={onRetry}
+        />
+      </form>
+    );
+    screen.getByRole('combobox', { name: 'Ben Project, switch project' }).focus();
+    await user.keyboard('{Enter}');
+    await screen.findByRole('listbox');
+    const select = document.querySelector('select')!;
+    fireEvent.change(select, { target: { value: select.options[0]?.value } });
+    expect(onRetry).toHaveBeenCalledTimes(1);
+
+    await user.keyboard('{Escape}');
+    expect(screen.queryByRole('listbox')).toBeNull();
+  });
+
+  it('reads Retrying, marks Retry unavailable and ignores it while a retry is in flight', async () => {
+    const user = userEvent.setup();
+    const onRetry = vi.fn();
+    render(
+      <NavSwitcher
+        label="Ben Project"
+        noun="project"
+        collection="projects"
+        options={[]}
+        value="ben"
+        onValueChange={() => {}}
+        error
+        retrying
+        onRetry={onRetry}
+      />
+    );
+    screen.getByRole('combobox', { name: 'Ben Project, switch project' }).focus();
+    await user.keyboard('{Enter}');
+    await screen.findByRole('listbox');
+    const row = screen.getByText('Retrying...').closest('[role="option"]')!;
+    expect(row.getAttribute('aria-disabled')).toBe('true');
+
+    await user.keyboard('{ArrowDown}{Enter}');
+    expect(onRetry).not.toHaveBeenCalled();
+    expect(screen.getByRole('listbox')).toBeTruthy();
+  });
+
+  it('announces a retry and its result to screen readers', async () => {
+    const user = userEvent.setup();
+    const props = {
+      label: 'Ben Project',
+      noun: 'project',
+      collection: 'projects',
+      value: 'ben',
+      onValueChange: () => {},
+    };
+    const { rerender } = render(<NavSwitcher {...props} options={[]} error onRetry={() => {}} />);
+    screen.getByRole('combobox', { name: 'Ben Project, switch project' }).focus();
+    await user.keyboard('{Enter}');
+    await screen.findByRole('listbox');
+    const announced = (text: string) => screen.getByText(text, { selector: '[role="status"]' });
+
+    rerender(<NavSwitcher {...props} options={[]} error retrying onRetry={() => {}} />);
+    expect(announced('Retrying...')).toBeTruthy();
+    rerender(<NavSwitcher {...props} options={[]} error onRetry={() => {}} />);
+    expect(announced("Couldn't load projects.")).toBeTruthy();
+    rerender(<NavSwitcher {...props} options={OPTIONS} />);
+    expect(announced('Loaded projects.')).toBeTruthy();
+
+    await user.keyboard('{ArrowDown}');
+    expect(document.activeElement?.getAttribute('role')).toBe('option');
+  });
+
+  it('lists the loaded options beside Retry and says when a search matches none', async () => {
+    const user = userEvent.setup();
+    render(
+      <NavSwitcher
+        label="Ben Project"
+        noun="project"
+        collection="projects"
+        options={OPTIONS}
+        value="ben"
+        onValueChange={() => {}}
+        error
+        onRetry={() => {}}
+      />
+    );
+    screen.getByRole('combobox', { name: 'Ben Project, switch project' }).focus();
+    await user.keyboard('{Enter}');
+    await screen.findByRole('listbox');
+    expect(screen.getByText('Retry')).toBeTruthy();
+    expect(screen.getByText('Ada Project')).toBeTruthy();
+
+    await user.type(screen.getByPlaceholderText('Search projects...'), 'zzz');
+    expect(screen.getByText('No projects found')).toBeTruthy();
+    expect(screen.getByText('Retry')).toBeTruthy();
+  });
+
+  it('announces nothing when a list that never failed refetches', async () => {
+    const user = userEvent.setup();
+    const props = {
+      label: 'Ben Project',
+      noun: 'project',
+      collection: 'projects',
+      options: OPTIONS,
+      value: 'ben',
+      onValueChange: () => {},
+      onRetry: () => {},
+    };
+    const { rerender } = render(<NavSwitcher {...props} error={false} />);
+    screen.getByRole('combobox', { name: 'Ben Project, switch project' }).focus();
+    await user.keyboard('{Enter}');
+    await screen.findByRole('listbox');
+
+    rerender(<NavSwitcher {...props} error={false} retrying />);
+    rerender(<NavSwitcher {...props} error={false} />);
+    expect(screen.queryByText('Loaded projects.')).toBeNull();
+  });
+
+  it('keeps the list open when a retry finds nothing, and goes plain once it closes', async () => {
+    const user = userEvent.setup();
+    const props = {
+      label: 'Ben Project',
+      noun: 'project',
+      collection: 'projects',
+      options: [],
+      value: 'ben',
+      onValueChange: () => {},
+    };
+    const { rerender } = render(<NavSwitcher {...props} error onRetry={() => {}} />);
+    screen.getByRole('combobox', { name: 'Ben Project, switch project' }).focus();
+    await user.keyboard('{Enter}');
+    await screen.findByRole('listbox');
+
+    rerender(<NavSwitcher {...props} />);
+    expect(screen.getByRole('listbox')).toBeTruthy();
+    expect(screen.getByText('No projects found')).toBeTruthy();
+    expect(screen.getByText('No projects found.', { selector: '[role="status"]' })).toBeTruthy();
+
+    await user.keyboard('{Escape}');
+    expect(screen.queryByRole('listbox')).toBeNull();
+    expect(screen.queryByRole('combobox')).toBeNull();
+    expect(screen.getByRole('heading', { name: 'Ben Project' })).toBeTruthy();
+
+    rerender(<NavSwitcher {...props} options={OPTIONS} />);
+    expect(screen.queryByRole('listbox')).toBeNull();
+  });
+
+  it('never retries from a closed list inside a form', () => {
+    const onRetry = vi.fn();
+    render(
+      <form>
+        <NavSwitcher
+          label="Ben Project"
+          noun="project"
+          collection="projects"
+          options={[]}
+          value="ben"
+          onValueChange={() => {}}
+          error
+          onRetry={onRetry}
+        />
+      </form>
+    );
+    const select = document.querySelector('select')!;
+    fireEvent.change(select, { target: { value: select.options[0]?.value } });
+    expect(onRetry).not.toHaveBeenCalled();
+  });
+
   it('names the switcher trigger by the label and what it does', () => {
     const ref = React.createRef<HTMLButtonElement>();
     render(