@mohasinac/appkit 4.71.0 → 4.71.2

package/dist/_internal/shared/cache/revalidate-targets.d.ts

@@ -4,7 +4,7 @@
  * ## Why this exists
  *
  * Detail routes used to carry very short `revalidate` windows — 30s on
- * `auctions/[id]`, 60s on `products/[slug]` — not because anyone wanted that
+ * `collector-drops/[id]`, 60s on `products/[slug]` — not because anyone wanted that
  * freshness, but because **the window was the only freshness mechanism in the
  * app**. Measured 2026-10-09: `revalidatePath` appeared three times in the whole
  * repository, all `revalidatePath("/")`, and `revalidateTag` zero times.
@@ -32,7 +32,7 @@
  * listing as in stock, so when in doubt this returns MORE paths, not fewer.
  */
 export interface RevalidateHints {
-    /** `standard` | `auction` | `pre-order` | … — picks the right detail route. */
+    /** `standard` | `collector drop` | `pre-order` | … — picks the right detail route. */
     listingType?: string;
     /** Full ancestor chain; every category page listing this product goes stale. */
     categorySlugs?: string[];

package/dist/_internal/shared/cache/revalidate-targets.js

@@ -4,7 +4,7 @@
  * ## Why this exists
  *
  * Detail routes used to carry very short `revalidate` windows — 30s on
- * `auctions/[id]`, 60s on `products/[slug]` — not because anyone wanted that
+ * `collector-drops/[id]`, 60s on `products/[slug]` — not because anyone wanted that
  * freshness, but because **the window was the only freshness mechanism in the
  * app**. Measured 2026-10-09: `revalidatePath` appeared three times in the whole
  * repository, all `revalidatePath("/")`, and `revalidateTag` zero times.
@@ -41,12 +41,12 @@ import { LISTING_TYPE_REGISTRY } from "../listing-types/_registry.js";
  * own `listingTypeFromId` prefix ladder, and both had already drifted by the
  * time the union reached ten — exactly the tenth-enumeration failure Root Cause
  * #61 is about. Measured 2026-10-26, while invalidating after a catalogue purge
- * that deleted 7 `spares` and 2 `stickers`:
+ * that deleted 7 `spares` and 2 `art-and-stickers`:
  *
  *   - **`spares` was absent from both.** A `spare-…` id fell through to the
  *     "unknown type" branch, which marks every OTHER type's detail route and
  *     therefore never marks `/products/spare-…` — the one page that existed.
- *   - **`/art`, `/stickers` and `/spares` were never marked at all.** The browse
+ *   - **`/art` and `/spares` were never marked at all.** The browse
  *     path was derived by stripping the last segment off the detail route, and
  *     all three types detail at `/products/{slug}`, so the strip yielded
  *     `/products` and the `!== ROUTES.PUBLIC.PRODUCTS` test discarded it. Their
@@ -82,8 +82,8 @@ function productTargets(id, hints) {
          * everything" button. `/products` alone is not "every listing page": five
          * types are deliberately OUT of the general catalogue
          * (`inGeneralCatalogue: false`) and are reachable only at their own browse
-         * route, so a bulk invalidation that marks `/products` leaves `/auctions`,
-         * `/pre-orders`, `/prize-draws`, `/art`, `/stickers` and `/spares` serving
+         * route, so a bulk invalidation that marks `/products` leaves `/collector-drops`,
+         * `/pre-orders`, `/clearance`, `/art` and `/spares` serving
          * rows that no longer exist.
          */
         for (const p of PLUGINS)
@@ -96,9 +96,9 @@ function productTargets(id, hints) {
     if (plugin) {
         out.push(String(plugin.detailRoute(id)));
         // The type's own browse page. Read off the plugin, NOT derived by stripping
-        // the detail route's last segment: art/stickers/spares all detail at
-        // `/products/{slug}`, so stripping yields `/products` and loses `/art`,
-        // `/stickers` and `/spares` entirely.
+        // the detail route's last segment: art-and-stickers/spares both detail at
+        // `/products/{slug}`, so stripping yields `/products` and loses `/art`
+        // and `/spares` entirely.
         if (plugin.browseRoute)
             out.push(String(plugin.browseRoute));
     }

package/dist/_internal/shared/checkout/lanes.d.ts

@@ -1,11 +1,11 @@
 export declare const CART_LANE: {
-    readonly AUCTION: "auction";
+    readonly COLLECTOR_DROP: "collector-drop";
     readonly OFFER: "offer";
     readonly STANDARD: "standard";
 };
 export type CartLane = (typeof CART_LANE)[keyof typeof CART_LANE];
 /**
- * Highest obligation first. An auction win is a completed sale the buyer already
+ * Highest obligation first. A collector drop win is a completed sale the buyer already
  * committed to by bidding; an accepted offer is a price the seller has held for
  * them on a clock; ordinary cart items carry no commitment at all.
  */
@@ -15,52 +15,52 @@ export declare const CART_LANE_LABELS: Record<CartLane, string>;
  * How long a locked line survives before it lapses, per lane.
  *
  * Lives here, with the lane model, because the deadline is a property OF the
- * lane — and because `AUCTION_CHECKOUT_WINDOW_MS` was previously declared twice
- * (`auctionSettlement.ts` and `bid-actions.ts`, i.e. the settlement path and the
+ * lane — and because `COLLECTOR_DROP_CHECKOUT_WINDOW_MS` was previously declared twice
+ * (`collectorDropSettlement.ts` and `bid-actions.ts`, i.e. the settlement path and the
  * Buy-Now path) with no link between them: changing one would silently give the
  * same kind of win two different deadlines depending on how it was won.
  *
  * The two windows are equal today but mean different things, so they stay
  * separate names rather than one shared constant:
- *  - **auction** — payment is MANDATORY. You bid, you won, you owe it. Past the
+ *  - **collector-drop** — payment is MANDATORY. You bid, you won, you owe it. Past the
  *    deadline the bid is forfeited and the buyer is warned that repeated
  *    non-payment restricts their account.
  *  - **offer** — payment is OPTIONAL. Declining to buy at your own offer price
  *    is the buyer's right; the offer simply lapses with no penalty.
  */
-export declare const LANE_CHECKOUT_WINDOW_MS: Record<"auction" | "offer", number>;
+export declare const LANE_CHECKOUT_WINDOW_MS: Record<"collector-drop" | "offer", number>;
 /** 2 days, in hours — for buyer-facing copy ("pay within 48 hours"). */
-export declare const LANE_CHECKOUT_WINDOW_HOURS: Record<"auction" | "offer", number>;
+export declare const LANE_CHECKOUT_WINDOW_HOURS: Record<"collector-drop" | "offer", number>;
 /**
  * A BUYOUT hold is a third window, deliberately much shorter than the two above,
- * even though it lands in the same auction lane.
+ * even though it lands in the same collector drop lane.
  *
- * A settled win (`LANE_CHECKOUT_WINDOW_MS.auction`) is a finished auction: the
+ * A settled win (`LANE_CHECKOUT_WINDOW_MS["collector-drop"]`) is a finished collector drop: the
  * clock already ran, nobody else is waiting, and 48 hours costs no one anything.
- * A buyout is the opposite — the auction is still live and still taking bids
+ * A buyout is the opposite — the collector drop is still live and still taking bids
  * while the hold exists, so a long window would let one buyer sit on a listing
  * they may never pay for. One hour, and the hold is additionally clamped to the
- * auction's own end time by `buyNowAuction` (see `AUCTION_BUYOUT_WINDOW_MS`
- * callers): a buyout that hasn't been paid for by the time the auction ends
- * fails, because by then the auction has settled to whoever actually won it.
+ * collector drop's own end time by `buyNowCollectorDrop` (see `COLLECTOR_DROP_BUYOUT_WINDOW_MS`
+ * callers): a buyout that hasn't been paid for by the time the collector drop ends
+ * fails, because by then the collector drop has settled to whoever actually won it.
  */
-export declare const AUCTION_BUYOUT_WINDOW_MS: number;
+export declare const COLLECTOR_DROP_BUYOUT_WINDOW_MS: number;
 /** 1 hour, in minutes — for buyer-facing copy ("pay within 60 minutes"). */
-export declare const AUCTION_BUYOUT_WINDOW_MINUTES: number;
+export declare const COLLECTOR_DROP_BUYOUT_WINDOW_MINUTES: number;
 /**
- * Deep link that drops a buyer straight into the auction lane at checkout.
+ * Deep link that drops a buyer straight into the collector drop lane at checkout.
  *
  * Declared once here, with the lane it selects, because it was previously a
- * const in `auctionSettlement.ts` AND an inline template literal in
+ * const in `collectorDropSettlement.ts` AND an inline template literal in
  * `bid-actions.ts` — the same two-copies problem `LANE_CHECKOUT_WINDOW_MS` was
  * extracted to fix, one layer up.
  */
-export declare const AUCTION_CHECKOUT_URL: string;
+export declare const COLLECTOR_DROP_CHECKOUT_URL: string;
 /** The two lanes whose price is fixed outside the listing. */
 export declare function isLockedLane(lane: CartLane): boolean;
 /** Minimal shape this module needs — works on cart documents and client rows alike. */
 export interface LaneAssignable {
-    isAuctionWin?: boolean;
+    isCollectorDropWin?: boolean;
     isOffer?: boolean;
     offerId?: string;
     bidId?: string;
@@ -81,16 +81,16 @@ export declare function isLaneCheckoutable(items: readonly LaneAssignable[], lan
  * whole cart against its own active lane — so every off-lane line was a
  * violation and the throw was unconditional. The consequence was total: a cart
  * holding more than ONE lane could not be checked out by any UI path, with
- * `CHECKOUT_LANE_BLOCKED` and "Settle your 1 won auction first" returned for
+ * `CHECKOUT_LANE_BLOCKED` and "Settle your 1 won collector drop first" returned for
  * the very lane the buyer was already settling.
  *
  * Multi-lane carts are not an edge case — they are what the lane model
- * produces. `auctionSettlement` pushes a won auction straight into the cart
+ * produces. `collectorDropSettlement` pushes a won collector drop straight into the cart
  * whatever is already sitting in it, and `assertCanAddNewItems` only blocks
  * ADDING while a higher lane is pending; it never clears what was there first.
- * So any buyer who had anything in their cart when they won an auction was
+ * So any buyer who had anything in their cart when they won a collector drop was
  * locked out of checkout entirely. That is Root Cause #60's symptom returning
- * by a different mechanism — the auction winner who cannot pay.
+ * by a different mechanism — the collector drop winner who cannot pay.
  *
  * Returning the active lane also makes the server agree with what the buyer is
  * looking at: the cart page scopes its lines, its totals and its CTA to that
@@ -119,8 +119,8 @@ export declare function defaultCheckoutItems<T extends LaneAssignable>(items: re
  * `cart.items` — every lane — while settle created orders for the active lane
  * only. And multi-lane carts are not an edge case: `defaultCheckoutItems`' own
  * docstring above says they "are what the lane model produces", because
- * `auctionSettlement` pushes a won auction into whatever is already in the
- * cart. So a buyer with a won auction and ordinary items in the cart was
+ * `collectorDropSettlement` pushes a won collector drop into whatever is already in the
+ * cart. So a buyer with a won collector drop and ordinary items in the cart was
  * charged for both and received orders for one.
  *
  * ## The rule

package/dist/_internal/shared/checkout/lanes.js

@@ -1,8 +1,8 @@
 /*
  * WHY: A cart can hold three kinds of line with three different obligations — a
- *      won auction (you owe it), an accepted offer (you negotiated it, at a
+ *      won collector drop (you owe it), an accepted offer (you negotiated it, at a
  *      locked price, on a deadline), and ordinary shopping. Mixing them into one
- *      total lets a buyer settle a ₹200 sticker while a ₹30,000 auction win they
+ *      total lets a buyer settle a ₹200 sticker while a ₹30,000 collector drop win they
  *      already committed to sits unpaid, and makes every total ambiguous.
  * WHAT: The lane model — a derived (never stored) partition of the cart, with a
  *       strict priority order. Exactly one lane is checkout-able at a time: the
@@ -26,22 +26,22 @@
  */
 import { ROUTES } from "../../../next/routing/route-map.js";
 export const CART_LANE = {
-    AUCTION: "auction",
+    COLLECTOR_DROP: "collector-drop",
     OFFER: "offer",
     STANDARD: "standard",
 };
 /**
- * Highest obligation first. An auction win is a completed sale the buyer already
+ * Highest obligation first. A collector drop win is a completed sale the buyer already
  * committed to by bidding; an accepted offer is a price the seller has held for
  * them on a clock; ordinary cart items carry no commitment at all.
  */
 export const CART_LANE_PRIORITY = [
-    CART_LANE.AUCTION,
+    CART_LANE.COLLECTOR_DROP,
     CART_LANE.OFFER,
     CART_LANE.STANDARD,
 ];
 export const CART_LANE_LABELS = {
-    auction: "Auction wins",
+    "collector-drop": "Collector Drop wins",
     offer: "Accepted offers",
     standard: "Cart",
 };
@@ -49,14 +49,14 @@ export const CART_LANE_LABELS = {
  * How long a locked line survives before it lapses, per lane.
  *
  * Lives here, with the lane model, because the deadline is a property OF the
- * lane — and because `AUCTION_CHECKOUT_WINDOW_MS` was previously declared twice
- * (`auctionSettlement.ts` and `bid-actions.ts`, i.e. the settlement path and the
+ * lane — and because `COLLECTOR_DROP_CHECKOUT_WINDOW_MS` was previously declared twice
+ * (`collectorDropSettlement.ts` and `bid-actions.ts`, i.e. the settlement path and the
  * Buy-Now path) with no link between them: changing one would silently give the
  * same kind of win two different deadlines depending on how it was won.
  *
  * The two windows are equal today but mean different things, so they stay
  * separate names rather than one shared constant:
- *  - **auction** — payment is MANDATORY. You bid, you won, you owe it. Past the
+ *  - **collector-drop** — payment is MANDATORY. You bid, you won, you owe it. Past the
  *    deadline the bid is forfeited and the buyer is warned that repeated
  *    non-payment restricts their account.
  *  - **offer** — payment is OPTIONAL. Declining to buy at your own offer price
@@ -64,47 +64,47 @@ export const CART_LANE_LABELS = {
  */
 export const LANE_CHECKOUT_WINDOW_MS = {
     /** 2 days. Mandatory — enforced by the expiry sweep, which forfeits the bid. */
-    auction: 48 * 60 * 60 * 1000,
+    "collector-drop": 48 * 60 * 60 * 1000,
     /** 2 days. Optional — lapses quietly, no penalty. */
     offer: 48 * 60 * 60 * 1000,
 };
 /** 2 days, in hours — for buyer-facing copy ("pay within 48 hours"). */
 export const LANE_CHECKOUT_WINDOW_HOURS = {
-    auction: LANE_CHECKOUT_WINDOW_MS.auction / (60 * 60 * 1000),
+    "collector-drop": LANE_CHECKOUT_WINDOW_MS["collector-drop"] / (60 * 60 * 1000),
     offer: LANE_CHECKOUT_WINDOW_MS.offer / (60 * 60 * 1000),
 };
 /**
  * A BUYOUT hold is a third window, deliberately much shorter than the two above,
- * even though it lands in the same auction lane.
+ * even though it lands in the same collector drop lane.
  *
- * A settled win (`LANE_CHECKOUT_WINDOW_MS.auction`) is a finished auction: the
+ * A settled win (`LANE_CHECKOUT_WINDOW_MS["collector-drop"]`) is a finished collector drop: the
  * clock already ran, nobody else is waiting, and 48 hours costs no one anything.
- * A buyout is the opposite — the auction is still live and still taking bids
+ * A buyout is the opposite — the collector drop is still live and still taking bids
  * while the hold exists, so a long window would let one buyer sit on a listing
  * they may never pay for. One hour, and the hold is additionally clamped to the
- * auction's own end time by `buyNowAuction` (see `AUCTION_BUYOUT_WINDOW_MS`
- * callers): a buyout that hasn't been paid for by the time the auction ends
- * fails, because by then the auction has settled to whoever actually won it.
+ * collector drop's own end time by `buyNowCollectorDrop` (see `COLLECTOR_DROP_BUYOUT_WINDOW_MS`
+ * callers): a buyout that hasn't been paid for by the time the collector drop ends
+ * fails, because by then the collector drop has settled to whoever actually won it.
  */
-export const AUCTION_BUYOUT_WINDOW_MS = 60 * 60 * 1000;
+export const COLLECTOR_DROP_BUYOUT_WINDOW_MS = 60 * 60 * 1000;
 /** 1 hour, in minutes — for buyer-facing copy ("pay within 60 minutes"). */
-export const AUCTION_BUYOUT_WINDOW_MINUTES = AUCTION_BUYOUT_WINDOW_MS / (60 * 1000);
+export const COLLECTOR_DROP_BUYOUT_WINDOW_MINUTES = COLLECTOR_DROP_BUYOUT_WINDOW_MS / (60 * 1000);
 /**
- * Deep link that drops a buyer straight into the auction lane at checkout.
+ * Deep link that drops a buyer straight into the collector drop lane at checkout.
  *
  * Declared once here, with the lane it selects, because it was previously a
- * const in `auctionSettlement.ts` AND an inline template literal in
+ * const in `collectorDropSettlement.ts` AND an inline template literal in
  * `bid-actions.ts` — the same two-copies problem `LANE_CHECKOUT_WINDOW_MS` was
  * extracted to fix, one layer up.
  */
-export const AUCTION_CHECKOUT_URL = `${String(ROUTES.USER.CHECKOUT)}?lane=${CART_LANE.AUCTION}`;
+export const COLLECTOR_DROP_CHECKOUT_URL = `${String(ROUTES.USER.CHECKOUT)}?lane=${CART_LANE.COLLECTOR_DROP}`;
 /** The two lanes whose price is fixed outside the listing. */
 export function isLockedLane(lane) {
-    return lane === CART_LANE.AUCTION || lane === CART_LANE.OFFER;
+    return lane === CART_LANE.COLLECTOR_DROP || lane === CART_LANE.OFFER;
 }
 export function laneOf(item) {
-    if (item.isAuctionWin || item.bidId)
-        return CART_LANE.AUCTION;
+    if (item.isCollectorDropWin || item.bidId)
+        return CART_LANE.COLLECTOR_DROP;
     if (item.isOffer || item.offerId)
         return CART_LANE.OFFER;
     return CART_LANE.STANDARD;
@@ -113,7 +113,7 @@ export function laneItems(items, lane) {
     return items.filter((i) => laneOf(i) === lane);
 }
 export function laneCounts(items) {
-    const counts = { auction: 0, offer: 0, standard: 0 };
+    const counts = { "collector-drop": 0, offer: 0, standard: 0 };
     for (const item of items)
         counts[laneOf(item)] += 1;
     return counts;
@@ -136,16 +136,16 @@ export function isLaneCheckoutable(items, lane) {
  * whole cart against its own active lane — so every off-lane line was a
  * violation and the throw was unconditional. The consequence was total: a cart
  * holding more than ONE lane could not be checked out by any UI path, with
- * `CHECKOUT_LANE_BLOCKED` and "Settle your 1 won auction first" returned for
+ * `CHECKOUT_LANE_BLOCKED` and "Settle your 1 won collector drop first" returned for
  * the very lane the buyer was already settling.
  *
  * Multi-lane carts are not an edge case — they are what the lane model
- * produces. `auctionSettlement` pushes a won auction straight into the cart
+ * produces. `collectorDropSettlement` pushes a won collector drop straight into the cart
  * whatever is already sitting in it, and `assertCanAddNewItems` only blocks
  * ADDING while a higher lane is pending; it never clears what was there first.
- * So any buyer who had anything in their cart when they won an auction was
+ * So any buyer who had anything in their cart when they won a collector drop was
  * locked out of checkout entirely. That is Root Cause #60's symptom returning
- * by a different mechanism — the auction winner who cannot pay.
+ * by a different mechanism — the collector drop winner who cannot pay.
  *
  * Returning the active lane also makes the server agree with what the buyer is
  * looking at: the cart page scopes its lines, its totals and its CTA to that
@@ -177,8 +177,8 @@ export function defaultCheckoutItems(items) {
  * `cart.items` — every lane — while settle created orders for the active lane
  * only. And multi-lane carts are not an edge case: `defaultCheckoutItems`' own
  * docstring above says they "are what the lane model produces", because
- * `auctionSettlement` pushes a won auction into whatever is already in the
- * cart. So a buyer with a won auction and ordinary items in the cart was
+ * `collectorDropSettlement` pushes a won collector drop into whatever is already in the
+ * cart. So a buyer with a won collector drop and ordinary items in the cart was
  * charged for both and received orders for one.
  *
  * ## The rule
@@ -213,9 +213,9 @@ export function laneBlockReason(items, lane) {
     const counts = laneCounts(items);
     if (counts[lane] === 0)
         return "There's nothing in this tab yet.";
-    if (active === CART_LANE.AUCTION) {
-        const n = counts.auction;
-        return `Settle your ${n} won auction${n === 1 ? "" : "s"} first — auction wins are already committed purchases.`;
+    if (active === CART_LANE.COLLECTOR_DROP) {
+        const n = counts["collector-drop"];
+        return `Settle your ${n} won collector drop${n === 1 ? "" : "s"} first — collector drop wins are already committed purchases.`;
     }
     if (active === CART_LANE.OFFER) {
         const n = counts.offer;

package/dist/_internal/shared/checkout/order-math.d.ts

@@ -6,6 +6,8 @@
  */
 import type { CartItemDocument, CartLineKind } from "../../../features/cart/schemas/firestore";
 import type { ProductDocument } from "../../../features/products/schemas/firestore";
+import type { PayableOrderLike } from "./payout-base";
+export { orderTaxableValue, ordersTaxableValue, linesTaxableValue, commissionRecordRates, type PayableOrderLike, type TaxableLineLike, } from "./payout-base";
 /**
  * Exactly the fields `unitPriceFor` reads.
  *
@@ -28,12 +30,53 @@ export interface PricedCartLine {
         quantity: number;
     }>;
 }
+/** One quantity break: at `quantity` units or more, take `discountPercent` off. */
+export interface BulkDiscountTier {
+    quantity: number;
+    discountPercent: number;
+}
+/**
+ * Resolve the wholesale quantity break that applies at `quantity` units.
+ *
+ * ## 🛑 This field was STORED AND NEVER READ
+ *
+ * `bulkDiscounts` has been declared on `ProductDocument`, validated by the
+ * product zod schema (so the API accepted and persisted it) and carried in the
+ * public projection — with **zero readers anywhere in the tree**. A seller
+ * could save "10+ = 15% off", a buyer could order 10, and be charged full
+ * price. Measured 2026-11-08: three occurrences of the identifier, all three
+ * declarations.
+ *
+ * That is the worst of the three possible states — it looks configured and does
+ * nothing — which is why the owner's ruling was to wire it up rather than
+ * delete it.
+ *
+ * ## The rule
+ *
+ * The BEST applicable tier wins, selected by highest `discountPercent` and not
+ * by position or by highest threshold. Tiers are seller-entered data: nothing
+ * guarantees they arrive sorted, and nothing guarantees they are monotonic, so
+ * `[{10, 15}, {25, 5}]` is a shape a seller can save. Picking by threshold
+ * would charge a buyer of 25 units MORE than a buyer of 10. Picking the best
+ * discount the quantity qualifies for cannot do that.
+ *
+ * Malformed rows are skipped rather than clamped to a boundary: a negative or
+ * non-finite percent is a data error, and treating it as 0 silently applies no
+ * discount where the seller meant one, while treating it as 100 gives the goods
+ * away. Skipping leaves the next-best valid tier to apply.
+ *
+ * `>= 100` is excluded for the same reason — a free line is never what a volume
+ * break means, and it would make the gateway capture ₹0 on a real order.
+ *
+ * Returns 0 when nothing applies, so the caller multiplies by 1.
+ */
+export declare function resolveBulkDiscountPercent(tiers: readonly BulkDiscountTier[] | null | undefined, quantity: number): number;
 /**
  * The single source of truth for "what do we charge for ONE COPY of this line".
  *
- * Four cases, in priority order:
+ * Five cases, in priority order:
  *
- *  1. **A locked price** — an accepted offer or a won auction. `lockedPrice` is
+ *  1. **A locked price** — an accepted offer or a won collector drop. `lockedPrice` is
  *     the negotiated/won amount and it OVERRIDES the current listing price, which
  *     is the whole point of the negotiation. Until 2026-08-21 none of the five
  *     copies of this function looked at `lockedPrice`, so an accepted offer was
@@ -49,6 +92,11 @@ export interface PricedCartLine {
  *     see the invariant on `CartLineMember`.
  *  4. **Everything else** — the live Firestore price, so a stale cart-cached
  *     price is never charged on a COD/UPI order.
+ *  5. **…less a wholesale quantity break**, when the live listing declares
+ *     `bulkDiscounts` and this line's quantity qualifies. Last on purpose:
+ *     cases 1–3 return before it, so a negotiated price, a bundle price and a
+ *     group's member sum can never have a tier stacked on top of them. See
+ *     `resolveBulkDiscountPercent`.
  *
  * `product` may be null for a locked line whose listing has since been archived;
  * the locked price is still owed, so that case must not dereference `product`.
@@ -206,20 +254,6 @@ export interface GroupGstSummary {
  * items), which is the only case where proportion is undefined.
  */
 export declare function allocateAcrossMembers(total: number, weights: number[]): number[];
-/** Exactly the fields `orderGoodsValue` / `orderTaxableValue` read. */
-export interface PayableOrderLike {
-    items?: Array<{
-        quantity: number;
-        unitPrice: number;
-        cancelledQuantity?: number;
-        /** Snapshotted at purchase. Absent or 0 means no tax to back out. */
-        gstRate?: number;
-    }>;
-    /** The flat shape, authoritative when `items` is absent. */
-    quantity?: number;
-    unitPrice?: number;
-    gstRate?: number;
-}
 /**
  * The GOODS VALUE of an order — the only correct base for a seller payout.
  *
@@ -258,40 +292,6 @@ export interface PayableOrderLike {
 export declare function orderGoodsValue(order: PayableOrderLike): number;
 /** Sum of `orderGoodsValue` across orders — the GROSS, not the payout base. */
 export declare function ordersGoodsValue(orders: readonly PayableOrderLike[]): number;
-/**
- * The TAXABLE VALUE of an order — **the payout base.**
- *
- * 🛑 This is the second of two narrowings, and the distinction between them is
- * worth keeping straight:
- *
- *  - C0 established the base is the **goods value**, not the order grand total
- *    (which folded in GST, the platform fee the buyer already paid, shipping,
- *    COD handling, add-ons and the EMI surcharge).
- *  - This establishes it is the **taxable value**, not the gross goods value —
- *    because every price here is tax-INCLUSIVE, so the goods value still has
- *    our GST sitting inside it, and paying that out is the very thing C0 set
- *    out to stop.
- *
- * The second narrowing was not possible until the pricing model was settled:
- * under the old add-on-top math the goods value WAS the taxable value, so the
- * two were indistinguishable and C0's fix was complete as written.
- *
- * One sentence covers both seller modes, which is the reason the flag is an
- * authoring convenience and nothing more:
- *
- *   **the payout base is the taxable value, never the gross.**
- *
- *   - inclusive seller, ₹999 @5% → buyer pays ₹999, taxable ₹951.43, payout ₹951.43
- *   - exclusive seller types ₹999 → grossed up on write to ₹1,048.95, buyer
- *     pays ₹1,048.95, taxable ₹999.00, payout ₹999.00
- *
- * Per ITEM, using each line's own snapshotted `gstRate`: a mixed 5% + 18%
- * order cannot be backed out with a single blended rate, and an order-level
- * rate does not exist.
- */
-export declare function orderTaxableValue(order: PayableOrderLike): number;
-/** Sum of `orderTaxableValue` across orders — the payout base for a batch. */
-export declare function ordersTaxableValue(orders: readonly PayableOrderLike[]): number;
 /** The subset `orderShippingReimbursement` reads. */
 export interface ReimbursableOrderLike {
     platformBookedShipment?: boolean;