@stapel/listings-react 0.4.0 → 0.8.0

package/src/default/StatusTags.tsx

@@ -1,5 +1,5 @@
 /**
- * The two axes, drawn as two.
+ * The two axes, drawn as two — in ONE visual treatment.
  *
  * `<LifecycleTag>` is the state; `<ModerationNote>` is what the moderation
  * axis adds ON TOP of it, and it renders nothing when there is nothing to add
@@ -8,13 +8,24 @@
  * than one overwriting the other — the failure `model/status.ts` exists to
  * prevent, made visual.
  *
+ * ── Why the note is a line and not an Alert ────────────────────────────────
+ *
+ * It was an antd `Alert`, toned by the moderation status, and the visual pass
+ * measured the result: one concept drawn three ways down a single dashboard —
+ * a full-bleed olive bar for one row, a full-bleed grey bar for the next, bare
+ * red text for a third — and a phone screen where a 340px khaki box wrapped
+ * one sentence over six ragged lines. A status is a status: ONE tag carrying
+ * the tone, and the sentence beneath it as ordinary text. Loud is not the
+ * same as clear, and a row that shouts three different ways is neither.
+ *
  * A tone maps to an antd preset here and nowhere else. No hex leaves this
  * file, because none enters it: the presets resolve through the theme, which
  * resolves through `@stapel/tokens`.
  */
 import type { ReactElement } from "react";
-import { Alert, Tag } from "antd";
+import { Flex, Tag, Typography, theme as antdTheme } from "antd";
 import { useT } from "@stapel/core";
+import { spacing } from "@stapel/tokens";
 import type { ListingStatusTone, ListingStatusView } from "../model/status.js";
 
 const TONE_COLOR: Readonly<Record<ListingStatusTone, string>> = {
@@ -25,14 +36,17 @@ const TONE_COLOR: Readonly<Record<ListingStatusTone, string>> = {
   stopped: "error",
 };
 
-const TONE_ALERT: Readonly<
-  Record<ListingStatusTone, "info" | "success" | "warning" | "error">
+/** How urgent the sentence beneath the tag reads. `warning` is the only tone
+ * that asks the owner to DO something, so it is the only one that gets antd's
+ * danger colour; the rest are secondary text. */
+const TONE_TEXT: Readonly<
+  Record<ListingStatusTone, "secondary" | "warning" | "success">
 > = {
-  neutral: "info",
-  waiting: "info",
+  neutral: "secondary",
+  waiting: "secondary",
   good: "success",
   warning: "warning",
-  stopped: "error",
+  stopped: "warning",
 };
 
 export interface ListingStatusProps {
@@ -40,7 +54,7 @@ export interface ListingStatusProps {
 }
 
 /** The lifecycle state — the field that decides whether anyone else can see
- * this listing. */
+ * this listing. One tag, never full-bleed, never bare text. */
 export function LifecycleTag(props: ListingStatusProps): ReactElement {
   const t = useT();
   return (
@@ -48,6 +62,7 @@ export function LifecycleTag(props: ListingStatusProps): ReactElement {
       color={TONE_COLOR[props.status.lifecycle.tone]}
       data-testid="listings-status-tag"
       data-listing-status={props.status.lifecycle.status}
+      style={{ marginInlineEnd: 0 }}
     >
       {t(props.status.lifecycle.labelKey)}
     </Tag>
@@ -55,32 +70,35 @@ export function LifecycleTag(props: ListingStatusProps): ReactElement {
 }
 
 /**
- * What the moderation axis adds. Renders `null` when it adds nothing, so a
- * calm listing shows no banner at all.
+ * What the moderation axis adds, as one sentence. Renders `null` when it adds
+ * nothing, so a calm listing shows no note at all.
  */
 export function ModerationNote(props: ListingStatusProps): ReactElement | null {
   const t = useT();
+  const { token } = antdTheme.useToken();
   const notice = props.status.moderation;
   if (notice === undefined) return null;
   return (
-    <Alert
-      type={TONE_ALERT[notice.tone]}
-      showIcon
+    <Typography.Text
+      type={TONE_TEXT[notice.tone]}
       data-testid="listings-moderation-note"
       data-listing-moderation={notice.moderationStatus}
       data-listing-live-under-review={String(notice.liveDuringReview)}
-      message={t(notice.messageKey)}
-    />
+      style={{ fontSize: token.fontSizeSM }}
+    >
+      {t(notice.messageKey)}
+    </Typography.Text>
   );
 }
 
 /** Both, in the order a person reads them: what it IS, then what is happening
- * to it. */
+ * to it. A column so the sentence can never be squeezed beside the tag on a
+ * 390px row — the shape that split "Draf/t" across two lines. */
 export function ListingStatusBlock(props: ListingStatusProps): ReactElement {
   return (
-    <>
+    <Flex vertical align="flex-start" gap={spacing[1]} style={{ minWidth: 0 }}>
       <LifecycleTag status={props.status} />
       <ModerationNote status={props.status} />
-    </>
+    </Flex>
   );
 }

package/src/default/index.ts

@@ -13,23 +13,37 @@
  * // the search pair's card slot — the container is the seam, not an import
  * <SearchPage renderCard={(item) => <ListingCard listing={item.card} href={`/l/${item.id}`} />} />
  * ```
+ *
+ * ── What this barrel no longer exports, and where it went ──────────────────
+ *
+ * `ListingsSkinTheme` and `ErrorAlert` were this pair's copies of two
+ * components nine pairs each carried a copy of. They live in
+ * `@stapel/tokens-antd/skin` now, as `SkinTheme` and `ErrorAlert`: one place
+ * for the reactive-theme fix, one place for the message/detail split. A host
+ * that wrapped its own composition in `<ListingsSkinTheme>` imports
+ * `<SkinTheme>` from the substrate instead — same props, plus a `surface`.
  */
 export { ListingCard } from "./ListingCard.js";
 export type {
   ListingCardProps,
   ListingCardBaseProps,
   ListingCardOpenProps,
+  ListingCardBlockedReason,
 } from "./ListingCard.js";
-export { ListingDetailPane } from "./ListingDetailPane.js";
+export { ListingDetailPane, DETAIL_MEASURE, DETAIL_PHOTO_MIN } from "./ListingDetailPane.js";
 export type { ListingDetailPaneProps } from "./ListingDetailPane.js";
-export { ListingComposerPage } from "./ListingComposerPage.js";
+export { ListingComposerPage, COMPOSER_MEASURE } from "./ListingComposerPage.js";
 export type {
   ListingComposerPageProps,
   ComposerCategorySlot,
+  ComposerCurrencySlot,
+  ComposerLocationSlot,
+  ComposerLocationValue,
+  ComposerLocationPickerProps,
 } from "./ListingComposerPage.js";
 export { MyListingsPane } from "./MyListingsPane.js";
 export type { MyListingsPaneProps } from "./MyListingsPane.js";
-export { FavoritesPane } from "./FavoritesPane.js";
+export { FavoritesPane, FAVORITES_CARD_MIN } from "./FavoritesPane.js";
 export type {
   FavoritesPaneProps,
   FavoritesPaneOpenProps,
@@ -37,11 +51,8 @@ export type {
 
 export { LifecycleTag, ListingStatusBlock, ModerationNote } from "./StatusTags.js";
 export type { ListingStatusProps } from "./StatusTags.js";
-export { ListingPhoto } from "./ListingPhoto.js";
+export { ListingPhoto, LISTING_PHOTO_ASPECT } from "./ListingPhoto.js";
 export type { ListingPhotoProps } from "./ListingPhoto.js";
-export { ErrorAlert } from "./ErrorAlert.js";
 export { SignInLink } from "./SignInLink.js";
 export type { SignInLinkProps } from "./SignInLink.js";
-export { ListingsSkinTheme } from "./theme.js";
-export type { ListingsSkinThemeProps } from "./theme.js";
 export type { ThemeModeProp } from "./types.js";

package/src/headless/Favorites.tsx

@@ -13,7 +13,10 @@ import type { ListingCard, ListingPageParams } from "../api/types.js";
 import { useMyFavorites } from "../model/queries.js";
 import { useFavoriteListing } from "../model/mutations.js";
 import { LISTINGS_I18N_KEYS } from "../i18n/keys.js";
-import { useMandateGate } from "./useMandateGate.js";
+import {
+  LISTINGS_ELEVATION_ACTIONS,
+  useElevatableMandateGate,
+} from "./useMandateGate.js";
 
 /**
  * Saving something for later — first-class in stapel-listings (a `Favorite`
@@ -48,29 +51,40 @@ export function useFavoriteToggle(
   id: number,
   favorited: boolean | null | undefined
 ): FavoriteToggleBag {
-  const mandate = useMandateGate();
+  const { gate: mandate, elevation } = useElevatableMandateGate(
+    LISTINGS_ELEVATION_ACTIONS.favorite
+  );
   const mutation = useFavoriteListing();
   const gate = firstBlock(
     mandate,
-    mutation.isPending
+    mutation.isPending || elevation.pending
       ? actionBlocked(LISTINGS_I18N_KEYS.blockedInFlight)
       : actionAvailable()
   );
   return {
     favorited: favorited === true,
     gate,
+    // On a host with auto-anonymous wired, the first heart an anonymous
+    // visitor presses mints their account and then saves — one press, no
+    // form, nothing said about it. Everywhere else `run` performs directly.
     toggle: () => {
       if (!gate.available) return;
-      mutation.mutate({ id, favorited: favorited !== true });
+      elevation.run(() => mutation.mutate({ id, favorited: favorited !== true }));
     },
-    inFlight: mutation.isPending,
-    error: mutation.error,
+    inFlight: mutation.isPending || elevation.pending,
+    error: mutation.error ?? elevation.error,
   };
 }
 
 export interface FavoritesBag {
   readonly rows: LoadState<readonly ListingCard[]>;
   readonly page: ListingPageParams;
+  /**
+   * Which page is on screen, 1-based. Keyset paging has no offset to read a
+   * number off, so it is counted: a pager with no indicator leaves a person
+   * unable to tell a second page from a reloaded first one.
+   */
+  readonly pageNumber: number;
   readonly nextPage: ActionAvailability;
   readonly prevPage: ActionAvailability;
   goNext(): void;
@@ -86,10 +100,22 @@ export interface UseFavoritesOptions {
 /** The favourites page: a real keyset list, unlike the owner's own listings
  * (see `MyListings.tsx` for why those are different). */
 export function useFavorites(options: UseFavoritesOptions = {}): FavoritesBag {
-  const gate = useMandateGate();
+  // The READ side of elevation, and the one place `identified` is the right
+  // question. A guest who saved listings must be able to come back and see
+  // them — an account that can save and cannot re-read is worse than the
+  // refusal it replaced — but a visitor who has never elevated has nothing
+  // here, so this page must not mint just to render. `covers` alone would
+  // open it for them and buy a 401.
+  const { gate: mandateGate, elevation } = useElevatableMandateGate(
+    LISTINGS_ELEVATION_ACTIONS.favorite
+  );
+  const gate = elevation.covers && !elevation.identified
+    ? actionBlocked(LISTINGS_I18N_KEYS.blockedSignIn)
+    : mandateGate;
   const [page, setPage] = useState<ListingPageParams>(
     options.limit !== undefined ? { limit: options.limit } : {}
   );
+  const [pageNumber, setPageNumber] = useState(1);
   const query = useMyFavorites(page, { enabled: gate.available });
   const envelope = query.data;
 
@@ -101,6 +127,7 @@ export function useFavorites(options: UseFavoritesOptions = {}): FavoritesBag {
           ? loadReady(envelope.items)
           : loadLoading(),
     page,
+    pageNumber,
     nextPage:
       envelope?.has_next === true && envelope.next_anchor != null
         ? actionAvailable()
@@ -113,11 +140,13 @@ export function useFavorites(options: UseFavoritesOptions = {}): FavoritesBag {
       const anchor = envelope?.next_anchor;
       if (anchor == null) return;
       setPage((current) => ({ ...current, anchor, direction: "next" }));
+      setPageNumber((current) => current + 1);
     },
     goPrev: () => {
       const anchor = envelope?.prev_anchor;
       if (anchor == null) return;
       setPage((current) => ({ ...current, anchor, direction: "prev" }));
+      setPageNumber((current) => Math.max(1, current - 1));
     },
     gate,
     refetch: () => {

package/src/headless/ListingActions.tsx

@@ -33,6 +33,18 @@ export interface ListingActionsBag {
   readonly archive: ActionAvailability;
   readonly complete: ActionAvailability;
   readonly remove: ActionAvailability;
+  /**
+   * Whether "edit this listing" is offerable — and if not, WHY.
+   *
+   * Editing is not an endpoint this pair calls: the composer is a screen, and
+   * whether the app has one is the container's fact, which is why it arrives
+   * as an argument rather than being derived. It is a gate all the same,
+   * because the alternative shipped for two releases: `<GatedButton gate={{
+   * available: true }}>` beside an absent `onEdit`, i.e. an enabled button
+   * that did nothing at all in the scripted scaffold (§83, "a control that
+   * offers something meaningless in the current state").
+   */
+  editGate(hasEditor: boolean): ActionAvailability;
   doArchive(): void;
   doComplete(): void;
   doRemove(): void;
@@ -86,6 +98,13 @@ export function useListingActions(
     archive: archiveGate,
     complete: completeGate,
     remove: removeGate,
+    editGate: (hasEditor) =>
+      firstBlock(
+        mandate,
+        hasEditor
+          ? actionAvailable()
+          : actionBlocked(LISTINGS_I18N_KEYS.blockedNoEditor)
+      ),
     doArchive: () => {
       if (archiveGate.available) archive.mutate(id);
     },

package/src/headless/ListingComposer.tsx

@@ -122,6 +122,18 @@ export interface UseListingComposerOptions {
   /** Value types the rendering half can draw — pass
    * `BUILTIN_VALUE_EDITOR_TYPES` from `@stapel/attributes-react/default`. */
   readonly editorTypes?: readonly string[];
+  /**
+   * The language a NEW draft is written in — the composer's own UI locale, in
+   * practice (`useI18n().locale`).
+   *
+   * `Listing.language` is sent on every save and was never settable: a blank
+   * value let the server's deployment default decide, so a Spanish seller's
+   * listing was filed as Russian because that is what the storefront defaults
+   * to. Seeding it from the locale the form is being READ in is the only
+   * honest guess a library can make, and a host that knows better passes
+   * `initialValues.language`, which still wins.
+   */
+  readonly language?: string;
   /** The upload queue. Absent: no gallery, and `images` is set through
    * `setValue` by whatever the host uses instead. */
   readonly images?: ListingImagesBag;
@@ -186,6 +198,17 @@ export interface ListingComposerBag {
   readonly saveGate: ActionAvailability;
   readonly publishGate: ActionAvailability;
   save(): void;
+  /**
+   * Save once the state written in this same handler has landed.
+   *
+   * `save()` closes over the values of the render it was created in, so a
+   * picker doing `setLocation(place); save()` in one click saved the draft as
+   * it was BEFORE the place was chosen — the plain fields never hit this
+   * because a blur is always a separate tick from the keystroke. A picker has
+   * no blur: choosing a suggestion IS the commit, so it needs a save that runs
+   * after the write it belongs to.
+   */
+  saveSoon(): void;
   publish(): void;
   readonly saving: boolean;
   readonly publishing: boolean;
@@ -204,7 +227,10 @@ export function useListingComposer(
     options.listingId
   );
   const [values, setValues] = useState<ListingDraftValues>(() => ({
-    ...emptyDraftValues({ currency: runtime.currency }),
+    ...emptyDraftValues({
+      currency: runtime.currency,
+      ...(options.language !== undefined ? { language: options.language } : {}),
+    }),
     ...options.initialValues,
   }));
   const [showErrors, setShowErrors] = useState(false);
@@ -212,6 +238,9 @@ export function useListingComposer(
   const [refusal, setRefusal] = useState<PublishRefusal | undefined>(undefined);
   const [outcome, setOutcome] = useState<PublishOutcome | undefined>(undefined);
   const [saved, setSaved] = useState(false);
+  // A counter rather than a boolean: two picks in a row are two saves, and a
+  // boolean that was already `true` would swallow the second.
+  const [saveRequest, setSaveRequest] = useState(0);
 
   const existing = useListing(options.listingId);
   const createDraft = useCreateDraft();
@@ -349,18 +378,26 @@ export function useListingComposer(
     mandate,
     categoryGate,
     schemaGate,
+    // The type names (`size_grid`) are this build's vocabulary, not copy: a
+    // seller can act on "finish it somewhere else", never on the identifier.
     unsupported.length > 0
-      ? actionBlocked(LISTINGS_I18N_KEYS.composeBlockedUnsupportedType, {
-          types: unsupported.join(", "),
-        })
+      ? actionBlocked(LISTINGS_I18N_KEYS.composeBlockedUnsupportedType)
       : actionAvailable(),
     options.images?.settled ?? actionAvailable(),
     busyGate,
     publishListing.isPending
       ? actionBlocked(LISTINGS_I18N_KEYS.composeBlockedBusy)
       : actionAvailable(),
+    // "Fix the highlighted fields first" is only true once something IS
+    // highlighted — the mirror reaches the fields only after `showErrors`.
+    // Before that the same block has to say what is actually missing.
     Object.keys(mirror).length > 0
-      ? actionBlocked(LISTINGS_I18N_KEYS.composeBlockedMirror)
+      ? actionBlocked(
+          showErrors
+            ? LISTINGS_I18N_KEYS.composeBlockedMirror
+            : LISTINGS_I18N_KEYS.composeBlockedIncomplete,
+          showErrors ? undefined : { count: Object.keys(mirror).length }
+        )
       : actionAvailable()
   );
 
@@ -401,6 +438,19 @@ export function useListingComposer(
     });
   }, [saveGate.available, persist]);
 
+  // `save` through a ref, so the effect below can run the CURRENT one without
+  // re-firing every time the form changes shape.
+  const saveRef = useRef(save);
+  saveRef.current = save;
+  useEffect(() => {
+    if (saveRequest === 0) return;
+    saveRef.current();
+  }, [saveRequest]);
+
+  const saveSoon = useCallback((): void => {
+    setSaveRequest((current) => current + 1);
+  }, []);
+
   const publish = useCallback((): void => {
     setShowErrors(true);
     if (!publishGate.available) return;
@@ -489,6 +539,7 @@ export function useListingComposer(
     saveGate,
     publishGate,
     save,
+    saveSoon,
     publish,
     saving: busy,
     publishing: publishListing.isPending,

package/src/headless/ListingDetail.tsx

@@ -21,7 +21,10 @@ import { asFeatureDaoList, featuresFromDaoList, unreadableFeatureCount } from ".
 import { listingStatusView } from "../model/status.js";
 import type { ListingStatusView } from "../model/status.js";
 import { LISTINGS_I18N_KEYS } from "../i18n/keys.js";
-import { useMandateGate } from "./useMandateGate.js";
+import {
+  LISTINGS_ELEVATION_ACTIONS,
+  useElevatableMandateGate,
+} from "./useMandateGate.js";
 
 /**
  * `images` is `string[] | NULL` on the wire, and the null is the SERVER
@@ -110,7 +113,9 @@ export function useListingDetail(
   const detail = useListing(id);
   const probe = useListingStatus(id);
   const favorite = useFavoriteListing();
-  const mandate = useMandateGate();
+  const { gate: mandate, elevation } = useElevatableMandateGate(
+    LISTINGS_ELEVATION_ACTIONS.favorite
+  );
 
   const state: LoadState<ListingDetailData> =
     detail.status === "error"
@@ -178,7 +183,7 @@ export function useListingDetail(
 
   const favoriteGate = firstBlock(
     mandate,
-    favorite.isPending
+    favorite.isPending || elevation.pending
       ? actionBlocked(LISTINGS_I18N_KEYS.blockedInFlight)
       : actionAvailable(),
     detail.data === undefined
@@ -206,9 +211,11 @@ export function useListingDetail(
     favoriteGate,
     toggleFavorite: () => {
       if (!favoriteGate.available) return;
-      favorite.mutate({ id, favorited: isFavorited !== true });
+      // Mints the anonymous account first where the host permits it for this
+      // action; a direct call everywhere else.
+      elevation.run(() => favorite.mutate({ id, favorited: isFavorited !== true }));
     },
-    favoriteInFlight: favorite.isPending,
+    favoriteInFlight: favorite.isPending || elevation.pending,
     refetch: () => {
       void detail.refetch();
       void probe.refetch();

package/src/headless/useMandateGate.ts

@@ -1,8 +1,24 @@
-import { matchMandate, useMandate } from "@stapel/core";
-import type { ActionAvailability } from "@stapel/core";
+import { matchMandate, useElevation, useMandate } from "@stapel/core";
+import type { ActionAvailability, Elevation } from "@stapel/core";
 import { actionAvailable, actionBlocked } from "@stapel/core";
 import { LISTINGS_I18N_KEYS } from "../i18n/keys.js";
 
+/**
+ * The names this pair's gated writes use when asking core's elevation seam
+ * whether an anonymous visitor may be given an identity instead of a
+ * refusal. A host lists the ones it permits (see `ElevationSource.actions`);
+ * anything it leaves out keeps its wall.
+ *
+ * Only `favorite` is named. Publishing a listing is deliberately absent and
+ * stays absent: a seller who cannot be reached again is not a seller, and an
+ * automatically-minted account is exactly that. Saving something for later
+ * is the opposite case — losing a shortlist because a stranger had not
+ * registered is friction with nothing behind it.
+ */
+export const LISTINGS_ELEVATION_ACTIONS = {
+  favorite: "listings.favorite",
+} as const;
+
 /**
  * "May this person act at all?" — the first gate on every write in the pair.
  *
@@ -28,13 +44,41 @@ import { LISTINGS_I18N_KEYS } from "../i18n/keys.js";
  * than throwing, so a pair rendered in a host that never wired the axis
  * degrades to "we could not check" — visible, fixable, and not a blank page.
  */
-export function useMandateGate(): ActionAvailability {
+export function useMandateGate(action?: string): ActionAvailability {
+  return useElevatableMandateGate(action).gate;
+}
+
+/**
+ * The same gate, with the elevation handle the caller needs to ACT on it.
+ *
+ * A control that passes an `action` is saying "for this one act, an
+ * anonymous visitor may be given an identity rather than a refusal" — and
+ * then it must run its write through `elevation.run`, or the write goes out
+ * before the account exists and buys a 401. The two halves are returned
+ * together so a caller cannot take the unblocked gate and forget the mint.
+ *
+ * Passing no `action` is the default and the majority: publishing, saving a
+ * draft, marking something sold. Those keep the wall.
+ */
+export function useElevatableMandateGate(action?: string): {
+  readonly gate: ActionAvailability;
+  readonly elevation: Elevation;
+} {
   const mandate = useMandate();
-  return matchMandate<ActionAvailability>(mandate, {
+  const elevation = useElevation(action);
+  const gate = matchMandate<ActionAvailability>(mandate, {
     member: () => actionAvailable(),
     guest: () => actionBlocked(LISTINGS_I18N_KEYS.blockedGuest),
-    anonymous: () => actionBlocked(LISTINGS_I18N_KEYS.blockedSignIn),
+    // The one arm elevation changes. An identity can be minted at the moment
+    // of the act for the actions the host listed, so the control is offered
+    // rather than refused — and the mandate axis itself is untouched, which
+    // is what keeps the composer's wall standing for the same visitor.
+    anonymous: () =>
+      elevation.covers
+        ? actionAvailable()
+        : actionBlocked(LISTINGS_I18N_KEYS.blockedSignIn),
     asking: () => actionBlocked(LISTINGS_I18N_KEYS.blockedMandateUnknown),
     unavailable: () => actionBlocked(LISTINGS_I18N_KEYS.blockedMandateUnknown),
   });
+  return { gate, elevation };
 }

package/src/i18n/es.ts

@@ -1,4 +1,5 @@
 import type { I18nDictionary, I18nEngine } from "@stapel/core";
+import { registerAttributesI18nEs } from "@stapel/attributes-react/i18n/es";
 import { listingsErrorBundleEs } from "./generated/errors.es.gen.js";
 
 export { listingsErrorBundleEs } from "./generated/errors.es.gen.js";
@@ -31,6 +32,8 @@ export const listingsI18nBundleEs: I18nDictionary = {
     "Estado de anuncio desconocido: «{status}»",
   "error.400.publish_validation_failed":
     "El anuncio no pasó la revisión y no se publicó",
+  "error.403.listing_anonymous_not_allowed":
+    "Para publicar un anuncio, inicia sesión o crea una cuenta",
   "error.403.listing_not_owner": "Este anuncio no es tuyo",
   "error.404.listing_not_found": "No se encontró el anuncio",
   "error.409.already_favorited": "El anuncio ya está en favoritos",
@@ -71,7 +74,7 @@ export const listingsI18nBundleEs: I18nDictionary = {
   "listings.card.price_absent": "Precio a consultar",
   "listings.card.favorite_add": "Guardar en favoritos",
   "listings.card.favorite_remove": "Quitar de favoritos",
-  "listings.card.open": "Abrir",
+  "listings.card.untitled": "Anuncio sin título",
   "listings.card.sign_in": "Iniciar sesión",
 
   "listings.detail.loading": "Cargando el anuncio…",
@@ -94,6 +97,8 @@ export const listingsI18nBundleEs: I18nDictionary = {
   "listings.detail.published_at": "Publicado el {date}",
   "listings.detail.expires_at": "A la venta hasta el {date}",
   "listings.detail.stock": "Disponibles",
+  "listings.detail.edit": "Editar el anuncio",
+  "listings.detail.take_down": "Retirarlo",
 
   "listings.compose.new_title": "Anuncio nuevo",
   "listings.compose.edit_title": "Editar el anuncio",
@@ -112,8 +117,8 @@ export const listingsI18nBundleEs: I18nDictionary = {
     "Escribe el precio como un número, con dos decimales como mucho",
   "listings.compose.currency_label": "Moneda",
   "listings.compose.location_label": "Dónde está",
-  "listings.compose.lat_label": "Latitud",
-  "listings.compose.lon_label": "Longitud",
+  "listings.compose.location_help":
+    "La gente busca por distancia — un anuncio sin lugar es un anuncio que no encontrarán",
   "listings.compose.geo_incomplete":
     "Una latitud necesita su longitud al lado — media coordenada no apunta a ningún sitio",
   "listings.compose.photos": "Fotos",
@@ -143,12 +148,13 @@ export const listingsI18nBundleEs: I18nDictionary = {
   "listings.compose.blocked.no_category":
     "Elige una categoría — el resto del formulario depende de ella",
   "listings.compose.blocked.unsupported_type":
-    "Esta categoría pide un tipo de detalle que la aplicación todavía no sabe mostrar ({types}), así que aquí no se puede rellenar",
+    "Esta categoría pide un tipo de detalle que la aplicación todavía no sabe mostrar, así que el anuncio no se puede completar aquí",
   "listings.compose.blocked.photos_pending":
     "Espera a que terminen de subirse las fotos",
   "listings.compose.blocked.no_draft": "El borrador todavía no está creado",
   "listings.compose.blocked.busy":
     "Un momento — el último cambio se está guardando",
+  "listings.compose.blocked.incomplete": "Faltan {count} datos obligatorios",
   "listings.compose.blocked.mirror": "Corrige primero los campos marcados",
   "listings.compose.blocked.details_unavailable":
     "No pudimos cargar lo que pide esta categoría, así que no podemos revisar el formulario",
@@ -167,6 +173,8 @@ export const listingsI18nBundleEs: I18nDictionary = {
   "listings.mine.empty.archived": "Nada archivado, pausado, caducado ni vendido todavía",
   "listings.mine.blocked.title":
     "Moderación retiró {count} de tus anuncios",
+  "listings.mine.blocked.title.one": "Moderación retiró uno de tus anuncios",
+  "listings.mine.blocked.title.other": "Moderación retiró {count} de tus anuncios",
   "listings.mine.blocked.load_failed":
     "No pudimos comprobar si alguno de tus anuncios fue retirado",
   "listings.mine.live_under_review": "Publicado, cambios en revisión",
@@ -174,11 +182,18 @@ export const listingsI18nBundleEs: I18nDictionary = {
   "listings.mine.archive": "Archivar",
   "listings.mine.complete": "Marcar como vendido",
   "listings.mine.delete": "Borrar",
+  "listings.mine.delete_confirm_title": "¿Borrar este anuncio?",
+  "listings.mine.delete_confirm_body":
+    "Desaparece de tu panel y no se puede recuperar. Archivarlo lo conserva.",
 
   "listings.favorites.title": "Favoritos",
   "listings.favorites.loading": "Cargando tus favoritos…",
   "listings.favorites.load_failed": "No pudimos cargar tus favoritos",
   "listings.favorites.empty": "Todavía no has guardado nada",
+  "listings.favorites.empty_hint":
+    "Toca el corazón en cualquier anuncio y te estará esperando aquí.",
+  "listings.favorites.sign_in_hint":
+    "Los favoritos se guardan en tu cuenta, así que te siguen entre dispositivos.",
 
   "listings.blocked.sign_in": "Inicia sesión para hacer esto",
   "listings.blocked.guest":
@@ -190,9 +205,12 @@ export const listingsI18nBundleEs: I18nDictionary = {
   "listings.blocked.delete_active":
     "Archívalo primero — un anuncio a la venta no se puede borrar",
   "listings.blocked.in_flight": "Un momento — eso ya está en marcha",
+  "listings.blocked.no_editor":
+    "Esta aplicación todavía no tiene una pantalla para editar un anuncio",
 
   "listings.page.prev": "Anterior",
   "listings.page.next": "Siguiente",
+  "listings.page.indicator": "Página {page}",
 
   "listings.nav.detail": "Anuncio",
   "listings.nav.compose": "Poner un anuncio",
@@ -200,7 +218,13 @@ export const listingsI18nBundleEs: I18nDictionary = {
   "listings.nav.favorites": "Favoritos",
 };
 
-/** Register the Spanish bundle into a core i18n engine. */
+/**
+ * Register the Spanish bundle — and, exactly as in `./ru.ts`, the twelve
+ * `stapel_attributes` sentences this pair does not author. The ownership split
+ * is a rule about who WRITES a string, not an instruction to ship two thirds
+ * of a locale and document the rest.
+ */
 export function registerListingsI18nEs(i18n: I18nEngine): void {
+  registerAttributesI18nEs(i18n);
   i18n.registerBundle("es", listingsI18nBundleEs);
 }

package/src/i18n/generated/errors.es.gen.ts

@@ -8,7 +8,7 @@ import type { ListingsErrorCode } from "./errors.gen.js";
 /**
  * `es` texts for the backend error codes this catalog carries.
  *
- * PARTIAL, and deliberately typed to say so: 22 key(s) owned by
+ * PARTIAL, and deliberately typed to say so: 23 key(s) owned by
  * stapel_attributes, stapel_listings are absent, because that owner ships no locale catalog
  * (ERRORS_LOCALE_EXEMPT_OWNERS). English for them still comes from the registry
  * artifact via the en bundle; the pair layers its own authored `es`