@mohasinac/appkit 4.9.4 → 4.9.5

package/dist/_internal/client/features/layout/DashboardLayoutClient.js

@@ -33,6 +33,7 @@ import { DASHBOARD_DESKTOP_MEDIA_QUERY } from "../../../shared/features/layout/c
 import { filterNavItems } from "./filterNavItems";
 import { useSiteSettings } from "../../../../core/hooks/useSiteSettings";
 import { useTheme } from "../../theme";
+import { useHandMode } from "../../hand-mode";
 import { BackgroundRenderer, Div, Nav, Span } from "../../../../ui";
 import { useToast } from "../../../../ui/components/Toast";
 import { useVisualViewportInset } from "../../../../react/hooks/useVisualViewportInset";
@@ -149,7 +150,10 @@ function DashboardBottomNav({ items, activeHref }) {
             return (_jsxs(Link, { href: item.href, className: `flex flex-1 flex-col items-center justify-center gap-[var(--appkit-space-0-5)] py-[var(--appkit-space-2)] ${isActive ? "text-[var(--appkit-color-primary)]" : "text-[var(--appkit-color-text-muted)]"}`, "aria-current": isActive ? "page" : undefined, children: [item.icon && _jsx(Span, { size: "base", children: item.icon }), _jsx(Span, { size: "xs", className: "max-w-full truncate", children: item.label })] }, item.href));
         }) }));
 }
-const DEFAULT_CONTENT_PADDING = "px-[var(--appkit-space-5)] py-[var(--appkit-space-8)] lg:pl-14 lg:pr-6 xl:pl-16 xl:pr-10";
+// Asymmetric padding clears the persistent sidebar rail — right-heavy by
+// default (rail docks left), left-heavy in left-hand mode (rail docks right).
+const DEFAULT_CONTENT_PADDING_RIGHT = "px-[var(--appkit-space-5)] py-[var(--appkit-space-8)] lg:pl-14 lg:pr-6 xl:pl-16 xl:pr-10";
+const DEFAULT_CONTENT_PADDING_LEFT = "px-[var(--appkit-space-5)] py-[var(--appkit-space-8)] lg:pr-14 lg:pl-6 xl:pr-16 xl:pl-10";
 const DEFAULT_CONTENT_MAX_WIDTH = "max-w-screen-2xl";
 export function DashboardLayoutClient({ variant, groups, permissions, activeHref: explicitActiveHref, responsive: _responsive, crossNav, className, contentPadding, contentSurface, contentMaxWidth, lightBackground, darkBackground, children, }) {
     const pathname = usePathname();
@@ -178,6 +182,7 @@ export function DashboardLayoutClient({ variant, groups, permissions, activeHref
     const { data: settings } = useSiteSettings();
     const navConfig = settings?.navConfig;
     const { theme } = useTheme();
+    const { hand } = useHandMode();
     // Explicit props win; otherwise fall back to the same siteSettings.background
     // the public shell reads, so admin/store/user dashboards match it by default.
     const resolvedLightBackground = lightBackground ?? settings?.background?.light;
@@ -193,7 +198,7 @@ export function DashboardLayoutClient({ variant, groups, permissions, activeHref
     return (_jsxs(_Fragment, { children: [hasBackground && (_jsx(BackgroundRenderer, { mode: theme === "dark" ? "dark" : "light", lightMode: resolvedLightBackground ?? { type: "color", value: "" }, darkMode: resolvedDarkBackground ?? { type: "color", value: "" } })), variant === "admin" && (_jsx(AdminSidebar, { variant: "sidebar", desktopOpen: desktopOpen, mobileOpen: mobileOpen, activePath: activeHref, groups: adminGroups, onCloseMobile: close, onToggle: toggle, className: className, renderFooter: renderCrossNavFooter })), variant === "store" && (_jsx(StoreSidebar, { variant: "sidebar", desktopOpen: desktopOpen, mobileOpen: mobileOpen, activeHref: activeHref, items: [], groups: filteredGroups, onCloseMobile: close, onToggle: toggle, className: className, renderFooter: renderCrossNavFooter })), variant === "user" && (_jsx(UserSidebar, { variant: "sidebar", desktopOpen: desktopOpen, mobileOpen: mobileOpen, items: filteredGroups.flatMap((g) => g.items), groups: filteredGroups, onCloseMobile: close, onToggle: toggle, className: className, renderFooter: renderCrossNavFooter })), _jsx(Div, { className: [
                     "w-full flex-1 flex flex-col min-h-[calc(100dvh-var(--header-height,3.5rem))]",
                     "pb-[var(--appkit-space-16)] lg:pb-[0]", // clears the fixed mobile bottom-nav
-                    contentPadding ?? DEFAULT_CONTENT_PADDING,
+                    contentPadding ?? (hand === "left" ? DEFAULT_CONTENT_PADDING_LEFT : DEFAULT_CONTENT_PADDING_RIGHT),
                     contentSurface,
                 ].filter(Boolean).join(" "), children: _jsx(Div, { className: ["w-full flex-1 mx-auto", contentMaxWidth ?? DEFAULT_CONTENT_MAX_WIDTH].filter(Boolean).join(" "), children: children }) }), _jsx(DashboardBottomNav, { items: filteredGroups.flatMap((g) => g.items), activeHref: activeHref })] }));
 }

package/dist/_internal/client/features/layout/SidebarCollapseToggle.d.ts

@@ -15,5 +15,9 @@ export interface SidebarCollapseToggleProps {
     /** aria-label override; defaults to "Collapse sidebar" / "Expand sidebar". */
     expandedLabel?: string;
     collapsedLabel?: string;
+    /** Which edge the parent sidebar panel is docked to. Defaults to "right"
+     * (the handle protrudes to the panel's outer/right edge). "left" mirrors
+     * the rounded corner and chevron direction for left-hand mode. */
+    edge?: "left" | "right";
 }
-export declare function SidebarCollapseToggle({ expanded, onToggle, expandedLabel, collapsedLabel, }: SidebarCollapseToggleProps): React.JSX.Element;
+export declare function SidebarCollapseToggle({ expanded, onToggle, expandedLabel, collapsedLabel, edge, }: SidebarCollapseToggleProps): React.JSX.Element;

package/dist/_internal/client/features/layout/SidebarCollapseToggle.js

@@ -7,6 +7,12 @@ const HANDLE_STYLE = {
 const CHEVRON_STYLE = {
     color: "var(--appkit-color-text-on-primary)",
 };
-export function SidebarCollapseToggle({ expanded, onToggle, expandedLabel = "Collapse sidebar", collapsedLabel = "Expand sidebar", }) {
-    return (_jsx(IconButton, { type: "button", onClick: onToggle, "aria-label": expanded ? expandedLabel : collapsedLabel, "aria-expanded": expanded, variant: "ghost", style: HANDLE_STYLE, className: "w-9 shrink-0 rounded-r-[1.25rem] shadow-lg transition-all duration-200 hover:shadow-xl hover:brightness-110 active:scale-[0.96]", icon: _jsx("svg", { className: `w-4 h-4 drop-shadow-sm transition-transform duration-300 ${expanded ? "" : "rotate-180"}`, style: CHEVRON_STYLE, fill: "none", stroke: "currentColor", viewBox: "0 0 24 24", "aria-hidden": "true", children: _jsx("path", { strokeLinecap: "round", strokeLinejoin: "round", strokeWidth: 2.5, d: "M15 19l-7-7 7-7" }) }) }));
+export function SidebarCollapseToggle({ expanded, onToggle, expandedLabel = "Collapse sidebar", collapsedLabel = "Expand sidebar", edge = "right", }) {
+    // The panel's free (open) edge is opposite its dock side: a left-docked
+    // panel (edge="left") protrudes its handle to the right, and vice versa.
+    const roundedClass = edge === "left" ? "rounded-r-[1.25rem]" : "rounded-l-[1.25rem]";
+    // Chevron rotation direction mirrors along with the dock side so it keeps
+    // pointing "into" the collapsed panel regardless of which edge it's on.
+    const chevronRotated = edge === "left" ? !expanded : expanded;
+    return (_jsx(IconButton, { type: "button", onClick: onToggle, "aria-label": expanded ? expandedLabel : collapsedLabel, "aria-expanded": expanded, variant: "ghost", style: HANDLE_STYLE, className: `w-9 shrink-0 ${roundedClass} shadow-lg transition-all duration-200 hover:shadow-xl hover:brightness-110 active:scale-[0.96]`, icon: _jsx("svg", { className: `w-4 h-4 drop-shadow-sm transition-transform duration-300 ${chevronRotated ? "rotate-180" : ""}`, style: CHEVRON_STYLE, fill: "none", stroke: "currentColor", viewBox: "0 0 24 24", "aria-hidden": "true", children: _jsx("path", { strokeLinecap: "round", strokeLinejoin: "round", strokeWidth: 2.5, d: "M15 19l-7-7 7-7" }) }) }));
 }

package/dist/_internal/client/features/layout/sidebarPositionClasses.d.ts

@@ -0,0 +1,20 @@
+import type { HandMode } from "../../hand-mode";
+/** Classes for the desktop persistent sidebar rail (Admin/Seller/User
+ * `variant="sidebar"`) — flips which edge it docks to, its border side, and
+ * its collapsed-state translate direction, based on the hand-mode
+ * preference. Kept as a single shared helper so the flip logic isn't
+ * hand-forked identically across all three sidebar files. */
+export interface SidebarRailClasses {
+    edgeClass: string;
+    borderClass: string;
+    collapsedTranslateClass: string;
+}
+export declare function getSidebarRailClasses(hand: HandMode): SidebarRailClasses;
+/** Classes for the mobile overlay drawer variant (Admin/Seller/User
+ * `variant="overlay"` → `DrawerPanel`) — same edge/border flip, no
+ * translate state since the panel is conditionally mounted, not animated. */
+export interface SidebarOverlayClasses {
+    edgeClass: string;
+    borderClass: string;
+}
+export declare function getSidebarOverlayClasses(hand: HandMode): SidebarOverlayClasses;

package/dist/_internal/client/features/layout/sidebarPositionClasses.js

@@ -0,0 +1,20 @@
+export function getSidebarRailClasses(hand) {
+    if (hand === "left") {
+        return {
+            edgeClass: "left-0",
+            borderClass: "border-r",
+            collapsedTranslateClass: "-translate-x-[calc(100%-1.25rem)]",
+        };
+    }
+    return {
+        edgeClass: "right-0",
+        borderClass: "border-l",
+        collapsedTranslateClass: "translate-x-[calc(100%-1.25rem)]",
+    };
+}
+export function getSidebarOverlayClasses(hand) {
+    if (hand === "left") {
+        return { edgeClass: "left-0", borderClass: "border-r" };
+    }
+    return { edgeClass: "right-0", borderClass: "border-l" };
+}

package/dist/_internal/client/hand-mode/HandModeProvider.d.ts

@@ -0,0 +1,21 @@
+import { type ReactNode } from "react";
+export type HandMode = "left" | "right";
+export interface HandModeContextValue {
+    /** Which side CTA panels/drawers/sidebars dock to and where close buttons sit. */
+    hand: HandMode;
+    /** Persist a new hand-mode preference and re-render the flipped layout. */
+    setHand: (next: HandMode) => void;
+    /** Flip preference between right ↔ left. */
+    toggleHand: () => void;
+}
+export interface HandModeProviderProps {
+    /**
+     * Seed value from the signed-in user's server-persisted preference
+     * (`user.uiPreferences.handMode`), used only when no value is already
+     * cached in localStorage on this device.
+     */
+    initialHand?: HandMode;
+    children: ReactNode;
+}
+export declare function HandModeProvider({ initialHand, children }: HandModeProviderProps): import("react").JSX.Element;
+export declare function useHandMode(): HandModeContextValue;

package/dist/_internal/client/hand-mode/HandModeProvider.js

@@ -0,0 +1,81 @@
+"use client";
+import { jsx as _jsx } from "react/jsx-runtime";
+import { normalizeError } from "../../../errors/normalize";
+import { createContext, useCallback, useContext, useEffect, useMemo, useState, } from "react";
+// Brand-neutral localStorage namespace, matching the `appkit:theme-mode` /
+// `appkit:theme-id` convention. audit-ssr-in-appkit blocks hardcoded brand
+// strings inside `_internal/`.
+const HAND_STORAGE_KEY = "appkit:hand-mode";
+// Default (non-null) context value — unlike `ThemeContext` (which throws
+// outside its provider because it's only ever consumed at the app-shell
+// level), `useHandMode()` is called from base UI primitives (SideDrawer,
+// Modal, Drawer, BackToTop, ...) that ship as part of the public design
+// system and must degrade gracefully to the "right" default for any
+// consumer that hasn't mounted `<HandModeProvider>`.
+const DEFAULT_CONTEXT_VALUE = {
+    hand: "right",
+    setHand: () => { },
+    toggleHand: () => { },
+};
+const HandModeContext = createContext(DEFAULT_CONTEXT_VALUE);
+function readHandPreference() {
+    if (typeof window === "undefined")
+        return "right";
+    try {
+        const stored = window.localStorage.getItem(HAND_STORAGE_KEY);
+        if (stored === "left" || stored === "right")
+            return stored;
+    }
+    catch (_err) {
+        void normalizeError(_err); /* localStorage unavailable in privacy/iframe context */
+    }
+    return "right";
+}
+/** Apply the hand-mode preference to `<html>` via a `data-hand` attribute.
+ * Deliberately NOT `dir="rtl"/"ltr"` — that would trigger the browser's
+ * bidi text-direction and native-control-mirroring behavior repo-wide, which
+ * is not what this "reachability" preference means. `data-hand` is a plain
+ * presentational attribute, same category as `data-theme`. */
+function applyHand(hand) {
+    if (typeof document === "undefined")
+        return;
+    document.documentElement.setAttribute("data-hand", hand);
+}
+export function HandModeProvider({ initialHand, children }) {
+    const [hand, setHandState] = useState(() => {
+        if (typeof window === "undefined")
+            return initialHand ?? "right";
+        const stored = readHandPreference();
+        // readHandPreference() falls back to "right" when nothing is cached —
+        // in that case, prefer the server-seeded value over the hardcoded default.
+        try {
+            if (window.localStorage.getItem(HAND_STORAGE_KEY) === null) {
+                return initialHand ?? stored;
+            }
+        }
+        catch (_err) {
+            void normalizeError(_err);
+        }
+        return stored;
+    });
+    useEffect(() => {
+        applyHand(hand);
+    }, [hand]);
+    const setHand = useCallback((next) => {
+        setHandState(next);
+        try {
+            window.localStorage.setItem(HAND_STORAGE_KEY, next);
+        }
+        catch (_err) {
+            void normalizeError(_err); /* localStorage unavailable; preference applies for this session */
+        }
+    }, []);
+    const toggleHand = useCallback(() => {
+        setHand(hand === "left" ? "right" : "left");
+    }, [hand, setHand]);
+    const value = useMemo(() => ({ hand, setHand, toggleHand }), [hand, setHand, toggleHand]);
+    return _jsx(HandModeContext.Provider, { value: value, children: children });
+}
+export function useHandMode() {
+    return useContext(HandModeContext);
+}

package/dist/_internal/client/hand-mode/index.d.ts

@@ -0,0 +1,2 @@
+export { HandModeProvider, useHandMode } from "./HandModeProvider";
+export type { HandMode, HandModeContextValue, HandModeProviderProps, } from "./HandModeProvider";

package/dist/_internal/client/hand-mode/index.js

@@ -0,0 +1 @@
+export { HandModeProvider, useHandMode } from "./HandModeProvider";

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

@@ -32,6 +32,18 @@ export interface CreateCheckoutOrderInput {
     /** 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
+ * read-only `previewCheckoutPricing` (Order Summary display) can compute the
+ * exact same per-seller shipping fee that order creation charges/records —
+ * a single source of truth instead of a third re-implementation.
+ */
+export declare function resolveShippingCost(storeId: string | undefined): Promise<{
+    shippingFee: number;
+    storeOwnerId: string | undefined;
+    storeEmiEnabled: boolean;
+    storeState: string | undefined;
+}>;
 /**
  * Place order(s) from the user's cart in a single Firestore transaction.
  *
@@ -39,6 +51,37 @@ export interface CreateCheckoutOrderInput {
  * auth + rate-limiting before calling this and supply the resolved user fields.
  */
 export declare function createCheckoutOrderAction(input: CreateCheckoutOrderInput): Promise<CheckoutOrderResult>;
+export interface CheckoutPricingPreviewInput {
+    userId: string;
+    /** Omitted for digital-only carts — GST can't be computed without a buyer state. */
+    addressId?: string;
+    paymentMethod: CheckoutPaymentMethod;
+    excludedProductIds?: string[];
+    whatsappNotifyAddon?: boolean;
+    giftWrapAddon?: boolean;
+    shipmentProtectionAddon?: boolean;
+}
+export interface CheckoutPricingPreview {
+    subtotal: number;
+    shippingFee: number;
+    codHandlingFee: number;
+    whatsappNotifyFee: number;
+    giftWrapFee: number;
+    shipmentProtectionFee: number;
+    gstAmount: number;
+    couponDiscount: number;
+    total: number;
+}
+/**
+ * Read-only "what will I actually be charged" preview for the checkout
+ * Order Summary. Reuses the exact same building blocks
+ * createCheckoutOrderAction / verifyAndPlaceRazorpayOrderAction use when an
+ * order is actually placed — resolveShippingCost, the compute*Fee helpers,
+ * computeGroupCouponDiscount, and the GST calc — so the number shown to the
+ * buyer can never diverge from what gets charged/recorded. Never decrements
+ * stock, creates an order, or writes coupon usage.
+ */
+export declare function previewCheckoutPricing(input: CheckoutPricingPreviewInput): Promise<CheckoutPricingPreview>;
 /**
  * Mark an order as paid after a payment provider verifies the transaction.
  * Consumers call this from /api/payment/verify or a payment webhook.

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

@@ -11,7 +11,7 @@ import { roundRupees } from "../../../../utils/number.formatter";
 import { ApiError, ValidationError, NotFoundError, ERROR_MESSAGES } from "../../../../errors";
 import { ORDER_FIELDS } from "../../../../constants/field-names";
 import { serverLogger } from "../../../../monitoring";
-import { unitOfWork, siteSettingsRepository, userRepository, storeRepository, couponsRepository, claimedCouponsRepository, addressesRepository, } from "../../../../repositories";
+import { unitOfWork, siteSettingsRepository, userRepository, storeRepository, couponsRepository, claimedCouponsRepository, addressesRepository, productRepository, } from "../../../../repositories";
 import { calculateGst } from "../../../shared/fees/calculator";
 import { computePreOrderDepositAmount } from "../../../shared/checkout/order-math";
 import { failedCheckoutRepository } from "../../../../features/checkout/repository/failed-checkout.repository";
@@ -151,7 +151,13 @@ function accumulateCouponUsage(accumulator, couponCode, couponId, discountAmount
     entry.totalDiscount += discountAmount;
     accumulator.set(couponCode, entry);
 }
-async function resolveShippingCost(storeId) {
+/**
+ * Exported so `/api/payment/create-order` (pre-charge amount) and the
+ * read-only `previewCheckoutPricing` (Order Summary display) can compute the
+ * exact same per-seller shipping fee that order creation charges/records —
+ * a single source of truth instead of a third re-implementation.
+ */
+export async function resolveShippingCost(storeId) {
     if (!storeId)
         return { shippingFee: 0, storeOwnerId: undefined, storeEmiEnabled: false, storeState: undefined };
     const store = await storeRepository.findById(storeId);
@@ -172,6 +178,55 @@ async function resolveStoreState(storeId) {
     const pickup = addresses.find((a) => a.isDefault) ?? addresses[0];
     return pickup?.state;
 }
+/**
+ * Prorates every buyer-applied coupon against one seller-group's total. Pure
+ * — no side effects (usage-accumulator bookkeeping is layered on by callers
+ * that actually place an order). Shared by createOrderForGroup,
+ * createRazorpayGroupOrder, and the read-only previewCheckoutPricing so the
+ * three can never drift on how a coupon splits across sellers (was three
+ * near-identical copies before this extraction — Duplication Decision
+ * Framework's Rule of Three).
+ */
+function computeGroupCouponDiscount(appliedCoupons, groupLines, groupTotal, cartSubtotal, storeId) {
+    let couponDiscount = 0;
+    const appliedDiscounts = [];
+    for (const coupon of appliedCoupons) {
+        let couponGroupDiscount = 0;
+        const isSellerScoped = coupon.scope === "seller" && coupon.storeId;
+        if (isSellerScoped) {
+            if (coupon.storeId !== storeId)
+                continue;
+            if (coupon.applicableItemIds?.length) {
+                const eligibleTotal = groupLines
+                    .filter((l) => coupon.applicableItemIds.includes(l.itemId))
+                    .reduce((s, l) => s + l.lineTotal, 0);
+                couponGroupDiscount =
+                    eligibleTotal > 0
+                        ? Math.min(roundRupees((eligibleTotal / groupTotal) * coupon.discountAmount), eligibleTotal)
+                        : 0;
+            }
+            else {
+                couponGroupDiscount = Math.min(coupon.discountAmount, groupTotal);
+            }
+        }
+        else if (cartSubtotal > 0) {
+            couponGroupDiscount = Math.min(roundRupees((groupTotal / cartSubtotal) * coupon.discountAmount), groupTotal);
+        }
+        if (couponGroupDiscount > 0) {
+            couponDiscount += couponGroupDiscount;
+            appliedDiscounts.push({
+                code: coupon.code,
+                couponId: coupon.couponId,
+                type: "coupon",
+                discountAmount: couponGroupDiscount,
+                scope: coupon.scope,
+                storeId: coupon.storeId,
+            });
+        }
+    }
+    couponDiscount = Math.min(couponDiscount, groupTotal);
+    return { couponDiscount, appliedDiscounts };
+}
 function buildStockUpdatePayload(product, qtyDelta) {
     const lt = (product.listingType ?? "standard");
     const rule = getListingRule(lt);
@@ -313,50 +368,15 @@ async function createOrderForGroup(group, orderType, ctx) {
     const whatsappNotifyFee = computeWhatsAppNotifyFee(whatsappNotifyAddon, commissions);
     const giftWrapFee = computeGiftWrapFee(giftWrapAddon, commissions);
     const shipmentProtectionFee = computeShipmentProtectionFee(groupTotal, shipmentProtectionAddon, commissions);
-    let couponDiscount = 0;
-    const appliedDiscounts = [];
     const groupCouponCodes = new Set();
-    for (const coupon of appliedCoupons) {
-        let couponGroupDiscount = 0;
-        const isSellerScoped = coupon.scope === "seller" && coupon.storeId;
-        if (isSellerScoped) {
-            if (coupon.storeId !== firstItem.storeId)
-                continue;
-            if (coupon.applicableItemIds?.length) {
-                const eligibleTotal = group
-                    .filter(({ item }) => coupon.applicableItemIds.includes(item.itemId))
-                    .reduce((s, { item }) => s + item.price * item.quantity, 0);
-                couponGroupDiscount =
-                    eligibleTotal > 0
-                        ? Math.min(roundRupees((eligibleTotal / groupTotal) * coupon.discountAmount), eligibleTotal)
-                        : 0;
-            }
-            else {
-                couponGroupDiscount = Math.min(coupon.discountAmount, groupTotal);
-            }
-        }
-        else {
-            if (cartSubtotal > 0) {
-                couponGroupDiscount = Math.min(roundRupees((groupTotal / cartSubtotal) * coupon.discountAmount), groupTotal);
-            }
-        }
-        if (couponGroupDiscount > 0) {
-            couponDiscount += couponGroupDiscount;
-            appliedDiscounts.push({
-                code: coupon.code,
-                couponId: coupon.couponId,
-                type: "coupon",
-                discountAmount: couponGroupDiscount,
-                scope: coupon.scope,
-                storeId: coupon.storeId,
-            });
-            if (coupon.couponId) {
-                accumulateCouponUsage(couponUsageAccumulator, coupon.code, coupon.couponId, couponGroupDiscount);
-                groupCouponCodes.add(coupon.code);
-            }
+    const groupLines = group.map(({ item }) => ({ itemId: item.itemId, lineTotal: item.price * item.quantity }));
+    const { couponDiscount, appliedDiscounts } = computeGroupCouponDiscount(appliedCoupons, groupLines, groupTotal, cartSubtotal, firstItem.storeId);
+    for (const discount of appliedDiscounts) {
+        if (discount.couponId) {
+            accumulateCouponUsage(couponUsageAccumulator, discount.code, discount.couponId, discount.discountAmount);
+            groupCouponCodes.add(discount.code);
         }
     }
-    couponDiscount = Math.min(couponDiscount, groupTotal);
     const orderTotal = Math.max(0, groupTotal - couponDiscount) + shippingFee + codHandlingFee + whatsappNotifyFee + giftWrapFee + shipmentProtectionFee + (emiSchedule?.surchargeAmount ?? 0) + (gstBreakdown?.gstAmount ?? 0);
     const imageUrls = [
         ...new Set(group
@@ -733,6 +753,105 @@ export async function createCheckoutOrderAction(input) {
         ...(unavailable.length > 0 ? { unavailableItems: unavailable } : {}),
     };
 }
+const EMPTY_PRICING_PREVIEW = {
+    subtotal: 0,
+    shippingFee: 0,
+    codHandlingFee: 0,
+    whatsappNotifyFee: 0,
+    giftWrapFee: 0,
+    shipmentProtectionFee: 0,
+    gstAmount: 0,
+    couponDiscount: 0,
+    total: 0,
+};
+/**
+ * Read-only "what will I actually be charged" preview for the checkout
+ * Order Summary. Reuses the exact same building blocks
+ * createCheckoutOrderAction / verifyAndPlaceRazorpayOrderAction use when an
+ * order is actually placed — resolveShippingCost, the compute*Fee helpers,
+ * computeGroupCouponDiscount, and the GST calc — so the number shown to the
+ * buyer can never diverge from what gets charged/recorded. Never decrements
+ * 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 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 cartItems = (cart.items ?? []).filter((item) => !excludedSet.has(item.productId) && (!selectedSet || selectedSet.has(item.itemId)));
+    if (cartItems.length === 0)
+        return EMPTY_PRICING_PREVIEW;
+    // Best-effort product lookup — a preview never throws on a since-unpublished
+    // product, it just falls back to the item's cart-snapshot price for that
+    // line (same fallback cartRepository.getSubtotal() implicitly relies on).
+    const uniqueProductIds = [...new Set(cartItems.map((item) => item.productId))];
+    const productDocs = await Promise.all(uniqueProductIds.map((pid) => productRepository.findById(pid)));
+    const productById = new Map(uniqueProductIds.map((pid, i) => [pid, productDocs[i]]));
+    let resolvedAddress = null;
+    if (addressId) {
+        const addressDoc = await unitOfWork.addresses.findById(addressId);
+        resolvedAddress =
+            addressDoc && addressDoc.ownerType === "user" && addressDoc.ownerId === uid ? addressDoc : null;
+    }
+    const unitPriceFor = (item, product) => item.bundleCategorySlug && item.bundleProductIds?.length ? item.price : (product?.price ?? item.price);
+    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;
+    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;
+        // 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);
+        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;
+            }
+        }
+        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;
+    }
+    const total = Math.max(0, cartSubtotal - couponDiscount) +
+        shippingFee +
+        codHandlingFee +
+        whatsappNotifyFeeTotal +
+        giftWrapFeeTotal +
+        shipmentProtectionFeeTotal +
+        gstAmount;
+    return {
+        subtotal: cartSubtotal,
+        shippingFee,
+        codHandlingFee,
+        whatsappNotifyFee: whatsappNotifyFeeTotal,
+        giftWrapFee: giftWrapFeeTotal,
+        shipmentProtectionFee: shipmentProtectionFeeTotal,
+        gstAmount,
+        couponDiscount,
+        total,
+    };
+}
 /**
  * Mark an order as paid after a payment provider verifies the transaction.
  * Consumers call this from /api/payment/verify or a payment webhook.
@@ -864,43 +983,8 @@ async function createRazorpayGroupOrder(group, orderType, ctx) {
     // of re-implementing it inline — was two sequential findById calls per
     // seller group here, duplicated from resolveShippingCost.
     const { shippingFee, storeOwnerId } = await resolveShippingCost(firstItem.storeId);
-    let couponDiscount = 0;
-    const appliedDiscounts = [];
-    for (const coupon of appliedCoupons) {
-        let couponGroupDiscount = 0;
-        const isSellerScoped = coupon.scope === "seller" && coupon.storeId;
-        if (isSellerScoped) {
-            if (coupon.storeId !== firstItem.storeId)
-                continue;
-            if (coupon.applicableItemIds?.length) {
-                const eligibleTotal = group
-                    .filter(({ item }) => coupon.applicableItemIds.includes(item.itemId))
-                    .reduce((s, { item, product }) => s + unitPriceFor(item, product) * item.quantity, 0);
-                couponGroupDiscount =
-                    eligibleTotal > 0
-                        ? Math.min(roundRupees((eligibleTotal / groupTotal) * coupon.discountAmount), eligibleTotal)
-                        : 0;
-            }
-            else {
-                couponGroupDiscount = Math.min(coupon.discountAmount, groupTotal);
-            }
-        }
-        else if (cartSubtotal > 0) {
-            couponGroupDiscount = Math.min(roundRupees((groupTotal / cartSubtotal) * coupon.discountAmount), groupTotal);
-        }
-        if (couponGroupDiscount > 0) {
-            couponDiscount += couponGroupDiscount;
-            appliedDiscounts.push({
-                code: coupon.code,
-                couponId: coupon.couponId,
-                type: "coupon",
-                discountAmount: couponGroupDiscount,
-                scope: coupon.scope,
-                storeId: coupon.storeId,
-            });
-        }
-    }
-    couponDiscount = Math.min(couponDiscount, groupTotal);
+    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));
     const platformFee = rawPlatformFee + gstOnFee;
@@ -1165,7 +1249,14 @@ export async function verifyAndPlaceRazorpayOrderAction(input) {
         }, 0);
         const expectedPlatformFee = roundRupees(cartSubtotalRs * (platformFeePercent / 100));
         const expectedGstOnFee = roundRupees(expectedPlatformFee * (gstPercent / 100));
-        const expectedPaymentAmountRs = cartSubtotalRs + expectedPlatformFee + expectedGstOnFee;
+        // 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
+        // floor check from passing an amount that's short by the shipping fee.
+        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;
         const rzpOrderRecord = await fetchRazorpayOrder(razorpay_order_id);
         const paidAmountRs = paiseToRupees(rzpOrderRecord.amount);
         if (paidAmountRs < expectedPaymentAmountRs - 1) {

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

@@ -1,3 +1,3 @@
-export { createCheckoutOrderAction, attachPaymentAction, verifyAndPlaceRazorpayOrderAction, type CreateCheckoutOrderInput, type VerifyAndPlaceRazorpayOrderInput, } from "./actions";
+export { createCheckoutOrderAction, attachPaymentAction, verifyAndPlaceRazorpayOrderAction, previewCheckoutPricing, resolveShippingCost, type CreateCheckoutOrderInput, type VerifyAndPlaceRazorpayOrderInput, type CheckoutPricingPreviewInput, type CheckoutPricingPreview, } from "./actions";
 export { formatShippingAddress, type CheckoutOrderResult, } from "./data";
 export { CHECKOUT_DEFAULT_COMMISSIONS, CHECKOUT_PAYMENT_METHODS, type CheckoutPaymentMethod, } from "../../../shared/features/checkout/config";

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

@@ -1,3 +1,3 @@
-export { createCheckoutOrderAction, attachPaymentAction, verifyAndPlaceRazorpayOrderAction, } from "./actions";
+export { createCheckoutOrderAction, attachPaymentAction, verifyAndPlaceRazorpayOrderAction, previewCheckoutPricing, resolveShippingCost, } from "./actions";
 export { formatShippingAddress, } from "./data";
 export { CHECKOUT_DEFAULT_COMMISSIONS, CHECKOUT_PAYMENT_METHODS, } from "../../../shared/features/checkout/config";

package/dist/_internal/server/features/seo/robots.js

@@ -7,12 +7,13 @@ export function buildRobots({ siteUrl }) {
                 disallow: [
                     "/admin/",
                     "/api/", // audit-hardcoded-api-routes-ok: robots.txt disallow prefix, not an endpoint reference
-                    "/seller/",
+                    "/store/",
                     "/user/",
                     "/auth/",
                     "/checkout/",
                     "/cart/",
-                    "/demo/",
+                    "/wishlist",
+                    "/preview/",
                     "/track/",
                     "/unauthorized/",
                     "/_next/",