@mohasinac/appkit 4.25.0 → 4.27.0

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

@@ -210,6 +210,27 @@ async function fetchCategoryTypeUrls(baseUrl, categoryType, buildUrl, label) {
 const fetchCategoryUrls = (baseUrl) => fetchCategoryTypeUrls(baseUrl, "listing", (slug) => ROUTES.PUBLIC.CATEGORY_DETAIL(slug), "category");
 const fetchBrandUrls = (baseUrl) => fetchCategoryTypeUrls(baseUrl, "brand", (slug) => ROUTES.PUBLIC.BRAND_DETAIL(slug), "brand");
 const fetchBundleUrls = (baseUrl) => fetchCategoryTypeUrls(baseUrl, "bundle", (slug) => ROUTES.PUBLIC.BUNDLE_DETAIL(slug), "bundle");
+/**
+ * `groupedListings` documents. `listSitemapGroupedListings` has existed since
+ * the feature was built, but there was no public page for it to point at until
+ * `/groups/{slug}` — so it was never wired into the sitemap.
+ */
+async function fetchGroupedListingUrls(baseUrl) {
+    try {
+        const { listSitemapGroupedListings } = await import("../grouped/data");
+        const groups = await listSitemapGroupedListings();
+        return groups.map((g) => ({
+            url: `${baseUrl}${ROUTES.PUBLIC.GROUP_DETAIL(g.slug)}`,
+            lastModified: g.updatedAt,
+            changeFrequency: "weekly",
+            priority: 0.5,
+        }));
+    }
+    catch (err) {
+        void normalizeError(err);
+        return [];
+    }
+}
 async function fetchBlogPostUrls(baseUrl) {
     try {
         const db = getAdminDb();
@@ -293,11 +314,12 @@ async function fetchScammerUrls(baseUrl) {
     }
 }
 export async function buildSitemap({ baseUrl }) {
-    const [productUrls, categoryUrls, brandUrls, bundleUrls, eventUrls, blogUrls, auctionUrls, preOrderUrls, prizeDrawUrls, classifiedUrls, digitalCodeUrls, liveUrls, storeUrls, scammerUrls,] = await Promise.all([
+    const [productUrls, categoryUrls, brandUrls, bundleUrls, groupedListingUrls, eventUrls, blogUrls, auctionUrls, preOrderUrls, prizeDrawUrls, classifiedUrls, digitalCodeUrls, liveUrls, storeUrls, scammerUrls,] = await Promise.all([
         fetchProductUrls(baseUrl),
         fetchCategoryUrls(baseUrl),
         fetchBrandUrls(baseUrl),
         fetchBundleUrls(baseUrl),
+        fetchGroupedListingUrls(baseUrl),
         fetchEventUrls(baseUrl),
         fetchBlogPostUrls(baseUrl),
         fetchAuctionUrls(baseUrl),
@@ -314,6 +336,7 @@ export async function buildSitemap({ baseUrl }) {
         ...categoryUrls,
         ...brandUrls,
         ...bundleUrls,
+        ...groupedListingUrls,
         ...blogUrls,
         ...productUrls,
         ...auctionUrls,

package/dist/_internal/shared/checkout/order-math.d.ts

@@ -17,13 +17,14 @@ import type { ProductDocument } from "../../../features/products/schemas/firesto
  *     copies of this function looked at `lockedPrice`, so an accepted offer was
  *     billed at the seller's listed price while the cart UI displayed the agreed
  *     one (`item.lockedPrice ?? item.price`) — the buyer saw ₹X and paid ₹Y.
- *  2. **A multi-member line** — the sum of its members' own snapshotted prices,
+ *  2. **A bundle line** — `item.price` is the bundle's own locked price, which
+ *     is deliberately LESS than the sum of its members. Checked before the
+ *     members branch for exactly that reason. Covers both modern bundle lines
+ *     (`lineKind: "bundle"`) and legacy ones (SB-UNI-5 2026-05-13).
+ *  3. **A grouped line** — the sum of its members' own snapshotted prices,
  *     weighted by each member's per-copy quantity. A `"group"` line pins
  *     `item.quantity` to 1, so this is both the unit price and the line total;
  *     see the invariant on `CartLineMember`.
- *  3. **A legacy bundle line** (SB-UNI-5 2026-05-13) — written before
- *     `groupMembers` existed. `item.price` is the bundle price locked at
- *     add-time.
  *  4. **Everything else** — the live Firestore price, so a stale cart-cached
  *     price is never charged on a COD/UPI order.
  *
@@ -44,6 +45,64 @@ export declare function unitPriceFor(item: CartItemDocument, product: ProductDoc
  * itself — that multiplication is where the six hand-rolled copies diverged.
  */
 export declare function lineTotalFor(item: CartItemDocument, product: ProductDocument | null): number;
+/** One taxable slice of a line. A single-product line has exactly one. */
+export interface LineTaxComponent {
+    productId: string;
+    /** Rupees this slice is taxed on. Slices of a line sum to its line total. */
+    taxable: number;
+    gstRate: number;
+    hsnCode?: string;
+}
+/**
+ * Split a line into its taxable slices.
+ *
+ * GST cannot go through `unitPriceFor`: that returns a scalar, and a
+ * multi-member line genuinely has SEVERAL rates — a ₹200 sticker at 12% next to
+ * a ₹2,000 top at 18% inside one selection. A scalar can only ever carry one of
+ * them, which is why a bundle line has paid **zero** GST for its whole
+ * existence: `previewCheckoutPricing` looked its product up by `item.productId`,
+ * which on a bundle is a CATEGORY id, so `product` was null and
+ * `product?.gstRate ?? 0` quietly resolved to 0.
+ *
+ * Three shapes:
+ *
+ *  - **Plain line** — one slice, taxed on the whole line total. Identical to
+ *    what the two GST loops did before.
+ *  - **Grouped line** — one slice per member, each taxed on its own
+ *    `unitPrice × member.quantity × item.quantity`. Slices sum to the line
+ *    total exactly, because a grouped line has no price of its own.
+ *  - **Bundle line** — the taxable base is the bundle's LOCKED price, not the
+ *    sum of the members' list prices, so each member's slice is a prorated
+ *    share of it (see `allocateBundlePrice`). Charging tax on the undiscounted
+ *    total would tax the buyer on money they never paid.
+ *
+ * `productById` supplies the live `gstRate`; each member's snapshotted rate is
+ * the fallback for a member whose listing has since been archived.
+ */
+export declare function lineTaxComponentsFor(item: CartItemDocument, productById: Map<string, ProductDocument>): LineTaxComponent[];
+/**
+ * Total GST for one order group, and the base it was charged on.
+ *
+ * Exists so `createOrderForGroup` (what the buyer is CHARGED) and
+ * `previewCheckoutPricing` (what the buyer is SHOWN) cannot disagree. They were
+ * two hand-written loops, and Root Cause #59 is precisely the pattern of fixing
+ * one and not the other — here that would mean quoting one tax figure and
+ * charging another.
+ */
+export declare function sumGroupGst(items: readonly CartItemDocument[], productById: Map<string, ProductDocument>, intraState: boolean): {
+    taxableAmount: number;
+    gstAmount: number;
+};
+/**
+ * Split `total` across members in proportion to their list prices, with the
+ * rounding remainder pushed onto the LAST member so the parts sum to exactly
+ * `total`, to the last decimal place. Rounding each share independently leaves
+ * an order whose `taxableAmount` doesn't reconcile with the sum of its lines.
+ *
+ * Falls back to an even split when every weight is zero (a bundle of free
+ * items), which is the only case where proportion is undefined.
+ */
+export declare function allocateAcrossMembers(total: number, weights: number[]): number[];
 /**
  * P-6 — pre-order groups charge each product's own `preOrderDepositPercent`
  * (falling back to the generic COD deposit % when a product doesn't have one

package/dist/_internal/shared/checkout/order-math.js

@@ -1,4 +1,5 @@
 import { roundRupees } from "../../../utils/number.formatter";
+import { calculateGst } from "../fees/calculator";
 /**
  * The single source of truth for "what do we charge for ONE COPY of this line".
  *
@@ -10,13 +11,14 @@ import { roundRupees } from "../../../utils/number.formatter";
  *     copies of this function looked at `lockedPrice`, so an accepted offer was
  *     billed at the seller's listed price while the cart UI displayed the agreed
  *     one (`item.lockedPrice ?? item.price`) — the buyer saw ₹X and paid ₹Y.
- *  2. **A multi-member line** — the sum of its members' own snapshotted prices,
+ *  2. **A bundle line** — `item.price` is the bundle's own locked price, which
+ *     is deliberately LESS than the sum of its members. Checked before the
+ *     members branch for exactly that reason. Covers both modern bundle lines
+ *     (`lineKind: "bundle"`) and legacy ones (SB-UNI-5 2026-05-13).
+ *  3. **A grouped line** — the sum of its members' own snapshotted prices,
  *     weighted by each member's per-copy quantity. A `"group"` line pins
  *     `item.quantity` to 1, so this is both the unit price and the line total;
  *     see the invariant on `CartLineMember`.
- *  3. **A legacy bundle line** (SB-UNI-5 2026-05-13) — written before
- *     `groupMembers` existed. `item.price` is the bundle price locked at
- *     add-time.
  *  4. **Everything else** — the live Firestore price, so a stale cart-cached
  *     price is never charged on a COD/UPI order.
  *
@@ -34,12 +36,18 @@ export function unitPriceFor(item, product) {
     if (typeof item.lockedPrice === "number" && item.lockedPrice > 0) {
         return item.lockedPrice;
     }
+    // A BUNDLE is priced as a whole, and that price is the entire point of it
+    // being a bundle — it is deliberately less than the sum of its members. This
+    // branch must come BEFORE the members branch: a bundle line carries
+    // `groupMembers` too (so the cart can show what's inside and checkout can
+    // prorate GST), and summing them would silently charge the undiscounted total.
+    if (item.lineKind === "bundle" || (item.bundleCategorySlug && item.bundleProductIds?.length)) {
+        return item.price;
+    }
+    // A GROUP line has no price of its own — it is exactly what the buyer picked.
     if (item.groupMembers?.length) {
         return roundRupees(item.groupMembers.reduce((sum, m) => sum + m.unitPrice * m.quantity, 0));
     }
-    if (item.bundleCategorySlug && item.bundleProductIds?.length) {
-        return item.price;
-    }
     // Null-safe fallback: one of the four call sites this replaced (the cart
     // summary/preview path) already guarded with `product?.price ?? item.price`,
     // and collapsing onto a non-null assertion would have regressed it into a
@@ -54,6 +62,110 @@ export function unitPriceFor(item, product) {
 export function lineTotalFor(item, product) {
     return unitPriceFor(item, product) * item.quantity;
 }
+/**
+ * Split a line into its taxable slices.
+ *
+ * GST cannot go through `unitPriceFor`: that returns a scalar, and a
+ * multi-member line genuinely has SEVERAL rates — a ₹200 sticker at 12% next to
+ * a ₹2,000 top at 18% inside one selection. A scalar can only ever carry one of
+ * them, which is why a bundle line has paid **zero** GST for its whole
+ * existence: `previewCheckoutPricing` looked its product up by `item.productId`,
+ * which on a bundle is a CATEGORY id, so `product` was null and
+ * `product?.gstRate ?? 0` quietly resolved to 0.
+ *
+ * Three shapes:
+ *
+ *  - **Plain line** — one slice, taxed on the whole line total. Identical to
+ *    what the two GST loops did before.
+ *  - **Grouped line** — one slice per member, each taxed on its own
+ *    `unitPrice × member.quantity × item.quantity`. Slices sum to the line
+ *    total exactly, because a grouped line has no price of its own.
+ *  - **Bundle line** — the taxable base is the bundle's LOCKED price, not the
+ *    sum of the members' list prices, so each member's slice is a prorated
+ *    share of it (see `allocateBundlePrice`). Charging tax on the undiscounted
+ *    total would tax the buyer on money they never paid.
+ *
+ * `productById` supplies the live `gstRate`; each member's snapshotted rate is
+ * the fallback for a member whose listing has since been archived.
+ */
+export function lineTaxComponentsFor(item, productById) {
+    const lineTotal = lineTotalFor(item, productById.get(item.productId) ?? null);
+    const members = item.groupMembers;
+    if (!members?.length) {
+        const product = productById.get(item.productId);
+        return [{
+                productId: item.productId,
+                taxable: lineTotal,
+                gstRate: product?.gstRate ?? 0,
+                hsnCode: product?.hsnCode,
+            }];
+    }
+    const rateFor = (m) => productById.get(m.productId)?.gstRate ?? m.gstRate ?? 0;
+    const hsnFor = (m) => productById.get(m.productId)?.hsnCode ?? m.hsnCode;
+    const isBundle = item.lineKind === "bundle" || Boolean(item.bundleCategorySlug);
+    if (!isBundle) {
+        return members.map((m) => ({
+            productId: m.productId,
+            taxable: roundRupees(m.unitPrice * m.quantity * item.quantity),
+            gstRate: rateFor(m),
+            hsnCode: hsnFor(m),
+        }));
+    }
+    const shares = allocateAcrossMembers(lineTotal, members.map((m) => m.unitPrice * m.quantity));
+    return members.map((m, i) => ({
+        productId: m.productId,
+        taxable: shares[i],
+        gstRate: rateFor(m),
+        hsnCode: hsnFor(m),
+    }));
+}
+/**
+ * Total GST for one order group, and the base it was charged on.
+ *
+ * Exists so `createOrderForGroup` (what the buyer is CHARGED) and
+ * `previewCheckoutPricing` (what the buyer is SHOWN) cannot disagree. They were
+ * two hand-written loops, and Root Cause #59 is precisely the pattern of fixing
+ * one and not the other — here that would mean quoting one tax figure and
+ * charging another.
+ */
+export function sumGroupGst(items, productById, intraState) {
+    let taxableAmount = 0;
+    let gstAmount = 0;
+    for (const item of items) {
+        for (const slice of lineTaxComponentsFor(item, productById)) {
+            if (slice.gstRate <= 0)
+                continue;
+            taxableAmount += slice.taxable;
+            gstAmount += calculateGst(slice.gstRate, intraState, slice.taxable).gstAmount;
+        }
+    }
+    return { taxableAmount, gstAmount };
+}
+/**
+ * Split `total` across members in proportion to their list prices, with the
+ * rounding remainder pushed onto the LAST member so the parts sum to exactly
+ * `total`, to the last decimal place. Rounding each share independently leaves
+ * an order whose `taxableAmount` doesn't reconcile with the sum of its lines.
+ *
+ * Falls back to an even split when every weight is zero (a bundle of free
+ * items), which is the only case where proportion is undefined.
+ */
+export function allocateAcrossMembers(total, weights) {
+    if (weights.length === 0)
+        return [];
+    const sum = weights.reduce((a, b) => a + b, 0);
+    const out = [];
+    let running = 0;
+    for (let i = 0; i < weights.length - 1; i++) {
+        const share = sum > 0
+            ? roundRupees((total * weights[i]) / sum) // audit-money-units-ok: proportional split of decimal rupees
+            : roundRupees(total / weights.length);
+        out.push(share);
+        running += share;
+    }
+    out.push(roundRupees(total - running));
+    return out;
+}
 /**
  * P-6 — pre-order groups charge each product's own `preOrderDepositPercent`
  * (falling back to the generic COD deposit % when a product doesn't have one

package/dist/client.d.ts

@@ -225,12 +225,14 @@ export { ProtectedRoute, AuthStatusPanel, ForgotPasswordView, LoginForm, Registe
 export type { AuthGuardUser, ForgotPasswordViewProps, LoginFormProps, LoginFormValues, RegisterFormProps, RegisterFormValues, ResetPasswordViewProps, VerifyEmailViewProps, } from "./features/auth/index";
 export { useLogout, useLogin, useGoogleLogin, useLinkGoogleAccount, useRegister, useForgotPassword, useResetPassword, useVerifyEmail, useChangeEmail } from "./features/auth/index";
 export type { LoginCredentials, RegisterData, ForgotPasswordData, ResetPasswordData, VerifyEmailData, ChangeEmailData } from "./features/auth/index";
-export { CartView, CartItemRow, CartSummary, CartPriceBreakdown, CartDrawer, CheckoutView, CheckoutSuccessView, CheckoutAddressStep, useGuestCart, useCartCount, useAddToCart, useCart, useGuestCartMerge, useCartQuery } from "./features/cart/index";
+export { CartView, CartItemRow, CartGroupLineRow, CartSummary, CartPriceBreakdown, CartDrawer, CheckoutView, CheckoutSuccessView, CheckoutAddressStep, useGuestCart, useCartCount, useAddToCart, useCart, useGuestCartMerge, useCartQuery } from "./features/cart/index";
 export { StoreAddonsPicker } from "./features/cart/index";
 export type { CartPriceBreakdownData, CartPriceBreakdownStore, StoreAddonsValue, StoreAddonsRates } from "./features/cart/index";
 export { getCartOps, CART_OPS_CHANGE_EVENT } from "./features/cart/utils/pending-ops";
 export type { CartOp } from "./features/cart/utils/pending-ops";
 export type { CartItem, CartItemMeta, CartData, GuestCartItem } from "./features/cart/index";
+export type { CartLineKind, CartGroupSource, CartLineMember, } from "./features/cart/schemas/firestore";
+export type { CartGroupLineRowProps } from "./features/cart/components/CartGroupLineRow";
 export { useAddresses, useCreateAddress, useUpdateAddress, useDeleteAddress, useSetDefaultAddress, useAddress } from "./features/account/index";
 export type { Address, AddressFormData } from "./features/account/index";
 export { AddressBook, AddressCard, AddressForm } from "./features/account/index";
@@ -262,6 +264,8 @@ export type { WishlistCapEventDetail } from "./features/wishlist/hooks/useWishli
 export { getGuestWishlistItems, addToGuestWishlist, removeFromGuestWishlist, isInGuestWishlist, clearGuestWishlist, getGuestWishlistCount, getGuestWishlistByType, } from "./features/wishlist/utils/guest-wishlist";
 export { InteractiveProductCard } from "./features/products/index";
 export type { InteractiveProductCardProps } from "./features/products/index";
+export { GroupedListingDetailView } from "./features/grouped/components/GroupedListingDetailView";
+export type { GroupedListingDetailViewProps } from "./features/grouped/components/GroupedListingDetailView";
 export { GroupMemberPicker } from "./features/products/components/GroupMemberPicker";
 export type { GroupMemberPickerProps, GroupPickerMember, } from "./features/products/components/GroupMemberPicker";
 export { MarketplaceBundleCard } from "./features/products/components/MarketplaceBundleCard";
@@ -420,8 +424,8 @@ export type { BecomeSellerResult, SellerCreateProductViewProps, SellerEditProduc
 export { BecomeSellerView } from "./features/account/index";
 export type { BidDocument } from "./features/auctions/index";
 export type { ClaimedCouponDocument } from "./features/promotions/schemas";
-export { groupOrderItemsByBundle } from "./features/orders/index";
-export type { BundleOrderGroup, OutOfStockPolicy } from "./features/orders/index";
+export { groupOrderItemsByLine } from "./features/orders/index";
+export type { LineOrderGroup, OutOfStockPolicy } from "./features/orders/index";
 export { MediaUploadField } from "./features/media/index";
 export { PrizeRevealModal } from "./features/products/components/PrizeRevealModal";
 export { useProduct } from "./features/products/index";

package/dist/client.js

@@ -260,7 +260,7 @@ export { PAGE_VIEW_ENTITY_TYPES } from "./features/analytics/types";
 export { AuctionBidsTable } from "./features/auctions/components/AuctionBidsTable";
 export { ProtectedRoute, AuthStatusPanel, ForgotPasswordView, LoginForm, RegisterForm, ResetPasswordView, VerifyEmailView } from "./features/auth/index";
 export { useLogout, useLogin, useGoogleLogin, useLinkGoogleAccount, useRegister, useForgotPassword, useResetPassword, useVerifyEmail, useChangeEmail } from "./features/auth/index";
-export { CartView, CartItemRow, CartSummary, CartPriceBreakdown, CartDrawer, CheckoutView, CheckoutSuccessView, CheckoutAddressStep, useGuestCart, useCartCount, useAddToCart, useCart, useGuestCartMerge, useCartQuery } from "./features/cart/index";
+export { CartView, CartItemRow, CartGroupLineRow, CartSummary, CartPriceBreakdown, CartDrawer, CheckoutView, CheckoutSuccessView, CheckoutAddressStep, useGuestCart, useCartCount, useAddToCart, useCart, useGuestCartMerge, useCartQuery } from "./features/cart/index";
 export { StoreAddonsPicker } from "./features/cart/index";
 export { getCartOps, CART_OPS_CHANGE_EVENT } from "./features/cart/utils/pending-ops";
 export { useAddresses, useCreateAddress, useUpdateAddress, useDeleteAddress, useSetDefaultAddress, useAddress } from "./features/account/index";
@@ -282,6 +282,7 @@ export { SyncManagerMount } from "./core/components/SyncManagerMount";
 export { useWishlistCount, useWishlistCountWithLimit, WISHLIST_CAP_EVENT } from "./features/wishlist/hooks/useWishlistCount";
 export { getGuestWishlistItems, addToGuestWishlist, removeFromGuestWishlist, isInGuestWishlist, clearGuestWishlist, getGuestWishlistCount, getGuestWishlistByType, } from "./features/wishlist/utils/guest-wishlist";
 export { InteractiveProductCard } from "./features/products/index";
+export { GroupedListingDetailView } from "./features/grouped/components/GroupedListingDetailView";
 export { GroupMemberPicker } from "./features/products/components/GroupMemberPicker";
 export { MarketplaceBundleCard } from "./features/products/components/MarketplaceBundleCard";
 export { CompareOverlay } from "./features/products/components/CompareOverlay";
@@ -405,7 +406,7 @@ export { SpinWheelView, EventRaffleEntryForm } from "./features/events/index";
 export { Card, CardBody } from "./ui/index";
 export { SellerCouponsView, SellerCreateProductView, SellerEditProductView, useBecomeSeller, } from "./features/seller/index";
 export { BecomeSellerView } from "./features/account/index";
-export { groupOrderItemsByBundle } from "./features/orders/index";
+export { groupOrderItemsByLine } from "./features/orders/index";
 export { MediaUploadField } from "./features/media/index";
 export { PrizeRevealModal } from "./features/products/components/PrizeRevealModal";
 export { useProduct } from "./features/products/index";

package/dist/constants/api-endpoints.d.ts

@@ -246,8 +246,6 @@ export declare const CART_ENDPOINTS: {
      * discriminated union would put this feature's blast radius on it.
      */
     readonly GROUP: "/api/cart/group";
-    /** Replace a grouped line's member quantities (whole array, not a delta). */
-    readonly GROUP_MEMBERS: (itemId: string) => string;
 };
 export declare const CATEGORY_ENDPOINTS: {
     readonly LIST: "/api/categories";
@@ -711,8 +709,6 @@ export declare const API_ENDPOINTS: {
          * discriminated union would put this feature's blast radius on it.
          */
         readonly GROUP: "/api/cart/group";
-        /** Replace a grouped line's member quantities (whole array, not a delta). */
-        readonly GROUP_MEMBERS: (itemId: string) => string;
     };
     readonly CATEGORIES: {
         readonly LIST: "/api/categories";
@@ -1178,8 +1174,6 @@ export declare const API_ROUTES: {
          * discriminated union would put this feature's blast radius on it.
          */
         readonly GROUP: "/api/cart/group";
-        /** Replace a grouped line's member quantities (whole array, not a delta). */
-        readonly GROUP_MEMBERS: (itemId: string) => string;
     };
     readonly CATEGORIES: {
         readonly LIST: "/api/categories";

package/dist/constants/api-endpoints.js

@@ -286,8 +286,6 @@ export const CART_ENDPOINTS = {
      * discriminated union would put this feature's blast radius on it.
      */
     GROUP: "/api/cart/group",
-    /** Replace a grouped line's member quantities (whole array, not a delta). */
-    GROUP_MEMBERS: (itemId) => `/api/cart/${encodeURIComponent(itemId)}/members`,
 };
 // ---------------------------------------------------------------------------
 // Categories

package/dist/features/analytics/types.d.ts

@@ -2,5 +2,5 @@
  * page-views.repository.ts (server-only, imports firebase-admin) so the
  * client-side tracker component can import just this without pulling
  * firebase-admin into the client bundle. */
-export declare const PAGE_VIEW_ENTITY_TYPES: readonly ["product", "store", "category", "homepage", "auction", "review", "user-profile", "blog", "event", "pre-order", "prize-draw", "classified", "digital-code", "live", "bundle"];
+export declare const PAGE_VIEW_ENTITY_TYPES: readonly ["product", "store", "category", "homepage", "auction", "review", "user-profile", "blog", "event", "pre-order", "prize-draw", "classified", "digital-code", "live", "bundle", "grouped-listing"];
 export type PageViewEntityType = (typeof PAGE_VIEW_ENTITY_TYPES)[number];

package/dist/features/analytics/types.js

@@ -18,4 +18,7 @@ export const PAGE_VIEW_ENTITY_TYPES = [
     "digital-code",
     "live",
     "bundle",
+    /** A `groupedListings` document's own page. Distinct from "bundle" — a
+     *  bundle is a priced, all-or-nothing set; a group is pick-as-you-wish. */
+    "grouped-listing",
 ];

package/dist/features/cart/components/CartGroupLineRow.d.ts

@@ -0,0 +1,42 @@
+/**
+ * CartGroupLineRow — one cart line that stands for several products.
+ *
+ * Two shapes behind one component, because the difference is exactly the
+ * bundle-vs-group distinction and putting them in separate files would let it
+ * drift:
+ *
+ *   BUNDLE — all-or-nothing. Members render read-only; the only stepper is the
+ *            line's own and it means COPIES OF THE BUNDLE.
+ *   GROUP  — pick-as-you-wish. One stepper PER MEMBER, and no line-level
+ *            stepper at all (a group line's `quantity` is pinned to 1, so a
+ *            second multiplier would double-count).
+ *
+ * Never render both steppers. That is the invariant on `CartLineMember`
+ * expressed in UI.
+ */
+import React from "react";
+import type { CartLineMember } from "../schemas";
+export interface CartGroupLineRowProps {
+    /** Line identity (`CartItemDocument.itemId`). */
+    id: string;
+    title: string;
+    image?: string;
+    currency?: string;
+    /** `"bundle"` → copies stepper; `"group"` → per-member steppers. */
+    lineKind: "bundle" | "group";
+    members: CartLineMember[];
+    /** Copies of the whole line. Bundles only — a group line is always 1. */
+    quantity: number;
+    /** Detail href for the bundle / group itself. */
+    href?: string;
+    locked?: boolean;
+    /** Bundle only: change the number of copies. */
+    onQtyChange?: (id: string, qty: number) => void;
+    /** Group only: change one member's per-copy quantity (0 removes it). */
+    onMemberQtyChange?: (id: string, productId: string, qty: number) => void;
+    onRemove?: (id: string) => void;
+    /** Per-member stock ceiling, keyed by productId. */
+    maxByProductId?: Record<string, number>;
+    variant?: "card" | "row";
+}
+export declare function CartGroupLineRow({ id, title, image, currency, lineKind, members, quantity, href, locked, onQtyChange, onMemberQtyChange, onRemove, maxByProductId, variant, }: CartGroupLineRowProps): React.JSX.Element;

package/dist/features/cart/components/CartGroupLineRow.js

@@ -0,0 +1,33 @@
+"use client";
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * CartGroupLineRow — one cart line that stands for several products.
+ *
+ * Two shapes behind one component, because the difference is exactly the
+ * bundle-vs-group distinction and putting them in separate files would let it
+ * drift:
+ *
+ *   BUNDLE — all-or-nothing. Members render read-only; the only stepper is the
+ *            line's own and it means COPIES OF THE BUNDLE.
+ *   GROUP  — pick-as-you-wish. One stepper PER MEMBER, and no line-level
+ *            stepper at all (a group line's `quantity` is pinned to 1, so a
+ *            second multiplier would double-count).
+ *
+ * Never render both steppers. That is the invariant on `CartLineMember`
+ * expressed in UI.
+ */
+import { useState } from "react";
+import { Button, Div, Row, Span, Stack, Text, TextLink } from "../../../ui";
+import { QuantityStepper } from "../../../ui/components/QuantityStepper";
+import { MediaImage } from "../../media/MediaImage";
+import { formatCurrency } from "../../../utils/number.formatter";
+import { ACTIONS } from "../../../_internal/shared/actions/action-registry";
+const __O = { hidden: "overflow-hidden" };
+export function CartGroupLineRow({ id, title, image, currency = "INR", lineKind, members, quantity, href, locked = false, onQtyChange, onMemberQtyChange, onRemove, maxByProductId, variant = "card", }) {
+    const [isOpen, setIsOpen] = useState(false);
+    const isRow = variant === "row";
+    const onePrice = members.reduce((sum, m) => sum + m.unitPrice * m.quantity, 0);
+    const lineTotal = onePrice * quantity;
+    const unitCount = members.reduce((sum, m) => sum + m.quantity, 0);
+    return (_jsxs(Div, { layout: "flex", gap: isRow ? "3" : "4", surface: isRow ? "none" : "card", padding: isRow ? "none" : "sm", className: "min-w-0", children: [_jsx(Div, { surface: "muted", className: `relative ${isRow ? "h-16 w-16" : "h-20 w-20"} flex-shrink-0 ${__O.hidden}`, rounded: "lg", children: image && _jsx(MediaImage, { src: image, alt: title, size: "thumbnail" }) }), _jsxs(Stack, { justify: "between", gap: "xs", className: "flex-1 min-w-0", children: [_jsxs(Row, { gap: "xs", align: "start", className: "min-w-0", children: [href ? (_jsx(TextLink, { href: href, weight: "medium", className: "text-[var(--appkit-color-text)] hover:underline underline-offset-2 line-clamp-2", children: title })) : (_jsx(Text, { truncate: 2, weight: "medium", color: "primary", children: title })), _jsx(Span, { padding: "pill-2xs", surface: "subtle", color: "muted", rounded: "default", className: "flex-shrink-0 text-[10px] tracking-wide", transform: "uppercase", children: lineKind === "bundle" ? "Bundle" : "Group" })] }), _jsxs(Button, { type: "button", variant: "ghost", size: "sm", onClick: () => setIsOpen((v) => !v), "aria-expanded": isOpen, className: "self-start text-[length:var(--appkit-text-xs)] text-[var(--appkit-color-primary)] hover:underline", children: [isOpen ? "▼" : "▶", " ", members.length, " item", members.length === 1 ? "" : "s", unitCount !== members.length ? ` · ${unitCount} units` : ""] }), isOpen && (_jsx(Stack, { gap: "xs", className: "w-full", children: members.map((m) => (_jsxs(Row, { gap: "sm", align: "center", justify: "between", className: "min-w-0", children: [_jsxs(Row, { gap: "sm", align: "center", className: "min-w-0 flex-1", children: [_jsx(Div, { className: `h-10 w-10 flex-shrink-0 ${__O.hidden}`, rounded: "default", surface: "muted", children: m.image && _jsx(MediaImage, { src: m.image, alt: m.title, size: "thumbnail" }) }), _jsxs(Stack, { gap: "none", className: "min-w-0", children: [_jsx(Text, { size: "sm", truncate: 1, color: "primary", children: m.title }), _jsxs(Text, { size: "xs", color: "muted", children: [formatCurrency(m.unitPrice, currency), lineKind === "bundle" ? ` × ${m.quantity}` : ""] })] })] }), lineKind === "group" && onMemberQtyChange && !locked && (_jsxs(Row, { gap: "xs", align: "center", className: "flex-shrink-0", children: [_jsx(QuantityStepper, { value: m.quantity, onChange: (next) => onMemberQtyChange(id, m.productId, next), min: 0, max: maxByProductId?.[m.productId], ariaLabel: `Quantity for ${m.title}`, decrementLabel: ACTIONS.CART["decrease-quantity"].ariaLabel, incrementLabel: ACTIONS.CART["increase-quantity"].ariaLabel }), _jsx(Button, { type: "button", variant: "ghost", size: "sm", "aria-label": ACTIONS.CART["remove-group-member"].ariaLabel, onClick: () => onMemberQtyChange(id, m.productId, 0), className: "text-[var(--appkit-color-text-faint)] transition hover:text-error", children: "\u2715" })] })), lineKind === "bundle" && (_jsxs(Span, { size: "xs", color: "muted", className: "flex-shrink-0", children: ["\u00D7 ", m.quantity] }))] }, m.productId))) })), _jsxs(Row, { justify: "between", gap: "sm", className: "min-w-0", children: [_jsx(Text, { weight: "semibold", className: "text-[var(--appkit-color-text)]", children: formatCurrency(lineTotal, currency) }), lineKind === "bundle" && onQtyChange && !locked && (_jsx(QuantityStepper, { value: quantity, onChange: (next) => onQtyChange(id, next), min: 1, ariaLabel: `Number of copies of ${title}`, decrementLabel: ACTIONS.CART["decrease-quantity"].ariaLabel, incrementLabel: ACTIONS.CART["increase-quantity"].ariaLabel }))] })] }), onRemove && !locked && (_jsx(Button, { onClick: () => onRemove(id), variant: "ghost", size: "sm", "aria-label": ACTIONS.CART["remove-item"].ariaLabel, className: "self-start text-[var(--appkit-color-text-faint)] transition hover:text-error", children: "\u2715" }))] }));
+}

package/dist/features/cart/components/index.d.ts

@@ -1,4 +1,6 @@
 export { CartItemRow, CartDrawer } from "./CartDrawer";
+export { CartGroupLineRow } from "./CartGroupLineRow";
+export type { CartGroupLineRowProps } from "./CartGroupLineRow";
 export { CartView } from "./CartView";
 export type { CartViewProps, CartOrderGroup } from "./CartView";
 export { CartSummary } from "./CartSummary";

package/dist/features/cart/components/index.js

@@ -1,4 +1,5 @@
 export { CartItemRow, CartDrawer } from "./CartDrawer";
+export { CartGroupLineRow } from "./CartGroupLineRow";
 export { CartView } from "./CartView";
 export { CartSummary } from "./CartSummary";
 export { StoreAddonsPicker } from "./StoreAddonsPicker";

package/dist/features/cart/repository/cart.repository.js

@@ -291,6 +291,12 @@ export class CartRepository extends BaseRepository {
                 throw new NotFoundError(ERR_CART_ITEM_NOT_FOUND);
             if (cart.items[itemIndex].locked)
                 throw new ValidationError(ERR_CART_ITEM_LOCKED);
+            // A grouped line's quantity is pinned to 1 — the member quantities carry
+            // the whole selection, so a copies multiplier on top would double every
+            // price, tax and stock decrement. Edit its members instead.
+            if (cart.items[itemIndex].lineKind === "group") {
+                throw new ValidationError("Change the quantities of the individual items in this group instead.");
+            }
             const items = [...cart.items];
             items[itemIndex] = {
                 ...items[itemIndex],

package/dist/features/cart/schemas/firestore.d.ts

@@ -48,8 +48,13 @@ export interface CartLineMember {
     unitPrice: number;
     title: string;
     image?: string;
-    /** Snapshot for per-member GST proration at checkout (`lineTaxComponentsFor`). */
-    gstRate?: number;
+    /**
+     * Snapshot for per-member GST proration at checkout (`lineTaxComponentsFor`).
+     * Same literal union as `ProductDocument.gstRate` on purpose — a loose
+     * `number` here would not survive assignment to `OrderDocumentItem` and would
+     * only be fixed by a cast, which is how a wrong rate reaches an invoice.
+     */
+    gstRate?: 0 | 5 | 12 | 18 | 28;
     hsnCode?: string;
     listingType?: ListingType;
 }

package/dist/features/categories/components/BundleBuyNowCta.d.ts

@@ -1,9 +1,16 @@
 /**
- * BundleBuyNowCta — direct-checkout CTA for bundle detail pages.
+ * BundleBuyNowCta — purchase CTAs for bundle detail pages.
  *
- * Replaces BundleAddToCartCta (deleted). Bundles bypass the cart and go
- * straight to checkout via the `directBundleCheckoutAction` server action.
- * No qty input — bundles are always qty=1 per checkout.
+ * A bundle is ALL-OR-NOTHING: its members are not pickable, and the only
+ * quantity the buyer controls is how many COPIES of the whole bundle they want.
+ * That is why there is one stepper here and no per-member controls anywhere on
+ * the bundle page — the mirror image of `GroupMemberPicker`, which has
+ * per-member steppers and no line-level one.
+ *
+ * Two CTAs, not one. "Buy now" adds and jumps straight to checkout (the
+ * pre-existing express path). "Add to cart" adds and stays — without it a
+ * bundle could never sit in the cart to be edited, because the only route in
+ * pushed the buyer past the cart immediately.
  */
 import React from "react";
 export interface BundleBuyNowCtaProps {
@@ -11,8 +18,14 @@ export interface BundleBuyNowCtaProps {
     outOfStock?: boolean;
     onBuyNow: (input: {
         bundleSlug: string;
+        quantity: number;
+    }) => Promise<unknown>;
+    /** Adds without leaving the page. Omit to render Buy-now only. */
+    onAddToCart?: (input: {
+        bundleSlug: string;
+        quantity: number;
     }) => Promise<unknown>;
     /** Renders a smaller single-line button suited for list cards. */
     compact?: boolean;
 }
-export declare function BundleBuyNowCta({ bundleSlug, outOfStock, onBuyNow, compact, }: BundleBuyNowCtaProps): React.JSX.Element;
+export declare function BundleBuyNowCta({ bundleSlug, outOfStock, onBuyNow, onAddToCart, compact, }: BundleBuyNowCtaProps): React.JSX.Element;