@mohasinac/appkit 4.24.0 → 4.25.0

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

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

@@ -72,10 +72,17 @@ export class CartRepository extends BaseRepository {
             if (input.bidId && items.some((item) => item.bidId === input.bidId)) {
                 return cart;
             }
+            // A grouped line is never merged by productId. Two "Add selected"
+            // presses are two different selections, and merging them would silently
+            // rewrite the buyer's per-member quantities into a copy count. Bundles
+            // DO still merge — the same bundle twice genuinely means two copies.
             const isLockedLine = Boolean(input.offerId || input.bidId);
-            const existingIndex = isLockedLine
+            const existingIndex = isLockedLine || input.lineKind === "group"
                 ? -1
-                : items.findIndex((item) => item.productId === input.productId && !item.offerId && !item.bidId);
+                : items.findIndex((item) => item.productId === input.productId &&
+                    !item.offerId &&
+                    !item.bidId &&
+                    item.lineKind !== "group");
             if (existingIndex >= 0) {
                 items[existingIndex] = {
                     ...items[existingIndex],
@@ -115,6 +122,12 @@ export class CartRepository extends BaseRepository {
                     ...(input.bundleProductIds !== undefined && {
                         bundleProductIds: input.bundleProductIds,
                     }),
+                    ...(input.lineKind !== undefined && { lineKind: input.lineKind }),
+                    ...(input.groupSource !== undefined && { groupSource: input.groupSource }),
+                    ...(input.groupId !== undefined && { groupId: input.groupId }),
+                    ...(input.groupSlug !== undefined && { groupSlug: input.groupSlug }),
+                    ...(input.groupTitle !== undefined && { groupTitle: input.groupTitle }),
+                    ...(input.groupMembers !== undefined && { groupMembers: input.groupMembers }),
                     addedAt: new Date(),
                     updatedAt: new Date(),
                 };
@@ -137,6 +150,137 @@ export class CartRepository extends BaseRepository {
             throw new DatabaseError("Failed to add item to cart", error);
         }
     }
+    /**
+     * 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.
+     */
+    deriveLinePrice(members) {
+        const raw = members.reduce((sum, m) => sum + m.unitPrice * m.quantity, 0);
+        // audit-money-units-ok: decimal rupees throughout; rounding to 2dp, not paise conversion.
+        return Math.round(raw * 100) / 100;
+    }
+    /**
+     * Create a multi-member line. Deliberately never merges into an existing
+     * line — see the note in `addItem`.
+     */
+    async addGroupLine(userId, input) {
+        try {
+            if (!input.groupMembers.length) {
+                throw new ValidationError("A grouped cart line needs at least one member.");
+            }
+            const cart = await this.getOrCreate(userId);
+            const newItem = {
+                itemId: randomUUID(),
+                productId: input.productId,
+                productTitle: input.productTitle,
+                productImage: input.productImage,
+                price: this.deriveLinePrice(input.groupMembers),
+                currency: input.currency,
+                quantity: input.quantity,
+                storeId: input.storeId,
+                storeName: input.storeName,
+                listingType: input.listingType,
+                groupMembers: input.groupMembers,
+                ...(input.lineKind !== undefined && { lineKind: input.lineKind }),
+                ...(input.groupSource !== undefined && { groupSource: input.groupSource }),
+                ...(input.groupId !== undefined && { groupId: input.groupId }),
+                ...(input.groupSlug !== undefined && { groupSlug: input.groupSlug }),
+                ...(input.groupTitle !== undefined && { groupTitle: input.groupTitle }),
+                ...(input.bundleCategorySlug !== undefined && {
+                    bundleCategorySlug: input.bundleCategorySlug,
+                }),
+                addedAt: new Date(),
+                updatedAt: new Date(),
+            };
+            const updatedCart = {
+                ...cart,
+                items: [...cart.items, newItem],
+                updatedAt: new Date(),
+            };
+            await this.db
+                .collection(this.collection)
+                .doc(userId)
+                .set(prepareForFirestore(updatedCart));
+            return updatedCart;
+        }
+        catch (error) {
+            if (error instanceof DatabaseError || error instanceof ValidationError)
+                throw error;
+            throw new DatabaseError("Failed to add grouped line to cart", error);
+        }
+    }
+    /**
+     * 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.
+     */
+    async updateGroupMembers(userId, itemId, input) {
+        try {
+            const cart = await this.findByUserId(userId);
+            if (!cart)
+                throw new NotFoundError("Cart not found");
+            const itemIndex = cart.items.findIndex((item) => item.itemId === itemId);
+            if (itemIndex < 0)
+                throw new NotFoundError(ERR_CART_ITEM_NOT_FOUND);
+            const target = cart.items[itemIndex];
+            if (target.locked)
+                throw new ValidationError(ERR_CART_ITEM_LOCKED);
+            if (!target.groupMembers?.length) {
+                throw new ValidationError("This cart line has no members to update.");
+            }
+            const requested = new Map(input.groupMembers.map((m) => [m.productId, m.quantity]));
+            for (const productId of requested.keys()) {
+                if (!target.groupMembers.some((m) => m.productId === productId)) {
+                    throw new ValidationError("That item is not part of this cart line. Add it from the group page instead.");
+                }
+            }
+            const nextMembers = target.groupMembers
+                .map((m) => (requested.has(m.productId)
+                ? { ...m, quantity: requested.get(m.productId) }
+                : m))
+                .filter((m) => m.quantity > 0);
+            if (nextMembers.length === 0) {
+                return this.removeItem(userId, itemId);
+            }
+            const items = [...cart.items];
+            items[itemIndex] = {
+                ...target,
+                groupMembers: nextMembers,
+                price: this.deriveLinePrice(nextMembers),
+                updatedAt: new Date(),
+            };
+            const updatedCart = { ...cart, items, updatedAt: new Date() };
+            await this.db
+                .collection(this.collection)
+                .doc(userId)
+                .set(prepareForFirestore(updatedCart));
+            return updatedCart;
+        }
+        catch (error) {
+            if (error instanceof DatabaseError ||
+                error instanceof NotFoundError ||
+                error instanceof ValidationError) {
+                throw error;
+            }
+            throw new DatabaseError("Failed to update grouped cart line", error);
+        }
+    }
     async updateItem(userId, itemId, input) {
         try {
             const cart = await this.findByUserId(userId);

package/dist/features/products/components/GroupMemberPicker.d.ts

@@ -0,0 +1,46 @@
+/**
+ * GroupMemberPicker — pick which members of a group you want, and how many of
+ * each, then add the whole selection as ONE cart line.
+ *
+ * This is the "pick as you wish" half of the grouped-purchase model. Bundles
+ * are the other half and deliberately do NOT use this: a bundle is priced as a
+ * whole and is all-or-nothing, so its members render read-only and the only
+ * stepper is the bundle's own copy count.
+ *
+ * Two mount points, one component: the "Part of: …" modal/drawer on a product
+ * detail page, and the public `/groups/{slug}` page.
+ *
+ * The component talks to the API directly rather than taking an `onAdd` server
+ * action prop. That keeps `ShowGroupSection`'s `renderGroupSection` slot
+ * signature unchanged, which in turn leaves both detail-page views and both
+ * consumer pages untouched.
+ */
+import React from "react";
+import type { ListingType } from "../types";
+export interface GroupPickerMember {
+    id: string;
+    title: string;
+    price: number;
+    currency?: string;
+    images?: string[];
+    image?: string;
+    slug?: string;
+    listingType?: ListingType;
+    isGroupParent?: boolean;
+    condition?: string;
+    availableQuantity?: number;
+    storeId?: string;
+    storeName?: string;
+    isSold?: boolean;
+    status?: string;
+}
+export interface GroupMemberPickerProps {
+    groupId: string;
+    groupSource: "product-group" | "grouped-listing";
+    members: GroupPickerMember[];
+    /** Called after a successful add so the host can close its overlay. */
+    onAdded?: () => void;
+    /** Called when the API reports the caller isn't signed in. */
+    onAuthRequired?: () => void;
+}
+export declare function GroupMemberPicker({ groupId, groupSource, members, onAdded, onAuthRequired, }: GroupMemberPickerProps): React.JSX.Element;

package/dist/features/products/components/GroupMemberPicker.js

@@ -0,0 +1,108 @@
+"use client";
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+/**
+ * GroupMemberPicker — pick which members of a group you want, and how many of
+ * each, then add the whole selection as ONE cart line.
+ *
+ * This is the "pick as you wish" half of the grouped-purchase model. Bundles
+ * are the other half and deliberately do NOT use this: a bundle is priced as a
+ * whole and is all-or-nothing, so its members render read-only and the only
+ * stepper is the bundle's own copy count.
+ *
+ * Two mount points, one component: the "Part of: …" modal/drawer on a product
+ * detail page, and the public `/groups/{slug}` page.
+ *
+ * The component talks to the API directly rather than taking an `onAdd` server
+ * action prop. That keeps `ShowGroupSection`'s `renderGroupSection` slot
+ * signature unchanged, which in turn leaves both detail-page views and both
+ * consumer pages untouched.
+ */
+import { useMemo, useState } from "react";
+import { Alert, Button, Div, Row, Span, Stack, Table, Tbody, Td, Text, Th, Thead, Tr, } 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";
+import { CART_ENDPOINTS } from "../../../constants/api-endpoints";
+import { normalizeError } from "../../../errors/normalize";
+import { pluginFor } from "../../../_internal/shared/listing-types/_registry";
+import { normalizeListingType } from "../utils/listing-type";
+const __O = { xAuto: "overflow-x-auto", hidden: "overflow-hidden" };
+function memberImage(m) {
+    return m.image ?? m.images?.[0] ?? "";
+}
+function memberHref(m) {
+    return pluginFor(normalizeListingType(m)).detailRoute(m.slug ?? m.id);
+}
+/** A member the buyer cannot choose, and the reason to show instead of a stepper. */
+function blockedReason(m) {
+    if (m.isSold)
+        return "Sold";
+    if (m.status && m.status !== "published")
+        return "Unavailable";
+    if ((m.availableQuantity ?? 0) <= 0)
+        return "Out of stock";
+    // `cartLine: "blocked"` is how a classified / live listing says "contact the
+    // seller instead" — those can never join a cart line.
+    if (pluginFor(normalizeListingType(m)).cartLine === "blocked")
+        return "Not purchasable here";
+    return null;
+}
+export function GroupMemberPicker({ groupId, groupSource, members, onAdded, onAuthRequired, }) {
+    const [qty, setQty] = useState({});
+    const [isSaving, setIsSaving] = useState(false);
+    const [error, setError] = useState(null);
+    // A group whose members span sellers cannot become one cart line: storeId is
+    // the order-splitting key and the key per-store add-ons, coupons, shipping and
+    // payout all hang off. Rather than offer a button that always fails, the
+    // picker stands down and the table stays read-only.
+    const storeIds = useMemo(() => new Set(members.map((m) => m.storeId).filter(Boolean)), [members]);
+    const isCrossStore = storeIds.size > 1;
+    const selected = useMemo(() => members
+        .map((m) => ({ member: m, quantity: qty[m.id] ?? 0 }))
+        .filter((s) => s.quantity > 0), [members, qty]);
+    const selectedTotal = selected.reduce((sum, s) => sum + s.member.price * s.quantity, 0);
+    const selectedUnits = selected.reduce((sum, s) => sum + s.quantity, 0);
+    const currency = members[0]?.currency ?? "INR";
+    const handleAdd = async () => {
+        setError(null);
+        setIsSaving(true);
+        try {
+            const res = await fetch(CART_ENDPOINTS.GROUP, {
+                method: "POST",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify({
+                    groupId,
+                    groupSource,
+                    // Ids and quantities only. Prices and titles are re-resolved on the
+                    // server — anything else would be a price-manipulation hole.
+                    members: selected.map((s) => ({ productId: s.member.id, quantity: s.quantity })),
+                }),
+            });
+            if (res.status === 401) {
+                onAuthRequired?.();
+                return;
+            }
+            const json = (await res.json());
+            if (!res.ok || json.success === false) {
+                setError(json.error ?? "Couldn't add those items to your cart.");
+                return;
+            }
+            setQty({});
+            onAdded?.();
+        }
+        catch (err) {
+            void normalizeError(err);
+            setError("Couldn't reach the server. Please try again.");
+        }
+        finally {
+            setIsSaving(false);
+        }
+    };
+    return (_jsxs(Stack, { gap: "sm", children: [isCrossStore && (_jsx(Alert, { variant: "info", children: "These items are sold by different sellers, so they can't be combined into one cart line. Open an item to buy it on its own." })), _jsx(Div, { className: __O.xAuto, children: _jsxs(Table, { className: "text-left min-w-[440px]", children: [_jsx(Thead, { children: _jsxs(Tr, { border: "default", children: [_jsx(Th, { paddingY: "sm", paddingSide: "pr-sm", color: "muted", size: "xs", weight: "semibold", children: "Image" }), _jsx(Th, { paddingY: "sm", paddingSide: "pr-sm", color: "muted", size: "xs", weight: "semibold", children: "Name" }), _jsx(Th, { paddingY: "sm", paddingSide: "pr-sm", color: "muted", size: "xs", weight: "semibold", children: "Price" }), !isCrossStore && (_jsx(Th, { paddingY: "sm", paddingSide: "pr-sm", color: "muted", size: "xs", weight: "semibold", children: "Qty" })), _jsx(Th, { paddingY: "sm", paddingSide: "pb-sm", color: "muted", size: "xs", weight: "semibold" })] }) }), _jsx(Tbody, { children: members.map((m) => {
+                                const blocked = blockedReason(m);
+                                return (_jsxs(Tr, { className: "last:border-0", border: "subtle", children: [_jsx(Td, { paddingSide: "pr-sm", padding: "xs-tall", children: _jsx(Div, { className: `w-10 h-10 ${__O.hidden}`, rounded: "full", border: "default", children: _jsx(MediaImage, { src: memberImage(m), alt: m.title, size: "thumbnail" }) }) }), _jsxs(Td, { paddingSide: "pr-sm", padding: "xs-tall", children: [_jsx(Text, { className: "line-clamp-2", color: "primary", size: "sm", weight: "medium", children: m.title }), m.isGroupParent && (_jsx(Span, { weight: "semibold", className: "text-[10px] text-[var(--appkit-color-primary)]", children: "Parent" }))] }), _jsx(Td, { paddingSide: "pr-sm", padding: "xs-tall", children: _jsx(Text, { size: "sm", color: "muted", children: formatCurrency(m.price, m.currency ?? currency) }) }), !isCrossStore && (_jsx(Td, { paddingSide: "pr-sm", padding: "xs-tall", children: blocked ? (_jsx(Span, { size: "xs", color: "muted", surface: "muted", rounded: "default", padding: "pill-2xs", children: blocked })) : (_jsx(QuantityStepper, { value: qty[m.id] ?? 0, onChange: (next) => setQty((prev) => ({ ...prev, [m.id]: next })), min: 0, max: m.availableQuantity, ariaLabel: `Quantity for ${m.title}`, decrementLabel: ACTIONS.CART["decrease-quantity"].ariaLabel, incrementLabel: ACTIONS.CART["increase-quantity"].ariaLabel })) })), _jsx(Td, { padding: "xs-tall", children: _jsx("a", { href: memberHref(m), className: "text-[length:var(--appkit-text-xs)] text-[var(--appkit-color-primary)] hover:underline", children: "View \u2192" }) })] }, m.id));
+                            }) })] }) }), !isCrossStore && (_jsxs(_Fragment, { children: [error && _jsx(Alert, { variant: "error", children: error }), _jsxs(Row, { justify: "between", align: "center", gap: "sm", className: "min-w-0", children: [_jsx(Text, { size: "sm", color: "muted", children: selectedUnits > 0
+                                    ? `${selectedUnits} item${selectedUnits === 1 ? "" : "s"} · ${formatCurrency(selectedTotal, currency)}`
+                                    : "Nothing selected yet" }), _jsx(Button, { action: ACTIONS.CART["add-group-to-cart"], disabled: selectedUnits === 0, isLoading: isSaving, onClick: handleAdd })] })] }))] }));
+}

package/dist/features/products/components/ShowGroupSection.js

@@ -2,8 +2,9 @@
 import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
 import { useEffect, useState } from "react";
 import Link from "next/link";
-import { Div, Row, Span, Table, Thead, Tbody, Tr, Th, Td, Text, Modal, SideDrawer, Button } from "../../../ui";
+import { Div, Row, Span, Text, Modal, SideDrawer, Button } from "../../../ui";
 import { MediaImage } from "../../media/MediaImage";
+import { GroupMemberPicker } from "./GroupMemberPicker";
 import { formatCurrency } from "../../../utils/number.formatter";
 import { normalizeListingType } from "../utils/listing-type";
 import { pluginFor } from "../../../_internal/shared/listing-types/_registry";
@@ -24,12 +25,6 @@ function MemberThumb({ member, isCurrent }) {
                     ? "border-[var(--appkit-color-primary)] ring-2 ring-[var(--appkit-color-primary)]/30"
                     : "border-[var(--appkit-color-border)] group-hover:border-[var(--appkit-color-primary)]"}`, children: [_jsx(MediaImage, { src: image, alt: member.title, size: "card" }), member.isGroupParent && (_jsx(Span, { color: "inverse", rounded: "sm", className: "absolute bottom-0 right-0 bg-[var(--appkit-color-primary)] text-[8px] leading-none px-[0.25rem] py-[0.125rem]", children: "Set" }))] }), _jsx(Text, { className: "text-[10px] leading-tight line-clamp-2 w-full", color: "muted", align: "start", children: member.title }), _jsx(Text, { className: "text-[10px]", color: "primary", weight: "semibold", children: price })] }));
 }
-function GroupTableRow({ member }) {
-    const href = memberHref(member);
-    const price = formatCurrency(member.price, member.currency ?? "INR");
-    const image = member.images?.[0] ?? "";
-    return (_jsxs(Tr, { className: "last:border-0", border: "subtle", children: [_jsx(Td, { paddingSide: "pr-sm", padding: "xs-tall", children: _jsx(Div, { className: `w-10 h-10 ${__O.hidden}`, rounded: "full", border: "default", children: _jsx(MediaImage, { src: image, alt: member.title, size: "thumbnail" }) }) }), _jsxs(Td, { paddingSide: "pr-sm", padding: "xs-tall", children: [_jsx(Text, { className: "line-clamp-2", color: "primary", size: "sm", weight: "medium", children: member.title }), member.isGroupParent && (_jsx(Span, { weight: "semibold", className: "text-[10px] text-[var(--appkit-color-primary)]", children: "Parent" }))] }), _jsx(Td, { paddingSide: "pr-sm", padding: "xs-tall", children: _jsx(Text, { size: "sm", color: "muted", children: price }) }), _jsx(Td, { paddingSide: "pr-sm", padding: "xs-tall", children: _jsx(Text, { size: "xs", transform: "capitalize", color: "muted", children: member.condition ?? "—" }) }), _jsx(Td, { padding: "xs-tall", children: _jsx(Link, { href: href, className: "text-[length:var(--appkit-text-xs)] text-[var(--appkit-color-primary)] hover:underline", children: "View \u2192" }) })] }));
-}
 export function ShowGroupSection({ groupId, currentSlug, isParent, groupTitle }) {
     const [open, setOpen] = useState(false);
     const [members, setMembers] = useState([]);
@@ -50,11 +45,14 @@ export function ShowGroupSection({ groupId, currentSlug, isParent, groupTitle })
     const label = groupTitle ?? "Product group";
     const parentLabel = isParent ? `Parts in this group: ${label}` : `Part of: ${label}`;
     const useDrawer = members.length >= 5;
-    const tableContent = (_jsx(Div, { className: `${__O.xAuto}`, children: _jsxs(Table, { className: "text-left min-w-[400px]", children: [_jsx(Thead, { children: _jsxs(Tr, { border: "default", children: [_jsx(Th, { paddingY: "sm", paddingSide: "pr-sm", color: "muted", size: "xs", weight: "semibold", children: "Image" }), _jsx(Th, { paddingY: "sm", paddingSide: "pr-sm", color: "muted", size: "xs", weight: "semibold", children: "Name" }), _jsx(Th, { paddingY: "sm", paddingSide: "pr-sm", color: "muted", size: "xs", weight: "semibold", children: "Price" }), _jsx(Th, { paddingY: "sm", paddingSide: "pr-sm", color: "muted", size: "xs", weight: "semibold", children: "Condition" }), _jsx(Th, { paddingY: "sm", paddingSide: "pb-sm", color: "muted", size: "xs", weight: "semibold" })] }) }), _jsx(Tbody, { children: members.map((m) => _jsx(GroupTableRow, { member: m }, m.id)) })] }) }));
+    // The overlay is now a PICKER, not a read-only table: pick how many of each
+    // member you want and add the whole selection as one cart line. The picker
+    // stands itself down (read-only, no CTA) when the group spans sellers.
+    const tableContent = (_jsx(GroupMemberPicker, { groupId: groupId, groupSource: "product-group", members: members, onAdded: () => setShowAll(false), onAuthRequired: () => setShowAll(false) }));
     return (_jsxs(_Fragment, { children: [_jsxs(Div, { className: `${__O.hidden}`, surface: "muted", rounded: "xl", border: "default", children: [_jsxs(Row, { role: "button", tabIndex: 0, onClick: () => setOpen((v) => !v), onKeyDown: (e) => { if (e.key === "Enter" || e.key === " ") {
                             e.preventDefault();
                             setOpen((v) => !v);
-                        } }, justify: "between", paddingX: "x-md", paddingY: "y-sm", className: "w-full cursor-pointer text-left hover:bg-[var(--appkit-color-surface-elevated)]/70 transition-colors", "aria-expanded": open, children: [_jsxs(Row, { align: "center", gap: "xs", children: [_jsx(Span, { size: "xs", className: "mr-1", color: "faint", children: open ? "▼" : "▶" }), _jsx(Text, { size: "sm", weight: "medium", color: "primary", children: parentLabel }), _jsx(Span, { size: "xs", className: "ml-1", rounded: "full", padding: "pill-xs", surface: "subtle", color: "muted", children: members.length })] }), _jsx(Button, { type: "button", variant: "ghost", size: "sm", onClick: (e) => { e.stopPropagation(); setShowAll(true); }, className: "text-[length:var(--appkit-text-xs)] text-[var(--appkit-color-primary)] hover:underline ml-3 flex-shrink-0", children: "View whole group \u2192" })] }), open && (_jsx(Div, { className: `pb-[1rem] pt-[0.25rem] ${__O.xAuto}`, padding: "x-md", children: _jsx(Row, { gap: "3", className: "min-w-0", children: [...members]
+                        } }, justify: "between", paddingX: "x-md", paddingY: "y-sm", className: "w-full cursor-pointer text-left hover:bg-[var(--appkit-color-surface-elevated)]/70 transition-colors", "aria-expanded": open, children: [_jsxs(Row, { align: "center", gap: "xs", children: [_jsx(Span, { size: "xs", className: "mr-1", color: "faint", children: open ? "▼" : "▶" }), _jsx(Text, { size: "sm", weight: "medium", color: "primary", children: parentLabel }), _jsx(Span, { size: "xs", className: "ml-1", rounded: "full", padding: "pill-xs", surface: "subtle", color: "muted", children: members.length })] }), _jsx(Button, { type: "button", variant: "ghost", size: "sm", onClick: (e) => { e.stopPropagation(); setShowAll(true); }, className: "text-[length:var(--appkit-text-xs)] text-[var(--appkit-color-primary)] hover:underline ml-3 flex-shrink-0", children: "Pick items \u2192" })] }), open && (_jsx(Div, { className: `pb-[1rem] pt-[0.25rem] ${__O.xAuto}`, padding: "x-md", children: _jsx(Row, { gap: "3", className: "min-w-0", children: [...members]
                                 .sort((a, b) => (b.isGroupParent ? 1 : 0) - (a.isGroupParent ? 1 : 0))
                                 .map((m) => (_jsx(MemberThumb, { member: m, isCurrent: m.slug === currentSlug || m.id === currentSlug }, m.id))) }) }))] }), useDrawer ? (_jsx(SideDrawer, { isOpen: showAll, onClose: () => setShowAll(false), title: label, children: tableContent })) : (_jsx(Modal, { open: showAll, onClose: () => setShowAll(false), title: label, children: tableContent }))] }));
 }

package/dist/index.d.ts

@@ -1551,7 +1551,8 @@ export { updateBlogPostSchema } from "./features/blog/server";
 export type { BlogPostDetailResponse } from "./features/blog/server";
 export type { CreateBlogPostInput } from "./features/blog/server";
 export type { UpdateBlogPostInput } from "./features/blog/server";
-export { addItemToCart, assertCanAddNewItems } from "./features/cart/server";
+export { addItemToCart, assertCanAddNewItems, addGroupLineToCart, updateCartGroupMembers, GROUP_LINE_MAX_MEMBERS, type AddGroupLineToCartInput, } from "./features/cart/server";
+export { toPublicGroupMember, toPublicGroupMembers, type PublicGroupMember, } from "./_internal/server/features/products/group-members";
 export { clearCart } from "./features/cart/server";
 export { getCart } from "./features/cart/server";
 export { mergeGuestCart } from "./features/cart/server";

package/dist/index.js

@@ -2912,7 +2912,11 @@ export { updateBlogPostSchema } from "./features/blog/server";
 // [SERVER-ONLY]-Server-only â€" uses Node.js, Next.js server internals, or third-party server SDKs (auth, email, payment, shipping).
 // addItemToCart - Helper for add item to cart.
 // assertCanAddNewItems - the lane gate every add-to-cart entry point must run.
-export { addItemToCart, assertCanAddNewItems } from "./features/cart/server";
+// addGroupLineToCart - add a buyer-assembled group selection as ONE line.
+export { addItemToCart, assertCanAddNewItems, addGroupLineToCart, updateCartGroupMembers, GROUP_LINE_MAX_MEMBERS, } from "./features/cart/server";
+// Public allow-list projection for a product-group member — see
+// § "Public Data Projections".
+export { toPublicGroupMember, toPublicGroupMembers, } from "./_internal/server/features/products/group-members";
 // [SERVER-ONLY]-Server-only â€" uses Node.js, Next.js server internals, or third-party server SDKs (auth, email, payment, shipping).
 // clearCart - Shared export for clear cart.
 export { clearCart } from "./features/cart/server";