@mohasinac/appkit 4.11.3 → 4.12.1

package/dist/_internal/server/features/auctions/service.d.ts

@@ -2,7 +2,13 @@ import { type BidIncrementTier } from "../../../shared/features/auctions/config"
 import type { ProductDocument } from "../../../shared/features/products/types";
 /** Assert an auction exists, is published, and is still active. Returns the product. */
 export declare function assertAuctionActive(auctionId: string): Promise<ProductDocument>;
-/** Compute the minimum valid bid given the current state and the admin's tier table. */
+/**
+ * Compute the minimum valid bid given the current state and the admin's tier table.
+ *
+ * Delegates to the shared `resolveMinBid` so this path can't drift from
+ * `placeBid`'s — including the no-bids case, where the starting bid is itself
+ * acceptable rather than needing to be beaten by an increment.
+ */
 export declare function computeMinBid(product: ProductDocument, tiers: BidIncrementTier[]): number;
 /** Assert a bid amount is valid against the current auction state. */
 export declare function assertBidAmount(product: ProductDocument, amount: number, tiers: BidIncrementTier[]): void;

package/dist/_internal/server/features/auctions/service.js

@@ -1,7 +1,7 @@
 import { productRepository } from "../../../../repositories";
 import { isAuctionListing } from "../../../../features/products/utils/listing-type";
 import { AuctionNotFoundError, AuctionEndedError, BidTooLowError, BidOnOwnAuctionError, } from "../../../shared/features/auctions/errors";
-import { AUCTION_SNIPING_WINDOW_SECONDS, AUCTION_DEFAULT_EXTENSION_MINUTES, resolveMinBidIncrement, } from "../../../shared/features/auctions/config";
+import { AUCTION_SNIPING_WINDOW_SECONDS, AUCTION_DEFAULT_EXTENSION_MINUTES, resolveMinBid, } from "../../../shared/features/auctions/config";
 /** Assert an auction exists, is published, and is still active. Returns the product. */
 export async function assertAuctionActive(auctionId) {
     const product = await productRepository.findByIdOrSlug(auctionId).catch(() => null);
@@ -16,11 +16,19 @@ export async function assertAuctionActive(auctionId) {
         throw new AuctionEndedError(auctionId);
     return product;
 }
-/** Compute the minimum valid bid given the current state and the admin's tier table. */
+/**
+ * Compute the minimum valid bid given the current state and the admin's tier table.
+ *
+ * Delegates to the shared `resolveMinBid` so this path can't drift from
+ * `placeBid`'s — including the no-bids case, where the starting bid is itself
+ * acceptable rather than needing to be beaten by an increment.
+ */
 export function computeMinBid(product, tiers) {
-    const current = product.currentBid ?? product.startingBid ?? 0;
-    const increment = resolveMinBidIncrement(current, tiers, product.minBidIncrement);
-    return current + increment;
+    const hasBids = (product.currentBid ?? 0) > 0 || (product.bidCount ?? 0) > 0;
+    const current = hasBids
+        ? (product.currentBid ?? product.startingBid ?? 0)
+        : (product.startingBid ?? 0);
+    return resolveMinBid(current, tiers, product.minBidIncrement, { hasBids });
 }
 /** Assert a bid amount is valid against the current auction state. */
 export function assertBidAmount(product, amount, tiers) {

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";
@@ -23,14 +24,6 @@ export interface CreateCheckoutOrderInput {
      * omits the field.
      */
     outOfStockPolicy?: OutOfStockPolicy;
-    /** Buyer opted into the ₹10 WhatsApp order-updates addon at checkout. Defaults false (unchecked). Only actually charged/honored when siteSettings.commissions.whatsappNotifyFeeEnabled is also true. */
-    whatsappNotifyAddon?: boolean;
-    /** Buyer opted into gift wrap at checkout. Defaults false (unchecked). Only actually charged/honored when siteSettings.commissions.giftWrapFeeEnabled is also true. */
-    giftWrapAddon?: boolean;
-    /** Optional gift message, only meaningful when giftWrapAddon is true. */
-    giftWrapMessage?: string;
-    /** Buyer opted into shipment protection at checkout. Defaults false (unchecked). Only actually charged/honored when siteSettings.commissions.shipmentProtectionFeeEnabled is also true. */
-    shipmentProtectionAddon?: boolean;
 }
 /**
  * Exported so `/api/payment/create-order` (pre-charge amount) and the
@@ -61,9 +54,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;
@@ -74,7 +87,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
@@ -113,12 +138,5 @@ export interface VerifyAndPlaceRazorpayOrderInput {
      * on the Razorpay path.
      */
     outOfStockPolicy?: OutOfStockPolicy;
-    /** Buyer opted into the ₹10 WhatsApp order-updates addon at checkout — must match the value sent to /api/payment/create-order so the pre-charged amount and the placed order agree. */
-    whatsappNotifyAddon?: boolean;
-    /** Buyer opted into gift wrap at checkout — must match the value sent to /api/payment/create-order. */
-    giftWrapAddon?: boolean;
-    giftWrapMessage?: string;
-    /** Buyer opted into shipment protection at checkout — must match the value sent to /api/payment/create-order. */
-    shipmentProtectionAddon?: boolean;
 }
 export declare function verifyAndPlaceRazorpayOrderAction(input: VerifyAndPlaceRazorpayOrderInput): Promise<CheckoutOrderResult>;

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

@@ -20,7 +20,7 @@ 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";
@@ -367,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 }) => {
@@ -456,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)
@@ -510,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,
@@ -591,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;
@@ -798,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,
@@ -821,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);
@@ -850,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
@@ -862,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
@@ -894,45 +913,75 @@ export async function previewCheckoutPricing(input) {
     // Same re-validation the real order placement runs, so the preview never
     // shows a discount the order won't actually honour.
     const { coupons: appliedCoupons } = await revalidateAppliedCoupons(cart.appliedCoupons ?? [], checks, uid);
-    let shippingFee = 0;
-    let codHandlingFee = 0;
-    let whatsappNotifyFeeTotal = 0;
-    let giftWrapFeeTotal = 0;
-    let shipmentProtectionFeeTotal = 0;
-    let gstAmount = 0;
-    let couponDiscount = 0;
+    // 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,
@@ -943,7 +992,10 @@ export async function previewCheckoutPricing(input) {
         shipmentProtectionFee: shipmentProtectionFeeTotal,
         gstAmount,
         couponDiscount,
+        platformFee,
+        gstOnFee,
         total,
+        stores,
     };
 }
 /**
@@ -1064,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, couponUsageAccumulator, } = 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
@@ -1083,11 +1135,25 @@ async function createRazorpayGroupOrder(group, orderType, ctx) {
             groupCouponCodes.add(discount.code);
         }
     }
-    const rawPlatformFee = roundRupees(groupTotal * (platformFeePercent / 100));
-    const gstOnFee = roundRupees(rawPlatformFee * (gstPercent / 100));
-    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;
+    // 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.
+    // Kept as two separate values, exactly as the COD/manual path does. Folding the
+    // GST into `platformFee` made `OrderDocument.platformFee` mean "fee" on one path
+    // and "fee + GST" on the other, so no revenue rollup could read it without
+    // knowing which path created the row. The buyer pays the same either way —
+    // both components are still added to orderTotal below.
+    const { platformFee = 0, gstOnFee: platformFeeGst = 0 } = platformFeeByStore.get(firstItem.storeId) ?? {};
+    // 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 + platformFeeGst;
     // 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
@@ -1232,12 +1298,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,
@@ -1360,8 +1425,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
@@ -1369,7 +1438,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) {
@@ -1397,16 +1478,17 @@ export async function verifyAndPlaceRazorpayOrderAction(input) {
     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,

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

@@ -11,7 +11,7 @@ import { sendNotification } from "../../../../features/admin/actions/notificatio
 import { restoreStockForOrder } from "../checkout/stock-restore";
 import { getAdminDb } from "../../../../providers/db-firebase";
 import { enqueueJob } from "../../../../features/jobs/actions/enqueue-job";
-import { PAYMENT_WINDOW_MS, PAYMENT_FRAUD_REJECTED_REASON } from "../../../../features/orders/constants/payment-window";
+import { PAYMENT_WINDOW_MS, PAYMENT_FRAUD_REJECTED_REASON, isManualPaymentMethod } from "../../../../features/orders/constants/payment-window";
 import { normalizeError } from "../../../../errors/normalize";
 import { serverLogger } from "../../../../monitoring";
 export async function createOrderAction(input) {
@@ -131,8 +131,10 @@ export async function attachPaymentProofAction(orderId, proof) {
             throw new OrderNotFoundError(orderId);
         if (!isAdminUser(user) && order.userId !== user.uid)
             throw new OrderOwnershipError(orderId);
-        const pm = order.paymentMethod ?? "";
-        if (pm !== "cash" && pm !== "upi_manual" && pm !== "emi") {
+        // Use the shared predicate rather than re-inlining the method list — this
+        // was the second of the two sites that had drifted from it (the other being
+        // AdminOrderEditorView, which was missing `emi` outright).
+        if (!isManualPaymentMethod(order.paymentMethod ?? "")) {
             throw new ValidationError("Payment proof can only be attached to cash, UPI, or EMI orders");
         }
         if (order.paymentProofUrl) {

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

@@ -62,7 +62,20 @@ export function orderDocumentToOrder(doc) {
         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/list-public.d.ts

@@ -49,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. */
@@ -127,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 {};