@mohasinac/appkit 4.11.3 → 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";
@@ -61,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;
@@ -74,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

@@ -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,21 @@ async function createRazorpayGroupOrder(group, orderType, ctx) {
             groupCouponCodes.add(discount.code);
         }
     }
-    const rawPlatformFee = roundRupees(groupTotal * (platformFeePercent / 100));
-    const gstOnFee = roundRupees(rawPlatformFee * (gstPercent / 100));
+    // 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
@@ -1232,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,
@@ -1360,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
@@ -1369,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) {
@@ -1397,16 +1474,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/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 {};

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/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/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;