@mohasinac/appkit 4.24.0 → 4.26.0

package/dist/_internal/server/features/grouped/og.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Grouped-listing OG card.
+ *
+ * Deliberately delegates to `renderBundleOgImage` rather than re-implementing
+ * the layout: the card is the same shape (title, description, cover, item
+ * count) minus the price, and `BundleOgData.priceLabel` / `.stockStatus` are
+ * already nullable for exactly that case. Forking it would give two ~150-line
+ * OG layouts to keep visually in step — the Duplication Framework's
+ * "same prop surface, same output" consolidate rule.
+ */
+import type { ReactElement } from "react";
+import type { GroupedListingDocument } from "../../../../features/grouped/schemas/firestore";
+export declare function renderGroupedListingOg(doc: Pick<GroupedListingDocument, "title" | "description" | "coverImage" | "productIds"> | null | undefined, opts: {
+    siteName: string;
+    baseUrl?: string;
+}): ReactElement;

package/dist/_internal/server/features/grouped/og.js

@@ -0,0 +1,24 @@
+/**
+ * Grouped-listing OG card.
+ *
+ * Deliberately delegates to `renderBundleOgImage` rather than re-implementing
+ * the layout: the card is the same shape (title, description, cover, item
+ * count) minus the price, and `BundleOgData.priceLabel` / `.stockStatus` are
+ * already nullable for exactly that case. Forking it would give two ~150-line
+ * OG layouts to keep visually in step — the Duplication Framework's
+ * "same prop surface, same output" consolidate rule.
+ */
+import { renderBundleOgImage } from "../bundles/og";
+import { resolveOgImageUrl } from "../seo/og";
+export function renderGroupedListingOg(doc, opts) {
+    return renderBundleOgImage({
+        name: doc?.title ?? "Group",
+        description: doc?.description?.slice(0, 140) ??
+            `A curated group of related listings on ${opts.siteName}.`,
+        coverImageUrl: resolveOgImageUrl(doc?.coverImage ?? null, opts.baseUrl),
+        // A group has no price of its own — the buyer's selection is the price.
+        priceLabel: null,
+        itemCount: doc?.productIds?.length ?? null,
+        stockStatus: null,
+    }, opts.siteName);
+}

package/dist/_internal/server/features/products/group-members.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Public projection for a product-group member.
+ *
+ * `GET /api/products/group/[groupId]` previously returned
+ * `sanitizeProductsForPublic(items)`, which is a DELETE-LIST of four
+ * seller-identity keys — every other field of `ProductDocument` went to the
+ * browser, including fields nobody had thought about. Per § "Public Data
+ * Projections", a public payload is built by naming what goes out, never by
+ * spreading a document and removing keys: a denial keyed on today's field list
+ * is structurally blind to the field added tomorrow.
+ *
+ * The member picker needs more than the old response carried (stock, store,
+ * sold state, gstRate), so widening the payload was required either way —
+ * which made this the moment to make it an allow-list rather than a wider
+ * deny-list.
+ */
+import type { ProductDocument } from "../../../../features/products/schemas/firestore";
+import type { ListingType } from "../../../../features/products/types/index";
+/**
+ * Every field the group picker and the group table render. If a field is not
+ * here it does not reach the browser.
+ *
+ * Deliberately absent, with reasons:
+ *  - `sellerId` / `ownerId` / `sellerName` / `sellerEmail` — seller identity;
+ *    public clients see store-scoped identity only.
+ *  - `costPrice`, `profitMargin`, `supplier*`, `adminNotes` — seller-private
+ *    commercial data.
+ *  - `stockQuantity` — the internal figure; `availableQuantity` is the one the
+ *    buyer may act on.
+ */
+export interface PublicGroupMember {
+    id: string;
+    slug?: string;
+    title: string;
+    price: number;
+    currency?: string;
+    /** First image only — the picker renders a thumbnail, never a gallery. */
+    image?: string;
+    condition?: string;
+    listingType: ListingType;
+    isGroupParent?: boolean;
+    groupTitle?: string;
+    /** Drives the stepper's `max`. */
+    availableQuantity: number;
+    storeId: string;
+    storeName?: string;
+    status: string;
+    isSold?: boolean;
+    /** Needed so the picker can show a tax-inclusive hint and the cart line can
+     *  snapshot it for per-member GST proration at checkout. */
+    gstRate?: 0 | 5 | 12 | 18 | 28;
+    hsnCode?: string;
+}
+export declare function toPublicGroupMember(doc: ProductDocument): PublicGroupMember;
+export declare function toPublicGroupMembers(docs: readonly ProductDocument[]): PublicGroupMember[];

package/dist/_internal/server/features/products/group-members.js

@@ -0,0 +1,41 @@
+/**
+ * Public projection for a product-group member.
+ *
+ * `GET /api/products/group/[groupId]` previously returned
+ * `sanitizeProductsForPublic(items)`, which is a DELETE-LIST of four
+ * seller-identity keys — every other field of `ProductDocument` went to the
+ * browser, including fields nobody had thought about. Per § "Public Data
+ * Projections", a public payload is built by naming what goes out, never by
+ * spreading a document and removing keys: a denial keyed on today's field list
+ * is structurally blind to the field added tomorrow.
+ *
+ * The member picker needs more than the old response carried (stock, store,
+ * sold state, gstRate), so widening the payload was required either way —
+ * which made this the moment to make it an allow-list rather than a wider
+ * deny-list.
+ */
+import { normalizeListingType } from "../../../../features/products/utils/listing-type";
+export function toPublicGroupMember(doc) {
+    return {
+        id: doc.id,
+        slug: doc.slug,
+        title: doc.title,
+        price: doc.price,
+        currency: doc.currency,
+        image: doc.images?.[0] ?? doc.mainImage,
+        condition: doc.condition,
+        listingType: normalizeListingType(doc),
+        isGroupParent: doc.isGroupParent,
+        groupTitle: doc.groupTitle,
+        availableQuantity: doc.availableQuantity ?? 0,
+        storeId: doc.storeId,
+        storeName: doc.storeName,
+        status: doc.status,
+        isSold: doc.isSold,
+        gstRate: doc.gstRate,
+        hsnCode: doc.hsnCode,
+    };
+}
+export function toPublicGroupMembers(docs) {
+    return docs.map(toPublicGroupMember);
+}

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/line-members.d.ts

@@ -0,0 +1,60 @@
+/**
+ * "What products does this cart line actually consume?" — the one answer.
+ *
+ * Lives in `shared/` rather than `server/features/checkout/` because three
+ * different layers need it and two of them are not server code:
+ *   - `order-math.ts`         (pricing + tax, shared)
+ *   - `rules/_registry.ts`    (preflight skip, shared)
+ *   - `bundle-expansion.ts`   (stock fan-out, server)
+ *   - `stock-restore.ts`      (restore fan-out, server)
+ *
+ * Pure functions, no Firestore, no framework imports.
+ */
+import type { CartItemDocument } from "../../../features/cart/schemas/firestore";
+/** One member of a cart line, with the units required per COPY of that line. */
+export interface CartLineMemberRef {
+    productId: string;
+    quantity: number;
+}
+/**
+ * Resolve a line's members. Three sources, in priority order — never read
+ * `bundleProductIds` directly at a call site:
+ *
+ *  1. `groupMembers` — authoritative, and the only shape that can express
+ *     per-member quantities.
+ *  2. `bundleProductIds` — legacy bundle lines written before `groupMembers`
+ *     existed, resolved at quantity 1 each. This fallback is what makes carts
+ *     that were already in flight behave byte-identically, with no migration.
+ *  3. the line's own `productId` — an ordinary single-product line.
+ *
+ * Keeping this a derivation rather than storing a second array is deliberate: a
+ * hand-maintained mirror drifts the first time one write path forgets it
+ * (Recurrent Root Cause #42).
+ */
+export declare function getCartLineMembers(item: CartItemDocument): CartLineMemberRef[];
+/**
+ * True when the line stands for several products rather than one.
+ *
+ * Replaces the scattered `item.bundleProductIds?.length` tests, which each
+ * meant "is this a bundle" and would all have silently answered "no" for a
+ * `groupMembers`-backed line.
+ */
+export declare function isMultiMemberLine(item: CartItemDocument): boolean;
+/** Just the product ids — see `getCartLineMembers` for the resolution order. */
+export declare function getCartItemMemberIds(item: CartItemDocument): string[];
+/** The order-side shape this module needs. Structural on purpose — it matches
+ *  `OrderDocumentItem` without dragging the orders schema into shared checkout. */
+export interface OrderItemMemberSource {
+    productId: string;
+    bundleProductIds?: string[];
+}
+/**
+ * The order-side twin of `getCartLineMembers`, used by stock restore.
+ *
+ * A LEGACY order row is collapsed: one row standing for a whole bundle, with
+ * its members listed in `bundleProductIds` at one unit each. Rows written after
+ * grouped lines were expanded carry no `bundleProductIds` at all — each row is
+ * already exactly one product — so they fall through to the single-member
+ * branch and need no special case.
+ */
+export declare function getOrderItemMemberRefs(item: OrderItemMemberSource): CartLineMemberRef[];

package/dist/_internal/shared/checkout/line-members.js

@@ -0,0 +1,68 @@
+/**
+ * "What products does this cart line actually consume?" — the one answer.
+ *
+ * Lives in `shared/` rather than `server/features/checkout/` because three
+ * different layers need it and two of them are not server code:
+ *   - `order-math.ts`         (pricing + tax, shared)
+ *   - `rules/_registry.ts`    (preflight skip, shared)
+ *   - `bundle-expansion.ts`   (stock fan-out, server)
+ *   - `stock-restore.ts`      (restore fan-out, server)
+ *
+ * Pure functions, no Firestore, no framework imports.
+ */
+/**
+ * Resolve a line's members. Three sources, in priority order — never read
+ * `bundleProductIds` directly at a call site:
+ *
+ *  1. `groupMembers` — authoritative, and the only shape that can express
+ *     per-member quantities.
+ *  2. `bundleProductIds` — legacy bundle lines written before `groupMembers`
+ *     existed, resolved at quantity 1 each. This fallback is what makes carts
+ *     that were already in flight behave byte-identically, with no migration.
+ *  3. the line's own `productId` — an ordinary single-product line.
+ *
+ * Keeping this a derivation rather than storing a second array is deliberate: a
+ * hand-maintained mirror drifts the first time one write path forgets it
+ * (Recurrent Root Cause #42).
+ */
+export function getCartLineMembers(item) {
+    if (item.groupMembers?.length) {
+        return item.groupMembers.map((m) => ({
+            productId: m.productId,
+            quantity: m.quantity,
+        }));
+    }
+    if (item.bundleProductIds?.length) {
+        return item.bundleProductIds.map((productId) => ({ productId, quantity: 1 }));
+    }
+    return [{ productId: item.productId, quantity: 1 }];
+}
+/**
+ * True when the line stands for several products rather than one.
+ *
+ * Replaces the scattered `item.bundleProductIds?.length` tests, which each
+ * meant "is this a bundle" and would all have silently answered "no" for a
+ * `groupMembers`-backed line.
+ */
+export function isMultiMemberLine(item) {
+    return Boolean(item.groupMembers?.length || item.bundleProductIds?.length);
+}
+/** Just the product ids — see `getCartLineMembers` for the resolution order. */
+export function getCartItemMemberIds(item) {
+    return getCartLineMembers(item).map((m) => m.productId);
+}
+/**
+ * The order-side twin of `getCartLineMembers`, used by stock restore.
+ *
+ * A LEGACY order row is collapsed: one row standing for a whole bundle, with
+ * its members listed in `bundleProductIds` at one unit each. Rows written after
+ * grouped lines were expanded carry no `bundleProductIds` at all — each row is
+ * already exactly one product — so they fall through to the single-member
+ * branch and need no special case.
+ */
+export function getOrderItemMemberRefs(item) {
+    if (item.bundleProductIds?.length) {
+        return item.bundleProductIds.map((productId) => ({ productId, quantity: 1 }));
+    }
+    return [{ productId: item.productId, quantity: 1 }];
+}

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/_internal/shared/checkout/rules/_registry.js

@@ -8,6 +8,7 @@
  *
  * No grep of the consumer codebase needed.
  */
+import { isMultiMemberLine } from "../line-members";
 import { standardRule } from "./standard.rule";
 import { auctionRule } from "./auction.rule";
 import { preOrderRule } from "./preorder.rule";
@@ -77,8 +78,13 @@ export function getSplitKey(item) {
 export function runSyncPreflight(pairs, paymentMethod) {
     const byType = new Map();
     for (const pair of pairs) {
-        if (pair.item.bundleProductIds?.length)
-            continue; // bundles skip — direct checkout
+        // Multi-member lines (bundle or grouped selection) skip the per-listing-type
+        // preflight: their `listingType` describes the wrapper, not the members, so
+        // a per-type rule would be applied to the wrong thing. Tested via the shared
+        // predicate rather than `bundleProductIds?.length`, which answers "is this a
+        // legacy bundle" and would say no for a `groupMembers`-backed line.
+        if (isMultiMemberLine(pair.item))
+            continue;
         const lt = (pair.item.listingType ?? "standard");
         const bucket = byType.get(lt) ?? [];
         bucket.push(pair);

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,10 @@ 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";
 export type { MarketplaceBundleCardProps, MarketplaceBundleCardData, MarketplaceBundleCardLabels, } from "./features/products/components/MarketplaceBundleCard";
 export { CompareOverlay } from "./features/products/components/CompareOverlay";
@@ -418,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,8 @@ 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";
 export { COMPARE_MAX_ITEMS } from "./features/products/constants/action-defs";
@@ -404,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";