diff --git a/__mocks__/platform-bible-react.tsx b/__mocks__/platform-bible-react.tsx
index c4776c75..e4d70fbb 100644
--- a/__mocks__/platform-bible-react.tsx
+++ b/__mocks__/platform-bible-react.tsx
@@ -687,9 +687,10 @@ export function RadioGroupItem({
  * Faithful in three ways the extension depends on. The trigger shows `customSelectedText` when the
  * caller supplies one and the bare `placeholder` otherwise — the real component never lists the
  * selection itself, so a caller that wants the selection named has to name it. An entry is resolved
- * by its label, so two entries sharing a label collide, and one whose `value` is empty can never be
- * selected at all. And `id` lands on the root; the stub additionally mirrors it to `data-testid`,
- * since Testing Library has no by-id query and a test needs to scope to one of several controls.
+ * by its label as the command list reports it, which is trimmed, so two entries whose labels agree
+ * once trimmed collide, and one whose `value` is empty can never be selected at all. And `id` lands
+ * on the root; the stub additionally mirrors it to `data-testid`, since Testing Library has no
+ * by-id query and a test needs to scope to one of several controls.
  */
 export function MultiSelectComboBox({
   entries,
@@ -732,11 +733,16 @@ export function MultiSelectComboBox({
         {entries.map((entry) => (
           <button
             aria-selected={selected.includes(entry.value)}
-            key={entry.label}
-            // Resolving the entry by label, as the real component's own select handler does, so a
-            // stub test cannot pass on a collision the real component would drop.
+            // Keyed by value where the real component keys by label, so a caller offering two
+            // choices under one label is left to the assertions rather than buried under React's
+            // own complaint about it.
+            key={entry.value}
+            // Resolving the entry by the label the command list reports back, as the real
+            // component's own select handler does, so a stub test cannot pass on a collision the
+            // real component would drop.
             onClick={() => {
-              const match = entries.find((candidate) => candidate.label === entry.label);
+              const reported = entry.label.trim();
+              const match = entries.find((candidate) => candidate.label === reported);
               if (match?.value) toggle(match.value);
             }}
             role="option"
diff --git a/src/__tests__/components/AnalysisCatalogPanel.test.tsx b/src/__tests__/components/AnalysisCatalogPanel.test.tsx
index efa08df5..a9b19f63 100644
--- a/src/__tests__/components/AnalysisCatalogPanel.test.tsx
+++ b/src/__tests__/components/AnalysisCatalogPanel.test.tsx
@@ -1,6 +1,7 @@
 /// <reference types="jest" />
 /// <reference types="@testing-library/jest-dom" />
 
+import { useSetting } from '@papi/frontend/react';
 import type { SerializedVerseRef } from '@sillsdev/scripture';
 import { act, render, screen, within } from '@testing-library/react';
 import userEvent from '@testing-library/user-event';
@@ -22,6 +23,21 @@ declare global {
   var triggerIntersection: (el: Element, isIntersecting: boolean) => void;
 }
 
+/**
+ * Configures `useSetting` to report the given interface languages, most preferred first, for
+ * `platform.interfaceLanguage` — the only setting the panel reads.
+ *
+ * @throws {Error} When `useSetting` is called with any other key (message: `useSetting mock:
+ *   unexpected key "<key>"`).
+ */
+function mockInterfaceLanguage(interfaceLanguage: string[] = ['und']): void {
+  jest.mocked(useSetting).mockImplementation((key: string) => {
+    if (key === 'platform.interfaceLanguage')
+      return [interfaceLanguage, jest.fn(), jest.fn(), false];
+    throw new Error(`useSetting mock: unexpected key "${key}"`);
+  });
+}
+
 /** Builds a link from `tokenRef` to the analysis, approved unless another status is given. */
 function link(
   analysisId: string,
@@ -193,6 +209,7 @@ describe('AnalysisCatalogPanel', () => {
     claimedFocusRequest = undefined;
     editGloss = () => {};
     mockKeyAsValueLocalizedStrings();
+    mockInterfaceLanguage();
   });
 
   describe('rows', () => {
@@ -634,6 +651,112 @@ describe('AnalysisCatalogPanel', () => {
       expect(listedAnalysisIds()).toEqual(['marked']);
     });
 
+    it('offers a value recorded with surrounding whitespace under a name that can be chosen', async () => {
+      const analysis: TextAnalysis = {
+        ...emptyAnalysis(),
+        tokenAnalyses: [
+          // A part of speech is free-form and reaches the draft as its source system recorded it,
+          // so it can carry whitespace the control trims off the name it reports back — leaving a
+          // choice the control cannot resolve unless it was offered under the trimmed spelling.
+          { ...FIXTURE_STAMPS, id: 'padded', surfaceText: 'λόγος', pos: ' noun ' },
+          { ...FIXTURE_STAMPS, id: 'verb', surfaceText: 'ἦν', pos: 'verb' },
+        ],
+        tokenAnalysisLinks: [link('padded', 'GEN 1:1:0'), link('verb', 'GEN 1:2:0')],
+      };
+      renderPanel({ analysis });
+      await openFilters();
+
+      await userEvent.click(screen.getByRole('option', { name: 'noun' }));
+
+      expect(listedAnalysisIds()).toEqual(['padded']);
+    });
+
+    it('offers a marking that pads what it wraps under a name that can be chosen', async () => {
+      mockKeyAsValueLocalizedStrings({
+        '%interlinearizer_analysisCatalog_filter_recordedValue%': '  {value} (recorded value)  ',
+      });
+      const analysis: TextAnalysis = {
+        ...emptyAnalysis(),
+        tokenAnalyses: [
+          // These agree once trimmed, so one has to be marked. Choices are offered in the order the
+          // values sort in, where the leading space sorts first — leaving the padded value under
+          // the plain name and this one under the marking.
+          { ...FIXTURE_STAMPS, id: 'plain', surfaceText: 'λόγος', pos: 'noun' },
+          { ...FIXTURE_STAMPS, id: 'padded', surfaceText: 'ἦν', pos: ' noun ' },
+        ],
+        tokenAnalysisLinks: [link('plain', 'GEN 1:1:0'), link('padded', 'GEN 1:2:0')],
+      };
+      renderPanel({ analysis });
+      await openFilters();
+
+      await userEvent.click(screen.getByRole('option', { name: 'noun (recorded value)' }));
+
+      expect(listedAnalysisIds()).toEqual(['plain']);
+    });
+
+    it('tells a value recorded as whitespace apart from one recorded as empty', async () => {
+      mockKeyAsValueLocalizedStrings({
+        '%interlinearizer_analysisCatalog_filter_empty%': '(empty)',
+        '%interlinearizer_analysisCatalog_filter_recordedValue%': '{value} (recorded value)',
+      });
+      const analysis: TextAnalysis = {
+        ...emptyAnalysis(),
+        tokenAnalyses: [
+          { ...FIXTURE_STAMPS, id: 'blank', surfaceText: 'λόγος', pos: '' },
+          // Nothing is left of this once trimmed, so it has no name of its own to be offered under.
+          { ...FIXTURE_STAMPS, id: 'spaces', surfaceText: 'ἦν', pos: '   ' },
+        ],
+        tokenAnalysisLinks: [link('blank', 'GEN 1:1:0'), link('spaces', 'GEN 1:2:0')],
+      };
+      renderPanel({ analysis });
+      await openFilters();
+
+      await userEvent.click(screen.getByRole('option', { name: '(empty) (recorded value)' }));
+
+      expect(listedAnalysisIds()).toEqual(['spaces']);
+    });
+
+    it('stops marking a value rather than spinning when the marking cannot tell it apart', async () => {
+      // A localization that drops `{value}` leaves the marking spelling whatever name it was given,
+      // so repeating it can never clear a collision. Two choices then share a name and one of them
+      // is unselectable — but the panel renders, where a render that never returns takes the whole
+      // WebView down with it.
+      mockKeyAsValueLocalizedStrings({
+        '%interlinearizer_analysisCatalog_filter_untagged%': '(none)',
+        '%interlinearizer_analysisCatalog_filter_recordedValue%': '{value}',
+      });
+      const analysis: TextAnalysis = {
+        ...emptyAnalysis(),
+        tokenAnalyses: [
+          { ...FIXTURE_STAMPS, id: 'named', surfaceText: 'λόγος', pos: '(none)' },
+          { ...FIXTURE_STAMPS, id: 'untagged', surfaceText: 'ἦν' },
+        ],
+        tokenAnalysisLinks: [link('named', 'GEN 1:1:0'), link('untagged', 'GEN 1:2:0')],
+      };
+      renderPanel({ analysis });
+
+      await openFilters();
+
+      expect(screen.getAllByRole('option', { name: '(none)' })).toHaveLength(2);
+    });
+
+    it('names the language the missing-gloss filter asks about, in the interface language', async () => {
+      mockInterfaceLanguage(['es']);
+      mockKeyAsValueLocalizedStrings({
+        '%interlinearizer_analysisCatalog_filter_missingGloss%': 'Missing gloss in {language}',
+      });
+      renderPanel({ analysis: PER_BOOK, analysisLanguage: 'fr' });
+
+      await openFilters();
+
+      // A reader who never chose the tag has no reason to recognize it, and a name taken from the
+      // host's own locale would read in one language beside a label resolved in another — the
+      // platform's interface language being a setting the host locale does not follow.
+      expect(
+        screen.getByRole('checkbox', { name: 'Missing gloss in francés' }),
+      ).toBeInTheDocument();
+    });
+
     it('narrows the list to the analyses carrying a chosen part of speech', async () => {
       const analysis: TextAnalysis = {
         ...emptyAnalysis(),
@@ -911,6 +1034,13 @@ describe('AnalysisCatalogPanel', () => {
       ),
     };
 
+    /** The scrolling list, reached through the sentinel it holds as its last child. */
+    function rowList(): HTMLElement {
+      const list = screen.getByTestId('catalog-rows-sentinel').parentElement;
+      if (!list) throw new Error('the row sentinel is outside a list');
+      return list;
+    }
+
     /** Reports the end of the list as having come into view. */
     function reachListEnd(): void {
       act(() => {
@@ -948,6 +1078,29 @@ describe('AnalysisCatalogPanel', () => {
       expect(screen.getAllByTestId('catalog-row').length).toBeLessThan(grown);
     });
 
+    it('returns the list to its top when the query changes', async () => {
+      renderPanel({ analysis: MANY });
+      const list = rowList();
+      list.scrollTop = 500;
+
+      // Matches every row, so the listing is the same length as before — only the window resets.
+      await userEvent.type(searchBox(), 'word');
+
+      // The list is the same element throughout, so it holds the offset it was left at until it is
+      // put back, landing a reader who narrowed a deeply scrolled list part way down a new one.
+      expect(list.scrollTop).toBe(0);
+    });
+
+    it('leaves the scroll where it is when the analysis changes under an unchanged query', () => {
+      renderPanelWithGlossEditing({ analysis: MANY });
+      const list = rowList();
+      list.scrollTop = 500;
+
+      act(() => editGloss('GEN 1:1:0', 'word0', 'beginning'));
+
+      expect(list.scrollTop).toBe(500);
+    });
+
     it('keeps the window where it is when the analysis changes under an unchanged query', () => {
       // A gloss approved in the view beside an open catalog rebuilds every row without narrowing
       // anything, and collapsing a deeply scrolled list back to its first chunk on that would throw
diff --git a/src/__tests__/utils/language-tags.test.ts b/src/__tests__/utils/language-tags.test.ts
index 74608641..c51b63e2 100644
--- a/src/__tests__/utils/language-tags.test.ts
+++ b/src/__tests__/utils/language-tags.test.ts
@@ -1,6 +1,6 @@
 /// <reference types="jest" />
 
-import { collatorForTag } from '../../utils/language-tags';
+import { collatorForTag, languageNameForTag } from '../../utils/language-tags';
 
 describe('collatorForTag', () => {
   it('collates under the tag it is given', () => {
@@ -15,3 +15,36 @@ describe('collatorForTag', () => {
     expect(collatorForTag('en_US').compare('a', 'b')).toBeLessThan(0);
   });
 });
+
+describe('languageNameForTag', () => {
+  it('names the language a tag stands for', () => {
+    // Held against the tag rather than against a spelling: the name comes back in whatever
+    // language the host is running in, which a test cannot pin.
+    expect(languageNameForTag('fr')).not.toBe('fr');
+  });
+
+  it('names the language in the interface languages it is given', () => {
+    expect(languageNameForTag('fr', ['es'])).toBe('francés');
+  });
+
+  it('names the language in a usable interface language behind one Intl rejects', () => {
+    // `Intl` rejects a whole list for any one entry it cannot parse, where the platform resolves a
+    // localized string by walking past the locales it has nothing for — so dropping the list would
+    // read a name in one language beside a label resolved in another.
+    expect(languageNameForTag('fr', ['en_US', 'es'])).toBe('francés');
+  });
+
+  it('names the language anyway when every interface language is one Intl rejects', () => {
+    // Losing the language a name is read in costs less than losing the name.
+    expect(languageNameForTag('fr', ['en_US'])).not.toBe('fr');
+  });
+
+  it('gives back a tag naming no language it knows', () => {
+    // The private-use range every unlisted language is assigned from, so no host has a name for it.
+    expect(languageNameForTag('qaa')).toBe('qaa');
+  });
+
+  it('gives back a tag Intl rejects', () => {
+    expect(languageNameForTag('en_US')).toBe('en_US');
+  });
+});
diff --git a/src/components/AnalysisCatalogPanel.tsx b/src/components/AnalysisCatalogPanel.tsx
index 09868e01..07e93344 100644
--- a/src/components/AnalysisCatalogPanel.tsx
+++ b/src/components/AnalysisCatalogPanel.tsx
@@ -1,8 +1,8 @@
-import { useLocalizedStrings } from '@papi/frontend/react';
+import { useLocalizedStrings, useSetting } from '@papi/frontend/react';
 import { Canon } from '@sillsdev/scripture';
 import { X } from 'lucide-react';
 import { Button, EmptyState, TooltipProvider } from 'platform-bible-react';
-import { formatReplacementString } from 'platform-bible-utils';
+import { formatReplacementString, isPlatformError } from 'platform-bible-utils';
 import { useCallback, useMemo, useState } from 'react';
 import { useAnalysisLanguage, useCatalogRows } from './AnalysisStore';
 import CatalogQueryControls, { QUERY_CONTROL_STRING_KEYS } from './CatalogQueryControls';
@@ -17,7 +17,7 @@ import {
   type CatalogSort,
   type CatalogUsage,
 } from '../utils/analysis-query';
-import { collatorForTag } from '../utils/language-tags';
+import { collatorForTag, languageNameForTag } from '../utils/language-tags';
 
 /**
  * Localized string keys the panel needs, the rows' among them so the list resolves once rather than
@@ -133,6 +133,23 @@ export default function AnalysisCatalogPanel({
    */
   const facets = useMemo(() => deriveFacets(catalogRows), [catalogRows]);
 
+  const [interfaceLanguages] = useSetting('platform.interfaceLanguage', ['und']);
+
+  /**
+   * What the analysis language is called, for the filter that asks after a missing gloss to name it
+   * in prose: the question is about a language rather than about a code, and a reader who never
+   * chose the tag has no reason to recognize it.
+   *
+   * Named in the interface's own languages rather than the host's, which the platform's interface
+   * language does not follow — a name resolved against the host would read in one language beside a
+   * label resolved in another.
+   */
+  const analysisLanguageName = useMemo(() => {
+    /* v8 ignore next -- useSetting never returns PlatformError for this key in practice */
+    const locales = isPlatformError(interfaceLanguages) ? undefined : interfaceLanguages;
+    return languageNameForTag(analysisLanguage, locales);
+  }, [analysisLanguage, interfaceLanguages]);
+
   /**
    * The slice of the listing that is actually mounted. A draft accumulates analyses without bound
    * and every row carries its own expander and usage list, so the list grows as it is scrolled
@@ -201,7 +218,7 @@ export default function AnalysisCatalogPanel({
         */}
         {catalogRows.length > 0 && (
           <CatalogQueryControls
-            analysisLanguage={analysisLanguage}
+            analysisLanguageName={analysisLanguageName}
             currentBookName={currentBookName}
             facets={facets}
             filters={filters}
diff --git a/src/components/CatalogFilterPopover.tsx b/src/components/CatalogFilterPopover.tsx
index 6a7ddd0d..91a7921f 100644
--- a/src/components/CatalogFilterPopover.tsx
+++ b/src/components/CatalogFilterPopover.tsx
@@ -137,8 +137,11 @@ function FacetFilter<T extends string>({
   labelFor,
   id,
 }: FacetFilterProps<T>) {
-  const untaggedLabel = localizedStrings['%interlinearizer_analysisCatalog_filter_untagged%'];
-  const emptyLabel = localizedStrings['%interlinearizer_analysisCatalog_filter_empty%'];
+  // Trimmed, as every label here is: the platform control resolves a choice by its label and trims
+  // what it hands back, so a label with surrounding whitespace names a choice it can never resolve.
+  const untaggedLabel =
+    localizedStrings['%interlinearizer_analysisCatalog_filter_untagged%'].trim();
+  const emptyLabel = localizedStrings['%interlinearizer_analysisCatalog_filter_empty%'].trim();
 
   /**
    * The choices to offer: the field's own, plus any still selected that it no longer lists. An edit
@@ -160,7 +163,13 @@ function FacetFilter<T extends string>({
     offered.map((choice) => [valueOf(choice), choice]),
   );
 
-  const nameOfValue = (choice: T) => (labelFor ? labelFor(choice) : choice);
+  /**
+   * What a recorded value is called before any marking that tells it apart from another choice.
+   *
+   * A value that is nothing but whitespace has no name of its own and so borrows the empty value's,
+   * the marking below being what tells those two apart.
+   */
+  const nameOfValue = (choice: T) => (labelFor ? labelFor(choice) : choice).trim() || emptyLabel;
 
   /**
    * What each offered choice is called, no two alike: the platform control cannot tell two options
@@ -179,11 +188,16 @@ function FacetFilter<T extends string>({
     if (choice === undefined) return labelByChoice.set(choice, untaggedLabel);
     if (choice === '') return labelByChoice.set(choice, emptyLabel);
     let name = nameOfValue(choice);
-    while (claimed.has(name)) {
+    // Bounded by the names already claimed: that many rounds of a marking that moves the name
+    // produce more distinct spellings than there are names to collide with, so only one leaving
+    // the name where it was reaches the bound — and spinning there would hang the panel.
+    for (let round = 0; claimed.has(name) && round < claimed.size; round += 1) {
+      // Trimmed because a marking is free to pad what it wraps, and an untrimmed name is both
+      // unselectable and what the next round collides against.
       name = formatReplacementString(
         localizedStrings['%interlinearizer_analysisCatalog_filter_recordedValue%'],
         { value: name },
-      );
+      ).trim();
     }
     claimed.add(name);
     return labelByChoice.set(choice, name);
@@ -252,8 +266,8 @@ type CatalogFilterPopoverProps = Readonly<{
   filters: CatalogFilters;
   /** Records a new set of filters. */
   onFiltersChange: (filters: CatalogFilters) => void;
-  /** BCP 47 tag the missing-gloss filter asks about, named in its label. */
-  analysisLanguage: string;
+  /** What the language the missing-gloss filter asks about is called, as its label names it. */
+  analysisLanguageName: string;
   /** Resolved localizations covering at least {@link FILTER_STRING_KEYS}. */
   localizedStrings: LanguageStrings;
 }>;
@@ -270,7 +284,7 @@ export default function CatalogFilterPopover({
   facets,
   filters,
   onFiltersChange,
-  analysisLanguage,
+  analysisLanguageName,
   localizedStrings,
 }: CatalogFilterPopoverProps) {
   const [isOpen, setIsOpen] = useState(false);
@@ -426,7 +440,7 @@ export default function CatalogFilterPopover({
             isOn={filters.missingGloss ?? false}
             label={formatReplacementString(
               localizedStrings['%interlinearizer_analysisCatalog_filter_missingGloss%'],
-              { language: analysisLanguage },
+              { language: analysisLanguageName },
             )}
             onChange={(missingGloss) => onFiltersChange({ ...filters, missingGloss })}
           />
diff --git a/src/components/CatalogQueryControls.tsx b/src/components/CatalogQueryControls.tsx
index e7452116..61bdac42 100644
--- a/src/components/CatalogQueryControls.tsx
+++ b/src/components/CatalogQueryControls.tsx
@@ -50,8 +50,8 @@ type CatalogQueryControlsProps = Readonly<{
   filters: CatalogFilters;
   /** Records a new set of filters. */
   onFiltersChange: (filters: CatalogFilters) => void;
-  /** BCP 47 tag the missing-gloss filter asks about. */
-  analysisLanguage: string;
+  /** What the language the missing-gloss filter asks about is called. */
+  analysisLanguageName: string;
   /** What the current book is called, as prose, for the per-book sort to be named after. */
   currentBookName: string;
   /** Resolved localizations covering at least {@link QUERY_CONTROL_STRING_KEYS}. */
@@ -74,7 +74,7 @@ export default function CatalogQueryControls({
   facets,
   filters,
   onFiltersChange,
-  analysisLanguage,
+  analysisLanguageName,
   currentBookName,
   localizedStrings,
 }: CatalogQueryControlsProps) {
@@ -117,7 +117,7 @@ export default function CatalogQueryControls({
         </Select>
 
         <CatalogFilterPopover
-          analysisLanguage={analysisLanguage}
+          analysisLanguageName={analysisLanguageName}
           facets={facets}
           filters={filters}
           localizedStrings={localizedStrings}
diff --git a/src/hooks/usePanelResizeKeys.ts b/src/hooks/usePanelResizeKeys.ts
index f39fabbe..7f54b257 100644
--- a/src/hooks/usePanelResizeKeys.ts
+++ b/src/hooks/usePanelResizeKeys.ts
@@ -68,17 +68,17 @@ export default function usePanelResizeKeys(
       if (event.ctrlKey || event.metaKey || event.altKey) return;
 
       const { travel, step } = keyTravel(event.key);
-      // Bound for the press, so the direction it is turned away for is the one it is resized by.
-      const widen = widenTravel();
       // Left alone in a left-to-right interface, where the platform handle already reads these
       // keys the way the panel is pointing; stepping here as well would move it twice.
-      if (travel === 0 || widen !== 1) return;
+      if (travel === 0 || widenTravel() !== 1) return;
 
       // Claims the press before the platform's own handler sees it, that handler starting by
       // returning on an event already defaulted.
       event.preventDefault();
 
-      const next = Math.min(100, Math.max(0, percentage + travel * widen * step));
+      // Past the gate the handle widens toward the screen's right, so a key traveling that way
+      // widens the panel and one traveling the other narrows it.
+      const next = Math.min(100, Math.max(0, percentage + travel * step));
       // A key pressed at the end of the range it moves toward — an arrow held down there repeating,
       // or a jump key aimed at it — would otherwise put an unchanged layout through the store.
       if (next !== percentage) onPercentageChange(next);
diff --git a/src/hooks/useRowWindow.ts b/src/hooks/useRowWindow.ts
index d73e109a..96424785 100644
--- a/src/hooks/useRowWindow.ts
+++ b/src/hooks/useRowWindow.ts
@@ -1,4 +1,4 @@
-import { useCallback, useEffect, useMemo, useState } from 'react';
+import { useCallback, useEffect, useLayoutEffect, useMemo, useState } from 'react';
 
 /**
  * How many rows are mounted before the list has been scrolled at all. Deliberately small: the
@@ -31,16 +31,17 @@ export interface UseRowWindowResult<T> {
  * the end of the mounted rows comes within reach of the scroll.
  *
  * Grow-only and anchored to nothing: the window has no notion of where in the list the reader is,
- * so it never culls from the top and never adjusts the scroll position. A row list has no
- * counterpart to the scripture reference a segment window has to hold still, so it needs none of
- * that geometry bookkeeping.
+ * so it never culls from the top and never compensates the scroll for a change in height. A row
+ * list has no counterpart to the scripture reference a segment window has to hold still, so it
+ * needs none of that geometry bookkeeping.
  *
- * The window starts over whenever `query` is a different value, compared by reference: a reader who
- * has scrolled deep into one listing and then narrows it is looking at a new list, not further down
- * the old one. A caller passes whatever it narrows and orders its rows by, and one whose listing
- * never narrows passes nothing. Keyed on that rather than on `rows`, which turns over on any edit
- * to the underlying analysis as well — a gloss approved in the view beside an open catalog would
- * otherwise collapse a deeply scrolled list back to its first chunk.
+ * The window starts over, and the list returns to its top, whenever `query` is a different value,
+ * compared by reference: a reader who has scrolled deep into one listing and then narrows it is
+ * looking at a new list, not further down the old one. A caller passes whatever it narrows and
+ * orders its rows by, and one whose listing never narrows passes nothing. Keyed on that rather than
+ * on `rows`, which turns over on any edit to the underlying analysis as well — a gloss approved in
+ * the view beside an open catalog would otherwise collapse a deeply scrolled list back to its first
+ * chunk.
  */
 export default function useRowWindow<T>(
   rows: readonly T[],
@@ -69,15 +70,20 @@ export default function useRowWindow<T>(
   const scrollRef = useCallback((el: HTMLElement | null) => setScrollEl(el ?? undefined), []);
   const sentinelRef = useCallback((el: HTMLElement | null) => setSentinelEl(el ?? undefined), []);
 
+  // The count reset alone leaves the offset where it was, merely clamped to the shorter content.
+  // Before paint rather than after, so the list is never shown at the old offset first.
+  useLayoutEffect(() => {
+    if (scrollEl) scrollEl.scrollTop = 0;
+  }, [countedQuery, scrollEl]);
+
   // Extend the window each time the sentinel is reported within reach. Re-subscribes on every count
   // change as well as on the elements', because an IntersectionObserver reports only intersection
   // *transitions*: after an extend the sentinel node is unchanged and may still sit inside the arming
   // margin, where a stale observer would stay silent however far the reader scrolls. A fresh observer
-  // re-delivers the current state, extending once per delivery until the sentinel is pushed clear —
-  // or until the window covers every row, at which point the count stops changing and with it the
-  // re-subscription.
+  // re-delivers the current state, extending once per delivery until the sentinel is pushed clear.
+  // A window already covering every row stands down instead, having nothing left to extend by.
   useEffect(() => {
-    if (!scrollEl || !sentinelEl) return undefined;
+    if (!scrollEl || !sentinelEl || count >= rows.length) return undefined;
     const observer = new IntersectionObserver(
       (entries) => {
         if (entries.some((entry) => entry.isIntersecting)) {
diff --git a/src/utils/language-tags.ts b/src/utils/language-tags.ts
index 460e8e2e..f739934c 100644
--- a/src/utils/language-tags.ts
+++ b/src/utils/language-tags.ts
@@ -30,3 +30,43 @@ export function collatorForTag(tag: string): Collator {
     return new Collator();
   }
 }
+
+/**
+ * Names languages in the most preferred of `locales` the host can use, falling back to the host's
+ * own locale where it can use none of them.
+ */
+function languageNamer(locales: readonly string[] | undefined): Intl.DisplayNames {
+  // Weighed one at a time because Intl rejects a whole list for any one entry it cannot parse,
+  // where the platform walks past the locales it has nothing for. Nothing holds an interface
+  // locale to BCP 47 structure, so an unusable one is not hypothetical.
+  const usable = locales?.filter((locale) => {
+    try {
+      Intl.getCanonicalLocales(locale);
+      return true;
+    } catch {
+      return false;
+    }
+  });
+  return new Intl.DisplayNames(usable?.length ? usable : undefined, { type: 'language' });
+}
+
+/**
+ * What a language is called, for prose that names a language rather than referring to it by code.
+ *
+ * Falls back to the tag itself, which is both what the host reports for a tag naming no language it
+ * knows and the only thing left to show for one it cannot parse at all — language tags reach this
+ * as free text, and naming an unparsable one throws.
+ *
+ * @param tag - BCP 47 tag of the language to name.
+ * @param locales - Interface languages to name it in, most preferred first. Omitted where there is
+ *   nothing but the host's own locale to go on, which the platform's interface language does not
+ *   follow.
+ */
+export function languageNameForTag(tag: string, locales?: readonly string[]): string {
+  try {
+    /* v8 ignore next -- `of` reports an unknown language as the tag itself, never as nothing */
+    return languageNamer(locales).of(tag) ?? tag;
+  } catch {
+    return tag;
+  }
+}