@mohasinac/appkit 4.11.3 → 4.12.1

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

@@ -80,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
@@ -118,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",
@@ -211,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));
@@ -353,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/functions/firestore.d.ts

@@ -6,7 +6,6 @@
  * The path patterns mirror the original `functions/src/index.ts` declarations
  * to preserve identical deploy behavior.
  */
-export declare const onBidPlaced: import("./types").DocumentTriggerFunctionDefinition<null, import("../jobs").NewBid>;
 export declare const onOrderCreate: import("./types").DocumentTriggerFunctionDefinition<null, import("../jobs").NewOrder>;
 export declare const onOrderStatusChange: import("./types").DocumentTriggerFunctionDefinition<import("../jobs").OrderBefore, import("../jobs").OrderAfter>;
 export declare const onProductWrite: import("./types").DocumentTriggerFunctionDefinition<import("../jobs").ProductDoc, import("../jobs").ProductDoc>;
@@ -51,7 +50,7 @@ export declare const onCatalogueSubmittedForApproval: import("./types").Document
     [x: string]: import("../../..").JsonValue;
 }>;
 export declare const onJobCreated: import("./types").DocumentTriggerFunctionDefinition<null, import("../../../server").JobDocument>;
-export declare const FIRESTORE_TRIGGER_FUNCTIONS: readonly [import("./types").DocumentTriggerFunctionDefinition<null, import("../jobs").NewBid>, import("./types").DocumentTriggerFunctionDefinition<null, import("../jobs").NewOrder>, import("./types").DocumentTriggerFunctionDefinition<import("../jobs").OrderBefore, import("../jobs").OrderAfter>, import("./types").DocumentTriggerFunctionDefinition<import("../jobs").ProductDoc, import("../jobs").ProductDoc>, import("./types").DocumentTriggerFunctionDefinition<{
+export declare const FIRESTORE_TRIGGER_FUNCTIONS: readonly [import("./types").DocumentTriggerFunctionDefinition<null, import("../jobs").NewOrder>, import("./types").DocumentTriggerFunctionDefinition<import("../jobs").OrderBefore, import("../jobs").OrderAfter>, import("./types").DocumentTriggerFunctionDefinition<import("../jobs").ProductDoc, import("../jobs").ProductDoc>, import("./types").DocumentTriggerFunctionDefinition<{
     [x: string]: import("../../..").JsonValue;
 }, {
     [x: string]: import("../../..").JsonValue;

package/dist/_internal/server/functions/firestore.js

@@ -6,16 +6,9 @@
  * The path patterns mirror the original `functions/src/index.ts` declarations
  * to preserve identical deploy behavior.
  */
-import { onBidPlacedHandler, onCategoryWriteHandler, onOrderCreateHandler, onOrderStatusChangeHandler, onProductStockChangeHandler, onProductWriteHandler, onReviewWriteHandler, onScamReportCreateHandler, onScamReportUpdateHandler, onStoreWriteHandler, onSupportTicketCreateHandler, onSupportTicketUpdateHandler, onUserBanChangeHandler, onShipmentItemWriteHandler, onShipmentLotWriteHandler, onShipmentHeaderWriteHandler, onShipmentDeletedHandler, onCatalogueSubmittedForApprovalHandler, onJobCreatedHandler, onPrizeDrawPaymentConfirmedHandler, prizeDrawSoldOutRevealHandler, } from "../jobs/handlers";
+import { onCategoryWriteHandler, onOrderCreateHandler, onOrderStatusChangeHandler, onProductStockChangeHandler, onProductWriteHandler, onReviewWriteHandler, onScamReportCreateHandler, onScamReportUpdateHandler, onStoreWriteHandler, onSupportTicketCreateHandler, onSupportTicketUpdateHandler, onUserBanChangeHandler, onShipmentItemWriteHandler, onShipmentLotWriteHandler, onShipmentHeaderWriteHandler, onShipmentDeletedHandler, onCatalogueSubmittedForApprovalHandler, onJobCreatedHandler, onPrizeDrawPaymentConfirmedHandler, prizeDrawSoldOutRevealHandler, } from "../jobs/handlers";
 import { defineFunction } from "./define";
 const REGION = "asia-south1";
-export const onBidPlaced = defineFunction({
-    name: "onBidPlaced",
-    description: "Side-effects on bid creation (notifications, outbid emails).",
-    trigger: { kind: "documentCreated", pathPattern: "bids/{bidId}" },
-    handler: onBidPlacedHandler,
-    options: { region: REGION },
-});
 export const onOrderCreate = defineFunction({
     name: "onOrderCreate",
     description: "Side-effects on order creation (notify store, decrement stock).",
@@ -164,7 +157,6 @@ export const onJobCreated = defineFunction({
     options: { region: REGION, timeoutSeconds: 300, memory: "512MiB" },
 });
 export const FIRESTORE_TRIGGER_FUNCTIONS = [
-    onBidPlaced,
     onOrderCreate,
     onOrderStatusChange,
     onProductWrite,

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/index.d.ts

@@ -36,7 +36,6 @@ export { runStoreAnalytics, type StoreAnalyticsInput, type StoreAnalyticsResult,
 export { runAdminAnalytics, type AdminAnalyticsResult } from "./adminAnalytics";
 export { runTriggerEventRaffle, type TriggerEventRaffleInput, type TriggerEventRaffleResult, } from "./triggerEventRaffle";
 export { runAssignSpinPrize, type AssignSpinPrizeInput, type AssignSpinPrizeResult, } from "./assignSpinPrize";
-export { handleBidPlaced, type HandleBidPlacedInput, type NewBid } from "./onBidPlaced";
 export { handleOrderCreate, type HandleOrderCreateInput, type NewOrder, } from "./onOrderCreate";
 export { handleOrderStatusChange, type HandleOrderStatusChangeInput, type OrderAfter, type OrderBefore, } from "./onOrderStatusChange";
 export { handleProductWrite, type HandleProductWriteInput, type ProductDoc, } from "./onProductWrite";

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

@@ -39,7 +39,6 @@ export { runAdminAnalytics } from "./adminAnalytics";
 export { runTriggerEventRaffle, } from "./triggerEventRaffle";
 export { runAssignSpinPrize, } from "./assignSpinPrize";
 // Trigger reactors — call with the meaningful payload, no Firestore event needed
-export { handleBidPlaced } from "./onBidPlaced";
 export { handleOrderCreate, } from "./onOrderCreate";
 export { handleOrderStatusChange, } from "./onOrderStatusChange";
 export { handleProductWrite, } from "./onProductWrite";

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

@@ -1,5 +1,5 @@
 import { normalizeError } from "../../../../errors/normalize";
-import { bidRepository, cartRepository, offerRepository } from "../../../../repositories";
+import { bidRepository, cartRepository, offerRepository, storeRepository } from "../../../../repositories";
 import { sendNotification } from "../../../../features/admin/actions/notification-actions";
 export async function runOfferExpiry(ctx) {
     ctx.logger.info("Starting offer expiry sweep");
@@ -141,6 +141,37 @@ async function lapseUnpaidAuctionWins(ctx) {
     if (auctionLines.length === 0)
         return;
     ctx.logger.info(`Found ${auctionLines.length} unpaid auction win(s) past deadline`);
+    /**
+     * Tell the seller their item is unsold again so they can relist it or approach
+     * the runner-up. Only the buyer was ever notified, so to a seller a forfeited
+     * win looked like a completed sale that simply never paid out.
+     *
+     * Best-effort by design: the forfeiture itself (cart line cleared, bid marked
+     * forfeited) is already committed by the time this runs, and a missing store or
+     * a notification failure must not roll that back or abort the sweep.
+     */
+    async function notifySellerOfForfeitedWin(item, jobCtx) {
+        try {
+            const store = item.storeId ? await storeRepository.findById(item.storeId) : null;
+            if (!store?.ownerId)
+                return;
+            await sendNotification({
+                userId: store.ownerId,
+                type: "auction_ended",
+                priority: "normal",
+                title: "Auction win forfeited — item unsold",
+                message: `The winning bidder for "${item.productTitle}" did not pay within the deadline, so the win was forfeited. You can relist the item or approach the next highest bidder.`,
+                relatedId: item.auctionId ?? item.productId,
+                relatedType: "product",
+            });
+        }
+        catch (sellerErr) {
+            void normalizeError(sellerErr);
+            jobCtx.logger.warn(`Failed to notify seller of forfeited win ${item.bidId}`, {
+                error: sellerErr instanceof Error ? sellerErr.message : String(sellerErr),
+            });
+        }
+    }
     for (const { userId, item } of auctionLines) {
         try {
             await cartRepository.removeItemsByBidId(userId, item.bidId);
@@ -154,6 +185,7 @@ async function lapseUnpaidAuctionWins(ctx) {
                 relatedId: item.auctionId ?? item.productId,
                 relatedType: "product",
             });
+            await notifySellerOfForfeitedWin(item, ctx);
         }
         catch (err) {
             void normalizeError(err);

package/dist/_internal/server/jobs/handlers/index.d.ts

@@ -4,7 +4,7 @@
  *
  * S4 batch 1: promotions, onOrderCreate, onOrderStatusChange,
  *             auctionSettlement, autoPayoutEligibility, couponExpiry, offerExpiry
- * S5 batch 2: onReviewWrite, onBidPlaced, cartPrune, notificationPrune,
+ * S5 batch 2: onReviewWrite, cartPrune, notificationPrune,
  *             dailyDataCleanup, countersReconcile, cleanupRtdbEvents
  */
 export { couponExpiryHandler } from "./couponExpiry";
@@ -18,7 +18,6 @@ export { autoPayoutEligibilityHandler } from "./autoPayoutEligibility";
 export { countersReconcileHandler } from "./countersReconcile";
 export { onOrderCreateHandler } from "./onOrderCreate";
 export { onOrderStatusChangeHandler } from "./onOrderStatusChange";
-export { onBidPlacedHandler } from "./onBidPlaced";
 export { onJobCreatedHandler } from "./onJobCreated";
 export { onReviewWriteHandler } from "./onReviewWrite";
 export { promotionsHandler, type PromotionsCallableResult } from "./promotions";

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

@@ -4,7 +4,7 @@
  *
  * S4 batch 1: promotions, onOrderCreate, onOrderStatusChange,
  *             auctionSettlement, autoPayoutEligibility, couponExpiry, offerExpiry
- * S5 batch 2: onReviewWrite, onBidPlaced, cartPrune, notificationPrune,
+ * S5 batch 2: onReviewWrite, cartPrune, notificationPrune,
  *             dailyDataCleanup, countersReconcile, cleanupRtdbEvents
  */
 export { couponExpiryHandler } from "./couponExpiry";
@@ -18,7 +18,6 @@ export { autoPayoutEligibilityHandler } from "./autoPayoutEligibility";
 export { countersReconcileHandler } from "./countersReconcile";
 export { onOrderCreateHandler } from "./onOrderCreate";
 export { onOrderStatusChangeHandler } from "./onOrderStatusChange";
-export { onBidPlacedHandler } from "./onBidPlaced";
 export { onJobCreatedHandler } from "./onJobCreated";
 export { onReviewWriteHandler } from "./onReviewWrite";
 export { promotionsHandler } from "./promotions";

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/auctions/config.d.ts

@@ -24,3 +24,37 @@ export declare function resolveTieredBidIncrement(currentBidAmount: number, tier
  * MORE than the platform tier, but can never undercut it.
  */
 export declare function resolveMinBidIncrement(currentBidAmount: number, tiers: BidIncrementTier[], override?: number | null): number;
+export interface ResolveMinBidOptions {
+    /**
+     * Whether the auction already has at least one bid. Defaults to `true`.
+     *
+     * When `false` the starting bid is itself acceptable — a seller's opening
+     * price is a price, not a floor that must be beaten. Requiring
+     * `startingBid + increment` for the very first bid (which is what this
+     * function did unconditionally before) meant a ₹100 auction could never be
+     * opened at ₹100, only at ₹110, contradicting both the "Starting bid ₹100"
+     * label shown next to the field and the eBay convention buyers expect.
+     */
+    hasBids?: boolean;
+}
+/**
+ * The single definition of "the lowest amount this auction will accept next".
+ *
+ * Both the bid form and `placeBid` must agree on this exactly, or the form
+ * seeds an amount the server then rejects. Deriving it in two places is the
+ * drift shape Root Cause #30 describes, so both call this instead.
+ *
+ * `currentBidAmount` is the auction's live visible price — for an auction with
+ * no bids yet, callers pass `startingBid` (mirroring `placeBid`'s `baseBid`)
+ * together with `{ hasBids: false }`.
+ */
+export declare function resolveMinBid(currentBidAmount: number, tiers: BidIncrementTier[], override?: number | null, opts?: ResolveMinBidOptions): number;
+/**
+ * Preset step multipliers offered by the bid form, as multiples of the
+ * effective minimum increment. With a ₹100 increment this renders
+ * +₹100 / +₹500 / +₹1,000; with a ₹1,000 increment, +₹1,000 / +₹5,000 /
+ * +₹10,000. Never hardcode the rupee amounts at the call site — the whole
+ * point is that the steps track the tier.
+ */
+export declare const BID_PRESET_MULTIPLIERS: readonly [1, 5, 10];
+export type BidPresetMultiplier = (typeof BID_PRESET_MULTIPLIERS)[number];

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

@@ -12,6 +12,23 @@ export const DEFAULT_AUCTION_BID_INCREMENT_TIERS = [
     { upTo: 10000, increment: 500 },
     { upTo: null, increment: 1000 },
 ];
+/**
+ * Drop malformed rows and fall back to the seed table when nothing usable is
+ * left.
+ *
+ * An empty/missing tier array does NOT mean "this auction has no increment
+ * rule" — it means the `siteSettings/global` singleton predates
+ * `auctionConfig.bidIncrementTiers`, or an admin cleared every row. Every
+ * caller reaches this via `settings.auctionConfig?.bidIncrementTiers ?? []`,
+ * so before this guard existed that case fell through to the ₹1
+ * `AUCTION_MIN_BID_INCREMENT` last-resort constant, which made the effective
+ * minimum step ₹1 on every auction on the site — that is what rendered the
+ * bid presets as "+₹1 / +₹5 / +₹10" instead of tier-derived steps.
+ */
+function usableTiers(tiers) {
+    const valid = (tiers ?? []).filter((t) => t && Number.isFinite(t.increment) && t.increment > 0);
+    return valid.length > 0 ? valid : DEFAULT_AUCTION_BID_INCREMENT_TIERS;
+}
 /**
  * Resolve the tiered minimum bid increment for a given current bid amount.
  * Tier lookup is inclusive of each band's upper bound — e.g. with the
@@ -19,11 +36,12 @@ export const DEFAULT_AUCTION_BID_INCREMENT_TIERS = [
  * increment (the 100-1000 tier), not the 200 increment of the next band.
  */
 export function resolveTieredBidIncrement(currentBidAmount, tiers) {
-    for (const tier of tiers) {
+    const table = usableTiers(tiers);
+    for (const tier of table) {
         if (tier.upTo === null || currentBidAmount <= tier.upTo)
             return tier.increment;
     }
-    return tiers[tiers.length - 1]?.increment ?? AUCTION_MIN_BID_INCREMENT;
+    return table[table.length - 1]?.increment ?? AUCTION_MIN_BID_INCREMENT;
 }
 /**
  * Effective minimum bid increment = max(admin tier floor, per-listing
@@ -32,5 +50,31 @@ export function resolveTieredBidIncrement(currentBidAmount, tiers) {
  */
 export function resolveMinBidIncrement(currentBidAmount, tiers, override) {
     const tierValue = resolveTieredBidIncrement(currentBidAmount, tiers);
-    return typeof override === "number" && override > tierValue ? override : tierValue;
+    return typeof override === "number" && Number.isFinite(override) && override > tierValue
+        ? override
+        : tierValue;
+}
+/**
+ * The single definition of "the lowest amount this auction will accept next".
+ *
+ * Both the bid form and `placeBid` must agree on this exactly, or the form
+ * seeds an amount the server then rejects. Deriving it in two places is the
+ * drift shape Root Cause #30 describes, so both call this instead.
+ *
+ * `currentBidAmount` is the auction's live visible price — for an auction with
+ * no bids yet, callers pass `startingBid` (mirroring `placeBid`'s `baseBid`)
+ * together with `{ hasBids: false }`.
+ */
+export function resolveMinBid(currentBidAmount, tiers, override, opts) {
+    if (opts?.hasBids === false)
+        return currentBidAmount;
+    return currentBidAmount + resolveMinBidIncrement(currentBidAmount, tiers, override);
 }
+/**
+ * Preset step multipliers offered by the bid form, as multiples of the
+ * effective minimum increment. With a ₹100 increment this renders
+ * +₹100 / +₹500 / +₹1,000; with a ₹1,000 increment, +₹1,000 / +₹5,000 /
+ * +₹10,000. Never hardcode the rupee amounts at the call site — the whole
+ * point is that the steps track the tier.
+ */
+export const BID_PRESET_MULTIPLIERS = [1, 5, 10];

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/fees/calculator.d.ts

@@ -18,17 +18,49 @@ export interface FeeCommissionRates {
     platformFeePercent: number;
     gstPercent: number;
     /** Rupee floor (not paise) — matches the existing `minimumTransactionFee` doc convention. */ minimumTransactionFee?: number;
+    /**
+     * Rupee ceiling on the buyer-facing platform commission. Optional so
+     * siteSettings documents saved before this field existed keep working —
+     * falls back to DEFAULT_PLATFORM_FEE_MAX (₹10).
+     *
+     * Applies to `computeCheckoutFees` (what the BUYER pays) only. The seller-side
+     * `computePayoutDeduction` is deliberately uncapped — that is a separate
+     * commercial decision, not the same number.
+     */ platformFeeMax?: number;
     gatewayFeePercent?: number;
 }
 export interface CheckoutFees {
-    /** Platform commission in decimal rupees. */
+    /** Platform commission in decimal rupees, capped at `platformFeeMax`. */
     platformFee: number;
-    /** GST on the platform fee, in decimal rupees. */
+    /** GST on the (already capped) platform fee, in decimal rupees. */
     gstOnFee: number;
     /** platformFee + gstOnFee, floored at minimumTransactionFee. */
     totalFee: number;
 }
+/**
+ * What the buyer pays on top of the subtotal.
+ *
+ * The cap is applied to the commission BEFORE GST is computed, because GST is
+ * levied on the commission actually charged — capping afterwards would bill tax
+ * on money that was never collected.
+ */
 export declare function computeCheckoutFees(subtotal: number, commissions: FeeCommissionRates): CheckoutFees;
+/**
+ * Split one checkout's platform commission across the orders it produces.
+ *
+ * The buyer is charged a single capped commission for the transaction, but the
+ * cart splits into one order per store, and each `OrderDocument` records its own
+ * `platformFee` (invoices, reconciliation). Apportioning pro-rata by group
+ * subtotal keeps those per-order figures meaningful; giving the last group the
+ * rounding remainder guarantees they sum to exactly what was charged, so the
+ * orders can never quietly total a rupee more or less than the buyer paid.
+ *
+ * @param groupSubtotals `[storeId, subtotal]` pairs, in stable order.
+ */
+export declare function allocateCheckoutFees(groupSubtotals: readonly (readonly [string, number])[], fees: CheckoutFees): Map<string, {
+    platformFee: number;
+    gstOnFee: number;
+}>;
 export interface PayoutDeduction {
     /** Platform commission in decimal rupees. */
     platformFee: number;

package/dist/_internal/shared/fees/calculator.js

@@ -15,12 +15,56 @@
  * All money amounts are in decimal rupees.
  */
 import { roundRupees } from "../../../utils/number.formatter";
+/** Buyer-facing platform commission ceiling, in decimal rupees. */
+const DEFAULT_PLATFORM_FEE_MAX = 10;
+/**
+ * What the buyer pays on top of the subtotal.
+ *
+ * The cap is applied to the commission BEFORE GST is computed, because GST is
+ * levied on the commission actually charged — capping afterwards would bill tax
+ * on money that was never collected.
+ */
 export function computeCheckoutFees(subtotal, commissions) {
-    const platformFee = roundRupees(subtotal * (commissions.platformFeePercent / 100));
+    const uncapped = roundRupees(subtotal * (commissions.platformFeePercent / 100));
+    const cap = commissions.platformFeeMax ?? DEFAULT_PLATFORM_FEE_MAX;
+    const platformFee = Math.min(uncapped, cap);
     const gstOnFee = roundRupees(platformFee * (commissions.gstPercent / 100));
     const totalFee = Math.max(platformFee + gstOnFee, commissions.minimumTransactionFee ?? 0);
     return { platformFee, gstOnFee, totalFee };
 }
+/**
+ * Split one checkout's platform commission across the orders it produces.
+ *
+ * The buyer is charged a single capped commission for the transaction, but the
+ * cart splits into one order per store, and each `OrderDocument` records its own
+ * `platformFee` (invoices, reconciliation). Apportioning pro-rata by group
+ * subtotal keeps those per-order figures meaningful; giving the last group the
+ * rounding remainder guarantees they sum to exactly what was charged, so the
+ * orders can never quietly total a rupee more or less than the buyer paid.
+ *
+ * @param groupSubtotals `[storeId, subtotal]` pairs, in stable order.
+ */
+export function allocateCheckoutFees(groupSubtotals, fees) {
+    const allocation = new Map();
+    if (groupSubtotals.length === 0)
+        return allocation;
+    const total = groupSubtotals.reduce((sum, [, subtotal]) => sum + subtotal, 0);
+    let platformRemaining = fees.platformFee;
+    let gstRemaining = fees.gstOnFee;
+    groupSubtotals.forEach(([storeId, subtotal], index) => {
+        const isLast = index === groupSubtotals.length - 1;
+        // An all-zero cart can't be apportioned by share — fall back to giving the
+        // whole (necessarily zero-ish) fee to the last group rather than dividing
+        // by zero.
+        const share = total > 0 ? subtotal / total : 0;
+        const platformFee = isLast ? roundRupees(platformRemaining) : roundRupees(fees.platformFee * share);
+        const gstOnFee = isLast ? roundRupees(gstRemaining) : roundRupees(fees.gstOnFee * share);
+        platformRemaining = roundRupees(platformRemaining - platformFee);
+        gstRemaining = roundRupees(gstRemaining - gstOnFee);
+        allocation.set(storeId, { platformFee, gstOnFee });
+    });
+    return allocation;
+}
 export function computePayoutDeduction(grossAmount, commissions) {
     const platformFee = roundRupees(grossAmount * (commissions.platformFeePercent / 100));
     const gatewayFee = roundRupees(grossAmount * ((commissions.gatewayFeePercent ?? 0) / 100));

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

@@ -9,7 +9,7 @@ export const config = {
     slugPrefix: "auction-",
     cartLine: "blocked",
     detailRoute: (idOrSlug) => String(ROUTES.PUBLIC.AUCTION_DETAIL(idOrSlug)),
-    badge: { label: "Auction", className: "bg-warning-surface text-white" },
+    badge: { label: "Auction", className: "bg-warning-solid text-warning-on-solid" },
     priceLabel: "Suggested Retail Price (₹)",
     typeLabel: "Auction",
     showsStockQuantity: false,

package/dist/_internal/shared/listing-types/digital-code/config.js

@@ -9,7 +9,7 @@ export const config = {
     slugPrefix: "digitalcode-",
     cartLine: "single-product",
     detailRoute: (idOrSlug) => String(ROUTES.PUBLIC.DIGITAL_CODE_DETAIL(idOrSlug)),
-    badge: { label: "Digital Code", className: "bg-success-surface text-success" },
+    badge: { label: "Digital Code", className: "bg-success-solid text-success-on-solid" },
     priceLabel: "Price per Code (₹)",
     typeLabel: "Digital Code",
     showsStockQuantity: false,

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

@@ -9,7 +9,7 @@ export const config = {
     slugPrefix: "live-",
     cartLine: "single-product",
     detailRoute: (idOrSlug) => String(ROUTES.PUBLIC.LIVE_DETAIL(idOrSlug)),
-    badge: { label: "Live Item", className: "bg-danger-surface text-error" },
+    badge: { label: "Live Item", className: "bg-error-solid text-error-on-solid" },
     priceLabel: "Price (₹)",
     typeLabel: "Live Item",
     showsStockQuantity: true,

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

@@ -9,7 +9,7 @@ export const config = {
     slugPrefix: "preorder-",
     cartLine: "single-product",
     detailRoute: (idOrSlug) => String(ROUTES.PUBLIC.PRE_ORDER_DETAIL(idOrSlug)),
-    badge: { label: "Pre-Order", className: "bg-info-surface text-white" },
+    badge: { label: "Pre-Order", className: "bg-info-solid text-info-on-solid" },
     priceLabel: "Pre-Order Price (₹)",
     typeLabel: "Pre-Order",
     showsStockQuantity: false,