@mohasinac/appkit 4.11.2 → 4.12.0

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
@@ -30,6 +49,16 @@ export interface PublicProductListInput {
     freeShipping?: boolean;
     isPartOfBundle?: boolean;
     features?: readonly string[];
+    /** Pipe-joined multi-select over the `tags` array field. */
+    tags?: readonly string[];
+    /** Pipe-joined multi-select over `sublistingCategoryId`. */
+    sublistingCategoryIds?: readonly string[];
+    /**
+     * Per-listing-type facets (classified meetup city, digital-code delivery
+     * method, live-item species, …), keyed by TABLE_KEY. Resolved to their
+     * nested Firestore paths via `TYPE_FACET_FIELD`.
+     */
+    typeFacets?: Record<string, string>;
     preOrderProductionStatus?: string;
     prizeRevealStatus?: string;
     /** Hide sold-out rows. Applied in memory — never pushed into Firestore. */
@@ -108,4 +137,22 @@ export declare function parsePublicProductParams(params: URLSearchParams | Recor
     hideEndedByDefault?: boolean;
 }): PublicProductListInput;
 export declare function listPublicProducts(input: PublicProductListInput, opts?: PublicProductListOptions): Promise<PublicProductListResult | null>;
+/**
+ * One store tab's worth of listings.
+ *
+ * Every `Store*PageView` used to hand-roll this: `productRepository.list()`
+ * with an inline `sieveAnd(...)` and a `.catch(() => null)`. That is the exact
+ * shape that made `/art` render empty — an unsafe inequality (or any missing
+ * index) becomes FAILED_PRECONDITION, the catch turns it into `null`, and the
+ * page shows "no results" with nothing logged. Eight views carried it, and
+ * `audit-listing-filter-parity` had none of them registered.
+ *
+ * Routing them through `listPublicProducts` also gives every store tab
+ * something it never had: the URL's own sort/filter/page params reach the SSR
+ * fetch, so the first paint matches what the toolbar says is selected.
+ */
+export declare function listStoreProducts(storeId: string, listingTypes: readonly string[], searchParams?: URLSearchParams | Record<string, string | string[] | undefined>, defaults?: {
+    pageSize?: number;
+    sorts?: string;
+}): Promise<PublicProductListResult | null>;
 export {};

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);
@@ -52,6 +80,40 @@ function num(raw) {
     const n = Number(raw);
     return Number.isFinite(n) ? n : undefined;
 }
+/**
+ * Per-type facet URL key → the Firestore field path it filters.
+ *
+ * Every target is already allowlisted in the products repository's
+ * SIEVE_FIELDS — the nested `classified.*` / `digitalCode.*` / `liveItem.*`
+ * entries have been there since those types shipped. What was missing was any
+ * code path that actually emitted a clause for them: the store listings
+ * declared these keys in their FILTER_KEYS (so they counted toward the
+ * filter badge) and rendered the controls, but never put them on the wire.
+ */
+const TYPE_FACET_FIELD = {
+    [TABLE_KEYS.CITY]: "classified.meetupArea.city",
+    [TABLE_KEYS.NEGOTIABLE]: "classified.negotiable",
+    [TABLE_KEYS.ACCEPTS_SHIPPING]: "classified.acceptsShipping",
+    [TABLE_KEYS.DELIVERY_METHOD]: "digitalCode.codeDeliveryMethod",
+    [TABLE_KEYS.SPECIES]: "liveItem.species",
+    [TABLE_KEYS.LIVE_SEX]: "liveItem.sex",
+    [TABLE_KEYS.JURISDICTION]: "liveItem.jurisdictionAllowed",
+};
+/** Read every known per-type facet present in the params. */
+function readTypeFacets(get) {
+    const out = {};
+    for (const key of Object.keys(TYPE_FACET_FIELD)) {
+        const value = get(key);
+        if (value)
+            out[key] = value;
+    }
+    return Object.keys(out).length > 0 ? out : undefined;
+}
+/** Split a pipe-joined multi-select value; `undefined` when empty. */
+function pipeList(raw) {
+    const parts = raw.split("|").map((s) => s.trim()).filter(Boolean);
+    return parts.length > 0 ? parts : undefined;
+}
 /**
  * Read the shared public-listing query params. SSR views hand in Next's
  * `searchParams` record; the API route hands in `url.searchParams`. Both produce
@@ -59,14 +121,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,
@@ -85,6 +152,12 @@ export function parsePublicProductParams(params, defaults) {
         freeShipping: get(TABLE_KEYS.FREE_SHIPPING) === "true" || undefined,
         isPartOfBundle: get(TABLE_KEYS.IS_PART_OF_BUNDLE) === "true" || undefined,
         features: featuresRaw ? featuresRaw.split("|").filter(Boolean) : undefined,
+        // Tags and Sublisting Type were rendered by <ProductFilters> for all three
+        // variants and counted toward the active-filter badge, but were never
+        // parsed here — so ticking one inflated the badge and changed nothing.
+        tags: pipeList(get(TABLE_KEYS.TAGS)),
+        sublistingCategoryIds: pipeList(get(TABLE_KEYS.SUBLISTING_CATEGORY)),
+        typeFacets: readTypeFacets(get),
         preOrderProductionStatus: get(TABLE_KEYS.PREORDER_STATUS) || get("preOrderStatus") || undefined,
         prizeRevealStatus: get(TABLE_KEYS.PRIZE_REVEAL_STATUS) || undefined,
         // Three spellings of one intent — /products and /art call it "Show sold",
@@ -178,6 +251,31 @@ function buildFirestoreSafeFilters(input) {
     if (input.features?.length === 1) {
         parts.push(sieveFilter(PRODUCT_FIELDS.FEATURES, SIEVE_OP.CONTAINS, input.features[0]));
     }
+    // `tags` is an array field, so the same one-value limit applies.
+    if (input.tags?.length === 1) {
+        parts.push(sieveFilter(PRODUCT_FIELDS.TAGS, SIEVE_OP.CONTAINS, input.tags[0]));
+    }
+    // A scalar field, so several values ARE expressible as an OR-group (which
+    // the Firebase adapter upgrades to `in`).
+    if (input.sublistingCategoryIds?.length) {
+        parts.push(sieveFilter(PRODUCT_FIELDS.SUBLISTING_CATEGORY_ID, SIEVE_OP.EQ, input.sublistingCategoryIds.join("|")));
+    }
+    // Per-type facets. Unknown keys can't reach here — `readTypeFacets` only
+    // reads the ones in TYPE_FACET_FIELD, so an arbitrary query param can never
+    // be turned into a Firestore field path.
+    for (const [key, raw] of Object.entries(input.typeFacets ?? {})) {
+        const field = TYPE_FACET_FIELD[key];
+        if (!field || !raw)
+            continue;
+        // `jurisdictionAllowed` is an array field — array-contains, not equality.
+        const op = field.endsWith("jurisdictionAllowed") ? SIEVE_OP.CONTAINS : SIEVE_OP.EQ;
+        const values = raw.split("|").filter(Boolean);
+        if (values.length === 0)
+            continue;
+        parts.push(op === SIEVE_OP.CONTAINS
+            ? sieveFilter(field, op, values[0])
+            : sieveFilter(field, op, values.join("|")));
+    }
     if (input.rawFilters)
         parts.push(input.rawFilters);
     return sieveAnd(...parts.filter(Boolean));
@@ -320,6 +418,33 @@ export async function listPublicProducts(input, opts) {
         sorts,
     };
 }
+/**
+ * One store tab's worth of listings.
+ *
+ * Every `Store*PageView` used to hand-roll this: `productRepository.list()`
+ * with an inline `sieveAnd(...)` and a `.catch(() => null)`. That is the exact
+ * shape that made `/art` render empty — an unsafe inequality (or any missing
+ * index) becomes FAILED_PRECONDITION, the catch turns it into `null`, and the
+ * page shows "no results" with nothing logged. Eight views carried it, and
+ * `audit-listing-filter-parity` had none of them registered.
+ *
+ * Routing them through `listPublicProducts` also gives every store tab
+ * something it never had: the URL's own sort/filter/page params reach the SSR
+ * fetch, so the first paint matches what the toolbar says is selected.
+ */
+export async function listStoreProducts(storeId, listingTypes, searchParams = {}, defaults) {
+    return listPublicProducts({
+        ...parsePublicProductParams(searchParams, {
+            listingTypes,
+            pageSize: defaults?.pageSize ?? DEFAULT_PAGE_SIZE,
+            sorts: defaults?.sorts,
+            ...defaultTogglesForListingTypes(listingTypes),
+        }),
+        // The route owns the store identity — a `?storeId=` in the URL must not be
+        // able to make one store's tab render another store's inventory.
+        storeId,
+    });
+}
 function sortRows(rows, field, desc) {
     return [...rows].sort((a, b) => {
         const av = a[field];

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/auctionSettlement.js

@@ -2,12 +2,15 @@ import { bidRepository, cartRepository, productRepository, storeRepository, } fr
 import { sendNotification } from "../../../../features/admin/actions/notification-actions";
 import { AUCTION_MESSAGES } from "../handlers/messages";
 import { ROUTES } from "../../../../next/routing/route-map";
-import { CART_LANE } from "../../../shared/checkout/lanes";
+import { CART_LANE, LANE_CHECKOUT_WINDOW_MS } from "../../../shared/checkout/lanes";
 /**
  * How long the winner has to pay before the locked cart line lapses. Mirrors
  * the accepted-offer window so both locked lanes behave the same.
  */
-const AUCTION_CHECKOUT_WINDOW_MS = 48 * 60 * 60 * 1000;
+// Was a local `48 * 60 * 60 * 1000` here AND an identical one in bid-actions.ts
+// (the Buy-Now path), with nothing linking them — changing one would have given
+// the same kind of win two different deadlines depending on how it was won.
+const AUCTION_CHECKOUT_WINDOW_MS = LANE_CHECKOUT_WINDOW_MS.auction;
 /** Deep link the winner straight into the auction checkout lane. */
 const AUCTION_CHECKOUT_URL = `${String(ROUTES.USER.CHECKOUT)}?lane=${CART_LANE.AUCTION}`;
 async function settleAuction(ctx, product) {

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();

package/dist/_internal/shared/checkout/lanes.d.ts

@@ -11,6 +11,26 @@ export type CartLane = (typeof CART_LANE)[keyof typeof CART_LANE];
  */
 export declare const CART_LANE_PRIORITY: readonly CartLane[];
 export declare const CART_LANE_LABELS: Record<CartLane, string>;
+/**
+ * How long a locked line survives before it lapses, per lane.
+ *
+ * Lives here, with the lane model, because the deadline is a property OF the
+ * lane — and because `AUCTION_CHECKOUT_WINDOW_MS` was previously declared twice
+ * (`auctionSettlement.ts` and `bid-actions.ts`, i.e. the settlement path and the
+ * Buy-Now path) with no link between them: changing one would silently give the
+ * same kind of win two different deadlines depending on how it was won.
+ *
+ * The two windows are equal today but mean different things, so they stay
+ * separate names rather than one shared constant:
+ *  - **auction** — payment is MANDATORY. You bid, you won, you owe it. Past the
+ *    deadline the bid is forfeited and the buyer is warned that repeated
+ *    non-payment restricts their account.
+ *  - **offer** — payment is OPTIONAL. Declining to buy at your own offer price
+ *    is the buyer's right; the offer simply lapses with no penalty.
+ */
+export declare const LANE_CHECKOUT_WINDOW_MS: Record<"auction" | "offer", number>;
+/** 2 days, in hours — for buyer-facing copy ("pay within 48 hours"). */
+export declare const LANE_CHECKOUT_WINDOW_HOURS: Record<"auction" | "offer", number>;
 /** The two lanes whose price is fixed outside the listing. */
 export declare function isLockedLane(lane: CartLane): boolean;
 /** Minimal shape this module needs — works on cart documents and client rows alike. */

package/dist/_internal/shared/checkout/lanes.js

@@ -44,6 +44,34 @@ export const CART_LANE_LABELS = {
     offer: "Accepted offers",
     standard: "Cart",
 };
+/**
+ * How long a locked line survives before it lapses, per lane.
+ *
+ * Lives here, with the lane model, because the deadline is a property OF the
+ * lane — and because `AUCTION_CHECKOUT_WINDOW_MS` was previously declared twice
+ * (`auctionSettlement.ts` and `bid-actions.ts`, i.e. the settlement path and the
+ * Buy-Now path) with no link between them: changing one would silently give the
+ * same kind of win two different deadlines depending on how it was won.
+ *
+ * The two windows are equal today but mean different things, so they stay
+ * separate names rather than one shared constant:
+ *  - **auction** — payment is MANDATORY. You bid, you won, you owe it. Past the
+ *    deadline the bid is forfeited and the buyer is warned that repeated
+ *    non-payment restricts their account.
+ *  - **offer** — payment is OPTIONAL. Declining to buy at your own offer price
+ *    is the buyer's right; the offer simply lapses with no penalty.
+ */
+export const LANE_CHECKOUT_WINDOW_MS = {
+    /** 2 days. Mandatory — enforced by the expiry sweep, which forfeits the bid. */
+    auction: 48 * 60 * 60 * 1000,
+    /** 2 days. Optional — lapses quietly, no penalty. */
+    offer: 48 * 60 * 60 * 1000,
+};
+/** 2 days, in hours — for buyer-facing copy ("pay within 48 hours"). */
+export const LANE_CHECKOUT_WINDOW_HOURS = {
+    auction: LANE_CHECKOUT_WINDOW_MS.auction / (60 * 60 * 1000),
+    offer: LANE_CHECKOUT_WINDOW_MS.offer / (60 * 60 * 1000),
+};
 /** The two lanes whose price is fixed outside the listing. */
 export function isLockedLane(lane) {
     return lane === CART_LANE.AUCTION || lane === CART_LANE.OFFER;

package/dist/_internal/shared/features/checkout/config.d.ts

@@ -1,4 +1,8 @@
 export declare const CHECKOUT_DEFAULT_COMMISSIONS: {
+    readonly platformFeePercent: 5;
+    readonly gstPercent: 18;
+    readonly minimumTransactionFee: 0;
+    readonly platformFeeMax: 10;
     readonly codDepositPercent: 10;
     readonly codHandlingFeeMin: 200;
     readonly codHandlingFeePercent: 10;

package/dist/_internal/shared/features/checkout/config.js

@@ -1,4 +1,12 @@
 export const CHECKOUT_DEFAULT_COMMISSIONS = {
+    // Platform-commission rates. Previously absent here because no checkout path
+    // computed a buyer-facing platform fee — the moment one did, a siteSettings
+    // document that failed to load would have produced NaN fees rather than a
+    // sane fallback. Mirrors the SiteSettingsDocument defaults.
+    platformFeePercent: 5,
+    gstPercent: 18,
+    minimumTransactionFee: 0,
+    platformFeeMax: 10,
     codDepositPercent: 10,
     codHandlingFeeMin: 200,
     codHandlingFeePercent: 10,

package/dist/_internal/shared/features/promotions/schema.d.ts

@@ -23,7 +23,6 @@ export declare const createCouponSchema: z.ZodObject<{
     name: z.ZodString;
     type: z.ZodEnum<["percentage", "fixed", "free_shipping", "buy_x_get_y"]>;
     scope: z.ZodEnum<["admin", "seller"]>;
-    sellerId: z.ZodOptional<z.ZodString>;
     discount: z.ZodObject<{
         value: z.ZodNumber;
         maxDiscount: z.ZodOptional<z.ZodNumber>;
@@ -62,17 +61,14 @@ export declare const createCouponSchema: z.ZodObject<{
     }>;
     restrictions: z.ZodOptional<z.ZodObject<{
         firstTimeUserOnly: z.ZodDefault<z.ZodBoolean>;
-        combineWithSellerCoupons: z.ZodDefault<z.ZodBoolean>;
         applicableProducts: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
         applicableCategories: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
     }, "strip", z.ZodTypeAny, {
         firstTimeUserOnly: boolean;
-        combineWithSellerCoupons: boolean;
         applicableProducts?: string[] | undefined;
         applicableCategories?: string[] | undefined;
     }, {
         firstTimeUserOnly?: boolean | undefined;
-        combineWithSellerCoupons?: boolean | undefined;
         applicableProducts?: string[] | undefined;
         applicableCategories?: string[] | undefined;
     }>>;
@@ -95,10 +91,8 @@ export declare const createCouponSchema: z.ZodObject<{
         endDate: string;
         startDate: string;
     };
-    sellerId?: string | undefined;
     restrictions?: {
         firstTimeUserOnly: boolean;
-        combineWithSellerCoupons: boolean;
         applicableProducts?: string[] | undefined;
         applicableCategories?: string[] | undefined;
     } | undefined;
@@ -121,10 +115,8 @@ export declare const createCouponSchema: z.ZodObject<{
         startDate: string;
         isActive?: boolean | undefined;
     };
-    sellerId?: string | undefined;
     restrictions?: {
         firstTimeUserOnly?: boolean | undefined;
-        combineWithSellerCoupons?: boolean | undefined;
         applicableProducts?: string[] | undefined;
         applicableCategories?: string[] | undefined;
     } | undefined;
@@ -134,7 +126,6 @@ export declare const updateCouponSchema: z.ZodObject<Omit<{
     name: z.ZodOptional<z.ZodString>;
     type: z.ZodOptional<z.ZodEnum<["percentage", "fixed", "free_shipping", "buy_x_get_y"]>>;
     scope: z.ZodOptional<z.ZodEnum<["admin", "seller"]>>;
-    sellerId: z.ZodOptional<z.ZodOptional<z.ZodString>>;
     discount: z.ZodOptional<z.ZodObject<{
         value: z.ZodNumber;
         maxDiscount: z.ZodOptional<z.ZodNumber>;
@@ -173,17 +164,14 @@ export declare const updateCouponSchema: z.ZodObject<Omit<{
     }>>;
     restrictions: z.ZodOptional<z.ZodOptional<z.ZodObject<{
         firstTimeUserOnly: z.ZodDefault<z.ZodBoolean>;
-        combineWithSellerCoupons: z.ZodDefault<z.ZodBoolean>;
         applicableProducts: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
         applicableCategories: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
     }, "strip", z.ZodTypeAny, {
         firstTimeUserOnly: boolean;
-        combineWithSellerCoupons: boolean;
         applicableProducts?: string[] | undefined;
         applicableCategories?: string[] | undefined;
     }, {
         firstTimeUserOnly?: boolean | undefined;
-        combineWithSellerCoupons?: boolean | undefined;
         applicableProducts?: string[] | undefined;
         applicableCategories?: string[] | undefined;
     }>>>;
@@ -191,7 +179,6 @@ export declare const updateCouponSchema: z.ZodObject<Omit<{
     type?: "fixed" | "percentage" | "free_shipping" | "buy_x_get_y" | undefined;
     scope?: "seller" | "admin" | undefined;
     name?: string | undefined;
-    sellerId?: string | undefined;
     discount?: {
         value: number;
         minPurchase: number;
@@ -208,7 +195,6 @@ export declare const updateCouponSchema: z.ZodObject<Omit<{
     } | undefined;
     restrictions?: {
         firstTimeUserOnly: boolean;
-        combineWithSellerCoupons: boolean;
         applicableProducts?: string[] | undefined;
         applicableCategories?: string[] | undefined;
     } | undefined;
@@ -216,7 +202,6 @@ export declare const updateCouponSchema: z.ZodObject<Omit<{
     type?: "fixed" | "percentage" | "free_shipping" | "buy_x_get_y" | undefined;
     scope?: "seller" | "admin" | undefined;
     name?: string | undefined;
-    sellerId?: string | undefined;
     discount?: {
         value: number;
         maxDiscount?: number | undefined;
@@ -233,7 +218,6 @@ export declare const updateCouponSchema: z.ZodObject<Omit<{
     } | undefined;
     restrictions?: {
         firstTimeUserOnly?: boolean | undefined;
-        combineWithSellerCoupons?: boolean | undefined;
         applicableProducts?: string[] | undefined;
         applicableCategories?: string[] | undefined;
     } | undefined;