@mohasinac/appkit 4.11.2 → 4.12.0

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

@@ -1,3 +1,4 @@
+import { type CartLane } from "../../../shared/checkout/lanes";
 import type { OutOfStockPolicy } from "../../../../features/orders/schemas/index";
 import { type CheckoutPaymentMethod } from "../../../shared/features/checkout/config";
 import { type CheckoutOrderResult } from "./data";
@@ -44,6 +45,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.
  *
@@ -57,9 +62,29 @@ export interface CheckoutPricingPreviewInput {
     addressId?: string;
     paymentMethod: CheckoutPaymentMethod;
     excludedProductIds?: string[];
-    whatsappNotifyAddon?: boolean;
-    giftWrapAddon?: boolean;
-    shipmentProtectionAddon?: boolean;
+    /**
+     * Which cart lane to price. Only one lane is payable in a single checkout, so
+     * a preview spanning lanes would be a number the buyer can never be charged.
+     *
+     * Passed in rather than derived from `activeLane` server-side because the cart
+     * page previews whichever tab the buyer is looking at — including a lane that
+     * is currently gated off.
+     */
+    lane?: CartLane;
+}
+/** One store's slice of the preview — what that seller's order will cost. */
+export interface CheckoutPricingPreviewStore {
+    storeId: string;
+    storeName: string;
+    subtotal: number;
+    shippingFee: number;
+    codHandlingFee: number;
+    whatsappNotifyFee: number;
+    giftWrapFee: number;
+    shipmentProtectionFee: number;
+    gstAmount: number;
+    couponDiscount: number;
+    total: number;
 }
 export interface CheckoutPricingPreview {
     subtotal: number;
@@ -70,7 +95,19 @@ export interface CheckoutPricingPreview {
     shipmentProtectionFee: number;
     gstAmount: number;
     couponDiscount: number;
+    /** Buyer-facing platform commission, capped, charged once for this checkout. */
+    platformFee: number;
+    /** GST on the (capped) platform commission. */
+    gstOnFee: number;
     total: number;
+    /**
+     * Per-store breakdown, in group order. Every figure here was already being
+     * computed inside the per-group loop and then discarded into an aggregate —
+     * surfacing it is what lets each seller card show its own fees.
+     *
+     * A store with no selected items forms no group and therefore never appears.
+     */
+    stores: CheckoutPricingPreviewStore[];
 }
 /**
  * Read-only "what will I actually be charged" preview for the checkout

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

@@ -17,9 +17,10 @@ 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";
+import { computeCodHandlingFee, computeWhatsAppNotifyFee, computeGiftWrapFee, computeShipmentProtectionFee, computeCheckoutFees, allocateCheckoutFees, } from "../../../shared/fees/calculator";
 import { getAdminDb, getAdminRealtimeDb, RTDB_PATHS, } from "../../../../providers/db-firebase";
 import { PRODUCT_COLLECTION, PRODUCT_CODES_SUBCOLLECTION } from "../../../../features/products/schemas/firestore";
 import { CART_COLLECTION } from "../../../../features/cart/schemas/index";
@@ -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;
@@ -282,9 +367,12 @@ function dispatchOrderConfirmationEmails(emailsToSend) {
  * so the caller can accumulate the checkout-wide `total`.
  */
 async function createOrderForGroup(group, orderType, ctx) {
-    const { paymentMethod, emiTenureMonths, emiSettings, commissions, appliedCoupons, cartSubtotal, couponUsageAccumulator, uid, userName, userEmail, shippingAddress, notes, adminBypass, adminBypassBy, adminBatchId, orderIds, emailsToSend, outOfStockPolicy, droppedItems, buyerState, gstSettings, siteContactUpiVpa, whatsappNotifyAddon, giftWrapAddon, giftWrapMessage, shipmentProtectionAddon, } = ctx;
+    const { paymentMethod, emiTenureMonths, emiSettings, commissions, appliedCoupons, cartSubtotal, couponUsageAccumulator, uid, userName, userEmail, shippingAddress, notes, adminBypass, adminBypassBy, adminBatchId, orderIds, emailsToSend, outOfStockPolicy, droppedItems, buyerState, gstSettings, siteContactUpiVpa, storeAddons, platformFeeByStore, } = ctx;
     const firstItem = group[0].item;
     const firstProduct = group[0].product;
+    // Add-ons are this store's choice, not the cart's — see OrderGroupContext.
+    const { whatsappNotifyAddon = false, giftWrapAddon = false, giftWrapMessage, shipmentProtectionAddon = false, } = storeAddons?.[firstItem.storeId] ?? {};
+    const { platformFee = 0, gstOnFee: platformFeeGst = 0 } = platformFeeByStore.get(firstItem.storeId) ?? {};
     const groupTotal = group.reduce((sum, { item, product }) => sum + unitPriceFor(item, product) * item.quantity, 0);
     // S-SBUNI-RULES 2026-05-13 — order-item decoration via rule registry.
     const orderItems = group.map(({ item, product }) => {
@@ -371,7 +459,10 @@ async function createOrderForGroup(group, orderType, ctx) {
             groupCouponCodes.add(discount.code);
         }
     }
-    const orderTotal = Math.max(0, groupTotal - couponDiscount) + shippingFee + codHandlingFee + whatsappNotifyFee + giftWrapFee + shipmentProtectionFee + (emiSchedule?.surchargeAmount ?? 0) + (gstBreakdown?.gstAmount ?? 0);
+    // The platform commission is now charged on EVERY payment method. It used to
+    // be added only on the Razorpay path, so COD / UPI-manual / cash / EMI buyers
+    // silently never paid it.
+    const orderTotal = Math.max(0, groupTotal - couponDiscount) + shippingFee + codHandlingFee + whatsappNotifyFee + giftWrapFee + shipmentProtectionFee + platformFee + platformFeeGst + (emiSchedule?.surchargeAmount ?? 0) + (gstBreakdown?.gstAmount ?? 0);
     const imageUrls = [
         ...new Set(group
             .map(({ product }) => product.mainImage)
@@ -425,6 +516,9 @@ async function createOrderForGroup(group, orderType, ctx) {
         depositAmount: adminBypass ? undefined : depositAmount,
         codRemainingAmount: adminBypass ? undefined : codRemainingAmount,
         codHandlingFee: !adminBypass && codHandlingFee > 0 ? codHandlingFee : undefined,
+        // This group's pro-rata share of the checkout's single capped commission —
+        // the shares across a multi-store checkout sum to exactly what was charged.
+        platformFee: !adminBypass && platformFee > 0 ? platformFee : undefined,
         whatsappNotifyAddon: !adminBypass && whatsappNotifyFee > 0 ? true : undefined,
         whatsappNotifyFee: !adminBypass && whatsappNotifyFee > 0 ? whatsappNotifyFee : undefined,
         giftWrapAddon: !adminBypass && giftWrapFee > 0 ? true : undefined,
@@ -506,7 +600,7 @@ async function createOrderForGroup(group, orderType, ctx) {
  * auth + rate-limiting before calling this and supply the resolved user fields.
  */
 export async function createCheckoutOrderAction(input) {
-    const { userId: uid, userName, userEmail, addressId, paymentMethod, emiTenureMonths, notes, excludedProductIds = [], adminBypass = false, adminBypassBy, outOfStockPolicy = OutOfStockPolicyValues.SKIP_ITEMS, whatsappNotifyAddon = false, giftWrapAddon = false, giftWrapMessage, shipmentProtectionAddon = false, } = input;
+    const { userId: uid, userName, userEmail, addressId, paymentMethod, emiTenureMonths, notes, excludedProductIds = [], adminBypass = false, adminBypassBy, outOfStockPolicy = OutOfStockPolicyValues.SKIP_ITEMS, } = input;
     const siteSettings = await siteSettingsRepository.getSingleton();
     const commissions = siteSettings?.commissions ?? CHECKOUT_DEFAULT_COMMISSIONS;
     const emiSettings = siteSettings?.emi ?? CHECKOUT_DEFAULT_EMI_SETTINGS;
@@ -701,7 +795,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.
@@ -713,6 +807,12 @@ export async function createCheckoutOrderAction(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();
+    // One commission on one transaction, capped, then apportioned across the
+    // orders this cart splits into — see allocateCheckoutFees.
+    const platformFeeByStore = allocateCheckoutFees(orderGroups.map(({ items: g }) => [
+        g[0].item.storeId,
+        g.reduce((sum, { item, product }) => sum + unitPriceFor(item, product) * item.quantity, 0),
+    ]), computeCheckoutFees(cartSubtotal, commissions));
     const groupCtx = {
         paymentMethod,
         emiTenureMonths,
@@ -736,10 +836,8 @@ export async function createCheckoutOrderAction(input) {
         buyerState: resolvedAddress?.state,
         gstSettings: siteSettings?.gst,
         siteContactUpiVpa: siteSettings?.contact?.upiVpa,
-        whatsappNotifyAddon,
-        giftWrapAddon,
-        giftWrapMessage,
-        shipmentProtectionAddon,
+        storeAddons: cart.storeAddons,
+        platformFeeByStore,
     };
     for (const { items: group, orderType } of orderGroups) {
         total += await createOrderForGroup(group, orderType, groupCtx);
@@ -753,6 +851,7 @@ export async function createCheckoutOrderAction(input) {
         total,
         itemCount: orderIds.length,
         ...(unavailable.length > 0 ? { unavailableItems: unavailable } : {}),
+        ...(droppedCoupons.length > 0 ? { droppedCoupons } : {}),
     };
 }
 const EMPTY_PRICING_PREVIEW = {
@@ -764,7 +863,10 @@ const EMPTY_PRICING_PREVIEW = {
     shipmentProtectionFee: 0,
     gstAmount: 0,
     couponDiscount: 0,
+    platformFee: 0,
+    gstOnFee: 0,
     total: 0,
+    stores: [],
 };
 /**
  * Read-only "what will I actually be charged" preview for the checkout
@@ -776,13 +878,16 @@ const EMPTY_PRICING_PREVIEW = {
  * stock, creates an order, or writes coupon usage.
  */
 export async function previewCheckoutPricing(input) {
-    const { userId: uid, addressId, paymentMethod, excludedProductIds = [], whatsappNotifyAddon = false, giftWrapAddon = false, shipmentProtectionAddon = false, } = input;
+    const { userId: uid, addressId, paymentMethod, excludedProductIds = [], lane, } = input;
     const siteSettings = await siteSettingsRepository.getSingleton();
     const commissions = siteSettings?.commissions ?? CHECKOUT_DEFAULT_COMMISSIONS;
     const cart = await unitOfWork.carts.getOrCreate(uid);
     const excludedSet = new Set(excludedProductIds);
     const selectedSet = cart.selectedItemIds?.length ? new Set(cart.selectedItemIds) : null;
-    const previewLane = activeLane(cart.items ?? []);
+    // An explicit lane wins: the cart page prices whichever tab is open, which may
+    // not be the one that is currently payable. Falling back to activeLane keeps
+    // the checkout page's existing behaviour unchanged.
+    const previewLane = lane ?? activeLane(cart.items ?? []);
     const cartItems = (cart.items ?? []).filter((item) => !excludedSet.has(item.productId) &&
         (!selectedSet || selectedSet.has(item.itemId)) &&
         // A preview never throws — it just shows the lane the buyer can actually
@@ -805,46 +910,78 @@ 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 ?? [];
-    let shippingFee = 0;
-    let codHandlingFee = 0;
-    let whatsappNotifyFeeTotal = 0;
-    let giftWrapFeeTotal = 0;
-    let shipmentProtectionFeeTotal = 0;
-    let gstAmount = 0;
-    let couponDiscount = 0;
+    // 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);
+    // Each group's figures are kept, not just summed away — the aggregates below
+    // are derived FROM this array, so a store card and the summary panel can never
+    // disagree about the same fee.
+    const stores = [];
     for (const { items: group } of orderGroups) {
         const firstItem = group[0].item;
         const groupTotal = group.reduce((sum, { item, product }) => sum + unitPriceFor(item, product) * item.quantity, 0);
         const { shippingFee: groupShippingFee, storeState } = await resolveShippingCost(firstItem.storeId);
-        shippingFee += groupShippingFee;
+        // Add-ons are per store, read off the cart document — the same entry
+        // createOrderForGroup will read when the order is actually placed.
+        const addons = cart.storeAddons?.[firstItem.storeId] ?? {};
         // Mirrors createOrderForGroup exactly — the COD handling fee is only
         // ever charged for literal "cod" (pay the courier), never upi_manual or
         // cash (both pre-paid via UPI/bank transfer before dispatch).
-        if (paymentMethod === "cod")
-            codHandlingFee += computeCodHandlingFee(groupTotal, commissions);
-        whatsappNotifyFeeTotal += computeWhatsAppNotifyFee(whatsappNotifyAddon, commissions);
-        giftWrapFeeTotal += computeGiftWrapFee(giftWrapAddon, commissions);
-        shipmentProtectionFeeTotal += computeShipmentProtectionFee(groupTotal, shipmentProtectionAddon, commissions);
+        const groupCodHandlingFee = paymentMethod === "cod" ? computeCodHandlingFee(groupTotal, commissions) : 0;
+        const groupWhatsappFee = computeWhatsAppNotifyFee(addons.whatsappNotifyAddon ?? false, commissions);
+        const groupGiftWrapFee = computeGiftWrapFee(addons.giftWrapAddon ?? false, commissions);
+        const groupShipmentProtectionFee = computeShipmentProtectionFee(groupTotal, addons.shipmentProtectionAddon ?? false, commissions);
+        let groupGstAmount = 0;
         if (siteSettings?.gst?.enabled && resolvedAddress?.state) {
             const intraState = !!storeState && storeState === resolvedAddress.state;
             for (const { item, product } of group) {
                 const lineTotal = unitPriceFor(item, product) * item.quantity;
                 const rate = product?.gstRate ?? 0;
                 if (rate > 0)
-                    gstAmount += calculateGst(rate, intraState, lineTotal).gstAmount;
+                    groupGstAmount += calculateGst(rate, intraState, lineTotal).gstAmount;
             }
         }
         const groupLines = group.map(({ item, product }) => ({ itemId: item.itemId, lineTotal: unitPriceFor(item, product) * item.quantity }));
         const { couponDiscount: groupCouponDiscount } = computeGroupCouponDiscount(appliedCoupons, groupLines, groupTotal, cartSubtotal, firstItem.storeId);
-        couponDiscount += groupCouponDiscount;
+        stores.push({
+            storeId: firstItem.storeId,
+            storeName: firstItem.storeName || firstItem.storeId,
+            subtotal: groupTotal,
+            shippingFee: groupShippingFee,
+            codHandlingFee: groupCodHandlingFee,
+            whatsappNotifyFee: groupWhatsappFee,
+            giftWrapFee: groupGiftWrapFee,
+            shipmentProtectionFee: groupShipmentProtectionFee,
+            gstAmount: groupGstAmount,
+            couponDiscount: groupCouponDiscount,
+            total: Math.max(0, groupTotal - groupCouponDiscount) +
+                groupShippingFee +
+                groupCodHandlingFee +
+                groupWhatsappFee +
+                groupGiftWrapFee +
+                groupShipmentProtectionFee +
+                groupGstAmount,
+        });
     }
+    const sum = (pick) => stores.reduce((acc, s) => acc + pick(s), 0);
+    const shippingFee = sum((s) => s.shippingFee);
+    const codHandlingFee = sum((s) => s.codHandlingFee);
+    const whatsappNotifyFeeTotal = sum((s) => s.whatsappNotifyFee);
+    const giftWrapFeeTotal = sum((s) => s.giftWrapFee);
+    const shipmentProtectionFeeTotal = sum((s) => s.shipmentProtectionFee);
+    const gstAmount = sum((s) => s.gstAmount);
+    const couponDiscount = sum((s) => s.couponDiscount);
+    // One capped commission for the whole checkout, on every payment method —
+    // deliberately not per store, so it is not added to the per-store rows above.
+    const { platformFee, gstOnFee } = computeCheckoutFees(cartSubtotal, commissions);
     const total = Math.max(0, cartSubtotal - couponDiscount) +
         shippingFee +
         codHandlingFee +
         whatsappNotifyFeeTotal +
         giftWrapFeeTotal +
         shipmentProtectionFeeTotal +
+        platformFee +
+        gstOnFee +
         gstAmount;
     return {
         subtotal: cartSubtotal,
@@ -855,7 +992,10 @@ export async function previewCheckoutPricing(input) {
         shipmentProtectionFee: shipmentProtectionFeeTotal,
         gstAmount,
         couponDiscount,
+        platformFee,
+        gstOnFee,
         total,
+        stores,
     };
 }
 /**
@@ -976,7 +1116,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, storeAddons, platformFeeByStore, 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,11 +1125,31 @@ 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);
-    const rawPlatformFee = roundRupees(groupTotal * (platformFeePercent / 100));
-    const gstOnFee = roundRupees(rawPlatformFee * (gstPercent / 100));
+    // 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);
+        }
+    }
+    // Was a per-group, uncapped `groupTotal × platformFeePercent` computed inline
+    // here — the only path that charged the commission at all, and it charged a
+    // different (larger, multiplied-per-store) number than the cap now allows.
+    // Both the amount and its allocation are now decided once for the checkout.
+    const { platformFee: rawPlatformFee = 0, gstOnFee = 0 } = platformFeeByStore.get(firstItem.storeId) ?? {};
     const platformFee = rawPlatformFee + gstOnFee;
-    const shipmentProtectionFee = computeShipmentProtectionFee(groupTotal, shipmentProtectionAddon, siteSettings?.commissions ?? CHECKOUT_DEFAULT_COMMISSIONS);
-    const orderTotal = Math.max(0, groupTotal - couponDiscount) + shippingFee + whatsappNotifyFee + giftWrapFee + shipmentProtectionFee;
+    // Add-ons are this store's choice, read off the cart doc — previously one
+    // cart-wide fee was passed in and billed against every group.
+    const commissionRates = siteSettings?.commissions ?? CHECKOUT_DEFAULT_COMMISSIONS;
+    const addons = storeAddons?.[firstItem.storeId] ?? {};
+    const whatsappNotifyFee = computeWhatsAppNotifyFee(addons.whatsappNotifyAddon ?? false, commissionRates);
+    const giftWrapFee = computeGiftWrapFee(addons.giftWrapAddon ?? false, commissionRates);
+    const giftWrapMessage = addons.giftWrapMessage;
+    const shipmentProtectionFee = computeShipmentProtectionFee(groupTotal, addons.shipmentProtectionAddon ?? false, commissionRates);
+    const orderTotal = Math.max(0, groupTotal - couponDiscount) + shippingFee + whatsappNotifyFee + giftWrapFee + shipmentProtectionFee + platformFee;
     // P-8 GST — deliberately NOT wired into this Razorpay-verify path. The
     // amount-mismatch check above (expectedPaymentAmountRs) compares against
     // what the buyer already paid via the Razorpay order created earlier in
@@ -1103,6 +1263,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,
@@ -1129,12 +1294,11 @@ async function createRazorpayGroupOrder(group, orderType, ctx) {
     return orderTotal;
 }
 export async function verifyAndPlaceRazorpayOrderAction(input) {
-    const { userId: uid, userName, userEmail, razorpay_order_id, razorpay_payment_id, razorpay_signature, addressId, notes, outOfStockPolicy = OutOfStockPolicyValues.CANCEL_ORDER, whatsappNotifyAddon = false, giftWrapAddon = false, giftWrapMessage, shipmentProtectionAddon = false, } = input;
+    const { userId: uid, userName, userEmail, razorpay_order_id, razorpay_payment_id, razorpay_signature, addressId, notes, outOfStockPolicy = OutOfStockPolicyValues.CANCEL_ORDER, } = input;
+    // Add-on fees are no longer resolved here. They are per store, and this
+    // function has no single store — each group reads its own selection off
+    // `cart.storeAddons` inside createRazorpayGroupOrder.
     const siteSettings = await siteSettingsRepository.getSingleton();
-    const platformFeePercent = siteSettings?.commissions?.platformFeePercent ?? 5;
-    const gstPercent = siteSettings?.commissions?.gstPercent ?? 18;
-    const whatsappNotifyFee = computeWhatsAppNotifyFee(whatsappNotifyAddon, siteSettings?.commissions ?? CHECKOUT_DEFAULT_COMMISSIONS);
-    const giftWrapFee = computeGiftWrapFee(giftWrapAddon, siteSettings?.commissions ?? CHECKOUT_DEFAULT_COMMISSIONS);
     const isValid = await verifyPaymentSignatureWithKeys({
         razorpay_order_id,
         razorpay_payment_id,
@@ -1257,8 +1421,12 @@ export async function verifyAndPlaceRazorpayOrderAction(input) {
             const unit = isBundle ? item.price : product.price;
             return sum + unit * item.quantity;
         }, 0);
-        const expectedPlatformFee = roundRupees(cartSubtotalRs * (platformFeePercent / 100));
-        const expectedGstOnFee = roundRupees(expectedPlatformFee * (gstPercent / 100));
+        // Must use the SAME helper /api/payment/create-order used to compute what
+        // it charged. This block used to re-derive the fee inline from the raw
+        // percentages, so the moment the cap landed it would have expected more
+        // than was actually collected and rejected every legitimate payment.
+        const commissionRates = siteSettings?.commissions ?? CHECKOUT_DEFAULT_COMMISSIONS;
+        const { platformFee: expectedPlatformFee, gstOnFee: expectedGstOnFee } = computeCheckoutFees(cartSubtotalRs, commissionRates);
         // Same per-seller-group shipping sum /api/payment/create-order charged
         // upfront (and the same resolveShippingCost createRazorpayGroupOrder
         // below will use to build each order's recorded totalPrice) — keeps this
@@ -1266,7 +1434,19 @@ export async function verifyAndPlaceRazorpayOrderAction(input) {
         const expectedShippingGroups = splitCartIntoOrderGroups(bucketedPaid.available);
         const expectedShippingFees = await Promise.all(expectedShippingGroups.map((g) => resolveShippingCost(g.items[0].item.storeId)));
         const expectedShippingFee = expectedShippingFees.reduce((sum, r) => sum + r.shippingFee, 0);
-        const expectedPaymentAmountRs = cartSubtotalRs + expectedPlatformFee + expectedGstOnFee + expectedShippingFee;
+        // Add-ons are per store, so the expected total sums each group's own
+        // selection — a single cart-wide figure would over- or under-count as soon
+        // as the buyer picked add-ons for only some sellers.
+        const expectedAddonFees = expectedShippingGroups.reduce((sum, g) => {
+            const storeId = g.items[0].item.storeId;
+            const addons = cart.storeAddons?.[storeId] ?? {};
+            const groupSubtotal = g.items.reduce((gs, { item, product }) => gs + unitPriceFor(item, product) * item.quantity, 0);
+            return (sum +
+                computeWhatsAppNotifyFee(addons.whatsappNotifyAddon ?? false, commissionRates) +
+                computeGiftWrapFee(addons.giftWrapAddon ?? false, commissionRates) +
+                computeShipmentProtectionFee(groupSubtotal, addons.shipmentProtectionAddon ?? false, commissionRates));
+        }, 0);
+        const expectedPaymentAmountRs = cartSubtotalRs + expectedPlatformFee + expectedGstOnFee + expectedAddonFees + expectedShippingFee;
         const rzpOrderRecord = await fetchRazorpayOrder(razorpay_order_id);
         const paidAmountRs = paiseToRupees(rzpOrderRecord.amount);
         if (paidAmountRs < expectedPaymentAmountRs - 1) {
@@ -1282,7 +1462,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,16 +1473,18 @@ 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();
+    // Same single capped commission + pro-rata split as the COD/UPI path.
+    const platformFeeByStore = allocateCheckoutFees(orderGroups.map(({ items: g }) => [
+        g[0].item.storeId,
+        g.reduce((sum, { item, product }) => sum + unitPriceFor(item, product) * item.quantity, 0),
+    ]), computeCheckoutFees(cartSubtotal, siteSettings?.commissions ?? CHECKOUT_DEFAULT_COMMISSIONS));
     for (const { items: group, orderType } of orderGroups) {
         total += await createRazorpayGroupOrder(group, orderType, {
             appliedCoupons,
             cartSubtotal,
-            platformFeePercent,
-            gstPercent,
-            whatsappNotifyFee,
-            giftWrapFee,
-            giftWrapMessage,
-            shipmentProtectionAddon,
+            storeAddons: cart.storeAddons,
+            platformFeeByStore,
             siteSettings,
             uid,
             userName,
@@ -1316,8 +1498,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 +1550,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,32 @@ 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,
+        couponDiscount: doc.couponDiscount,
+        appliedDiscounts: doc.appliedDiscounts,
+        // Add-ons are operational, not decorative: the status-change notifier reads
+        // whatsappNotifyAddon, and the packer needs giftWrapMessage in hand. An
+        // adapter that drops them makes every downstream surface render its
+        // "not applicable" fallback instead (Root Cause #57).
+        whatsappNotifyAddon: doc.whatsappNotifyAddon,
+        whatsappNotifyFee: doc.whatsappNotifyFee,
+        giftWrapAddon: doc.giftWrapAddon,
+        giftWrapFee: doc.giftWrapFee,
+        giftWrapMessage: doc.giftWrapMessage,
+        shipmentProtectionAddon: doc.shipmentProtectionAddon,
+        shipmentProtectionFee: doc.shipmentProtectionFee,
+        platformFee: doc.platformFee,
         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;