diff --git a/jest.config.ts b/jest.config.ts
index 339497d..b4a0f47 100644
--- a/jest.config.ts
+++ b/jest.config.ts
@@ -7,8 +7,9 @@ const config: Config = {
   moduleNameMapper: {
     '^@/(.*)$': '<rootDir>/src/$1',
   },
+  transformIgnorePatterns: ['/node_modules/(?!@uidotdev/usehooks/)'],
   transform: {
-    '^.+\\.(ts|tsx)?$': 'ts-jest',
+    '^.+\\.[jt]sx?$': 'ts-jest',
   },
 };
 
diff --git a/src/components/CompetitionListItem/CompetitionListItem.tsx b/src/components/CompetitionListItem/CompetitionListItem.tsx
index 9edbc19..dd0c796 100644
--- a/src/components/CompetitionListItem/CompetitionListItem.tsx
+++ b/src/components/CompetitionListItem/CompetitionListItem.tsx
@@ -31,42 +31,40 @@ export const CompetitionListItem = ({
     new Date(end_date).getTime() + 1000 * 60 * new Date().getTimezoneOffset(),
   );
 
-  return (
-    <Link to={`/competitions/${id}`}>
-      <li
-        className={classNames(
-          variant === 'card'
-            ? 'link-card list-none flex flex-row cursor-pointer group hover-transition my-1 type-body'
-            : 'list-none flex flex-row cursor-pointer group hover-transition type-body w-full px-2 py-2 bg-panel hover:bg-gray-100 dark:hover:bg-gray-700',
-          {
-            'opacity-50': endDate < new Date(Date.now() - 1000 * 60 * 60 * 24),
-          },
-        )}>
-        {hasFlag(country_iso2) && (
-          <div className="flex flex-shrink mr-2 type-title">
-            {' '}
-            {getUnicodeFlagIcon(country_iso2)}{' '}
-          </div>
-        )}
-        <div className="flex-1">
-          <p className="type-heading leading-1 dark:text-white"> {name} </p>{' '}
-          <p className="type-body-sm text-muted leading-1">
-            {formatDateRange(start_date, end_date)}
-            {'  '}&#8211;{'  '}
-            {city}
-          </p>
+  const Item = variant === 'dropdown' ? 'div' : 'li';
+  const content = (
+    <Item
+      className={classNames(
+        variant === 'card'
+          ? 'link-card list-none flex flex-row cursor-pointer group hover-transition my-1 type-body'
+          : 'list-none flex flex-row cursor-pointer group hover-transition type-body w-full px-2 py-2',
+        {
+          'opacity-50': endDate < new Date(Date.now() - 1000 * 60 * 60 * 24),
+        },
+      )}>
+      {hasFlag(country_iso2) && (
+        <div className="flex flex-shrink mr-2 type-title"> {getUnicodeFlagIcon(country_iso2)} </div>
+      )}
+      <div className="flex-1">
+        <p className="type-heading leading-1 dark:text-white"> {name} </p>{' '}
+        <p className="type-body-sm text-muted leading-1">
+          {formatDateRange(start_date, end_date)}
+          {'  '}&#8211;{'  '}
+          {city}
+        </p>
+      </div>
+      {isLive && (
+        <div className="flex items-center flex-shrink px-2 type-title">
+          <span className="text-green-500 fa fa-tower-broadcast" />
         </div>
-        {isLive && (
-          <div className="flex items-center flex-shrink px-2 type-title">
-            <span className="text-green-500 fa fa-tower-broadcast" />
-          </div>
-        )}
-        {isBookmarked && !isLive && (
-          <div className="flex items-center flex-shrink px-2 type-title">
-            <span className="text-yellow-500 fa fa-bookmark" />
-          </div>
-        )}
-      </li>
-    </Link>
+      )}
+      {isBookmarked && !isLive && (
+        <div className="flex items-center flex-shrink px-2 type-title">
+          <span className="text-yellow-500 fa fa-bookmark" />
+        </div>
+      )}
+    </Item>
   );
+
+  return variant === 'dropdown' ? content : <Link to={`/competitions/${id}`}>{content}</Link>;
 };
diff --git a/src/components/CompetitionSelect/CompetitionSelect.test.tsx b/src/components/CompetitionSelect/CompetitionSelect.test.tsx
new file mode 100644
index 0000000..3c747a7
--- /dev/null
+++ b/src/components/CompetitionSelect/CompetitionSelect.test.tsx
@@ -0,0 +1,133 @@
+import { act, fireEvent, render, screen, waitFor } from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
+import { MemoryRouter } from 'react-router-dom';
+import { fetchSearchCompetition } from '@/lib/api';
+import { CompetitionSelect } from './CompetitionSelect';
+
+jest.mock('@/lib/api', () => ({ fetchSearchCompetition: jest.fn() }));
+jest.mock('@/providers/UserSettingsProvider', () => ({
+  useUserSettings: () => ({ effectiveTheme: 'light' }),
+}));
+jest.mock('react-i18next', () => ({ useTranslation: () => ({ t: (key: string) => key }) }));
+const competition = {
+  id: 'Campulung2026',
+  name: 'Campulung Moldovenesc Open 2026',
+  start_date: '2026-10-31',
+  end_date: '2026-10-31',
+  country_iso2: 'RO',
+  city: 'Campulung Moldovenesc',
+} as ApiCompetition;
+const mockSearch = jest.mocked(fetchSearchCompetition);
+beforeEach(() => {
+  jest.clearAllMocks();
+  mockSearch.mockResolvedValue({ result: [competition] });
+});
+
+it('exposes a named combobox and real options with usable active-descendant IDs', async () => {
+  render(<CompetitionSelect onSelect={jest.fn()} />, { wrapper: MemoryRouter });
+  const input = screen.getByRole('combobox', { name: 'common.competitionSelect.placeholder' });
+  await act(async () => {
+    await userEvent.type(input, 'Campulung');
+  });
+  const option = await screen.findByRole('option', { name: /Campulung Moldovenesc Open 2026/ });
+  await act(async () => {
+    await userEvent.keyboard('{ArrowDown}');
+  });
+  expect(input).toHaveAttribute('aria-activedescendant', option.id);
+  expect(option.id).not.toBe('');
+  expect(option).toHaveAttribute('aria-selected', 'false');
+  expect(option.querySelector('a')).toBeNull();
+});
+
+it.each(['keyboard', 'pointer'])('selects the same competition once by %s', async (method) => {
+  const onSelect = jest.fn();
+  render(<CompetitionSelect onSelect={onSelect} />, { wrapper: MemoryRouter });
+  await act(async () => {
+    await userEvent.type(screen.getByRole('combobox'), 'Campulung');
+  });
+  await screen.findByText(competition.name);
+  if (method === 'keyboard')
+    await act(async () => {
+      await userEvent.keyboard('{ArrowDown}{Enter}');
+    });
+  else
+    await act(async () => {
+      await userEvent.click(screen.getByText(competition.name));
+    });
+  expect(onSelect).toHaveBeenCalledTimes(1);
+  expect(onSelect).toHaveBeenCalledWith(competition.id);
+  expect(screen.queryByRole('listbox')).not.toBeInTheDocument();
+  expect(screen.getByRole('combobox')).toHaveFocus();
+});
+
+it('dismisses with Escape and can search and select again without accidental navigation', async () => {
+  const onSelect = jest.fn();
+  render(<CompetitionSelect onSelect={onSelect} />, { wrapper: MemoryRouter });
+  const input = screen.getByRole('combobox');
+  await act(async () => {
+    await userEvent.type(input, 'Campulung');
+  });
+  await screen.findByText(competition.name);
+  await act(async () => {
+    await userEvent.keyboard('{Escape}');
+  });
+  await act(async () => {
+    await userEvent.keyboard('{Enter}');
+  });
+  expect(onSelect).not.toHaveBeenCalled();
+  expect(input).toHaveFocus();
+  await act(async () => {
+    await userEvent.clear(input);
+  });
+  await act(async () => {
+    await userEvent.type(input, 'Campulung');
+  });
+  await screen.findByRole('option');
+  await act(async () => {
+    await userEvent.keyboard('{ArrowDown}{Enter}');
+  });
+  expect(onSelect).toHaveBeenCalledWith(competition.id);
+});
+
+it('ignores a stale response after a newer query or after the search is cleared', async () => {
+  let resolveOld!: (value: { result: ApiCompetition[] }) => void;
+  mockSearch.mockImplementationOnce(
+    () =>
+      new Promise((resolve) => {
+        resolveOld = resolve;
+      }),
+  );
+  const onSelect = jest.fn();
+  render(<CompetitionSelect onSelect={onSelect} />, { wrapper: MemoryRouter });
+  const input = screen.getByRole('combobox');
+  fireEvent.change(input, { target: { value: 'Old' } });
+  await waitFor(() => expect(mockSearch).toHaveBeenCalledWith('Old'));
+  fireEvent.change(input, { target: { value: 'Campulung' } });
+  await screen.findByText(competition.name);
+  await act(async () =>
+    resolveOld({ result: [{ ...competition, id: 'Old2026', name: 'Old competition' }] }),
+  );
+  expect(screen.queryByText('Old competition')).not.toBeInTheDocument();
+  await act(async () => {
+    await userEvent.clear(input);
+  });
+  expect(screen.queryByRole('option')).not.toBeInTheDocument();
+  expect(onSelect).not.toHaveBeenCalled();
+});
+
+it('cancels an unstarted search when navigation unmounts the control', async () => {
+  jest.useFakeTimers();
+  try {
+    const { unmount } = render(<CompetitionSelect onSelect={jest.fn()} />, {
+      wrapper: MemoryRouter,
+    });
+    fireEvent.change(screen.getByRole('combobox'), { target: { value: 'Campulung' } });
+    unmount();
+    await act(async () => {
+      jest.runAllTimers();
+    });
+    expect(mockSearch).not.toHaveBeenCalled();
+  } finally {
+    jest.useRealTimers();
+  }
+});
diff --git a/src/components/CompetitionSelect/CompetitionSelect.tsx b/src/components/CompetitionSelect/CompetitionSelect.tsx
index ff58920..6d6e934 100644
--- a/src/components/CompetitionSelect/CompetitionSelect.tsx
+++ b/src/components/CompetitionSelect/CompetitionSelect.tsx
@@ -1,8 +1,12 @@
-import { useCallback, useRef } from 'react';
+import { useCallback, useEffect, useRef } from 'react';
 import { useTranslation } from 'react-i18next';
-import type { ClassNamesConfig, StylesConfig } from 'react-select';
+import {
+  components,
+  type ClassNamesConfig,
+  type OptionProps,
+  type StylesConfig,
+} from 'react-select';
 import AsyncSelect from 'react-select/async';
-import { OptionProps } from 'react-select/dist/declarations/src';
 import { fetchSearchCompetition } from '@/lib/api';
 import { useUserSettings } from '@/providers/UserSettingsProvider';
 import { CompetitionListItem } from '../CompetitionListItem';
@@ -139,6 +143,11 @@ export const CompetitionSelect = ({ onSelect, className }: CompetitionSelectProp
       className={className}
       classNamePrefix="cg-select"
       cacheOptions
+      aria-label={t('common.competitionSelect.placeholder')}
+      getOptionLabel={(option) => option.name}
+      getOptionValue={(option) => option.id}
+      blurInputOnSelect={false}
+      loadingMessage={() => t('common.loading')}
       loadOptions={loadOptions}
       placeholder={t('common.competitionSelect.placeholder')}
       noOptionsMessage={({ inputValue }) =>
@@ -154,9 +163,11 @@ export const CompetitionSelect = ({ onSelect, className }: CompetitionSelectProp
   );
 };
 
-export const CompetitionOption = ({ data }: OptionProps<ApiCompetition>) => {
-  return <CompetitionListItem {...data} isLive={false} variant="dropdown" />;
-};
+export const CompetitionOption = (props: OptionProps<ApiCompetition, false>) => (
+  <components.Option {...props}>
+    <CompetitionListItem {...props.data} isLive={false} variant="dropdown" />
+  </components.Option>
+);
 
 function useDebounced<Input, Output>(
   fn: (arg: Input) => Promise<Output>,
@@ -164,6 +175,13 @@ function useDebounced<Input, Output>(
 ): (arg: Input) => Promise<Output> {
   const timeout = useRef<ReturnType<typeof setTimeout> | null>(null);
 
+  useEffect(
+    () => () => {
+      if (timeout.current) clearTimeout(timeout.current);
+    },
+    [],
+  );
+
   return useCallback(
     (arg: Input) => {
       if (timeout.current) {
diff --git a/src/components/Container/Container.tsx b/src/components/Container/Container.tsx
index bc032f9..147d7e0 100644
--- a/src/components/Container/Container.tsx
+++ b/src/components/Container/Container.tsx
@@ -4,11 +4,18 @@ import { PropsWithChildren } from 'react';
 interface ContainerProps extends PropsWithChildren {
   className?: string;
   fullWidth?: boolean;
+  scrollRestorationId?: string;
 }
 
-export const Container = ({ children, className, fullWidth = false }: ContainerProps) => {
+export const Container = ({
+  children,
+  className,
+  fullWidth = false,
+  scrollRestorationId,
+}: ContainerProps) => {
   return (
     <div
+      data-scroll-restoration={scrollRestorationId}
       className={classNames(
         'flex flex-col w-full h-max',
         {
diff --git a/src/components/CutoffTimeLimitPanel/CutoffTimeLimitPanel.advancement.test.tsx b/src/components/CutoffTimeLimitPanel/CutoffTimeLimitPanel.advancement.test.tsx
new file mode 100644
index 0000000..56dea46
--- /dev/null
+++ b/src/components/CutoffTimeLimitPanel/CutoffTimeLimitPanel.advancement.test.tsx
@@ -0,0 +1,113 @@
+import { render, screen } from '@testing-library/react';
+import { Competition, EventId, RankingType, Round } from '@wca/helpers';
+import { readFileSync } from 'fs';
+import { createInstance } from 'i18next';
+import { load } from 'js-yaml';
+import { I18nextProvider, initReactI18next } from 'react-i18next';
+import { MemoryRouter } from 'react-router-dom';
+import { CutoffTimeLimitPanel } from './CutoffTimeLimitPanel';
+
+let competitionMock: Pick<Competition, 'events'>;
+jest.mock('@/providers/WCIFProvider', () => ({
+  useWCIF: () => ({ wcif: competitionMock }),
+}));
+
+const makeRound = (id: string): Round => ({
+  id,
+  format: 'a',
+  cutoff: null,
+  timeLimit: null,
+  linkedRounds: null,
+  participationRuleset: null,
+  results: [],
+  extensions: [],
+});
+
+const renderThreshold = async (
+  eventId: EventId,
+  scope: RankingType,
+  value: number | null,
+  linked: boolean,
+) => {
+  const rounds = Array.from({ length: linked ? 3 : 2 }, (_, i) =>
+    makeRound(`${eventId}-r${i + 1}`),
+  );
+  const sourceIds = rounds.slice(0, -1).map(({ id }) => id);
+  rounds.at(-1)!.participationRuleset = {
+    reservedPlaces: null,
+    participationSource: linked
+      ? {
+          type: 'linkedRounds',
+          roundIds: sourceIds,
+          resultCondition: { type: 'resultAchieved', scope, value },
+        }
+      : {
+          type: 'round',
+          roundId: sourceIds[0],
+          resultCondition: { type: 'resultAchieved', scope, value },
+        },
+  };
+  competitionMock = { events: [{ id: eventId, rounds, extensions: [] }] };
+  const i18n = createInstance();
+  await i18n.use(initReactI18next).init({
+    lng: 'en',
+    fallbackLng: 'en',
+    resources: {
+      en: { translation: load(readFileSync('src/i18n/en/translation.yaml', 'utf8')) as object },
+    },
+    interpolation: { escapeValue: false },
+  });
+  return render(
+    <I18nextProvider i18n={i18n}>
+      <MemoryRouter>
+        <CutoffTimeLimitPanel round={rounds[0]} />
+      </MemoryRouter>
+    </I18nextProvider>,
+  );
+};
+
+const cap = '; minimum of 25% of competitors must be eliminated';
+
+describe.each([false, true])('actual translated advancement captions (linked=%s)', (linked) => {
+  const source = linked ? ' in dual rounds 1 & 2' : '';
+  it.each<RankingType>(['single', 'average'])(
+    'describes a null %s threshold as any successful result',
+    async (scope) => {
+      await renderThreshold('333', scope, null, linked);
+      expect(
+        screen.getByText(`Any successful ${scope}${source} advances to final${cap}`),
+      ).toBeInTheDocument();
+      expect(document.body).not.toHaveTextContent('unknown result');
+      expect(document.body).not.toHaveTextContent('<');
+    },
+  );
+
+  it('renders an FMC single threshold in moves', async () => {
+    await renderThreshold('333fm', 'single', 30, linked);
+    expect(
+      screen.getByText(`Singles better than 30 moves${source} advance to final${cap}`),
+    ).toBeInTheDocument();
+    expect(document.body).not.toHaveTextContent('0.30');
+  });
+
+  it('renders an FMC average threshold in hundredths of moves', async () => {
+    await renderThreshold('333fm', 'average', 3050, linked);
+    expect(
+      screen.getByText(`Averages better than 30.50 moves${source} advance to final${cap}`),
+    ).toBeInTheDocument();
+  });
+
+  it('renders timed results without changing centisecond units', async () => {
+    await renderThreshold('333', 'average', 1234, linked);
+    expect(
+      screen.getByText(`Averages better than 12.34${source} advance to final${cap}`),
+    ).toBeInTheDocument();
+  });
+
+  it('decodes multi-blind results and describes a better result rather than a numeric less-than score', async () => {
+    await renderThreshold('333mbf', 'single', 970036000, linked);
+    expect(
+      screen.getByText(`Singles better than 2/2 6:00${source} advance to final${cap}`),
+    ).toBeInTheDocument();
+  });
+});
diff --git a/src/components/CutoffTimeLimitPanel/CutoffTimeLimitPanel.help.test.tsx b/src/components/CutoffTimeLimitPanel/CutoffTimeLimitPanel.help.test.tsx
new file mode 100644
index 0000000..2842227
--- /dev/null
+++ b/src/components/CutoffTimeLimitPanel/CutoffTimeLimitPanel.help.test.tsx
@@ -0,0 +1,64 @@
+import { fireEvent, render, screen } from '@testing-library/react';
+import { Round } from '@wca/helpers';
+import { readFileSync } from 'fs';
+import { createInstance } from 'i18next';
+import { load } from 'js-yaml';
+import { I18nextProvider, initReactI18next } from 'react-i18next';
+import { MemoryRouter } from 'react-router-dom';
+import { CutoffTimeLimitPanel } from './CutoffTimeLimitPanel';
+
+jest.mock('@/providers/WCIFProvider', () => ({
+  useWCIF: () => ({ wcif: undefined }),
+}));
+
+const round: Round = {
+  id: '333-r1',
+  format: 'a',
+  cutoff: { numberOfAttempts: 2, resultValue: 1200 },
+  timeLimit: null,
+  linkedRounds: null,
+  participationRuleset: null,
+  results: [],
+  extensions: [],
+};
+
+it('renders actual translated help markup and supports repeated dismissal and reopening', async () => {
+  const i18n = createInstance();
+  await i18n.use(initReactI18next).init({
+    lng: 'en',
+    fallbackLng: 'en',
+    resources: {
+      en: { translation: load(readFileSync('src/i18n/en/translation.yaml', 'utf8')) as object },
+    },
+    interpolation: { escapeValue: false },
+  });
+  const { unmount } = render(
+    <I18nextProvider i18n={i18n}>
+      <MemoryRouter>
+        <CutoffTimeLimitPanel round={round} />
+      </MemoryRouter>
+    </I18nextProvider>,
+  );
+  const help = screen.getByRole('button', { name: /help/i, expanded: false });
+  help.focus();
+  for (let attempt = 0; attempt < 2; attempt++) {
+    fireEvent.click(help);
+    expect(help).toHaveAttribute('aria-expanded', 'true');
+    expect(screen.getByText('cutoffs', { selector: 'strong' })).toBeInTheDocument();
+    expect(document.body).not.toHaveTextContent('<bold>');
+    fireEvent.keyDown(document, { key: 'Escape' });
+    expect(help).toHaveAttribute('aria-expanded', 'false');
+    expect(screen.queryByText('cutoffs', { selector: 'strong' })).not.toBeInTheDocument();
+    expect(help).toHaveFocus();
+  }
+  fireEvent.click(help);
+  fireEvent.click(help);
+  expect(help).toHaveAttribute('aria-expanded', 'false');
+  fireEvent.click(help);
+  fireEvent.click(document.body);
+  expect(help).toHaveAttribute('aria-expanded', 'false');
+  fireEvent.click(help);
+  unmount();
+  fireEvent.keyDown(document, { key: 'Escape' });
+  expect(screen.queryByText('cutoffs', { selector: 'strong' })).not.toBeInTheDocument();
+});
diff --git a/src/components/CutoffTimeLimitPanel/CutoffTimeLimitPanel.stories.tsx b/src/components/CutoffTimeLimitPanel/CutoffTimeLimitPanel.stories.tsx
index f46eab7..fe43ccc 100644
--- a/src/components/CutoffTimeLimitPanel/CutoffTimeLimitPanel.stories.tsx
+++ b/src/components/CutoffTimeLimitPanel/CutoffTimeLimitPanel.stories.tsx
@@ -1,4 +1,5 @@
 import type { Meta, StoryObj } from '@storybook/react';
+import { EventId } from '@wca/helpers';
 import {
   getStorybookRoundFixture,
   makeStorybookCompetitionFixtureWithRoundUpdates,
@@ -105,3 +106,72 @@ export const FinalRoundWithoutAdvancement: Story = {
     round: finalRoundCompetitionFixture.events[0].rounds[2],
   },
 };
+
+// Synthetic edge cases for browser UAT, not a captured real competition.
+const makeThresholdFixture = (
+  eventId: EventId,
+  scope: 'single' | 'average',
+  value: number | null,
+  linked = false,
+) => {
+  const competition = makeStorybookCompetitionFixtureWithRoundUpdates({});
+  const rounds = competition.events[0].rounds.slice(0, linked ? 3 : 2).map((round, index) => ({
+    ...round,
+    id: `${eventId}-r${index + 1}`,
+    cutoff: null,
+    timeLimit: null,
+    linkedRounds: null,
+    participationRuleset: null,
+    results: [],
+  }));
+  const target = rounds.at(-1)!;
+  const participationRuleset = {
+    reservedPlaces: null,
+    participationSource: linked
+      ? {
+          type: 'linkedRounds' as const,
+          roundIds: rounds.slice(0, -1).map(({ id }) => id),
+          resultCondition: { type: 'resultAchieved' as const, scope, value },
+        }
+      : {
+          type: 'round' as const,
+          roundId: rounds[0].id,
+          resultCondition: { type: 'resultAchieved' as const, scope, value },
+        },
+  };
+  competition.events = [
+    {
+      id: eventId,
+      rounds: [...rounds.slice(0, -1), { ...target, participationRuleset }],
+      extensions: [],
+    },
+  ];
+  return competition;
+};
+const thresholdStory = (
+  eventId: EventId,
+  scope: 'single' | 'average',
+  value: number | null,
+  linked = false,
+): Story => {
+  const fixture = makeThresholdFixture(eventId, scope, value, linked);
+  return {
+    parameters: { competitionFixture: fixture },
+    args: { round: fixture.events[0].rounds[0] },
+    decorators: [
+      (Story) => (
+        <div className="space-y-4">
+          <p>Synthetic advancement-caption fixture</p>
+          <Story />
+        </div>
+      ),
+    ],
+  };
+};
+
+export const SyntheticNullSingleThreshold = thresholdStory('333', 'single', null);
+export const SyntheticNullAverageThreshold = thresholdStory('333', 'average', null);
+export const SyntheticLinkedNullAverageThreshold = thresholdStory('333', 'average', null, true);
+export const SyntheticFmcSingleThreshold = thresholdStory('333fm', 'single', 30);
+export const SyntheticFmcAverageThreshold = thresholdStory('333fm', 'average', 3050);
+export const SyntheticMultiBlindThreshold = thresholdStory('333mbf', 'single', 970036000);
diff --git a/src/components/CutoffTimeLimitPanel/CutoffTimeLimitPanel.tsx b/src/components/CutoffTimeLimitPanel/CutoffTimeLimitPanel.tsx
index cb01f7b..64f02e6 100644
--- a/src/components/CutoffTimeLimitPanel/CutoffTimeLimitPanel.tsx
+++ b/src/components/CutoffTimeLimitPanel/CutoffTimeLimitPanel.tsx
@@ -1,10 +1,10 @@
 import { Cutoff, Round, parseActivityCode } from '@wca/helpers';
 import classNames from 'classnames';
-import { useMemo, useState } from 'react';
+import { useEffect, useMemo, useState } from 'react';
 import { Trans, useTranslation } from 'react-i18next';
 import { Link } from 'react-router-dom';
 import { Popover } from 'react-tiny-popover';
-import { renderCentiseconds, renderCutoff } from '@/lib/results';
+import { renderCentiseconds, renderCutoff, renderResultByEventId } from '@/lib/results';
 import { getEventRoundsForRound, joinLabels } from '@/lib/roundLabels';
 import { getAdvancementConditionForRound } from '@/lib/wcif';
 import { useWCIF } from '@/providers/WCIFProvider';
@@ -148,15 +148,16 @@ function renderLinkedRoundsAdvancementText(
         what: targetLabel,
       });
     case 'resultAchieved':
-      return t('common.wca.advancement.linkedResultAchieved', {
-        scope: t(`common.wca.advancement.scope.${resultCondition.scope}`),
-        result:
-          resultCondition.value === null
-            ? t('common.wca.advancement.resultThresholdUnknown')
-            : renderCentiseconds(resultCondition.value),
-        rounds: sourceRoundsLabel,
-        what: targetLabel,
-      });
+      return t(
+        resultCondition.value === null
+          ? 'common.wca.advancement.linkedAnyResultAchieved'
+          : 'common.wca.advancement.linkedResultAchieved',
+        {
+          ...getAdvancementResultText(t, advancement),
+          rounds: sourceRoundsLabel,
+          what: targetLabel,
+        },
+      );
   }
 }
 
@@ -180,17 +181,32 @@ function renderSingleRoundAdvancementText(
         what: targetLabel,
       });
     case 'resultAchieved':
-      return t('common.wca.advancement.resultAchieved', {
-        scope: t(`common.wca.advancement.scope.${resultCondition.scope}`),
-        result:
-          resultCondition.value === null
-            ? t('common.wca.advancement.resultThresholdUnknown')
-            : renderCentiseconds(resultCondition.value),
-        what: targetLabel,
-      });
+      return t(
+        resultCondition.value === null
+          ? 'common.wca.advancement.anyResultAchieved'
+          : 'common.wca.advancement.resultAchieved',
+        { ...getAdvancementResultText(t, advancement), what: targetLabel },
+      );
   }
 }
 
+function getAdvancementResultText(
+  t: ReturnType<typeof useTranslation>['t'],
+  advancement: NonNullable<ReturnType<typeof getAdvancementConditionForRound>>,
+) {
+  const { scope, value } = advancement.resultCondition;
+  if (value === null) {
+    return { scope: t(`common.wca.advancement.successfulScope.${scope}`) };
+  }
+
+  const { eventId } = parseActivityCode(advancement.sourceRoundIds[0]);
+  const result = renderResultByEventId(eventId, scope, value);
+  return {
+    scope: t(`common.wca.advancement.scope.${scope}`),
+    result: eventId === '333fm' ? t('common.wca.advancement.resultInMoves', { result }) : result,
+  };
+}
+
 function getAdvancementTargetLabel(
   t: ReturnType<typeof useTranslation>['t'],
   eventRounds: Round[],
@@ -212,6 +228,15 @@ function CutoffTimeLimitPopover({ cutoff }: { cutoff: Cutoff | null }) {
   const { t } = useTranslation();
   const [open, setOpen] = useState(false);
 
+  useEffect(() => {
+    if (!open) return;
+    const dismissOnEscape = (event: KeyboardEvent) => {
+      if (event.key === 'Escape') setOpen(false);
+    };
+    document.addEventListener('keydown', dismissOnEscape);
+    return () => document.removeEventListener('keydown', dismissOnEscape);
+  }, [open]);
+
   return (
     <Popover
       isOpen={open}
@@ -229,12 +254,15 @@ function CutoffTimeLimitPopover({ cutoff }: { cutoff: Cutoff | null }) {
           <p>
             <Trans
               i18nKey="common.cutoffTimeLimitPopover.timeLimits"
-              components={{ b: <strong /> }}
+              components={{ b: <strong />, bold: <strong /> }}
             />
           </p>
 
           <p>
-            <Trans i18nKey="common.cutoffTimeLimitPopover.cutoffs" components={{ b: <strong /> }} />
+            <Trans
+              i18nKey="common.cutoffTimeLimitPopover.cutoffs"
+              components={{ b: <strong />, bold: <strong /> }}
+            />
             <br />
             <i>
               {cutoff &&
diff --git a/src/containers/About/About.tsx b/src/containers/About/About.tsx
index 4c68988..dc9e15f 100644
--- a/src/containers/About/About.tsx
+++ b/src/containers/About/About.tsx
@@ -16,7 +16,7 @@ export function AboutContainer() {
   }, [t]);
 
   return (
-    <Container className="safe-area-scroll-bottom overflow-auto">
+    <Container scrollRestorationId="page" className="safe-area-scroll-bottom overflow-auto">
       <div className="flex flex-col items-center">
         <div className="flex flex-col space-y-4 p-2 pt-2 type-body">
           <p>{t('about.welcome')}</p>
diff --git a/src/containers/CompetitionPerson/CompetitionPerson.test.tsx b/src/containers/CompetitionPerson/CompetitionPerson.test.tsx
new file mode 100644
index 0000000..746b3c0
--- /dev/null
+++ b/src/containers/CompetitionPerson/CompetitionPerson.test.tsx
@@ -0,0 +1,80 @@
+import { fireEvent, render, screen } from '@testing-library/react';
+import { Competition, Person } from '@wca/helpers';
+import { MemoryRouter, Route, Routes, useNavigate, useParams } from 'react-router-dom';
+import { WCIFContext } from '@/providers/WCIFProvider';
+import { CompetitionPersonContainer } from './CompetitionPerson';
+
+jest.mock('react-i18next', () => ({ useTranslation: () => ({ t: (key: string) => key }) }));
+jest.mock('@/containers/CompetitionPersonalResults', () => ({
+  CompetitionPersonalResultsContent: () => <div>Person results</div>,
+}));
+jest.mock('@/containers/PersonalBests', () => ({
+  PersonalBestsContainer: () => <div>Person records</div>,
+}));
+jest.mock('@/containers/PersonalSchedule', () => ({
+  PersonalScheduleContent: () => <div>Person schedule</div>,
+}));
+jest.mock('@/containers/PersonalSchedule/PersonalPageLayout', () => ({
+  PersonalPageLayout: ({ children, person }: { children: React.ReactNode; person: Person }) => (
+    <>
+      <p>{person.name}</p>
+      {children}
+    </>
+  ),
+}));
+jest.mock('@/providers/WCIFProvider', () => {
+  const React = jest.requireActual('react');
+  const WCIFContext = React.createContext({});
+  return { WCIFContext, useWCIF: () => React.useContext(WCIFContext) };
+});
+const wcif = {
+  persons: [{ registrantId: 1, name: 'Valid person', wcaId: '2026TEST01' }],
+} as Competition;
+const setTitle = jest.fn();
+function PersonPage() {
+  const { registrantId = '' } = useParams();
+  return <CompetitionPersonContainer registrantId={registrantId} />;
+}
+function Navigation() {
+  const navigate = useNavigate();
+  return (
+    <>
+      <button onClick={() => navigate('/competitions/Test/persons/1')}>Valid person</button>
+      <button onClick={() => navigate('/competitions/Test/persons/999')}>Missing person</button>
+      <button onClick={() => navigate(-1)}>Back</button>
+    </>
+  );
+}
+function renderPerson(path = '/competitions/Test/persons/999') {
+  return render(
+    <WCIFContext.Provider value={{ competitionId: 'Test', wcif, setTitle }}>
+      <MemoryRouter initialEntries={[path]}>
+        <Navigation />
+        <Routes>
+          <Route path="/competitions/Test" element={<div>Competition people</div>} />
+          <Route path="/competitions/Test/persons/:registrantId/*" element={<PersonPage />} />
+        </Routes>
+      </MemoryRouter>
+    </WCIFContext.Provider>,
+  );
+}
+it.each(['', '/results', '/records'])(
+  'explains a missing person and offers recovery on %s',
+  (suffix) => {
+    renderPerson(`/competitions/Test/persons/999${suffix}`);
+    expect(screen.getByRole('status')).toHaveTextContent('competition.person.notFound');
+    fireEvent.click(screen.getByRole('link', { name: 'competition.person.backToCompetitors' }));
+    expect(screen.getByText('Competition people')).toBeInTheDocument();
+  },
+);
+it('updates the title and content when moving between valid and missing people and Back', () => {
+  renderPerson('/competitions/Test/persons/1');
+  expect(screen.getByText('Person schedule')).toBeInTheDocument();
+  fireEvent.click(screen.getByRole('button', { name: 'Missing person' }));
+  expect(screen.queryByText('Person schedule')).not.toBeInTheDocument();
+  expect(screen.getByRole('status')).toBeInTheDocument();
+  expect(setTitle).toHaveBeenLastCalledWith('competition.person.notFound');
+  fireEvent.click(screen.getByRole('button', { name: 'Back' }));
+  expect(screen.getByText('Person schedule')).toBeInTheDocument();
+  expect(setTitle).toHaveBeenLastCalledWith('Valid person');
+});
diff --git a/src/containers/CompetitionPerson/CompetitionPerson.tsx b/src/containers/CompetitionPerson/CompetitionPerson.tsx
index f68aff2..c0249f0 100644
--- a/src/containers/CompetitionPerson/CompetitionPerson.tsx
+++ b/src/containers/CompetitionPerson/CompetitionPerson.tsx
@@ -1,7 +1,10 @@
 import { Person } from '@wca/helpers';
 import { Extension } from '@wca/helpers/lib/models/extension';
 import { useEffect } from 'react';
+import { useTranslation } from 'react-i18next';
 import { Link, useLocation } from 'react-router-dom';
+import { Container } from '@/components/Container';
+import { LinkButton } from '@/components/LinkButton';
 import { CompetitionPersonalResultsContent } from '@/containers/CompetitionPersonalResults';
 import { PersonalBestsContainer } from '@/containers/PersonalBests';
 import { PersonalScheduleContent } from '@/containers/PersonalSchedule';
@@ -13,6 +16,7 @@ export interface CompetitionPersonContainerProps {
 }
 
 export function CompetitionPersonContainer({ registrantId }: CompetitionPersonContainerProps) {
+  const { t } = useTranslation();
   const { competitionId, wcif, setTitle } = useWCIF();
   const { pathname } = useLocation();
 
@@ -23,13 +27,24 @@ export function CompetitionPersonContainer({ registrantId }: CompetitionPersonCo
     | undefined;
 
   useEffect(() => {
-    if (person) {
-      setTitle(person.name);
+    if (wcif) {
+      setTitle(person?.name ?? t('competition.person.notFound'));
     }
-  }, [person, setTitle]);
+  }, [person, setTitle, t, wcif]);
 
-  if (!wcif || !person) {
-    return null;
+  if (!wcif) return null;
+
+  if (!person) {
+    return (
+      <Container className="p-4 space-y-4">
+        <p role="status">{t('competition.person.notFound')}</p>
+        <LinkButton
+          to={`/competitions/${competitionId}`}
+          title={t('competition.person.backToCompetitors')}
+          LinkComponent={Link}
+        />
+      </Container>
+    );
   }
 
   const activePage: PersonalPage = pathname.endsWith('/results')
diff --git a/src/containers/CompetitionPersonalResults/CompetitionPersonalResults.test.tsx b/src/containers/CompetitionPersonalResults/CompetitionPersonalResults.test.tsx
index 592e19d..d7713f9 100644
--- a/src/containers/CompetitionPersonalResults/CompetitionPersonalResults.test.tsx
+++ b/src/containers/CompetitionPersonalResults/CompetitionPersonalResults.test.tsx
@@ -340,7 +340,9 @@ describe('CompetitionPersonalResultsContainer', () => {
     fireEvent.click(screen.getByRole('row', { name: /2 Round 1/ }));
 
     expect(screen.getByRole('dialog')).toBeInTheDocument();
-    expect(screen.getByRole('heading', { name: '#2' })).toBeInTheDocument();
+    expect(
+      screen.getByRole('dialog', { name: 'Vikram Haldar · 3x3x3 Cube · Round 1 #2' }),
+    ).toBeInTheDocument();
     expect(within(screen.getByRole('dialog')).getByText('Event')).toBeInTheDocument();
     expect(within(screen.getByRole('dialog')).getByText('3x3x3 Cube')).toBeInTheDocument();
     expect(within(screen.getByRole('dialog')).getByText('Round')).toBeInTheDocument();
diff --git a/src/containers/CompetitionPersonalResults/CompetitionPersonalResultsTable.tsx b/src/containers/CompetitionPersonalResults/CompetitionPersonalResultsTable.tsx
index 42bfe44..578f8d2 100644
--- a/src/containers/CompetitionPersonalResults/CompetitionPersonalResultsTable.tsx
+++ b/src/containers/CompetitionPersonalResults/CompetitionPersonalResultsTable.tsx
@@ -1,6 +1,6 @@
 import { ResultValue, EventId, Person } from '@wca/helpers';
 import classNames from 'classnames';
-import { KeyboardEvent, useState } from 'react';
+import { KeyboardEvent, useEffect, useState } from 'react';
 import { useTranslation } from 'react-i18next';
 import { CompetitionRoundResult } from '@/containers/CompetitionResults/CompetitionResultsTable';
 import { ResultDetailsDialog } from '@/containers/CompetitionResults/ResultDetailsDialog';
@@ -58,7 +58,16 @@ const toCompetitionRoundResult = (result: PersonalRoundResult): CompetitionRound
   average: result.average,
 });
 
-export function CompetitionPersonalResultsTable({
+export function CompetitionPersonalResultsTable(props: CompetitionPersonalResultsTableProps) {
+  return (
+    <PersonalEventResultsTable
+      key={`${props.competitionId}/${props.person.registrantId}/${props.eventId}`}
+      {...props}
+    />
+  );
+}
+
+function PersonalEventResultsTable({
   competitionId,
   eventId,
   eventName,
@@ -67,21 +76,30 @@ export function CompetitionPersonalResultsTable({
   LinkComponent,
 }: CompetitionPersonalResultsTableProps) {
   const { t } = useTranslation();
-  const [selectedResult, setSelectedResult] = useState<PersonalRoundResult | null>(null);
+  const [selection, setSelection] = useState<{
+    roundId: string;
+    trigger: HTMLTableRowElement;
+  } | null>(null);
+  const selectedResult = selection
+    ? roundResults.find((result) => result.roundId === selection.roundId)
+    : undefined;
+  useEffect(() => {
+    if (selection && !selectedResult) setSelection(null);
+  }, [selection, selectedResult]);
   const attemptColumnCount = Math.max(0, ...roundResults.map((result) => result.attempts.length));
   const getRoundName = (result: PersonalRoundResult) =>
     result.roundName ?? t('common.activityCodeToName.round', { roundNumber: result.roundNumber });
-  const openDetailsDialog = (result: PersonalRoundResult) => {
+  const openDetailsDialog = (result: PersonalRoundResult, trigger: HTMLTableRowElement) => {
     if (!shouldOpenResultDetailsDialog()) {
       return;
     }
 
-    setSelectedResult(result);
+    setSelection({ roundId: result.roundId, trigger });
   };
 
   const openDetailsDialogFromKeyboard =
     (result: PersonalRoundResult) => (event: KeyboardEvent<HTMLTableRowElement>) => {
-      if (event.key !== 'Enter' && event.key !== ' ') {
+      if (event.target !== event.currentTarget || (event.key !== 'Enter' && event.key !== ' ')) {
         return;
       }
 
@@ -90,7 +108,7 @@ export function CompetitionPersonalResultsTable({
       }
 
       event.preventDefault();
-      setSelectedResult(result);
+      setSelection({ roundId: result.roundId, trigger: event.currentTarget });
     };
 
   return (
@@ -137,7 +155,7 @@ export function CompetitionPersonalResultsTable({
               key={result.roundId}
               className="cursor-pointer border-b border-tertiary-weak hover-transition hover:bg-gray-50 last:border-b-0 dark:hover:bg-gray-800 md:cursor-default"
               tabIndex={0}
-              onClick={() => openDetailsDialog(result)}
+              onClick={(event) => openDetailsDialog(result, event.currentTarget)}
               onKeyDown={openDetailsDialogFromKeyboard(result)}>
               <td
                 className={classNames(
@@ -182,9 +200,7 @@ export function CompetitionPersonalResultsTable({
           competitionId={competitionId}
           eventId={eventId}
           name={person.name}
-          title={
-            selectedResult.ranking ? `#${selectedResult.ranking}` : getRoundName(selectedResult)
-          }
+          title={`${person.name} · ${eventName} · ${getRoundName(selectedResult)}${selectedResult.ranking ? ` #${selectedResult.ranking}` : ''}`}
           details={[
             {
               label: t('common.wca.event'),
@@ -202,7 +218,8 @@ export function CompetitionPersonalResultsTable({
           primaryRankingType="average"
           result={toCompetitionRoundResult(selectedResult)}
           LinkComponent={LinkComponent}
-          onClose={() => setSelectedResult(null)}
+          returnFocusTo={selection?.trigger}
+          onClose={() => setSelection(null)}
         />
       )}
     </div>
diff --git a/src/containers/CompetitionResults/CompetitionResults.test.tsx b/src/containers/CompetitionResults/CompetitionResults.test.tsx
index 6f9e5f7..831821e 100644
--- a/src/containers/CompetitionResults/CompetitionResults.test.tsx
+++ b/src/containers/CompetitionResults/CompetitionResults.test.tsx
@@ -44,7 +44,7 @@ jest.mock('react-i18next', () => ({
       if (key === 'competition.results.best') return 'Best';
       if (key === 'competition.results.attempts') return 'Attempts';
       if (key === 'competition.results.resultsSourceNote') {
-        return 'Results are merged from WCIF and WCA Live when available. WCA Live data may be delayed.';
+        return 'Results combine WCA Live, WCIF, and published WCA results. Yellow highlights are provisional. Without Live, advancement uses next-round participants when available, otherwise calculated eligibility; incomplete source rounds remain provisional. Stored data may lag behind organizer changes.';
       }
       if (key === 'competition.results.allResults') return 'All results';
       if (key === 'competition.results.unknownCompetitor') {
@@ -313,7 +313,7 @@ describe('CompetitionResultsContainer', () => {
     expect(screen.queryByRole('table', { name: 'Results' })).not.toBeInTheDocument();
     expect(
       screen.getByText(
-        'Results are merged from WCIF and WCA Live when available. WCA Live data may be delayed.',
+        'Results combine WCA Live, WCIF, and published WCA results. Yellow highlights are provisional. Without Live, advancement uses next-round participants when available, otherwise calculated eligibility; incomplete source rounds remain provisional. Stored data may lag behind organizer changes.',
       ),
     ).toBeInTheDocument();
   });
@@ -358,7 +358,7 @@ describe('CompetitionResultsContainer', () => {
     expect(screen.queryByLabelText('Attempts')).not.toBeInTheDocument();
     expect(
       screen.getByText(
-        'Results are merged from WCIF and WCA Live when available. WCA Live data may be delayed.',
+        'Results combine WCA Live, WCIF, and published WCA results. Yellow highlights are provisional. Without Live, advancement uses next-round participants when available, otherwise calculated eligibility; incomplete source rounds remain provisional. Stored data may lag behind organizer changes.',
       ),
     ).toBeInTheDocument();
     expect(
@@ -367,9 +367,10 @@ describe('CompetitionResultsContainer', () => {
         .slice(1)
         .map((row) => within(row).getAllByRole('cell')[0].textContent),
     ).toEqual(['1', '2']);
+    // The stored average-of-five fixture has only three attempts per result.
     expect(
       within(screen.getByRole('row', { name: /1 Blake Thompson/ })).getByText('1'),
-    ).toHaveClass('bg-green-300');
+    ).toHaveClass('bg-yellow-200');
     expect(
       within(screen.getByRole('row', { name: /2 Nick Silvestri/ })).getByText('2'),
     ).not.toHaveClass('bg-green-300');
@@ -555,7 +556,7 @@ describe('CompetitionResultsContainer', () => {
     ).toHaveLength(2);
     expect(
       screen.getByText(
-        'Results are merged from WCIF and WCA Live when available. WCA Live data may be delayed.',
+        'Results combine WCA Live, WCIF, and published WCA results. Yellow highlights are provisional. Without Live, advancement uses next-round participants when available, otherwise calculated eligibility; incomplete source rounds remain provisional. Stored data may lag behind organizer changes.',
       ),
     ).toBeInTheDocument();
   });
diff --git a/src/containers/CompetitionResults/CompetitionResultsTable.tsx b/src/containers/CompetitionResults/CompetitionResultsTable.tsx
index 7eef876..d47739f 100644
--- a/src/containers/CompetitionResults/CompetitionResultsTable.tsx
+++ b/src/containers/CompetitionResults/CompetitionResultsTable.tsx
@@ -7,7 +7,7 @@ import {
   RoundFormat,
 } from '@wca/helpers';
 import classNames from 'classnames';
-import { KeyboardEvent, ReactNode, useState } from 'react';
+import { KeyboardEvent, ReactNode, useEffect, useState } from 'react';
 import { useTranslation } from 'react-i18next';
 import { AnchorLink, LinkRenderer } from '@/lib/linkRenderer';
 import { renderResultByEventId } from '@/lib/results';
@@ -19,6 +19,7 @@ export interface CompetitionRoundResult {
   id: string | number;
   personId: number | null;
   personName?: string;
+  wcaId?: string | null;
   ranking: number | null;
   advancing: boolean;
   advancingQuestionable: boolean;
@@ -162,6 +163,15 @@ const ResultValue = ({
   </span>
 );
 
+// Use the same identity as merged results, not a source-specific result ID.
+// A stored result replaced by Live should keep its row, selection and focus.
+const getResultKey = (result: CompetitionRoundResult) =>
+  result.personId != null
+    ? `person-${result.personId}`
+    : result.wcaId
+      ? `wca-${result.wcaId}`
+      : `result-${result.id}`;
+
 const isRosterOnlyResult = (result: CompetitionRoundResult) =>
   result.ranking == null &&
   result.attempts.length === 0 &&
@@ -206,7 +216,16 @@ const toCompetitionRoundResult = (result: Round['results'][number]): Competition
   };
 };
 
-export function CompetitionResultsTable({
+export function CompetitionResultsTable(props: CompetitionResultsTableProps) {
+  return (
+    <RoundResultsTable
+      key={`${props.competitionId}/${props.eventId}/${props.round.id}`}
+      {...props}
+    />
+  );
+}
+
+function RoundResultsTable({
   competitionId,
   eventId,
   round,
@@ -215,23 +234,32 @@ export function CompetitionResultsTable({
   LinkComponent = AnchorLink,
 }: CompetitionResultsTableProps) {
   const { t } = useTranslation();
-  const [selectedResult, setSelectedResult] = useState<CompetitionRoundResult | null>(null);
+  const [selection, setSelection] = useState<{
+    resultKey: string;
+    trigger: HTMLTableRowElement;
+  } | null>(null);
+  const selectedResult = selection
+    ? results.find((result) => getResultKey(result) === selection.resultKey)
+    : undefined;
+  useEffect(() => {
+    if (selection && !selectedResult) setSelection(null);
+  }, [selection, selectedResult]);
   const primaryRankingType = getPrimaryRankingType(round.format);
   const showSecondaryBest = primaryRankingType === 'average';
   const attemptColumnCount = Math.max(0, ...results.map((result) => result.attempts.length));
   const sortedResults = sortResultsByRanking(results);
 
-  const openDetailsDialog = (result: CompetitionRoundResult) => {
+  const openDetailsDialog = (result: CompetitionRoundResult, trigger: HTMLTableRowElement) => {
     if (!shouldOpenResultDetailsDialog()) {
       return;
     }
 
-    setSelectedResult(result);
+    setSelection({ resultKey: getResultKey(result), trigger });
   };
 
   const openDetailsDialogFromKeyboard =
     (result: CompetitionRoundResult) => (event: KeyboardEvent<HTMLTableRowElement>) => {
-      if (event.key !== 'Enter' && event.key !== ' ') {
+      if (event.target !== event.currentTarget || (event.key !== 'Enter' && event.key !== ' ')) {
         return;
       }
 
@@ -240,7 +268,7 @@ export function CompetitionResultsTable({
       }
 
       event.preventDefault();
-      setSelectedResult(result);
+      setSelection({ resultKey: getResultKey(result), trigger: event.currentTarget });
     };
 
   if (results.length === 0) {
@@ -307,10 +335,10 @@ export function CompetitionResultsTable({
 
             return (
               <tr
-                key={result.id}
+                key={getResultKey(result)}
                 className="cursor-pointer border-b border-tertiary-weak hover-transition hover:bg-gray-50 last:border-b-0 dark:hover:bg-gray-700 md:cursor-default"
                 tabIndex={0}
-                onClick={() => openDetailsDialog(result)}
+                onClick={(event) => openDetailsDialog(result, event.currentTarget)}
                 onKeyDown={openDetailsDialogFromKeyboard(result)}>
                 <td
                   className={classNames(
@@ -394,7 +422,8 @@ export function CompetitionResultsTable({
               primaryRankingType={primaryRankingType}
               result={selectedResult}
               LinkComponent={LinkComponent}
-              onClose={() => setSelectedResult(null)}
+              returnFocusTo={selection?.trigger}
+              onClose={() => setSelection(null)}
             />
           );
         })()}
diff --git a/src/containers/CompetitionResults/FallbackAdvancement.stories.tsx b/src/containers/CompetitionResults/FallbackAdvancement.stories.tsx
new file mode 100644
index 0000000..ecd8087
--- /dev/null
+++ b/src/containers/CompetitionResults/FallbackAdvancement.stories.tsx
@@ -0,0 +1,120 @@
+import type { Meta, StoryObj } from '@storybook/react';
+import { Competition, Round } from '@wca/helpers';
+import { makeStorybookCompetitionFixtureWithRoundUpdates } from '@/storybook/competitionFixtures';
+import { makeCompetitionContainerDecorator } from '@/storybook/competitionStorybook';
+import { CompetitionResultsTable } from './CompetitionResultsTable';
+import { getRoundResultsFromSources } from './resultsProvider';
+
+const makeFixture = (partial: boolean, actualParticipants: boolean): Competition => {
+  const competition = makeStorybookCompetitionFixtureWithRoundUpdates({});
+  competition.id = 'SyntheticAdvancementFixture';
+  competition.persons = Array.from({ length: 10 }, (_, index) => ({
+    ...competition.persons[0],
+    registrantId: index + 1,
+    wcaId: null,
+    name: `Synthetic Solver ${index + 1}`,
+    assignments: [],
+  }));
+  const source: Round = {
+    ...competition.events[0].rounds[0],
+    cutoff: null,
+    format: 'a',
+    linkedRounds: null,
+    results: Array.from({ length: 10 }, (_, index) => {
+      const entered = !partial || index < 6;
+      return {
+        personId: index + 1,
+        ranking: entered ? index + 1 : null,
+        best: entered ? 1000 + index * 100 : 0,
+        average: partial ? 0 : 1000 + index * 100,
+        attempts: !entered
+          ? []
+          : Array.from({ length: partial ? 1 : 5 }, () => ({
+              value: 1000 + index * 100,
+              reconstruction: null,
+            })),
+      };
+    }),
+  };
+  const target: Round = {
+    ...competition.events[0].rounds[1],
+    linkedRounds: null,
+    participationRuleset: {
+      reservedPlaces: null,
+      participationSource: {
+        type: 'round',
+        roundId: source.id,
+        resultCondition: { type: 'percent', scope: 'average', value: 75 },
+      },
+    },
+    results: actualParticipants
+      ? [1, 2, 3, 5, 6, 8].map((personId) => ({
+          personId,
+          ranking: null,
+          best: 0,
+          average: 0,
+          attempts: [],
+        }))
+      : [],
+  };
+  competition.events = [{ ...competition.events[0], rounds: [source, target] }];
+  return competition;
+};
+
+const meta = {
+  title: 'Components/Competition/FallbackAdvancement',
+  component: CompetitionResultsTable,
+  decorators: [makeCompetitionContainerDecorator()],
+  tags: ['autodocs'],
+} satisfies Meta<typeof CompetitionResultsTable>;
+export default meta;
+type Story = StoryObj<typeof meta>;
+
+const fixtureStory = (
+  partial: boolean,
+  actualParticipants: boolean,
+  description: string,
+): Story => {
+  const competition = makeFixture(partial, actualParticipants);
+  const event = competition.events[0];
+  const round = event.rounds[0];
+  return {
+    parameters: { competitionFixture: competition },
+    args: {
+      competitionId: competition.id,
+      eventId: event.id,
+      round,
+      persons: competition.persons,
+      results: getRoundResultsFromSources({
+        wcif: competition,
+        selectedRound: { event, round, roundNumber: 1 },
+        wcaApiResults: [],
+        wcaLiveRound: null,
+      }),
+    },
+    decorators: [
+      (Story) => (
+        <div className="space-y-4">
+          <p>{description}</p>
+          <Story />
+        </div>
+      ),
+    ],
+  };
+};
+
+export const SyntheticPartialRoster = fixtureStory(
+  true,
+  false,
+  'Synthetic partial snapshot: ten stored participants, six with one of five attempts. The six currently qualifying ranks are yellow, not settled green.',
+);
+export const SyntheticCompletedRoster = fixtureStory(
+  false,
+  false,
+  'Synthetic completed snapshot: ten participants with five attempts each. Seven calculated qualifiers are green.',
+);
+export const SyntheticActualParticipants = fixtureStory(
+  false,
+  true,
+  'Synthetic next-round roster: participants 1, 2, 3, 5, 6, and 8 are green. Actual participation overrides calculated eligibility.',
+);
diff --git a/src/containers/CompetitionResults/ResultDetailsDialog.test.tsx b/src/containers/CompetitionResults/ResultDetailsDialog.test.tsx
new file mode 100644
index 0000000..386820e
--- /dev/null
+++ b/src/containers/CompetitionResults/ResultDetailsDialog.test.tsx
@@ -0,0 +1,386 @@
+import { act, fireEvent, render, screen, within } from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
+import { Person, Round } from '@wca/helpers';
+import { StrictMode } from 'react';
+import { Link, MemoryRouter, Route, Routes } from 'react-router-dom';
+import { CompetitionPersonalResultsTable } from '@/containers/CompetitionPersonalResults/CompetitionPersonalResultsTable';
+import { CompetitionResultsTable, CompetitionRoundResult } from './CompetitionResultsTable';
+import { ResultDetailsDialog } from './ResultDetailsDialog';
+
+jest.mock('react-i18next', () => ({
+  useTranslation: () => ({
+    t: (key: string) =>
+      ({
+        'common.close': 'Close',
+        'competition.results.allResults': 'All results',
+      })[key] ?? key,
+  }),
+}));
+
+const persons = [
+  { registrantId: 1, name: 'Competitor One' },
+  { registrantId: 2, name: 'Competitor Two' },
+] as Person[];
+const results: CompetitionRoundResult[] = persons.map((person, index) => ({
+  id: index + 1,
+  personId: person.registrantId,
+  ranking: index + 1,
+  attempts: [{ result: 1200 }],
+  best: 1200,
+  average: 1300,
+  advancing: false,
+  advancingQuestionable: false,
+}));
+const round = { id: '333-r1', format: 'a', results: [] } as unknown as Round;
+const table = (roundId = '333-r1') => (
+  <CompetitionResultsTable
+    competitionId="Test"
+    eventId="333"
+    round={{ ...round, id: roundId }}
+    persons={persons}
+    results={results}
+    LinkComponent={Link}
+  />
+);
+
+async function openRow(name = 'Competitor One', key = '{Enter}') {
+  const row = screen.getByRole('row', { name: new RegExp(name) });
+  act(() => row.focus());
+  await act(() => userEvent.keyboard(key));
+  return row;
+}
+
+it('opens a named dialog, moves focus inside and traps forward/backward tabbing', async () => {
+  render(<MemoryRouter>{table()}</MemoryRouter>);
+  const row = await openRow();
+  const dialog = screen.getByRole('dialog', { name: 'Competitor One #1' });
+  const close = within(dialog).getByRole('button', { name: 'Close' });
+  const link = within(dialog).getByRole('link', { name: 'All results' });
+  expect(close).toHaveFocus();
+  await act(() => userEvent.tab());
+  expect(link).toHaveFocus();
+  await act(() => userEvent.tab({ shift: true }));
+  expect(close).toHaveFocus();
+  await act(() => userEvent.tab({ shift: true }));
+  expect(link).toHaveFocus();
+  await act(() => userEvent.tab());
+  expect(close).toHaveFocus();
+  // A programmatic focus escape is also redirected while the modal is open.
+  act(() => row.focus());
+  expect(close).toHaveFocus();
+});
+
+it.each(['Close', 'Escape', 'backdrop'])(
+  'restores the invoking row after %s and repeated opening',
+  async (dismissal) => {
+    render(
+      <MemoryRouter>
+        <StrictMode>{table()}</StrictMode>
+      </MemoryRouter>,
+    );
+    const row = await openRow();
+    const dialog = screen.getByRole('dialog');
+    if (dismissal === 'Close')
+      await act(() => userEvent.click(within(dialog).getByRole('button', { name: 'Close' })));
+    else if (dismissal === 'Escape') await act(() => userEvent.keyboard('{Escape}'));
+    else await act(() => userEvent.click(dialog));
+    expect(screen.queryByRole('dialog')).not.toBeInTheDocument();
+    expect(row).toHaveFocus();
+    const secondRow = await openRow('Competitor Two', ' ');
+    expect(screen.getByRole('dialog', { name: 'Competitor Two #2' })).toBeInTheDocument();
+    await act(() => userEvent.keyboard('{Escape}'));
+    expect(secondRow).toHaveFocus();
+  },
+);
+
+it('keeps a single Close control focused and uses the latest close callback without resetting focus', async () => {
+  const firstClose = jest.fn();
+  const nextClose = jest.fn();
+  const props = {
+    competitionId: 'Test',
+    eventId: '333',
+    name: 'One',
+    primaryRankingType: 'average' as const,
+    result: results[0],
+  };
+  const { rerender, unmount } = render(<ResultDetailsDialog {...props} onClose={firstClose} />);
+  const close = screen.getByRole('button', { name: 'Close' });
+  expect(close).toHaveFocus();
+  await act(() => userEvent.tab());
+  expect(close).toHaveFocus();
+  await act(() => userEvent.tab({ shift: true }));
+  expect(close).toHaveFocus();
+  rerender(<ResultDetailsDialog {...props} onClose={nextClose} />);
+  await act(() => userEvent.keyboard('{Escape}'));
+  expect(nextClose).toHaveBeenCalledTimes(1);
+  expect(firstClose).not.toHaveBeenCalled();
+  unmount();
+  const event = new KeyboardEvent('keydown', { key: 'Tab', bubbles: true, cancelable: true });
+  document.dispatchEvent(event);
+  expect(event.defaultPrevented).toBe(false);
+});
+
+it('releases focus and listeners on link navigation rather than restoring a removed row', async () => {
+  render(
+    <MemoryRouter initialEntries={['/competitions/Test/results/333-r1']}>
+      <Routes>
+        <Route path="/competitions/Test/results/:roundId" element={table()} />
+        <Route
+          path="/competitions/Test/persons/1/results"
+          element={<button>Personal page action</button>}
+        />
+      </Routes>
+    </MemoryRouter>,
+  );
+  const row = await openRow();
+  const link = within(screen.getByRole('dialog')).getByRole('link', { name: 'All results' });
+  act(() => link.focus());
+  await act(() => userEvent.keyboard('{Enter}'));
+  expect(screen.getByRole('button', { name: 'Personal page action' })).toBeInTheDocument();
+  expect(screen.queryByRole('dialog')).not.toBeInTheDocument();
+  expect(row.isConnected).toBe(false);
+  await act(() => userEvent.tab());
+  expect(screen.getByRole('button', { name: 'Personal page action' })).toHaveFocus();
+  const event = new KeyboardEvent('keydown', { key: 'Escape', bubbles: true, cancelable: true });
+  document.dispatchEvent(event);
+  expect(event.defaultPrevented).toBe(false);
+});
+
+it('dismisses a stale selection on a round change and does not reopen it on Back', async () => {
+  const { rerender } = render(<MemoryRouter>{table()}</MemoryRouter>);
+  await openRow();
+  rerender(<MemoryRouter>{table('333-r2')}</MemoryRouter>);
+  expect(screen.queryByRole('dialog')).not.toBeInTheDocument();
+  rerender(<MemoryRouter>{table()}</MemoryRouter>);
+  expect(screen.queryByRole('dialog')).not.toBeInTheDocument();
+});
+
+it('applies the same focus lifecycle and person isolation to personal result tables', async () => {
+  const personalTable = (person: Person) => (
+    <CompetitionPersonalResultsTable
+      competitionId="Test"
+      eventId="333"
+      eventName="3x3x3 Cube"
+      person={person}
+      LinkComponent={Link}
+      roundResults={[
+        {
+          roundId: '333-r1',
+          roundName: 'Round 1',
+          roundNumber: 1,
+          ranking: 1,
+          attempts: [{ result: 1200 }],
+          best: 1200,
+          average: 1300,
+          advancing: false,
+          advancingQuestionable: false,
+        },
+      ]}
+    />
+  );
+  const { rerender } = render(<MemoryRouter>{personalTable(persons[0])}</MemoryRouter>);
+  const row = screen.getByRole('row', { name: /Round 1/ });
+  act(() => row.focus());
+  await act(() => userEvent.keyboard('{Enter}'));
+  const dialog = screen.getByRole('dialog');
+  expect(dialog).toHaveAccessibleName();
+  expect(within(dialog).getByRole('button', { name: 'Close' })).toHaveFocus();
+  await act(() => userEvent.tab());
+  expect(within(dialog).getByRole('link', { name: 'All results' })).toHaveFocus();
+  await act(() => userEvent.keyboard('{Escape}'));
+  expect(row).toHaveFocus();
+  fireEvent.click(row);
+  rerender(<MemoryRouter>{personalTable(persons[1])}</MemoryRouter>);
+  expect(screen.queryByRole('dialog')).not.toBeInTheDocument();
+});
+
+it('keeps focus through live prop updates, calls the latest callback and restores the original opener', async () => {
+  const opener = document.createElement('button');
+  opener.textContent = 'Original opener';
+  document.body.appendChild(opener);
+  opener.focus();
+  const firstClose = jest.fn();
+  const nextClose = jest.fn();
+  const props = {
+    competitionId: 'Test',
+    eventId: '333',
+    name: 'Competitor One',
+    person: persons[0],
+    primaryRankingType: 'average' as const,
+    result: results[0],
+  };
+  const { rerender, unmount } = render(
+    <MemoryRouter>
+      <ResultDetailsDialog {...props} onClose={firstClose} />
+    </MemoryRouter>,
+  );
+  const link = within(screen.getByRole('dialog')).getByRole('link', { name: 'All results' });
+  act(() => link.focus());
+  rerender(
+    <MemoryRouter>
+      <ResultDetailsDialog
+        {...props}
+        name="Updated competitor"
+        result={{ ...results[0], ranking: 2 }}
+        onClose={nextClose}
+      />
+    </MemoryRouter>,
+  );
+  expect(screen.getByRole('dialog', { name: 'Updated competitor #2' })).toBeInTheDocument();
+  expect(link).toHaveFocus();
+  await act(() => userEvent.keyboard('{Escape}'));
+  expect(nextClose).toHaveBeenCalledTimes(1);
+  expect(firstClose).not.toHaveBeenCalled();
+  await act(async () => unmount());
+  expect(opener).toHaveFocus();
+  opener.remove();
+});
+
+it('restores a pointer-invoked row even when the click did not focus the row', async () => {
+  render(<MemoryRouter>{table()}</MemoryRouter>);
+  const row = screen.getByRole('row', { name: /Competitor Two/ });
+  fireEvent.click(row);
+  expect(screen.getByRole('button', { name: 'Close' })).toHaveFocus();
+  await act(() => userEvent.click(screen.getByRole('button', { name: 'Close' })));
+  expect(row).toHaveFocus();
+});
+
+it('does not steal focus from a replacement screen during unmount cleanup', async () => {
+  const opener = document.createElement('button');
+  const replacement = document.createElement('button');
+  document.body.append(opener, replacement);
+  opener.focus();
+  const { unmount } = render(
+    <ResultDetailsDialog
+      competitionId="Test"
+      eventId="333"
+      name="One"
+      primaryRankingType="average"
+      result={results[0]}
+      onClose={jest.fn()}
+    />,
+  );
+  await act(async () => {
+    unmount();
+    replacement.focus();
+  });
+  expect(replacement).toHaveFocus();
+  opener.remove();
+  replacement.remove();
+});
+
+it('refreshes an open competition modal from current results while retaining focus and source-independent row identity', async () => {
+  const liveTable = (currentResults: CompetitionRoundResult[]) => (
+    <MemoryRouter>
+      <CompetitionResultsTable
+        competitionId="Test"
+        eventId="333"
+        round={round}
+        persons={persons}
+        results={currentResults}
+        LinkComponent={Link}
+      />
+    </MemoryRouter>
+  );
+  const { rerender } = render(liveTable(results));
+  const row = await openRow();
+  const link = within(screen.getByRole('dialog')).getByRole('link', { name: 'All results' });
+  act(() => link.focus());
+  // The result source changes its ID, but this is still the same registered person.
+  const refreshed = [
+    {
+      ...results[0],
+      id: 'live-result-1',
+      ranking: 2,
+      attempts: [{ result: 900 }],
+      best: 900,
+      average: 1000,
+    },
+    results[1],
+  ];
+  rerender(liveTable(refreshed));
+  const dialog = screen.getByRole('dialog', { name: 'Competitor One #2' });
+  expect(within(dialog).getByText('10.00')).toBeInTheDocument();
+  expect(within(dialog).getAllByText('9.00')).toHaveLength(2);
+  expect(within(dialog).queryByText('13.00')).not.toBeInTheDocument();
+  expect(link).toHaveFocus();
+  expect(screen.getByRole('row', { name: /Competitor One/ })).toBe(row);
+  expect(row).toHaveTextContent('10.00');
+  await act(() => userEvent.keyboard('{Escape}'));
+  expect(row).toHaveFocus();
+});
+
+it('dismisses a removed competition result without reopening it when results return', async () => {
+  const liveTable = (currentResults: CompetitionRoundResult[]) => (
+    <MemoryRouter>
+      <CompetitionResultsTable
+        competitionId="Test"
+        eventId="333"
+        round={round}
+        persons={persons}
+        results={currentResults}
+        LinkComponent={Link}
+      />
+    </MemoryRouter>
+  );
+  const { rerender } = render(liveTable(results));
+  const row = await openRow();
+  rerender(liveTable([results[1]]));
+  expect(screen.queryByRole('dialog')).not.toBeInTheDocument();
+  expect(row.isConnected).toBe(false);
+  rerender(liveTable(results));
+  expect(screen.queryByRole('dialog')).not.toBeInTheDocument();
+  const event = new KeyboardEvent('keydown', { key: 'Tab', bubbles: true, cancelable: true });
+  document.dispatchEvent(event);
+  expect(event.defaultPrevented).toBe(false);
+});
+
+it('refreshes and removes an open personal round modal from current round results', async () => {
+  const initial = [
+    {
+      roundId: '333-r1',
+      roundName: 'Round 1',
+      roundNumber: 1,
+      ranking: 1,
+      attempts: [{ result: 1200 }],
+      best: 1200,
+      average: 1300,
+      advancing: false,
+      advancingQuestionable: false,
+    },
+  ];
+  const personalTable = (currentResults: typeof initial) => (
+    <MemoryRouter>
+      <CompetitionPersonalResultsTable
+        competitionId="Test"
+        eventId="333"
+        eventName="3x3x3 Cube"
+        person={persons[0]}
+        roundResults={currentResults}
+        LinkComponent={Link}
+      />
+    </MemoryRouter>
+  );
+  const { rerender } = render(personalTable(initial));
+  const row = screen.getByRole('row', { name: /Round 1/ });
+  act(() => row.focus());
+  await act(() => userEvent.keyboard('{Enter}'));
+  const link = within(screen.getByRole('dialog')).getByRole('link', { name: 'All results' });
+  act(() => link.focus());
+  const refreshed = [
+    { ...initial[0], ranking: 2, attempts: [{ result: 900 }], best: 900, average: 1000 },
+  ];
+  rerender(personalTable(refreshed));
+  const dialog = screen.getByRole('dialog', { name: 'Competitor One · 3x3x3 Cube · Round 1 #2' });
+  expect(within(dialog).getByText('10.00')).toBeInTheDocument();
+  expect(within(dialog).getAllByText('9.00')).toHaveLength(2);
+  expect(within(dialog).queryByText('13.00')).not.toBeInTheDocument();
+  expect(link).toHaveFocus();
+  await act(() => userEvent.keyboard('{Escape}'));
+  expect(row).toHaveFocus();
+  await act(() => userEvent.keyboard('{Enter}'));
+  rerender(personalTable([]));
+  expect(screen.queryByRole('dialog')).not.toBeInTheDocument();
+  rerender(personalTable(refreshed));
+  expect(screen.queryByRole('dialog')).not.toBeInTheDocument();
+});
diff --git a/src/containers/CompetitionResults/ResultDetailsDialog.tsx b/src/containers/CompetitionResults/ResultDetailsDialog.tsx
index 6562e5f..0ad08e5 100644
--- a/src/containers/CompetitionResults/ResultDetailsDialog.tsx
+++ b/src/containers/CompetitionResults/ResultDetailsDialog.tsx
@@ -1,5 +1,5 @@
 import { EventId, Person, RankingType } from '@wca/helpers';
-import { MouseEvent, useEffect } from 'react';
+import { MouseEvent, useId, useLayoutEffect, useRef } from 'react';
 import { useTranslation } from 'react-i18next';
 import { AnchorLink, LinkRenderer } from '@/lib/linkRenderer';
 import { renderResultByEventId } from '@/lib/results';
@@ -24,6 +24,7 @@ interface ResultDetailsDialogProps {
   primaryRankingType: RankingType;
   result: CompetitionRoundResult;
   onClose: () => void;
+  returnFocusTo?: HTMLElement | null;
   LinkComponent?: LinkRenderer;
 }
 
@@ -45,9 +46,15 @@ export function ResultDetailsDialog({
   primaryRankingType,
   result,
   onClose,
+  returnFocusTo,
   LinkComponent = AnchorLink,
 }: ResultDetailsDialogProps) {
   const { t } = useTranslation();
+  const titleId = useId();
+  const dialogRef = useRef<HTMLDivElement>(null);
+  const closeButtonRef = useRef<HTMLButtonElement>(null);
+  const onCloseRef = useRef(onClose);
+  onCloseRef.current = onClose;
   const attempts = result.attempts
     .map((attempt) => renderValue(eventId, 'single', attempt.result))
     .filter(Boolean);
@@ -70,29 +77,83 @@ export function ResultDetailsDialog({
     event.stopPropagation();
   };
 
-  useEffect(() => {
-    const closeOnEscape = (event: KeyboardEvent) => {
+  useLayoutEffect(() => {
+    const dialog = dialogRef.current;
+    if (!dialog) return;
+    const previousFocus =
+      returnFocusTo ??
+      (document.activeElement instanceof HTMLElement ? document.activeElement : null);
+    const focusInside = () => (closeButtonRef.current ?? dialog).focus({ preventScroll: true });
+    const focusableElements = () =>
+      Array.from(
+        dialog.querySelectorAll<HTMLElement>(
+          'a[href], button:not([disabled]), input:not([disabled]), select:not([disabled]), textarea:not([disabled]), [tabindex]',
+        ),
+      ).filter((element) => {
+        const style = window.getComputedStyle(element);
+        return (
+          element.tabIndex >= 0 &&
+          !element.matches(':disabled') &&
+          !element.closest('[hidden], [inert], [aria-hidden="true"]') &&
+          style.display !== 'none' &&
+          style.visibility !== 'hidden'
+        );
+      });
+    const handleKeyDown = (event: KeyboardEvent) => {
       if (event.key === 'Escape') {
-        onClose();
+        event.preventDefault();
+        event.stopPropagation();
+        onCloseRef.current();
+      } else if (event.key === 'Tab' && !event.altKey && !event.ctrlKey && !event.metaKey) {
+        event.preventDefault();
+        const controls = focusableElements();
+        const index = controls.indexOf(document.activeElement as HTMLElement);
+        const nextIndex = event.shiftKey
+          ? index <= 0
+            ? controls.length - 1
+            : index - 1
+          : (index + 1) % controls.length;
+        (controls[nextIndex] ?? closeButtonRef.current ?? dialog).focus();
       }
     };
+    const containFocus = (event: FocusEvent) => {
+      if (event.target instanceof Node && !dialog.contains(event.target)) focusInside();
+    };
 
-    document.addEventListener('keydown', closeOnEscape);
+    document.addEventListener('keydown', handleKeyDown, true);
+    document.addEventListener('focusin', containFocus);
+    focusInside();
 
     return () => {
-      document.removeEventListener('keydown', closeOnEscape);
+      document.removeEventListener('keydown', handleKeyDown, true);
+      document.removeEventListener('focusin', containFocus);
+      // Wait until removed route elements are detached. Do not steal focus from
+      // a new page/dialog, or restore during StrictMode's effect replay.
+      queueMicrotask(() => {
+        const active = document.activeElement;
+        if (
+          !dialog.isConnected &&
+          previousFocus?.isConnected &&
+          (active === document.body || (active instanceof Node && dialog.contains(active)))
+        ) {
+          previousFocus.focus({ preventScroll: true });
+        }
+      });
     };
-  }, [onClose]);
+  }, [returnFocusTo]);
 
   return (
     <div
+      ref={dialogRef}
+      tabIndex={-1}
       aria-modal="true"
+      aria-labelledby={titleId}
       className="fixed inset-0 z-50 flex items-center justify-center bg-gray-950/40 p-4"
       role="dialog"
       onClick={onClose}>
       <div className="w-full max-w-xl rounded-md bg-panel p-6 shadow-xl" onClick={stopPropagation}>
         <div className="space-y-6">
-          <h3 className="type-heading">
+          <h3 id={titleId} className="type-heading">
             {title ?? `${name}${result.ranking ? ` #${result.ranking}` : ''}`}
           </h3>
 
@@ -137,7 +198,8 @@ export function ResultDetailsDialog({
 
           <div className="flex justify-end">
             <button
-              className="px-2 py-1 font-semibold text-primary hover-transition hover:underline"
+              ref={closeButtonRef}
+              className="px-2 py-2 font-semibold text-primary hover-transition hover:underline focus-visible:outline focus-visible:outline-2 focus-visible:outline-blue-500"
               type="button"
               onClick={onClose}>
               {t('common.close')}
diff --git a/src/containers/CompetitionResults/advancement.test.ts b/src/containers/CompetitionResults/advancement.test.ts
index e405dc9..93d5526 100644
--- a/src/containers/CompetitionResults/advancement.test.ts
+++ b/src/containers/CompetitionResults/advancement.test.ts
@@ -1,6 +1,6 @@
 import { ResultCondition, Round } from '@wca/helpers';
 import { getAdvancementConditionForRound, getLinkedRoundIds } from '@/lib/wcif';
-import { getStoredRoundResults } from './advancement';
+import { getQualifyingResultKeys, getStoredRoundResults, hasExpectedAttempts } from './advancement';
 import * as hongKongRounds from './fixtures/CubeAgainstCancerHongKong2026.json';
 import * as fmcRounds from './fixtures/FMCEastMelbourne2026.json';
 
@@ -108,21 +108,341 @@ describe('dual-round stored results', () => {
           average,
         })),
       );
-      // Later participation may differ after withdrawals and replacements. Keep
-      // this assertion on the stated qualifying condition, not the final roster.
+      // The actual target participants override the earlier eligibility estimate.
+      const targetIds = new Set(rounds[2].results.map(({ personId }) => personId));
+      expect(results.filter(({ advancing }) => advancing).map(({ personId }) => personId)).toEqual(
+        round.results
+          .filter(({ personId, ranking }) => ranking != null && targetIds.has(personId))
+          .map(({ personId }) => personId),
+      );
       const condition = getAdvancementConditionForRound(rounds, round)!;
       const entrants = new Set(
         rounds.slice(0, 2).flatMap(({ results }) => results.map(({ personId }) => personId)),
       ).size;
       const limit =
         condition.resultCondition.type === 'percent'
-          ? Math.ceil((entrants * condition.resultCondition.value) / 100)
+          ? Math.floor((entrants * condition.resultCondition.value) / 100)
           : condition.resultCondition.value!;
+      const qualifying = getQualifyingResultKeys(
+        round,
+        condition,
+        rounds
+          .slice(0, 2)
+          .flatMap(({ results }) =>
+            results.map((result) => ({ ...result, key: String(result.personId) })),
+          ),
+      );
       expect(
-        results.every(
-          ({ ranking, advancing }) => advancing === (ranking != null && ranking <= limit),
+        round.results.every(
+          ({ personId, ranking }) =>
+            qualifying.has(String(personId)) === (ranking != null && ranking <= limit),
         ),
       ).toBe(true);
     }
   });
 });
+
+const qualifiers = (
+  results: Round['results'],
+  condition: ResultCondition,
+  format: Round['format'] = 'a',
+) => {
+  const round = { ...makeRound('333-r1', results), format };
+  return getStoredRoundResults(round, {
+    sourceType: 'round',
+    sourceRoundIds: [round.id],
+    resultCondition: condition,
+  }).filter(({ advancing }) => advancing);
+};
+const rankedResults = (count: number) =>
+  Array.from({ length: count }, (_, i) => result(i + 1, i + 1, 800 + i * 100));
+
+describe('stored qualification rules', () => {
+  it.each([
+    [11, 8],
+    [15, 11],
+    [17, 12],
+  ])('rounds 75%% of %i scored entrants down to %i', (count, expected) => {
+    expect(
+      qualifiers(rankedResults(count), { type: 'percent', scope: 'average', value: 75 }),
+    ).toHaveLength(expected);
+  });
+
+  it('caps a configured top 10 at six of eight entrants', () => {
+    expect(
+      qualifiers(rankedResults(8), { type: 'ranking', scope: 'average', value: 10 }),
+    ).toHaveLength(6);
+  });
+
+  it('keeps a top-N tie together when it stays below the elimination cap', () => {
+    const results = rankedResults(20);
+    results[6].ranking = 6;
+    expect(
+      qualifiers(results, { type: 'ranking', scope: 'average', value: 6 }).map(
+        ({ personId }) => personId,
+      ),
+    ).toEqual([1, 2, 3, 4, 5, 6, 7]);
+  });
+
+  it.each<ResultCondition>([
+    { type: 'ranking', scope: 'average', value: 15 },
+    { type: 'percent', scope: 'average', value: 75 },
+    { type: 'resultAchieved', scope: 'average', value: 10000 },
+    { type: 'resultAchieved', scope: 'average', value: null },
+  ])('excludes a whole tied group crossing the cap for %j', (condition) => {
+    const results = rankedResults(20);
+    results[15].ranking = 15;
+    results[16].ranking = 15;
+    expect(qualifiers([...results].reverse(), condition)).toHaveLength(14);
+  });
+
+  it('counts failed results in the population but never qualifies all-DNF or DNS entrants', () => {
+    const results = rankedResults(16);
+    results[6].average = -1; // A successful single still makes this competitor eligible.
+    results.slice(7).forEach((entry, i) => {
+      entry.best = i % 2 ? -1 : -2;
+      entry.average = -1;
+      entry.ranking = 8;
+    });
+    expect(
+      qualifiers(results, { type: 'percent', scope: 'average', value: 50 }).map(
+        ({ personId }) => personId,
+      ),
+    ).toEqual([1, 2, 3, 4, 5, 6, 7]);
+  });
+
+  it('counts empty participant rows in the roster but never highlights them', () => {
+    const results: Round['results'] = [
+      ...rankedResults(6),
+      ...Array.from({ length: 4 }, (_, index) => ({
+        ...result(index + 7, 0, 0),
+        ranking: null,
+        attempts: [],
+      })),
+    ];
+    const advancing = qualifiers(results, { type: 'percent', scope: 'average', value: 75 });
+    expect(advancing.map(({ personId }) => personId)).toEqual([1, 2, 3, 4, 5, 6]);
+    expect(advancing.every(({ advancingQuestionable }) => advancingQuestionable)).toBe(true);
+  });
+
+  it('treats a null threshold as any successful value in the requested scope', () => {
+    const results = rankedResults(8);
+    results[1].average = -1;
+    results[2].average = -2;
+    results[3].average = 0;
+    expect(
+      qualifiers(results, { type: 'resultAchieved', scope: 'average', value: null }).map(
+        ({ personId }) => personId,
+      ),
+    ).toEqual([1, 5, 6]);
+    expect(
+      qualifiers(results, { type: 'resultAchieved', scope: 'single', value: null }),
+    ).toHaveLength(6);
+  });
+
+  it('requires a value strictly better than a non-null threshold', () => {
+    expect(
+      qualifiers(rankedResults(8), {
+        type: 'resultAchieved',
+        scope: 'average',
+        value: 1000,
+      }).map(({ personId }) => personId),
+    ).toEqual([1, 2]);
+  });
+
+  it('allows success in either linked component without replacing displayed DNF values', () => {
+    const rounds = linkedRounds({ type: 'ranking', scope: 'average', value: 3 });
+    rounds[0].results[0] = { ...result(1, 2, -1), best: -1 };
+    rounds[1].results[0] = { ...result(1, 2, -1), best: 900 };
+    expect(
+      getStoredRoundResults(
+        rounds[0],
+        getAdvancementConditionForRound(rounds, rounds[0]),
+        rounds,
+      )[0],
+    ).toMatchObject({ ranking: 2, best: -1, average: -1, advancing: true });
+  });
+
+  it('keeps an empty component row unhighlighted without losing sibling eligibility', () => {
+    const rounds = linkedRounds({ type: 'ranking', scope: 'average', value: 3 });
+    rounds[0].results[0] = {
+      ...result(1, 2, 0),
+      ranking: null,
+      attempts: [],
+    };
+    const condition = getAdvancementConditionForRound(rounds, rounds[0]);
+    expect(getStoredRoundResults(rounds[0], condition, rounds)[0]).toMatchObject({
+      ranking: null,
+      best: 0,
+      average: 0,
+      attempts: [],
+      advancing: false,
+    });
+    expect(getStoredRoundResults(rounds[1], condition, rounds)[0].advancing).toBe(true);
+  });
+
+  it('does not qualify a final or an entirely empty round', () => {
+    expect(getStoredRoundResults(makeRound('333-r1', rankedResults(8)), null)).toEqual(
+      expect.arrayContaining([expect.objectContaining({ advancing: false })]),
+    );
+    expect(qualifiers([], { type: 'ranking', scope: 'average', value: 10 })).toEqual([]);
+  });
+});
+
+const fullResult = (personId: number, ranking: number, average = 1000) => ({
+  ...result(personId, ranking, average),
+  attempts: Array.from({ length: 5 }, () => ({ value: average, reconstruction: null })),
+});
+const withTarget = (rounds: Round[]) => {
+  rounds[1].participationRuleset = {
+    reservedPlaces: null,
+    participationSource: {
+      type: 'round',
+      roundId: rounds[0].id,
+      resultCondition: { type: 'percent', scope: 'average', value: 75 },
+    },
+  };
+  return rounds;
+};
+
+describe('fallback qualification certainty and participation', () => {
+  it('settles calculated eligibility when all source attempts are complete', () => {
+    const rounds = withTarget([
+      makeRound(
+        '333-r1',
+        Array.from({ length: 8 }, (_, i) => fullResult(i + 1, i + 1)),
+      ),
+      makeRound('333-r2'),
+    ]);
+    const results = getStoredRoundResults(
+      rounds[0],
+      getAdvancementConditionForRound(rounds, rounds[0]),
+      rounds,
+    );
+    expect(results.filter(({ advancing }) => advancing)).toHaveLength(6);
+    expect(results.every(({ advancingQuestionable }) => !advancingQuestionable)).toBe(true);
+  });
+
+  it('keeps every calculated qualifier provisional when even one row is partial', () => {
+    const rounds = withTarget([
+      makeRound(
+        '333-r1',
+        Array.from({ length: 8 }, (_, i) => fullResult(i + 1, i + 1)),
+      ),
+      makeRound('333-r2'),
+    ]);
+    rounds[0].results[7].attempts = [{ value: 1100, reconstruction: null }];
+    const results = getStoredRoundResults(
+      rounds[0],
+      getAdvancementConditionForRound(rounds, rounds[0]),
+      rounds,
+    );
+    expect(
+      results
+        .filter(({ advancing }) => advancing)
+        .every(({ advancingQuestionable }) => advancingQuestionable),
+    ).toBe(true);
+    expect(
+      results
+        .filter(({ advancing }) => !advancing)
+        .every(({ advancingQuestionable }) => !advancingQuestionable),
+    ).toBe(true);
+  });
+
+  it.each(['missing', 'empty', 'partial'])(
+    'does not settle linked eligibility when a component is %s',
+    (state) => {
+      const rounds = linkedRounds({ type: 'ranking', scope: 'average', value: 3 });
+      rounds[0].results = Array.from({ length: 4 }, (_, i) => fullResult(i + 1, i + 1));
+      rounds[1].results = state === 'partial' ? [result(1, 1, 900)] : [];
+      const condition = getAdvancementConditionForRound(rounds, rounds[0]);
+      const sourceRounds = state === 'missing' ? [rounds[0], rounds[2]] : rounds;
+      expect(getStoredRoundResults(rounds[0], condition, sourceRounds)[0]).toMatchObject({
+        advancing: true,
+        advancingQuestionable: true,
+      });
+    },
+  );
+
+  it('uses actual next-round participants, including blank rows, over theoretical qualifiers', () => {
+    const rounds = withTarget([
+      makeRound(
+        '333-r1',
+        Array.from({ length: 8 }, (_, i) => result(i + 1, i + 1, 1000)),
+      ),
+      makeRound('333-r2', [
+        { ...result(1, 0, 0), ranking: null, attempts: [] },
+        { ...result(8, 0, 0), ranking: null, attempts: [] },
+      ]),
+    ]);
+    const results = getStoredRoundResults(
+      rounds[0],
+      getAdvancementConditionForRound(rounds, rounds[0]),
+      rounds,
+    );
+    expect(results.filter(({ advancing }) => advancing).map(({ personId }) => personId)).toEqual([
+      1, 8,
+    ]);
+    expect(results.every(({ advancingQuestionable }) => !advancingQuestionable)).toBe(true);
+  });
+
+  it('uses the union if a future WCIF target stage has linked components', () => {
+    // Current WCA dual rounds are first-round only. This covers WCIF's extensible links.
+    const rounds = withTarget([
+      makeRound(
+        '333-r1',
+        Array.from({ length: 8 }, (_, i) => result(i + 1, i + 1, 1000)),
+      ),
+      makeRound('333-r2', [result(1, 1, 1000)]),
+      makeRound('333-r3', [result(8, 1, 900)]),
+    ]);
+    rounds[1].linkedRounds = ['333-r2', '333-r3'];
+    rounds[2].linkedRounds = ['333-r2', '333-r3'];
+    expect(
+      getStoredRoundResults(rounds[0], getAdvancementConditionForRound(rounds, rounds[0]), rounds)
+        .filter(({ advancing }) => advancing)
+        .map(({ personId }) => personId),
+    ).toEqual([1, 8]);
+  });
+});
+
+describe('expected attempts in stored snapshots', () => {
+  it.each<[Round['format'], number]>([
+    ['1', 1],
+    ['2', 2],
+    ['3', 3],
+    ['5', 5],
+    ['a', 5],
+    ['m', 3],
+  ])('recognizes completed format %s and rejects one missing attempt', (format, count) => {
+    const round = { ...makeRound('333-r1'), format };
+    const attempts = Array.from({ length: count }, () => ({ result: -1 }));
+    expect(hasExpectedAttempts(round, { attempts })).toBe(true);
+    expect(hasExpectedAttempts(round, { attempts: attempts.slice(1) })).toBe(false);
+    expect(hasExpectedAttempts(round, { attempts: [...attempts.slice(1), { result: 0 }] })).toBe(
+      false,
+    );
+    expect(
+      hasExpectedAttempts(round, { attempts: [...attempts, { result: 0 }, { result: 0 }] }),
+    ).toBe(true);
+  });
+
+  it('recognizes a missed cutoff, but requires all attempts once the cutoff is met', () => {
+    const round = { ...makeRound('333-r1'), cutoff: { numberOfAttempts: 2, resultValue: 1000 } };
+    const hasAttempts = (values: number[]) =>
+      hasExpectedAttempts(round, { attempts: values.map((result) => ({ result })) });
+    expect(hasAttempts([1200])).toBe(false);
+    expect(hasAttempts([1200, -1, 0, 0, 0])).toBe(true);
+    expect(hasAttempts([-2, -2])).toBe(true);
+    expect(hasAttempts([1000, 1000])).toBe(true); // equality does not meet the cutoff
+    expect(hasAttempts([900, -1])).toBe(false);
+    expect(hasAttempts([900, -1, -2, 1000, 1100])).toBe(true);
+    expect(hasAttempts([900, -1, -2, 1000, 0])).toBe(false);
+  });
+
+  it('does not infer completion for an unsupported head-to-head format', () => {
+    expect(hasExpectedAttempts({ ...makeRound('333-r1'), format: 'h' }, { attempts: [] })).toBe(
+      false,
+    );
+  });
+});
diff --git a/src/containers/CompetitionResults/advancement.ts b/src/containers/CompetitionResults/advancement.ts
index d940a32..10346db 100644
--- a/src/containers/CompetitionResults/advancement.ts
+++ b/src/containers/CompetitionResults/advancement.ts
@@ -1,5 +1,5 @@
-import { RankingType, Round } from '@wca/helpers';
-import { RoundAdvancementCondition } from '@/lib/wcif';
+import { RankingType, Round, getFormatExpectedSolves } from '@wca/helpers';
+import { RoundAdvancementCondition, getLinkedRoundIds } from '@/lib/wcif';
 import { CompetitionRoundResult } from './CompetitionResultsTable';
 import { normalizeResultRecordTag } from './ResultRecordBadge';
 
@@ -8,80 +8,194 @@ const averagedFormats = new Set(['a', 'm']);
 const getPrimaryRankingType = (round: Pick<Round, 'format'>): RankingType =>
   averagedFormats.has(round.format) ? 'average' : 'single';
 
-const getRankLimit = (
-  resultCondition: RoundAdvancementCondition['resultCondition'],
-  resultCount: number,
-) => {
-  if (resultCondition.type === 'ranking') {
-    return resultCondition.value;
-  }
-
-  if (resultCondition.type === 'percent') {
-    return Math.ceil((resultCount * resultCondition.value) / 100);
-  }
-
-  return null;
+type QualificationResult = Pick<CompetitionRoundResult, 'ranking' | 'best' | 'average'> & {
+  // Stable competitor identity across all source rounds, not the component result ID.
+  key: string;
 };
 
-const getResultValue = (result: Round['results'][number], scope: RankingType) =>
-  scope === 'average' ? result.average : result.best;
-
-const isAdvancingFromStoredResult = (
-  round: Round,
-  result: Round['results'][number],
+export const getQualifyingResultKeys = (
+  round: Pick<Round, 'format'>,
   advancementCondition: RoundAdvancementCondition | null,
-  eventRounds: Round[],
-) => {
-  if (!advancementCondition) {
-    return false;
-  }
+  sourceResults: QualificationResult[],
+): Set<string> => {
+  if (!advancementCondition) return new Set();
 
   const { resultCondition } = advancementCondition;
-  // A dual-round percentage uses distinct competitors across both components,
-  // including people who only competed in one. WCIF already supplies shared ranks.
-  const sourceRounds =
-    advancementCondition.sourceType === 'linkedRounds'
-      ? eventRounds.filter((sourceRound) =>
-          advancementCondition.sourceRoundIds.includes(sourceRound.id),
-        )
-      : [round];
-  const sourceResults = sourceRounds.flatMap((sourceRound) => sourceRound.results);
-  const rankedResultCount = new Set(
-    sourceResults
-      .filter((roundResult) => roundResult.ranking != null)
-      .map((roundResult) => roundResult.personId),
-  ).size;
-  const rankLimit = getRankLimit(resultCondition, rankedResultCount);
-
-  if (rankLimit != null) {
-    return result.ranking != null && result.ranking <= rankLimit;
-  }
+  const resultsByPerson = new Map<string, QualificationResult[]>();
+  sourceResults.forEach((result) => {
+    const personResults = resultsByPerson.get(result.key) ?? [];
+    personResults.push(result);
+    resultsByPerson.set(result.key, personResults);
+  });
 
-  if (resultCondition.type !== 'resultAchieved') {
-    return false;
-  }
+  // WCIF supplies official ranks shared across linked components. Like Live,
+  // count every participant result row, including an empty one, exactly once.
+  // Scheduled group assignments are not evidence of current participation.
+  const rankingsByPerson = new Map<string, number>();
+  resultsByPerson.forEach((results, key) => {
+    const rankings = results.flatMap(({ ranking }) =>
+      ranking != null && ranking > 0 ? [ranking] : [],
+    );
+    if (rankings.length > 0) rankingsByPerson.set(key, Math.min(...rankings));
+  });
+  const rankings = [...rankingsByPerson.values()].sort((a, b) => a - b);
+  const resultCount = resultsByPerson.size;
+  const maxQualifying = Math.floor(resultCount * 0.75);
+  // WCA Live's qualification algorithm excludes the entire tied group if it
+  // crosses the 75% cap (9p1). Never break an official tie by array order.
+  const firstNonQualifyingRanking = rankings[maxQualifying] ?? Infinity;
+  const rankLimit =
+    resultCondition.type === 'ranking'
+      ? resultCondition.value
+      : resultCondition.type === 'percent'
+        ? Math.floor((resultCount * resultCondition.value) / 100)
+        : null;
+  const scope = resultCondition.scope ?? getPrimaryRankingType(round);
+
+  return new Set(
+    [...resultsByPerson].flatMap(([key, results]) => {
+      const ranking = rankingsByPerson.get(key);
+      if (
+        ranking == null ||
+        ranking >= firstNonQualifyingRanking ||
+        // A DNF average is still eligible when either component has a successful
+        // single. Only all-DNF/DNS results are excluded by 9p4.
+        !results.some(({ best }) => best > 0)
+      ) {
+        return [];
+      }
+
+      const satisfiesCondition =
+        rankLimit != null
+          ? ranking <= rankLimit
+          : resultCondition.type === 'resultAchieved' &&
+            results.some((result) => {
+              const value = scope === 'average' ? result.average : result.best;
+              return value > 0 && (resultCondition.value == null || value < resultCondition.value);
+            });
+      return satisfiesCondition ? [key] : [];
+    }),
+  );
+};
+
+type QualificationRound = {
+  round: Pick<Round, 'format' | 'cutoff'>;
+  results: (QualificationResult & Pick<CompetitionRoundResult, 'attempts'>)[];
+};
 
-  if (resultCondition.value == null) {
-    return false;
+export const hasExpectedAttempts = (
+  round: Pick<Round, 'format' | 'cutoff'>,
+  result: Pick<CompetitionRoundResult, 'attempts'>,
+): boolean => {
+  const maxAttempts = getFormatExpectedSolves(round.format);
+  if (maxAttempts === 0) return false;
+
+  // Published API results can be padded with zeros. A trailing zero is missing,
+  // not an entered attempt; an interior skipped attempt still occupies its slot.
+  const attempts = result.attempts.map(({ result }) => result);
+  while (attempts.at(-1) === 0) attempts.pop();
+  const meetsCutoff =
+    !round.cutoff ||
+    attempts
+      .slice(0, round.cutoff.numberOfAttempts)
+      .some((value) => value > 0 && value < round.cutoff!.resultValue);
+  const expected = meetsCutoff ? maxAttempts : round.cutoff!.numberOfAttempts;
+  return attempts.length === expected;
+};
+
+/**
+ * Stored snapshots can establish next-round participation or estimate eligibility.
+ * Live exports all result rows, including blank ones, so a populated target round
+ * is the participant list, not a reason to reapply the previous qualifying rule.
+ * https://github.com/thewca/wca-live/blob/main/lib/wca_live/scoretaking/advancing.ex
+ *
+ * For incomplete snapshots we deliberately do not claim Live's clinching parity:
+ * all calculated qualifiers remain provisional until the source results are
+ * complete. WCIF has no Live edit history or organizer-only disqualification state.
+ */
+export const getFallbackAdvancement = (
+  round: Pick<Round, 'format'>,
+  advancementCondition: RoundAdvancementCondition | null,
+  sourceRounds: QualificationRound[],
+  targetResults: (Pick<QualificationResult, 'key'> & { identityResolved?: boolean })[] = [],
+  sourceIdentityComplete = true,
+): { advancingKeys: Set<string>; questionableKeys: Set<string> } => {
+  if (!advancementCondition) return { advancingKeys: new Set(), questionableKeys: new Set() };
+  const actualParticipantKeys = new Set(
+    targetResults
+      .filter(({ identityResolved }) => identityResolved !== false)
+      .map(({ key }) => key),
+  );
+  const targetIdentityComplete = targetResults.every(
+    ({ identityResolved }) => identityResolved !== false,
+  );
+  if (targetResults.length > 0 && targetIdentityComplete) {
+    return { advancingKeys: actualParticipantKeys, questionableKeys: new Set() };
   }
 
-  const scope = resultCondition.scope ?? getPrimaryRankingType(round);
-  return sourceResults.some((sourceResult) => {
-    const resultValue = getResultValue(sourceResult, scope);
-    return (
-      sourceResult.personId === result.personId &&
-      resultValue > 0 &&
-      resultValue < resultCondition.value!
+  const sourceResults = sourceRounds.flatMap(({ results }) => results);
+  const qualifyingKeys = sourceIdentityComplete
+    ? getQualifyingResultKeys(round, advancementCondition, sourceResults)
+    : new Set<string>();
+  const complete =
+    targetIdentityComplete &&
+    sourceRounds.length === advancementCondition.sourceRoundIds.length &&
+    sourceRounds.every(
+      ({ round, results }) =>
+        results.length > 0 && results.every((result) => hasExpectedAttempts(round, result)),
     );
-  });
+
+  // Unidentified target rows cannot prove that a known qualifier was excluded.
+  // Keep those estimates provisional, but settle the actual matches we do know.
+  return {
+    advancingKeys: new Set([...qualifyingKeys, ...actualParticipantKeys]),
+    questionableKeys: new Set(
+      [...qualifyingKeys].filter((key) => !complete && !actualParticipantKeys.has(key)),
+    ),
+  };
+};
+
+/** Never interpret a linked source component as evidence of later participation. */
+export const getAdvancementTargetRoundIds = (
+  eventRounds: Round[],
+  advancementCondition: RoundAdvancementCondition | null,
+): string[] => {
+  const targetRound = eventRounds.find(({ id }) => id === advancementCondition?.targetRoundId);
+  if (!targetRound || !advancementCondition) return [];
+  const linkedTargetIds = getLinkedRoundIds(eventRounds, targetRound);
+  return linkedTargetIds.length > 0 &&
+    !linkedTargetIds.some((id) => advancementCondition.sourceRoundIds.includes(id))
+    ? linkedTargetIds
+    : [targetRound.id];
 };
 
 export const getStoredRoundResults = (
   round: Round,
   advancementCondition: RoundAdvancementCondition | null,
   eventRounds: Round[] = [round],
-): CompetitionRoundResult[] =>
-  round.results.map((result) => {
+): CompetitionRoundResult[] => {
+  const sourceRounds =
+    advancementCondition?.sourceType === 'linkedRounds'
+      ? eventRounds.filter(({ id }) => advancementCondition.sourceRoundIds.includes(id))
+      : [round];
+  const targetRoundIds = getAdvancementTargetRoundIds(eventRounds, advancementCondition);
+  const { advancingKeys, questionableKeys } = getFallbackAdvancement(
+    round,
+    advancementCondition,
+    sourceRounds.map((sourceRound) => ({
+      round: sourceRound,
+      results: sourceRound.results.map((result) => ({
+        ...result,
+        key: String(result.personId),
+        attempts: result.attempts.map(({ value }) => ({ result: value })),
+      })),
+    })),
+    eventRounds
+      .filter(({ id }) => targetRoundIds.includes(id))
+      .flatMap(({ results }) => results.map(({ personId }) => ({ key: String(personId) }))),
+  );
+
+  return round.results.map((result) => {
     const resultWithRecords = result as typeof result & {
       regionalSingleRecord?: string | null;
       regionalAverageRecord?: string | null;
@@ -89,12 +203,13 @@ export const getStoredRoundResults = (
       averageRecordTag?: string | null;
     };
 
+    const advancing = result.ranking != null && advancingKeys.has(String(result.personId));
     return {
       id: result.personId,
       personId: result.personId,
       ranking: result.ranking,
-      advancing: isAdvancingFromStoredResult(round, result, advancementCondition, eventRounds),
-      advancingQuestionable: false,
+      advancing,
+      advancingQuestionable: advancing && questionableKeys.has(String(result.personId)),
       attempts: result.attempts.map((attempt) => ({ result: attempt.value })),
       best: result.best,
       average: result.average,
@@ -106,3 +221,4 @@ export const getStoredRoundResults = (
       ),
     };
   });
+};
diff --git a/src/containers/CompetitionResults/fixtures/README.md b/src/containers/CompetitionResults/fixtures/README.md
index 4306821..33bb153 100644
--- a/src/containers/CompetitionResults/fixtures/README.md
+++ b/src/containers/CompetitionResults/fixtures/README.md
@@ -10,3 +10,20 @@ Only the relevant event rounds are retained (FMC and 3x3, respectively). Person
 WCA Regulation 9v4 defines ranking by the better result of either round; 9v4a retains both component results; 9v5 prohibits elimination between components. Advancement percentages count distinct competitors across the linked source rounds. Later participants need not match the original qualification estimate because of withdrawals/replacements.
 
 Published-results endpoint verified separately on 2026-11-03: Hong Kong uses `1`, `2`, `f` for its three 3x3 rounds; FMC East Melbourne returned no published results. WCIF is available for both.
+
+
+## Stored advancement semantics
+
+- Qualification uses the distinct union of participant result rows, including blank rows, but not scheduled group assignments or registrations. Official ranks, the 75% cap, and ties are preserved.
+- A populated target result roster takes precedence over calculated qualification. WCIF target membership takes precedence over published API membership; the latter is used only when the corresponding WCIF roster is empty. An unresolved API identity cannot prove that a known qualifier was excluded: known matches are settled, remaining eligible rows stay provisional.
+- Without target participation, all calculated qualifiers are provisional when any source component is missing/empty or any result lacks its expected attempts. Completion respects format, cutoff, and zero-padded API attempts. Complete snapshots settle the estimate; they do not establish future organizer decisions.
+- Selected Live rows override stored values and flags, including blank Live rows. Stored snapshots cannot reproduce all Live edit history, organizer-only state, or exact clinching simulation. Marking all calculated qualifiers provisional during incomplete rounds is deliberately conservative.
+- Caption tests use actual English resources for timed, FMC, multi-blind, null, and linked thresholds. Storybook stories prefixed `Synthetic` are isolated edge-case fixtures, not evidence of a real competition incident.
+
+Primary implementation references, inspected 2026-11-03:
+
+- [Live advancement and clinching](https://github.com/thewca/wca-live/blob/main/lib/wca_live/scoretaking/advancing.ex)
+- [Live open-round definition](https://github.com/thewca/wca-live/blob/main/lib/wca_live/scoretaking/round.ex): any result row, even blank, makes a round open.
+- [Live expected attempts](https://github.com/thewca/wca-live/blob/main/lib/wca_live/scoretaking/result.ex)
+- [Live WCIF export](https://github.com/thewca/wca-live/blob/main/lib/wca_live/synchronization/export.ex): includes blank result rows.
+- [WCIF2 result conditions and units](https://github.com/thewca/wcif/blob/latest/specification.md#resultcondition)
diff --git a/src/containers/CompetitionResults/resultSources.ts b/src/containers/CompetitionResults/resultSources.ts
index ac0510a..2d9ece3 100644
--- a/src/containers/CompetitionResults/resultSources.ts
+++ b/src/containers/CompetitionResults/resultSources.ts
@@ -104,6 +104,7 @@ export const toCompetitionRoundResult = (
     id: result.id,
     personId: person?.registrantId ?? null,
     personName: result.name,
+    wcaId: result.wca_id,
     ranking: result.pos,
     advancing: false,
     advancingQuestionable: false,
diff --git a/src/containers/CompetitionResults/resultsProvider.test.ts b/src/containers/CompetitionResults/resultsProvider.test.ts
index c6a467b..59fed34 100644
--- a/src/containers/CompetitionResults/resultsProvider.test.ts
+++ b/src/containers/CompetitionResults/resultsProvider.test.ts
@@ -741,3 +741,487 @@ describe('resultsProvider', () => {
     ]);
   });
 });
+
+const linkedCompetition = (): Competition => {
+  const competition = JSON.parse(JSON.stringify(wcif)) as Competition;
+  competition.persons.push({
+    ...persons[0],
+    registrantId: 4,
+    name: 'Dana Solver',
+    wcaId: '2010DANA01',
+  });
+  const rounds = competition.events[0].rounds;
+  rounds[0].results = competition.persons.map(({ registrantId }, index) => ({
+    personId: registrantId!,
+    ranking: index + 1,
+    best: 1500 + index * 100,
+    average: 1500 + index * 100,
+    attempts: [{ value: 1500 + index * 100, reconstruction: null }],
+  }));
+  rounds[0].linkedRounds = ['333-r1', '333-r2'];
+  rounds[1].linkedRounds = ['333-r1', '333-r2'];
+  rounds[2].participationRuleset = {
+    participationSource: {
+      type: 'linkedRounds',
+      roundIds: ['333-r1', '333-r2'],
+      resultCondition: { type: 'resultAchieved', scope: 'average', value: 1000 },
+    },
+    reservedPlaces: null,
+  };
+  return competition;
+};
+
+const linkedSourceResults = (
+  competition: Competition,
+  apiResults: WcaCompetitionResult[],
+  roundIndex = 0,
+  live: WcaLiveRound | null = null,
+) =>
+  getRoundResultsFromSources({
+    wcif: competition,
+    selectedRound: {
+      event: competition.events[0],
+      round: competition.events[0].rounds[roundIndex],
+      roundNumber: roundIndex + 1,
+    },
+    wcaApiResults: apiResults,
+    wcaLiveRound: live,
+  });
+
+const aliceSecondComponent = () =>
+  apiResult({
+    id: 9010,
+    pos: 1,
+    best: 800,
+    average: 900,
+    attempts: [800, 900, 1000],
+    name: 'Alice Solver',
+    wca_id: '2010ALIC01',
+  });
+
+describe('mixed-source linked qualification', () => {
+  it('uses a sibling API result to qualify a WCIF row without replacing component values', () => {
+    const competition = linkedCompetition();
+    const api = aliceSecondComponent();
+    expect(linkedSourceResults(competition, [api])[0]).toMatchObject({
+      personId: 1,
+      ranking: 1,
+      best: 1500,
+      average: 1500,
+      attempts: [{ result: 1500 }],
+      advancing: true,
+    });
+    expect(linkedSourceResults(competition, [api], 1)).toEqual([
+      expect.objectContaining({ id: 9010, average: 900, advancing: true }),
+    ]);
+  });
+
+  it('does not highlight an empty selected component when the sibling qualifies', () => {
+    const competition = linkedCompetition();
+    const round = competition.events[0].rounds[0];
+    round.results[0] = {
+      ...round.results[0],
+      ranking: null,
+      best: 0,
+      average: 0,
+      attempts: [],
+    };
+    expect(linkedSourceResults(competition, [aliceSecondComponent()])[0]).toMatchObject({
+      ranking: null,
+      best: 0,
+      average: 0,
+      advancing: false,
+    });
+    expect(linkedSourceResults(competition, [aliceSecondComponent()], 1)[0].advancing).toBe(true);
+  });
+
+  it('keeps WCIF priority over a conflicting API result in a sibling component', () => {
+    const competition = linkedCompetition();
+    competition.events[0].rounds[1].results = [
+      { ...competition.events[0].rounds[0].results[0], best: 1100, average: 1200 },
+    ];
+    expect(linkedSourceResults(competition, [aliceSecondComponent()])[0].advancing).toBe(false);
+  });
+
+  it('allows a DNF component when the sibling API component has a successful single', () => {
+    const competition = linkedCompetition();
+    const rounds = competition.events[0].rounds;
+    rounds[0].results[0] = {
+      ...rounds[0].results[0],
+      best: -1,
+      average: -1,
+      attempts: [{ value: -1, reconstruction: null }],
+    };
+    rounds[2].participationRuleset!.participationSource = {
+      type: 'linkedRounds',
+      roundIds: ['333-r1', '333-r2'],
+      resultCondition: { type: 'ranking', scope: 'average', value: 2 },
+    };
+    expect(
+      linkedSourceResults(competition, [{ ...aliceSecondComponent(), average: -1 }])[0],
+    ).toMatchObject({ best: -1, average: -1, advancing: true });
+  });
+
+  it('counts API-only entrants in the distinct linked union for percentages', () => {
+    const competition = linkedCompetition();
+    const rounds = competition.events[0].rounds;
+    rounds[0].results = [rounds[0].results[0], { ...rounds[0].results[1], ranking: 3 }];
+    rounds[2].participationRuleset!.participationSource = {
+      type: 'linkedRounds',
+      roundIds: ['333-r1', '333-r2'],
+      resultCondition: { type: 'percent', scope: 'average', value: 50 },
+    };
+    const api = [
+      aliceSecondComponent(),
+      apiResult({ id: 9011, pos: 2, name: 'Casey Solver', wca_id: null }),
+      apiResult({ id: 9012, pos: 4, name: 'Dana Solver', wca_id: '2010DANA01' }),
+    ];
+    expect(linkedSourceResults(competition, api).map(({ advancing }) => advancing)).toEqual([
+      true,
+      false,
+    ]);
+    expect(
+      linkedSourceResults(competition, api, 1).map(({ personId, advancing }) => ({
+        personId,
+        advancing,
+      })),
+    ).toEqual([
+      { personId: 1, advancing: true },
+      { personId: 3, advancing: true },
+      { personId: 4, advancing: false },
+    ]);
+  });
+
+  it('deduplicates an API-only competitor by WCA ID without inventing a WCIF identity', () => {
+    const competition = linkedCompetition();
+    const rounds = competition.events[0].rounds;
+    rounds[0].results = [rounds[0].results[0], { ...rounds[0].results[1], ranking: 3 }];
+    rounds[2].participationRuleset!.participationSource = {
+      type: 'linkedRounds',
+      roundIds: ['333-r1', '333-r2'],
+      resultCondition: { type: 'ranking', scope: 'average', value: 10 },
+    };
+    const api = [
+      apiResult({ id: 9011, pos: 2, wca_id: '2010ELSE01', round_type_id: '1' }),
+      apiResult({ id: 9012, pos: 2, wca_id: '2010ELSE01', round_type_id: '2' }),
+    ];
+    const results = linkedSourceResults(competition, api);
+    expect(results.find(({ id }) => id === 9011)).toMatchObject({
+      personId: null,
+      wcaId: '2010ELSE01',
+      advancing: true,
+    });
+    expect(results.find(({ personId }) => personId === 2)?.advancing).toBe(false);
+  });
+
+  it('does not invent a linked union when an API row has no resolvable identity', () => {
+    const competition = linkedCompetition();
+    const results = linkedSourceResults(competition, [
+      aliceSecondComponent(),
+      apiResult({ id: 9011, name: 'Unmatched Competitor', wca_id: null }),
+    ]);
+    expect(results.every(({ advancing }) => !advancing)).toBe(true);
+  });
+
+  it('allows authoritative live advancement even when unresolved linked identity suppresses fallback', () => {
+    const competition = linkedCompetition();
+    const live = liveRound([
+      liveRoundResult({
+        id: 'live-alice',
+        person: { id: '1', registrantId: 1, name: 'Alice Solver' },
+        advancing: true,
+        advancingQuestionable: false,
+      }),
+    ]);
+    expect(
+      linkedSourceResults(
+        competition,
+        [apiResult({ id: 9011, name: 'Unmatched Competitor', wca_id: null })],
+        0,
+        live,
+      ).find(({ personId }) => personId === 1),
+    ).toMatchObject({ advancing: true, advancingQuestionable: false });
+  });
+
+  it('keeps live advancement and questionable flags authoritative over computed qualification', () => {
+    const competition = linkedCompetition();
+    const live = liveRound([
+      liveRoundResult({
+        id: 'live-alice',
+        person: { id: '1', registrantId: 1, name: 'Alice Solver' },
+        advancing: false,
+        advancingQuestionable: true,
+      }),
+    ]);
+    expect(
+      linkedSourceResults(competition, [aliceSecondComponent()], 0, live).find(
+        ({ personId }) => personId === 1,
+      ),
+    ).toMatchObject({ advancing: false, advancingQuestionable: true });
+  });
+});
+
+const singleSourceCompetition = (): Competition => {
+  const competition = linkedCompetition();
+  const rounds = competition.events[0].rounds;
+  rounds[0].linkedRounds = null;
+  rounds[1].linkedRounds = null;
+  rounds[0].results = Array.from({ length: 8 }, (_, index) => ({
+    personId: index + 1,
+    ranking: index + 1,
+    best: 1000 + index * 100,
+    average: 1000 + index * 100,
+    attempts: Array.from({ length: 5 }, () => ({
+      value: 1000 + index * 100,
+      reconstruction: null,
+    })),
+  }));
+  rounds[1].participationRuleset = {
+    reservedPlaces: null,
+    participationSource: {
+      type: 'round',
+      roundId: '333-r1',
+      resultCondition: { type: 'percent', scope: 'average', value: 75 },
+    },
+  };
+  rounds[2].participationRuleset = null;
+  return competition;
+};
+const blankResult = (personId: number) => ({
+  personId,
+  ranking: null,
+  best: 0,
+  average: 0,
+  attempts: [],
+});
+const advancingPersonIds = (results: ReturnType<typeof linkedSourceResults>) =>
+  results.filter(({ advancing }) => advancing).map(({ personId }) => personId);
+
+describe('stored roster and actual-participant semantics', () => {
+  it('counts empty WCIF result rows but does not count group assignments in the denominator', () => {
+    const competition = singleSourceCompetition();
+    const round = competition.events[0].rounds[0];
+    round.results = [...round.results.slice(0, 6), ...[7, 8, 9, 10].map(blankResult)];
+    let results = linkedSourceResults(competition, []);
+    expect(advancingPersonIds(results)).toEqual([1, 2, 3, 4, 5, 6]);
+    expect(
+      results
+        .filter(({ advancing }) => advancing)
+        .every(({ advancingQuestionable }) => advancingQuestionable),
+    ).toBe(true);
+    expect(
+      results
+        .slice(6)
+        .every(({ advancing, advancingQuestionable }) => !advancing && !advancingQuestionable),
+    ).toBe(true);
+
+    // Four people have group assignments, but only this stored result is a participant.
+    round.results = [round.results[0]];
+    results = linkedSourceResults(competition, []);
+    expect(results).toHaveLength(1);
+    expect(advancingPersonIds(results)).toEqual([]);
+  });
+
+  it('settles complete snapshots and marks partial snapshots provisional without changing values', () => {
+    const competition = singleSourceCompetition();
+    let results = linkedSourceResults(competition, []);
+    expect(advancingPersonIds(results)).toEqual([1, 2, 3, 4, 5, 6]);
+    expect(results.every(({ advancingQuestionable }) => !advancingQuestionable)).toBe(true);
+    competition.events[0].rounds[0].results[0].attempts = [{ value: 1000, reconstruction: null }];
+    results = linkedSourceResults(competition, []);
+    expect(results[0]).toMatchObject({
+      best: 1000,
+      average: 1000,
+      attempts: [{ result: 1000 }],
+      advancing: true,
+      advancingQuestionable: true,
+    });
+    expect(results[1]).toMatchObject({ advancing: true, advancingQuestionable: true });
+  });
+
+  it('uses a populated next-round WCIF roster, including blank rows, instead of qualification', () => {
+    const competition = singleSourceCompetition();
+    competition.events[0].rounds[1].results = [blankResult(1), blankResult(8)];
+    const results = linkedSourceResults(competition, []);
+    expect(advancingPersonIds(results)).toEqual([1, 8]);
+    expect(results.every(({ advancingQuestionable }) => !advancingQuestionable)).toBe(true);
+  });
+
+  it('uses published next-round API participants when that WCIF roster is empty', () => {
+    const competition = singleSourceCompetition();
+    const api = [
+      apiResult({ name: 'Alice Solver', wca_id: '2010ALIC01', pos: 2 }),
+      apiResult({ name: 'Dana Solver', wca_id: '2010DANA01', pos: 1 }),
+    ];
+    const results = linkedSourceResults(competition, api);
+    expect(advancingPersonIds(results)).toEqual([1, 4]);
+    expect(results.every(({ advancingQuestionable }) => !advancingQuestionable)).toBe(true);
+  });
+
+  it('does not restore API-only target participants when WCIF provides a newer roster', () => {
+    const competition = singleSourceCompetition();
+    competition.events[0].rounds[1].results = [blankResult(1)];
+    const results = linkedSourceResults(competition, [apiResult()]);
+    expect(advancingPersonIds(results)).toEqual([1]);
+    expect(results.find(({ personId }) => personId === 2)?.advancing).toBe(false);
+  });
+
+  it('does not mistake a group assignment in the target round for an actual participant', () => {
+    const competition = singleSourceCompetition();
+    const group = competition.schedule.venues[0].rooms[0].activities[0].childActivities![0];
+    group.activityCode = '333-r2-g1';
+    const results = linkedSourceResults(competition, []);
+    expect(advancingPersonIds(results)).toEqual([1, 2, 3, 4, 5, 6]);
+  });
+
+  it('matches actual target API participants by stable WCA ID without creating WCIF identities', () => {
+    const competition = singleSourceCompetition();
+    const api = [
+      apiResult({
+        id: 9111,
+        round_type_id: '1',
+        name: 'External Person',
+        wca_id: '2010ELSE01',
+        pos: 9,
+      }),
+      apiResult({
+        id: 9222,
+        round_type_id: '2',
+        name: 'Different Published Name',
+        wca_id: '2010ELSE01',
+        pos: 1,
+      }),
+    ];
+    const results = linkedSourceResults(competition, api);
+    expect(results.filter(({ advancing }) => advancing)).toEqual([
+      expect.objectContaining({
+        id: 9111,
+        personId: null,
+        wcaId: '2010ELSE01',
+        advancing: true,
+        advancingQuestionable: false,
+      }),
+    ]);
+  });
+
+  it('does not treat an unresolved target identity as proof that known qualifiers were excluded', () => {
+    const competition = singleSourceCompetition();
+    const results = linkedSourceResults(competition, [
+      apiResult({ id: 9222, round_type_id: '2', wca_id: null, name: 'Unresolved Name' }),
+    ]);
+    expect(advancingPersonIds(results)).toEqual([1, 2, 3, 4, 5, 6]);
+    expect(
+      results
+        .filter(({ advancing }) => advancing)
+        .every(({ advancingQuestionable }) => advancingQuestionable),
+    ).toBe(true);
+  });
+
+  it('settles known target matches while leaving other eligible rows provisional if target identity is incomplete', () => {
+    const competition = singleSourceCompetition();
+    const results = linkedSourceResults(competition, [
+      apiResult({ id: 9222, round_type_id: '2', wca_id: null, name: 'Unresolved Name' }),
+      apiResult({ id: 9333, round_type_id: '2', wca_id: '2010ALIC01', name: 'Alice Solver' }),
+    ]);
+    expect(advancingPersonIds(results)).toEqual([1, 2, 3, 4, 5, 6]);
+    expect(results[0]).toMatchObject({ advancing: true, advancingQuestionable: false });
+    expect(results[1]).toMatchObject({ advancing: true, advancingQuestionable: true });
+  });
+
+  it('never treats a linked source row as evidence of target participation', () => {
+    const competition = singleSourceCompetition();
+    const rounds = competition.events[0].rounds;
+    rounds[1].linkedRounds = ['333-r1', '333-r2'];
+    rounds[1].results = [blankResult(8)];
+    expect(advancingPersonIds(linkedSourceResults(competition, []))).toEqual([8]);
+  });
+
+  it('uses known actual target participation even when linked source identity cannot be resolved', () => {
+    const competition = linkedCompetition();
+    competition.events[0].rounds[2].results = [blankResult(2)];
+    const results = linkedSourceResults(competition, [
+      apiResult({ name: 'Unresolved Person', wca_id: null }),
+    ]);
+    expect(advancingPersonIds(results)).toEqual([2]);
+    expect(results.find(({ personId }) => personId === 2)).toMatchObject({
+      advancingQuestionable: false,
+    });
+  });
+
+  it('keeps each component value while using the shared target participation set', () => {
+    const competition = linkedCompetition();
+    const rounds = competition.events[0].rounds;
+    rounds[1].results = [{ ...rounds[0].results[0], best: 800, average: 900 }];
+    rounds[2].results = [blankResult(1)];
+    expect(linkedSourceResults(competition, [])[0]).toMatchObject({
+      best: 1500,
+      average: 1500,
+      advancing: true,
+      advancingQuestionable: false,
+    });
+    expect(linkedSourceResults(competition, [], 1)[0]).toMatchObject({
+      best: 800,
+      average: 900,
+      advancing: true,
+      advancingQuestionable: false,
+    });
+  });
+
+  it('lets a blank selected Live row clear stale WCIF scores and qualifying flags', () => {
+    const competition = singleSourceCompetition();
+    const results = linkedSourceResults(
+      competition,
+      [],
+      0,
+      liveRound([
+        liveRoundResult({
+          person: { id: '1', registrantId: 1, name: 'Alice Solver' },
+          ranking: null,
+          best: 0,
+          average: 0,
+          attempts: [],
+          advancing: false,
+          advancingQuestionable: false,
+        }),
+      ]),
+    );
+    expect(results.find(({ personId }) => personId === 1)).toMatchObject({
+      ranking: null,
+      best: 0,
+      average: 0,
+      attempts: [],
+      advancing: false,
+      advancingQuestionable: false,
+    });
+  });
+
+  it('keeps selected Live flags authoritative over an actual stored target roster', () => {
+    const competition = singleSourceCompetition();
+    competition.events[0].rounds[1].results = [blankResult(1)];
+    const results = linkedSourceResults(
+      competition,
+      [],
+      0,
+      liveRound([
+        liveRoundResult({
+          person: { id: '1', registrantId: 1, name: 'Alice Solver' },
+          advancing: false,
+          advancingQuestionable: false,
+        }),
+        liveRoundResult({
+          person: { id: '2', registrantId: 2, name: 'Bob Solver' },
+          advancing: true,
+          advancingQuestionable: true,
+        }),
+      ]),
+    );
+    expect(results.find(({ personId }) => personId === 1)).toMatchObject({
+      advancing: false,
+      advancingQuestionable: false,
+    });
+    expect(results.find(({ personId }) => personId === 2)).toMatchObject({
+      advancing: true,
+      advancingQuestionable: true,
+    });
+  });
+});
diff --git a/src/containers/CompetitionResults/resultsProvider.ts b/src/containers/CompetitionResults/resultsProvider.ts
index a1baddf..df5a8a0 100644
--- a/src/containers/CompetitionResults/resultsProvider.ts
+++ b/src/containers/CompetitionResults/resultsProvider.ts
@@ -7,12 +7,16 @@ import { getAdvancementConditionForRound } from '@/lib/wcif';
 import { PersonalRoundResult } from '../CompetitionPersonalResults/CompetitionPersonalResultsTable';
 import { CompetitionRoundResult } from './CompetitionResultsTable';
 import { normalizeResultRecordTag } from './ResultRecordBadge';
-import { getStoredRoundResults } from './advancement';
+import {
+  getAdvancementTargetRoundIds,
+  getFallbackAdvancement,
+  getStoredRoundResults,
+} from './advancement';
 import {
   findPersonForApiResult,
   findUniquePersonByName,
-  getApiRoundResults,
   getWcaApiResultsByRoundId,
+  toCompetitionRoundResult,
 } from './resultSources';
 import { getRoundRosterResults } from './roundRoster';
 
@@ -26,7 +30,11 @@ export interface EventResults {
 }
 
 const getResultKey = (result: CompetitionRoundResult) =>
-  result.personId == null ? `result-${result.id}` : `person-${result.personId}`;
+  result.personId != null
+    ? `person-${result.personId}`
+    : result.wcaId
+      ? `wca-${result.wcaId}`
+      : `result-${result.id}`;
 
 const mergeRoundResultSources = (
   ...sources: CompetitionRoundResult[][]
@@ -90,25 +98,25 @@ const findPersonForLiveRoundResult = (
 };
 
 const getLiveRoundResults = (wcif: Competition, wcaLiveRound: WcaLiveRound | null | undefined) =>
-  wcaLiveRound?.results
-    .filter((result) => result.attempts.length > 0)
-    .map<CompetitionRoundResult>((result) => {
-      const matchedPerson = findPersonForLiveRoundResult(wcif, result);
-
-      return {
-        id: result.id,
-        personId: matchedPerson?.registrantId ?? result.person.registrantId,
-        personName: result.person.name,
-        ranking: result.ranking,
-        advancing: result.advancing,
-        advancingQuestionable: result.advancingQuestionable,
-        attempts: result.attempts,
-        best: result.best,
-        average: result.average,
-        singleRecordTag: normalizeResultRecordTag(result.singleRecordTag),
-        averageRecordTag: normalizeResultRecordTag(result.averageRecordTag),
-      };
-    }) ?? [];
+  // Blank Live rows also supersede stale stored scores and advancement flags.
+  wcaLiveRound?.results.map<CompetitionRoundResult>((result) => {
+    const matchedPerson = findPersonForLiveRoundResult(wcif, result);
+
+    return {
+      id: result.id,
+      personId: matchedPerson?.registrantId ?? result.person.registrantId,
+      personName: result.person.name,
+      wcaId: result.person.wcaId,
+      ranking: result.ranking,
+      advancing: result.advancing,
+      advancingQuestionable: result.advancingQuestionable,
+      attempts: result.attempts,
+      best: result.best,
+      average: result.average,
+      singleRecordTag: normalizeResultRecordTag(result.singleRecordTag),
+      averageRecordTag: normalizeResultRecordTag(result.averageRecordTag),
+    };
+  }) ?? [];
 
 export const getRoundResultsFromSources = ({
   wcif,
@@ -125,22 +133,89 @@ export const getRoundResultsFromSources = ({
     return [];
   }
 
-  const liveRoundResults = getLiveRoundResults(wcif, wcaLiveRound);
-  const storedRoundResults = getStoredRoundResults(
+  const advancementCondition = getAdvancementConditionForRound(
+    selectedRound.event.rounds,
     selectedRound.round,
-    getAdvancementConditionForRound(selectedRound.event.rounds, selectedRound.round),
+  );
+  const sourceRoundIds =
+    advancementCondition?.sourceType === 'linkedRounds'
+      ? advancementCondition.sourceRoundIds
+      : [selectedRound.round.id];
+  const apiResultsByRound = getWcaApiResultsByRoundId(wcif, wcaApiResults ?? []);
+  // Apply the existing API < WCIF priority in each component before evaluating
+  // linked qualification. The selected table still shows only that component.
+  const fallbackResultsByRound = new Map(
+    selectedRound.event.rounds
+      .filter(({ id }) => id === selectedRound.round.id || sourceRoundIds.includes(id))
+      .map((round) => [
+        round.id,
+        mergeRoundResultSources(
+          (apiResultsByRound.get(round.id) ?? []).map((result) =>
+            toCompetitionRoundResult(wcif.persons, result),
+          ),
+          getStoredRoundResults(round, null),
+        ),
+      ]),
+  );
+  const sourceResults = sourceRoundIds.flatMap((id) => fallbackResultsByRound.get(id) ?? []);
+  // Without either identifier an API row cannot be deduplicated across linked
+  // components. Do not invent a person or overstate qualification in that case.
+  const hasUnresolvedLinkedIdentity =
+    advancementCondition?.sourceType === 'linkedRounds' &&
+    sourceResults.some((result) => result.personId == null && !result.wcaId);
+  // A WCIF target roster is a complete membership snapshot, so do not resurrect
+  // an API-only participant that was removed from it. Use published API results
+  // only when WCIF has no target rows. Assignments are not actual participation.
+  const targetRoundIds = getAdvancementTargetRoundIds(
     selectedRound.event.rounds,
+    advancementCondition,
   );
-  const apiRoundResults = getApiRoundResults(wcif, selectedRound.round.id, wcaApiResults);
+  const targetResults = selectedRound.event.rounds
+    .filter(({ id }) => targetRoundIds.includes(id))
+    .flatMap((round) =>
+      round.results.length > 0
+        ? getStoredRoundResults(round, null)
+        : (apiResultsByRound.get(round.id) ?? []).map((result) =>
+            toCompetitionRoundResult(wcif.persons, result),
+          ),
+    );
+  const { advancingKeys, questionableKeys } = getFallbackAdvancement(
+    selectedRound.round,
+    advancementCondition,
+    selectedRound.event.rounds
+      .filter(({ id }) => sourceRoundIds.includes(id))
+      .map((round) => ({
+        round,
+        results: (fallbackResultsByRound.get(round.id) ?? []).map((result) => ({
+          ...result,
+          key: getResultKey(result),
+        })),
+      })),
+    targetResults.map((result) => ({
+      key: getResultKey(result),
+      identityResolved: result.personId != null || Boolean(result.wcaId),
+    })),
+    !hasUnresolvedLinkedIdentity,
+  );
+  const fallbackResults = (fallbackResultsByRound.get(selectedRound.round.id) ?? []).map(
+    (result) => {
+      // Keep empty component/roster rows visually empty, even if the competitor
+      // qualifies through the other component. Live flags remain authoritative.
+      const advancing = result.ranking != null && advancingKeys.has(getResultKey(result));
+      return {
+        ...result,
+        advancing,
+        advancingQuestionable: advancing && questionableKeys.has(getResultKey(result)),
+      };
+    },
+  );
+  const liveRoundResults = getLiveRoundResults(wcif, wcaLiveRound);
 
-  if (liveRoundResults.length === 0) {
-    return mergeRoundResultSources(apiRoundResults, storedRoundResults);
-  }
+  if (liveRoundResults.length === 0) return fallbackResults;
 
   return mergeRoundResultSources(
     getRoundRosterResults(wcif, selectedRound.round.id),
-    apiRoundResults,
-    storedRoundResults,
+    fallbackResults,
     liveRoundResults,
   );
 };
diff --git a/src/containers/CompetitionRound/CompetitionRound.test.tsx b/src/containers/CompetitionRound/CompetitionRound.test.tsx
index dc0cd6e..81f9b4c 100644
--- a/src/containers/CompetitionRound/CompetitionRound.test.tsx
+++ b/src/containers/CompetitionRound/CompetitionRound.test.tsx
@@ -195,7 +195,9 @@ jest.mock('@/providers/WCIFProvider', () => ({
     setTitle: () => {},
   }),
   useWcifUtils: () => ({
-    roundActivies: linkedRoundsCompetition.schedule.venues[0].rooms[0].activities,
+    roundActivies: linkedRoundsCompetition.schedule.venues.flatMap((venue) =>
+      venue.rooms.flatMap((room) => room.activities),
+    ),
   }),
 }));
 
@@ -210,6 +212,61 @@ function renderRound(roundId: string) {
 }
 
 describe('CompetitionRoundContainer', () => {
+  it.each([
+    ['Europe/Bucharest', '2026-10-31T07:00:00Z', '2026-10-31T07:22:30Z', 'Sat 09:00 AM - 09:25 AM'],
+    ['Asia/Calcutta', '2026-10-31T03:15:00Z', '2026-10-31T03:55:00Z', 'Sat 08:45 AM - 09:25 AM'],
+  ])('shows group times in the %s venue timezone', (timezone, startTime, endTime, expected) => {
+    const venue = linkedRoundsCompetition.schedule.venues[0];
+    const group = venue.rooms[0].activities[0].childActivities[0];
+    const original = {
+      timezone: venue.timezone,
+      startTime: group.startTime,
+      endTime: group.endTime,
+    };
+    const languages = jest.spyOn(navigator, 'languages', 'get').mockReturnValue(['en-US']);
+    try {
+      venue.timezone = timezone;
+      group.startTime = startTime;
+      group.endTime = endTime;
+      renderRound('333-r2');
+      expect(screen.getByText(expected)).toBeInTheDocument();
+    } finally {
+      venue.timezone = original.timezone;
+      group.startTime = original.startTime;
+      group.endTime = original.endTime;
+      languages.mockRestore();
+    }
+  });
+
+  it('keeps separate local ranges when the same group runs in different venue timezones', () => {
+    const originalVenue = linkedRoundsCompetition.schedule.venues[0];
+    const secondVenue = {
+      ...originalVenue,
+      id: 2,
+      timezone: 'Asia/Calcutta',
+      rooms: originalVenue.rooms.map((room) => ({
+        ...room,
+        id: 2,
+        activities: room.activities.map((activity) => ({
+          ...activity,
+          id: 20,
+          childActivities: activity.childActivities.map((child) => ({ ...child, id: 21 })),
+        })),
+      })),
+    };
+    const languages = jest.spyOn(navigator, 'languages', 'get').mockReturnValue(['en-US']);
+    linkedRoundsCompetition.schedule.venues.push(secondVenue);
+    try {
+      renderRound('333-r2');
+      expect(screen.getByText('Sun 09:00 AM - 09:30 AM (America/Los_Angeles)')).toBeInTheDocument();
+      expect(screen.getByText('Sun 09:30 PM - 10:00 PM (Asia/Calcutta)')).toBeInTheDocument();
+      expect(screen.getAllByText('Group 1')).toHaveLength(1);
+    } finally {
+      linkedRoundsCompetition.schedule.venues.pop();
+      languages.mockRestore();
+    }
+  });
+
   it('shows linked-round context for rounds in a dual-round advancement set', () => {
     renderRound('333-r2');
 
@@ -265,3 +322,19 @@ describe('CompetitionRoundContainer', () => {
     }
   });
 });
+
+it.each(['333-r99', 'not-a-round', '999-r1'])(
+  'explains missing round %s without implying that it has a schedule or results',
+  (roundId) => {
+    const { rerender } = renderRound(roundId);
+    expect(screen.getByRole('status')).toHaveTextContent('competition.results.roundNotFound');
+    expect(screen.queryByText('See Results')).not.toBeInTheDocument();
+    expect(screen.getByText('Back To Events')).toHaveAttribute(
+      'href',
+      '/competitions/TestComp2026/events/',
+    );
+    rerender(<CompetitionRoundContainer competitionId="TestComp2026" roundId="333-r2" />);
+    expect(screen.queryByRole('status')).not.toBeInTheDocument();
+    expect(screen.getByText('Group 1')).toBeInTheDocument();
+  },
+);
diff --git a/src/containers/CompetitionRound/CompetitionRound.tsx b/src/containers/CompetitionRound/CompetitionRound.tsx
index 812bc53..f26d8dd 100644
--- a/src/containers/CompetitionRound/CompetitionRound.tsx
+++ b/src/containers/CompetitionRound/CompetitionRound.tsx
@@ -4,6 +4,7 @@ import { Breadcrumbs } from '@/components/Breadcrumbs/Breadcrumbs';
 import { Container } from '@/components/Container';
 import { CutoffTimeLimitPanel } from '@/components/CutoffTimeLimitPanel';
 import { LinkButton } from '@/components/LinkButton';
+import { getVenueForActivity } from '@/lib/activities';
 import {
   activityCodeToName,
   parseActivityCodeFlexible,
@@ -31,17 +32,17 @@ export function CompetitionRoundContainer({
   const { wcif, setTitle } = useWCIF();
   const { roundActivies } = useWcifUtils();
 
-  useEffect(() => {
-    setTitle(activityCodeToName(roundId));
-  }, [roundId, setTitle]);
-
   const round = useMemo(() => {
     const events = wcif && getAllEvents(wcif);
     return events?.flatMap((e) => e.rounds).find((r) => r.id === roundId);
   }, [roundId, wcif]);
+  useEffect(() => {
+    setTitle(round ? activityCodeToName(roundId) : t('competition.results.roundNotFound'));
+  }, [round, roundId, setTitle, t]);
+
   const eventRounds = useMemo(
-    () => getEventRoundsForRound(wcif?.events, roundId),
-    [roundId, wcif?.events],
+    () => (round ? getEventRoundsForRound(wcif?.events, roundId) : []),
+    [round, roundId, wcif?.events],
   );
   const linkedRoundNames = useMemo(
     () =>
@@ -53,11 +54,28 @@ export function CompetitionRoundContainer({
     [eventRounds, round, roundId, t],
   );
 
+  const findVenue = useMemo(() => (wcif ? getVenueForActivity(wcif) : undefined), [wcif]);
+
   const rounds = roundActivies.filter((ra) => toRoundAttemptId(ra.activityCode) === roundId);
   const groups = rounds.flatMap((r) => r.childActivities);
   const uniqueGroupCodes = [...new Set(groups.map((g) => g.activityCode))];
   const hasResults = (round?.results.length ?? 0) > 0;
 
+  if (!wcif) return null;
+
+  if (!round) {
+    return (
+      <Container className="p-4 space-y-4">
+        <p role="status">{t('competition.results.roundNotFound')}</p>
+        <LinkButton
+          to={`/competitions/${competitionId}/events/`}
+          title={t('competition.groups.backToEvents')}
+          LinkComponent={LinkComponent}
+        />
+      </Container>
+    );
+  }
+
   return (
     <Container>
       <div className="space-y-2 p-2 type-body">
@@ -82,8 +100,16 @@ export function CompetitionRoundContainer({
         {uniqueGroupCodes.map((value) => {
           const { groupNumber } = parseActivityCodeFlexible(value);
           const activities = groups.filter((g) => g.activityCode === value);
-          const minStartTime = activities.map((a) => a.startTime).sort()[0];
-          const maxEndTime = activities.map((a) => a.endTime).sort()[activities.length - 1];
+          const timeZones = [...new Set(activities.map((a) => findVenue?.(a)?.timezone))];
+          const timeRanges = timeZones.map((timeZone) => {
+            const venueActivities = activities.filter((a) => findVenue?.(a)?.timezone === timeZone);
+            const minStartTime = venueActivities.map((a) => a.startTime).sort()[0];
+            const maxEndTime = venueActivities
+              .map((a) => a.endTime)
+              .sort()
+              .at(-1)!;
+            return { timeZone, label: formatDateTimeRange(minStartTime, maxEndTime, 5, timeZone) };
+          });
 
           return (
             <LinkComponent
@@ -94,7 +120,12 @@ export function CompetitionRoundContainer({
                 <span className="type-heading">
                   {t('common.activityCodeToName.group', { groupNumber })}
                 </span>
-                <span className="type-meta">{formatDateTimeRange(minStartTime, maxEndTime)}</span>
+                {timeRanges.map(({ timeZone, label }) => (
+                  <span key={timeZone ?? 'local'} className="type-meta">
+                    {label}
+                    {timeRanges.length > 1 && timeZone && ` (${timeZone})`}
+                  </span>
+                ))}
               </li>
             </LinkComponent>
           );
diff --git a/src/containers/Competitors/Competitors.test.tsx b/src/containers/Competitors/Competitors.test.tsx
index 2d9b92d..eeb33e4 100644
--- a/src/containers/Competitors/Competitors.test.tsx
+++ b/src/containers/Competitors/Competitors.test.tsx
@@ -1,10 +1,13 @@
 import { fireEvent, render, screen } from '@testing-library/react';
 import { Competition, Person } from '@wca/helpers';
 import { Link, MemoryRouter, Route, Routes, useLocation, useNavigate } from 'react-router-dom';
+import { usePinnedPersons } from '@/hooks/UsePinnedPersons';
 import { Competitors } from './Competitors';
 
 jest.mock('react-i18next', () => ({ useTranslation: () => ({ t: (key: string) => key }) }));
-jest.mock('@/hooks/UsePinnedPersons', () => ({ usePinnedPersons: () => ({ pinnedPersons: [] }) }));
+jest.mock('@/hooks/UsePinnedPersons', () => ({
+  usePinnedPersons: jest.fn(() => ({ pinnedPersons: [] })),
+}));
 jest.mock('@/hooks/useOngoingActivities', () => ({
   useOngoingActivities: () => ({ ongoingActivities: [] }),
 }));
@@ -96,3 +99,20 @@ it('renders no unpinned competitors for a search with no match', () => {
   renderCompetition('/competitions/Test2026?search=unknown');
   expect(screen.queryAllByRole('link')).toHaveLength(0);
 });
+
+it('announces no matches and removes the message when the search is cleared', () => {
+  renderCompetition('/competitions/Test2026?search=unknown');
+  expect(screen.getByText('competition.competitors.noMatches')).toHaveAttribute('role', 'status');
+  fireEvent.change(screen.getByRole('searchbox'), { target: { value: '' } });
+  expect(screen.queryByText('competition.competitors.noMatches')).not.toBeInTheDocument();
+  expect(screen.getAllByRole('link')).toHaveLength(2);
+});
+
+it('does not claim there are no matches when a matching competitor is pinned above the search', () => {
+  jest
+    .mocked(usePinnedPersons)
+    .mockReturnValueOnce({ pinnedPersons: [2] } as ReturnType<typeof usePinnedPersons>);
+  renderCompetition('/competitions/Test2026?search=Tin');
+  expect(screen.getByRole('link', { name: 'Tin Huang' })).toBeInTheDocument();
+  expect(screen.queryByText('competition.competitors.noMatches')).not.toBeInTheDocument();
+});
diff --git a/src/containers/Competitors/Competitors.tsx b/src/containers/Competitors/Competitors.tsx
index 1dac564..94d2f1f 100644
--- a/src/containers/Competitors/Competitors.tsx
+++ b/src/containers/Competitors/Competitors.tsx
@@ -61,6 +61,10 @@ export const Competitors = ({ wcif }: { wcif: Competition }) => {
       !person.pinned && (!input || person.name.toLowerCase().includes(input.toLowerCase().trim())),
   );
 
+  const hasMatchingPerson = acceptedPersons.some((person) =>
+    person.name.toLowerCase().includes(input.toLowerCase().trim()),
+  );
+
   return (
     <div className="space-y-2">
       {me && (
@@ -90,7 +94,13 @@ export const Competitors = ({ wcif }: { wcif: Competition }) => {
         </div>
       </div>
 
-      <CompetitorList persons={acceptedUnpinnedPersons} />
+      {input.trim() && !hasMatchingPerson ? (
+        <p role="status" className="p-2 text-muted">
+          {t('competition.competitors.noMatches')}
+        </p>
+      ) : (
+        <CompetitorList persons={acceptedUnpinnedPersons} />
+      )}
     </div>
   );
 };
diff --git a/src/containers/PersonalSchedule/Assignments.test.tsx b/src/containers/PersonalSchedule/Assignments.test.tsx
new file mode 100644
index 0000000..4b6cc56
--- /dev/null
+++ b/src/containers/PersonalSchedule/Assignments.test.tsx
@@ -0,0 +1,135 @@
+import { act, render, screen } from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
+import { Person } from '@wca/helpers';
+import { PersonalScheduleContent } from './PersonalSchedule';
+import { getGroupedAssignmentsByDate } from './utils';
+
+jest.mock('react-i18next', () => ({ useTranslation: () => ({ t: (key: string) => key }) }));
+jest.mock('@/components', () => ({ DisclaimerText: () => null }));
+jest.mock('@/providers/WCIFProvider', () => ({ useWCIF: () => ({ wcif: { id: 'Test' } }) }));
+jest.mock('@/hooks/useNow/useNow', () => ({ useNow: () => 0 }));
+jest.mock('@/lib/events', () => ({ isOfficialEventId: jest.fn() }));
+jest.mock('@/lib/activityCodes', () => ({ parseActivityCodeFlexible: jest.fn() }));
+jest.mock('@/lib/activities', () => ({ hasMultipleScheduleLocations: () => false }));
+jest.mock('./utils', () => ({
+  getGroupedAssignmentsByDate: jest.fn(() => [
+    { date: 'Saturday', dateParts: [], assignments: [] },
+    { date: 'Sunday', dateParts: [], assignments: [] },
+  ]),
+}));
+jest.mock('./PersonalExtraAssignment', () => ({ ExtraAssignment: () => null }));
+jest.mock('./PersonalNormalAssignment', () => ({ PersonalNormalAssignment: () => null }));
+jest.mock('./PersonalPageLayout', () => ({ PersonalPageLayout: () => null }));
+
+const person = { registrantId: 1, assignments: [{ activityId: 1 }] } as Person;
+beforeEach(() => {
+  localStorage.clear();
+  jest
+    .mocked(getGroupedAssignmentsByDate)
+    .mockReset()
+    .mockReturnValue([
+      { date: 'Saturday', dateParts: [], assignments: [] },
+      { date: 'Sunday', dateParts: [], assignments: [] },
+    ] as unknown as ReturnType<typeof getGroupedAssignmentsByDate>);
+});
+
+it('makes personal schedule days operable by keyboard with a stable focused button', async () => {
+  render(<PersonalScheduleContent person={person} />);
+  const saturday = screen.getByRole('button', { name: 'Saturday' });
+  expect(saturday).toHaveAttribute('aria-expanded', 'true');
+  await act(() => userEvent.tab());
+  expect(saturday).toHaveFocus();
+  await act(() => userEvent.keyboard('{Enter}'));
+  expect(saturday).toHaveAttribute('aria-expanded', 'false');
+  await act(() => userEvent.keyboard(' '));
+  expect(saturday).toHaveAttribute('aria-expanded', 'true');
+  expect(saturday).toHaveFocus();
+});
+
+it('does not carry a collapsed day into a different person on repeated navigation', async () => {
+  const { rerender } = render(<PersonalScheduleContent person={person} />);
+  await act(() => userEvent.click(screen.getByText('Saturday')));
+  rerender(<PersonalScheduleContent person={{ ...person, registrantId: 2 }} />);
+  expect(screen.getByRole('button', { name: 'Saturday' })).toHaveAttribute('aria-expanded', 'true');
+  rerender(<PersonalScheduleContent person={person} />);
+  expect(screen.getByRole('button', { name: 'Saturday' })).toHaveAttribute(
+    'aria-expanded',
+    'false',
+  );
+});
+
+const historicalAssignments = ['Saturday', 'Sunday'].map((date, index) => ({
+  date,
+  dateParts: [],
+  approxDateTime: index,
+  assignments: [
+    {
+      date,
+      activity: { id: index + 1, endTime: '2020-01-01T12:00:00Z' },
+      assignment: { activityId: index + 1 },
+    },
+  ],
+})) as unknown as ReturnType<typeof getGroupedAssignmentsByDate>;
+
+it.each([[[]], [['Saturday']], [['Sunday']]])(
+  'respects saved personal historical day choices %j',
+  (collapsed) => {
+    jest.mocked(getGroupedAssignmentsByDate).mockReturnValue(historicalAssignments);
+    localStorage.setItem(
+      'collapse',
+      JSON.stringify({ 'Test-1': collapsed, 'Test-2': ['Saturday'] }),
+    );
+    render(<PersonalScheduleContent person={person} />);
+    for (const { date } of historicalAssignments) {
+      expect(screen.getByRole('button', { name: date })).toHaveAttribute(
+        'aria-expanded',
+        String(!collapsed.includes(date)),
+      );
+    }
+    expect(JSON.parse(localStorage.getItem('collapse')!)).toEqual({
+      'Test-1': collapsed,
+      'Test-2': ['Saturday'],
+    });
+  },
+);
+
+it.each([false, true])(
+  'retains personal historical keyboard choices across reload (mixed: %s)',
+  async (mixed) => {
+    jest.mocked(getGroupedAssignmentsByDate).mockReturnValue(historicalAssignments);
+    const { unmount } = render(<PersonalScheduleContent person={person} />);
+    expect(screen.getByRole('button', { name: 'Saturday' })).toHaveAttribute(
+      'aria-expanded',
+      'false',
+    );
+    expect(screen.getByRole('button', { name: 'Sunday' })).toHaveAttribute(
+      'aria-expanded',
+      'false',
+    );
+    await act(() => userEvent.tab());
+    await act(() => userEvent.keyboard('{Enter}'));
+    await act(() => userEvent.tab());
+    await act(() => userEvent.keyboard(' '));
+    if (mixed) {
+      await act(() => userEvent.tab({ shift: true }));
+      await act(() => userEvent.keyboard('{Enter}'));
+    }
+    unmount();
+    const { rerender } = render(<PersonalScheduleContent person={person} />);
+    expect(screen.getByRole('button', { name: 'Saturday' })).toHaveAttribute(
+      'aria-expanded',
+      String(!mixed),
+    );
+    expect(screen.getByRole('button', { name: 'Sunday' })).toHaveAttribute('aria-expanded', 'true');
+    rerender(<PersonalScheduleContent person={{ ...person, registrantId: 2 }} />);
+    expect(screen.getByRole('button', { name: 'Sunday' })).toHaveAttribute(
+      'aria-expanded',
+      'false',
+    );
+    rerender(<PersonalScheduleContent person={person} />);
+    expect(screen.getByRole('button', { name: 'Sunday' })).toHaveAttribute('aria-expanded', 'true');
+    expect(JSON.parse(localStorage.getItem('collapse')!)).toEqual({
+      'Test-1': mixed ? ['Saturday'] : [],
+    });
+  },
+);
diff --git a/src/containers/PersonalSchedule/Assignments.tsx b/src/containers/PersonalSchedule/Assignments.tsx
index 2068e9b..aa25806 100644
--- a/src/containers/PersonalSchedule/Assignments.tsx
+++ b/src/containers/PersonalSchedule/Assignments.tsx
@@ -1,5 +1,5 @@
 import { Competition, Person } from '@wca/helpers';
-import { Fragment, useEffect, useMemo } from 'react';
+import { Fragment, useMemo } from 'react';
 import { useTranslation } from 'react-i18next';
 import { useCollapse } from '@/hooks/UseCollapse';
 import { useNow } from '@/hooks/useNow/useNow';
@@ -24,37 +24,23 @@ export function Assignments({ wcif, person, showStationNumber }: AssignmentsProp
 
   const showRoom = useMemo(() => hasMultipleScheduleLocations(wcif), [wcif]);
 
-  const { collapsedDates, setCollapsedDates, toggleDate } = useCollapse(
-    key(wcif.id, person.registrantId),
-  );
-
   const now = useNow(15 * 1000);
 
   const scheduleDays = useMemo(() => getGroupedAssignmentsByDate(wcif, person), [person, wcif]);
 
-  useEffect(() => {
-    const today = new Date().getTime();
-
-    const collapse: string[] = [];
-    scheduleDays.forEach(({ date, assignments }) => {
-      const lastActivity = [...assignments].reverse().find((a) => a.activity)?.activity;
-      if (!lastActivity) {
-        return;
-      }
-
-      const lastActivityEndTime = new Date(lastActivity.endTime);
-      // Collapse days that are more than 4 hours old.
-      if (
-        today - lastActivityEndTime.getTime() > 1000 * 60 * 60 * 4 &&
-        !collapsedDates.includes(date)
-      ) {
-        collapse.push(date);
-      }
-    });
-
-    setCollapsedDates((prev) => [...prev, ...collapse]);
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-  }, [scheduleDays]);
+  const { collapsedDates, toggleDate } = useCollapse(key(wcif.id, person.registrantId), () => {
+    const today = Date.now();
+
+    return scheduleDays
+      .filter(({ assignments }) => {
+        const lastActivity = [...assignments].reverse().find((a) => a.activity)?.activity;
+        if (!lastActivity) return false;
+
+        // Collapse days that are more than 4 hours old only as an initial default.
+        return today - new Date(lastActivity.endTime).getTime() > 1000 * 60 * 60 * 4;
+      })
+      .map(({ date }) => date);
+  });
 
   const isSingleDay = scheduleDays.length === 1;
 
@@ -95,14 +81,20 @@ export function Assignments({ wcif, person, showStationNumber }: AssignmentsProp
               return (
                 <Fragment key={date}>
                   {!isSingleDay && (
-                    <tr onClick={() => toggleDate(date)} className="table-row-hover-bg">
-                      <td colSpan={6} className="table-row-group-header cursor-pointer select-none">
-                        <div className="flex justify-between">
+                    <tr className="table-row-hover-bg">
+                      <td colSpan={6} className="table-row-group-header select-none">
+                        <button
+                          type="button"
+                          aria-expanded={!collapsed}
+                          onClick={() => toggleDate(date)}
+                          className="flex w-full justify-between focus-visible:outline focus-visible:outline-2 focus-visible:outline-blue-500">
                           <span className="w-full p-2 text-center">
                             {dateParts.find((i) => i.type === 'weekday')?.value || date}
                           </span>
-                          <span className="p-2 flex-end">{collapsed ? ' ▼' : ' ▲'}</span>
-                        </div>
+                          <span className="p-2 flex-end" aria-hidden="true">
+                            {collapsed ? ' ▼' : ' ▲'}
+                          </span>
+                        </button>
                       </td>
                     </tr>
                   )}
diff --git a/src/containers/PersonalSchedule/PersonHeader.test.tsx b/src/containers/PersonalSchedule/PersonHeader.test.tsx
new file mode 100644
index 0000000..ddf738a
--- /dev/null
+++ b/src/containers/PersonalSchedule/PersonHeader.test.tsx
@@ -0,0 +1,110 @@
+import { act, render, screen } from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
+import { Person } from '@wca/helpers';
+import { readFileSync } from 'fs';
+import { createInstance } from 'i18next';
+import { load } from 'js-yaml';
+import { I18nextProvider, initReactI18next } from 'react-i18next';
+import { PersonHeader } from './PersonHeader';
+
+const competitionId = 'TestCompetition2026';
+const person = {
+  name: 'Test Competitor',
+  registrantId: 5,
+  countryIso2: 'FR',
+  roles: [],
+} as unknown as Person;
+const i18n = createInstance();
+
+jest.mock('@/providers/WCIFProvider', () => ({
+  useWCIF: () => ({ competitionId: 'TestCompetition2026' }),
+}));
+
+beforeAll(async () => {
+  await i18n.use(initReactI18next).init({
+    lng: 'en',
+    fallbackLng: 'en',
+    resources: {
+      en: { translation: load(readFileSync('src/i18n/en/translation.yaml', 'utf8')) as object },
+    },
+  });
+});
+
+beforeEach(() => {
+  localStorage.clear();
+});
+
+const header = (competitor = person) => (
+  <I18nextProvider i18n={i18n}>
+    <PersonHeader competitionId={competitionId} person={competitor} />
+  </I18nextProvider>
+);
+
+it('renders a translated, unpressed bookmark button with a decorative icon', () => {
+  render(header());
+
+  const button = screen.getByRole('button', { name: 'Bookmark competitor', pressed: false });
+  expect(button).toBeEnabled();
+  expect(button.querySelector('.fa-bookmark')).toHaveAttribute('aria-hidden', 'true');
+});
+
+it('persists keyboard bookmark changes across remounts without changing another competition', async () => {
+  localStorage.setItem('pinnedPersons', JSON.stringify({ OtherCompetition2026: [5] }));
+  const { unmount } = render(header());
+
+  await act(() => userEvent.tab());
+  expect(screen.getByRole('button', { name: 'Bookmark competitor', pressed: false })).toHaveFocus();
+  await act(() => userEvent.keyboard('{Enter}'));
+  expect(
+    screen.getByRole('button', { name: 'Remove competitor bookmark', pressed: true }),
+  ).toHaveFocus();
+  expect(JSON.parse(localStorage.getItem('pinnedPersons')!)).toEqual({
+    OtherCompetition2026: [5],
+    [competitionId]: [5],
+  });
+
+  unmount();
+  const { unmount: unmountPinned } = render(header());
+  expect(
+    screen.getByRole('button', { name: 'Remove competitor bookmark', pressed: true }),
+  ).toBeEnabled();
+  await act(() => userEvent.tab());
+  await act(() => userEvent.keyboard(' '));
+  expect(screen.getByRole('button', { name: 'Bookmark competitor', pressed: false })).toHaveFocus();
+  expect(JSON.parse(localStorage.getItem('pinnedPersons')!)).toEqual({
+    OtherCompetition2026: [5],
+    [competitionId]: [],
+  });
+
+  unmountPinned();
+  render(header());
+  expect(screen.getByRole('button', { name: 'Bookmark competitor', pressed: false })).toBeEnabled();
+});
+
+it('reads the correct pressed state when navigating between competitors', () => {
+  localStorage.setItem('pinnedPersons', JSON.stringify({ [competitionId]: [5] }));
+  const { rerender } = render(header());
+  expect(
+    screen.getByRole('button', { name: 'Remove competitor bookmark', pressed: true }),
+  ).toBeEnabled();
+
+  rerender(header({ ...person, registrantId: 6 }));
+  expect(screen.getByRole('button', { name: 'Bookmark competitor', pressed: false })).toBeEnabled();
+
+  rerender(header());
+  expect(
+    screen.getByRole('button', { name: 'Remove competitor bookmark', pressed: true }),
+  ).toBeEnabled();
+  expect(JSON.parse(localStorage.getItem('pinnedPersons')!)).toEqual({ [competitionId]: [5] });
+});
+
+it('keeps a competitor without a registrant ID named, unpressed, and disabled', async () => {
+  const saved = { [competitionId]: [5] };
+  localStorage.setItem('pinnedPersons', JSON.stringify(saved));
+  render(header({ ...person, registrantId: null } as unknown as Person));
+  const button = screen.getByRole('button', { name: 'Bookmark competitor', pressed: false });
+  expect(button).toBeDisabled();
+
+  await act(() => userEvent.click(button));
+  expect(JSON.parse(localStorage.getItem('pinnedPersons')!)).toEqual(saved);
+});
diff --git a/src/containers/PersonalSchedule/PersonHeader.tsx b/src/containers/PersonalSchedule/PersonHeader.tsx
index 44b59a6..504fb68 100644
--- a/src/containers/PersonalSchedule/PersonHeader.tsx
+++ b/src/containers/PersonalSchedule/PersonHeader.tsx
@@ -60,6 +60,10 @@ export const PersonHeader: React.FC<PersonHeaderProps> = ({ person }) => {
             <Button
               variant="blue"
               className="min-h-10"
+              aria-label={t(
+                isPinned ? 'common.removeCompetitorBookmark' : 'common.bookmarkCompetitor',
+              )}
+              aria-pressed={isPinned}
               disabled={person.registrantId == null}
               onClick={() => {
                 if (person.registrantId == null) return;
@@ -99,5 +103,8 @@ export const PersonHeader: React.FC<PersonHeaderProps> = ({ person }) => {
 };
 
 const PinIcon = ({ pinned }: { pinned: boolean }) => (
-  <span className={pinned ? 'fa fa-bookmark text-yellow-500' : 'fa-regular fa-bookmark'} />
+  <span
+    className={pinned ? 'fa fa-bookmark text-yellow-500' : 'fa-regular fa-bookmark'}
+    aria-hidden="true"
+  />
 );
diff --git a/src/containers/PersonalSchedule/PersonalSchedule.tsx b/src/containers/PersonalSchedule/PersonalSchedule.tsx
index 9fdcbf1..d7da249 100644
--- a/src/containers/PersonalSchedule/PersonalSchedule.tsx
+++ b/src/containers/PersonalSchedule/PersonalSchedule.tsx
@@ -24,6 +24,7 @@ export function PersonalScheduleContent({ person }: PersonalScheduleContainerPro
         <>
           {person.assignments && person.assignments.length > 0 ? (
             <Assignments
+              key={`${wcif.id}-${person.registrantId}`}
               wcif={wcif}
               person={person}
               showStationNumber={anyAssignmentsHasStationNumber}
diff --git a/src/containers/Schedule/Schedule.test.tsx b/src/containers/Schedule/Schedule.test.tsx
new file mode 100644
index 0000000..6057872
--- /dev/null
+++ b/src/containers/Schedule/Schedule.test.tsx
@@ -0,0 +1,175 @@
+import { act, render, screen } from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
+import { Competition } from '@wca/helpers';
+import { getScheduledDays } from '@/lib/activities';
+import { ScheduleContainer } from './Schedule';
+
+jest.mock('@/lib/activities', () => ({
+  getScheduledDays: jest.fn(() => [
+    { date: 'Saturday, 1/1/2030', activities: [{ id: 1, endTime: '2030-01-01T12:00:00Z' }] },
+  ]),
+  hasMultipleScheduleLocations: () => false,
+}));
+jest.mock('./scheduleActivityGroups', () => ({ getScheduleActivityGroups: () => [{ id: '1' }] }));
+jest.mock('./ScheduleActivityRow', () => ({
+  ScheduleActivityRow: () => <div>Day activities</div>,
+}));
+const wcif = { id: 'One2026' } as Competition;
+beforeEach(() => {
+  localStorage.clear();
+  jest
+    .mocked(getScheduledDays)
+    .mockReset()
+    .mockReturnValue([
+      { date: 'Saturday, 1/1/2030', activities: [{ id: 1, endTime: '2030-01-01T12:00:00Z' }] },
+    ] as ReturnType<typeof getScheduledDays>);
+});
+
+it('toggles with Enter and Space, preserves focus, and exposes the controlled day', async () => {
+  render(<ScheduleContainer wcif={wcif} />);
+  const toggle = screen.getByRole('button', { name: 'Saturday, 1/1/2030' });
+  expect(toggle).toHaveAttribute('aria-expanded', 'true');
+  expect(document.getElementById(toggle.getAttribute('aria-controls')!)).toContainElement(
+    screen.getByText('Day activities'),
+  );
+  await act(() => userEvent.tab());
+  expect(toggle).toHaveFocus();
+  await act(() => userEvent.keyboard('{Enter}'));
+  expect(toggle).toHaveAttribute('aria-expanded', 'false');
+  expect(screen.queryByText('Day activities')).not.toBeInTheDocument();
+  expect(toggle).toHaveFocus();
+  await act(() => userEvent.keyboard(' '));
+  expect(toggle).toHaveAttribute('aria-expanded', 'true');
+  expect(screen.getByText('Day activities')).toBeInTheDocument();
+  expect(toggle).toHaveFocus();
+});
+
+it('restores a saved collapse state without carrying it into another competition on the same date', async () => {
+  const { rerender } = render(<ScheduleContainer wcif={wcif} />);
+  await act(() => userEvent.click(screen.getByText('Saturday, 1/1/2030')));
+  expect(screen.queryByText('Day activities')).not.toBeInTheDocument();
+  rerender(<ScheduleContainer wcif={{ ...wcif, id: 'Other2026' }} />);
+  expect(screen.getByText('Day activities')).toBeInTheDocument();
+  rerender(<ScheduleContainer wcif={wcif} />);
+  expect(screen.queryByText('Day activities')).not.toBeInTheDocument();
+});
+
+it('persists toggles for multiple days rather than overwriting the previous day', async () => {
+  const mockDays = jest.mocked(getScheduledDays);
+  const days = mockDays(wcif);
+  mockDays.mockReturnValueOnce([...days, { ...days[0], date: 'Sunday, 1/2/2030' }]);
+  const { unmount } = render(<ScheduleContainer wcif={wcif} />);
+  await act(() => userEvent.click(screen.getByText('Saturday, 1/1/2030')));
+  await act(() => userEvent.click(screen.getByText('Sunday, 1/2/2030')));
+  const saved = JSON.parse(localStorage.getItem('collapse')!) as Record<string, string[]>;
+  expect(saved['One2026-schedule']).toEqual(['Saturday, 1/1/2030', 'Sunday, 1/2/2030']);
+  unmount();
+  mockDays.mockReturnValueOnce([...days, { ...days[0], date: 'Sunday, 1/2/2030' }]);
+  render(<ScheduleContainer wcif={wcif} />);
+  expect(screen.getAllByRole('button')).toHaveLength(2);
+  screen
+    .getAllByRole('button')
+    .forEach((button) => expect(button).toHaveAttribute('aria-expanded', 'false'));
+});
+
+it('automatically collapses past days, lets the user reopen them, and keeps later days expanded', async () => {
+  const mockDays = jest.mocked(getScheduledDays);
+  const days = mockDays(wcif);
+  mockDays.mockReturnValueOnce([
+    {
+      ...days[0],
+      date: 'Past day',
+      activities: [{ ...days[0].activities[0], endTime: '2020-01-01T12:00:00Z' }],
+    },
+    { ...days[0], date: 'Future day' },
+  ]);
+  try {
+    render(<ScheduleContainer wcif={wcif} />);
+    const pastDay = screen.getByRole('button', { name: 'Past day' });
+    expect(pastDay).toHaveAttribute('aria-expanded', 'false');
+    expect(screen.getByRole('button', { name: 'Future day' })).toHaveAttribute(
+      'aria-expanded',
+      'true',
+    );
+    await act(() => userEvent.click(pastDay));
+    expect(pastDay).toHaveAttribute('aria-expanded', 'true');
+    expect(pastDay).toHaveFocus();
+  } finally {
+    jest.restoreAllMocks();
+  }
+});
+
+const historicalDays = ['Saturday', 'Sunday'].map((date, index) => ({
+  date,
+  activities: [{ id: index + 1, endTime: '2020-01-01T12:00:00Z' }],
+})) as ReturnType<typeof getScheduledDays>;
+
+it.each([[[]], [['Saturday']], [['Sunday']]])(
+  'gives saved historical day choices %j precedence over automatic collapse',
+  (collapsed) => {
+    jest.mocked(getScheduledDays).mockReturnValue(historicalDays);
+    localStorage.setItem(
+      'collapse',
+      JSON.stringify({ 'One2026-schedule': collapsed, other: ['Unrelated'] }),
+    );
+    render(<ScheduleContainer wcif={wcif} />);
+    for (const { date } of historicalDays) {
+      expect(screen.getByRole('button', { name: date })).toHaveAttribute(
+        'aria-expanded',
+        String(!collapsed.includes(date)),
+      );
+    }
+    expect(JSON.parse(localStorage.getItem('collapse')!)).toEqual({
+      'One2026-schedule': collapsed,
+      other: ['Unrelated'],
+    });
+  },
+);
+
+it.each([false, true])(
+  'retains historical keyboard choices across reload (mixed: %s)',
+  async (mixed) => {
+    jest.mocked(getScheduledDays).mockReturnValue(historicalDays);
+    localStorage.setItem('collapse', JSON.stringify({ other: ['Unrelated'] }));
+    const { unmount } = render(<ScheduleContainer wcif={wcif} />);
+    const saturday = screen.getByRole('button', { name: 'Saturday' });
+    const sunday = screen.getByRole('button', { name: 'Sunday' });
+    expect(saturday).toHaveAttribute('aria-expanded', 'false');
+    expect(sunday).toHaveAttribute('aria-expanded', 'false');
+    await act(() => userEvent.tab());
+    await act(() => userEvent.keyboard('{Enter}'));
+    await act(() => userEvent.tab());
+    await act(() => userEvent.keyboard(' '));
+    if (mixed) {
+      await act(() => userEvent.tab({ shift: true }));
+      await act(() => userEvent.keyboard('{Enter}'));
+    }
+    expect(saturday).toHaveAttribute('aria-expanded', String(!mixed));
+    expect(sunday).toHaveAttribute('aria-expanded', 'true');
+    unmount();
+    const { rerender } = render(<ScheduleContainer wcif={wcif} />);
+    expect(screen.getByRole('button', { name: 'Saturday' })).toHaveAttribute(
+      'aria-expanded',
+      String(!mixed),
+    );
+    expect(screen.getByRole('button', { name: 'Sunday' })).toHaveAttribute('aria-expanded', 'true');
+    // Receiving refreshed schedule data must not reset an explicit choice either.
+    rerender(<ScheduleContainer wcif={{ ...wcif }} />);
+    expect(screen.getByRole('button', { name: 'Sunday' })).toHaveAttribute('aria-expanded', 'true');
+    rerender(<ScheduleContainer wcif={{ ...wcif, id: 'Other2026' }} />);
+    expect(screen.getByRole('button', { name: 'Sunday' })).toHaveAttribute(
+      'aria-expanded',
+      'false',
+    );
+    rerender(<ScheduleContainer wcif={wcif} />);
+    expect(screen.getByRole('button', { name: 'Saturday' })).toHaveAttribute(
+      'aria-expanded',
+      String(!mixed),
+    );
+    expect(screen.getByRole('button', { name: 'Sunday' })).toHaveAttribute('aria-expanded', 'true');
+    expect(JSON.parse(localStorage.getItem('collapse')!)).toEqual({
+      other: ['Unrelated'],
+      'One2026-schedule': mixed ? ['Saturday'] : [],
+    });
+  },
+);
diff --git a/src/containers/Schedule/Schedule.tsx b/src/containers/Schedule/Schedule.tsx
index 40006ba..5d8e4ae 100644
--- a/src/containers/Schedule/Schedule.tsx
+++ b/src/containers/Schedule/Schedule.tsx
@@ -1,5 +1,5 @@
 import { Competition } from '@wca/helpers';
-import { useCallback, useEffect, useMemo } from 'react';
+import { useId, useMemo } from 'react';
 import { useCollapse } from '@/hooks/UseCollapse';
 import { getScheduledDays, hasMultipleScheduleLocations } from '@/lib/activities';
 import { LinkRenderer } from '@/lib/linkRenderer';
@@ -14,34 +14,39 @@ const ScheduleDay = ({
   date,
   activities,
   showRoom,
+  collapsed,
+  onToggle,
   LinkComponent,
 }: {
-  wcif;
+  wcif: Competition;
   date: string;
   activities: ActivityWithRoomOrParent[];
   showRoom: boolean;
+  collapsed: boolean;
+  onToggle: () => void;
   LinkComponent?: LinkRenderer;
 }) => {
-  const { collapsedDates, toggleDate } = useCollapse(key(wcif.id));
   const activityGroups = useMemo(
     () => getScheduleActivityGroups(wcif, activities),
     [activities, wcif],
   );
 
-  const collapsed = collapsedDates.includes(date);
-  const toggleCollapsed = useCallback(() => {
-    toggleDate(date);
-  }, [date, toggleDate]);
+  const activitiesId = useId();
 
   return (
     <div className="flex flex-col">
-      <div
-        className="w-full text-center bg-gray-50 dark:bg-gray-800 hover:bg-gray-100 dark:hover:bg-gray-700 text-default font-bold type-heading mb-1 select-none cursor-pointer h-10 hover-transition"
-        onClick={() => toggleCollapsed()}>
+      <button
+        type="button"
+        aria-expanded={!collapsed}
+        aria-controls={activitiesId}
+        className="w-full text-center bg-gray-50 dark:bg-gray-800 hover:bg-gray-100 dark:hover:bg-gray-700 text-default font-bold type-heading mb-2 select-none cursor-pointer h-10 hover-transition focus-visible:outline focus-visible:outline-2 focus-visible:outline-blue-500"
+        onClick={onToggle}>
         <span>{date}</span>
-        <span className="p-2 flex-end">{collapsed ? ' ▼' : ' ▲'}</span>
-      </div>
-      <div className="flex flex-col">
+        <span className="p-2 flex-end" aria-hidden="true">
+          {collapsed ? ' ▼' : ' ▲'}
+        </span>
+      </button>
+      <div id={activitiesId} className="flex flex-col" hidden={collapsed}>
         {(collapsed ? [] : activityGroups).map((group) => (
           <ScheduleActivityRow
             key={group.id}
@@ -60,27 +65,28 @@ export interface ScheduleContainerProps {
   LinkComponent?: LinkRenderer;
 }
 
-export const ScheduleContainer = ({ wcif, LinkComponent }: ScheduleContainerProps) => {
-  const { collapsedDates, setCollapsedDates } = useCollapse(key(wcif.id));
+// A competition owns one collapse state for all its days. Remount it on navigation
+// so a different competition cannot inherit the previous competition's dates.
+export const ScheduleContainer = (props: ScheduleContainerProps) => (
+  <CompetitionSchedule key={props.wcif.id} {...props} />
+);
 
+const CompetitionSchedule = ({ wcif, LinkComponent }: ScheduleContainerProps) => {
   const scheduleDays = useMemo(() => getScheduledDays(wcif), [wcif]);
 
-  useEffect(() => {
-    const now = new Date().getTime();
-
-    const collapse = new Set(collapsedDates);
-    scheduleDays.forEach(({ date, activities }) => {
-      const lastActivityEndTime = Math.max(...activities.map((i) => new Date(i.endTime).getTime()));
-
-      // Collapse days that are more than 4 hours old.
-      if (now - new Date(lastActivityEndTime).getTime() > 1000 * 60 * 60 * 4) {
-        collapse.add(date);
-      }
-    });
+  const { collapsedDates, toggleDate } = useCollapse(key(wcif.id), () => {
+    const now = Date.now();
 
-    setCollapsedDates([...collapse]);
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-  }, [scheduleDays]);
+    return scheduleDays
+      .filter(({ activities }) => {
+        const lastActivityEndTime = Math.max(
+          ...activities.map((i) => new Date(i.endTime).getTime()),
+        );
+        // Collapse days that are more than 4 hours old.
+        return now - lastActivityEndTime > 1000 * 60 * 60 * 4;
+      })
+      .map(({ date }) => date);
+  });
 
   const showRoom = useMemo(() => hasMultipleScheduleLocations(wcif), [wcif]);
 
@@ -92,6 +98,8 @@ export const ScheduleContainer = ({ wcif, LinkComponent }: ScheduleContainerProp
           wcif={wcif}
           activities={activities}
           date={date}
+          collapsed={collapsedDates.includes(date)}
+          onToggle={() => toggleDate(date)}
           showRoom={showRoom}
           LinkComponent={LinkComponent}
         />
diff --git a/src/containers/Support/Support.tsx b/src/containers/Support/Support.tsx
index c5eea34..8f17383 100644
--- a/src/containers/Support/Support.tsx
+++ b/src/containers/Support/Support.tsx
@@ -7,7 +7,7 @@ export function SupportContainer() {
   }, []);
 
   return (
-    <Container className="safe-area-scroll-bottom overflow-auto">
+    <Container scrollRestorationId="page" className="safe-area-scroll-bottom overflow-auto">
       <div className="flex flex-col items-center">
         <div className="flex w-full max-w-3xl flex-col space-y-4 p-2 pt-2 type-body md:px-0 md:type-body">
           <p className="type-body">Thanks for being a user of Competition Groups!</p>
diff --git a/src/containers/UpcomingCompetitions/UpcomingCompetitions.test.tsx b/src/containers/UpcomingCompetitions/UpcomingCompetitions.test.tsx
new file mode 100644
index 0000000..9d992c3
--- /dev/null
+++ b/src/containers/UpcomingCompetitions/UpcomingCompetitions.test.tsx
@@ -0,0 +1,38 @@
+import { render, screen } from '@testing-library/react';
+import { useInfiniteCompetitions } from '@/hooks/queries/useInfiniteCompetitions';
+import UpcomingCompetitions from './UpcomingCompetitions';
+
+jest.mock('react-i18next', () => ({ useTranslation: () => ({ t: (key: string) => key }) }));
+jest.mock('react-intersection-observer', () => ({ useInView: () => ({ inView: false }) }));
+jest.mock('@/providers/AppProvider', () => ({ useApp: () => ({ online: true }) }));
+jest.mock('@/hooks/queries/useInfiniteCompetitions', () => ({
+  useInfiniteCompetitions: jest.fn(),
+}));
+jest.mock('@/queries', () => ({ useCompetitionsQuery: () => ({}) }));
+jest.mock('@/components', () => ({
+  NoteBox: () => null,
+  LastFetchedAt: ({ lastFetchedAt }: { lastFetchedAt: Date }) => (
+    <div>Fetched at {lastFetchedAt.toISOString()}</div>
+  ),
+  CompetitionListFragment: () => null,
+  Container: ({ children }: { children: React.ReactNode }) => <div>{children}</div>,
+}));
+it('omits the last-fetched timestamp until data has actually arrived and preserves it during refresh', () => {
+  Object.assign(globalThis, { __GIT_COMMIT__: 'test' });
+  const mockQuery = jest.mocked(useInfiniteCompetitions);
+  mockQuery.mockReturnValue({ dataUpdatedAt: 0, status: 'pending' } as ReturnType<
+    typeof useInfiniteCompetitions
+  >);
+  const { rerender } = render(<UpcomingCompetitions />);
+  expect(screen.queryByText(/Fetched at/)).not.toBeInTheDocument();
+  mockQuery.mockReturnValue({ dataUpdatedAt: 1793718000000, status: 'success' } as ReturnType<
+    typeof useInfiniteCompetitions
+  >);
+  rerender(<UpcomingCompetitions />);
+  expect(screen.getByText(/Fetched at 2026/)).toBeInTheDocument();
+  mockQuery.mockReturnValue({ dataUpdatedAt: 1793718000000, status: 'error' } as ReturnType<
+    typeof useInfiniteCompetitions
+  >);
+  rerender(<UpcomingCompetitions />);
+  expect(screen.getByText(/Fetched at 2026/)).toBeInTheDocument();
+});
diff --git a/src/containers/UpcomingCompetitions/UpcomingCompetitions.tsx b/src/containers/UpcomingCompetitions/UpcomingCompetitions.tsx
index f486edb..99e713a 100644
--- a/src/containers/UpcomingCompetitions/UpcomingCompetitions.tsx
+++ b/src/containers/UpcomingCompetitions/UpcomingCompetitions.tsx
@@ -67,7 +67,7 @@ export default function UpcomingCompetitions() {
         <div className="flex space-x-2">
           <div className="type-meta">{__GIT_COMMIT__}</div>
           <div className="flex flex-grow" />
-          {<LastFetchedAt lastFetchedAt={new Date(dataUpdatedAt)} />}
+          {!!dataUpdatedAt && <LastFetchedAt lastFetchedAt={new Date(dataUpdatedAt)} />}
         </div>
       </Container>
     </div>
diff --git a/src/hooks/UseCollapse/UseCollapse.test.tsx b/src/hooks/UseCollapse/UseCollapse.test.tsx
new file mode 100644
index 0000000..899ff87
--- /dev/null
+++ b/src/hooks/UseCollapse/UseCollapse.test.tsx
@@ -0,0 +1,62 @@
+import { act, renderHook } from '@testing-library/react';
+import { StrictMode } from 'react';
+import { useCollapse } from './UseCollapse';
+
+beforeEach(() => localStorage.clear());
+
+it('handles repeated toggles without render-phase storage writes or losing other saved schedules', () => {
+  localStorage.setItem('collapse', JSON.stringify({ other: ['Other date'] }));
+  const consoleError = jest.spyOn(console, 'error').mockImplementation(() => {});
+  try {
+    const { result } = renderHook(() => useCollapse('schedule'), { wrapper: StrictMode });
+    act(() => {
+      result.current.toggleDate('Saturday');
+      result.current.toggleDate('Sunday');
+      result.current.toggleDate('Saturday');
+    });
+    expect(result.current.collapsedDates).toEqual(['Sunday']);
+    expect(JSON.parse(localStorage.getItem('collapse')!)).toEqual({
+      other: ['Other date'],
+      schedule: ['Sunday'],
+    });
+    expect(consoleError).not.toHaveBeenCalled();
+  } finally {
+    consoleError.mockRestore();
+  }
+});
+
+it.each([[[]], [['Sunday']]])(
+  'initializes from explicit saved dates %j without evaluating defaults',
+  (savedDates) => {
+    localStorage.setItem('collapse', JSON.stringify({ schedule: savedDates }));
+    const defaults = jest.fn(() => ['Saturday', 'Sunday']);
+    const { result } = renderHook(() => useCollapse('schedule', defaults));
+    expect(result.current.collapsedDates).toEqual(savedDates);
+    expect(defaults).not.toHaveBeenCalled();
+  },
+);
+
+it('uses defaults only for an unsaved schedule and preserves rapid choices through remount', () => {
+  localStorage.setItem('collapse', JSON.stringify({ other: ['Unrelated'] }));
+  const defaults = jest.fn(() => ['Saturday', 'Sunday']);
+  const { result, rerender, unmount } = renderHook(() => useCollapse('schedule', defaults));
+  expect(result.current.collapsedDates).toEqual(['Saturday', 'Sunday']);
+  expect(defaults).toHaveBeenCalledTimes(1);
+  expect(JSON.parse(localStorage.getItem('collapse')!)).toEqual({ other: ['Unrelated'] });
+  act(() => {
+    result.current.toggleDate('Saturday');
+    result.current.toggleDate('Sunday');
+    result.current.toggleDate('Saturday');
+  });
+  expect(result.current.collapsedDates).toEqual(['Saturday']);
+  rerender();
+  expect(defaults).toHaveBeenCalledTimes(1);
+  unmount();
+  const remounted = renderHook(() => useCollapse('schedule', defaults));
+  expect(remounted.result.current.collapsedDates).toEqual(['Saturday']);
+  expect(defaults).toHaveBeenCalledTimes(1);
+  expect(JSON.parse(localStorage.getItem('collapse')!)).toEqual({
+    other: ['Unrelated'],
+    schedule: ['Saturday'],
+  });
+});
diff --git a/src/hooks/UseCollapse/UseCollapse.ts b/src/hooks/UseCollapse/UseCollapse.ts
index 21410c9..d5a6fe6 100644
--- a/src/hooks/UseCollapse/UseCollapse.ts
+++ b/src/hooks/UseCollapse/UseCollapse.ts
@@ -1,46 +1,35 @@
 import { useLocalStorage } from '@uidotdev/usehooks';
-import { startTransition, useCallback, useState } from 'react';
+import { useCallback, useRef, useState } from 'react';
 
-export const useCollapse = (key: string) => {
+export const useCollapse = (key: string, getDefaultCollapsedDates: () => string[] = () => []) => {
   const [initialCollapsed, saveCollapsed] = useLocalStorage<Record<string, string[]>>(
     `collapse`,
     {},
   );
 
   const [collapsedDates, setCollapsedDates] = useState<string[]>(() => {
-    if (!initialCollapsed) {
-      return [];
-    }
-
-    const collapsed = initialCollapsed[key];
-    if (!collapsed || !Array.isArray(collapsed)) {
-      return [];
-    }
-
-    return collapsed;
+    const savedDates = initialCollapsed?.[key];
+    // An empty saved array is an explicit choice to expand every day. Defaults
+    // apply only on initialization when this schedule has no saved preference.
+    return Array.isArray(savedDates) ? savedDates : getDefaultCollapsedDates();
   });
 
+  const collapsedDatesRef = useRef(collapsedDates);
+  collapsedDatesRef.current = collapsedDates;
+
   const toggleDate = useCallback(
     (date: string) => {
-      startTransition(() => {
-        setCollapsedDates((prev) => {
-          let newState = prev;
-          if (prev.includes(date)) {
-            newState = prev.filter((d) => d !== date);
-          } else {
-            newState = [...prev, date];
-          }
-
-          saveCollapsed({
-            ...initialCollapsed,
-            [key]: newState,
-          });
-
-          return newState;
-        });
-      });
+      // Keep rapid toggles in order without writing to the external storage store
+      // from a React state updater, which may run during rendering or be replayed.
+      const previous = collapsedDatesRef.current;
+      const next = previous.includes(date)
+        ? previous.filter((collapsedDate) => collapsedDate !== date)
+        : [...previous, date];
+      collapsedDatesRef.current = next;
+      setCollapsedDates(next);
+      saveCollapsed((saved) => ({ ...saved, [key]: next }));
     },
-    [initialCollapsed, key, saveCollapsed],
+    [key, saveCollapsed],
   );
 
   return {
diff --git a/src/hooks/useSessionScrollRestoration/restoreScroll.ts b/src/hooks/useSessionScrollRestoration/restoreScroll.ts
new file mode 100644
index 0000000..55e144c
--- /dev/null
+++ b/src/hooks/useSessionScrollRestoration/restoreScroll.ts
@@ -0,0 +1,156 @@
+import { ScrollPosition, ScrollPositions } from './scrollPositions';
+
+const PANE_SELECTOR = '[data-scroll-restoration]';
+const SCROLL_KEYS = new Set([
+  'ArrowUp',
+  'ArrowDown',
+  'ArrowLeft',
+  'ArrowRight',
+  'PageUp',
+  'PageDown',
+  'Home',
+  'End',
+  ' ',
+]);
+const atPosition = (actual: ScrollPosition, expected: ScrollPosition) =>
+  Math.abs(actual.left - expected.left) < 1 && Math.abs(actual.top - expected.top) < 1;
+
+/** One controller per history entry. Disposing cancels all deferred restoration. */
+export function restoreScroll(root: HTMLElement, saved: ScrollPositions = {}) {
+  const positions: ScrollPositions = { ...saved };
+  const pending = new Map(Object.entries(saved));
+  const panes = new Map<string, HTMLElement>();
+  const initialized = new Set<string>();
+  const observed = new Set<Element>();
+  let disposed = false;
+  let interrupted = false;
+  let frame: number | undefined;
+
+  const read = (id: string, pane: HTMLElement): ScrollPosition =>
+    id === 'window'
+      ? { left: window.scrollX, top: window.scrollY }
+      : { left: pane.scrollLeft, top: pane.scrollTop };
+
+  const remember = () => {
+    for (const [id, pane] of panes) {
+      // Do not replace an unfulfilled position with the loading screen's zero.
+      if (!pending.has(id)) positions[id] = read(id, pane);
+    }
+  };
+
+  const onScroll = (event: Event) => {
+    for (const [id, pane] of panes) {
+      if (
+        (id === 'window' ? event.target === document : event.target === pane) &&
+        !pending.has(id)
+      ) {
+        positions[id] = read(id, pane);
+      }
+    }
+  };
+
+  const resizeObserver =
+    typeof ResizeObserver === 'undefined' ? undefined : new ResizeObserver(schedule);
+
+  function attempt() {
+    frame = undefined;
+    if (disposed) return;
+    const current = new Map<string, HTMLElement>([['window', document.documentElement]]);
+    if (root.matches(PANE_SELECTOR)) current.set(root.dataset.scrollRestoration!, root);
+    root.querySelectorAll<HTMLElement>(PANE_SELECTOR).forEach((pane) => {
+      current.set(pane.dataset.scrollRestoration!, pane);
+    });
+    for (const [id, pane] of panes) {
+      if (current.get(id) !== pane) initialized.delete(id);
+    }
+    panes.clear();
+    const needsObservation = new Set<Element>();
+    for (const [id, pane] of current) {
+      panes.set(id, pane);
+      if (!initialized.has(id)) {
+        initialized.add(id);
+        if (!interrupted) pending.set(id, positions[id] || { left: 0, top: 0 });
+        else positions[id] = read(id, pane);
+      }
+      const target = pending.get(id);
+      if (!target) continue;
+      const before = read(id, pane);
+      if (!atPosition(before, target)) {
+        if (id === 'window') {
+          window.scrollTo({ ...target, behavior: 'instant' });
+        } else {
+          pane.scrollTo({ ...target, behavior: 'instant' });
+        }
+      }
+      if (atPosition(read(id, pane), target)) {
+        positions[id] = target;
+        pending.delete(id);
+      } else {
+        // Pane size alone does not change when its children grow after a fetch.
+        needsObservation.add(pane);
+        Array.from(pane.children).forEach((child) => needsObservation.add(child));
+      }
+    }
+    // Re-observing an unchanged element produces a fresh ResizeObserver delivery.
+    // Keep subscriptions stable so an unreachable position does not poll forever.
+    for (const element of observed) {
+      if (!needsObservation.has(element)) {
+        resizeObserver?.unobserve(element);
+        observed.delete(element);
+      }
+    }
+    for (const element of needsObservation) {
+      if (!observed.has(element)) {
+        observed.add(element);
+        resizeObserver?.observe(element);
+      }
+    }
+  }
+
+  function schedule() {
+    if (!disposed && frame === undefined) frame = requestAnimationFrame(attempt);
+  }
+
+  const interrupt = (event: Event) => {
+    if (event instanceof KeyboardEvent && !SCROLL_KEYS.has(event.key) && event.key !== 'Tab')
+      return;
+    // Do not prevent input, move focus, or fight a user's scroll while data loads.
+    interrupted = true;
+    for (const id of pending.keys()) delete positions[id];
+    pending.clear();
+    resizeObserver?.disconnect();
+    observed.clear();
+    remember();
+  };
+
+  const mutationObserver = new MutationObserver(schedule);
+  mutationObserver.observe(root, {
+    childList: true,
+    subtree: true,
+    attributes: true,
+    characterData: true,
+  });
+  document.addEventListener('scroll', onScroll, true);
+  root.addEventListener('load', schedule, true);
+  const inputEvents = ['wheel', 'touchstart', 'pointerdown', 'keydown'];
+  inputEvents.forEach((type) =>
+    document.addEventListener(type, interrupt, { capture: true, passive: true }),
+  );
+  attempt();
+
+  return {
+    snapshot(readCurrent = false) {
+      if (readCurrent) remember();
+      return { ...positions };
+    },
+    dispose() {
+      disposed = true;
+      if (frame !== undefined) cancelAnimationFrame(frame);
+      mutationObserver.disconnect();
+      resizeObserver?.disconnect();
+      document.removeEventListener('scroll', onScroll, true);
+      root.removeEventListener('load', schedule, true);
+      inputEvents.forEach((type) => document.removeEventListener(type, interrupt, true));
+    },
+  };
+}
diff --git a/src/hooks/useSessionScrollRestoration/scrollPositions.test.ts b/src/hooks/useSessionScrollRestoration/scrollPositions.test.ts
new file mode 100644
index 0000000..426f17e
--- /dev/null
+++ b/src/hooks/useSessionScrollRestoration/scrollPositions.test.ts
@@ -0,0 +1,77 @@
+import { createScrollPositionStore, SCROLL_STORAGE_KEY } from './scrollPositions';
+
+beforeEach(() => sessionStorage.clear());
+afterEach(() => jest.restoreAllMocks());
+
+it('persists only in sessionStorage and isolates entries, including repeated URLs and searches', () => {
+  const localWrite = jest.spyOn(Storage.prototype, 'setItem');
+  const store = createScrollPositionStore();
+  store.set('first', '/groups?q=amy', { competition: { left: 10, top: 700 } });
+  store.set('second', '/groups?q=amy', { competition: { left: 0, top: 200 } });
+  store.set('third', '/groups?q=bob', { competition: { left: 0, top: 300 } });
+  const reloaded = createScrollPositionStore();
+  expect(reloaded.get('first', '/groups?q=amy')?.competition.top).toBe(700);
+  expect(reloaded.get('second', '/groups?q=amy')?.competition.top).toBe(200);
+  expect(reloaded.get('third', '/groups?q=bob')?.competition.top).toBe(300);
+  expect(reloaded.get('first', '/groups?q=bob')).toBeUndefined();
+  expect(localWrite.mock.contexts.every((context) => context === sessionStorage)).toBe(true);
+  sessionStorage.clear();
+  expect(createScrollPositionStore().get('first', '/groups?q=amy')).toBeUndefined();
+});
+
+it.each(['broken json', '{}', 'null', '[null,3,{},[]]'])(
+  'ignores malformed session storage: %s',
+  (value) => {
+    sessionStorage.setItem(SCROLL_STORAGE_KEY, value);
+    const store = createScrollPositionStore();
+    expect(() => store.set('entry', '/', { page: { left: 0, top: 10 } })).not.toThrow();
+    expect(store.get('entry', '/')?.page.top).toBe(10);
+  },
+);
+
+it('validates stored coordinates and does not treat object prototype keys as entries', () => {
+  sessionStorage.setItem(
+    SCROLL_STORAGE_KEY,
+    JSON.stringify([
+      {
+        key: '__proto__',
+        url: '/',
+        positions: {
+          valid: { left: 0, top: 40 },
+          negative: { left: 0, top: -1 },
+          text: { left: 0, top: '70' },
+          empty: null,
+        },
+      },
+      { key: 1, url: '/', positions: {} },
+    ]),
+  );
+  const store = createScrollPositionStore();
+  expect(store.get('__proto__', '/')).toEqual({ valid: { left: 0, top: 40 } });
+  expect(store.get('toString', '/')).toBeUndefined();
+});
+
+it('continues working in memory when session storage reads and writes throw', () => {
+  jest.spyOn(Storage.prototype, 'getItem').mockImplementation(() => {
+    throw new Error('blocked');
+  });
+  jest.spyOn(Storage.prototype, 'setItem').mockImplementation(() => {
+    throw new Error('full');
+  });
+  const store = createScrollPositionStore();
+  expect(() => store.set('entry', '/', { page: { left: 0, top: 80 } })).not.toThrow();
+  expect(store.get('entry', '/')?.page.top).toBe(80);
+});
+
+it('retains every history entry throughout a long session without arbitrary eviction', () => {
+  const store = createScrollPositionStore();
+  for (let i = 0; i < 250; i++) store.set(`${i}`, '/', { page: { left: 0, top: i + 10 } });
+  store.set('0', '/', { page: { left: 0, top: 500 } });
+  store.set('new', '/', {});
+  expect(store.get('1', '/')?.page.top).toBe(11);
+  expect(store.get('0', '/')?.page.top).toBe(500);
+  expect(JSON.parse(sessionStorage.getItem(SCROLL_STORAGE_KEY)!)).toHaveLength(251);
+  const reloaded = createScrollPositionStore();
+  expect(reloaded.get('1', '/')?.page.top).toBe(11);
+  expect(reloaded.get('249', '/')?.page.top).toBe(259);
+});
diff --git a/src/hooks/useSessionScrollRestoration/scrollPositions.ts b/src/hooks/useSessionScrollRestoration/scrollPositions.ts
new file mode 100644
index 0000000..07ccbb0
--- /dev/null
+++ b/src/hooks/useSessionScrollRestoration/scrollPositions.ts
@@ -0,0 +1,65 @@
+export interface ScrollPosition {
+  left: number;
+  top: number;
+}
+
+export type ScrollPositions = Record<string, ScrollPosition>;
+
+interface ScrollEntry {
+  key: string;
+  url: string;
+  positions: ScrollPositions;
+}
+
+export const SCROLL_STORAGE_KEY = 'competition-groups:session-scroll:v1';
+
+const isPosition = (value: unknown): value is ScrollPosition => {
+  if (!value || typeof value !== 'object') return false;
+  const { left, top } = value as ScrollPosition;
+  return Number.isFinite(left) && left >= 0 && Number.isFinite(top) && top >= 0;
+};
+
+/** Only page-session storage: never the durable settings/query cache. */
+export function createScrollPositionStore() {
+  const entries = new Map<string, ScrollEntry>();
+  try {
+    const stored: unknown = JSON.parse(sessionStorage.getItem(SCROLL_STORAGE_KEY) || 'null');
+    if (Array.isArray(stored)) {
+      for (const value of stored) {
+        if (!value || typeof value !== 'object') continue;
+        const entry = value as Record<string, unknown>;
+        if (
+          typeof entry.key === 'string' &&
+          typeof entry.url === 'string' &&
+          entry.positions &&
+          typeof entry.positions === 'object' &&
+          !Array.isArray(entry.positions)
+        ) {
+          const positions = Object.fromEntries(
+            Object.entries(entry.positions).filter(([, position]) => isPosition(position)),
+          ) as ScrollPositions;
+          entries.set(entry.key, { key: entry.key, url: entry.url, positions });
+        }
+      }
+    }
+  } catch {
+    // Storage can be disabled, full, or left over from a malformed session.
+  }
+
+  return {
+    get(key: string, url: string): ScrollPositions | undefined {
+      const entry = entries.get(key);
+      // The initial React Router key can be "default" on different documents.
+      return entry?.url === url ? entry.positions : undefined;
+    },
+    set(key: string, url: string, positions: ScrollPositions) {
+      entries.delete(key);
+      entries.set(key, { key, url, positions });
+      try {
+        sessionStorage.setItem(SCROLL_STORAGE_KEY, JSON.stringify([...entries.values()]));
+      } catch {
+        // Back/Forward still works in memory when sessionStorage is unavailable.
+      }
+    },
+  };
+}
diff --git a/src/hooks/useSessionScrollRestoration/useSessionScrollRestoration.test.tsx b/src/hooks/useSessionScrollRestoration/useSessionScrollRestoration.test.tsx
new file mode 100644
index 0000000..deed170
--- /dev/null
+++ b/src/hooks/useSessionScrollRestoration/useSessionScrollRestoration.test.tsx
@@ -0,0 +1,452 @@
+import { act, fireEvent, render, screen } from '@testing-library/react';
+import { StrictMode, useRef } from 'react';
+import { MemoryRouter, NavigateFunction, useLocation, useNavigate } from 'react-router-dom';
+import { createScrollPositionStore } from './scrollPositions';
+import { useSessionScrollRestoration } from './useSessionScrollRestoration';
+
+let navigate: NavigateFunction;
+let capacities: WeakMap<HTMLElement, number>;
+let frames: Map<number, FrameRequestCallback>;
+let nextFrame: number;
+let resizeCallbacks: Set<ResizeObserverCallback>;
+let navigationTiming: string;
+let resizeObserveCalls: number;
+const originalNavigationTiming = performance.getEntriesByType;
+const originalScrollTo = HTMLElement.prototype.scrollTo;
+const originalResizeObserver = global.ResizeObserver;
+
+beforeEach(() => {
+  sessionStorage.clear();
+  capacities = new WeakMap();
+  frames = new Map();
+  nextFrame = 0;
+  resizeCallbacks = new Set();
+  navigationTiming = 'reload';
+  resizeObserveCalls = 0;
+  Object.defineProperty(performance, 'getEntriesByType', {
+    configurable: true,
+    value: () => [{ type: navigationTiming }],
+  });
+  jest.spyOn(window, 'requestAnimationFrame').mockImplementation((callback) => {
+    frames.set(++nextFrame, callback);
+    return nextFrame;
+  });
+  jest.spyOn(window, 'cancelAnimationFrame').mockImplementation((id) => {
+    frames.delete(id);
+  });
+  jest.spyOn(window, 'scrollTo').mockImplementation(() => {});
+  HTMLElement.prototype.scrollTo = jest.fn(function (
+    this: HTMLElement,
+    options: ScrollToOptions | number = {},
+    top?: number,
+  ) {
+    const target = typeof options === 'number' ? { left: options, top } : options;
+    this.scrollTop = Math.min(target.top || 0, capacities.get(this) ?? 3000);
+    this.scrollLeft = target.left || 0;
+  });
+  global.ResizeObserver = class {
+    callback: ResizeObserverCallback;
+    elements = new Set<Element>();
+    constructor(callback: ResizeObserverCallback) {
+      this.callback = callback;
+    }
+    observe(element: Element) {
+      resizeObserveCalls += 1;
+      this.elements.add(element);
+      resizeCallbacks.add(this.callback);
+    }
+    unobserve(element: Element) {
+      this.elements.delete(element);
+      if (!this.elements.size) resizeCallbacks.delete(this.callback);
+    }
+    disconnect() {
+      this.elements.clear();
+      resizeCallbacks.delete(this.callback);
+    }
+  };
+});
+
+afterEach(() => {
+  jest.restoreAllMocks();
+  HTMLElement.prototype.scrollTo = originalScrollTo;
+  global.ResizeObserver = originalResizeObserver;
+  Object.defineProperty(performance, 'getEntriesByType', {
+    configurable: true,
+    value: originalNavigationTiming,
+  });
+});
+
+function Harness({ loaded = true, showPane = true }: { loaded?: boolean; showPane?: boolean }) {
+  const root = useRef<HTMLElement>(null);
+  const location = useLocation();
+  navigate = useNavigate();
+  useSessionScrollRestoration(root);
+  const paneId = location.pathname.startsWith('/competitions/') ? 'competition' : 'page';
+  const max = location.pathname.includes('/persons/') || !loaded ? 50 : 3000;
+  return (
+    <main ref={root} data-scroll-restoration="root" data-testid="root">
+      <output>{location.pathname + location.search}</output>
+      {showPane && (
+        <div
+          key={paneId}
+          ref={(pane) => {
+            if (pane) {
+              capacities.set(pane, max);
+              pane.scrollTop = Math.min(pane.scrollTop, max);
+            }
+          }}
+          data-scroll-restoration={paneId}
+          data-testid="pane">
+          <div>{loaded ? 'Loaded content' : 'Loading content'}</div>
+          <a href="#target">A link</a>
+          <input aria-label="Filter" />
+        </div>
+      )}
+    </main>
+  );
+}
+
+const groups = '/competitions/Test';
+const person = '/competitions/Test/persons/1';
+const pane = () => screen.getByTestId('pane');
+const go = (to: string | number, replace = false) =>
+  act(() => {
+    if (typeof to === 'number') navigate(to);
+    else navigate(to, { replace });
+  });
+const scroll = (top: number, target = pane(), left = 0) => {
+  target.scrollTop = top;
+  target.scrollLeft = left;
+  fireEvent.scroll(target);
+};
+const flush = async () => {
+  await act(async () => {});
+  act(() => {
+    const callbacks = [...frames.values()];
+    frames.clear();
+    callbacks.forEach((callback) => callback(0));
+  });
+};
+const resize = async () => {
+  resizeCallbacks.forEach((callback) => callback([], {} as ResizeObserver));
+  await flush();
+};
+
+it('remembers the outgoing long list before DOM shrink and restores Back/Forward repeatedly', () => {
+  render(
+    <MemoryRouter initialEntries={[groups]}>
+      <Harness />
+    </MemoryRouter>,
+  );
+  scroll(850);
+  go(person);
+  expect(pane().scrollTop).toBe(0);
+  scroll(30);
+  go(-1);
+  expect(pane().scrollTop).toBe(850);
+  go(1);
+  expect(pane().scrollTop).toBe(30);
+  go(-1);
+  expect(pane().scrollTop).toBe(850);
+});
+
+it('isolates repeated URLs, query entries, PUSH and REPLACE', () => {
+  render(
+    <MemoryRouter initialEntries={[groups]}>
+      <Harness />
+    </MemoryRouter>,
+  );
+  scroll(500);
+  go(groups);
+  expect(pane().scrollTop).toBe(0);
+  scroll(200);
+  go(`${groups}?q=amy`);
+  expect(pane().scrollTop).toBe(0);
+  scroll(100);
+  go(-1);
+  expect(pane().scrollTop).toBe(200);
+  go(-1);
+  expect(pane().scrollTop).toBe(500);
+  go(2);
+  expect(pane().scrollTop).toBe(100);
+  go(`${groups}?q=bob`, true);
+  expect(pane().scrollTop).toBe(0);
+  scroll(70);
+  go(-1);
+  expect(pane().scrollTop).toBe(200);
+  go(1);
+  expect(pane().scrollTop).toBe(70);
+});
+
+it.each([
+  '/competitions/Test/events',
+  '/competitions/Test/activities',
+  '/competitions/Test/results/333-r1',
+  '/competitions/Test/persons/1/results',
+  '/',
+  '/about',
+  '/support',
+  '/me/results',
+  '/live-activities',
+  '/settings',
+])('restores the correct root or competition scroll owner on %s', (route) => {
+  render(
+    <MemoryRouter initialEntries={[route]}>
+      <Harness />
+    </MemoryRouter>,
+  );
+  const offset = route.includes('/persons/') ? 40 : 640;
+  scroll(offset, pane(), 20);
+  scroll(25, screen.getByTestId('root'));
+  go('/other');
+  expect(pane().scrollTop).toBe(0);
+  go(-1);
+  expect(pane().scrollTop).toBe(offset);
+  expect(pane().scrollLeft).toBe(20);
+  expect(screen.getByTestId('root').scrollTop).toBe(25);
+});
+
+it('waits through short async content and restores after it grows', async () => {
+  createScrollPositionStore().set('delayed', groups, { competition: { left: 0, top: 900 } });
+  const view = render(
+    <MemoryRouter initialEntries={[{ pathname: groups, key: 'delayed' }]}>
+      <Harness loaded={false} />
+    </MemoryRouter>,
+  );
+  expect(pane().scrollTop).toBe(50);
+  fireEvent.scroll(pane());
+  fireEvent(window, new Event('pagehide'));
+  expect(createScrollPositionStore().get('delayed', groups)?.competition.top).toBe(900);
+  view.rerender(
+    <MemoryRouter initialEntries={[{ pathname: groups, key: 'delayed' }]}>
+      <Harness />
+    </MemoryRouter>,
+  );
+  await resize();
+  expect(pane().scrollTop).toBe(900);
+  scroll(300);
+  await resize();
+  expect(pane().scrollTop).toBe(300);
+});
+
+it('restores a pane that mounts only after async data arrives', async () => {
+  createScrollPositionStore().set('delayed', '/me/results', { page: { left: 0, top: 780 } });
+  const view = render(
+    <MemoryRouter initialEntries={[{ pathname: '/me/results', key: 'delayed' }]}>
+      <Harness showPane={false} />
+    </MemoryRouter>,
+  );
+  view.rerender(
+    <MemoryRouter initialEntries={[{ pathname: '/me/results', key: 'delayed' }]}>
+      <Harness />
+    </MemoryRouter>,
+  );
+  await flush();
+  expect(pane().scrollTop).toBe(780);
+});
+
+it.each(['wheel', 'touchStart', 'pointerDown', 'keyDown'])(
+  'cancels pending restoration on manual %s without blocking the interaction',
+  async (type) => {
+    createScrollPositionStore().set('delayed', groups, { competition: { left: 0, top: 900 } });
+    const view = render(
+      <MemoryRouter initialEntries={[{ pathname: groups, key: 'delayed' }]}>
+        <Harness loaded={false} />
+      </MemoryRouter>,
+    );
+    const event =
+      type === 'keyDown'
+        ? new KeyboardEvent('keydown', { key: 'PageDown', bubbles: true, cancelable: true })
+        : new Event(type.toLowerCase(), { bubbles: true, cancelable: true });
+    fireEvent(pane(), event);
+    expect(event.defaultPrevented).toBe(false);
+    scroll(20);
+    view.rerender(
+      <MemoryRouter initialEntries={[{ pathname: groups, key: 'delayed' }]}>
+        <Harness />
+      </MemoryRouter>,
+    );
+    await resize();
+    expect(pane().scrollTop).toBe(20);
+    fireEvent(window, new Event('pagehide'));
+    expect(createScrollPositionStore().get('delayed', groups)?.competition.top).toBe(20);
+  },
+);
+
+it('does not move focus or interfere with Tab and typing while data arrives', async () => {
+  createScrollPositionStore().set('delayed', groups, { competition: { left: 0, top: 900 } });
+  const view = render(
+    <MemoryRouter initialEntries={[{ pathname: groups, key: 'delayed' }]}>
+      <Harness loaded={false} />
+    </MemoryRouter>,
+  );
+  const input = screen.getByRole('textbox');
+  fireEvent.keyDown(document, { key: 'Tab' });
+  input.focus();
+  fireEvent.change(input, { target: { value: 'amy' } });
+  view.rerender(
+    <MemoryRouter initialEntries={[{ pathname: groups, key: 'delayed' }]}>
+      <Harness />
+    </MemoryRouter>,
+  );
+  await resize();
+  expect(input).toHaveFocus();
+  expect(input).toHaveValue('amy');
+  expect(pane().scrollTop).toBe(50);
+});
+
+it('cancels stale callbacks on newer navigation and saves the unfulfilled target for Back', async () => {
+  createScrollPositionStore().set('delayed', groups, { competition: { left: 0, top: 900 } });
+  const view = render(
+    <MemoryRouter initialEntries={[{ pathname: groups, key: 'delayed' }]}>
+      <Harness loaded={false} />
+    </MemoryRouter>,
+  );
+  resizeCallbacks.forEach((callback) => callback([], {} as ResizeObserver));
+  go('/about');
+  view.rerender(
+    <MemoryRouter initialEntries={[{ pathname: groups, key: 'delayed' }]}>
+      <Harness />
+    </MemoryRouter>,
+  );
+  await flush();
+  expect(pane().scrollTop).toBe(0);
+  go(-1);
+  expect(pane().scrollTop).toBe(900);
+});
+
+it('rehydrates the current entry on reload, with pagehide saving the latest coordinates', () => {
+  const entry = { pathname: groups, key: 'reload-entry' };
+  const view = render(
+    <MemoryRouter initialEntries={[entry]}>
+      <Harness />
+    </MemoryRouter>,
+  );
+  pane().scrollTop = 650;
+  fireEvent(window, new Event('pagehide'));
+  expect(createScrollPositionStore().get(entry.key, groups)?.competition.top).toBe(650);
+  // Reload does not run React cleanup. Save the persisted snapshot before test unmount.
+  const persisted = sessionStorage.getItem('competition-groups:session-scroll:v1')!;
+  view.unmount();
+  sessionStorage.setItem('competition-groups:session-scroll:v1', persisted);
+  render(
+    <MemoryRouter initialEntries={[entry]}>
+      <Harness />
+    </MemoryRouter>,
+  );
+  expect(pane().scrollTop).toBe(650);
+});
+
+it('starts fresh document navigation at the top, then remembers its first entry on Back', () => {
+  navigationTiming = 'navigate';
+  createScrollPositionStore().set('default', '/', { page: { left: 0, top: 900 } });
+  render(
+    <MemoryRouter initialEntries={['/']}>
+      <Harness />
+    </MemoryRouter>,
+  );
+  expect(pane().scrollTop).toBe(0);
+  scroll(300);
+  go('/about');
+  go(-1);
+  expect(pane().scrollTop).toBe(300);
+});
+
+it('handles StrictMode and cleans up observers, frames and native restoration ownership', async () => {
+  window.history.scrollRestoration = 'auto';
+  createScrollPositionStore().set('delayed', groups, { competition: { left: 0, top: 900 } });
+  const view = render(
+    <StrictMode>
+      <MemoryRouter initialEntries={[{ pathname: groups, key: 'delayed' }]}>
+        <Harness loaded={false} />
+      </MemoryRouter>
+    </StrictMode>,
+  );
+  expect(window.history.scrollRestoration).toBe('manual');
+  expect(resizeCallbacks.size).toBe(1);
+  resizeCallbacks.forEach((callback) => callback([], {} as ResizeObserver));
+  view.unmount();
+  expect(window.history.scrollRestoration).toBe('auto');
+  expect(frames.size).toBe(0);
+  expect(resizeCallbacks.size).toBe(0);
+  const stored = sessionStorage.getItem('competition-groups:session-scroll:v1');
+  fireEvent(window, new Event('pagehide'));
+  await flush();
+  expect(sessionStorage.getItem('competition-groups:session-scroll:v1')).toBe(stored);
+});
+
+it('observes unreachable positions without a re-observe animation loop, including image-only growth', async () => {
+  createScrollPositionStore().set('delayed', groups, { competition: { left: 0, top: 900 } });
+  render(
+    <MemoryRouter initialEntries={[{ pathname: groups, key: 'delayed' }]}>
+      <Harness loaded={false} />
+    </MemoryRouter>,
+  );
+  const subscribed = resizeObserveCalls;
+  expect(subscribed).toBeGreaterThan(0);
+  await resize();
+  await resize();
+  expect(resizeObserveCalls).toBe(subscribed);
+  expect(frames.size).toBe(0);
+  capacities.set(pane(), 3000);
+  await resize();
+  expect(pane().scrollTop).toBe(900);
+  expect(resizeCallbacks.size).toBe(0);
+});
+
+it('persists when the tab becomes hidden without waiting for navigation', () => {
+  const entry = { pathname: groups, key: 'hidden-entry' };
+  render(
+    <MemoryRouter initialEntries={[entry]}>
+      <Harness />
+    </MemoryRouter>,
+  );
+  scroll(420);
+  const visibility = jest.spyOn(document, 'visibilityState', 'get').mockReturnValue('hidden');
+  fireEvent(document, new Event('visibilitychange'));
+  expect(createScrollPositionStore().get(entry.key, groups)?.competition.top).toBe(420);
+  visibility.mockRestore();
+});
+
+it('does not revive an abandoned target when manual input precedes the async pane mount', async () => {
+  createScrollPositionStore().set('delayed', '/me/results', { page: { left: 0, top: 950 } });
+  const entry = { pathname: '/me/results', key: 'delayed' };
+  const view = render(
+    <MemoryRouter initialEntries={[entry]}>
+      <Harness showPane={false} />
+    </MemoryRouter>,
+  );
+  fireEvent.wheel(screen.getByTestId('root'));
+  fireEvent(window, new Event('pagehide'));
+  expect(createScrollPositionStore().get(entry.key, entry.pathname)?.page).toBeUndefined();
+  view.rerender(
+    <MemoryRouter initialEntries={[entry]}>
+      <Harness />
+    </MemoryRouter>,
+  );
+  await flush();
+  expect(pane().scrollTop).toBe(0);
+  go('/about');
+  go(-1);
+  expect(pane().scrollTop).toBe(0);
+});
+
+it('does not mistake browser or programmatic focus for a manual scroll override', async () => {
+  createScrollPositionStore().set('delayed', groups, { competition: { left: 0, top: 900 } });
+  const entry = { pathname: groups, key: 'delayed' };
+  const view = render(
+    <MemoryRouter initialEntries={[entry]}>
+      <Harness loaded={false} />
+    </MemoryRouter>,
+  );
+  const input = screen.getByRole('textbox');
+  input.focus();
+  view.rerender(
+    <MemoryRouter initialEntries={[entry]}>
+      <Harness />
+    </MemoryRouter>,
+  );
+  await resize();
+  expect(input).toHaveFocus();
+  expect(pane().scrollTop).toBe(900);
+});
diff --git a/src/hooks/useSessionScrollRestoration/useSessionScrollRestoration.ts b/src/hooks/useSessionScrollRestoration/useSessionScrollRestoration.ts
new file mode 100644
index 0000000..3e407af
--- /dev/null
+++ b/src/hooks/useSessionScrollRestoration/useSessionScrollRestoration.ts
@@ -0,0 +1,51 @@
+import { RefObject, useLayoutEffect, useRef, useState } from 'react';
+import { useLocation, useNavigationType } from 'react-router-dom';
+import { restoreScroll } from './restoreScroll';
+import { createScrollPositionStore } from './scrollPositions';
+
+export function useSessionScrollRestoration(root: RefObject<HTMLElement>) {
+  const location = useLocation();
+  const navigationType = useNavigationType();
+  const [store] = useState(createScrollPositionStore);
+  const initialEntry = useRef(true);
+  const [freshDocument] = useState(() => {
+    const navigation = performance.getEntriesByType?.('navigation')[0] as
+      | PerformanceNavigationTiming
+      | undefined;
+    return navigation?.type === 'navigate';
+  });
+  const url = location.pathname + location.search + location.hash;
+
+  useLayoutEffect(() => {
+    const previous = window.history.scrollRestoration;
+    window.history.scrollRestoration = 'manual';
+    return () => {
+      window.history.scrollRestoration = previous;
+    };
+  }, []);
+
+  useLayoutEffect(() => {
+    if (!root.current) return;
+    // PUSH/REPLACE are new views. POP and reload restore this exact history entry,
+    // never the last position of a different visit to the same URL.
+    const isFreshInitialEntry = initialEntry.current && freshDocument;
+    initialEntry.current = false;
+    const saved =
+      navigationType === 'POP' && !isFreshInitialEntry ? store.get(location.key, url) : undefined;
+    const controller = restoreScroll(root.current, saved);
+    const persist = () => store.set(location.key, url, controller.snapshot(true));
+    const onVisibility = () => {
+      if (document.visibilityState === 'hidden') persist();
+    };
+    window.addEventListener('pagehide', persist);
+    document.addEventListener('visibilitychange', onVisibility);
+    return () => {
+      // DOM mutations may already have clamped the old pane. Use its last scroll
+      // event, not its now-replaced content, when leaving the history entry.
+      store.set(location.key, url, controller.snapshot());
+      controller.dispose();
+      window.removeEventListener('pagehide', persist);
+      document.removeEventListener('visibilitychange', onVisibility);
+    };
+  }, [root, store, location.key, url, navigationType, freshDocument]);
+}
diff --git a/src/i18n/en/translation.yaml b/src/i18n/en/translation.yaml
index 5dda002..f7b9afa 100644
--- a/src/i18n/en/translation.yaml
+++ b/src/i18n/en/translation.yaml
@@ -4,6 +4,8 @@ common:
   retry: 'Try again'
   home: 'Back to home'
   bookmarkCompetition: 'Bookmark competition'
+  bookmarkCompetitor: 'Bookmark competitor'
+  removeCompetitorBookmark: 'Remove competitor bookmark'
   wca:
     event: 'Event'
     round: 'Round'
@@ -40,9 +42,14 @@ common:
       linkedRanking: 'Top {{level}} in dual rounds {{rounds}} advance to {{what}}'
       linkedPercent: 'Top {{level}}% in dual rounds {{rounds}} advance to {{what}}'
       attemptResult: Result better than <b>{level}</b> advances to next round. Minimum of 25% of competitors must be eliminated.
-      resultAchieved: '{{scope}} < {{result}} advance to {{what}}; minimum of 25% of competitors must be eliminated'
-      linkedResultAchieved: '{{scope}} < {{result}} in dual rounds {{rounds}} advance to {{what}}; minimum of 25% of competitors must be eliminated'
-      resultThresholdUnknown: an unknown result
+      resultAchieved: '{{scope}} better than {{result}} advance to {{what}}; minimum of 25% of competitors must be eliminated'
+      linkedResultAchieved: '{{scope}} better than {{result}} in dual rounds {{rounds}} advance to {{what}}; minimum of 25% of competitors must be eliminated'
+      anyResultAchieved: 'Any {{scope}} advances to {{what}}; minimum of 25% of competitors must be eliminated'
+      linkedAnyResultAchieved: 'Any {{scope}} in dual rounds {{rounds}} advances to {{what}}; minimum of 25% of competitors must be eliminated'
+      resultInMoves: '{{result}} moves'
+      successfulScope:
+        single: successful single
+        average: successful average
       nextRound: next round
       final: final
       unknown: unknown
@@ -152,6 +159,7 @@ appUpdate:
   description: 'Refresh to get the latest version of the app.'
   action: 'Refresh now'
 header:
+  settings: 'Settings'
   login: $t(common.login)
   logout: 'Logout'
   tabs:
@@ -186,6 +194,7 @@ competition:
     viewMyAssignments: 'View My Assignments'
     viewCompetitionInformation: 'View Competition Information'
     searchCompetitors: 'Search Competitors'
+    noMatches: 'No competitors match your search.'
   groups:
     backToEvents: 'Back to Events'
     nextGroup: 'Next Group'
@@ -219,7 +228,10 @@ competition:
     viewLiveResults: View live results
     dualPersonalNote: 'Dual-round ranks use the better result from either linked round. Each row shows that round’s own results.'
     dualRoundNote: 'Dual-round standings: rank is based on the better result from either linked round. Attempts, best and average below belong to the selected round. No competitors are eliminated between the linked rounds.'
-    resultsSourceNote: Results are merged from WCIF and WCA Live when available. WCA Live data may be delayed.
+    resultsSourceNote: Results combine WCA Live, WCIF, and published WCA results. Yellow highlights are provisional. Without Live, advancement uses next-round participants when available, otherwise calculated eligibility; incomplete source rounds remain provisional. Stored data may lag behind organizer changes.
+  person:
+    notFound: 'Competitor not found.'
+    backToCompetitors: 'Back to competitors'
   personalResults:
     eventResults: Event results
   round:
diff --git a/src/layouts/CompetitionLayout/CompetitionLayout.test.tsx b/src/layouts/CompetitionLayout/CompetitionLayout.test.tsx
index aecc77e..d53dd6e 100644
--- a/src/layouts/CompetitionLayout/CompetitionLayout.test.tsx
+++ b/src/layouts/CompetitionLayout/CompetitionLayout.test.tsx
@@ -1,9 +1,14 @@
-import { fireEvent, render, screen } from '@testing-library/react';
-import { MemoryRouter, Route, Routes } from 'react-router-dom';
+import { QueryClientProvider } from '@tanstack/react-query';
+import { act, fireEvent, render, screen } from '@testing-library/react';
+import { Competition } from '@wca/helpers';
+import { MemoryRouter, Route, Routes, useParams } from 'react-router-dom';
 import { useWcif } from '@/hooks/queries/useWcif';
+import { fetchWcif } from '@/lib/api';
+import { queryClient } from '@/providers/QueryProvider';
 import { CompetitionLayout } from './CompetitionLayout';
 
 jest.mock('@/hooks/queries/useWcif', () => ({ useWcif: jest.fn() }));
+jest.mock('@/lib/api', () => ({ fetchWcif: jest.fn() }));
 jest.mock('@/hooks/useCompetitionAnalytics', () => ({ useCompetitionAnalytics: jest.fn() }));
 jest.mock('@/providers/AppProvider', () => ({ useApp: () => ({ online: true }) }));
 jest.mock('@/providers/WCIFProvider', () => ({
@@ -32,6 +37,7 @@ const view = () => (
 
 beforeAll(() => {
   HTMLElement.prototype.scrollTo = jest.fn();
+  Object.assign(globalThis, { __GIT_COMMIT__: 'test' });
 });
 
 beforeEach(() => {
@@ -41,6 +47,7 @@ beforeEach(() => {
     error: null,
     dataUpdatedAt: 0,
     isFetching: true,
+    isPlaceholderData: false,
     refetch,
   });
 });
@@ -116,3 +123,225 @@ it('replaces an initial error with content after a successful retry', () => {
   expect(screen.queryByRole('alert')).not.toBeInTheDocument();
   expect(screen.getByText('Competition content')).toBeInTheDocument();
 });
+
+it('announces initial loading and retry loading even when the query clears its previous error', () => {
+  const { rerender } = render(view());
+  expect(screen.getByRole('status')).toHaveTextContent('common.loading');
+  mockUseWcif.mockReturnValue({
+    error: new Error('Missing'),
+    dataUpdatedAt: 0,
+    isFetching: false,
+    refetch,
+  });
+  rerender(view());
+  fireEvent.click(screen.getByRole('button', { name: 'common.retry' }));
+  mockUseWcif.mockReturnValue({ error: null, dataUpdatedAt: 0, isFetching: true, refetch });
+  rerender(view());
+  expect(screen.getByRole('status')).toHaveTextContent('common.loading');
+  expect(screen.queryByText('Competition content')).not.toBeInTheDocument();
+  mockUseWcif.mockReturnValue({
+    error: new Error('Missing'),
+    dataUpdatedAt: 0,
+    isFetching: false,
+    refetch,
+  });
+  rerender(view());
+  expect(screen.queryByRole('status')).not.toBeInTheDocument();
+  expect(screen.getByRole('button', { name: 'common.retry' })).toBeEnabled();
+});
+
+describe('with actual WCIF query state', () => {
+  const { useWcif: useActualWcif } = jest.requireActual<{
+    useWcif: typeof useWcif;
+  }>('@/hooks/queries/useWcif');
+  const competitionId = 'Example2026';
+  const competition = {
+    id: competitionId,
+    name: 'Example 2026',
+    shortName: 'Example 2026',
+    formatVersion: '2.2',
+    events: [],
+    persons: [],
+    schedule: {
+      numberOfDays: 1,
+      startDate: '2026-11-03',
+      venues: [
+        {
+          id: 1,
+          name: 'Venue',
+          latitudeMicrodegrees: 0,
+          longitudeMicrodegrees: 0,
+          countryIso2: 'US',
+          timezone: 'Etc/UTC',
+          extensions: [],
+          rooms: [
+            {
+              id: 1,
+              name: 'Main room',
+              color: '#ffffff',
+              extensions: [],
+              activities: [
+                {
+                  id: 42,
+                  activityCode: '333-r1',
+                  name: '3x3x3 Cube, Round 1',
+                  startTime: '2026-11-03T09:00:00Z',
+                  endTime: '2026-11-03T10:00:00Z',
+                  childActivities: [],
+                  extensions: [],
+                  scrambleSetId: null,
+                },
+              ],
+            },
+          ],
+        },
+      ],
+    },
+    series: null,
+    registrationInfo: {
+      openTime: '2026-10-01T00:00:00Z',
+      closeTime: '2026-11-01T00:00:00Z',
+      baseEntryFee: 1000,
+      currencyCode: 'USD',
+      onTheSpotRegistration: false,
+      useWcaRegistration: true,
+    },
+    competitorLimit: 100,
+    extensions: [],
+  } satisfies Competition;
+
+  function ActivityContent() {
+    const { competitionId, activityId } = useParams();
+    const { data } = useWcif(competitionId);
+    const activity = data?.schedule.venues
+      .flatMap((venue) => venue.rooms)
+      .flatMap((room) => room.activities)
+      .find((activity) => activity.id === Number(activityId));
+
+    return <h2>{activity?.name ?? 'Activity not found'}</h2>;
+  }
+
+  const activityView = (activityId = 42) => (
+    <QueryClientProvider client={queryClient}>
+      <MemoryRouter initialEntries={[`/competitions/${competitionId}/activities/${activityId}`]}>
+        <Routes>
+          <Route path="/competitions/:competitionId" element={<CompetitionLayout />}>
+            <Route path="activities/:activityId" element={<ActivityContent />} />
+          </Route>
+        </Routes>
+      </MemoryRouter>
+    </QueryClientProvider>
+  );
+
+  beforeEach(() => {
+    queryClient.clear();
+    queryClient.setDefaultOptions({ queries: { retry: false } });
+    mockUseWcif.mockImplementation(useActualWcif);
+    jest.mocked(fetchWcif).mockReset();
+    queryClient.setQueryData(['upcomingCompetitions'], {
+      pages: [[{ id: competitionId, name: 'Example 2026', short_name: 'Example 2026' }]],
+      pageParams: [undefined],
+    });
+  });
+
+  afterEach(() => {
+    queryClient.clear();
+  });
+
+  it.each([
+    { activityId: 42, expectedHeading: '3x3x3 Cube, Round 1' },
+    { activityId: 999, expectedHeading: 'Activity not found' },
+  ])(
+    'waits for full WCIF before resolving activity $activityId',
+    async ({ activityId, expectedHeading }) => {
+      let resolveWcif!: (value: Competition) => void;
+      jest.mocked(fetchWcif).mockReturnValue(
+        new Promise((resolve) => {
+          resolveWcif = resolve;
+        }),
+      );
+
+      render(activityView(activityId));
+
+      expect(mockUseWcif.mock.results[0].value.isPlaceholderData).toBe(true);
+      expect(screen.getByRole('status')).toHaveTextContent('common.loading');
+      expect(screen.queryByRole('heading')).not.toBeInTheDocument();
+      expect(screen.queryByText('Remote bar')).not.toBeInTheDocument();
+
+      await act(async () => resolveWcif(competition));
+
+      expect(await screen.findByRole('heading', { name: expectedHeading })).toBeInTheDocument();
+      expect(screen.queryByRole('status')).not.toBeInTheDocument();
+      expect(screen.getByText('Remote bar')).toBeInTheDocument();
+    },
+  );
+
+  it('keeps real cached WCIF visible throughout a background refresh and its failure', async () => {
+    queryClient.setQueryData(['wcif', competitionId], competition);
+    let rejectWcif!: (error: Error) => void;
+    jest.mocked(fetchWcif).mockReturnValue(
+      new Promise((_, reject) => {
+        rejectWcif = reject;
+      }),
+    );
+
+    render(activityView());
+
+    expect(mockUseWcif.mock.results[0].value).toMatchObject({
+      isFetching: true,
+      isPlaceholderData: false,
+    });
+    expect(screen.getByRole('heading', { name: '3x3x3 Cube, Round 1' })).toBeInTheDocument();
+    expect(screen.queryByRole('status')).not.toBeInTheDocument();
+
+    await act(async () => rejectWcif(new Error('Offline')));
+
+    expect(await screen.findByRole('alert')).toHaveTextContent('competition.refreshError');
+    expect(screen.getByRole('heading', { name: '3x3x3 Cube, Round 1' })).toBeInTheDocument();
+    expect(screen.queryByRole('status')).not.toBeInTheDocument();
+    expect(screen.queryByText('competition.loadErrorHint')).not.toBeInTheDocument();
+    expect(screen.getByRole('button', { name: 'common.retry' })).toBeEnabled();
+  });
+
+  it('offers an actionable initial error and returns to loading until a retry supplies full WCIF', async () => {
+    jest.mocked(fetchWcif).mockRejectedValueOnce(new Error('Offline'));
+    render(activityView());
+
+    expect(await screen.findByRole('alert')).toHaveTextContent('competition.loadErrorHint');
+    expect(screen.getByRole('link', { name: 'common.home' })).toHaveAttribute('href', '/');
+    expect(screen.queryByRole('heading')).not.toBeInTheDocument();
+
+    let resolveWcif!: (value: Competition) => void;
+    jest.mocked(fetchWcif).mockReturnValue(
+      new Promise((resolve) => {
+        resolveWcif = resolve;
+      }),
+    );
+    fireEvent.click(screen.getByRole('button', { name: 'common.retry' }));
+
+    expect(await screen.findByRole('status')).toHaveTextContent('common.loading');
+    expect(screen.queryByRole('heading')).not.toBeInTheDocument();
+    expect(screen.queryByRole('alert')).not.toBeInTheDocument();
+
+    await act(async () => resolveWcif(competition));
+
+    expect(await screen.findByRole('heading', { name: '3x3x3 Cube, Round 1' })).toBeInTheDocument();
+    expect(screen.queryByRole('status')).not.toBeInTheDocument();
+    expect(screen.queryByRole('alert')).not.toBeInTheDocument();
+  });
+});
+
+it('keeps a loading status for placeholder-only data when fetching is paused', () => {
+  mockUseWcif.mockReturnValue({
+    data: { persons: [], events: [], schedule: { venues: [] } },
+    error: null,
+    dataUpdatedAt: 0,
+    isFetching: false,
+    isPlaceholderData: true,
+    refetch,
+  });
+  render(view());
+  expect(screen.getByRole('status')).toHaveTextContent('common.loading');
+  expect(screen.queryByText('Competition content')).not.toBeInTheDocument();
+  expect(screen.queryByText('Remote bar')).not.toBeInTheDocument();
+});
diff --git a/src/layouts/CompetitionLayout/CompetitionLayout.tsx b/src/layouts/CompetitionLayout/CompetitionLayout.tsx
index ced849f..0c13ee2 100644
--- a/src/layouts/CompetitionLayout/CompetitionLayout.tsx
+++ b/src/layouts/CompetitionLayout/CompetitionLayout.tsx
@@ -1,8 +1,7 @@
 import classNames from 'classnames';
-import { useEffect, useRef } from 'react';
 import { ErrorBoundary } from 'react-error-boundary';
 import { useTranslation } from 'react-i18next';
-import { Link, Outlet, useLocation, useParams } from 'react-router-dom';
+import { Link, Outlet, useParams } from 'react-router-dom';
 import { BarLoader } from 'react-spinners';
 import { ErrorFallback, LastFetchedAt, NoteBox, NotifyCompRemoteBar } from '@/components';
 import { Button } from '@/components/Button';
@@ -18,11 +17,12 @@ export function CompetitionLayout() {
   const { t } = useTranslation();
   const { online } = useApp();
   const { competitionId } = useParams();
-  const { pathname } = useLocation();
 
-  const ref = useRef<HTMLDivElement>(null);
-
-  const { data: wcif, dataUpdatedAt, isFetching, error, refetch } = useWcif(competitionId!);
+  const { data, dataUpdatedAt, isFetching, isPlaceholderData, error, refetch } = useWcif(
+    competitionId!,
+  );
+  // List placeholders contain competition metadata, but no activities or people yet.
+  const wcif = isPlaceholderData ? undefined : data;
 
   useCompetitionAnalytics(competitionId);
 
@@ -31,10 +31,6 @@ export function CompetitionLayout() {
     wcif: wcif,
   });
 
-  useEffect(() => {
-    ref.current?.scrollTo(0, 0);
-  }, [pathname]);
-
   const Header = (
     <nav className="z-10 flex justify-center w-full shadow-md shadow-tertiary-dark print:hidden bg-panel">
       <Container className="justify-between md:flex-row">
@@ -73,7 +69,12 @@ export function CompetitionLayout() {
         {isFetching ? <BarLoader width="100%" /> : <div style={{ height: '4px' }} />}
         <div
           className="safe-area-scroll-bottom flex flex-1 flex-col w-full items-center overflow-y-auto [scrollbar-gutter:stable;]"
-          ref={ref}>
+          data-scroll-restoration="competition">
+          {!wcif && (isFetching || isPlaceholderData) && (
+            <Container className="p-4">
+              <p role="status">{t('common.loading')}</p>
+            </Container>
+          )}
           {error && (
             <Container className="p-4 space-y-2">
               <div role="alert" className="space-y-2">
diff --git a/src/layouts/RootLayout/Header.test.tsx b/src/layouts/RootLayout/Header.test.tsx
new file mode 100644
index 0000000..b837099
--- /dev/null
+++ b/src/layouts/RootLayout/Header.test.tsx
@@ -0,0 +1,42 @@
+import { render, screen } from '@testing-library/react';
+import { MemoryRouter, Route, Routes } from 'react-router-dom';
+import Header from './Header';
+
+jest.mock('react-i18next', () => ({ useTranslation: () => ({ t: (key: string) => key }) }));
+jest.mock('@/providers/AuthProvider', () => ({ useAuth: () => ({ user: null }) }));
+jest.mock('@/providers/WCIFProvider', () => ({ useWCIF: () => ({}) }));
+jest.mock('@/lib/featureFlags', () => ({ FEATURE_FLAGS: {} }));
+jest.mock('@/hooks/queries/useCompetition', () => ({ useCompetition: () => ({}) }));
+jest.mock('@tanstack/react-query', () => ({
+  useQueryClient: () => ({ getQueryData: () => undefined, getQueriesData: () => [] }),
+}));
+it.each(['/', '/settings'])(
+  'names the Home and Settings links without a bogus competition link on %s',
+  (path) => {
+    render(
+      <MemoryRouter initialEntries={[path]}>
+        <Header />
+      </MemoryRouter>,
+    );
+    expect(screen.getByRole('link', { name: 'common.home' })).toHaveAttribute('href', '/');
+    expect(screen.getByRole('link', { name: 'header.settings' })).toHaveAttribute(
+      'href',
+      '/settings',
+    );
+    expect(screen.getAllByRole('link')).toHaveLength(2);
+    expect(screen.queryByRole('link', { name: '' })).not.toBeInTheDocument();
+  },
+);
+it('uses the competition ID as a nonempty name while the competition details load', () => {
+  render(
+    <MemoryRouter initialEntries={['/competitions/Loading2026']}>
+      <Routes>
+        <Route path="/competitions/:competitionId" element={<Header />} />
+      </Routes>
+    </MemoryRouter>,
+  );
+  expect(screen.getByRole('link', { name: 'Loading2026' })).toHaveAttribute(
+    'href',
+    '/competitions/Loading2026',
+  );
+});
diff --git a/src/layouts/RootLayout/Header.tsx b/src/layouts/RootLayout/Header.tsx
index b0cf4c2..677f9c0 100644
--- a/src/layouts/RootLayout/Header.tsx
+++ b/src/layouts/RootLayout/Header.tsx
@@ -21,7 +21,7 @@ export default function Header() {
   const { data: comp } = useCompetition(competitionId);
   const { wcif } = useWCIF();
 
-  const competitioName = useMemo(() => {
+  const competitionName = useMemo(() => {
     if (comp?.name) {
       return comp.name;
     }
@@ -55,13 +55,15 @@ export default function Header() {
   return (
     <header className="z-20 flex items-center w-full h-12 p-2 shadow-md print:hidden bg-panel">
       <div className="flex items-center space-x-1">
-        <Link to="/" className="link-inline">
-          <i className="fa fa-home" />
+        <Link to="/" className="link-inline" aria-label={t('common.home')}>
+          <i className="fa fa-home" aria-hidden="true" />
         </Link>
         {competitionId && <span className="text-tertiary">{' / '}</span>}
-        <Link to={`/competitions/${comp?.id || competitionId}`} className="link-inline">
-          {competitioName}
-        </Link>
+        {competitionId && (
+          <Link to={`/competitions/${competitionId}`} className="link-inline">
+            {competitionName || competitionId}
+          </Link>
+        )}
       </div>
       <div className="flex flex-1" />
       {user ? (
@@ -83,7 +85,7 @@ export default function Header() {
                 </Link>
               )}
               <Link to="/settings" className="block w-32 px-3 py-2 link-inline hover-bg-tertiary">
-                Settings
+                {t('header.settings')}
               </Link>
               <button
                 onClick={signOut}
@@ -103,8 +105,8 @@ export default function Header() {
           <button onClick={signIn} className="link-inline type-label text-primary">
             {t('common.login')}
           </button>
-          <Link to="/settings" className="link-inline">
-            <i className="fa fa-gear" />
+          <Link to="/settings" className="link-inline" aria-label={t('header.settings')}>
+            <i className="fa fa-gear" aria-hidden="true" />
           </Link>
         </div>
       )}
diff --git a/src/layouts/RootLayout/index.tsx b/src/layouts/RootLayout/index.tsx
index 27b16fd..fc0dd9c 100644
--- a/src/layouts/RootLayout/index.tsx
+++ b/src/layouts/RootLayout/index.tsx
@@ -1,17 +1,24 @@
+import { useRef } from 'react';
 import { ErrorBoundary } from 'react-error-boundary';
 import { Outlet } from 'react-router-dom';
 import { AppUpdatePrompt, ErrorFallback } from '@/components';
 import { usePWAUpdate } from '@/hooks/useRegisterSW/useRegisterSW';
+import { useSessionScrollRestoration } from '@/hooks/useSessionScrollRestoration/useSessionScrollRestoration';
 import Header from './Header';
 
 export function RootLayout() {
   const { updateAvailable, updateSW } = usePWAUpdate();
+  const mainRef = useRef<HTMLElement>(null);
+  useSessionScrollRestoration(mainRef);
 
   return (
     <div className="flex flex-col flex-1 full-viewport-height overflow-hidden bg-app">
       <Header />
       {updateAvailable && <AppUpdatePrompt onUpdate={updateSW} />}
-      <main className="flex flex-1 flex-col w-full items-center overflow-hidden">
+      <main
+        ref={mainRef}
+        data-scroll-restoration="root"
+        className="flex min-h-0 flex-1 flex-col w-full items-center overflow-y-auto">
         <ErrorBoundary FallbackComponent={ErrorFallback}>
           <Outlet />
         </ErrorBoundary>
diff --git a/src/lib/time.test.ts b/src/lib/time.test.ts
new file mode 100644
index 0000000..7795486
--- /dev/null
+++ b/src/lib/time.test.ts
@@ -0,0 +1,47 @@
+import { formatDateTimeRange, formmatDate } from './time';
+
+describe('venue-local date and time ranges', () => {
+  beforeEach(() => {
+    jest.spyOn(navigator, 'languages', 'get').mockReturnValue(['en-US']);
+    jest.spyOn(navigator, 'language', 'get').mockReturnValue('en-US');
+  });
+
+  afterEach(() => jest.restoreAllMocks());
+
+  it('shows the Campulung venue time and preserves five-minute rounding', () => {
+    expect(
+      formatDateTimeRange('2026-10-31T07:00:00Z', '2026-10-31T07:22:30Z', 5, 'Europe/Bucharest'),
+    ).toBe('Sat 09:00 AM - 09:25 AM');
+  });
+
+  it('shows Saturday for Concours even when the viewer is still on Friday', () => {
+    expect(
+      formatDateTimeRange('2026-10-31T03:15:00Z', '2026-10-31T03:55:00Z', 5, 'Asia/Calcutta'),
+    ).toBe('Sat 08:45 AM - 09:25 AM');
+    expect(formmatDate('2026-10-31T03:15:00Z', 5, 'Asia/Calcutta')).toBe('Sat');
+  });
+
+  it('repeats weekdays when a range crosses venue midnight but not viewer midnight', () => {
+    expect(
+      formatDateTimeRange('2026-10-31T18:00:00Z', '2026-10-31T19:00:00Z', 5, 'Asia/Calcutta'),
+    ).toBe('Sat 11:30 PM - Sun 12:30 AM');
+  });
+
+  it('uses one weekday when a range crosses UTC midnight but not venue midnight', () => {
+    expect(
+      formatDateTimeRange('2026-10-30T23:30:00Z', '2026-10-31T00:30:00Z', 5, 'Asia/Calcutta'),
+    ).toBe('Sat 05:00 AM - 06:00 AM');
+  });
+
+  it('compares dates after rounding across midnight', () => {
+    expect(
+      formatDateTimeRange('2026-10-31T18:29:00Z', '2026-10-31T18:40:00Z', 5, 'Asia/Calcutta'),
+    ).toBe('Sun 12:00 AM - 12:10 AM');
+  });
+
+  it('uses the requested rounding interval for the weekday as well as the time', () => {
+    expect(
+      formatDateTimeRange('2026-10-31T18:29:00Z', '2026-10-31T18:30:00Z', 1, 'Asia/Calcutta'),
+    ).toBe('Sat 11:59 PM - Sun 12:00 AM');
+  });
+});
diff --git a/src/lib/time.ts b/src/lib/time.ts
index cd966c3..f7e06af 100644
--- a/src/lib/time.ts
+++ b/src/lib/time.ts
@@ -21,9 +21,10 @@ export const formatTime = (isoString: string, minutes: number = 5, timeZone?: st
     }),
   });
 
-export const formmatDate = (isoString: string, minutes: number = 5) =>
+export const formmatDate = (isoString: string, minutes: number = 5, timeZone?: string) =>
   roundTime(new Date(isoString), minutes).toLocaleDateString([...navigator.languages], {
     weekday: 'short',
+    timeZone,
   });
 
 export const formatDateTime = (isoString: string, minutes: number = 5, timeZone?: string) =>
@@ -48,11 +49,12 @@ export const formatDateTimeRange = (
   minutes: number = 5,
   timeZone?: string,
 ) => {
-  const startDate = new Date(start);
-  const endDate = new Date(end);
+  const startDate = roundTime(new Date(start), minutes);
+  const endDate = roundTime(new Date(end), minutes);
+  const dateFormatter = getNumericDateFormatter(timeZone);
 
-  if (startDate.toLocaleDateString() === endDate.toLocaleDateString()) {
-    return `${formmatDate(start)} ${formatTimeRange(start, end, minutes, timeZone)}`;
+  if (dateFormatter.format(startDate) === dateFormatter.format(endDate)) {
+    return `${formmatDate(start, minutes, timeZone)} ${formatTimeRange(start, end, minutes, timeZone)}`;
   }
 
   return `${formatDateTime(start, minutes, timeZone)} - ${formatDateTime(end, minutes, timeZone)}`;
diff --git a/src/pages/Home/Home.test.tsx b/src/pages/Home/Home.test.tsx
new file mode 100644
index 0000000..5ad61c6
--- /dev/null
+++ b/src/pages/Home/Home.test.tsx
@@ -0,0 +1,69 @@
+import { act, render, screen } from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
+import { MemoryRouter, Route, Routes, useNavigate } from 'react-router-dom';
+import { fetchSearchCompetition } from '@/lib/api';
+import Home from './index';
+
+jest.mock('@/lib/api', () => ({ fetchSearchCompetition: jest.fn() }));
+jest.mock('@/providers/UserSettingsProvider', () => ({
+  useUserSettings: () => ({ effectiveTheme: 'light' }),
+}));
+jest.mock('react-i18next', () => ({ useTranslation: () => ({ t: (key: string) => key }) }));
+jest.mock('@/providers/AuthProvider', () => ({ useAuth: () => ({ user: {}, signIn: jest.fn() }) }));
+jest.mock('@/containers/MyCompetitions', () => ({ MyCompetitions: () => null }));
+jest.mock('@/containers/UpcomingCompetitions/UpcomingCompetitions', () => ({
+  __esModule: true,
+  default: () => null,
+}));
+jest.mock('@/components/LoggedOutPromptCard', () => ({ LoggedOutPromptCard: () => null }));
+function Competition() {
+  const navigate = useNavigate();
+  return (
+    <>
+      <p>Opened competition</p>
+      <button onClick={() => navigate(-1)}>Back</button>
+    </>
+  );
+}
+it('opens the selected competition with the keyboard, then supports Back and another selection', async () => {
+  jest.mocked(fetchSearchCompetition).mockResolvedValue({
+    result: [
+      {
+        id: 'Campulung2026',
+        name: 'Campulung Moldovenesc Open 2026',
+        start_date: '2026-10-31',
+        end_date: '2026-10-31',
+        country_iso2: 'RO',
+        city: 'Campulung',
+      } as ApiCompetition,
+    ],
+  });
+  render(
+    <MemoryRouter>
+      <Routes>
+        <Route path="/" element={<Home />} />
+        <Route path="/competitions/Campulung2026" element={<Competition />} />
+      </Routes>
+    </MemoryRouter>,
+  );
+  await act(async () => {
+    await userEvent.type(screen.getByRole('combobox'), 'Campulung');
+  });
+  await screen.findByText('Campulung Moldovenesc Open 2026');
+  await act(async () => {
+    await userEvent.keyboard('{ArrowDown}{Enter}');
+  });
+  expect(screen.getByText('Opened competition')).toBeInTheDocument();
+  await act(async () => {
+    await userEvent.click(screen.getByRole('button', { name: 'Back' }));
+  });
+  expect(screen.getByRole('combobox')).toHaveValue('');
+  await act(async () => {
+    await userEvent.type(screen.getByRole('combobox'), 'Campulung');
+  });
+  const option = await screen.findByText('Campulung Moldovenesc Open 2026');
+  await act(async () => {
+    await userEvent.click(option);
+  });
+  expect(screen.getByText('Opened competition')).toBeInTheDocument();
+});
diff --git a/src/pages/Home/index.tsx b/src/pages/Home/index.tsx
index 55e48a3..1827696 100644
--- a/src/pages/Home/index.tsx
+++ b/src/pages/Home/index.tsx
@@ -1,6 +1,6 @@
 import { useEffect } from 'react';
 import { useTranslation } from 'react-i18next';
-import { Link } from 'react-router-dom';
+import { Link, useNavigate } from 'react-router-dom';
 import { CompetitionSelect } from '@/components/CompetitionSelect';
 import { Container } from '@/components/Container';
 import { LoggedOutPromptCard } from '@/components/LoggedOutPromptCard';
@@ -10,6 +10,7 @@ import { useAuth } from '@/providers/AuthProvider';
 
 export default function Home() {
   const { t } = useTranslation();
+  const navigate = useNavigate();
   const { user, signIn } = useAuth();
 
   useEffect(() => {
@@ -17,7 +18,9 @@ export default function Home() {
   }, [t]);
 
   return (
-    <div className="safe-area-scroll-bottom flex flex-col items-center w-full overflow-auto">
+    <div
+      data-scroll-restoration="page"
+      className="safe-area-scroll-bottom flex flex-col items-center w-full overflow-auto">
       <Container className="mt-2 space-y-2">
         <div className="flex flex-col w-full px-6 md:px-6 type-body">
           <p className="type-body-sm">{t('home.subtitle')}</p>
@@ -32,7 +35,7 @@ export default function Home() {
         {!user && <LoggedOutPromptCard onLogin={signIn} />}
         <MyCompetitions />
         <div className="px-2">
-          <CompetitionSelect onSelect={(e) => console.log(e)} />
+          <CompetitionSelect onSelect={(id) => navigate(`/competitions/${id}`)} />
         </div>
         <UpcomingCompetitions />
       </Container>
diff --git a/src/pages/LiveActivities/About.tsx b/src/pages/LiveActivities/About.tsx
index d07258a..598b683 100644
--- a/src/pages/LiveActivities/About.tsx
+++ b/src/pages/LiveActivities/About.tsx
@@ -26,7 +26,9 @@ export default function LiveActivitiesAbout() {
   }, []);
 
   return (
-    <Container className="safe-area-scroll-bottom min-h-0 flex-1 overflow-y-auto px-4 pt-8">
+    <Container
+      scrollRestorationId="page"
+      className="safe-area-scroll-bottom min-h-0 flex-1 overflow-y-auto px-4 pt-8">
       <div className="space-y-8">
         <section className="space-y-4">
           <div className="space-y-2">
diff --git a/src/pages/User/index.tsx b/src/pages/User/index.tsx
index 98cadcb..78ded90 100644
--- a/src/pages/User/index.tsx
+++ b/src/pages/User/index.tsx
@@ -114,7 +114,9 @@ export default function UserPage() {
 
   if (!user) {
     return (
-      <div className="safe-area-scroll-bottom flex min-h-0 w-full flex-1 justify-center overflow-y-auto">
+      <div
+        data-scroll-restoration="page"
+        className="safe-area-scroll-bottom flex min-h-0 w-full flex-1 justify-center overflow-y-auto">
         <Container className="px-4 py-8">
           <p className="type-body">Please log in to view your profile.</p>
         </Container>
@@ -123,7 +125,9 @@ export default function UserPage() {
   }
 
   return (
-    <div className="safe-area-scroll-bottom flex min-h-0 w-full flex-1 justify-center overflow-y-auto">
+    <div
+      data-scroll-restoration="page"
+      className="safe-area-scroll-bottom flex min-h-0 w-full flex-1 justify-center overflow-y-auto">
       <Container className="space-y-4 p-2 pt-4">
         <ProfileHeader countryIso2={recordsQuery.data?.person.country_iso2} user={user} />
         <ProfileTabs activeTab={tab} />