@mohasinac/appkit 4.11.2 → 4.11.3

package/dist/_internal/server/features/checkout/actions.d.ts

@@ -44,6 +44,10 @@ export declare function resolveShippingCost(storeId: string | undefined): Promis
     storeEmiEnabled: boolean;
     storeState: string | undefined;
 }>;
+export interface DroppedCoupon {
+    code: string;
+    reason: string;
+}
 /**
  * Place order(s) from the user's cart in a single Firestore transaction.
  *

package/dist/_internal/server/features/checkout/actions.js

@@ -17,6 +17,7 @@ import { computePreOrderDepositAmount, unitPriceFor } from "../../../shared/chec
 import { failedCheckoutRepository } from "../../../../features/checkout/repository/failed-checkout.repository";
 import { sendOrderConfirmationEmail } from "../../../../features/contact/server";
 import { splitCartIntoOrderGroups } from "../../../../features/orders/index";
+import { resolveCouponCategorySlugs } from "../../../../features/promotions/actions/coupon-actions";
 import { assertCheckoutLane, assertLockedLinesStillValid, finalizeLockedLines, } from "./locked-lines";
 import { activeLane, laneOf } from "../../../shared/checkout/lanes";
 import { computeCodHandlingFee, computeWhatsAppNotifyFee, computeGiftWrapFee, computeShipmentProtectionFee, } from "../../../shared/fees/calculator";
@@ -238,6 +239,90 @@ function buildStockUpdatePayload(product, qtyDelta) {
         ...rule.stockDecrementExtras(product, qtyDelta),
     };
 }
+/**
+ * Re-checks every coupon persisted on the cart against the items actually
+ * being ordered, immediately before pricing.
+ *
+ * A cart can sit for days, so the `discountAmount` frozen onto
+ * `cart.appliedCoupons` at apply-time may since have become wrong or
+ * unearned — the coupon may have expired, hit its total/per-user limit, been
+ * deactivated, or had its eligible items removed from the cart. Trusting the
+ * stored amount let all of those redeem anyway.
+ *
+ * Invalid coupons are DROPPED (and reported back to the caller) rather than
+ * failing the whole checkout: the buyer is on the payment step and cannot fix
+ * a lapsed coupon from there, so killing an otherwise-valid order is hostile.
+ *
+ * One parallel round of reads for at most a handful of coupons (the stacking
+ * rule caps it at one per store plus one platform-wide), so this stays inside
+ * the Vercel Hobby round-trip budget.
+ */
+async function revalidateAppliedCoupons(appliedCoupons, available, uid) {
+    if (appliedCoupons.length === 0)
+        return { coupons: [], dropped: [] };
+    const cartItems = available.map(({ item, product }) => ({
+        productId: item.productId,
+        storeId: item.storeId,
+        price: unitPriceFor(item, product),
+        quantity: item.quantity,
+        listingType: (item.listingType ?? "standard"),
+    }));
+    const results = await Promise.all(appliedCoupons.map(async (coupon) => {
+        try {
+            const check = await couponsRepository.validateCouponForCart(coupon.code, uid, cartItems, { resolveCategorySlugs: resolveCouponCategorySlugs });
+            if (!check.valid) {
+                return {
+                    dropped: {
+                        code: coupon.code,
+                        reason: check.message ?? "This coupon is no longer valid",
+                    },
+                };
+            }
+            // Re-derive the amount and the eligible lines from the CURRENT cart —
+            // the stored values were computed against whatever was in the cart at
+            // apply-time.
+            const applicableItemIds = check.eligibleProductIds
+                ? available
+                    .filter(({ item }) => check.eligibleProductIds.includes(item.productId))
+                    .map(({ item }) => item.itemId)
+                : undefined;
+            return {
+                coupon: {
+                    ...coupon,
+                    discountAmount: check.discountAmount ?? 0,
+                    scope: check.scope ?? coupon.scope,
+                    storeId: check.storeId ?? coupon.storeId,
+                    applicableItemIds,
+                },
+            };
+        }
+        catch (err) {
+            void normalizeError(err);
+            // A lookup failure must not silently grant the discount.
+            return {
+                dropped: {
+                    code: coupon.code,
+                    reason: "This coupon could not be verified",
+                },
+            };
+        }
+    }));
+    const coupons = [];
+    const dropped = [];
+    for (const r of results) {
+        if (r.coupon)
+            coupons.push(r.coupon);
+        else if (r.dropped)
+            dropped.push(r.dropped);
+    }
+    if (dropped.length > 0) {
+        serverLogger.info("Dropped invalid coupons at checkout", {
+            uid,
+            codes: dropped.map((d) => d.code).join(","),
+        });
+    }
+    return { coupons, dropped };
+}
 async function flushCouponUsageAccumulator(accumulator, uid) {
     if (accumulator.size === 0)
         return;
@@ -701,7 +786,7 @@ export async function createCheckoutOrderAction(input) {
             .catch((logErr) => { void normalizeError(logErr); serverLogger.warn(AUDIT_LOG_FAIL_MSG, { error: logErr instanceof Error ? logErr.message : String(logErr) }); });
         throw new ValidationError(ERROR_MESSAGES.CHECKOUT.INSUFFICIENT_STOCK);
     }
-    const appliedCoupons = cart.appliedCoupons ?? [];
+    const { coupons: appliedCoupons, dropped: droppedCoupons } = await revalidateAppliedCoupons(cart.appliedCoupons ?? [], available, uid);
     const orderGroups = splitCartIntoOrderGroups(available);
     // Admin-bypass orders are immediately paid and processing; generate a shared
     // transaction reference for all orders in this checkout batch.
@@ -753,6 +838,7 @@ export async function createCheckoutOrderAction(input) {
         total,
         itemCount: orderIds.length,
         ...(unavailable.length > 0 ? { unavailableItems: unavailable } : {}),
+        ...(droppedCoupons.length > 0 ? { droppedCoupons } : {}),
     };
 }
 const EMPTY_PRICING_PREVIEW = {
@@ -805,7 +891,9 @@ export async function previewCheckoutPricing(input) {
     const checks = cartItems.map((item) => ({ item, product: productById.get(item.productId) ?? null }));
     const orderGroups = splitCartIntoOrderGroups(checks);
     const cartSubtotal = orderGroups.reduce((s, { items: g }) => s + g.reduce((gs, { item, product }) => gs + unitPriceFor(item, product) * item.quantity, 0), 0);
-    const appliedCoupons = cart.appliedCoupons ?? [];
+    // Same re-validation the real order placement runs, so the preview never
+    // shows a discount the order won't actually honour.
+    const { coupons: appliedCoupons } = await revalidateAppliedCoupons(cart.appliedCoupons ?? [], checks, uid);
     let shippingFee = 0;
     let codHandlingFee = 0;
     let whatsappNotifyFeeTotal = 0;
@@ -976,7 +1064,7 @@ async function refundDroppedItemsForRazorpayCheckout(input) {
  * from the inline version this replaced.
  */
 async function createRazorpayGroupOrder(group, orderType, ctx) {
-    const { appliedCoupons, cartSubtotal, platformFeePercent, gstPercent, whatsappNotifyFee, giftWrapFee, giftWrapMessage, shipmentProtectionAddon, siteSettings, uid, userName, userEmail, razorpay_order_id, razorpay_payment_id, razorpay_signature, shippingAddress, notes, outOfStockPolicy, unavailablePaid, orderIds, emailsToSend, } = ctx;
+    const { appliedCoupons, cartSubtotal, platformFeePercent, gstPercent, whatsappNotifyFee, giftWrapFee, giftWrapMessage, shipmentProtectionAddon, siteSettings, uid, userName, userEmail, razorpay_order_id, razorpay_payment_id, razorpay_signature, shippingAddress, notes, outOfStockPolicy, unavailablePaid, orderIds, emailsToSend, couponUsageAccumulator, } = ctx;
     const firstItem = group[0].item;
     const groupTotal = group.reduce((sum, { item, product }) => sum + unitPriceFor(item, product) * item.quantity, 0);
     // Reuses the same store/seller lookup as the COD/UPI path above instead
@@ -985,6 +1073,16 @@ async function createRazorpayGroupOrder(group, orderType, ctx) {
     const { shippingFee, storeOwnerId } = await resolveShippingCost(firstItem.storeId);
     const groupLines = group.map(({ item, product }) => ({ itemId: item.itemId, lineTotal: unitPriceFor(item, product) * item.quantity }));
     const { couponDiscount, appliedDiscounts } = computeGroupCouponDiscount(appliedCoupons, groupLines, groupTotal, cartSubtotal, firstItem.storeId);
+    // Mirrors createOrderForGroup — without this the online-payment path wrote
+    // the discount onto the order but never incremented usage.currentUsage or
+    // the per-user counter, so limits were unenforceable for Razorpay orders.
+    const groupCouponCodes = new Set();
+    for (const discount of appliedDiscounts) {
+        if (discount.couponId) {
+            accumulateCouponUsage(couponUsageAccumulator, discount.code, discount.couponId, discount.discountAmount);
+            groupCouponCodes.add(discount.code);
+        }
+    }
     const rawPlatformFee = roundRupees(groupTotal * (platformFeePercent / 100));
     const gstOnFee = roundRupees(rawPlatformFee * (gstPercent / 100));
     const platformFee = rawPlatformFee + gstOnFee;
@@ -1103,6 +1201,11 @@ async function createRazorpayGroupOrder(group, orderType, ctx) {
             productTitle: firstItem.productTitle,
         }).catch((e) => serverLogger.error("claimDigitalCode", e));
     }
+    for (const code of groupCouponCodes) {
+        const entry = couponUsageAccumulator.get(code);
+        if (entry)
+            entry.orderIds.push(order.id);
+    }
     if (userEmail) {
         emailsToSend.push({
             to: userEmail,
@@ -1282,7 +1385,7 @@ export async function verifyAndPlaceRazorpayOrderAction(input) {
             throw new ValidationError(ERROR_MESSAGES.CHECKOUT.PAYMENT_FAILED);
         }
     }
-    const appliedCoupons = cart.appliedCoupons ?? [];
+    const { coupons: appliedCoupons, dropped: droppedCoupons } = await revalidateAppliedCoupons(cart.appliedCoupons ?? [], bucketedPaid.available, uid);
     // "skip_items" (or an all-available cart under any policy) — build order
     // groups from the available bucket only. Dropped items are never ordered;
     // their value is refunded below since Razorpay already captured payment
@@ -1293,6 +1396,7 @@ export async function verifyAndPlaceRazorpayOrderAction(input) {
     const emailsToSend = [];
     const cartSubtotal = orderGroups.reduce((s, { items: g }) => s +
         g.reduce((gs, { item, product }) => gs + unitPriceFor(item, product) * item.quantity, 0), 0);
+    const couponUsageAccumulator = new Map();
     for (const { items: group, orderType } of orderGroups) {
         total += await createRazorpayGroupOrder(group, orderType, {
             appliedCoupons,
@@ -1316,8 +1420,10 @@ export async function verifyAndPlaceRazorpayOrderAction(input) {
             unavailablePaid,
             orderIds,
             emailsToSend,
+            couponUsageAccumulator,
         });
     }
+    await flushCouponUsageAccumulator(couponUsageAccumulator, uid);
     // SB-UNI-5 2026-05-13 — bundle-aware batch decrement. We iterate the
     // cumulative `decrements` map (one entry per unique member product) so a
     // bundle's members + any sibling cart line touching the same product
@@ -1366,5 +1472,6 @@ export async function verifyAndPlaceRazorpayOrderAction(input) {
         total,
         itemCount: orderIds.length,
         ...(unavailablePaid.length > 0 ? { unavailableItems: unavailablePaid } : {}),
+        ...(droppedCoupons.length > 0 ? { droppedCoupons } : {}),
     };
 }

package/dist/_internal/server/features/checkout/data.d.ts

@@ -10,4 +10,14 @@ export interface CheckoutOrderResult {
         requestedQty: number;
         availableQty: number;
     }[];
+    /**
+     * Coupons that were on the cart but failed re-validation at placement time
+     * (expired, limit reached, no longer any eligible items). They were removed
+     * and the order priced without them — surfaced so the UI can tell the buyer
+     * rather than silently charging more than the cart showed.
+     */
+    droppedCoupons?: {
+        code: string;
+        reason: string;
+    }[];
 }

package/dist/_internal/server/features/orders/adapters.js

@@ -50,12 +50,19 @@ export function orderDocumentToOrder(doc) {
         address,
         orderStatus: doc.status,
         paymentStatus: doc.paymentStatus,
+        // Which checkout lane produced this order (standard / auction / offer /
+        // preorder / prize-draw). Drives the lane tabs on /user/orders. Absent on
+        // orders written before `orderType` existed — every reader must treat a
+        // missing value as "standard" rather than filtering it out.
+        orderType: doc.orderType,
+        offerId: doc.offerId,
         subtotal,
         shippingCost: shippingCost || undefined,
         discount: discount || undefined,
         total: doc.totalPrice,
         currency: doc.currency,
         couponCode: doc.couponCode,
+        appliedDiscounts: doc.appliedDiscounts,
         trackingNumber: doc.trackingNumber,
         shippingCarrier: doc.shippingCarrier,
         trackingUrl: doc.trackingUrl,

package/dist/_internal/server/features/products/data.d.ts

@@ -4,15 +4,24 @@ import type { ProductDocument } from "../../../../features/products/schemas/fire
 import type { ListingType } from "../../../../features/products/types";
 import type { ProductItem } from "../../../../features/products/types";
 import type { FirestoreDocument } from "../../../../schemas/types";
-import type { Review } from "../../../../features/reviews/types";
+import type { Review, ReviewListResponse } from "../../../../features/reviews/types";
 /** Fetch a single product by slug or id, deduped per request. */
 export declare const getProductForDetail: (slugOrId: string) => Promise<ProductDocument | null>;
 /** Fetch the first page of approved reviews for a product, deduped per request. */
-export declare const getReviewsForProduct: (productId: string) => Promise<unknown[]>;
+export declare const getReviewsForProduct: (productId: string, limit?: number) => Promise<unknown[]>;
 /** Firestore review doc → client Review shape. Shared by every listing-type detail page's reviews tab. */
 export declare function toReview(doc: FirestoreDocument): Review;
 /** Fetch + map approved reviews for a product straight to the client Review shape, deduped per request. */
-export declare const getReviewItemsForProduct: (productId: string) => Promise<Review[]>;
+export declare const getReviewItemsForProduct: (productId: string, limit?: number) => Promise<Review[]>;
+/**
+ * Page 1 of a product's approved reviews, shaped exactly like `GET /api/reviews?productId=`
+ * so it can seed `<ReviewsListingPanel initialData>` without a client round-trip.
+ *
+ * The defaults here MUST match the panel's bare (unfiltered, page-1) query defaults —
+ * `staleTime: Infinity` freezes whatever `initialData` is handed over, so a mismatch would
+ * pin the wrong rows into the cache (Recurrent Root Cause #30).
+ */
+export declare const getReviewPageForProduct: (productId: string, pageSize?: number) => Promise<ReviewListResponse>;
 /** Minimal product fields needed for sitemap generation. */
 export interface SitemapProduct {
     slugOrId: string;

package/dist/_internal/server/features/products/data.js

@@ -13,6 +13,8 @@ import { PRODUCT_COLLECTION } from "../../../../features/products/schemas/firest
 import { PRODUCTS_SITEMAP_LIMIT } from "../../../shared/features/products/config";
 import { PRODUCT_FIELDS } from "../../../../constants/field-names";
 import { SIEVE_OP, sieveAnd, sieveFilter, sortBy } from "../../../../utils/sieve-builder";
+import { REVIEW_FIELDS } from "../../../../constants/field-names";
+import { REVIEWS_DETAIL_PAGE_SIZE } from "../../../shared/features/reviews/config";
 // ---------------------------------------------------------------------------
 // Request-scoped cache — each function is deduplicated per RSC render tree.
 // Both generateMetadata() and the page component get the same promise.
@@ -26,8 +28,8 @@ export const getProductForDetail = cache(async (slugOrId) => {
     return product;
 });
 /** Fetch the first page of approved reviews for a product, deduped per request. */
-export const getReviewsForProduct = cache(async (productId) => {
-    return reviewRepository.findApprovedByProduct(productId).catch(() => []);
+export const getReviewsForProduct = cache(async (productId, limit = REVIEWS_DETAIL_PAGE_SIZE) => {
+    return reviewRepository.findApprovedByProduct(productId, limit).catch(() => []);
 });
 /** Firestore review doc → client Review shape. Shared by every listing-type detail page's reviews tab. */
 export function toReview(doc) {
@@ -57,10 +59,59 @@ export function toReview(doc) {
     };
 }
 /** Fetch + map approved reviews for a product straight to the client Review shape, deduped per request. */
-export const getReviewItemsForProduct = cache(async (productId) => {
-    const docs = await reviewRepository.findApprovedByProduct(productId).catch(() => []);
+export const getReviewItemsForProduct = cache(async (productId, limit = REVIEWS_DETAIL_PAGE_SIZE) => {
+    const docs = await reviewRepository
+        .findApprovedByProduct(productId, limit)
+        .catch(() => []);
     return docs.map(toReview);
 });
+/**
+ * Page 1 of a product's approved reviews, shaped exactly like `GET /api/reviews?productId=`
+ * so it can seed `<ReviewsListingPanel initialData>` without a client round-trip.
+ *
+ * The defaults here MUST match the panel's bare (unfiltered, page-1) query defaults —
+ * `staleTime: Infinity` freezes whatever `initialData` is handed over, so a mismatch would
+ * pin the wrong rows into the cache (Recurrent Root Cause #30).
+ */
+export const getReviewPageForProduct = cache(async (productId, pageSize = REVIEWS_DETAIL_PAGE_SIZE) => {
+    const empty = {
+        items: [],
+        total: 0,
+        page: 1,
+        pageSize,
+        totalPages: 1,
+        hasMore: false,
+        averageRating: 0,
+        ratingDistribution: {},
+        totalApproved: 0,
+    };
+    try {
+        const [summary, result] = await Promise.all([
+            reviewRepository.getApprovedRatingSummary(productId),
+            reviewRepository.listForProduct(productId, {
+                filters: sieveFilter(REVIEW_FIELDS.STATUS, SIEVE_OP.EQ, "approved"),
+                sorts: sortBy(REVIEW_FIELDS.CREATED_AT),
+                page: 1,
+                pageSize,
+            }),
+        ]);
+        return {
+            items: result.items.map(toReview),
+            total: result.total,
+            page: result.page,
+            pageSize: result.pageSize,
+            totalPages: result.totalPages,
+            hasMore: result.hasMore,
+            averageRating: summary.averageRating,
+            ratingDistribution: summary.ratingDistribution,
+            totalApproved: summary.total,
+        };
+    }
+    catch (err) {
+        void normalizeError(err);
+        return empty;
+    }
+});
 /** List all published products for sitemap generation. */
 export async function listSitemapProducts() {
     try {

package/dist/_internal/server/features/products/index.d.ts

@@ -1,4 +1,4 @@
-export { getProductForDetail, getReviewsForProduct, listSitemapProducts, type SitemapProduct, computeRelatedItems, toProductItem, toReview, getReviewItemsForProduct, type RelatedItemsResult, } from "./data";
+export { getProductForDetail, getReviewsForProduct, listSitemapProducts, type SitemapProduct, computeRelatedItems, toProductItem, toReview, getReviewItemsForProduct, getReviewPageForProduct, type RelatedItemsResult, } from "./data";
 export { listPublicProducts, parsePublicProductParams, PUBLIC_PRODUCT_MAX_PAGE_SIZE, type PublicProductListInput, type PublicProductListResult, type PublicProductListOptions, type PublicProductExecutor, type PublicProductQuery, type ExecutorResult, } from "./list-public";
 export { assertProductOwnership, assertStatusTransition, assertInStock, effectivePrice, isAvailableForPurchase, } from "./service";
 export { createProductAction, createAuctionAction, createPreOrderAction, updateProductAction, deleteProductAction, setProductStatusAction, setProductFeaturedAction, } from "./actions";

package/dist/_internal/server/features/products/index.js

@@ -1,4 +1,4 @@
-export { getProductForDetail, getReviewsForProduct, listSitemapProducts, computeRelatedItems, toProductItem, toReview, getReviewItemsForProduct, } from "./data";
+export { getProductForDetail, getReviewsForProduct, listSitemapProducts, computeRelatedItems, toProductItem, toReview, getReviewItemsForProduct, getReviewPageForProduct, } from "./data";
 export { listPublicProducts, parsePublicProductParams, PUBLIC_PRODUCT_MAX_PAGE_SIZE, } from "./list-public";
 export { assertProductOwnership, assertStatusTransition, assertInStock, effectivePrice, isAvailableForPurchase, } from "./service";
 export { createProductAction, createAuctionAction, createPreOrderAction, updateProductAction, deleteProductAction, setProductStatusAction, setProductFeaturedAction, } from "./actions";

package/dist/_internal/server/features/products/list-public.d.ts

@@ -1,6 +1,25 @@
 import type { JsonValue } from "../../../../schemas/types";
 /** Vercel Hobby Fluid Compute ceiling (CLAUDE.md Rule #6) — never fetch more at once. */
 export declare const PUBLIC_PRODUCT_MAX_PAGE_SIZE = 50;
+/**
+ * Which "Show X" defaults apply to a set of listing types.
+ *
+ * THE POINT OF THIS FUNCTION is that SSR and the client refetch call the SAME
+ * implementation. `staleTime: Infinity` freezes SSR `initialData` forever, so
+ * if the SSR filter-builder computes a different default than the client's
+ * bare-URL state, the first paint and every later refetch disagree and one of
+ * them is wrong — permanently (Root Cause #30). Two mirrored literals is
+ * exactly how that bug is written; one shared function is how it isn't.
+ *
+ * `/products` now spans all nine listing types, which makes this load-bearing
+ * rather than theoretical: a mixed set includes both sold-out-able types
+ * (products, art) and time-boxed ones (auctions, pre-orders, prize draws), so
+ * BOTH toggles can apply at once.
+ */
+export declare function defaultTogglesForListingTypes(types: readonly string[] | undefined): {
+    hideSoldByDefault: boolean;
+    hideEndedByDefault: boolean;
+};
 /**
  * A product document as it comes back from either executor. Deliberately
  * `JsonValue`-shaped rather than `ProductDocument`: the upstream listingProcessor

package/dist/_internal/server/features/products/list-public.js

@@ -32,8 +32,36 @@ import { PRODUCT_FIELDS } from "../../../../constants/field-names";
 import { TABLE_KEYS } from "../../../../constants/table-keys";
 import { sortBy } from "../../../../constants/sort";
 import { SIEVE_OP, sieveAnd, sieveFilter, expandSieveParam, } from "../../../../utils/sieve-builder";
+import { ALL_LISTING_TYPES } from "../../../shared/listing-types/feature-flags";
+import { hideDefaultsFor } from "../../../shared/listing-types/_registry";
 /** Vercel Hobby Fluid Compute ceiling (CLAUDE.md Rule #6) — never fetch more at once. */
 export const PUBLIC_PRODUCT_MAX_PAGE_SIZE = 50;
+/**
+ * Which "Show X" defaults apply to a set of listing types.
+ *
+ * THE POINT OF THIS FUNCTION is that SSR and the client refetch call the SAME
+ * implementation. `staleTime: Infinity` freezes SSR `initialData` forever, so
+ * if the SSR filter-builder computes a different default than the client's
+ * bare-URL state, the first paint and every later refetch disagree and one of
+ * them is wrong — permanently (Root Cause #30). Two mirrored literals is
+ * exactly how that bug is written; one shared function is how it isn't.
+ *
+ * `/products` now spans all nine listing types, which makes this load-bearing
+ * rather than theoretical: a mixed set includes both sold-out-able types
+ * (products, art) and time-boxed ones (auctions, pre-orders, prize draws), so
+ * BOTH toggles can apply at once.
+ */
+export function defaultTogglesForListingTypes(types) {
+    // No explicit set = every type is in play, so both defaults apply.
+    const effective = types && types.length > 0 ? types : ALL_LISTING_TYPES;
+    const defaults = hideDefaultsFor(effective.filter((t) => ALL_LISTING_TYPES.includes(t)));
+    return {
+        hideSoldByDefault: defaults.includes("sold"),
+        // "ended" and "closed" are the same query mechanic (a date range against
+        // the type's own end field); they differ only in the toggle's wording.
+        hideEndedByDefault: defaults.includes("ended") || defaults.includes("closed"),
+    };
+}
 const DEFAULT_PAGE = 1;
 const DEFAULT_PAGE_SIZE = 24;
 const DEFAULT_SORTS = sortBy(PRODUCT_FIELDS.CREATED_AT);
@@ -59,14 +87,19 @@ function num(raw) {
  */
 export function parsePublicProductParams(params, defaults) {
     const get = (k) => first(params, k);
-    // A single type chip narrows the page's span; anything else keeps the full span.
+    // The type filter is a multi-select checkbox group, so its URL value is a
+    // pipe-joined set (`auction|pre-order`). Selected types NARROW the page's
+    // span; anything outside the span is discarded rather than allowed to widen
+    // it (an /art URL must not be able to ask for auctions). Nothing selected —
+    // or nothing valid selected — means the page's full span.
     const typeParam = get(TABLE_KEYS.LISTING_TYPE);
     const span = defaults?.listingTypes;
-    const listingTypes = typeParam
-        ? span && !span.includes(typeParam)
-            ? span // an unknown chip value must not widen the page beyond its own span
-            : [typeParam]
-        : span;
+    const selected = typeParam
+        .split("|")
+        .map((t) => t.trim())
+        .filter((t) => t && t !== "All");
+    const narrowed = span ? selected.filter((t) => span.includes(t)) : selected;
+    const listingTypes = narrowed.length > 0 ? narrowed : span;
     const featuresRaw = get(TABLE_KEYS.FEATURES);
     return {
         listingTypes,

package/dist/_internal/server/features/reviews/data.d.ts

@@ -1,4 +1,4 @@
-export declare const getReviewsForProduct: (productId: string) => Promise<never[] | import("../../../..").ReviewDocument[]>;
+export declare const getReviewsForProduct: (productId: string, limit?: number) => Promise<never[] | import("../../../..").ReviewDocument[]>;
 export declare const getReviewsForStore: (storeId: string, page?: number, pageSize?: number) => Promise<import("../../../..").FirebaseSieveResult<import("../../../..").ReviewDocument> | {
     items: never[];
     total: number;

package/dist/_internal/server/features/reviews/data.js

@@ -1,7 +1,8 @@
 import { cache } from "react";
 import { reviewRepository, orderRepository } from "../../../../repositories";
-export const getReviewsForProduct = cache(async (productId) => {
-    return reviewRepository.findApprovedByProduct(productId).catch(() => []);
+import { REVIEWS_DETAIL_PAGE_SIZE } from "../../../shared/features/reviews/config";
+export const getReviewsForProduct = cache(async (productId, limit = REVIEWS_DETAIL_PAGE_SIZE) => {
+    return reviewRepository.findApprovedByProduct(productId, limit).catch(() => []);
 });
 export const getReviewsForStore = cache(async (storeId, page = 1, pageSize = 20) => {
     return reviewRepository.listForStore(storeId, { page, pageSize }).catch(() => ({

package/dist/_internal/server/features/tester/visibility.js

@@ -3,9 +3,9 @@
  * created as fully public/active documents so testers exercise the real browse/search/
  * checkout code paths, but must stay invisible to non-testers. Filtering happens at the
  * application layer (post-fetch, in-memory) rather than via a Firestore `where` clause,
- * because `isTestData` is a new optional field — a Firestore inequality filter
- * (`where("isTestData", "!=", true)`) would silently exclude every pre-existing document
- * that doesn't have the field set at all, which is worse than the problem it solves.
+ * because `isTestData` is a new optional field — a Firestore inequality filter on it
+ * (a `!=` clause) would silently exclude every pre-existing document that doesn't have
+ * the field set at all, which is worse than the problem it solves.
  */
 import { isAdminUser } from "../../../../features/auth/role-predicates";
 /** True when the viewer is allowed to see isTestData:true documents. */

package/dist/_internal/server/jobs/core/testerSandboxCleanup.d.ts

@@ -1,5 +1,5 @@
 import type { JobContext } from "../runtime/types";
-export declare const SANDBOX_COLLECTIONS: readonly ["categories", "stores", "products", "blogPosts", "events"];
+export declare const SANDBOX_COLLECTIONS: readonly ["categories", "stores", "products", "blogPosts", "events", "offers"];
 export interface TesterSandboxCleanupOptions {
     /** true = wipe every isTestData:true doc regardless of testDataExpiresAt (manual force-purge). */
     force?: boolean;

package/dist/_internal/server/jobs/core/testerSandboxCleanup.js

@@ -3,7 +3,10 @@ import { BID_FIELDS } from "../../../../constants/field-names";
 // Exported so testerSandboxRefresh.ts (the every-4h revert+prune job) reuses
 // the exact same collection scope instead of redefining it — one source of
 // truth for "what counts as sandbox scope."
-export const SANDBOX_COLLECTIONS = ["categories", "stores", "products", "blogPosts", "events"];
+// Keep in sync with testerSandboxRefresh.ts's SEED_BY_COLLECTION — the daily
+// TTL cleanup and the 4-hourly revert+prune must agree on what "sandbox" means
+// (CLAUDE.md § Tester QA standards #3).
+export const SANDBOX_COLLECTIONS = ["categories", "stores", "products", "blogPosts", "events", "offers"];
 const BID_CHUNK_SIZE = 30; // Firestore `in` query cap
 export async function runTesterSandboxCleanup(ctx, opts = {}) {
     const cutoff = opts.force ? null : new Date();

package/dist/_internal/server/jobs/core/testerSandboxRefresh.js

@@ -8,6 +8,7 @@ import { storesTesterSeedData } from "../../../../features/tester/seed-data/stor
 import { productsTesterSeedData } from "../../../../features/tester/seed-data/products-tester-seed-data";
 import { blogTesterSeedData } from "../../../../features/tester/seed-data/blog-tester-seed-data";
 import { eventsTesterSeedData } from "../../../../features/tester/seed-data/events-tester-seed-data";
+import { offersTesterSeedData } from "../../../../features/tester/seed-data/offers-tester-seed-data";
 import { bidsTesterSeedData } from "../../../../features/tester/seed-data/bids-tester-seed-data";
 const SEED_BY_COLLECTION = {
     categories: categoriesTesterSeedData,
@@ -15,6 +16,7 @@ const SEED_BY_COLLECTION = {
     products: productsTesterSeedData,
     blogPosts: blogTesterSeedData,
     events: eventsTesterSeedData,
+    offers: offersTesterSeedData,
 };
 const BID_CHUNK_SIZE = 30; // Firestore `in` query cap
 /**

package/dist/_internal/server/jobs/handlers/_helpers.js

@@ -2,6 +2,7 @@
  * Shared helpers for job handlers.
  */
 import { getAdminRealtimeDb } from "../../../../providers/db-firebase";
+import { PRODUCT_FIELDS } from "../../../../constants/field-names";
 import { BATCH_LIMIT } from "./messages";
 /** Batch-delete document refs, respecting Firestore's 500-write batch limit. */
 export async function batchDelete(ctx, refs) {
@@ -23,7 +24,9 @@ export { getAdminRealtimeDb };
  * only the ones past testDataExpiresAt (the scheduled 7-day sweep).
  */
 export async function getTestDataRefs(db, collection, cutoff) {
-    let q = db.collection(collection).where("isTestData", "==", true);
+    let q = db
+        .collection(collection)
+        .where(PRODUCT_FIELDS.IS_TEST_DATA, "==", true);
     if (cutoff)
         q = q.where("testDataExpiresAt", "<=", cutoff);
     const snap = await q.limit(200).get();