@mohasinac/appkit 2.6.3 → 2.6.5

package/dist/features/orders/components/RefundHistoryTable.d.ts

@@ -0,0 +1,6 @@
+import type { OrderDocument } from "../schemas";
+export interface RefundHistoryTableProps {
+    order: Pick<OrderDocument, "refunds" | "contestable" | "totalPrice" | "currency">;
+    className?: string;
+}
+export declare function RefundHistoryTable({ order, className }: RefundHistoryTableProps): import("react/jsx-runtime").JSX.Element | null;

package/dist/features/orders/components/RefundHistoryTable.js

@@ -0,0 +1,23 @@
+"use client";
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Badge, Div, Heading, Row, Stack, Text } from "../../../ui";
+import { formatCurrency } from "../../../utils/number.formatter";
+import { REFUND_COPY } from "../../../_internal/shared/features/orders/refund-copy";
+function formatDate(d) {
+    const dt = d instanceof Date ? d : new Date(d);
+    return dt.toLocaleDateString("en-IN", { day: "numeric", month: "short", year: "numeric" });
+}
+function RefundRow({ event, currency }) {
+    return (_jsxs(Row, { justify: "between", align: "start", gap: "sm", className: "border-b border-zinc-100 py-3 last:border-0 dark:border-zinc-800", children: [_jsxs(Stack, { gap: "xs", className: "flex-1", children: [_jsxs(Row, { gap: "sm", align: "center", children: [_jsx(Badge, { variant: event.type === "full" ? "danger" : "warning", children: event.type === "full" ? REFUND_COPY.history.badgeFull : REFUND_COPY.history.badgePartial }), _jsx(Text, { size: "xs", color: "muted", children: formatDate(event.refundedAt) })] }), _jsx(Text, { size: "sm", children: event.reason }), event.manualTransactionId && (_jsxs(Text, { size: "xs", color: "muted", children: [REFUND_COPY.history.labelTxn, " ", event.manualTransactionId] })), event.razorpayRefundId && (_jsxs(Text, { size: "xs", color: "muted", children: [REFUND_COPY.history.labelRazorpay, " ", event.razorpayRefundId] }))] }), _jsx(Text, { size: "sm", weight: "semibold", className: "shrink-0", children: formatCurrency(event.amount / 100, currency) })] }));
+}
+/** Warning triangle icon — inline SVG kept here since it's a single-use decorative element. */
+function WarningIcon() {
+    return (_jsx("svg", { className: "h-4 w-4 shrink-0 text-amber-600 dark:text-amber-400", fill: "currentColor", viewBox: "0 0 20 20", "aria-hidden": "true", children: _jsx("path", { fillRule: "evenodd", d: "M8.485 2.495c.673-1.167 2.357-1.167 3.03 0l6.28 10.875c.673 1.167-.17 2.625-1.516 2.625H3.72c-1.347 0-2.189-1.458-1.515-2.625L8.485 2.495zM10 5a.75.75 0 01.75.75v3.5a.75.75 0 01-1.5 0v-3.5A.75.75 0 0110 5zm0 9a1 1 0 100-2 1 1 0 000 2z", clipRule: "evenodd" }) }));
+}
+export function RefundHistoryTable({ order, className = "" }) {
+    const events = order.refunds ?? [];
+    const currency = order.currency ?? "INR";
+    if (events.length === 0 && order.contestable !== false)
+        return null;
+    return (_jsxs(Div, { className: `rounded-xl border border-zinc-200 bg-white dark:border-zinc-800 dark:bg-zinc-900 ${className}`, children: [order.contestable === false && (_jsx(Div, { className: "rounded-t-xl bg-amber-50 px-4 py-3 dark:bg-amber-950/30", children: _jsxs(Row, { gap: "sm", align: "center", children: [_jsx(WarningIcon, {}), _jsx(Text, { size: "sm", weight: "semibold", className: "text-amber-700 dark:text-amber-400", children: REFUND_COPY.history.nonContestableBanner })] }) })), events.length > 0 && (_jsxs(Div, { className: "p-4", children: [_jsx(Heading, { level: 4, className: "mb-3 text-sm font-semibold text-zinc-700 dark:text-zinc-300", children: REFUND_COPY.history.heading }), _jsx(Stack, { gap: "none", children: events.map((e) => (_jsx(RefundRow, { event: e, currency: currency }, e.refundId))) })] }))] }));
+}

package/dist/features/orders/components/RefundRequestView.d.ts

@@ -0,0 +1,8 @@
+import type { OrderDocument } from "../schemas";
+export interface RefundRequestViewProps {
+    order: Pick<OrderDocument, "id" | "totalPrice" | "currency" | "isNonRefundable" | "refunds" | "contestable">;
+    onSubmitRequest: (reason: string) => Promise<void>;
+    isLoading?: boolean;
+    className?: string;
+}
+export declare function RefundRequestView({ order, onSubmitRequest, isLoading, className, }: RefundRequestViewProps): import("react/jsx-runtime").JSX.Element;

package/dist/features/orders/components/RefundRequestView.js

@@ -0,0 +1,42 @@
+"use client";
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * RefundRequestView — buyer-facing refund submission form.
+ *
+ * Shows 3 acknowledgment checkboxes (via the appkit Checkbox primitive) that
+ * the buyer must tick before the submit button becomes active. On submit the
+ * parent's `onSubmitRequest` is called with the reason string; the parent
+ * (page or modal) is responsible for calling the API.
+ *
+ * This component is presentational: it has no server-action imports and
+ * does not talk to the API directly.
+ */
+import { useState } from "react";
+import { Button, Checkbox, Div, Stack, Text, Textarea } from "../../../ui";
+import { REFUND_COPY } from "../../../_internal/shared/features/orders/refund-copy";
+import { formatCurrency } from "../../../utils/number.formatter";
+const ACK_COUNT = REFUND_COPY.request.acknowledgments.length;
+export function RefundRequestView({ order, onSubmitRequest, isLoading = false, className = "", }) {
+    const [acknowledged, setAcknowledged] = useState(Array(ACK_COUNT).fill(false));
+    const [reason, setReason] = useState("");
+    const [error, setError] = useState(null);
+    const allChecked = acknowledged.every(Boolean);
+    const canSubmit = allChecked && reason.trim().length >= 10 && !isLoading;
+    if (order.isNonRefundable) {
+        return (_jsx(Div, { className: `rounded-xl border border-zinc-200 bg-zinc-50 p-4 dark:border-zinc-800 dark:bg-zinc-900 ${className}`, children: _jsx(Text, { size: "sm", color: "muted", children: REFUND_COPY.request.nonRefundableMessage }) }));
+    }
+    if (order.contestable === false) {
+        return (_jsx(Div, { className: `rounded-xl border border-amber-200 bg-amber-50 p-4 dark:border-amber-800 dark:bg-amber-950/30 ${className}`, children: _jsx(Text, { size: "sm", className: "text-amber-700 dark:text-amber-400", children: REFUND_COPY.request.alreadyRefundedMessage }) }));
+    }
+    const handleToggle = (i) => setAcknowledged((prev) => prev.map((v, idx) => (idx === i ? !v : v)));
+    const handleSubmit = async () => {
+        setError(null);
+        try {
+            await onSubmitRequest(reason.trim());
+        }
+        catch (err) {
+            setError(err instanceof Error ? err.message : REFUND_COPY.request.errorFallback);
+        }
+    };
+    return (_jsxs(Stack, { gap: "md", className: className, children: [_jsxs(Text, { size: "sm", color: "muted", children: [REFUND_COPY.request.orderTotalLabel, " ", _jsx("strong", { children: formatCurrency(order.totalPrice / 100, order.currency ?? "INR") })] }), _jsxs(Stack, { gap: "xs", children: [_jsxs(Text, { size: "sm", weight: "semibold", children: [REFUND_COPY.request.reasonLabel, " ", _jsx("span", { "aria-hidden": true, children: "*" })] }), _jsx(Textarea, { value: reason, onChange: (e) => setReason(e.target.value), placeholder: REFUND_COPY.request.reasonPlaceholder, rows: 3, "aria-required": "true", "aria-label": REFUND_COPY.request.reasonLabel })] }), _jsxs(Stack, { gap: "sm", children: [_jsx(Text, { size: "sm", weight: "semibold", children: REFUND_COPY.request.acknowledgeHeading }), REFUND_COPY.request.acknowledgments.map((text, i) => (_jsx(Checkbox, { checked: acknowledged[i], onChange: () => handleToggle(i), label: _jsx(Text, { size: "sm", className: "leading-snug", children: text }), "aria-label": `Acknowledgment ${i + 1}` }, i)))] }), error && (_jsx(Text, { size: "sm", color: "danger", role: "alert", children: error })), _jsx(Button, { variant: "danger", onClick: handleSubmit, disabled: !canSubmit, "aria-busy": isLoading, children: isLoading ? REFUND_COPY.request.submittingLabel : REFUND_COPY.request.submitLabel })] }));
+}

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

@@ -2,3 +2,9 @@ export { OrderCard, OrdersList } from "./OrdersList";
 export { MarketplaceOrderCard, type MarketplaceOrderCardLabels, type MarketplaceOrderCardLinks, type MarketplaceOrderCardOrder, type MarketplaceOrderCardProps, } from "./MarketplaceOrderCard";
 export { OrderFilters, ORDER_FILTER_KEYS, ORDER_ADMIN_SORT_OPTIONS, ORDER_SELLER_SORT_OPTIONS, ORDER_USER_SORT_OPTIONS, getOrderFilterKeys, getOrderSortOptions, } from "./OrderFilters";
 export type { OrderFiltersProps, OrderFilterVariant } from "./OrderFilters";
+export { OrderSiblingPayments } from "./OrderSiblingPayments";
+export type { OrderSiblingPaymentsProps } from "./OrderSiblingPayments";
+export { RefundHistoryTable } from "./RefundHistoryTable";
+export type { RefundHistoryTableProps } from "./RefundHistoryTable";
+export { RefundRequestView } from "./RefundRequestView";
+export type { RefundRequestViewProps } from "./RefundRequestView";

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

@@ -1,3 +1,6 @@
 export { OrderCard, OrdersList } from "./OrdersList";
 export { MarketplaceOrderCard, } from "./MarketplaceOrderCard";
 export { OrderFilters, ORDER_FILTER_KEYS, ORDER_ADMIN_SORT_OPTIONS, ORDER_SELLER_SORT_OPTIONS, ORDER_USER_SORT_OPTIONS, getOrderFilterKeys, getOrderSortOptions, } from "./OrderFilters";
+export { OrderSiblingPayments } from "./OrderSiblingPayments";
+export { RefundHistoryTable } from "./RefundHistoryTable";
+export { RefundRequestView } from "./RefundRequestView";

package/dist/features/orders/index.d.ts

@@ -4,4 +4,5 @@ export * from "./components";
 export * from "./schemas";
 export * from "./columns";
 export * from "./utils/order-splitter";
+export { groupOrderItemsByBundle, type BundleOrderGroup, type OrderItemForBundleGrouping, } from "./utils/bundle-grouping";
 export { manifest } from "./manifest";

package/dist/features/orders/index.js

@@ -4,4 +4,6 @@ export * from "./components";
 export * from "./schemas";
 export * from "./columns";
 export * from "./utils/order-splitter";
+// S-SBUNI-5 2026-05-13 — bundle-aware order item grouping.
+export { groupOrderItemsByBundle, } from "./utils/bundle-grouping";
 export { manifest } from "./manifest";

package/dist/features/orders/repository/orders.repository.d.ts

@@ -1,7 +1,7 @@
 import type { DocumentReference, WriteBatch } from "firebase-admin/firestore";
 import type { FirebaseSieveResult, SieveModel } from "../../../providers/db-firebase";
 import { BaseRepository } from "../../../providers/db-firebase";
-import { type OrderCreateInput, type OrderDocument } from "../schemas";
+import { type OrderCreateInput, type OrderDocument, type OrderRefundEvent } from "../schemas";
 import type { OrderStatus, PaymentStatus } from "../types";
 declare class OrderRepository extends BaseRepository<OrderDocument> {
     constructor();
@@ -81,6 +81,10 @@ declare class OrderRepository extends BaseRepository<OrderDocument> {
             canFilter: boolean;
             canSort: boolean;
         };
+        contestable: {
+            canFilter: boolean;
+            canSort: boolean;
+        };
     };
     listForSeller(productIds: string[], model: SieveModel): Promise<FirebaseSieveResult<OrderDocument>>;
     listForUser(userId: string, model: SieveModel): Promise<FirebaseSieveResult<OrderDocument>>;
@@ -145,8 +149,23 @@ declare class OrderRepository extends BaseRepository<OrderDocument> {
             canFilter: boolean;
             canSort: boolean;
         };
+        paymentBatchId: {
+            canFilter: boolean;
+            canSort: boolean;
+        };
+        contestable: {
+            canFilter: boolean;
+            canSort: boolean;
+        };
     };
     listAll(model: SieveModel): Promise<FirebaseSieveResult<OrderDocument>>;
+    /**
+     * Append one refund event to the order and mark it non-contestable.
+     * If `becomeRefunded` is true, also transitions the order status to "refunded".
+     */
+    postRefundEvent(orderId: string, event: OrderRefundEvent, becomeRefunded?: boolean): Promise<OrderDocument>;
+    /** Fetch all orders sharing a paymentBatchId (for sibling-orders display). */
+    findByPaymentBatchId(batchId: string): Promise<OrderDocument[]>;
     /**
      * Cloud Functions: find pending orders created before a timeout threshold.
      * Used by the payment-timeout cleanup job to cancel stale unconfirmed orders.

package/dist/features/orders/repository/orders.repository.js

@@ -1,4 +1,4 @@
-import { DatabaseError } from "../../../errors";
+import { DatabaseError, NotFoundError } from "../../../errors";
 import { BaseRepository, prepareForFirestore, } from "../../../providers/db-firebase";
 import { decryptPiiFields, encryptPiiFields, ORDER_PII_FIELDS, } from "../../../security";
 import { serverTimestamp } from "../../../contracts/field-ops";
@@ -208,6 +208,31 @@ class OrderRepository extends BaseRepository {
             maxPageSize: 200,
         });
     }
+    /**
+     * Append one refund event to the order and mark it non-contestable.
+     * If `becomeRefunded` is true, also transitions the order status to "refunded".
+     */
+    async postRefundEvent(orderId, event, becomeRefunded = false) {
+        const order = await this.findById(orderId);
+        if (!order)
+            throw new NotFoundError(`Order ${orderId} not found`);
+        const existing = order.refunds ?? [];
+        return this.update(orderId, {
+            refunds: [...existing, event],
+            contestable: false,
+            ...(becomeRefunded ? { status: "refunded" } : {}),
+            updatedAt: new Date(),
+        });
+    }
+    /** Fetch all orders sharing a paymentBatchId (for sibling-orders display). */
+    async findByPaymentBatchId(batchId) {
+        const snap = await this.db
+            .collection(this.collection)
+            .where("paymentBatchId", "==", batchId)
+            .limit(20)
+            .get();
+        return snap.docs.map((d) => this.decryptOrder({ id: d.id, ...d.data() }));
+    }
     /**
      * Cloud Functions: find pending orders created before a timeout threshold.
      * Used by the payment-timeout cleanup job to cancel stale unconfirmed orders.
@@ -325,6 +350,7 @@ OrderRepository.SELLER_SIEVE_FIELDS = {
     totalPrice: { canFilter: true, canSort: true },
     orderDate: { canFilter: true, canSort: true },
     createdAt: { canFilter: true, canSort: true },
+    contestable: { canFilter: true, canSort: false },
 };
 OrderRepository.ADMIN_SIEVE_FIELDS = {
     id: { canFilter: true, canSort: false },
@@ -342,6 +368,9 @@ OrderRepository.ADMIN_SIEVE_FIELDS = {
     totalPrice: { canFilter: true, canSort: true },
     orderDate: { canFilter: true, canSort: true },
     createdAt: { canFilter: true, canSort: true },
+    // S-SBUNI-RULES 2026-05-13 — refund + batch fields
+    paymentBatchId: { canFilter: true, canSort: false },
+    contestable: { canFilter: true, canSort: false },
 };
 const orderRepository = new OrderRepository();
 export { OrderRepository, orderRepository };

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

@@ -4,14 +4,15 @@
 import type { OrderStatus, PaymentStatus } from "../types";
 import type { OrderType } from "../utils/order-splitter";
 export type ShippingMethod = "custom" | "shiprocket";
+export type RefundType = "full" | "partial";
 export type OrderPayoutStatus = "eligible" | "requested" | "paid";
 export type RefundStatus = "pending" | "processing" | "completed" | "rejected";
-/** Runtime-accessible shipping method values — use instead of bare string literals. */
+/** Runtime-accessible shipping method values — use instead of bare string literals. */
 export declare const ShippingMethodValues: {
     readonly CUSTOM: "custom";
     readonly SHIPROCKET: "shiprocket";
 };
-/** Runtime-accessible order status values — use instead of bare string literals. */
+/** Runtime-accessible order status values — use instead of bare string literals. */
 export declare const OrderStatusValues: {
     readonly PENDING: "pending";
     readonly CONFIRMED: "confirmed";
@@ -23,7 +24,7 @@ export declare const OrderStatusValues: {
     readonly RETURN_REQUESTED: "return_requested";
     readonly RETURNED: "returned";
 };
-/** Runtime-accessible payment status values — use instead of bare string literals. */
+/** Runtime-accessible payment status values — use instead of bare string literals. */
 export declare const PaymentStatusValues: {
     readonly PENDING: "pending";
     readonly PROCESSING: "processing";
@@ -32,36 +33,62 @@ export declare const PaymentStatusValues: {
     readonly REFUNDED: "refunded";
     readonly PARTIAL_REFUND: "partial_refund";
 };
-/** Runtime-accessible payment method values — use instead of bare string literals. */
+/** Runtime-accessible payment method values — use instead of bare string literals. */
 export declare const PaymentMethodValues: {
     readonly COD: "cod";
     readonly ONLINE: "online";
     readonly UPI_MANUAL: "upi_manual";
     readonly RAZORPAY: "razorpay";
 };
-/** Runtime-accessible refund status values — use instead of bare string literals. */
+/** Runtime-accessible refund status values — use instead of bare string literals. */
 export declare const RefundStatusValues: {
     readonly PENDING: "pending";
     readonly PROCESSING: "processing";
     readonly COMPLETED: "completed";
     readonly REJECTED: "rejected";
 };
-/** Firestore storage shape for an order line item — distinct from the API display model OrderItem */
+/** Firestore storage shape for an order line item — distinct from the API display model OrderItem */
 export interface OrderDocumentItem {
     productId: string;
     productTitle: string;
     quantity: number;
     unitPrice: number;
     totalPrice: number;
-    /** SB8-F — set when the item is a prize-draw entry; drives the reveals badge. */
-    listingType?: "standard" | "auction" | "pre-order" | "prize-draw";
-    /** SB8-F — per-item reveal status; flips through pending → open → revealed/closed. */
+    /** SB8-F — set when the item is a prize-draw entry; drives the reveals badge. */
+    listingType?: "standard" | "auction" | "pre-order" | "prize-draw" | "classified" | "digital-code" | "live";
+    /** SB8-F — per-item reveal status; flips through pending → open → revealed/closed. */
     prizeRevealStatus?: "pending" | "open" | "closed" | "revealed";
-    /** SB8-F — ISO timestamp; deadline by which the buyer must claim the prize. */
+    /** SB8-F — ISO timestamp; deadline by which the buyer must claim the prize. */
     prizeRevealDeadline?: string;
-    /** SB8-F — set after the reveal API picks a winner. */
+    /** SB8-F — set after the reveal API picks a winner. */
     revealedItemNumber?: number;
 }
+/**
+ * One refund event on an order. Multiple partial refund events are allowed
+ * until the cumulative amount equals the order total, at which point the order
+ * transitions to full-refund terminal state. Once any refund is posted the
+ * order's `contestable` flag becomes false permanently.
+ */
+export interface OrderRefundEvent {
+    refundId: string;
+    type: RefundType;
+    /** Amount in paise. */
+    amount: number;
+    /** ProductIds / itemIds that were refunded (for partial refunds). */
+    itemIds?: string[];
+    reason: string;
+    refundedAt: Date;
+    refundedBy: string;
+    /** Set when Razorpay processed the refund. */
+    razorpayRefundId?: string;
+    /** Set when refund was processed manually (offline). */
+    manualTransactionId?: string;
+    /** Proof document URL (via /api/media signed-URL flow). */
+    proofDocumentUrl?: string;
+    proofDocumentMimeType?: string;
+    /** Required for Razorpay-override path ("failed auto-refund, settled manually"). */
+    overrideReason?: string;
+}
 /** One applied discount/coupon saved on the order for accounting and display */
 export interface AppliedOrderDiscount {
     code: string;
@@ -136,14 +163,37 @@ export interface OrderDocument {
     };
     /** Deadline for the buyer to claim the won prize (typically 7 days). */
     prizeRevealDeadline?: Date;
-    /** True once `prizeRevealDeadline` passes without a claim — auto-forfeit. */
+    /** True once `prizeRevealDeadline` passes without a claim — auto-forfeit. */
     prizeRevealExpired?: boolean;
     /** Source product id when the order came from a prize-draw entry. */
     prizeDrawProductId?: string;
     /** True for prize-draw entries and bundle purchases that bypass refund. */
     isNonRefundable?: boolean;
-    /** Set when the order came from a bundle — points back to `bundles/{id}`. */
+    /** Set when the order came from a bundle — points back to `bundles/{id}`. */
     bundleId?: string;
+    /**
+     * Internal reference linking sibling orders created from the same checkout
+     * transaction (one Razorpay payment, N orders). Not a contractual record —
+     * orders are the source of truth for invoicing, refunds, and disputes.
+     */
+    paymentBatchId?: string;
+    /**
+     * Append-only log of refund events on this order. Multiple partial refund
+     * events are allowed until the cumulative amount equals `totalPrice`.
+     */
+    refunds?: OrderRefundEvent[];
+    /**
+     * False once ANY refund (full or partial) has been posted. Once false it
+     * stays false — no dispute, RMA request, or “Item Not Received” claim may
+     * be filed. Both buyer and seller must acknowledge this in the refund UI
+     * via `confirmIrrevocable: true` before the refund is posted.
+     */
+    contestable?: boolean;
+    /** Signed-URL media slug for a shipping-proof document (label, AWB scan). */
+    shippingProofUrl?: string;
+    shippingProofMimeType?: string;
+    shippingProofUploadedAt?: Date;
+    shippingProofUploadedBy?: string;
     createdAt: Date;
     updatedAt: Date;
 }

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

@@ -2,12 +2,12 @@
  * Orders Firestore Document Types & Constants
  */
 import { generateOrderId } from "../../../utils/id-generators";
-/** Runtime-accessible shipping method values — use instead of bare string literals. */
+/** Runtime-accessible shipping method values — use instead of bare string literals. */
 export const ShippingMethodValues = {
     CUSTOM: "custom",
     SHIPROCKET: "shiprocket",
 };
-/** Runtime-accessible order status values — use instead of bare string literals. */
+/** Runtime-accessible order status values — use instead of bare string literals. */
 export const OrderStatusValues = {
     PENDING: "pending",
     CONFIRMED: "confirmed",
@@ -19,7 +19,7 @@ export const OrderStatusValues = {
     RETURN_REQUESTED: "return_requested",
     RETURNED: "returned",
 };
-/** Runtime-accessible payment status values — use instead of bare string literals. */
+/** Runtime-accessible payment status values — use instead of bare string literals. */
 export const PaymentStatusValues = {
     PENDING: "pending",
     PROCESSING: "processing",
@@ -28,14 +28,14 @@ export const PaymentStatusValues = {
     REFUNDED: "refunded",
     PARTIAL_REFUND: "partial_refund",
 };
-/** Runtime-accessible payment method values — use instead of bare string literals. */
+/** Runtime-accessible payment method values — use instead of bare string literals. */
 export const PaymentMethodValues = {
     COD: "cod",
     ONLINE: "online",
     UPI_MANUAL: "upi_manual",
     RAZORPAY: "razorpay",
 };
-/** Runtime-accessible refund status values — use instead of bare string literals. */
+/** Runtime-accessible refund status values — use instead of bare string literals. */
 export const RefundStatusValues = {
     PENDING: "pending",
     PROCESSING: "processing",

package/dist/features/orders/schemas/index.d.ts

@@ -137,16 +137,16 @@ export declare const orderSchema: z.ZodObject<{
     }[];
     total: number;
     userId: string;
-    subtotal: number;
     paymentStatus: string;
+    subtotal: number;
     orderStatus: "pending" | "processing" | "refunded" | "confirmed" | "shipped" | "delivered" | "cancelled" | "return_requested" | "returned";
     createdAt?: string | undefined;
     updatedAt?: string | undefined;
     notes?: string | undefined;
-    tax?: number | undefined;
     trackingNumber?: string | undefined;
     couponCode?: string | undefined;
     shippingCarrier?: string | undefined;
+    tax?: number | undefined;
     paymentGateway?: string | undefined;
     shippingCost?: number | undefined;
     discount?: number | undefined;
@@ -172,16 +172,16 @@ export declare const orderSchema: z.ZodObject<{
     }[];
     total: number;
     userId: string;
-    subtotal: number;
     paymentStatus: string;
+    subtotal: number;
     orderStatus: "pending" | "processing" | "refunded" | "confirmed" | "shipped" | "delivered" | "cancelled" | "return_requested" | "returned";
     createdAt?: string | undefined;
     updatedAt?: string | undefined;
     notes?: string | undefined;
-    tax?: number | undefined;
     trackingNumber?: string | undefined;
     couponCode?: string | undefined;
     shippingCarrier?: string | undefined;
+    tax?: number | undefined;
     paymentGateway?: string | undefined;
     shippingCost?: number | undefined;
     discount?: number | undefined;

package/dist/features/orders/types/index.d.ts

@@ -23,8 +23,9 @@ export interface OrderItem {
     currency?: string;
     storeId?: string;
     attributes?: Record<string, string>;
-    /** Listing kind at the time of order — needed for prize-draw UI hints (SB8-F). */
-    listingType?: "standard" | "auction" | "pre-order" | "prize-draw";
+    /** Listing kind at the time of order — needed for prize-draw UI hints (SB8-F).
+     *  SB-UNI-F 2026-05-13 — Phase 2 union extension. */
+    listingType?: "standard" | "auction" | "pre-order" | "prize-draw" | "classified" | "digital-code" | "live";
     /**
      * Per-item prize-draw reveal status (SB8-F). Populated by the checkout
      * actions when listingType === "prize-draw". Used to render the
@@ -35,6 +36,15 @@ export interface OrderItem {
     prizeRevealDeadline?: string;
     /** Set after the reveal endpoint picks a winner — the prize item index. */
     revealedItemNumber?: number;
+    /**
+     * SB-UNI-4 2026-05-13 — bundle identifier when this order line represents a
+     * bundle purchase. `productId` then points at the bundle category id and
+     * `bundleProductIds` snapshots the included member product ids. Per-member
+     * stock decrement + order fan-out lands in S-SBUNI-5.
+     */
+    bundleCategorySlug?: string;
+    /** Snapshot of bundle.bundleProductIds at order-creation time. */
+    bundleProductIds?: string[];
 }
 export interface OrderTimeline {
     status: OrderStatus;

package/dist/features/orders/utils/bundle-grouping.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Order-item bundle grouping — S-SBUNI-5 2026-05-13.
+ *
+ * Orders carry bundle members as individual `OrderItem` rows (per S-SBUNI-4
+ * schema) when the buyer's cart line was a bundle. The order-detail UI
+ * collapses those rows back under a single "Bundle: <name>" header so the
+ * checkout receipt mirrors the buyer's intent. This helper is the pure
+ * grouping logic — the UI primitive lives next to the consumer view.
+ *
+ * Two flavours of "bundle row" can appear on an order:
+ *   1. ONE order row whose `bundleCategorySlug` + `bundleProductIds[]` set
+ *      describe the bundle (this is what S-SBUNI-4's checkout writes — the
+ *      bundle stays a single row in the order with the locked
+ *      bundlePriceInPaise as its line total).
+ *   2. (Future) Expanded N rows, each tagged with the same
+ *      `bundleCategorySlug`. The grouping handles this too in case a future
+ *      session pivots to row expansion.
+ *
+ * Either way, `groupOrderItemsByBundle` returns a stable, ordered list of
+ * "groups" so the renderer can iterate once.
+ */
+/** Minimal shape consumed from an order item (Firestore wire format). */
+export interface OrderItemForBundleGrouping {
+    /** Bundle discriminator — set when this row is part of a bundle. */
+    bundleCategorySlug?: string;
+    /** Snapshot of bundle members at order-creation time. */
+    bundleProductIds?: string[];
+}
+export type BundleOrderGroup<T extends OrderItemForBundleGrouping> = {
+    kind: "single";
+    item: T;
+    index: number;
+} | {
+    kind: "bundle";
+    bundleCategorySlug: string;
+    items: Array<{
+        item: T;
+        index: number;
+    }>;
+    /** Pulled from the first row in the group; reflects what checkout snapshotted. */
+    memberCount: number;
+};
+/**
+ * Walk the items array preserving original order; collapse contiguous (or
+ * non-contiguous) bundle rows sharing the same `bundleCategorySlug` into a
+ * single group. Single rows pass through unchanged.
+ */
+export declare function groupOrderItemsByBundle<T extends OrderItemForBundleGrouping>(items: T[]): Array<BundleOrderGroup<T>>;

package/dist/features/orders/utils/bundle-grouping.js

@@ -0,0 +1,54 @@
+/**
+ * Order-item bundle grouping — S-SBUNI-5 2026-05-13.
+ *
+ * Orders carry bundle members as individual `OrderItem` rows (per S-SBUNI-4
+ * schema) when the buyer's cart line was a bundle. The order-detail UI
+ * collapses those rows back under a single "Bundle: <name>" header so the
+ * checkout receipt mirrors the buyer's intent. This helper is the pure
+ * grouping logic — the UI primitive lives next to the consumer view.
+ *
+ * Two flavours of "bundle row" can appear on an order:
+ *   1. ONE order row whose `bundleCategorySlug` + `bundleProductIds[]` set
+ *      describe the bundle (this is what S-SBUNI-4's checkout writes — the
+ *      bundle stays a single row in the order with the locked
+ *      bundlePriceInPaise as its line total).
+ *   2. (Future) Expanded N rows, each tagged with the same
+ *      `bundleCategorySlug`. The grouping handles this too in case a future
+ *      session pivots to row expansion.
+ *
+ * Either way, `groupOrderItemsByBundle` returns a stable, ordered list of
+ * "groups" so the renderer can iterate once.
+ */
+/**
+ * Walk the items array preserving original order; collapse contiguous (or
+ * non-contiguous) bundle rows sharing the same `bundleCategorySlug` into a
+ * single group. Single rows pass through unchanged.
+ */
+export function groupOrderItemsByBundle(items) {
+    const groups = [];
+    const bundleIndexBySlug = new Map();
+    items.forEach((item, index) => {
+        const slug = item.bundleCategorySlug;
+        if (!slug) {
+            groups.push({ kind: "single", item, index });
+            return;
+        }
+        const existingIdx = bundleIndexBySlug.get(slug);
+        if (existingIdx === undefined) {
+            const memberCount = item.bundleProductIds?.length ?? 1;
+            groups.push({
+                kind: "bundle",
+                bundleCategorySlug: slug,
+                items: [{ item, index }],
+                memberCount,
+            });
+            bundleIndexBySlug.set(slug, groups.length - 1);
+            return;
+        }
+        const existing = groups[existingIdx];
+        if (existing.kind === "bundle") {
+            existing.items.push({ item, index });
+        }
+    });
+    return groups;
+}

package/dist/features/orders/utils/order-splitter.d.ts

@@ -3,22 +3,21 @@ export interface OrderGroup<T> {
     items: T[];
     orderType: OrderType;
 }
+import type { CartItemDocument } from "../../cart/schemas/firestore";
 /**
  * Split a sequence of cart-items into order groups by `OrderType`.
  *
- * Auctions and offers each settle as their own single-item order (the auction
- * win is one transaction; an accepted offer is locked to one item). Pre-orders
- * and standard items are grouped per-store so each store gets a single
- * shipment.
+ * The split key and order type are both derived from the checkout rule
+ * registry so new listing types need no changes here.
+ *
+ * Prize-draw items with qty > PRIZE_DRAW_MAX_REVEALS_PER_ORDER are first
+ * expanded into virtual single-batch items (via `rule.splitMultipleOrders`),
+ * then each batch lands in its own order group.
  *
  * SB1-G Phase 4 — keys off the canonical `CartItem.listingType` discriminator
  * instead of the legacy `isAuction` / `isPreOrder` booleans.
+ * S-SBUNI-RULES 2026-05-13 — rule-registry dispatch replaces if/else chain.
  */
 export declare function splitCartIntoOrderGroups<T extends {
-    item: {
-        itemId: string;
-        storeId?: string;
-        listingType?: "standard" | "auction" | "pre-order" | "prize-draw";
-        isOffer?: boolean;
-    };
+    item: CartItemDocument;
 }>(checks: T[]): OrderGroup<T>[];