@mohasinac/appkit 4.42.13 → 4.42.14

package/dist/_internal/server/features/checkout/actions.js

@@ -19,7 +19,7 @@ import { sendOrderConfirmationEmail } from "../../../../features/contact/server"
 import { splitCartIntoOrderGroups } from "../../../../features/orders/index";
 import { resolveCouponCategorySlugs } from "../../../../features/promotions/actions/coupon-actions";
 import { assertCheckoutLane, assertLockedLinesStillValid, finalizeLockedLines, } from "./locked-lines";
-import { activeLane, laneOf } from "../../../shared/checkout/lanes";
+import { activeLane, defaultCheckoutItems, laneOf, } from "../../../shared/checkout/lanes";
 import { computeCodHandlingFee, computeWhatsAppNotifyFee, computeGiftWrapFee, computeShipmentProtectionFee, computeCheckoutFees, allocateCheckoutFees, } from "../../../shared/fees/calculator";
 import { getAdminDb, getAdminRealtimeDb, RTDB_PATHS, } from "../../../../providers/db-firebase";
 import { PRODUCT_COLLECTION, PRODUCT_CODES_SUBCOLLECTION } from "../../../../features/products/schemas/firestore";
@@ -655,8 +655,13 @@ export async function createCheckoutOrderAction(input) {
     const selectedSet = cart.selectedItemIds?.length
         ? new Set(cart.selectedItemIds)
         : null;
-    const cartItems = cart.items.filter((item) => !excludedSet.has(item.productId) &&
-        (!selectedSet || selectedSet.has(item.itemId)));
+    // No explicit selection means THE ACTIVE LANE, not the whole cart — see
+    // defaultCheckoutItems. Falling back to every line made assertCheckoutLane
+    // below throw on any multi-lane cart, which is most of them.
+    const candidateItems = selectedSet
+        ? cart.items.filter((item) => selectedSet.has(item.itemId))
+        : defaultCheckoutItems(cart.items);
+    const cartItems = candidateItems.filter((item) => !excludedSet.has(item.productId));
     if (cartItems.length === 0) {
         throw new ValidationError(ERROR_MESSAGES.CHECKOUT.CART_EMPTY);
     }
@@ -1426,11 +1431,17 @@ export async function verifyAndPlacePhonePeOrderAction(input) {
         throw new ValidationError(ERROR_MESSAGES.CHECKOUT.CART_EMPTY);
     }
     // Same lane priority + locked-line revalidation the manual/COD path runs.
-    // The PhonePe path settles the whole cart (no selectedItemIds), so the
-    // "selected" set is the cart itself.
-    assertCheckoutLane(cart.items, cart.items);
-    await assertLockedLinesStillValid(cart.items, uid);
-    const isDigitalCartPp = cartIsDigitalOnly(cart.items);
+    //
+    // 🛑 This path carries no selectedItemIds, so it settles the ACTIVE LANE —
+    // not the cart. It used to pass `cart.items` as its own "selected" set,
+    // which made assertCheckoutLane compare the whole cart against its own
+    // active lane and throw on every multi-lane cart. Everything downstream
+    // reads `settleItems` for the same reason: stock decrements, jurisdiction
+    // and the order rows must cover exactly what was charged for.
+    const settleItems = defaultCheckoutItems(cart.items);
+    assertCheckoutLane(cart.items, settleItems);
+    await assertLockedLinesStillValid(settleItems, uid);
+    const isDigitalCartPp = cartIsDigitalOnly(settleItems);
     let shippingAddress;
     let resolvedAddressPp = null;
     if (!isDigitalCartPp) {
@@ -1451,7 +1462,7 @@ export async function verifyAndPlacePhonePeOrderAction(input) {
     // cart line gets paired with a "representative" product (first member id
     // for bundles, productId for regular items). The full bundle-member
     // decrement runs against `expansionPaid.decrements` lower down.
-    const expansionPaid = getExpandedDecrements(cart.items);
+    const expansionPaid = getExpandedDecrements(settleItems);
     const productByIdPaid = new Map();
     // Independent reads across distinct product docs — batch them instead of
     // awaiting one findById per product (mirrors the COD/UPI path above, which
@@ -1462,7 +1473,7 @@ export async function verifyAndPlacePhonePeOrderAction(input) {
         if (product)
             productByIdPaid.set(pid, product);
     });
-    const productChecks = cart.items.map((item) => {
+    const productChecks = settleItems.map((item) => {
         const [firstMember] = getCartItemMemberIds(item);
         const product = productByIdPaid.get(firstMember) ?? null;
         return { item, product };
@@ -1481,7 +1492,7 @@ export async function verifyAndPlacePhonePeOrderAction(input) {
     runSyncPreflight(preflightPairs, "online");
     // SB-UNI-O 2026-05-15 — Live-item jurisdiction guard.
     if (!isDigitalCartPp && resolvedAddressPp) {
-        assertLiveJurisdiction(cart.items, productByIdPaid, resolvedAddressPp.state);
+        assertLiveJurisdiction(settleItems, productByIdPaid, resolvedAddressPp.state);
     }
     // SB-UNI-5 — validate every required member product across the cart with
     // cumulative decrement awareness (two bundles sharing a member must NOT
@@ -1491,7 +1502,7 @@ export async function verifyAndPlacePhonePeOrderAction(input) {
     // ALREADY been captured for the full cart by the time this runs — so
     // "skip_items" here means placing orders for the available items only and
     // auto-refunding the dropped items' value (below), not skipping payment.
-    const bucketedPaid = bucketCartItemsByStock(cart.items, productByIdPaid, expansionPaid.decrements, (item) => productByIdPaid.get(getCartItemMemberIds(item)[0]) ?? null);
+    const bucketedPaid = bucketCartItemsByStock(settleItems, productByIdPaid, expansionPaid.decrements, (item) => productByIdPaid.get(getCartItemMemberIds(item)[0]) ?? null);
     const unavailablePaid = bucketedPaid.unavailable;
     if (unavailablePaid.length > 0) {
         for (const u of unavailablePaid) {

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

@@ -73,6 +73,31 @@ export declare function laneCounts(items: readonly LaneAssignable[]): Record<Car
  */
 export declare function activeLane(items: readonly LaneAssignable[]): CartLane | null;
 export declare function isLaneCheckoutable(items: readonly LaneAssignable[], lane: CartLane): boolean;
+/**
+ * The items a checkout settles when the buyer has made no explicit selection.
+ *
+ * 🛑 This MUST be the active lane, never the whole cart. Both placement paths
+ * used to fall back to `cart.items`, and `assertCheckoutLane` then compared the
+ * 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
+ * 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
+ * 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
+ * locked out of checkout entirely. That is Root Cause #60's symptom returning
+ * by a different mechanism — the auction 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
+ * same lane, and renders no selection control at all, so "no explicit
+ * selection" means "the lane on screen" and can mean nothing else.
+ */
+export declare function defaultCheckoutItems<T extends LaneAssignable>(items: readonly T[]): T[];
 /**
  * Why `lane` can't be checked out right now — null when it can.
  * Phrased for the buyer, naming the lane that's blocking and what to do.

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

@@ -128,6 +128,34 @@ export function activeLane(items) {
 export function isLaneCheckoutable(items, lane) {
     return activeLane(items) === lane;
 }
+/**
+ * The items a checkout settles when the buyer has made no explicit selection.
+ *
+ * 🛑 This MUST be the active lane, never the whole cart. Both placement paths
+ * used to fall back to `cart.items`, and `assertCheckoutLane` then compared the
+ * 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
+ * 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
+ * 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
+ * locked out of checkout entirely. That is Root Cause #60's symptom returning
+ * by a different mechanism — the auction 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
+ * same lane, and renders no selection control at all, so "no explicit
+ * selection" means "the lane on screen" and can mean nothing else.
+ */
+export function defaultCheckoutItems(items) {
+    const active = activeLane(items);
+    return active ? laneItems(items, active) : [...items];
+}
 /**
  * Why `lane` can't be checked out right now — null when it can.
  * Phrased for the buyer, naming the lane that's blocking and what to do.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mohasinac/appkit",
-  "version": "4.42.13",
+  "version": "4.42.14",
   "license": "MIT",
   "publishConfig": {
     "access": "public"