@mohasinac/appkit 2.6.2 → 2.6.4

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>[];

package/dist/features/orders/utils/order-splitter.js

@@ -1,45 +1,39 @@
+import { getListingRule, offerRule, } from "../../../_internal/shared/checkout/rules";
 /**
  * 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 function splitCartIntoOrderGroups(checks) {
     const groups = new Map();
     for (const check of checks) {
         const { item } = check;
-        let key;
-        let orderType;
-        if (item.listingType === "auction") {
-            key = `auction:${item.itemId}`;
-            orderType = "auction";
-        }
-        else if (item.isOffer) {
-            key = `offer:${item.itemId}`;
-            orderType = "offer";
-        }
-        else if (item.listingType === "prize-draw") {
-            // Each prize-draw entry is its own order (single reveal per order).
-            key = `prize-draw:${item.itemId}`;
-            orderType = "prize-draw";
-        }
-        else if (item.listingType === "pre-order") {
-            key = `preorder:${item.storeId ?? "unknown"}`;
-            orderType = "preorder";
-        }
-        else {
-            key = `standard:${item.storeId ?? "unknown"}`;
-            orderType = "standard";
-        }
-        if (!groups.has(key)) {
-            groups.set(key, { items: [], orderType });
+        const lt = (item.listingType ?? "standard");
+        const rule = item.isOffer ? offerRule : (getListingRule(lt) ?? getListingRule("standard"));
+        // Prize-draw (and future types with maxLinesPerOrder < Infinity) may split
+        // one cart item into N virtual batch items.
+        const virtualItems = rule.splitMultipleOrders(item);
+        for (let batchIdx = 0; batchIdx < virtualItems.length; batchIdx++) {
+            const virtualItem = virtualItems[batchIdx];
+            const virtualCheck = { ...check, item: virtualItem };
+            const baseKey = rule.splitKey(virtualItem);
+            // Append a batch suffix only when there are multiple batches so the key
+            // stays stable for single-order types.
+            const key = virtualItems.length > 1 ? `${baseKey}:batch-${batchIdx}` : baseKey;
+            if (!groups.has(key)) {
+                groups.set(key, { items: [], orderType: rule.orderType });
+            }
+            groups.get(key).items.push(virtualCheck);
         }
-        groups.get(key).items.push(check);
     }
     return Array.from(groups.values());
 }

package/dist/features/payments/repository/payout.repository.d.ts

@@ -6,7 +6,7 @@
  */
 import { BaseRepository, type SieveModel, type FirebaseSieveResult } from "../../../providers/db-firebase";
 import type { DocumentReference, WriteResult } from "firebase-admin/firestore";
-import type { PayoutDocument, PayoutCreateInput, PayoutStatus, PayoutUpdateInput } from "../schemas";
+import type { PayoutDocument, PayoutCreateInput, PayoutRefundDeduction, PayoutStatus, PayoutUpdateInput } from "../schemas";
 export declare class PayoutRepository extends BaseRepository<PayoutDocument> {
     constructor();
     /** Decrypt PII fields on a payout document after Firestore read */
@@ -57,6 +57,18 @@ export declare class PayoutRepository extends BaseRepository<PayoutDocument> {
      * Used to avoid double-paying the same orders.
      */
     getPaidOutOrderIds(storeId: string): Promise<Set<string>>;
+    /**
+     * Find the most recent pending payout for a store.
+     * Used to locate the deduction target when a refund is issued.
+     */
+    findPendingByStore(storeId: string): Promise<PayoutDocument | null>;
+    /**
+     * Atomically append a refund deduction and recalculate netAmount.
+     *
+     * Only valid while status = "pending". Throws if the payout is not found
+     * or is no longer pending. netAmount is floored at 0.
+     */
+    applyRefundDeduction(payoutId: string, deduction: Omit<PayoutRefundDeduction, "appliedAt">): Promise<PayoutDocument>;
     static readonly SIEVE_FIELDS: {
         id: {
             canFilter: boolean;
@@ -90,6 +102,10 @@ export declare class PayoutRepository extends BaseRepository<PayoutDocument> {
             canFilter: boolean;
             canSort: boolean;
         };
+        netAmount: {
+            canFilter: boolean;
+            canSort: boolean;
+        };
         requestedAt: {
             canFilter: boolean;
             canSort: boolean;

package/dist/features/payments/repository/payout.repository.js

@@ -172,6 +172,52 @@ export class PayoutRepository extends BaseRepository {
         });
         return ids;
     }
+    /**
+     * Find the most recent pending payout for a store.
+     * Used to locate the deduction target when a refund is issued.
+     */
+    async findPendingByStore(storeId) {
+        const snapshot = await this.db
+            .collection(this.collection)
+            .where(PAYOUT_FIELDS.STORE_ID, "==", storeId)
+            .where(PAYOUT_FIELDS.STATUS, "==", "pending")
+            .orderBy(PAYOUT_FIELDS.CREATED_AT, "desc")
+            .limit(1)
+            .get();
+        if (snapshot.empty)
+            return null;
+        return this.decryptPayout({ id: snapshot.docs[0].id, ...snapshot.docs[0].data() });
+    }
+    /**
+     * Atomically append a refund deduction and recalculate netAmount.
+     *
+     * Only valid while status = "pending". Throws if the payout is not found
+     * or is no longer pending. netAmount is floored at 0.
+     */
+    async applyRefundDeduction(payoutId, deduction) {
+        const ref = this.db.collection(this.collection).doc(payoutId);
+        const entry = { ...deduction, appliedAt: new Date() };
+        const updated = await this.db.runTransaction(async (tx) => {
+            const snap = await tx.get(ref);
+            if (!snap.exists)
+                throw new Error(`Payout ${payoutId} not found`);
+            const doc = { id: snap.id, ...snap.data() };
+            if (doc.status !== "pending") {
+                throw new Error(`Cannot deduct from payout ${payoutId} in status "${doc.status}"`);
+            }
+            const existing = doc.refundDeductions ?? [];
+            const newDeductions = [...existing, entry];
+            const totalDeducted = newDeductions.reduce((s, d) => s + d.deductedAmount, 0);
+            const netAmount = Math.max(0, doc.amount - totalDeducted);
+            tx.update(ref, {
+                refundDeductions: newDeductions.map((d) => prepareForFirestore(d)),
+                netAmount,
+                updatedAt: new Date(),
+            });
+            return { ...doc, refundDeductions: newDeductions, netAmount, updatedAt: new Date() };
+        });
+        return this.decryptPayout(updated);
+    }
     /**
      * Paginated, Firestore-native payout list (admin use).
      */
@@ -194,6 +240,7 @@ PayoutRepository.SIEVE_FIELDS = {
     status: { canFilter: true, canSort: true },
     paymentMethod: { canFilter: true, canSort: false },
     amount: { canFilter: true, canSort: true },
+    netAmount: { canFilter: true, canSort: true },
     requestedAt: { canFilter: true, canSort: true },
     createdAt: { canFilter: true, canSort: true },
     processedAt: { canFilter: true, canSort: true },

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

@@ -9,6 +9,22 @@ export interface PayoutBankAccount {
     bankName: string;
 }
 export type PayoutStatus = "pending" | "processing" | "completed" | "failed";
+/**
+ * A single refund deduction applied against a payout before dispatch.
+ *
+ * deductedAmount = refundedAmount − (refundedAmount × platformFeeRate)
+ * The platform keeps its fee share; only the net seller portion is deducted.
+ */
+export interface PayoutRefundDeduction {
+    orderId: string;
+    refundId: string;
+    /** Gross refund amount in paise (for audit trail). */
+    refundedAmount: number;
+    /** Net amount deducted from the seller payout in paise. */
+    deductedAmount: number;
+    reason: string;
+    appliedAt: Date;
+}
 export declare const PayoutStatusValues: {
     readonly PENDING: "pending";
     readonly PROCESSING: "processing";
@@ -38,6 +54,16 @@ export interface PayoutDocument {
     gstAmount?: number;
     gstRate?: number;
     isAutomatic?: boolean;
+    /**
+     * Refund deductions applied before dispatch (while status = "pending").
+     * Each entry reduces the seller's net payout by deductedAmount.
+     */
+    refundDeductions?: PayoutRefundDeduction[];
+    /**
+     * amount − sum(refundDeductions.deductedAmount). Undefined when no
+     * deductions have been applied; dispatch code must use `netAmount ?? amount`.
+     */
+    netAmount?: number;
     requestedAt: Date;
     processedAt?: Date;
     createdAt: Date;

package/dist/features/pre-orders/components/PreorderCard.d.ts

@@ -7,6 +7,9 @@ export declare function PreorderBadge({ shipDate, className }: PreorderBadgeProp
 interface PreorderCardProps {
     item: PreorderItem;
     href: string;
+    selectable?: boolean;
+    isSelected?: boolean;
+    onSelect?: (id: string, selected: boolean) => void;
 }
-export declare function PreorderCard({ item, href }: PreorderCardProps): import("react/jsx-runtime").JSX.Element;
+export declare function PreorderCard({ item, href, selectable, isSelected, onSelect }: PreorderCardProps): import("react/jsx-runtime").JSX.Element;
 export {};

package/dist/features/pre-orders/components/PreorderCard.js

@@ -1,9 +1,10 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import Link from "next/link";
-import { Div, Heading, Span, Text } from "../../../ui";
+import { BaseListingCard, Div, Heading, Span, Text } from "../../../ui";
 import { getPreorderStatus } from "../types";
 import { formatCurrency } from "../../../utils/number.formatter";
 import { getDefaultLocale } from "../../../core/baseline-resolver";
+import { useLongPress } from "../../../react/hooks/useLongPress";
 const STATUS_LABELS = {
     available: "Pre-order now",
     shipping_soon: "Shipping soon",
@@ -18,9 +19,10 @@ export function PreorderBadge({ shipDate, className }) {
     const status = getPreorderStatus(shipDate);
     return (_jsx(Span, { className: `inline-flex items-center rounded-full px-2.5 py-0.5 text-xs font-medium ${STATUS_COLORS[status]} ${className ?? ""}`, children: STATUS_LABELS[status] }));
 }
-export function PreorderCard({ item, href }) {
-    return (_jsxs(Link, { href: href, className: "group relative block overflow-hidden rounded-xl border border-gray-200 dark:border-slate-700 bg-white dark:bg-slate-900 transition-shadow hover:shadow-md", children: [item.images[0] ? (_jsx(Div, { role: "img", "aria-label": item.name, className: "aspect-square w-full bg-center bg-cover transition-transform duration-300 group-hover:scale-105", style: { backgroundImage: `url(${item.images[0]})` } })) : (_jsx(Div, { className: "aspect-square w-full bg-gray-100" })), _jsxs(Div, { className: "p-4", children: [_jsx(PreorderBadge, { shipDate: item.preorderShipDate }), _jsx(Heading, { level: 3, className: "mt-2 font-semibold text-gray-900 dark:text-zinc-100 text-base", children: item.name }), _jsx(Text, { className: "mt-1 text-sm text-gray-500 dark:text-zinc-400", children: item.brand }), _jsxs(Div, { className: "mt-3 flex items-baseline gap-2", children: [_jsx(Span, { className: "text-lg font-bold text-gray-900 dark:text-zinc-100", children: formatCurrency(item.salePrice) }), item.regularPrice > item.salePrice && (_jsx(Span, { className: "text-sm text-gray-400 dark:text-zinc-500 line-through", children: formatCurrency(item.regularPrice) }))] }), item.preorderShipDate && (_jsxs(Text, { className: "mt-1 text-xs text-gray-400 dark:text-zinc-500", children: ["Ships:", " ", new Date(item.preorderShipDate).toLocaleDateString(getDefaultLocale(), {
-                                month: "short",
-                                year: "numeric",
-                            })] }))] })] }));
+export function PreorderCard({ item, href, selectable = false, isSelected = false, onSelect }) {
+    const longPress = useLongPress(() => onSelect?.(item.id, !isSelected));
+    return (_jsxs(Div, { className: `group relative block overflow-hidden rounded-xl border bg-white dark:bg-slate-900 transition-shadow hover:shadow-md ${isSelected ? "border-primary outline outline-2 outline-primary" : "border-gray-200 dark:border-slate-700"}`, onMouseDown: onSelect && !isSelected ? longPress.onMouseDown : undefined, onMouseUp: onSelect && !isSelected ? longPress.onMouseUp : undefined, onMouseLeave: onSelect && !isSelected ? longPress.onMouseLeave : undefined, onTouchStart: onSelect && !isSelected ? longPress.onTouchStart : undefined, onTouchEnd: onSelect && !isSelected ? longPress.onTouchEnd : undefined, children: [onSelect && (_jsx(BaseListingCard.Checkbox, { selected: isSelected, onSelect: (e) => { e.preventDefault(); onSelect(item.id, !isSelected); }, label: isSelected ? "Deselect pre-order" : "Select pre-order", position: "top-2 left-2", className: selectable || isSelected ? "opacity-100" : "opacity-0 group-hover:opacity-100 transition-opacity" })), _jsxs(Link, { href: href, className: "block", children: [item.images[0] ? (_jsx(Div, { role: "img", "aria-label": item.name, className: "aspect-square w-full bg-center bg-cover transition-transform duration-300 group-hover:scale-105", style: { backgroundImage: `url(${item.images[0]})` } })) : (_jsx(Div, { className: "aspect-square w-full bg-gray-100" })), _jsxs(Div, { className: "p-4", children: [_jsx(PreorderBadge, { shipDate: item.preorderShipDate }), _jsx(Heading, { level: 3, className: "mt-2 font-semibold text-gray-900 dark:text-zinc-100 text-base", children: item.name }), _jsx(Text, { className: "mt-1 text-sm text-gray-500 dark:text-zinc-400", children: item.brand }), _jsxs(Div, { className: "mt-3 flex items-baseline gap-2", children: [_jsx(Span, { className: "text-lg font-bold text-gray-900 dark:text-zinc-100", children: formatCurrency(item.salePrice) }), item.regularPrice > item.salePrice && (_jsx(Span, { className: "text-sm text-gray-400 dark:text-zinc-500 line-through", children: formatCurrency(item.regularPrice) }))] }), item.preorderShipDate && (_jsxs(Text, { className: "mt-1 text-xs text-gray-400 dark:text-zinc-500", children: ["Ships:", " ", new Date(item.preorderShipDate).toLocaleDateString(getDefaultLocale(), {
+                                        month: "short",
+                                        year: "numeric",
+                                    })] }))] })] })] }));
 }

package/dist/features/products/actions/product-actions.d.ts

@@ -6,7 +6,7 @@ export interface ProductListActionParams {
     page?: number;
     pageSize?: number;
     /** Canonical listing-kind discriminator (SB1-G Phase 4). */
-    listingType?: "standard" | "auction" | "pre-order" | "prize-draw";
+    listingType?: "standard" | "auction" | "pre-order" | "prize-draw" | "classified" | "digital-code" | "live";
     featured?: boolean;
     storeId?: string;
     categoriesIn?: string[];