@mohasinac/appkit 4.24.0 → 4.26.0

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

@@ -239,6 +239,13 @@ export declare const CART_ENDPOINTS: {
     /** Per-store paid add-on selections — the source of truth for what's charged. */
     readonly ADDONS: "/api/cart/addons";
     readonly COUPON: "/api/cart/coupon";
+    /**
+     * Add a buyer-assembled group selection as ONE line. Separate from `GET`'s
+     * POST on purpose: that is the hot path behind every product card's
+     * Add-to-cart, and widening its `{productId, quantity}` schema into a
+     * discriminated union would put this feature's blast radius on it.
+     */
+    readonly GROUP: "/api/cart/group";
 };
 export declare const CATEGORY_ENDPOINTS: {
     readonly LIST: "/api/categories";
@@ -695,6 +702,13 @@ export declare const API_ENDPOINTS: {
         /** Per-store paid add-on selections — the source of truth for what's charged. */
         readonly ADDONS: "/api/cart/addons";
         readonly COUPON: "/api/cart/coupon";
+        /**
+         * Add a buyer-assembled group selection as ONE line. Separate from `GET`'s
+         * POST on purpose: that is the hot path behind every product card's
+         * Add-to-cart, and widening its `{productId, quantity}` schema into a
+         * discriminated union would put this feature's blast radius on it.
+         */
+        readonly GROUP: "/api/cart/group";
     };
     readonly CATEGORIES: {
         readonly LIST: "/api/categories";
@@ -1153,6 +1167,13 @@ export declare const API_ROUTES: {
         /** Per-store paid add-on selections — the source of truth for what's charged. */
         readonly ADDONS: "/api/cart/addons";
         readonly COUPON: "/api/cart/coupon";
+        /**
+         * Add a buyer-assembled group selection as ONE line. Separate from `GET`'s
+         * POST on purpose: that is the hot path behind every product card's
+         * Add-to-cart, and widening its `{productId, quantity}` schema into a
+         * discriminated union would put this feature's blast radius on it.
+         */
+        readonly GROUP: "/api/cart/group";
     };
     readonly CATEGORIES: {
         readonly LIST: "/api/categories";

package/dist/constants/api-endpoints.js

@@ -279,6 +279,13 @@ export const CART_ENDPOINTS = {
     /** Per-store paid add-on selections — the source of truth for what's charged. */
     ADDONS: "/api/cart/addons",
     COUPON: "/api/cart/coupon",
+    /**
+     * Add a buyer-assembled group selection as ONE line. Separate from `GET`'s
+     * POST on purpose: that is the hot path behind every product card's
+     * Add-to-cart, and widening its `{productId, quantity}` schema into a
+     * discriminated union would put this feature's blast radius on it.
+     */
+    GROUP: "/api/cart/group",
 };
 // ---------------------------------------------------------------------------
 // Categories

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

@@ -54,32 +54,16 @@ export declare const NOTIFICATION_FIELDS: {
     readonly RELATED_TYPE: "relatedType";
     readonly CREATED_AT: "createdAt";
     readonly UPDATED_AT: "updatedAt";
-    readonly TYPE_VALUES: {
-        readonly ORDER_PLACED: NotificationType;
-        readonly ORDER_CONFIRMED: NotificationType;
-        readonly ORDER_SHIPPED: NotificationType;
-        readonly ORDER_DELIVERED: NotificationType;
-        readonly ORDER_CANCELLED: NotificationType;
-        readonly BID_PLACED: NotificationType;
-        readonly BID_OUTBID: NotificationType;
-        readonly BID_WON: NotificationType;
-        readonly BID_LOST: NotificationType;
-        readonly AUCTION_ENDED: NotificationType;
-        readonly REVIEW_APPROVED: NotificationType;
-        readonly REVIEW_REPLIED: NotificationType;
-        readonly PRODUCT_AVAILABLE: NotificationType;
-        readonly PROMOTION: NotificationType;
-        readonly SYSTEM: NotificationType;
-        readonly WELCOME: NotificationType;
-        readonly OFFER_RECEIVED: NotificationType;
-        readonly OFFER_RESPONDED: NotificationType;
-        readonly OFFER_EXPIRED: NotificationType;
-        readonly OFFER_COUNTER_ACCEPTED: NotificationType;
-        readonly REFUND_INITIATED: NotificationType;
-        readonly ACCOUNT_ACTION: NotificationType;
-        readonly PRIZE_WON: NotificationType;
-        readonly PRIZE_REVEAL_EXPIRED: NotificationType;
-    };
+    /**
+     * SCREAMING_SNAKE accessors, DERIVED from `NOTIFICATION_TYPE_VALUES`.
+     *
+     * This was a fifth hand-written copy of the union — 24 of the 28 values,
+     * missing `emi_installment_due_soon`, `emi_installment_overdue`,
+     * `payment_review` and `catalogue_images_stale` — and every entry carried an
+     * `as NotificationType` cast, which is precisely the assertion that lets a
+     * wrong string through. Built from the array now, so it cannot be short.
+     */
+    readonly TYPE_VALUES: { [K in NotificationType as Uppercase<K>]: K; };
     readonly PRIORITY_VALUES: {
         readonly LOW: NotificationPriority;
         readonly NORMAL: NotificationPriority;

package/dist/features/admin/schemas/firestore.js

@@ -110,32 +110,16 @@ export const NOTIFICATION_FIELDS = {
     RELATED_TYPE: "relatedType",
     CREATED_AT: "createdAt",
     UPDATED_AT: "updatedAt",
-    TYPE_VALUES: {
-        ORDER_PLACED: "order_placed",
-        ORDER_CONFIRMED: "order_confirmed",
-        ORDER_SHIPPED: "order_shipped",
-        ORDER_DELIVERED: "order_delivered",
-        ORDER_CANCELLED: "order_cancelled",
-        BID_PLACED: "bid_placed",
-        BID_OUTBID: "bid_outbid",
-        BID_WON: "bid_won",
-        BID_LOST: "bid_lost",
-        AUCTION_ENDED: "auction_ended",
-        REVIEW_APPROVED: "review_approved",
-        REVIEW_REPLIED: "review_replied",
-        PRODUCT_AVAILABLE: "product_available",
-        PROMOTION: "promotion",
-        SYSTEM: "system",
-        WELCOME: "welcome",
-        OFFER_RECEIVED: "offer_received",
-        OFFER_RESPONDED: "offer_responded",
-        OFFER_EXPIRED: "offer_expired",
-        OFFER_COUNTER_ACCEPTED: "offer_counter_accepted",
-        REFUND_INITIATED: "refund_initiated",
-        ACCOUNT_ACTION: "account_action",
-        PRIZE_WON: "prize_won",
-        PRIZE_REVEAL_EXPIRED: "prize_reveal_expired",
-    },
+    /**
+     * SCREAMING_SNAKE accessors, DERIVED from `NOTIFICATION_TYPE_VALUES`.
+     *
+     * This was a fifth hand-written copy of the union — 24 of the 28 values,
+     * missing `emi_installment_due_soon`, `emi_installment_overdue`,
+     * `payment_review` and `catalogue_images_stale` — and every entry carried an
+     * `as NotificationType` cast, which is precisely the assertion that lets a
+     * wrong string through. Built from the array now, so it cannot be short.
+     */
+    TYPE_VALUES: Object.fromEntries(NOTIFICATION_TYPE_VALUES.map((v) => [v.toUpperCase(), v])),
     PRIORITY_VALUES: {
         LOW: "low",
         NORMAL: "normal",

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/actions/cart-actions.d.ts

@@ -4,7 +4,7 @@
  * Pure business functions — auth, rate-limiting, and Next.js specifics
  * are handled by the calling server action in the consumer.
  */
-import type { AddToCartInput, CartDocument, UpdateCartItemInput } from "../schemas";
+import type { AddToCartInput, CartDocument, CartGroupSource, UpdateCartItemInput, UpdateCartGroupMembersInput } from "../schemas";
 /**
  * Lane gate. While a higher-obligation lane (a won auction, then an accepted
  * offer) is outstanding, no NEW shopping may be added — otherwise the buyer can
@@ -24,6 +24,30 @@ export declare function assertCanAddNewItems(userId: string): Promise<CartDocume
 export declare function addItemToCart(userId: string, input: AddToCartInput): Promise<CartDocument>;
 /** Error code the client maps to a lane-aware message. */
 export declare const CART_LANE_BLOCKED = "CART_LANE_BLOCKED";
+/** Max members one grouped line may hold. Keeps the batch read bounded (Rule #6). */
+export declare const GROUP_LINE_MAX_MEMBERS = 20;
+export interface AddGroupLineToCartInput {
+    /** `product.groupId` for a product group, or the `groupedListings` doc id. */
+    groupId: string;
+    groupSource: CartGroupSource;
+    /** Ids and quantities ONLY — every other field is re-resolved server-side. */
+    members: Array<{
+        productId: string;
+        quantity: number;
+    }>;
+}
+/**
+ * Add a buyer-assembled selection of group members as ONE cart line.
+ *
+ * The client sends ids and quantities and nothing else. Accepting a price, a
+ * title or an image from the browser would be a ₹1-group exploit; every
+ * snapshot below is read from Firestore here.
+ *
+ * A rejected member fails the WHOLE request, naming the offender. Silently
+ * dropping it would hand the buyer a line that quietly isn't what they picked —
+ * the "wrong data, no error" failure nobody can report.
+ */
+export declare function addGroupLineToCart(userId: string, input: AddGroupLineToCartInput): Promise<CartDocument>;
 /**
  * Won-auction lines are non-removable and fixed-quantity — the buyer committed
  * to the purchase by bidding, and letting them delete it would turn every
@@ -34,6 +58,12 @@ export declare const CART_LANE_BLOCKED = "CART_LANE_BLOCKED";
  * and the offer simply lapses at its `checkoutDeadline`.
  */
 export declare function updateCartItem(userId: string, itemId: string, input: UpdateCartItemInput): Promise<CartDocument>;
+/**
+ * Replace a grouped line's member quantities. A member set to 0 is dropped;
+ * dropping the last one removes the line (enforced in the repository so a
+ * forgetful caller can't leave an empty ghost line behind).
+ */
+export declare function updateCartGroupMembers(userId: string, itemId: string, input: UpdateCartGroupMembersInput): Promise<CartDocument>;
 export declare function removeCartItem(userId: string, itemId: string): Promise<CartDocument>;
 export declare function clearCart(userId: string): Promise<CartDocument>;
 export declare function mergeGuestCart(userId: string, items: Array<{

package/dist/features/cart/actions/cart-actions.js

@@ -12,6 +12,8 @@ import { storeRepository } from "../../stores/repository/store.repository";
 import { normalizeListingType } from "../../products/utils/listing-type";
 import { getDefaultCurrency } from "../../../core/baseline-resolver";
 import { CART_LANE, activeLane, canAddNewItems, } from "../../../_internal/shared/checkout/lanes";
+import { CART_MAX_ITEMS } from "../../../constants/limits";
+import { getExpandedDecrements, validateCartItemStock, } from "../../../_internal/server/features/checkout/bundle-expansion";
 /**
  * Product documents don't always carry a denormalized `storeName` — the
  * create routes only set it when the caller explicitly passes one, so
@@ -67,6 +69,159 @@ export async function addItemToCart(userId, input) {
 }
 /** Error code the client maps to a lane-aware message. */
 export const CART_LANE_BLOCKED = "CART_LANE_BLOCKED";
+/** Max members one grouped line may hold. Keeps the batch read bounded (Rule #6). */
+export const GROUP_LINE_MAX_MEMBERS = 20;
+/**
+ * Add a buyer-assembled selection of group members as ONE cart line.
+ *
+ * The client sends ids and quantities and nothing else. Accepting a price, a
+ * title or an image from the browser would be a ₹1-group exploit; every
+ * snapshot below is read from Firestore here.
+ *
+ * A rejected member fails the WHOLE request, naming the offender. Silently
+ * dropping it would hand the buyer a line that quietly isn't what they picked —
+ * the "wrong data, no error" failure nobody can report.
+ */
+export async function addGroupLineToCart(userId, input) {
+    const { groupId, groupSource, members } = input;
+    if (!groupId)
+        throw new ValidationError("A group id is required.");
+    if (!members.length)
+        throw new ValidationError("Select at least one item to add.");
+    if (members.length > GROUP_LINE_MAX_MEMBERS) {
+        throw new ValidationError(`A single group line can hold at most ${GROUP_LINE_MAX_MEMBERS} different items.`);
+    }
+    for (const m of members) {
+        if (!Number.isInteger(m.quantity) || m.quantity < 1) {
+            throw new ValidationError("Every selected item needs a whole quantity of at least 1.");
+        }
+    }
+    if (new Set(members.map((m) => m.productId)).size !== members.length) {
+        throw new ValidationError("The same item was selected twice.");
+    }
+    const cart = await assertCanAddNewItems(userId);
+    // One batched read for the whole selection — capped at 20 above, so well
+    // inside the per-request Firestore budget.
+    const docs = await Promise.all(members.map((m) => productRepository.findById(m.productId).catch(() => null)));
+    const productById = new Map(members.map((m, i) => [m.productId, docs[i]]));
+    const { getListingRule } = await import("../../../_internal/shared/checkout/rules");
+    const { ProductStatusValues } = await import("../../products/schemas/firestore");
+    const resolved = [];
+    for (const m of members) {
+        const product = productById.get(m.productId);
+        if (!product) {
+            throw new ValidationError(`One of the selected items no longer exists.`);
+        }
+        if (product.status !== ProductStatusValues.PUBLISHED || product.isSold) {
+            throw new ValidationError(`"${product.title}" is no longer available.`);
+        }
+        // Membership. Without this a caller could staple arbitrary products into
+        // one line and buy them under a group's identity.
+        const belongs = groupSource === "product-group"
+            ? product.groupId === groupId
+            : await isGroupedListingMember(groupId, product.id);
+        if (!belongs) {
+            throw new ValidationError(`"${product.title}" is not part of this group.`);
+        }
+        const listingType = normalizeListingType(product);
+        const rule = getListingRule(listingType);
+        if (!rule.cartEligible) {
+            throw new ValidationError(`"${product.title}" can't be added to the cart. ${rule.cartIneligibleHint ?? ""}`.trim());
+        }
+        if ((product.availableQuantity ?? 0) < m.quantity) {
+            throw new ValidationError(`Only ${product.availableQuantity ?? 0} left of "${product.title}".`);
+        }
+        resolved.push({
+            productId: product.id,
+            quantity: m.quantity,
+            unitPrice: product.price,
+            title: product.title,
+            image: product.images?.[0] ?? product.mainImage,
+            gstRate: product.gstRate,
+            hsnCode: product.hsnCode,
+            listingType,
+        });
+    }
+    // Single-store rule. `storeId` is the order-splitting key AND the key the
+    // per-store add-ons, coupons, shipping and payout all hang off, so a line
+    // spanning two stores would break five things at once. The picker hides
+    // itself for a cross-store group; this is the server-side half of that.
+    const storeIds = new Set(resolved.map((r) => productById.get(r.productId)?.storeId ?? ""));
+    if (storeIds.size > 1) {
+        throw new ValidationError("These items are sold by different sellers, so they can't be combined into one cart line.");
+    }
+    const storeId = [...storeIds][0] ?? "";
+    const first = productById.get(resolved[0].productId);
+    // A one-member selection is just an ordinary line: 1 item × qty N is exactly
+    // what a normal cart line already means, and routing it through the group
+    // path would create a second representation of the same thing.
+    if (resolved.length === 1) {
+        return addItemToCart(userId, {
+            productId: first.id,
+            productTitle: first.title,
+            productImage: first.images?.[0] ?? first.mainImage,
+            price: first.price,
+            currency: first.currency,
+            quantity: resolved[0].quantity,
+            storeId,
+            storeName: first.storeName ?? "",
+            listingType: resolved[0].listingType ?? "standard",
+        });
+    }
+    // A grouped line counts as ONE item against the distinct-items cap.
+    if (cart.items.length >= CART_MAX_ITEMS) {
+        throw new ValidationError(`Cart full (${cart.items.length}/${CART_MAX_ITEMS}). Remove items to add new ones.`);
+    }
+    // Same stock check checkout will run, so add-time and checkout-time agree by
+    // construction rather than by two similar-looking implementations.
+    const candidate = {
+        itemId: "candidate",
+        productId: groupId,
+        quantity: 1,
+        groupMembers: resolved,
+    };
+    const expansion = getExpandedDecrements([...cart.items, candidate]);
+    const shortfall = validateCartItemStock(candidate, new Map([...productById.entries()].filter(([, p]) => p !== null)), expansion.decrements);
+    if (shortfall) {
+        const short = productById.get(shortfall.productId);
+        throw new ValidationError(`Only ${shortfall.availableQty} left of "${short?.title ?? shortfall.productId}" once your cart is counted.`);
+    }
+    const groupTitle = await resolveGroupTitle(groupId, groupSource, first ?? null);
+    return cartRepository.addGroupLine(userId, {
+        productId: groupId,
+        productTitle: groupTitle,
+        productImage: resolved[0].image ?? "",
+        currency: first?.currency ?? getDefaultCurrency(),
+        // Pinned to 1: member quantities carry the whole selection, and a copies
+        // multiplier on top would double-count. See the invariant on CartLineMember.
+        quantity: 1,
+        storeId,
+        storeName: await resolveStoreName(storeId, first?.storeName),
+        listingType: "standard",
+        lineKind: "group",
+        groupSource,
+        groupId,
+        groupSlug: groupSource === "product-group" ? groupId : undefined,
+        groupTitle,
+        groupMembers: resolved,
+    });
+}
+/** Is this product listed on that `groupedListings` document? */
+async function isGroupedListingMember(groupId, productId) {
+    const { groupedListingsRepository } = await import("../../grouped/repository/grouped-listings.repository");
+    const group = await groupedListingsRepository.findById(groupId).catch(() => null);
+    return Boolean(group?.productIds?.includes(productId));
+}
+/** Display name for the line. Falls back to the parent product's group title. */
+async function resolveGroupTitle(groupId, groupSource, sample) {
+    if (groupSource === "grouped-listing") {
+        const { groupedListingsRepository } = await import("../../grouped/repository/grouped-listings.repository");
+        const group = await groupedListingsRepository.findById(groupId).catch(() => null);
+        if (group?.title)
+            return group.title;
+    }
+    return sample?.groupTitle ?? "Selected items";
+}
 /**
  * Won-auction lines are non-removable and fixed-quantity — the buyer committed
  * to the purchase by bidding, and letting them delete it would turn every
@@ -79,6 +234,14 @@ export const CART_LANE_BLOCKED = "CART_LANE_BLOCKED";
 export async function updateCartItem(userId, itemId, input) {
     return cartRepository.updateItem(userId, itemId, input);
 }
+/**
+ * Replace a grouped line's member quantities. A member set to 0 is dropped;
+ * dropping the last one removes the line (enforced in the repository so a
+ * forgetful caller can't leave an empty ghost line behind).
+ */
+export async function updateCartGroupMembers(userId, itemId, input) {
+    return cartRepository.updateGroupMembers(userId, itemId, input);
+}
 export async function removeCartItem(userId, itemId) {
     return cartRepository.removeItem(userId, itemId);
 }

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.d.ts

@@ -1,7 +1,7 @@
 import { type DocumentReference } from "firebase-admin/firestore";
 import type { DocumentSnapshot } from "../../../providers/db-firebase";
 import { BaseRepository, type FirebaseSieveResult, type SieveModel } from "../../../providers/db-firebase";
-import { type AddToCartInput, type CartAppliedCoupon, type CartDocument, type CartStoreAddons, type CartItemDocument, type UpdateCartItemInput } from "../schemas";
+import { type AddToCartInput, type CartAppliedCoupon, type CartDocument, type CartStoreAddons, type CartItemDocument, type AddGroupLineInput, type UpdateCartItemInput, type UpdateCartGroupMembersInput } from "../schemas";
 export declare class CartRepository extends BaseRepository<CartDocument> {
     private static readonly SIEVE_FIELDS;
     constructor();
@@ -12,6 +12,38 @@ export declare class CartRepository extends BaseRepository<CartDocument> {
     getOrCreate(userId: string): Promise<CartDocument>;
     createEmpty(userId: string): Promise<CartDocument>;
     addItem(userId: string, input: AddToCartInput): Promise<CartDocument>;
+    /**
+     * Price of ONE COPY of a multi-member line.
+     *
+     * Private and called at every write of `groupMembers`, so `item.price` cannot
+     * drift from the members it is supposed to summarise — no caller sets it, so
+     * no caller can forget it. That property is load-bearing well beyond this
+     * file: `getSubtotal`, the cart page's per-seller subtotal, and both lane
+     * subtotals all compute `price × quantity`, and a grouped line pins
+     * `quantity` to 1, so all four stay correct with no changes of their own.
+     */
+    private deriveLinePrice;
+    /**
+     * Create a multi-member line. Deliberately never merges into an existing
+     * line — see the note in `addItem`.
+     */
+    addGroupLine(userId: string, input: AddGroupLineInput): Promise<CartDocument>;
+    /**
+     * Replace a grouped line's member quantities.
+     *
+     * Takes the WHOLE array rather than a per-member delta: the cart is one
+     * Firestore document written with `set()`, so N per-member writes would be
+     * both a Rule #6 cost and a genuine lost-update race on a fast double-click.
+     *
+     * A member dropped to 0 is removed, and **a line left with no members is
+     * removed entirely** — enforced here rather than in the client, so a caller
+     * that forgets cannot leave an empty ghost line in the document.
+     *
+     * Only quantities move. Prices, titles and images are the snapshots taken
+     * server-side at add time and are never re-accepted from a caller; adding a
+     * NEW member is an add-to-cart, which has its own eligibility checks.
+     */
+    updateGroupMembers(userId: string, itemId: string, input: UpdateCartGroupMembersInput): Promise<CartDocument>;
     updateItem(userId: string, itemId: string, input: UpdateCartItemInput): Promise<CartDocument>;
     removeItem(userId: string, itemId: string): Promise<CartDocument>;
     clearCart(userId: string): Promise<CartDocument>;