@mohasinac/appkit 4.71.0 → 4.71.2

package/dist/_internal/shared/listing-types/hidden-surfaces.d.ts

@@ -20,7 +20,7 @@
  *
  * | | rule | why the other rule would break it |
  * |---|---|---|
- * | `hiddenSurfaceRoutes` — listing-type browse pages | **exact path** | `art`, `stickers`, `spares` and `standard` all detail at `/products/{slug}`, so a prefix rule would 404 the whole standard catalogue the day `spares` emptied |
+ * | `hiddenSurfaceRoutes` — listing-type browse pages | **exact path** | `art-and-stickers`, `spares` and `standard` all detail at `/products/{slug}`, so a prefix rule would 404 the whole standard catalogue the day `spares` emptied |
  * | `closedSurfacePrefixes` — browse sections, bundles, `disabledRoutes` | **prefix** | `/categories/{slug}` is owned by `categories` alone, and exact-only matching left all 4,698 of them serving a real 200 while `/categories` said 404 |
  *
  * Do not merge them. Picking either rule for both is a live defect one way or
@@ -28,9 +28,10 @@
  *
  * ## 🛑 A SHARED route survives while ANY of its types is visible
  *
- * `/art` spans `art` and `stickers`; `/products` spans `standard` plus several
- * others. Without `hiddenSurfaceRoutes`' second pass, hiding `stickers` alone
- * would close a page `art` still fills — and hiding `spares` alone would close
+ * `/art` is `art-and-stickers`' own page; `/products` spans `standard` plus
+ * several others. Without `hiddenSurfaceRoutes`' second pass, hiding one
+ * claimant of a SHARED route would close a page its co-claimant still fills —
+ * and hiding `spares` alone would close
  * `/products`.
  *
  * @tag domain:products
@@ -38,13 +39,21 @@
  * @tag access:isomorphic
  * @tag sideEffects:none
  */
-import { type BrowsePageKey, type SurfaceCountSnapshot } from "./feature-flags";
-/** The snapshot shape `isListingSurfaceVisible` reads its admin flags from. */
+import { type BrowsePageKey, type FlagValue, type SurfaceCountSnapshot } from "./feature-flags";
+/**
+ * The snapshot shape `isListingSurfaceVisible` reads its admin flags from.
+ *
+ * `FlagValue` (not `boolean`) because `isListingTypeEnabled`/
+ * `isCategoryTypeEnabled`/`isBrowsePageEnabled` all read `"unlisted"` as
+ * enabled (`!== false`) — the 404 gate this module drives must agree with
+ * them, or `SiteSettingsDocument`'s widened `listings` shape (which carries
+ * the real `"unlisted"` value) could never satisfy this interface.
+ */
 interface SettingsSnapshot {
     listings?: {
-        listingTypes?: Partial<Record<string, boolean>>;
-        browsePages?: Partial<Record<BrowsePageKey, boolean>>;
-        categoryTypes?: Partial<Record<string, boolean>>;
+        listingTypes?: Partial<Record<string, FlagValue>>;
+        browsePages?: Partial<Record<BrowsePageKey, FlagValue>>;
+        categoryTypes?: Partial<Record<string, FlagValue>>;
         closedPaths?: string[];
     };
     disabledRoutes?: string[];
@@ -56,7 +65,7 @@ export declare function hiddenSurfaceRoutes(settings: SettingsSnapshot | null |
  * ## Why this is a second function and not more entries in the first
  *
  * `hiddenSurfaceRoutes` above is exact-path-only, and its docstring explains
- * why it has to be: `art`, `stickers`, `spares` and `standard` all detail at
+ * why it has to be: `art-and-stickers`, `spares` and `standard` all detail at
  * `/products/{slug}`, so a prefix rule there would 404 the whole standard
  * catalogue the day `spares` emptied.
  *

package/dist/_internal/shared/listing-types/hidden-surfaces.js

@@ -20,7 +20,7 @@
  *
  * | | rule | why the other rule would break it |
  * |---|---|---|
- * | `hiddenSurfaceRoutes` — listing-type browse pages | **exact path** | `art`, `stickers`, `spares` and `standard` all detail at `/products/{slug}`, so a prefix rule would 404 the whole standard catalogue the day `spares` emptied |
+ * | `hiddenSurfaceRoutes` — listing-type browse pages | **exact path** | `art-and-stickers`, `spares` and `standard` all detail at `/products/{slug}`, so a prefix rule would 404 the whole standard catalogue the day `spares` emptied |
  * | `closedSurfacePrefixes` — browse sections, bundles, `disabledRoutes` | **prefix** | `/categories/{slug}` is owned by `categories` alone, and exact-only matching left all 4,698 of them serving a real 200 while `/categories` said 404 |
  *
  * Do not merge them. Picking either rule for both is a live defect one way or
@@ -28,9 +28,10 @@
  *
  * ## 🛑 A SHARED route survives while ANY of its types is visible
  *
- * `/art` spans `art` and `stickers`; `/products` spans `standard` plus several
- * others. Without `hiddenSurfaceRoutes`' second pass, hiding `stickers` alone
- * would close a page `art` still fills — and hiding `spares` alone would close
+ * `/art` is `art-and-stickers`' own page; `/products` spans `standard` plus
+ * several others. Without `hiddenSurfaceRoutes`' second pass, hiding one
+ * claimant of a SHARED route would close a page its co-claimant still fills —
+ * and hiding `spares` alone would close
  * `/products`.
  *
  * @tag domain:products
@@ -68,7 +69,7 @@ export function hiddenSurfaceRoutes(settings, counts) {
  * ## Why this is a second function and not more entries in the first
  *
  * `hiddenSurfaceRoutes` above is exact-path-only, and its docstring explains
- * why it has to be: `art`, `stickers`, `spares` and `standard` all detail at
+ * why it has to be: `art-and-stickers`, `spares` and `standard` all detail at
  * `/products/{slug}`, so a prefix rule there would 404 the whole standard
  * catalogue the day `spares` emptied.
  *

package/dist/_internal/shared/listing-types/live/config.d.ts

@@ -20,6 +20,7 @@ export declare const config: {
     inGeneralCatalogue: boolean;
     canJoinProductGroup: boolean;
     iconKey: "live";
+    primaryActionKind: "buy-now";
     hideDefault: "sold";
     isAvailable: typeof alwaysAvailable;
     unavailableClauses: readonly import("../availability").UnavailableClause[];

package/dist/_internal/shared/listing-types/live/config.js

@@ -24,6 +24,7 @@ export const config = {
     // jurisdiction-gated per buyer and vendor-verified — not mixable into a group line
     canJoinProductGroup: false,
     iconKey: "live",
+    primaryActionKind: "buy-now",
     hideDefault: "sold",
     // Runs out rather than ending — no time dimension, so the shared
     // stock-only rules are the whole story for this type.

package/dist/_internal/shared/listing-types/pre-order/config.d.ts

@@ -20,6 +20,7 @@ export declare const config: {
     inGeneralCatalogue: boolean;
     canJoinProductGroup: boolean;
     iconKey: "preOrder";
+    primaryActionKind: "reserve";
     hideDefault: "closed";
     isAvailable: (row: AvailabilityRow) => boolean;
     unavailableClauses: readonly import("../availability").UnavailableClause[];

package/dist/_internal/shared/listing-types/pre-order/config.js

@@ -24,12 +24,27 @@ export const config = {
     // a deposit against a future release; members would ship at different times
     canJoinProductGroup: false,
     iconKey: "preOrder",
+    primaryActionKind: "reserve",
     hideDefault: "closed",
-    // A pre-order closes when its allocation fills, NOT when its delivery date
-    // passes — a shipped-soon pre-order is still orderable. `preOrderClosed`
-    // exists on the schema but no write path has ever set it, so the count pair
-    // is the only real signal; it is checked defensively anyway in case one
-    // starts.
+    /*
+     * A pre-order closes when its allocation fills, NOT when its delivery date
+     * passes — a shipped-soon pre-order is still orderable.
+     *
+     * 🛑 THIS IS THE CANONICAL PRE-ORDER AVAILABILITY RULE. `./schema.ts`'s
+     * `isOpenPreOrder` used to state a different one — it gated on the delivery
+     * date with a non-null assertion on an optional field, so a dateless
+     * pre-order read as closed — and it now DELEGATES here. The date is a
+     * checkout input, not an availability input: `preOrderRule.preflightChecks`
+     * refuses a past or beyond-45-day date at the moment money would move. See
+     * `features/products/constants/preorder-window.ts`.
+     *
+     * 🛑 `preOrderClosed` NOW HAS A WRITE PATH. This comment used to say "no
+     * write path has ever set it", and the reason was not that nobody tried: the
+     * field was absent from `PRODUCT_UPDATABLE_FIELDS`, so the write schema
+     * dropped it while returning 200 (Root Cause #101). It is in both the
+     * updatable and public lists as of Phase 2, so this check is load-bearing
+     * rather than defensive.
+     */
     isAvailable: (row) => {
         if (row[PRODUCT_FIELDS.PRE_ORDER_CLOSED] === true)
             return false;

package/dist/_internal/shared/listing-types/pre-order/schema.d.ts

@@ -1,3 +1,48 @@
 import type { ProductDocument } from "../../../../features/products/schemas/firestore";
 export declare function isPreOrderProduct(doc: ProductDocument): boolean;
+/**
+ * True when the pre-order window is still open.
+ *
+ * ## 🛑 `config.ts` WINS. This function used to disagree with it, and it was
+ * the one that was wrong — twice over.
+ *
+ * It read:
+ *
+ *     isPreOrderProduct(doc) && !doc.preOrderClosed && doc.preOrderDeliveryDate! > new Date()
+ *
+ * Two defects in one expression:
+ *
+ *  1. **The `!` assertion on an OPTIONAL field.** `preOrderDeliveryDate?: Date`,
+ *     so on a dateless pre-order this evaluated `undefined > new Date()` →
+ *     `false`, silently calling every such listing CLOSED. The non-null
+ *     assertion is what hid it from `tsc`: the only tool that could have said
+ *     so was told not to.
+ *  2. **Gating availability on the delivery date at all.** That is the
+ *     substantive disagreement, and `config.ts:37-48` states the right rule
+ *     with its reason: *"A pre-order closes when its allocation fills, NOT when
+ *     its delivery date passes — a shipped-soon pre-order is still orderable."*
+ *     A pre-order due tomorrow is the most orderable it will ever be.
+ *
+ * So the date is **not** an availability input. It is a CHECKOUT input — the
+ * 45-day rule lives in `preOrderRule.preflightChecks`, which refuses a past or
+ * beyond-window date at the moment money would move, and in the write-side cap
+ * that stops such a listing existing. Those are the places a date belongs:
+ * availability answers "is this listing live", the rule answers "may this
+ * payment be taken".
+ *
+ * 🛑 This now DELEGATES rather than restating the three conditions. Four
+ * partial copies of one predicate, none of them the definition, is Root Cause
+ * #73 — and this was copy number two. `config.isAvailable` is the per-type half
+ * of the canonical predicate (`isListingRowAvailable` in `_registry.ts` pairs
+ * it with the shared stock clauses), so calling it is what makes "they agree"
+ * structural instead of a comment claiming they do.
+ *
+ * ## Callers
+ *
+ * None, measured at the time this was fixed — which is why correcting the
+ * behaviour here is safe rather than a change of meaning somewhere unseen. If
+ * you are about to add one, prefer `isListingRowAvailable(row)` from
+ * `_registry.ts`: it also applies the shared sold/stock checks that this
+ * type-specific half deliberately does not.
+ */
 export declare function isOpenPreOrder(doc: ProductDocument): boolean;

package/dist/_internal/shared/listing-types/pre-order/schema.js

@@ -1,7 +1,65 @@
+import { config } from "./config.js";
 export function isPreOrderProduct(doc) {
     return doc.listingType === "pre-order";
 }
-// True when the pre-order window is still open (not closed, delivery date in future).
+/**
+ * True when the pre-order window is still open.
+ *
+ * ## 🛑 `config.ts` WINS. This function used to disagree with it, and it was
+ * the one that was wrong — twice over.
+ *
+ * It read:
+ *
+ *     isPreOrderProduct(doc) && !doc.preOrderClosed && doc.preOrderDeliveryDate! > new Date()
+ *
+ * Two defects in one expression:
+ *
+ *  1. **The `!` assertion on an OPTIONAL field.** `preOrderDeliveryDate?: Date`,
+ *     so on a dateless pre-order this evaluated `undefined > new Date()` →
+ *     `false`, silently calling every such listing CLOSED. The non-null
+ *     assertion is what hid it from `tsc`: the only tool that could have said
+ *     so was told not to.
+ *  2. **Gating availability on the delivery date at all.** That is the
+ *     substantive disagreement, and `config.ts:37-48` states the right rule
+ *     with its reason: *"A pre-order closes when its allocation fills, NOT when
+ *     its delivery date passes — a shipped-soon pre-order is still orderable."*
+ *     A pre-order due tomorrow is the most orderable it will ever be.
+ *
+ * So the date is **not** an availability input. It is a CHECKOUT input — the
+ * 45-day rule lives in `preOrderRule.preflightChecks`, which refuses a past or
+ * beyond-window date at the moment money would move, and in the write-side cap
+ * that stops such a listing existing. Those are the places a date belongs:
+ * availability answers "is this listing live", the rule answers "may this
+ * payment be taken".
+ *
+ * 🛑 This now DELEGATES rather than restating the three conditions. Four
+ * partial copies of one predicate, none of them the definition, is Root Cause
+ * #73 — and this was copy number two. `config.isAvailable` is the per-type half
+ * of the canonical predicate (`isListingRowAvailable` in `_registry.ts` pairs
+ * it with the shared stock clauses), so calling it is what makes "they agree"
+ * structural instead of a comment claiming they do.
+ *
+ * ## Callers
+ *
+ * None, measured at the time this was fixed — which is why correcting the
+ * behaviour here is safe rather than a change of meaning somewhere unseen. If
+ * you are about to add one, prefer `isListingRowAvailable(row)` from
+ * `_registry.ts`: it also applies the shared sold/stock checks that this
+ * type-specific half deliberately does not.
+ */
 export function isOpenPreOrder(doc) {
-    return isPreOrderProduct(doc) && !doc.preOrderClosed && doc.preOrderDeliveryDate > new Date();
+    if (!isPreOrderProduct(doc))
+        return false;
+    /*
+     * `as never` — the established spelling in this codebase for handing a
+     * `ProductDocument` to an `AvailabilityRow` predicate
+     * (`products.repository.ts:1056`, `countersReconcile.ts:156`,
+     * `onProductWrite.ts:347,351` all do exactly this). An interface is not
+     * assignable to `Record<string, FirestoreValue>` even when every field would
+     * satisfy it, and `AvailabilityRow` is deliberately the loose shape because
+     * the same row arrives as a Firestore document, as a serialised Function
+     * payload and as JSON — see its own docstring. A cast at the boundary beats
+     * narrowing `AvailabilityRow`, which would push one to every other caller.
+     */
+    return config.isAvailable(doc);
 }

package/dist/_internal/shared/listing-types/route-gating.d.ts

@@ -10,9 +10,9 @@
  * destination by URL and never mentions a listing type at all: a carousel
  * slide's overlay button, a card's CTA, a promo-grid tile.
  *
- * Measured 2026-10-20 with `auction: false` live: the homepage hero carousel
- * still shipped a "Live auctions / Place a bid before the timer runs out"
- * CARD linking to `/auctions`, and a whole `slide-beyblade-auction` slide
+ * Measured 2026-10-20 with `collector drop: false` live: the homepage hero carousel
+ * still shipped a "Live collector drops / Place a bid before the timer runs out"
+ * CARD linking to `/collector-drops`, and a whole `slide-beyblade-collectorDrop` slide
  * whose overlay read "Win it at your price". Both are authored content, so no
  * type-keyed gate could see them — the only thing that identifies them is
  * where they point.
@@ -26,16 +26,16 @@
  * disagreeing about what a gate matches is a defect this codebase keeps paying
  * for, and the only safe number of descriptions is one.
  *
- * Store tabs (`/stores/{slug}/auctions`) are out of scope — those are resolved
+ * Store tabs (`/stores/{slug}/collector-drops`) are out of scope — those are resolved
  * by `resolveStoreTabs`, which owns its own visibility, and a second owner is
  * how a mirror drifts (Root Cause #42).
  */
-import { type BrowsePageKey, type SurfaceCountSnapshot } from "./feature-flags";
+import { type BrowsePageKey, type FlagValue, type SurfaceCountSnapshot } from "./feature-flags";
 import type { ListingType } from "../../../features/products/types/index";
 interface ListingFlagSnapshot {
     listings?: {
-        listingTypes?: Partial<Record<ListingType, boolean>>;
-        browsePages?: Partial<Record<BrowsePageKey, boolean>>;
+        listingTypes?: Partial<Record<ListingType, FlagValue>>;
+        browsePages?: Partial<Record<BrowsePageKey, FlagValue>>;
     };
     disabledRoutes?: string[];
 }
@@ -84,10 +84,10 @@ export declare function closedSurfaceContext(settings: ListingFlagSnapshot | nul
  *
  * ## What it still does NOT match
  *
- * Editorial pages that merely carry a name in the path — `/help/auctions`,
- * `/how-auctions-work`, `/seller-guide/prize-draws`. None starts with
- * `/auctions`, so the `/`-delimited boundary excludes them for free, and that
- * is correct: an explainer about auctions is honest reading when auctions are
+ * Editorial pages that merely carry a name in the path — `/help/collector-drops`,
+ * `/how-collector-drops-work`, `/seller-guide/clearance`. None starts with
+ * `/collector-drops`, so the `/`-delimited boundary excludes them for free, and that
+ * is correct: an explainer about collector drops is honest reading when collector drops are
  * off.
  *
  * Fails OPEN on anything it cannot classify — an unknown path, an external

package/dist/_internal/shared/listing-types/route-gating.js

@@ -10,9 +10,9 @@
  * destination by URL and never mentions a listing type at all: a carousel
  * slide's overlay button, a card's CTA, a promo-grid tile.
  *
- * Measured 2026-10-20 with `auction: false` live: the homepage hero carousel
- * still shipped a "Live auctions / Place a bid before the timer runs out"
- * CARD linking to `/auctions`, and a whole `slide-beyblade-auction` slide
+ * Measured 2026-10-20 with `collector drop: false` live: the homepage hero carousel
+ * still shipped a "Live collector drops / Place a bid before the timer runs out"
+ * CARD linking to `/collector-drops`, and a whole `slide-beyblade-collectorDrop` slide
  * whose overlay read "Win it at your price". Both are authored content, so no
  * type-keyed gate could see them — the only thing that identifies them is
  * where they point.
@@ -26,7 +26,7 @@
  * disagreeing about what a gate matches is a defect this codebase keeps paying
  * for, and the only safe number of descriptions is one.
  *
- * Store tabs (`/stores/{slug}/auctions`) are out of scope — those are resolved
+ * Store tabs (`/stores/{slug}/collector-drops`) are out of scope — those are resolved
  * by `resolveStoreTabs`, which owns its own visibility, and a second owner is
  * how a mirror drifts (Root Cause #42).
  */
@@ -37,7 +37,7 @@ import { closedSurfacePrefixes, isUnderClosedPrefix } from "./hidden-surfaces.js
  * browse route → every listing type that browses there.
  *
  * Built from the registry rather than hand-listed, so a tenth type joins it by
- * existing. `art` and `stickers` both resolve to `/art`, which is the entire
+ * existing. Several types can resolve to one route, which is the entire
  * reason the value is an array.
  */
 const TYPES_BY_BROWSE_ROUTE = (() => {
@@ -62,7 +62,7 @@ const TYPES_BY_BROWSE_ROUTE = (() => {
  * route, and a caller must not filter them out.
  *
  * 🛑 The locale prefix is stripped. `ROUTES` values are unprefixed
- * (`/auctions`) and `next-intl` adds `/en` at navigation time, but an admin
+ * (`/collector-drops`) and `next-intl` adds `/en` at navigation time, but an admin
  * pasting a URL out of the address bar stores the prefixed form — so a
  * comparison against the raw value matches the seed and misses the hand-typed
  * one, which is the half most likely to be wrong.
@@ -73,9 +73,9 @@ function normalisePath(href) {
     const trimmed = href.trim();
     if (!trimmed || !trimmed.startsWith("/"))
         return "";
-    // Drop query + hash: `/auctions?sort=ending` is still /auctions.
+    // Drop query + hash: `/collector-drops?sort=ending` is still /collector-drops.
     const path = trimmed.split(/[?#]/)[0] ?? "";
-    // `/en/auctions` → `/auctions`. Two-letter segment only, so a real route
+    // `/en/collector-drops` → `/collector-drops`. Two-letter segment only, so a real route
     // whose first segment is short (there are none today, but `/ar` would be a
     // plausible future one) is the only thing this could over-match — and it
     // would have to collide with a locale code to do it.
@@ -116,10 +116,10 @@ export function closedSurfaceContext(settings, counts) {
  *
  * ## What it still does NOT match
  *
- * Editorial pages that merely carry a name in the path — `/help/auctions`,
- * `/how-auctions-work`, `/seller-guide/prize-draws`. None starts with
- * `/auctions`, so the `/`-delimited boundary excludes them for free, and that
- * is correct: an explainer about auctions is honest reading when auctions are
+ * Editorial pages that merely carry a name in the path — `/help/collector-drops`,
+ * `/how-collector-drops-work`, `/seller-guide/clearance`. None starts with
+ * `/collector-drops`, so the `/`-delimited boundary excludes them for free, and that
+ * is correct: an explainer about collector drops is honest reading when collector drops are
  * off.
  *
  * Fails OPEN on anything it cannot classify — an unknown path, an external
@@ -143,8 +143,9 @@ export function isClosedHref(href, ctx) {
          * 🛑 `every`, not `some`, and `isListingSurfaceVisible`, not
          * `isListingTypeEnabled`.
          *
-         * `every`: `art` and `stickers` share `/art`, so a site selling art but
-         * not stickers must keep `/art` reachable. One closed claimant is not
+         * `every`: a route can have more than one claimant type, and a site that
+         * still sells one of them must keep that route reachable. One closed
+         * claimant is not
          * enough — treating it as enough silently deletes a working destination.
          *
          * `isListingSurfaceVisible`: it ANDs the admin flag with the measured

package/dist/_internal/shared/listing-types/spares/config.d.ts

@@ -20,6 +20,7 @@ export declare const config: {
     inGeneralCatalogue: boolean;
     canJoinProductGroup: boolean;
     iconKey: "spares";
+    primaryActionKind: "buy-now";
     hideDefault: "sold";
     isAvailable: typeof alwaysAvailable;
     unavailableClauses: readonly import("../availability").UnavailableClause[];

package/dist/_internal/shared/listing-types/spares/config.js

@@ -46,6 +46,7 @@ export const config = {
      */
     canJoinProductGroup: true,
     iconKey: "spares",
+    primaryActionKind: "buy-now",
     hideDefault: "sold",
     /*
      * A spare runs out rather than ending — there is no time dimension at all, so

package/dist/_internal/shared/listing-types/standard/config.d.ts

@@ -20,6 +20,7 @@ export declare const config: {
     inGeneralCatalogue: boolean;
     canJoinProductGroup: boolean;
     iconKey: "order";
+    primaryActionKind: "buy-now";
     hideDefault: "sold";
     isAvailable: typeof alwaysAvailable;
     unavailableClauses: readonly import("../availability").UnavailableClause[];

package/dist/_internal/shared/listing-types/standard/config.js

@@ -22,6 +22,7 @@ export const config = {
     // the ordinary case — a complete item whose parts can be sold beside it
     canJoinProductGroup: true,
     iconKey: "order",
+    primaryActionKind: "buy-now",
     hideDefault: "sold",
     // Runs out rather than ending — no time dimension, so the shared
     // stock-only rules are the whole story for this type.

package/dist/_internal/shared/listing-types/tiers.d.ts

@@ -3,10 +3,10 @@
  *
  * ── The rule ──────────────────────────────────────────────────────────────
  *
- * `standard`, `spares` and `auction` are BASIC — every store can use them.
+ * `standard`, `spares` and `collector drop` are BASIC — every store can use them.
  * The other seven are ADVANCED and need the `advanced_listing_types`
  * capability, because each carries an obligation a new seller has not agreed
- * to yet: a pre-order takes money for stock that does not exist, a prize draw
+ * to yet: a pre-order takes money for stock that does not exist, clearance
  * is a regulated promotion, a classified happens off-platform with no escrow,
  * a digital code must be delivered from a pool the seller has to keep stocked,
  * and a live listing is an animal.

package/dist/_internal/shared/listing-types/tiers.js

@@ -3,10 +3,10 @@
  *
  * ── The rule ──────────────────────────────────────────────────────────────
  *
- * `standard`, `spares` and `auction` are BASIC — every store can use them.
+ * `standard`, `spares` and `collector drop` are BASIC — every store can use them.
  * The other seven are ADVANCED and need the `advanced_listing_types`
  * capability, because each carries an obligation a new seller has not agreed
- * to yet: a pre-order takes money for stock that does not exist, a prize draw
+ * to yet: a pre-order takes money for stock that does not exist, clearance
  * is a regulated promotion, a classified happens off-platform with no escrow,
  * a digital code must be delivered from a pool the seller has to keep stocked,
  * and a live listing is an animal.
@@ -45,14 +45,13 @@ export const ADVANCED_LISTING_TYPE_CAPABILITY = "advanced_listing_types";
 export const LISTING_TYPE_TIER = {
     standard: "basic",
     spares: "basic",
-    auction: "basic",
+    "collector-drop": "basic",
     "pre-order": "advanced",
-    "prize-draw": "advanced",
+    "clearance": "advanced",
     classified: "advanced",
     "digital-code": "advanced",
     live: "advanced",
-    art: "advanced",
-    stickers: "advanced",
+    "art-and-stickers": "advanced",
 };
 /**
  * Capabilities that grant ONE advanced type on their own, for stores that were
@@ -63,7 +62,7 @@ export const LISTING_TYPE_TIER = {
  * access from a seller who had been using it, and a permission that disappears
  * on deploy is indistinguishable from a bug.
  *
- * `host_auctions` deliberately has NO entry: `auction` is basic now, so the
+ * `host_collector_drops` deliberately has NO entry: `collector drop` is basic now, so the
  * check is gone. The capability string stays declared in the union so existing
  * store documents carrying it remain valid — it simply no longer gates
  * anything.

package/dist/_internal/shared/search/index-record.d.ts

@@ -5,7 +5,7 @@
  * falls back to the server path, rather than rendering a half-understood one.
  * That is why this is in the envelope and not implied by the URL.
  */
-export declare const SEARCH_INDEX_SCHEMA_VERSION = 1;
+export declare const SEARCH_INDEX_SCHEMA_VERSION = 2;
 /**
  * The incremental build's watermark field.
  *
@@ -34,18 +34,22 @@ export declare const REC_TITLE = 1;
 export declare const REC_DETAIL = 2;
 export declare const REC_SLUG = 3;
 export declare const REC_FACETS = 4;
+export declare const REC_IMAGE = 5;
 /**
- * `[typeIdx, title, detail, slug, facets?]`
+ * `[typeIdx, title, detail, slug, facets?, image?]`
  *
- * `facets` is a compact pipe-joined string (`"lt:auction|br:takara-tomy"`) and
+ * `facets` is a compact pipe-joined string (`"lt:collector drop|br:takara-tomy"`) and
  * is absent rather than empty when a record has none — an omitted trailing
- * element costs two bytes, `""` costs four, times 3,730.
+ * element costs two bytes, `""` costs four, times 3,730. `image`, when
+ * present, is the record's `mainImage` URL verbatim — see this file's own
+ * header comment for why it is absent on every source but `standard`.
  */
 export type SearchIndexRecord = readonly [
     number,
     string,
     string,
     string,
+    string?,
     string?
 ];
 export interface SearchIndexArtifact {
@@ -66,3 +70,5 @@ export declare function hrefFor(artifact: Pick<SearchIndexArtifact, "types">, re
  * is still a record somebody should be able to find.
  */
 export declare function facetsOf(rec: SearchIndexRecord): ReadonlyArray<readonly [string, string]>;
+/** The record's image URL, or `undefined` — absent for every source but `standard` (see this file's header). */
+export declare function imageOf(rec: SearchIndexRecord): string | undefined;

package/dist/_internal/shared/search/index-record.js

@@ -25,6 +25,18 @@
  *               into the artifact is untranslatable, and this app is
  *               `[locale]`-routed with every other UI string going through the
  *               label system. The client maps `key` -> label at render time
+ *
+ * ## `image` (added schema v2, overhaul brief Phase 11)
+ *
+ * Optional, trailing. Only the `standard` (products) source populates it —
+ * the other 12 sources never set `BuiltRecord.image`, so their tuples never
+ * grow a 6th element at all (zero added bytes, not an empty placeholder).
+ * When a record needs `image` but has no `facets`, position 4 gets an
+ * explicit `""` rather than a true array hole — `JSON.stringify` turns a
+ * sparse hole into `null`, which `facetsOf` would then have to special-case;
+ * `""` already round-trips correctly through its existing `if (!raw)
+ * return []` check.
+ *
  *   price       § Guest price gating is a CLIENT gate; it reaches the rendered
  *               DOM and nothing else. This artifact is unauthenticated and
  *               immutable-cached, so no gate can reach it — an amount here is
@@ -50,7 +62,7 @@
  * falls back to the server path, rather than rendering a half-understood one.
  * That is why this is in the envelope and not implied by the URL.
  */
-export const SEARCH_INDEX_SCHEMA_VERSION = 1;
+export const SEARCH_INDEX_SCHEMA_VERSION = 2;
 /**
  * The incremental build's watermark field.
  *
@@ -68,6 +80,7 @@ export const REC_TITLE = 1;
 export const REC_DETAIL = 2;
 export const REC_SLUG = 3;
 export const REC_FACETS = 4;
+export const REC_IMAGE = 5;
 /** Resolve a record's destination from the type table. */
 export function hrefFor(artifact, rec) {
     const type = artifact.types[rec[REC_TYPE]];
@@ -94,3 +107,7 @@ export function facetsOf(rec) {
     }
     return out;
 }
+/** The record's image URL, or `undefined` — absent for every source but `standard` (see this file's header). */
+export function imageOf(rec) {
+    return rec[REC_IMAGE] || undefined;
+}

package/dist/_internal/shared/search/match.d.ts

@@ -8,7 +8,7 @@ export interface ResolvedEntity {
     readonly href: string;
     readonly score: number;
     /**
-     * The record's raw compact facet string (`"lt:auction|br:takara-tomy"`), or
+     * The record's raw compact facet string (`"lt:collector drop|br:takara-tomy"`), or
      * `""`. Carried on the hit so a facet rail can count what the CURRENT result
      * set contains without going back to the artifact and re-finding each row.
      *
@@ -18,6 +18,8 @@ export interface ResolvedEntity {
      * handful it actually needs.
      */
     readonly facets: string;
+    /** The record's image URL, or `undefined` — only `standard` (products) records carry one. */
+    readonly image?: string;
 }
 export interface ResolveOptions {
     readonly limit?: number;

package/dist/_internal/shared/search/match.js

@@ -57,7 +57,7 @@
 import { normalizeSearchText, parseSearchTxtQuery } from "../../../utils/search-txt.js";
 import { aliasVariantsForName } from "./alias-variants.js";
 import { partAliasTokens } from "./part-aliases.js";
-import { facetsOf, hrefFor, REC_DETAIL, REC_FACETS, REC_TITLE, REC_TYPE, } from "./index-record.js";
+import { facetsOf, hrefFor, imageOf, REC_DETAIL, REC_FACETS, REC_TITLE, REC_TYPE, } from "./index-record.js";
 /** Field weights. Title dominates; a detail match is corroboration. */
 const W_TITLE = 3;
 const W_DETAIL = 1;
@@ -225,6 +225,7 @@ export function searchIndex(artifact, prepared, query, opts = {}) {
                 detail: p.rec[REC_DETAIL],
                 href: hrefFor(artifact, p.rec),
                 facets: p.rec[REC_FACETS] ?? "",
+                image: imageOf(p.rec),
                 // An alias hit is a weaker signal than a direct one and must not
                 // outrank it when both are present in a later, wider query.
                 score: aliasPass ? score - S_ALIAS : score,

package/dist/_internal/shared/search/to-groups.js

@@ -71,6 +71,7 @@ export function toSearchGroups(hits, opts) {
             title: h.title,
             href: h.href,
             detail: h.detail || undefined,
+            image: h.image,
         }));
         return {
             key: typeKey,

package/dist/_internal/shared/templating/placeholders.d.ts

@@ -68,3 +68,21 @@ export declare function interpolate(text: string, values: PlaceholderValues): In
  * publishes from it.
  */
 export declare function missingPlaceholders(text: string, available: PlaceholderValues): string[];
+/**
+ * Remove the source line that carries `{{slot}}`.
+ *
+ * Used when a slot has no value, so the body arrives without the line rather
+ * than with an empty one — `interpolate` resolves an unfilled slot to an empty
+ * string, and `<li><strong>System:</strong> {{system}}</li>` would otherwise
+ * render an empty bullet that reads as broken data.
+ *
+ * 🛑 Line-based, with a known consequence worth stating: a slot that appears
+ * both as a standalone row AND mid-sentence loses the whole sentence, not just
+ * the value. Losing a sentence is the better of the two, but a template author
+ * adding an inline slot should know the line goes with it.
+ *
+ * Moved here 2026-11-08 from `features/parts/utils/part-breakdown.ts` when the
+ * bey/part taxonomy left the shop. It was never parts-specific — it is a
+ * templating helper that happened to live beside its first caller.
+ */
+export declare function stripSlotLine(body: string, slot: string): string;