@stapel/search-react 0.19.0 → 0.21.0

package/src/api/generated/schema.ts

@@ -135,6 +135,19 @@ export interface paths {
 export type webhooks = Record<string, never>;
 export interface components {
     schemas: {
+        /** @description One partition of the answer — a heading, never a filter over it. */
+        BandSummary: {
+            id: components["schemas"]["IdEnum"];
+            /** @description How many rows are in this band. `null` when the engine cannot say. The two counts add up to the top-level `count`, which is the machine-checkable form of 'nothing is hidden by distance'. */
+            count: number | null;
+            /** @description True when `count` is a floor (a capped count). Render 'N+'. */
+            count_is_lower_bound: boolean;
+            /**
+             * Format: double
+             * @description Present on `nearby` only: the edge, in km, the band was cut at. `all` has no edge — it is everything else, which is the promise.
+             */
+            radius_km?: number;
+        };
         /** @description One destination in the dropdown, ready to render and ready to follow. */
         CategorySuggestion: {
             /** @description Category id. A `listings`-graded row derives it from the path's leaf segment. */
@@ -149,6 +162,17 @@ export interface components {
             category: string;
             /** @description Live listings a buyer would see under this category, descendants included — the same number the SERP reports for it. On a `listings`-graded row: how many of them match the typed query, which is the count a `?q=…&category=…` tap will show. */
             count: number;
+            /**
+             * @description What `count` counted. `category`: everything live under this category, the typed text ignored — the row is a PLACE. `query_in_category`: only the documents matching the typed text, which is what a `listings`-graded row is about. The two are different numbers about different pages, which is why the row says which one it is instead of leaving a storefront to guess.
+             *
+             *     * `category` - category
+             *     * `query_in_category` - query_in_category
+             */
+            count_scope: components["schemas"]["CountScopeEnum"];
+            /** @description The /query parameters this row's `count` was computed for — send them VERBATIM (plus your own `type`/`lang`/paging) when the buyer follows the row. Always carries `category`; carries `q` only when `count_scope` is `query_in_category`. Assembling these yourself re-opens the defect this field exists to close: a place row followed with the typed text opens an empty page while its count promised stock. */
+            query: {
+                [key: string]: string;
+            };
             /** @description Number of segments in `path`. */
             depth: number;
             /**
@@ -163,6 +187,28 @@ export interface components {
              */
             match: components["schemas"]["MatchEnum"];
         };
+        /**
+         * @description * `category` - category
+         *     * `query_in_category` - query_in_category
+         * @enum {string}
+         */
+        CountScopeEnum: "category" | "query_in_category";
+        /** @description One filter the query's own words produced, ready to be replayed. */
+        ExtractedFilter: {
+            slug: string;
+            value: string;
+            label: string;
+            value_label: string;
+            method: components["schemas"]["MethodEnum"];
+            /** Format: double */
+            confidence: number;
+            /** @description `[start, end)` into the RAW query, so a UI can underline the words that became this chip. */
+            span: number[];
+            /** @description The literal query parameter this filter IS — e.g. `f.color=krasnyy`. Re-send it verbatim to KEEP the chip, omit it to remove it, and send `qu=off` alongside so the server does not extract it again. Nothing about extraction is remembered server-side, which is why the parameter has to be complete. */
+            param: string;
+            /** @description True when this filter actually narrowed the answer. A false one still contributed to each row's `match_count`. */
+            applied: boolean;
+        };
         /** @description Captions for one slug's option codes. */
         FacetLabels: {
             /** @description True when `values` holds translation KEYS to run through the catalogue; false when it holds literal captions. The reader cannot tell by looking — `b.apple` and `Б/у` are both strings. */
@@ -183,6 +229,16 @@ export interface components {
             dropped_filters: string[];
             /** @description Range slugs that address a core document column rather than an attribute (`r.price`). Offer them as filters unconditionally: they exist for every document in every category, which is why they are not in the category's own plan. */
             core_ranges: string[];
+            /** @description Where the plan came from. `category` — the queried category's own authored schema. `evidence` — the categories the CANDIDATE SET actually contains, used when that schema did not fill MAX_FACET_FIELDS, which is every branch category and every text query (`categories.features` resolves own + ANCESTOR-inherited features, so a branch owns no axes; its leaves do). */
+            plan: string;
+            /** @description `{slug, coverage, candidates}` for groups that were counted and then withheld because they describe too little of the result set (FACET_MIN_COVERAGE). Present so a panel can say «3 filters apply to too few of these» instead of «no filters» — the second is false whenever this list is not empty. Only slugs the evidence plan borrowed from another category are ever here, and never one the reader has already filtered on. */
+            withheld: {
+                [key: string]: unknown;
+            }[];
+            /** @description `{category, count}` — the categories this answer's candidate set is made of, busiest first, `category` being the same slash-joined id path the `category` filter takes. The evidence the plan was drawn from, and what a panel needs to offer the CATEGORY itself as the first filter on a text search. Empty when the plan is the queried category's own. */
+            categories: {
+                [key: string]: unknown;
+            }[];
         };
         HealthResponse: {
             backend: string;
@@ -196,6 +252,12 @@ export interface components {
             lag_seconds?: number | null;
             stale_reason?: string;
         };
+        /**
+         * @description * `nearby` - nearby
+         *     * `all` - all
+         * @enum {string}
+         */
+        IdEnum: "nearby" | "all";
         /**
          * @description * `exact` - exact
          *     * `prefix` - prefix
@@ -206,6 +268,24 @@ export interface components {
          * @enum {string}
          */
         MatchEnum: "exact" | "prefix" | "word" | "substring" | "listings" | "vector";
+        /**
+         * @description * `exact` - exact
+         *     * `translit` - translit
+         *     * `alias` - alias
+         *     * `vector` - vector
+         * @enum {string}
+         */
+        MethodEnum: "exact" | "translit" | "alias" | "vector";
+        /** @description What a free-text query turned out to be ABOUT, beside its words. */
+        QueryUnderstanding: {
+            filters: components["schemas"]["ExtractedFilter"][];
+            category_path: string[];
+            /** Format: double */
+            category_confidence: number;
+            /** @description The query with every extracted span removed — the text the engine still had to match. Empty is normal and correct: «красный» is entirely a filter, and the answer is then the filters' set. */
+            residual: string;
+            degraded: string[];
+        };
         /** @description The P2B Art. 5 disclosure, generated from the scorer registry. */
         RankingResponse: {
             doc_type: string;
@@ -252,10 +332,14 @@ export interface components {
             promoted: boolean;
             /**
              * Format: double
-             * @description Great-circle distance from the searched centre.
+             * @description Great-circle distance from the searched centre, in km. For an ANONYMOUS reader it is measured from the same ~1.1km grid point the card publishes and floored to that grid's quantum (the cell's diagonal, ~1.574km): a distance finer than the position it came from is the position, three requests away. The listing's own owner, staff and the service transport get the exact number. Coarse is enough for what it drives — a card saying «12 км» does not need metres — and it never overstates proximity, being floored rather than rounded.
              */
             distance_km: number | null;
-            /** @description Stored row fields, so a result page costs one query. */
+            /** @description `nearby` | `all` | `""`. Which partition this row sits in, present only under `geo_mode=rank`. A LABEL, never a filter: `all` carries every remaining row, including rows with no coordinates at all, so a query never returns fewer results because of distance. `""` means the request ranked by proximity but gave no centre, which is not an error. */
+            band?: string;
+            /** @description How many of the filters the QUERY's own words produced this row satisfies — including the soft ones that were not applied as filters. Orders rows within a band, strongest first. Present only when the query produced signals. */
+            match_count?: number;
+            /** @description Stored row fields, so a result page costs one query. For an ANONYMOUS reader the card never carries full-precision coordinates, on every path and whatever the flags: a key naming half a pair (`lat`, `latitude`, `lon`, `lng`, `*_lat`…) is rewritten onto the ~1.1km public grid from the row's own columns, and a key carrying a position this module cannot turn into an area (`geohash`, `location`, `coordinates`…) is removed rather than truncated — two differently-aligned areas around one point intersect down to a sliver. `geo_precision_km` says how wide the area is: draw a CIRCLE, never a marker. Under `geo_mode=rank` the pair is ADDED even to a card that carried no position at all. */
             card: {
                 [key: string]: unknown;
             };
@@ -263,6 +347,10 @@ export interface components {
         /** @description The query envelope: AnchorPagination's keys, plus what search owes. */
         SearchResponse: {
             items: components["schemas"]["SearchItem"][];
+            /** @description Per-band counts in render order — `nearby` («Объявления поблизости») then `all` («Все объявления»). Present only under `geo_mode=rank`; empty when no centre was given. The rows themselves carry `band`; this is the summary a heading needs. The top-level `count` remains the WHOLE matching total, never the nearby one. */
+            bands?: components["schemas"]["BandSummary"][];
+            /** @description What the query's words became. Absent entirely while QUERY_UNDERSTANDING is off or `qu=off` was sent. */
+            query_understanding?: components["schemas"]["QueryUnderstanding"];
             /** @description {slug: {value: count}}, counted with the slug's own filter removed. */
             facets: {
                 [key: string]: {
@@ -338,7 +426,7 @@ export interface operations {
             query: {
                 /** @description Opaque keyset cursor from a previous answer. */
                 anchor?: string;
-                /** @description minLat,minLon,maxLat,maxLon. minLon > maxLon means the box crosses +/-180. */
+                /** @description minLat,minLon,maxLat,maxLon. minLon > maxLon means the box crosses +/-180. For an anonymous caller the rectangle is grown OUTWARD to whole ~1.1km cells of the public geo grid, so it can only ever ask about the area a public card publishes: a box EXCLUDES rows, and halving one around a listing would otherwise converge on the seller's pin in a few dozen requests. */
                 bbox?: string;
                 /** @description root/leaf path; a prefix filter, so a parent finds its descendants. */
                 category?: string;
@@ -348,6 +436,8 @@ export interface operations {
                 "f.<slug>"?: string;
                 /** @description on | off | comma-separated slugs. Default is the category's plan. */
                 facets?: string;
+                /** @description rank | filter. What `radius_km` means. `rank` PARTITIONS: the answer comes back as `nearby` (inside the radius) then `all` (every remaining row), nothing is withheld, and `count` stays the whole matching total — a query can never come back empty because of distance. `filter` is the historical hard cut, for a caller that genuinely wants only what is within N km. `rank` is the default inside the feature; while STAPEL_SEARCH['GEO_BANDS'] is off this parameter is inert and `radius_km` filters as it always has. */
+                geo_mode?: string;
                 /** @description Language of the query: selects the analyzer AND narrows the corpus. Omit it and only the analyzer is chosen (from Accept-Language) — a header must not hide a catalogue. */
                 lang?: string;
                 /** @description Centre latitude (with lon). */
@@ -359,9 +449,11 @@ export interface operations {
                 owner?: string;
                 /** @description Free text. Dictionary-normalized here; morphology belongs to the engine. */
                 q?: string;
+                /** @description auto | off. Whether the query's own words may become filters. `auto` (the default while QUERY_UNDERSTANDING is on) extracts and reports what it extracted under `query_understanding`; each filter carries the literal `param` to replay. Send `qu=off` with those replayed params afterwards — extraction is stateless, so without it a removed chip comes straight back. */
+                qu?: string;
                 /** @description Range filter, `from..to`; either end may be omitted. */
                 "r.<slug>"?: string;
-                /** @description Radius around the centre. */
+                /** @description Distance around the centre, in km. Its MEANING is `geo_mode`'s: under `rank` it is the edge of the `nearby` band and excludes nothing; under `filter` it is a hard cut. Defaults to NEAR_BAND_RADIUS_KM under `rank`. */
                 radius_km?: number;
                 /** @description relevance | newest | price_asc | price_desc | distance. An explicit sort never receives a promotional boost. */
                 sort?: string;

package/src/api/types.ts

@@ -13,17 +13,59 @@ import type { components } from "./generated/schema.js";
 /** The generated schema table — the one source of truth for wire shapes. */
 export type Schemas = components["schemas"];
 
-/** `GET /query` 200 — the whole envelope. */
-export type SearchResponse = Schemas["SearchResponse"];
+/** `GET /query` 200 — the whole envelope. Corrected in one place: see
+ * {@link FacetMeta}. */
+export type SearchResponse = Omit<Schemas["SearchResponse"], "facet_meta"> & {
+  readonly facet_meta: FacetMeta;
+};
 
 /** One result row. `promoted` is present on EVERY item under EVERY sort — a
  * mandatory marking (DSA Art. 26), not an optional field, which is why the
  * card slot's contract carries it and why the default skin renders it. */
 export type SearchItem = Schemas["SearchItem"];
 
-/** The honesty block beside the counts: `approximate`, `candidates`,
- * `counted`, `skipped`. Rendered, never swallowed (spec §4.2). */
-export type FacetMeta = Schemas["FacetMeta"];
+/**
+ * One group the counter COUNTED and then held back, because its buckets
+ * describe too little of the result set (`FACET_MIN_COVERAGE`).
+ *
+ * The existence of this list is what makes "this search offers no filters"
+ * a false sentence whenever it is not empty (D175).
+ */
+export interface FacetWithheldGroup {
+  readonly slug: string;
+  /** Sum of that group's bucket counts — how much of the set it describes. */
+  readonly coverage: number;
+  /** Size of the candidate set `coverage` is a fraction of. */
+  readonly candidates: number;
+}
+
+/** One category the candidate set is made of. */
+export interface FacetCategoryCount {
+  /** The slash-joined id path (`"32/149/163"`) — the SAME string the
+   * `category` filter and `SearchQueryState.category` already take, so a
+   * panel can offer it as a filter without translating anything. */
+  readonly category: string;
+  readonly count: number;
+}
+
+/**
+ * The honesty block beside the counts: `approximate`, `candidates`,
+ * `counted`, `skipped`, and (stapel-search 0.12.0+) where the facet plan came
+ * from. Rendered, never swallowed (spec §4.2).
+ *
+ * WHAT THE GENERATOR LOST: drf-spectacular describes `withheld` and
+ * `categories` as bare `object` arrays, so the generated members are
+ * `{[key: string]: unknown}[]` — the two fields a panel has to read
+ * field-by-field are the two it cannot. Both are corrected here to the
+ * documented row shapes; nothing else about `FacetMeta` is hand-written.
+ */
+export type FacetMeta = Omit<
+  Schemas["FacetMeta"],
+  "withheld" | "categories"
+> & {
+  readonly withheld: readonly FacetWithheldGroup[];
+  readonly categories: readonly FacetCategoryCount[];
+};
 
 /** `GET /suggest` 200, as the CURRENT generated schema describes it. */
 export type SuggestResponse = Schemas["SuggestResponse"];
@@ -259,6 +301,10 @@ export type SearchDegradationKind =
   | "exact_total"
   | "exact_facet_counts"
   | "category_rollup"
+  /** The engine has no `category_counts` verb, so the categories the result
+   * set is made of are unknown and no evidence facet plan could be drawn.
+   * An empty filter panel then means "we do not know", not "there are none". */
+  | "facet_plan_evidence"
   | "scorer"
   | "unknown";
 

package/src/default/FacetPanelPane.tsx

@@ -22,19 +22,27 @@
  *    filters on a slug it never counted; the engine's own list of skipped
  *    slugs is a developer's note and lives behind `skippedNotice`.
  *
- * ── Two slots, and why they are slots ─────────────────────────────────────
+ * ── One slot, and why it is a slot ────────────────────────────────────────
  *
- * `renderCategoryFilter` and `renderGeoFilter` are filled by OTHER pairs:
- * choosing a category means walking the catalogue tree (`categories-react`),
- * and turning an address into a coordinate needs a geocoder and a map
- * (`geo-react`). Neither belongs in a search package, and importing either
- * would tie a storefront's search to a catalogue it might not have.
+ * `renderCategoryFilter` is filled by ANOTHER pair: choosing a category means
+ * walking the catalogue tree (`categories-react`), which does not belong in a
+ * search package, and importing it would tie a storefront's search to a
+ * catalogue it might not have.
+ *
+ * There used to be a second one, `renderGeoFilter`, and a "Location" group
+ * around it with the radius under it. Both are gone from this panel. A place
+ * is not a filter — a coordinate pair is the machine form of somewhere, and
+ * putting it in the filter list is what let a landing announce "clear all
+ * filters (2)" over an empty page with two constraints that had no name.
+ * The place and its radius are ONE control of their own
+ * (`<LocationSummaryLine>`), the way a search box is, and `<SearchPage>`
+ * still takes `renderGeoFilter` — it hands it there.
  *
  * What this panel does NOT do is pretend the slot is optional. An unfilled
  * slot renders `SlotPlaceholder` in development — a named, visible hole rather
  * than a silent absence — and, in every build, any constraint the URL already
  * carries gets a control that REMOVES it. A shared link that narrows to a
- * category or a point must never leave a person with no way to widen it again.
+ * category must never leave a person with no way to widen it again.
  *
  * ── The panel opens what the answer argues for, and closes the rest ────────
  *
@@ -68,11 +76,10 @@ import {
   Divider,
   Flex,
   Input,
-  InputNumber,
   Typography,
   theme,
 } from "antd";
-import { SlotPlaceholder, isDevBuild, useT, useTPlural } from "@stapel/core";
+import { SlotPlaceholder, useT, useTPlural } from "@stapel/core";
 import {
   EmptyState,
   ErrorAlert,
@@ -84,6 +91,7 @@ import { featureName } from "@stapel/attributes-react";
 import type { FeatureDef } from "@stapel/attributes-react";
 import type { SearchGeo } from "../api/types.js";
 import { FacetPanel } from "../headless/FacetPanel.js";
+import type { FacetPanelBag } from "../headless/FacetPanel.js";
 import type { FacetLabelResolver } from "../headless/useFacetLabels.js";
 import { useSearchState } from "../headless/SearchStateProvider.js";
 import { useAppliedCount } from "../headless/useAppliedCount.js";
@@ -202,25 +210,6 @@ export interface FacetPanelPaneProps extends ThemeModeProp {
   /** The catalogue picker (`categories-react`'s `CategoryPickerField`, bound
    * to a path). Unfilled, an active category still gets a "clear" control. */
   readonly renderCategoryFilter?: (slot: CategoryFilterSlotProps) => ReactNode;
-  /** The location control (`geo-react`). Unfilled, a location that arrived in
-   * the URL still gets its radius and a "clear" control. */
-  readonly renderGeoFilter?: (slot: GeoFilterSlotProps) => ReactNode;
-  /**
-   * What the current location constraint is CALLED, in words — the address or
-   * the city the host resolved.
-   *
-   * The panel owns `lat`/`lon`/`radius_km` as URL state and must never render
-   * them: a coordinate is what gets STORED, and storage is not a display
-   * concern. `55.756, 37.617` is unreadable to the one person who could have
-   * caught the mistake, so a wrong point looks as authoritative as a right one
-   * and a right one looks like machinery.
-   *
-   * Whoever turned an address into that point still has the address — the
-   * geocoder's own answer, the city an IP guess named, the label on the map
-   * pin — and hands it back here. Absent, the panel says a location is applied
-   * without pretending to name it (`search.geo.chosen_place`).
-   */
-  readonly geoLabel?: ReactNode;
   /** BCP-47 tags this deployment indexes — see {@link LanguageSelect}. */
   readonly languages?: readonly string[];
   /**
@@ -407,97 +396,6 @@ export function geoSummaryFallback(
     : t(SEARCH_I18N_KEYS.geoChosenPlace);
 }
 
-/**
- * The location constraint.
- *
- * SETTING a centre needs a geocoder, which is the deployment's and
- * `geo-react`'s. ADJUSTING one that already exists does not: the radius is a
- * number in the URL, and a link shared with `lat/lon/radius_km` is a link this
- * panel can widen, tighten and clear without knowing what a map is. That is the
- * difference between a slot and a hole.
- *
- * NAMING the centre is a third thing again, and it is the host's: this panel
- * has two numbers and no way to turn them into a place. So it either says the
- * name it was handed (`label`) or says that a place is chosen — never the
- * numbers themselves. See {@link FacetPanelPaneProps.geoLabel}.
- */
-function GeoFilter(props: {
-  render?: (slot: GeoFilterSlotProps) => ReactNode;
-  label?: ReactNode;
-}): ReactElement | null {
-  const t = useT();
-  const { state, setGeo } = useSearchState();
-  const geo = state.geo;
-
-  const slot =
-    props.render !== undefined
-      ? props.render({
-          value: geo,
-          onChange: (next) => {
-            setGeo(next);
-          },
-        })
-      : geo === undefined
-        ? <SlotPlaceholder name="renderGeoFilter" data-testid="search-geo-slot" />
-        : null;
-
-  if (geo === undefined) {
-    // An unfilled slot is a NAMED hole in development and nothing at all in a
-    // production build — so the heading has to follow the placeholder rather
-    // than outlive it. It did not, and the live desktop panel printed
-    // "Location" over empty space with no location control under it
-    // (class NC-ORPHANFIELD): a label is a promise that a control follows.
-    if (props.render === undefined && !isDevBuild()) return null;
-    return slot === null ? null : (
-      <Flex vertical gap={spacing[1]} data-testid="search-geo">
-        <Typography.Text strong>{t(SEARCH_I18N_KEYS.geoTitle)}</Typography.Text>
-        {slot}
-      </Flex>
-    );
-  }
-
-  return (
-    <Flex vertical gap={spacing[1]} data-testid="search-geo">
-      <Typography.Text strong>{t(SEARCH_I18N_KEYS.geoTitle)}</Typography.Text>
-      {slot}
-      <Typography.Text type="secondary" data-testid="search-geo-summary">
-        {props.label ?? geoSummaryFallback(geo, t)}
-      </Typography.Text>
-      {geo.kind === "center" && (
-        <Flex gap={spacing[2]} align="center" wrap>
-          <Typography.Text type="secondary" aria-hidden="true">
-            {t(SEARCH_I18N_KEYS.geoRadiusLabel)}
-          </Typography.Text>
-          <InputNumber
-            min={1}
-            value={geo.radiusKm ?? null}
-            aria-label={t(SEARCH_I18N_KEYS.geoRadiusLabel)}
-            data-testid="search-geo-radius"
-            onChange={(value) => {
-              setGeo({
-                kind: "center",
-                lat: geo.lat,
-                lon: geo.lon,
-                ...(typeof value === "number" ? { radiusKm: value } : {}),
-              });
-            }}
-          />
-        </Flex>
-      )}
-      <Button
-        style={{ alignSelf: "flex-start" }}
-        data-testid="search-geo-clear"
-        data-analytics="none"
-        data-analytics-reason="a filter is a read, not a flow step"
-        onClick={() => {
-          setGeo(null);
-        }}
-      >
-        {t(SEARCH_I18N_KEYS.geoClear)}
-      </Button>
-    </Flex>
-  );
-}
 
 /**
  * The slugs the server skipped, named the way the panel names everything else.
@@ -524,6 +422,40 @@ function skippedNames(
     .join(", ");
 }
 
+/**
+ * The empty arm of the panel — the ONE place "this search offers no filters"
+ * may be said, and the two answers that forbid it (D175).
+ *
+ * A group list of zero is not the same claim. `withheld` names groups the
+ * counter counted and then held back for describing too little of the result
+ * set: they exist, so the honest line is how many. `planUnavailable` means
+ * the server could not work a plan out at all — the reader hears that from
+ * `<DegradationNotice>`, and this arm's only job is to not contradict it.
+ *
+ * A COMPONENT rather than a ternary inline in `empty=`, because `LoadList`
+ * reads a nullish `empty` as "no arm given" and draws its own default, which
+ * is the sentence again. An element that renders `null` says nothing; a
+ * `null` prop says it louder.
+ */
+function FacetsEmptyArm(props: { readonly bag: FacetPanelBag }): ReactElement | null {
+  const t = useT();
+  const tPlural = useTPlural();
+  const withheld = props.bag.withheld.length;
+  if (withheld > 0) {
+    return (
+      <EmptyState
+        compact
+        title={tPlural(SEARCH_I18N_KEYS.facetsWithheld, { count: withheld })}
+        testId="facets-withheld"
+      />
+    );
+  }
+  if (props.bag.planUnavailable) return null;
+  return (
+    <EmptyState compact title={t(SEARCH_I18N_KEYS.facetsEmpty)} testId="facets-empty" />
+  );
+}
+
 export function FacetPanelPane(props: FacetPanelPaneProps): ReactElement {
   const t = useT();
   const { state } = useSearchState();
@@ -616,12 +548,6 @@ export function FacetPanelPane(props: FacetPanelPaneProps): ReactElement {
             <LanguageSelect
               {...(props.languages !== undefined ? { languages: props.languages } : {})}
             />
-            <GeoFilter
-              {...(props.renderGeoFilter !== undefined
-                ? { render: props.renderGeoFilter }
-                : {})}
-              {...(props.geoLabel !== undefined ? { label: props.geoLabel } : {})}
-            />
 
             {/* Price, and only the CORE axes — the ones the server declares
                 for every document in every category.
@@ -675,7 +601,7 @@ export function FacetPanelPane(props: FacetPanelPaneProps): ReactElement {
               state={bag.state}
               testId="facets"
               skeletonRows={4}
-              empty={<EmptyState compact title={t(SEARCH_I18N_KEYS.facetsEmpty)} testId="facets-empty" />}
+              empty={<FacetsEmptyArm bag={bag} />}
               failed={(error) => (
                 <ErrorAlert
                   testId="facets-failed"

package/src/default/FilterChips.tsx

@@ -138,12 +138,8 @@ import type { FacetGroup } from "../state/facets.js";
 import { SEARCH_I18N_KEYS } from "../i18n/keys.js";
 import { FacetGroupControl } from "./FacetGroupControl.js";
 import { RangeFilterRow } from "./RangeFilterRow.js";
-import { geoSummaryFallback } from "./FacetPanelPane.js";
-import type {
-  CategoryFilterSlotProps,
-  GeoFilterSlotProps,
-} from "./FacetPanelPane.js";
-import { CHIP_GEO_TEST_IDS, GeoSheet, useApplyLabel } from "./geoSheet.js";
+import type { CategoryFilterSlotProps } from "./FacetPanelPane.js";
+import { useApplyLabel } from "./geoSheet.js";
 
 /** The class the scroller carries, for {@link chipRowCss}. */
 export const CHIP_ROW_CLASS = "stapel-filter-chips";
@@ -179,6 +175,7 @@ const ROW: CSSProperties = {
 
 const CHIP: CSSProperties = { flex: "0 0 auto", borderRadius: radii.full };
 
+
 /** Which picker is open, if any. `null` closes everything. */
 type OpenChip = string | null;
 
@@ -323,19 +320,6 @@ export interface FilterChipsProps {
    * does not, and it is never invented.
    */
   readonly categoryLabel?: ReactNode;
-  /** The location control (`geo-react`), same slot the panel takes. Without
-   * it the location chip appears only when the URL already carries a point,
-   * so a shared link can still be widened. */
-  readonly renderGeoFilter?: (slot: GeoFilterSlotProps) => ReactNode;
-  /**
-   * What the current location constraint is CALLED — see
-   * {@link FacetPanelPaneProps.geoLabel}. The chip carries it as its own text,
-   * which is the whole point of a chip row: "Berlin Mitte" states the filter
-   * on the results page, where `55.756, 37.617` stated only that a machine was
-   * involved. Absent, the chip reads `search.geo.chosen_place`; never a
-   * coordinate, on either surface.
-   */
-  readonly geoLabel?: ReactNode;
   /** Open the whole panel — the leading chip's action. The page owns that
    * sheet, because the page is the surface it covers. */
   readonly onOpenAll: () => void;
@@ -346,16 +330,6 @@ export interface FilterChipsProps {
    * they are always drawn.
    */
   readonly maxRowChips?: number | null;
-  /**
-   * Draw the location chip. Default `true`.
-   *
-   * `false` for a surface that already states the location ABOVE this row —
-   * `<LocationSummaryLine>` is that surface, and the phone SERP mounts both.
-   * Together they printed two location controls one line apart — the summary
-   * sentence over the chip's own prompt — opening two different sheets over
-   * one filter, which is the same constraint asked about twice.
-   */
-  readonly geoChip?: boolean;
 }
 
 /**
@@ -494,18 +468,6 @@ export function FilterChips(props: FilterChipsProps): ReactElement | null {
     props.maxRowChips === undefined ? CHIP_ROW_CAP : props.maxRowChips
   );
 
-  const geo = state.geo;
-  const showGeoChip =
-    props.geoChip !== false &&
-    (props.renderGeoFilter !== undefined || geo !== undefined);
-  // Nothing applied: the chip is the FILTER's name ("Location"), because there
-  // is no constraint to describe yet. Applied: the host's name for the place,
-  // and failing that the sentence that admits the pair does not know it.
-  const geoChipLabel: ReactNode =
-    geo === undefined
-      ? t(SEARCH_I18N_KEYS.geoTitle)
-      : (props.geoLabel ?? geoSummaryFallback(geo, t));
-
   /*
    * A row of one button is not a chip row.
    *
@@ -518,7 +480,7 @@ export function FilterChips(props: FilterChipsProps): ReactElement | null {
    * there is nothing to state, the row states nothing and the surface above
    * keeps its own door.
    */
-  const hasChips = showCategoryChip || showGeoChip || ordered.length > 0;
+  const hasChips = showCategoryChip || ordered.length > 0;
   if (!hasChips) return null;
 
   return (
@@ -570,21 +532,6 @@ export function FilterChips(props: FilterChipsProps): ReactElement | null {
           </Button>
         )}
 
-        {showGeoChip && (
-          <Button
-            style={CHIP}
-            shape="round"
-            type={geo !== undefined ? "primary" : "default"}
-            data-testid="search-chip-geo"
-            data-analytics="none"
-            data-analytics-reason="a filter is a read, not a flow step"
-            onClick={() => {
-              setOpen("geo");
-            }}
-          >
-            {geoChipLabel}
-          </Button>
-        )}
 
         {/* One list, in the row's stated order — see this module's ordering
             note. Rendering ranges and facets as two separate `.map`s is what
@@ -690,19 +637,6 @@ export function FilterChips(props: FilterChipsProps): ReactElement | null {
                 <RangeFilterRow group={group} onApply={bag.setRange} />
               );
         })()}
-
-      {/* The LOCATION sheet is shared with `<LocationSummaryLine>` — the ref
-          puts a location control on both rows, and they must land in the same
-          place. See `geoSheet.tsx`. */}
-      <GeoSheet
-        open={open === "geo"}
-        onClose={close}
-        testIds={CHIP_GEO_TEST_IDS}
-        {...(props.renderGeoFilter !== undefined
-          ? { renderGeoFilter: props.renderGeoFilter }
-          : {})}
-        {...(props.geoLabel !== undefined ? { geoLabel: props.geoLabel } : {})}
-      />
     </>
   );
 }
@@ -710,6 +644,7 @@ export function FilterChips(props: FilterChipsProps): ReactElement | null {
 /** The mark on the "all filters" chip: something is applied. Not a count —
  * the counts are on the chips beside it, and a number inside a 32px circle is
  * a number nobody reads. */
+
 function ActiveDot(): ReactElement {
   return (
     <span