@mohasinac/appkit 4.47.0 → 4.48.0

package/dist/features/orders/repository/orders.repository.js

@@ -1,5 +1,5 @@
 import { buildOrderSearchTxt } from "../../../utils/search-txt-builders.js";
-import { planSearchTxt, refineSearchTxt, emptySearchResult, } from "../../../utils/search-txt-query.js";
+import { planSearchTxt, beginSearchWindow, emptySearchResult, } from "../../../utils/search-txt-query.js";
 import { normalizeError } from "../../../errors/normalize.js";
 import { DatabaseError, NotFoundError } from "../../../errors/index.js";
 import { BaseRepository, prepareForFirestore, parseSieveDateValue, } from "../../../providers/db-firebase/index.js";
@@ -314,12 +314,19 @@ class OrderRepository extends BaseRepository {
             // `in`/`not-in`/`array-contains-any` family separately.
             baseQuery = baseQuery.where(ORDER_FIELDS.SEARCH_TXT, "array-contains", plan.head);
         }
-        const result = await this.sieveQuery(model, OrderRepository.SELLER_SIEVE_FIELDS, {
+        /*
+         * One bounded window, one raised `maxPageSize`, one page slice — see
+         * `beginSearchWindow`. Hand-writing the three is how the other ten
+         * repositories each ended up with two of them, which reads as a working
+         * multi-word search and silently cannot reach page 2.
+         */
+        const win = beginSearchWindow(model, plan);
+        const result = await this.sieveQuery(win.model, OrderRepository.SELLER_SIEVE_FIELDS, {
             baseQuery,
             defaultPageSize: 20,
-            maxPageSize: 100,
+            maxPageSize: win.maxPageSize(100),
         });
-        return refineSearchTxt(result, plan.rest);
+        return win.finish(result);
     }
     async listForUser(userId, model) {
         const baseQuery = this.getCollection().where(ORDER_FIELDS.USER_ID, "==", userId);
@@ -347,12 +354,19 @@ class OrderRepository extends BaseRepository {
         if (plan.head) {
             baseQuery = baseQuery.where(ORDER_FIELDS.SEARCH_TXT, "array-contains", plan.head);
         }
-        const result = await this.sieveQuery(model, OrderRepository.ADMIN_SIEVE_FIELDS, {
+        /*
+         * One bounded window, one raised `maxPageSize`, one page slice — see
+         * `beginSearchWindow`. Hand-writing the three is how the other ten
+         * repositories each ended up with two of them, which reads as a working
+         * multi-word search and silently cannot reach page 2.
+         */
+        const win = beginSearchWindow(model, plan);
+        const result = await this.sieveQuery(win.model, OrderRepository.ADMIN_SIEVE_FIELDS, {
             baseQuery,
             defaultPageSize: 50,
-            maxPageSize: 200,
+            maxPageSize: win.maxPageSize(200),
         });
-        return refineSearchTxt(result, plan.rest);
+        return win.finish(result);
     }
     /**
      * Append one refund event to the order and mark it non-contestable.

package/dist/features/orders/schemas/firestore.d.ts

@@ -226,6 +226,17 @@ export interface OrderDocumentItem {
     /** I8 — the brand display name at order time, for the same reason. */
     brand?: string;
     condition?: string;
+    /**
+     * I9 — which physical variant of a PART this unit was, snapshotted.
+     *
+     * 🛑 Snapshotted for the same reason `condition` and `gstRate` are: the
+     * price index slices by colourway, and reading the product's CURRENT
+     * colourway would retroactively re-file an old sale under a value the seller
+     * changed later. For a part this is a bigger price variable than condition —
+     * the silver Metal Ball and the transparent-black one are the same mould
+     * with the same stats, and one is rare and costly.
+     */
+    colourway?: string;
     /** SB8-F â€" per-item reveal status; flips through pending â†' open â†' revealed/closed. */
     prizeRevealStatus?: "pending" | "open" | "closed" | "revealed";
     /** Set when the buyer cancels this specific line item post-order (partial cancellation). */

package/dist/features/products/components/CityCollectiblesView.d.ts

@@ -0,0 +1,31 @@
+import { type MeetupCity } from "../constants/meetup-cities";
+export interface CityCollectiblesViewProps {
+    city: MeetupCity;
+}
+/**
+ * D5 — local SEO: the collectibles people are selling in ONE city.
+ *
+ * ## 🛑 What makes this a real page rather than a doorway
+ *
+ * Google's own guidance on local pages is that they must carry content specific
+ * to the place; a template with the city name swapped in is the doorway pattern
+ * it penalises. So everything on this page is city-SPECIFIC and comes from the
+ * city's own data:
+ *
+ *   - the classified listings whose seller named THIS city as the meet-up
+ *     point, which is a real field (`classified.meetupArea.city`) with its own
+ *     composite index, not a text match on a description;
+ *   - the count, stated plainly;
+ *   - and when the count is zero it SAYS so, with the national browse as the
+ *     next step. An empty grid under a city headline is the failure mode this
+ *     page type is famous for.
+ *
+ * ## 🛑 Classifieds only, deliberately
+ *
+ * A shipped listing has no city — it has a seller's warehouse, which is not
+ * where the buyer is and not a fact about the buyer's town. Only the classified
+ * type carries a meet-up place, so only classifieds can honestly appear under a
+ * city heading. Padding the page with shippable national inventory is what
+ * turns a local page into the same page six times.
+ */
+export declare function CityCollectiblesView({ city }: CityCollectiblesViewProps): Promise<import("react").JSX.Element>;

package/dist/features/products/components/CityCollectiblesView.js

@@ -0,0 +1,82 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { ROUTES } from "../../../next/routing/route-map.js";
+import { PAGE_CONTAINER } from "../../../_internal/shared/styles/page.js";
+import { THEMED_BG_PRIMARY } from "../../../_internal/shared/styles/themed.js";
+import { TABLE_KEYS } from "../../../constants/table-keys.js";
+import { safeRead } from "../../../errors/safe-read.js";
+import { Alert, Div, Grid, Heading, Row, Section, Stack, Text, TextLink, } from "../../../ui/index.js";
+import { listPublicProducts } from "../../../_internal/server/features/products/list-public.js";
+import { hidePublicTestData } from "../../../_internal/server/features/tester/visibility.js";
+import { MEETUP_CITIES } from "../constants/meetup-cities.js";
+import { ProductGrid } from "./ProductGrid.js";
+const __P = {
+    p5: "p-[var(--appkit-space-5)]",
+};
+/** Listings read per city page. One bounded query, Rule #6. */
+const CITY_LISTING_LIMIT = 24;
+/**
+ * D5 — local SEO: the collectibles people are selling in ONE city.
+ *
+ * ## 🛑 What makes this a real page rather than a doorway
+ *
+ * Google's own guidance on local pages is that they must carry content specific
+ * to the place; a template with the city name swapped in is the doorway pattern
+ * it penalises. So everything on this page is city-SPECIFIC and comes from the
+ * city's own data:
+ *
+ *   - the classified listings whose seller named THIS city as the meet-up
+ *     point, which is a real field (`classified.meetupArea.city`) with its own
+ *     composite index, not a text match on a description;
+ *   - the count, stated plainly;
+ *   - and when the count is zero it SAYS so, with the national browse as the
+ *     next step. An empty grid under a city headline is the failure mode this
+ *     page type is famous for.
+ *
+ * ## 🛑 Classifieds only, deliberately
+ *
+ * A shipped listing has no city — it has a seller's warehouse, which is not
+ * where the buyer is and not a fact about the buyer's town. Only the classified
+ * type carries a meet-up place, so only classifieds can honestly appear under a
+ * city heading. Padding the page with shippable national inventory is what
+ * turns a local page into the same page six times.
+ */
+export async function CityCollectiblesView({ city }) {
+    const page = { container: PAGE_CONTAINER };
+    const result = await safeRead(() => listPublicProducts({
+        listingTypes: ["classified"],
+        // The city is a TYPE FACET, resolved to `classified.meetupArea.city` by
+        // the shared query — never a hand-written Sieve clause here.
+        typeFacets: { [TABLE_KEYS.CITY]: city.city },
+        availability: "available",
+        page: 1,
+        pageSize: CITY_LISTING_LIMIT,
+    }), {
+        route: "/collectibles/[city]",
+        key: "city.classifieds",
+        fallback: null,
+    });
+    /*
+     * The metadata comes off the result FIRST, then the rows are narrowed — so
+     * nothing reads the raw result after the projection exists. That ordering is
+     * what `audit-projection-shadow` is for: a narrowed copy beside a live
+     * source is how a raw document reaches a client prop (Root Cause #70), and
+     * the rule holds even when the later read is innocent.
+     *
+     * 🛑 `truncated` means `total` is a FLOOR, so it renders as "24+" and never
+     * as an exact figure — the same rule every other bounded listing follows. A
+     * floor presented as a total compounds into a wrong "page 2 of 1".
+     */
+    const total = result?.total ?? 0;
+    const truncated = result?.truncated === true;
+    const items = hidePublicTestData(result?.items ?? []);
+    const countLabel = truncated ? `${items.length}+` : String(total);
+    const others = MEETUP_CITIES.filter((c) => c.slug !== city.slug);
+    return (_jsxs(Div, { children: [_jsx(Section, { className: THEMED_BG_PRIMARY, padding: "y-2xl", children: _jsxs(Div, { className: page.container.lg, children: [_jsx(Heading, { level: 1, size: "3xl", mdSize: "4xl", weight: "bold", className: "mb-3", children: `Collectibles for sale in ${city.city}` }), _jsx(Text, { size: "lg", color: "muted", className: "max-w-3xl", children: `Classified listings where the seller meets buyers in ${city.city}, ${city.state} — pay in person, inspect before you buy, no shipping involved.` })] }) }), _jsx(Section, { padding: "y-xl", children: _jsx(Div, { className: page.container.lg, children: items.length > 0 ? (_jsxs(_Fragment, { children: [_jsxs(Row, { align: "center", justify: "between", wrap: true, className: "mb-4", children: [_jsx(Heading, { level: 2, size: "xl", weight: "semibold", children: `${countLabel} listing${items.length === 1 ? "" : "s"} in ${city.city}` }), _jsx(TextLink, { href: String(ROUTES.PUBLIC.CLASSIFIED), children: "All classifieds" })] }), _jsx(ProductGrid, { products: items })] })) : (
+                    /*
+                     * 🛑 Says what is true. A city page with no listings is a normal
+                     * state for a local marketplace — the dishonest version is an empty
+                     * grid under a confident headline, which reads as a broken page and
+                     * is also the doorway pattern this page type is penalised for.
+                     */
+                    _jsxs(Alert, { variant: "info", children: [_jsx(Text, { weight: "semibold", children: `Nobody is selling in ${city.city} right now` }), _jsx(Text, { size: "sm", children: `Classified listings come and go quickly — this page lists them whenever a seller names ${city.city} as their meet-up point. In the meantime, everything on LetItRip ships nationwide.` }), _jsxs(Row, { gap: "md", wrap: true, className: "mt-3", children: [_jsx(TextLink, { href: String(ROUTES.PUBLIC.PRODUCTS), children: "Browse everything" }), _jsx(TextLink, { href: String(ROUTES.PUBLIC.CLASSIFIED), children: "All classifieds" })] })] })) }) }), _jsx(Section, { padding: "y-xl", children: _jsxs(Div, { className: page.container.lg, children: [_jsx(Stack, { gap: "md", children: _jsxs(Div, { className: __P.p5, surface: "card", rounded: "xl", border: "subtle", children: [_jsx(Heading, { level: 2, size: "lg", weight: "semibold", className: "mb-2", children: `Meeting a seller in ${city.city}` }), _jsx(Text, { color: "muted", children: "Meet somewhere public and busy, in daylight. Bring the exact amount if you are paying cash, and check the item against its listing photos before you hand anything over \u2014 a classified sale is between you and the seller, so LetItRip's buyer protection does not cover a cash handover." }), _jsxs(Row, { gap: "md", wrap: true, className: "mt-3", children: [_jsx(TextLink, { href: String(ROUTES.PUBLIC.SPOT_A_FAKE), children: "How to spot a fake" }), _jsx(TextLink, { href: String(ROUTES.PUBLIC.SCAMS), children: "Scam registry" })] })] }) }), _jsx(Heading, { level: 2, size: "lg", weight: "semibold", className: "mt-8 mb-3", children: "Other cities" }), _jsx(Grid, { cols: "navTiles", gap: "sm", children: others.map((c) => (_jsx(TextLink, { href: String(ROUTES.PUBLIC.CITY_COLLECTIBLES(c.slug)), children: c.city }, c.slug))) })] }) })] }));
+}

package/dist/features/products/components/MarketPriceAnchor.d.ts

@@ -0,0 +1,45 @@
+import { type PriceIndexBand } from "../../categories/repository/price-index.repository";
+export interface MarketPriceAnchorProps {
+    /** The band for this leaf AND this listing type, or null when there is none. */
+    band: PriceIndexBand | null | undefined;
+    /** Days of completed sales the band covers — stated, never implied. */
+    windowDays: number | null | undefined;
+    currency?: string;
+    /** This listing's own price, so the comparison can be stated as a direction. */
+    price?: number | null;
+}
+/**
+ * H2 — the one persuasion pattern on this site that is made of measurement.
+ *
+ * ## 🛑 Why an anchor at all, and why THIS anchor
+ *
+ * Price anchoring works; the usual implementation is a fabricated "RRP ₹2,499"
+ * beside a ₹1,299 price, and in this market it is close to universal. It is
+ * also a lie, and the plan's H2 boundary is explicit that a persuasion pattern
+ * here has to be a true statement a visitor could verify.
+ *
+ * This one is: **what this model has actually sold for on this site**, from
+ * `priceIndexRollup`'s realised-sale bands. A seller can check it against their
+ * own completed orders and a buyer can click through to the tool that shows the
+ * distribution. Nothing is invented and nothing is rounded in our favour.
+ *
+ * ## 🛑 Three rules that keep it honest
+ *
+ * 1. **Silent below `PRICE_INDEX_MIN_CONFIDENT_SAMPLES`.** A median of two
+ *    sales is arithmetic, not a market. The tool page says "not enough data
+ *    yet" because that is a legitimate answer to a direct question; a product
+ *    page says NOTHING, because an unasked-for caveat beside a buy button is
+ *    noise rather than information.
+ * 2. **The window is stated.** "over 90 days" is part of the claim — a median
+ *    with no period attached is unfalsifiable.
+ * 3. **The direction is stated plainly, including when it is unflattering.**
+ *    If this listing is ABOVE what the model usually sells for, it says so. An
+ *    anchor that only ever renders when it flatters the price is a filter, not
+ *    a measurement, and a buyer who notices that once never believes the
+ *    number again.
+ *
+ * 🛑 Wrapped in `<PricesOnly>`: it is a SECONDARY money figure beside an
+ * already-gated price, so a signed-out visitor sees nothing rather than a
+ * second "sign in to see price" (CLAUDE.md § Guest price gating).
+ */
+export declare function MarketPriceAnchor({ band, windowDays, currency, price, }: MarketPriceAnchorProps): import("react").JSX.Element | null;

package/dist/features/products/components/MarketPriceAnchor.js

@@ -0,0 +1,62 @@
+import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+import { PRICE_INDEX_MIN_CONFIDENT_SAMPLES } from "../../categories/repository/price-index.repository.js";
+import { formatCurrency } from "../../../utils/number.formatter.js";
+import { PricesOnly } from "../../../ui/components/GatedPrice.js";
+import { Text } from "../../../ui/components/Typography.js";
+/**
+ * H2 — the one persuasion pattern on this site that is made of measurement.
+ *
+ * ## 🛑 Why an anchor at all, and why THIS anchor
+ *
+ * Price anchoring works; the usual implementation is a fabricated "RRP ₹2,499"
+ * beside a ₹1,299 price, and in this market it is close to universal. It is
+ * also a lie, and the plan's H2 boundary is explicit that a persuasion pattern
+ * here has to be a true statement a visitor could verify.
+ *
+ * This one is: **what this model has actually sold for on this site**, from
+ * `priceIndexRollup`'s realised-sale bands. A seller can check it against their
+ * own completed orders and a buyer can click through to the tool that shows the
+ * distribution. Nothing is invented and nothing is rounded in our favour.
+ *
+ * ## 🛑 Three rules that keep it honest
+ *
+ * 1. **Silent below `PRICE_INDEX_MIN_CONFIDENT_SAMPLES`.** A median of two
+ *    sales is arithmetic, not a market. The tool page says "not enough data
+ *    yet" because that is a legitimate answer to a direct question; a product
+ *    page says NOTHING, because an unasked-for caveat beside a buy button is
+ *    noise rather than information.
+ * 2. **The window is stated.** "over 90 days" is part of the claim — a median
+ *    with no period attached is unfalsifiable.
+ * 3. **The direction is stated plainly, including when it is unflattering.**
+ *    If this listing is ABOVE what the model usually sells for, it says so. An
+ *    anchor that only ever renders when it flatters the price is a filter, not
+ *    a measurement, and a buyer who notices that once never believes the
+ *    number again.
+ *
+ * 🛑 Wrapped in `<PricesOnly>`: it is a SECONDARY money figure beside an
+ * already-gated price, so a signed-out visitor sees nothing rather than a
+ * second "sign in to see price" (CLAUDE.md § Guest price gating).
+ */
+export function MarketPriceAnchor({ band, windowDays, currency = "INR", price, }) {
+    if (!band)
+        return null;
+    if (!band.sampleSize || band.sampleSize < PRICE_INDEX_MIN_CONFIDENT_SAMPLES)
+        return null;
+    if (!Number.isFinite(band.median) || band.median <= 0)
+        return null;
+    const window = typeof windowDays === "number" && windowDays > 0 ? windowDays : null;
+    const sales = `${band.sampleSize} sale${band.sampleSize === 1 ? "" : "s"}`;
+    const period = window ? ` in the last ${window} days` : "";
+    /*
+     * The direction, computed against a 5% band so a rounding difference is not
+     * reported as "above the usual price". Below that threshold the line states
+     * the median and claims nothing about this listing.
+     */
+    const delta = typeof price === "number" && price > 0 ? (price - band.median) / band.median : null;
+    const direction = delta === null || Math.abs(delta) < 0.05
+        ? null
+        : delta < 0
+            ? "below"
+            : "above";
+    return (_jsx(PricesOnly, { children: _jsxs(Text, { size: "xs", color: "muted", className: "mt-1", children: [`Sold here for a median of ${formatCurrency(band.median, currency)} — ${sales}${period}`, direction === "below" && ", so this one is under the usual price", direction === "above" && ", so this one is above the usual price"] }) }));
+}

package/dist/features/products/components/ProductDetailPageView.js

@@ -1,11 +1,12 @@
 import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
 import Link from "next/link.js";
 import { productRepository } from "../../../repositories/index.js";
+import { priceIndexRepository } from "../../categories/repository/price-index.repository.js";
+import { MarketPriceAnchor } from "./MarketPriceAnchor.js";
 const __P = {
     p3: "p-[var(--appkit-space-3)]",
     p5: "p-[var(--appkit-space-5)]",
 };
-const CLS_BREADCRUMB_LINK = "hover:text-primary-600 transition-colors";
 const ACTION_NOT_WIRED = "Action not wired";
 const CLS_STAR_FULL = "text-warning text-[length:var(--appkit-text-sm)]";
 const CLS_STAR_HALF = "text-warning text-[length:var(--appkit-text-sm)]";
@@ -23,8 +24,10 @@ const CLS_BUNDLE_ROW = "flex items-center justify-between gap-[var(--appkit-spac
 const CLS_BUNDLE_LABEL = "text-[length:var(--appkit-text-xs)] text-success dark:text-success font-medium uppercase tracking-wide mb-0.5";
 const CLS_BUNDLE_CTA = "flex-shrink-0 rounded-lg bg-success-solid hover:brightness-110 px-[var(--appkit-space-3)] py-[var(--appkit-space-1-5)] text-[length:var(--appkit-text-xs)] font-semibold text-success-on-solid transition-colors";
 import { ROUTES } from "../../../next/routing/route-map.js";
+import { ContextualTrail } from "../../categories/components/ContextualTrail.js";
+import { productCrumbs, withTrailHead } from "../../categories/utils/breadcrumb-chain.js";
 import { getDefaultCurrency } from "../../../core/baseline-resolver.js";
-import { Button, Container, Div, Heading, Main, Nav, PriceDisplay, RichText, Row, Section, Span, Stack, Text, Ul, Ol, Li, Dl, Dt, Dd, Icon, } from "../../../ui/index.js";
+import { Button, Container, Div, Heading, Main, PriceDisplay, RichText, Row, Section, Span, Stack, Text, Ul, Ol, Li, Dl, Dt, Dd, Icon, } from "../../../ui/index.js";
 import { normalizeRichTextHtml } from "../../../utils/string.formatter.js";
 import { safeDisplayName } from "../../../security/index.js";
 import { ReviewsListingPanel } from "../../reviews/components/ReviewsListingPanel.js";
@@ -46,6 +49,7 @@ import { getGroupsWithItemsForProduct } from "../../../_internal/server/features
 import { getSiteSettingsGlobal } from "../../admin/utils/getSiteSettingsGlobal.js";
 import { safeRead } from "../../../errors/safe-read.js";
 import { canMakeOffer } from "../../../_internal/shared/listing-types/capabilities.js";
+import { MessageSellerButton } from "../../messages/components/MessageSellerButton.js";
 import { normalizeListingType } from "../utils/listing-type.js";
 import { DEFAULT_MIN_OFFER_PERCENT, resolveOfferBounds, } from "../../../_internal/shared/features/offers/config.js";
 // ---------------------------------------------------------------------------
@@ -134,6 +138,52 @@ export async function ProductDetailPageView({ slug, initialProduct, renderOfferA
     const categoryNames = Array.isArray(p.categoryNames)
         ? p.categoryNames
         : categoryName ? [categoryName] : [];
+    /*
+     * I5b — the VISIBLE trail, from the same `productCrumbs` builder the route's
+     * JSON-LD uses.
+     *
+     * 🛑 This page rendered `Home / Products / <Category>` — three crumbs — while
+     * its own `BreadcrumbList` carried the full 8-level chain. The data was on
+     * the row the whole time; only the markup read it. Same builder, same
+     * inputs, so the two cannot describe different hierarchies.
+     */
+    const categoryIds = Array.isArray(p.categoryIds) ? p.categoryIds : [];
+    const categoryIdNames = Array.isArray(p.categoryIdNames)
+        ? p.categoryIdNames
+        : [];
+    const defaultTrail = withTrailHead([
+        ...productCrumbs({
+            categorySlugs,
+            categoryNames,
+            hrefFor: (s) => String(ROUTES.PUBLIC.CATEGORY_DETAIL(s)),
+        }),
+        { name: title || String(p.slug ?? ""), url: String(ROUTES.PUBLIC.PRODUCT_DETAIL(String(p.slug ?? ""))) },
+    ], [
+        { name: "Home", url: String(ROUTES.HOME) },
+        { name: "Products", url: String(ROUTES.PUBLIC.PRODUCTS) },
+    ]);
+    /*
+     * One trail per assignment, default first. The alternates are a SINGLE-crumb
+     * chain each: a non-default assignment has no stored ancestor names on the
+     * product (only `categoryIdNames`), and inventing its ancestry from the
+     * default chain would describe a hierarchy that may not exist. A one-level
+     * trail is a true statement; a padded one is not.
+     */
+    const trails = categoryIds.length > 1
+        ? [
+            { categoryId: categoryIds[0] ?? "", crumbs: defaultTrail },
+            ...categoryIds.slice(1).map((id, i) => ({
+                categoryId: id,
+                crumbs: withTrailHead([
+                    { name: categoryIdNames[i + 1] ?? id, url: String(ROUTES.PUBLIC.CATEGORY_DETAIL(id)) },
+                    { name: title || String(p.slug ?? "") },
+                ], [
+                    { name: "Home", url: String(ROUTES.HOME) },
+                    { name: "Products", url: String(ROUTES.PUBLIC.PRODUCTS) },
+                ]),
+            })),
+        ]
+        : [{ categoryId: categoryIds[0] ?? primaryCategorySlug ?? "", crumbs: defaultTrail }];
     const subcategory = typeof p.subcategory === "string" ? p.subcategory : null;
     const brand = typeof p.brand === "string" ? p.brand : null;
     const brandSlug = typeof p.brandSlug === "string" ? p.brandSlug : null;
@@ -208,13 +258,29 @@ export async function ProductDetailPageView({ slug, initialProduct, renderOfferA
     const storeId = typeof p.storeId === "string" ? p.storeId : null;
     // -- Fetch reviews + the shared 4-signal related-items computation + grouped listings in parallel --
     // Only page 1 of reviews is fetched here; <ReviewsListingPanel> pages the rest client-side.
-    const [initialReviews, related, groups, siteSettings] = await Promise.all([
+    const [initialReviews, related, groups, siteSettings, priceBand] = await Promise.all([
         getReviewPageForProduct(product.id),
         computeRelatedItems(product),
         getGroupsWithItemsForProduct(product.id),
         safeRead(() => getSiteSettingsGlobal(), {
             route: "/products/[slug]", key: "product.siteSettings", fallback: null,
         }),
+        /*
+         * H2 — the realised-price band for this leaf, read INSIDE the existing
+         * `Promise.all` rather than beside it: the four reads above already run in
+         * parallel, so a fifth parallel read adds document reads but no latency,
+         * which is the argument Rule #6 cares about (~3 SEQUENTIAL round trips).
+         *
+         * One `findById` by leaf id — no query, no index. `null` when the leaf has
+         * never sold, which is the common case and renders nothing.
+         */
+        primaryCategorySlug
+            ? safeRead(() => priceIndexRepository.getForLeaf(primaryCategorySlug), {
+                route: "/products/[slug]",
+                key: "product.priceIndex",
+                fallback: null,
+            })
+            : Promise.resolve(null),
     ]);
     const { relatedItems, relatedByBrand, relatedByTags, relatedByStore } = related;
     return (_jsxs(Main, { children: [_jsx(HistoryTracker, { productId: product.id, productType: "product", snapshot: {
@@ -223,7 +289,7 @@ export async function ProductDetailPageView({ slug, initialProduct, renderOfferA
                     price: product.price,
                     storeId: product.storeId,
                     storeName: product.storeName,
-                } }), _jsxs(Container, { size: "xl", padding: "y-lg", children: [_jsx(ProductDetailView, { renderBreadcrumb: () => (_jsxs(Row, { className: "mb-4", align: "center", justify: "between", gap: "sm", wrap: true, children: [_jsxs(Nav, { "aria-label": "Breadcrumb", layout: "flex-wrap", gap: "2xs", textSize: "xs", color: "muted", children: [_jsx(Link, { href: String(ROUTES.HOME), className: CLS_BREADCRUMB_LINK, children: "Home" }), _jsx(Span, { "aria-hidden": true, children: "/" }), _jsx(Link, { href: String(ROUTES.PUBLIC.PRODUCTS), className: CLS_BREADCRUMB_LINK, children: "Products" }), (primaryCategorySlug || category) && (_jsxs(_Fragment, { children: [_jsx(Span, { "aria-hidden": true, children: "/" }), _jsx(Link, { href: String(ROUTES.PUBLIC.CATEGORY_DETAIL(primaryCategorySlug ?? category)), className: CLS_BREADCRUMB_LINK, children: categoryNames[0] || categoryName || category })] })), subcategory && (_jsxs(_Fragment, { children: [_jsx(Span, { "aria-hidden": true, children: "/" }), _jsx(Span, { transform: "capitalize", children: subcategory })] }))] }), _jsx(ShareButton, { title: title || undefined })] })), renderGallery: () => (_jsx(ProductGalleryClient, { images: images, video: productVideo, productName: title || undefined })), renderInfo: () => (_jsxs(Stack, { gap: "md", children: [_jsxs(Div, { children: [condition && (_jsx(Span, { size: "xs", weight: "medium", className: "mb-2 inline-block", padding: "pill-sm", rounded: "full", surface: "subtle", color: "muted", transform: "capitalize", children: condition === "new"
+                } }), _jsxs(Container, { size: "xl", padding: "y-lg", children: [_jsx(ProductDetailView, { renderBreadcrumb: () => (_jsxs(Row, { className: "mb-4", align: "center", justify: "between", gap: "sm", wrap: true, children: [_jsx(ContextualTrail, { trails: trails, alternates: { ids: categoryIds, names: categoryIdNames } }), _jsx(ShareButton, { title: title || undefined })] })), renderGallery: () => (_jsx(ProductGalleryClient, { images: images, video: productVideo, productName: title || undefined })), renderInfo: () => (_jsxs(Stack, { gap: "md", children: [_jsxs(Div, { children: [condition && (_jsx(Span, { size: "xs", weight: "medium", className: "mb-2 inline-block", padding: "pill-sm", rounded: "full", surface: "subtle", color: "muted", transform: "capitalize", children: condition === "new"
                                                 ? "Brand New"
                                                 : condition === "like_new"
                                                     ? "Like New"
@@ -253,7 +319,7 @@ export async function ProductDetailPageView({ slug, initialProduct, renderOfferA
                                         categoryProductCount: (n, cat) => `${n} in ${cat}`,
                                     } }), productFeatures && features.length > 0 && (_jsx(FeatureBadgeList, { productFeatureIds: features, features: productFeatures })), !productFeatures && features.length > 0 && (_jsxs(Div, { border: "subtle", surface: "muted", padding: "inline", rounded: "xl", children: [_jsx(Text, { className: "mb-2 tracking-wide", color: "muted", size: "xs", weight: "semibold", transform: "uppercase", children: "About this product" }), _jsx(Ul, { spacing: "comfortable", size: "sm", color: "primary", children: features.map((f, i) => (_jsxs(Li, { layout: "flex-start", gap: "2", children: [_jsx(Span, { className: "mt-0.5 flex-shrink-0 text-primary-500", children: "\u2022" }), f] }, i))) })] })), descriptionHtml && (_jsx(RichText, { html: descriptionHtml, proseClass: "prose prose-sm max-w-none dark:prose-invert prose-p:my-0", className: "text-[length:var(--appkit-text-sm)] leading-relaxed text-[var(--appkit-color-text-muted)] line-clamp-4" })), safeSeller && (_jsx(Div, { className: `${__P.p3}`, border: "subtle", rounded: "xl", surface: "muted", children: _jsxs(Row, { justify: "between", align: "center", children: [_jsxs(Div, { children: [_jsx(Text, { className: "text-[10px] tracking-wide mb-0.5", color: "faint", transform: "uppercase", children: "Sold by" }), _jsx(Text, { size: "sm", weight: "semibold", color: "primary", children: safeSeller }), typeof p.storeRating === "number" && p.storeRating > 0 && (_jsx(Row, { gap: "xs", align: "center", className: "mt-0.5", children: _jsxs(Text, { size: "xs", color: "muted", children: [_jsx(Span, { className: "text-warning", "aria-hidden": "true", children: "\u2605" }), " ", p.storeRating.toFixed(1), typeof p.storeReviewCount === "number" &&
                                                                     p.storeReviewCount > 0 &&
-                                                                    ` · ${p.storeReviewCount} reviews`] }) }))] }), storeHref && (_jsx(Link, { href: storeHref, className: "shrink-0 rounded-lg bg-primary/10 dark:bg-primary/20 px-[var(--appkit-space-3)] py-[var(--appkit-space-1-5)] text-[length:var(--appkit-text-xs)] font-semibold text-primary-700 dark:text-primary-300 hover:bg-primary/20 dark:hover:bg-primary/30 transition-colors", children: "Visit Store \u2192" }))] }) }))] })), renderActions: () => (_jsxs(Stack, { className: `${__P.p5}`, border: "subtle", gap: "md", rounded: "xl", surface: "muted", children: [price !== null && (_jsxs(Div, { children: [_jsx(PriceDisplay, { amount: price, originalAmount: originalPrice ?? undefined, currency: currency, variant: "detail" }), inStock && effectiveStock !== null && effectiveStock <= 10 && (_jsxs(Text, { className: "mt-1 text-warning", size: "xs", children: ["Only ", effectiveStock, " left \u2014 order soon!"] }))] })), _jsxs(Stack, { gap: "sm", children: [renderPrimaryActions ? (renderPrimaryActions({
+                                                                    ` · ${p.storeReviewCount} reviews`] }) }))] }), _jsxs(Row, { gap: "xs", align: "center", className: "shrink-0", children: [storeId && _jsx(MessageSellerButton, { storeId: storeId }), storeHref && (_jsx(Link, { href: storeHref, className: "rounded-lg bg-primary/10 dark:bg-primary/20 px-[var(--appkit-space-3)] py-[var(--appkit-space-1-5)] text-[length:var(--appkit-text-xs)] font-semibold text-primary-700 dark:text-primary-300 hover:bg-primary/20 dark:hover:bg-primary/30 transition-colors", children: "Visit Store \u2192" }))] })] }) }))] })), renderActions: () => (_jsxs(Stack, { className: `${__P.p5}`, border: "subtle", gap: "md", rounded: "xl", surface: "muted", children: [price !== null && (_jsxs(Div, { children: [_jsx(PriceDisplay, { amount: price, originalAmount: originalPrice ?? undefined, currency: currency, variant: "detail" }), _jsx(MarketPriceAnchor, { band: priceBand?.byListingType?.[normalizeListingType(p)] ?? null, windowDays: priceBand?.windowDays ?? null, currency: currency, price: price }), inStock && effectiveStock !== null && effectiveStock <= 3 && (_jsxs(Text, { className: "mt-1 text-warning", size: "xs", children: ["Only ", effectiveStock, " left \u2014 order soon!"] })), inStock && effectiveStock !== null && effectiveStock > 3 && effectiveStock <= 10 && (_jsxs(Text, { className: "mt-1", color: "muted", size: "xs", children: [effectiveStock, " in stock"] }))] })), _jsxs(Stack, { gap: "sm", children: [renderPrimaryActions ? (renderPrimaryActions({
                                             productId: product.id,
                                             productSlug: product.slug ?? slug,
                                             productTitle: product.title,

package/dist/features/products/constants/meetup-cities.d.ts

@@ -0,0 +1,47 @@
+/**
+ * D5 — the cities that get their own local-SEO page.
+ *
+ * ## 🛑 Six, because six is what the data has
+ *
+ * Every entry here is a city a classified listing actually names in
+ * `classified.meetupArea.city`, measured from the seed rather than chosen from
+ * a list of big Indian cities. A page for a city with no listings is an empty
+ * page with a city in its `<title>` — which is the doorway-page pattern Google
+ * penalises, and the thing local SEO is most often got wrong by.
+ *
+ * 🛑 So the rule for adding one is: a city joins this list when listings name
+ * it, not in anticipation of listings naming it. The page still renders when a
+ * city's listings all sell — it says so in words rather than showing an empty
+ * grid, because "nobody is selling here this week" is true and useful, while a
+ * bare grid reads as broken.
+ *
+ * ## Why a constant rather than a query
+ *
+ * These routes are STATIC (`generateStaticParams`), which is the whole point:
+ * a city page that awaited `searchParams` or queried for its own slug list
+ * would be dynamic, and then every visitor and every crawler hit pays a render
+ * — on the surface most likely to be crawled widely (Root Cause #94). A
+ * `DISTINCT city` query is also not something Firestore offers, so deriving the
+ * list would mean scanning the collection at build time for six strings.
+ *
+ * @tag domain:products
+ * @tag layer:constant
+ * @tag access:isomorphic
+ */
+export interface MeetupCity {
+    /** URL segment. Lower-case, hyphenated — the page's own identity. */
+    slug: string;
+    /** Exactly as stored in `classified.meetupArea.city`, which the query matches on. */
+    city: string;
+    /** State, for the page's own prose and its `<title>`. Never queried. */
+    state: string;
+}
+/**
+ * 🛑 `city` must match the STORED value byte-for-byte. Firestore `==` is
+ * byte-exact (Root Cause #33), so "New Delhi" and "new delhi" are two different
+ * cities to the query and one of them returns nothing with no error — which is
+ * exactly how a filter chip comes to look like it does nothing.
+ */
+export declare const MEETUP_CITIES: readonly MeetupCity[];
+/** The city for a URL segment, or `null` — which the route turns into a 404. */
+export declare function meetupCityBySlug(slug: string): MeetupCity | null;

package/dist/features/products/constants/meetup-cities.js

@@ -0,0 +1,49 @@
+/**
+ * D5 — the cities that get their own local-SEO page.
+ *
+ * ## 🛑 Six, because six is what the data has
+ *
+ * Every entry here is a city a classified listing actually names in
+ * `classified.meetupArea.city`, measured from the seed rather than chosen from
+ * a list of big Indian cities. A page for a city with no listings is an empty
+ * page with a city in its `<title>` — which is the doorway-page pattern Google
+ * penalises, and the thing local SEO is most often got wrong by.
+ *
+ * 🛑 So the rule for adding one is: a city joins this list when listings name
+ * it, not in anticipation of listings naming it. The page still renders when a
+ * city's listings all sell — it says so in words rather than showing an empty
+ * grid, because "nobody is selling here this week" is true and useful, while a
+ * bare grid reads as broken.
+ *
+ * ## Why a constant rather than a query
+ *
+ * These routes are STATIC (`generateStaticParams`), which is the whole point:
+ * a city page that awaited `searchParams` or queried for its own slug list
+ * would be dynamic, and then every visitor and every crawler hit pays a render
+ * — on the surface most likely to be crawled widely (Root Cause #94). A
+ * `DISTINCT city` query is also not something Firestore offers, so deriving the
+ * list would mean scanning the collection at build time for six strings.
+ *
+ * @tag domain:products
+ * @tag layer:constant
+ * @tag access:isomorphic
+ */
+/**
+ * 🛑 `city` must match the STORED value byte-for-byte. Firestore `==` is
+ * byte-exact (Root Cause #33), so "New Delhi" and "new delhi" are two different
+ * cities to the query and one of them returns nothing with no error — which is
+ * exactly how a filter chip comes to look like it does nothing.
+ */
+export const MEETUP_CITIES = [
+    { slug: "mumbai", city: "Mumbai", state: "Maharashtra" },
+    { slug: "bengaluru", city: "Bengaluru", state: "Karnataka" },
+    { slug: "pune", city: "Pune", state: "Maharashtra" },
+    { slug: "new-delhi", city: "New Delhi", state: "Delhi" },
+    { slug: "chennai", city: "Chennai", state: "Tamil Nadu" },
+    { slug: "hyderabad", city: "Hyderabad", state: "Telangana" },
+];
+/** The city for a URL segment, or `null` — which the route turns into a 404. */
+export function meetupCityBySlug(slug) {
+    const want = slug.trim().toLowerCase();
+    return MEETUP_CITIES.find((c) => c.slug === want) ?? null;
+}