@stapel/search-react 0.21.0 → 0.23.0

package/src/i18n/es.ts

@@ -93,6 +93,15 @@ export const searchI18nBundleEs: I18nDictionary = {
   "search.facets.show_less": "Ver menos",
   "search.facets.search": "Buscar un filtro",
   "search.facets.search_empty": "Ningún filtro coincide con esto",
+  "search.facets.dictionary_search": "Buscar un valor",
+  "search.facets.dictionary_empty": "Ningún valor coincide con esto",
+  "search.facets.dictionary_chosen": "Elegido",
+  "search.facets.dictionary_any": "Cualquiera",
+  "search.facets.all_filters": "Todos los filtros ({count})",
+  "search.facets.range_bounds": "de {min} a {max}",
+  "search.facets.popular_all": "Todos",
+  "search.partition.all": "Todos",
+  "search.partition.label": "Sección",
   "search.facets.match_count.one": "{count} anuncio coincide",
   "search.facets.match_count.other": "{count} anuncios coinciden",
   "search.facets.range_invalid":

package/src/i18n/keys.ts

@@ -157,6 +157,46 @@ export const SEARCH_I18N_KEYS = {
    * Distinct from `facetsEmpty`, which says the SEARCH offers no filters —
    * here the filters exist and the query missed. */
   facetsSearchEmpty: "search.facets.search_empty",
+  /**
+   * The box inside ONE dictionary group — 418 car makes are not a list a
+   * person scrolls. Distinct from `facetsSearch`, which finds a GROUP among
+   * forty headings: one narrows the panel, the other narrows one axis of it,
+   * and a translator handed one string for both has to pick which surface to
+   * be wrong on.
+   */
+  facetsDictionarySearch: "search.facets.dictionary_search",
+  /** The dictionary box matched no value of this group. Not `facetsEmpty`,
+   * and not `facetsSearchEmpty`: the group exists and its values exist. */
+  facetsDictionaryEmpty: "search.facets.dictionary_empty",
+  /** Over the values already chosen, which stay visible whatever the box
+   * says — a filter a person cannot see is a filter they cannot remove. */
+  facetsDictionaryChosen: "search.facets.dictionary_chosen",
+  /**
+   * The closed dictionary FIELD with nothing chosen — "no constraint on this
+   * axis", the way a classified says it ("Any make", shortened to "Any").
+   *
+   * Not `facetsPopularAll` and not `partitionAll`, which are both the word
+   * "All": those two name a WIDER SET a person can move to, and this one
+   * names the absence of a narrowing. The three read alike in English and
+   * diverge in every language with gender or case.
+   */
+  facetsDictionaryAny: "search.facets.dictionary_any",
+  /**
+   * The tail of the rail, folded: how many groups are behind one control.
+   * `{count}` is a number in parentheses, not a counted noun, so this is not
+   * a plural family — the same shape as `facetsClearAll`.
+   */
+  facetsAllFilters: "search.facets.all_filters",
+  /**
+   * The bounds of a picker axis, said in words when what was typed is
+   * outside them — a year before the catalogue's own floor otherwise does
+   * nothing at all, silently.
+   */
+  facetsRangeBounds: "search.facets.range_bounds",
+  /** The way from the "popular values" block into the whole control. The
+   * block is a shortcut over the busiest values, so the link has to say that
+   * the rest exist. */
+  facetsPopularAll: "search.facets.popular_all",
   /**
    * The rail's sticky footer: what the applied filters LEFT — "N listings
    * match". A PLURAL FAMILY: it counts a noun in words. Desktop filters
@@ -192,6 +232,20 @@ export const SEARCH_I18N_KEYS = {
    * `{count}` is how many chips it hides (D16). */
   filtersChipOverflow: "search.filters.chips_overflow",
 
+  // ── a partition: one template split by a value its children name ─────────
+  /**
+   * The first chip of a partition row — the parent itself, unnarrowed.
+   *
+   * Not `facetsPopularAll` reused: that one OPENS a control, this one is a
+   * CHOICE among the children (and the one that is selected by default). The
+   * two are the same word in English and stop being one the moment a
+   * translator reads either as an imperative.
+   */
+  partitionAll: "search.partition.all",
+  /** The accessible name of the chip row — a `radiogroup` with no name is
+   * announced as nothing at all. */
+  partitionLabel: "search.partition.label",
+
   // ── the way OUT of a search that found nothing ───────────────────────────
   /** Caption above the exit buttons. Not a second "nothing found" — that
    * sentence has already been said; this one says what can be done next. */
@@ -462,6 +516,15 @@ export const searchI18nBundleEn: Record<string, string> = {
   "search.facets.show_less": "Show fewer",
   "search.facets.search": "Find a filter",
   "search.facets.search_empty": "No filter matches this",
+  "search.facets.dictionary_search": "Find a value",
+  "search.facets.dictionary_empty": "No value matches this",
+  "search.facets.dictionary_chosen": "Chosen",
+  "search.facets.dictionary_any": "Any",
+  "search.facets.all_filters": "All filters ({count})",
+  "search.facets.range_bounds": "from {min} to {max}",
+  "search.facets.popular_all": "All",
+  "search.partition.all": "All",
+  "search.partition.label": "Section",
   "search.facets.match_count.one": "{count} listing matches",
   "search.facets.match_count.other": "{count} listings match",
   "search.facets.range_invalid":

package/src/i18n/ru.ts

@@ -122,6 +122,15 @@ export const searchI18nBundleRu: I18nDictionary = {
   "search.facets.show_less": "Свернуть",
   "search.facets.search": "Найти фильтр",
   "search.facets.search_empty": "Среди фильтров такого нет",
+  "search.facets.dictionary_search": "Найти значение",
+  "search.facets.dictionary_empty": "Такого значения здесь нет",
+  "search.facets.dictionary_chosen": "Выбрано",
+  "search.facets.dictionary_any": "Любая",
+  "search.facets.all_filters": "Все фильтры ({count})",
+  "search.facets.range_bounds": "от {min} до {max}",
+  "search.facets.popular_all": "Все",
+  "search.partition.all": "Все",
+  "search.partition.label": "Раздел",
   "search.facets.match_count.one": "Найдено {count} объявление",
   "search.facets.match_count.few": "Найдено {count} объявления",
   "search.facets.match_count.many": "Найдено {count} объявлений",

package/src/index.ts

@@ -52,6 +52,8 @@ export {
 } from "./api/types.js";
 export type {
   FacetCategoryCount,
+  FacetLabels,
+  FacetLabelsMap,
   FacetMeta,
   FacetSelection,
   FacetWithheldGroup,
@@ -114,17 +116,28 @@ export type {
 export {
   FACETABLE_FEATURE_TYPES,
   buildFacetGroups,
+  facetGroupHasEvidence,
+  facetGroupIsDrawable,
   facetOptionLabel,
   isFacetableFeature,
+  orderFacetGroupsBySchema,
 } from "./state/facets.js";
 export type {
   BuildFacetGroupsInput,
   FacetGroup,
+  FacetLabelSource,
   FacetOption,
 } from "./state/facets.js";
 
+export {
+  consonantKey,
+  translitKey,
+  translitPrefixMatch,
+} from "./state/translit.js";
+
 export {
   RANGE_FEATURE_TYPES,
+  RANGE_PICKER_MAX_VALUES,
   buildRangeGroups,
   coreRangeLabelKey,
   isRangeFeature,

package/src/state/facets.ts

@@ -8,9 +8,12 @@
  *    they would have if you swapped to them. A panel that greys the siblings
  *    out has silently converted a drill-down facet into a naive one, and the
  *    e2e leg in the spec (§7.2) exists to catch exactly that.
- * 2. **Option LABELS have one stated order: ANSWER, then schema, then the
- *    raw value** — with a host resolver between the last two, applied by
- *    `useHostFacetLabels` on what this module could not name.
+ * 2. **LABELS have one stated order: ANSWER, then schema, then the raw
+ *    term** — for the group's heading and for every option alike, with a host
+ *    resolver between the last two for options, applied by
+ *    `useHostFacetLabels` on what this module could not name. The bottom of
+ *    that order is not a label and is marked as such: `labelSource: "none"`,
+ *    a warning in development, and a data attribute on the drawn group.
  *
  *    The answer leads because it is the only source that always exists and
  *    the only one that has RESOLVED anything: `categoryFeatures` is an
@@ -50,12 +53,88 @@
 import {
   VOCABULARY_BACKED_TYPES,
   featureConfig,
-  featureName,
   featureType,
   formatFeatureValue,
 } from "@stapel/attributes-react";
 import type { FeatureDef } from "@stapel/attributes-react";
-import type { FacetMeta, SearchQueryState } from "../api/types.js";
+import type { FacetLabelsMap, FacetMeta, SearchQueryState } from "../api/types.js";
+
+/**
+ * Where a caption came from — the group's heading and every option carry it,
+ * because "did anybody actually name this?" is a question two surfaces have
+ * to answer and neither can answer by looking at the string.
+ *
+ * `"none"` is the honest bottom: the raw slug for a heading, the raw index
+ * term for an option. It is not a label, it is what is printed when there is
+ * none, and it is the one value a storefront's own test asserts against.
+ */
+export type FacetLabelSource = "server" | "schema" | "host" | "none";
+
+declare const process: { readonly env: { readonly NODE_ENV?: string } };
+
+/** Slugs already complained about — one warning per slug per page load, not
+ * one per render. */
+const warnedSlugs = new Set<string>();
+
+/**
+ * A heading nobody named, said once, in development only.
+ *
+ * A raw slug in a filter panel is a wiring fault — the category has no
+ * feature definition for the slug and the server sent no label — and it is
+ * invisible to everyone but the buyer who meets it. The group still renders,
+ * because a heading a person cannot read still beats options with no heading
+ * at all; `FacetGroup.labelSource` is how a surface marks it up for a test.
+ */
+function warnUnnamedGroup(slug: string): void {
+  const env = typeof process === "undefined" ? undefined : process.env;
+  if (env?.NODE_ENV === "production") return;
+  if (warnedSlugs.has(slug)) return;
+  warnedSlugs.add(slug);
+  console.warn(
+    `[search-react] facet group "${slug}" has no label: the answer sent none ` +
+      `and no category feature defines it, so the heading is the raw slug.`
+  );
+}
+
+/** Slugs already reported as undrawable — one warning per slug per page. */
+const warnedUndrawable = new Set<string>();
+
+/**
+ * An axis that reached the panel with nothing to draw, said once, in
+ * development only.
+ *
+ * Measured on a live classified's cars branch: `make_ref_select`,
+ * `model` and `generation` are `ref_select` features whose config is a bare
+ * `optionsRef` pointer into a vocabulary — there is no option table in the
+ * schema and there never will be — so whenever the server's facet plan does
+ * not COUNT them there is nothing on the client to enumerate, and the group
+ * left the rail without a word while every `select`-typed comfort option
+ * (steering side, power steering, heating) drew its schema table and stayed.
+ * buyer's report was "I cannot pick a make".
+ *
+ * The panel still refuses to draw a heading over nothing — that is the right
+ * call — but the disappearance is a WIRING FAULT with two possible owners
+ * (the server's plan skipped a required axis, or the host threaded the wrong
+ * category's schema), and neither of them can see it from the page.
+ */
+function warnUndrawableGroup(group: FacetGroup): void {
+  const env = typeof process === "undefined" ? undefined : process.env;
+  if (env?.NODE_ENV === "production") return;
+  if (warnedUndrawable.has(group.slug)) return;
+  warnedUndrawable.add(group.slug);
+  console.warn(
+    `[search-react] facet group "${group.slug}" has no values to draw: the ` +
+      `answer did not count it${
+        group.feature === undefined
+          ? " and the category schema passed to this page does not define it"
+          : " and its config carries a vocabulary pointer, not an option table"
+      }, so the group is not rendered.` +
+      (group.feature?.mandatory === true
+        ? " The schema marks this axis REQUIRED — a buyer cannot narrow by a" +
+          " field every seller had to fill."
+        : "")
+  );
+}
 
 /**
  * Value types whose values are a BOUNDED OPTION SET — the only kind of
@@ -111,14 +190,22 @@ export interface FacetOption {
   readonly count: number | null;
   /** Resolved through the category schema; the raw value when there is none. */
   readonly label: string;
+  /** Which of the three sources named it — `"none"` means {@link label} IS
+   * the raw index term. The host seam reads this rather than comparing the
+   * two strings. */
+  readonly labelSource: FacetLabelSource;
   readonly selected: boolean;
 }
 
 /** One facet slug, with its options. */
 export interface FacetGroup {
   readonly slug: string;
-  /** The feature's display name (translated when it is a key), else the slug. */
+  /** The group's heading: the answer's own `label`, else the feature's
+   * display name, else — with a dev warning — the raw slug. */
   readonly label: string;
+  /** Which source named the heading. `"none"` is the slug standing in for a
+   * name nobody has; a surface marks it so a storefront test can fail on it. */
+  readonly labelSource: FacetLabelSource;
   /** The category-schema entry behind the slug, when the host supplied one. */
   readonly feature: FeatureDef | undefined;
   /** `false` when the server skipped this slug — counts are `null`. */
@@ -175,6 +262,105 @@ export function orderFacetGroups(
   return [...groups].sort(compareFacetsByEvidence);
 }
 
+/**
+ * Does the ANSWER have evidence for this axis — at least one value some
+ * candidate actually carries?
+ *
+ * The one fact that outranks every other rule in this module. A bucket with a
+ * count above zero is the server saying "documents in this result set have
+ * this value", and no schema opinion, no missing feature list and no type
+ * table may take an axis like that off the screen.
+ */
+export function facetGroupHasEvidence(group: FacetGroup): boolean {
+  return group.options.some((option) => (option.count ?? 0) > 0);
+}
+
+/**
+ * Is there anything for a surface to DRAW here?
+ *
+ * Shared by the rail and the chip row, which each used to hold their own
+ * `options.length > 0` — one predicate, or the two surfaces drift into two
+ * opinions about what an empty group is.
+ *
+ * A group with no options is a heading over nothing: after
+ * {@link buildFacetGroups} learned to read the schema, what is left in that
+ * state is a `ref_select` whose config is a bare `optionsRef` pointer and
+ * which the server did not count — nothing to enumerate from either side. It
+ * is not drawn, and in development it is NAMED: a required axis (the make on
+ * cars leaf) disappearing out of a rail is exactly the fault this pair spent
+ * a release chasing, and it must not disappear silently a second time.
+ *
+ * A group the reader has already FILTERED on is drawn whatever its options
+ * say — a constraint with no control to remove it is worse than a bare
+ * heading.
+ */
+export function facetGroupIsDrawable(group: FacetGroup): boolean {
+  if (group.selected.length > 0) return true;
+  if (group.options.length > 0) return true;
+  warnUndrawableGroup(group);
+  return false;
+}
+
+/**
+ * The order the RAIL puts groups in: the category's own schema order, with
+ * the axes the schema calls required in front of it.
+ *
+ * Evidence order ({@link compareFacetsByEvidence}) answers "which axis does
+ * this corpus fill in", which is the right question for a chip row that has
+ * room for four. It is the wrong question for a rail: on a cars leaf with
+ * three listings the busiest axis is whichever three values happen to be
+ * counted, so the rail opened on condition and colour while make, model and
+ * year — the three fields the schema marks
+ * `mandatory`, i.e. the three every seller had to fill and every buyer
+ * narrows by first — sat below them or off the fold entirely.
+ *
+ * So: the schema's own order, which is the order the composer asks the
+ * seller to fill the form in, with required first. Four bands:
+ *
+ *  1. `pinned` slugs, in the order given — the axis a page has already
+ *     decided is its subject (a partition's own field).
+ *  2. schema-required (`mandatory: true`), in schema order.
+ *  3. everything else the schema names, in schema order.
+ *  4. what the schema does not name at all — including EVERY group when the
+ *     host passed no feature list, which is the live parent-node case — in
+ *     evidence order, because with no schema there is no other order to have.
+ *
+ * Stable: within a band the comparator falls through to evidence and then to
+ * the order `buildFacetGroups` gave, so equal-ranked groups never reshuffle.
+ */
+export function orderFacetGroupsBySchema(input: {
+  readonly groups: readonly FacetGroup[];
+  /** The category schema, in the order the category declares it. */
+  readonly categoryFeatures?: readonly FeatureDef[];
+  /** Slugs pinned above everything, in the order given. */
+  readonly pinned?: readonly string[];
+}): readonly FacetGroup[] {
+  const schemaIndex = new Map<string, number>();
+  (input.categoryFeatures ?? []).forEach((feature, index) => {
+    if (!schemaIndex.has(feature.slug)) schemaIndex.set(feature.slug, index);
+  });
+  const pinnedIndex = new Map<string, number>();
+  (input.pinned ?? []).forEach((slug, index) => {
+    if (!pinnedIndex.has(slug)) pinnedIndex.set(slug, index);
+  });
+
+  const band = (group: FacetGroup): number => {
+    if (pinnedIndex.has(group.slug)) return 0;
+    if (!schemaIndex.has(group.slug)) return 3;
+    return group.feature?.mandatory === true ? 1 : 2;
+  };
+  const within = (group: FacetGroup): number =>
+    pinnedIndex.get(group.slug) ?? schemaIndex.get(group.slug) ?? 0;
+
+  return [...input.groups].sort((a, b) => {
+    const byBand = band(a) - band(b);
+    if (byBand !== 0) return byBand;
+    const byOrder = within(a) - within(b);
+    if (byOrder !== 0) return byOrder;
+    return compareFacetsByEvidence(a, b);
+  });
+}
+
 export interface BuildFacetGroupsInput {
   /** The envelope's `facets`: `{slug: {value: count}}`. */
   readonly facets: Readonly<Record<string, Readonly<Record<string, number>>>>;
@@ -199,17 +385,17 @@ export interface BuildFacetGroupsInput {
    *    `apple` or `chernyy`. The server read that vocabulary against the
    *    snapshot the documents were written with.
    *
+   * Each entry also carries the GROUP's own `label` — the heading, resolved
+   * from the feature definition server-side and localized like everything
+   * else. It leads for the same two reasons, and it is what a category whose
+   * host passed no feature list has instead of a rail full of index slugs.
+   *
    * ABSENT on a server older than 0.4.0 — absent, not empty — which is why
    * every read of it here is optional-chained and every option falls through
    * to the schema and then to its raw self. No labels are invented at any
    * step.
    */
-  readonly facetLabels?: Readonly<
-    Record<
-      string,
-      { readonly translatable: boolean; readonly values: Readonly<Record<string, string>> }
-    >
-  >;
+  readonly facetLabels?: FacetLabelsMap;
   /** Translator for label keys. */
   readonly t?: (key: string) => string;
   /** BCP-47 tag, forwarded to `formatFeatureValue` for `date` options. */
@@ -287,11 +473,49 @@ function resolveLabel(
   slug: string,
   value: string,
   labelOptions: { t?: (key: string) => string; locale?: string }
-): string {
-  return (
-    serverLabel(input.facetLabels, slug, value, input.t) ??
-    facetOptionLabel(feature, value, labelOptions)
-  );
+): { readonly label: string; readonly labelSource: FacetLabelSource } {
+  const answer = serverLabel(input.facetLabels, slug, value, input.t);
+  if (answer !== undefined) return { label: answer, labelSource: "server" };
+  const schema = facetOptionLabel(feature, value, labelOptions);
+  // `facetOptionLabel` hands back the value unchanged for an option it
+  // cannot name, and that identity is the whole test — a formatter that
+  // returned the term is a formatter that named nothing.
+  return schema === value
+    ? { label: value, labelSource: "none" }
+    : { label: schema, labelSource: "schema" };
+}
+
+/**
+ * The group's HEADING, in the one order the fleet states: the answer, then
+ * the category schema, then the slug under a dev warning.
+ *
+ * The answer leads because it is the only source that always exists. The
+ * schema slot is optional, and at a live classified's cars branch the
+ * storefront passed an empty feature list, so every heading in the rail was
+ * a raw index slug — the make group was on screen, unlabelled, and the
+ * complaint that came back was "I cannot pick a make".
+ *
+ * The slug is not a fallback anyone may ship: it renders, because a heading
+ * beats no heading, and it renders MARKED — `labelSource: "none"`, a warning
+ * in development, and a data attribute on the drawn group.
+ */
+function resolveGroupLabel(
+  input: BuildFacetGroupsInput,
+  feature: FeatureDef | undefined,
+  slug: string
+): { readonly label: string; readonly labelSource: FacetLabelSource } {
+  const answer = input.facetLabels?.[slug]?.label;
+  if (typeof answer === "string" && answer.length > 0) {
+    return { label: translate(input.t, answer), labelSource: "server" };
+  }
+  // `featureName` falls back to the slug itself, so the def has to be asked
+  // for a NAME rather than for a name-or-slug: a def with none names nothing.
+  const declared = feature?.name;
+  if (typeof declared === "string" && declared.length > 0) {
+    return { label: translate(input.t, declared), labelSource: "schema" };
+  }
+  warnUnnamedGroup(slug);
+  return { label: slug, labelSource: "none" };
 }
 
 /**
@@ -382,6 +606,19 @@ export function buildFacetGroups(input: BuildFacetGroupsInput): readonly FacetGr
     seen.add(slug);
     // Applied first, type second — in that order, so an `imei` somebody
     // somehow got into a link keeps the control that removes it.
+    //
+    // EVIDENCE does not enter here, and the reason is worth stating because
+    // the opposite was tried: a counted bucket cannot promote a slug the
+    // schema NAMES AND DISOWNS. An `imei` the engine counted is still not a
+    // filter — a free-text identifier enumerates one term per document — and
+    // a `visibility: "owner"` feature is one the canon says is never
+    // facetable at all. What evidence does outrank is SILENCE: an absent def,
+    // an untyped def, and the whole empty feature list the live cars page
+    // passes at its parent node all answer "not a verdict"
+    // (see {@link isFacetableFeature}), so a counted axis is never dropped
+    // for a schema that says nothing about it. That is the live case; a
+    // wrong-schema case where some other category types `make_ref_select` as
+    // free text is not one this pair can tell apart from a real `imei`.
     const applied = (input.state.filters[slug] ?? []).length > 0;
     if (!applied && !isFacetableFeature(bySlug.get(slug))) continue;
     slugs.push(slug);
@@ -446,22 +683,17 @@ export function buildFacetGroups(input: BuildFacetGroupsInput): readonly FacetGr
 
     return {
       slug,
-      label:
-        feature === undefined
-          ? slug
-          : translate(input.t, featureName(feature)),
+      ...resolveGroupLabel(input, feature, slug),
       feature,
       counted,
       selected,
       options: values.map((value) => ({
         value,
         count: counted ? (counts[value] ?? 0) : null,
-        // The host's schema first when it actually resolves the value, the
-        // answer's caption when it does not (or when there is no schema at
-        // all), the raw value when neither knows. `facetOptionLabel` returns
-        // the value unchanged for an option it cannot name, which is what
-        // makes "did it resolve?" answerable without a second lookup.
-        label: resolveLabel(input, feature, slug, value, labelOptions),
+        // The answer's caption first, then the schema's own option table,
+        // then the raw value — and the source is carried rather than
+        // re-derived, so "did it resolve?" needs no second lookup.
+        ...resolveLabel(input, feature, slug, value, labelOptions),
         selected: selected.includes(value),
       })),
     };

package/src/state/ranges.ts

@@ -76,6 +76,19 @@ export interface RangeGroup {
    * category forgot to declare an attribute for it.
    */
   readonly core: boolean;
+  /**
+   * The values this axis can take, when it is a BOUNDED INTEGER small enough
+   * to pick from — `undefined` for every other axis, including price.
+   *
+   * A year is not a number a person types, it is one of a hundred-odd values,
+   * and the reference classified draws it as two pickers. `min`/`max` from
+   * the schema (`year: 1900..2027` on a live cars leaf) bound the list;
+   * {@link RANGE_PICKER_MAX_VALUES} is where a picker stops being one and
+   * becomes a scroll with a search box in it, at which point two typed fields
+   * are the better control. Descending, because the busy end of a bounded
+   * axis is its top: a year picker that opens on 1900 is a picker nobody uses.
+   */
+  readonly picker: readonly number[] | undefined;
   /**
    * ISO 4217 code when the row is money, so the control can read as money
    * instead of as a bare integer. Only ever set on a core axis: an attribute
@@ -131,6 +144,36 @@ function translate(t: ((key: string) => string) | undefined, key: string): strin
   return resolved.length > 0 ? resolved : key;
 }
 
+/**
+ * How many values a bounded integer may have and still be a PICKER.
+ *
+ * 300 covers every year range a catalogue declares (a live cars leaf is
+ * 1900..2027, 128 values) and a door count, a seat count, a floor number,
+ * and stops well short of a mileage (1..1000000), which is a number people
+ * type and never a list.
+ */
+export const RANGE_PICKER_MAX_VALUES = 300;
+
+/**
+ * The value list for a bounded integer axis, or `undefined`.
+ *
+ * A CORE axis never gets one: price is unbounded by construction and the
+ * server does not declare bounds for it.
+ */
+function pickerValues(
+  feature: FeatureDef | undefined,
+  min: number | undefined,
+  max: number | undefined
+): readonly number[] | undefined {
+  if (feature === undefined) return undefined;
+  if (featureType(feature) !== "int") return undefined;
+  if (min === undefined || max === undefined) return undefined;
+  if (!Number.isInteger(min) || !Number.isInteger(max)) return undefined;
+  const span = max - min + 1;
+  if (span < 2 || span > RANGE_PICKER_MAX_VALUES) return undefined;
+  return Array.from({ length: span }, (_, i) => max - i);
+}
+
 /** Is this feature one a numeric range row is drawn for? */
 export function isRangeFeature(feature: FeatureDef): boolean {
   const type = featureType(feature);
@@ -190,6 +233,7 @@ export function buildRangeGroups(
         ? undefined
         : (str(config["postfix"]) ?? str(config["unit_m"]) ?? str(config["unit_i"])),
       step: feature !== undefined && featureType(feature) === "int" ? 1 : undefined,
+      picker: isCore ? undefined : pickerValues(feature, num(config["min"]), num(config["max"])),
       active: applied !== undefined,
       core: isCore,
       currency: isCore ? str(input.currency) : undefined,