@mohasinac/appkit 4.11.0 → 4.11.2

package/dist/features/auctions/components/AuctionsListView.js

@@ -1,62 +1,21 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { sieveFilter, SIEVE_OP } from "@mohasinac/appkit";
-import { productRepository } from "../../../repositories";
 import { Container, Heading, Main, Section } from "../../../ui";
 import { AdSlot } from "../../homepage/components/AdSlot";
-import { parseListingSearchParams } from "../../../utils/listing-params";
 import { AuctionsIndexListing } from "../../products/components/AuctionsIndexListing";
-const DEFAULT_PAGE = 1;
+import { listPublicProducts, parsePublicProductParams, } from "../../../_internal/server/features/products/list-public";
+const AUCTION_LISTING_TYPES = ["auction"];
 const DEFAULT_PAGE_SIZE = 24;
 const DEFAULT_SORT = "auctionEndDate";
-function sp(params, key) {
-    const v = params[key];
-    return Array.isArray(v) ? v[0] ?? "" : v ?? "";
-}
-function buildAuctionFilters(params) {
-    const parts = ["status==published", "listingType==auction"];
-    const minBid = sp(params, "minBid");
-    const maxBid = sp(params, "maxBid");
-    if (minBid)
-        parts.push(sieveFilter("currentBid", SIEVE_OP.GTE, minBid));
-    if (maxBid)
-        parts.push(sieveFilter("currentBid", SIEVE_OP.LTE, maxBid));
-    const store = sp(params, "store");
-    if (store) {
-        const values = store.split("|").filter(Boolean);
-        if (values.length === 1)
-            parts.push(sieveFilter("storeId", SIEVE_OP.EQ, values[0]));
-        else if (values.length > 1)
-            parts.push(sieveFilter("storeId", SIEVE_OP.EQ, values.join("|")));
-    }
-    // Mirror AuctionsIndexListing's client-side default (Root Cause pattern —
-    // SSR initialData is seeded into React Query with staleTime:Infinity, so if
-    // this SSR filter doesn't already exclude ended auctions, the client never
-    // refetches and ended auctions leak into the default "Show ended" off view).
-    const showEnded = sp(params, "showEnded") === "true";
-    const dateFrom = showEnded
-        ? sp(params, "dateFrom")
-        : sp(params, "dateFrom") || new Date().toISOString();
-    const dateTo = sp(params, "dateTo");
-    if (dateFrom)
-        parts.push(sieveFilter("auctionEndDate", SIEVE_OP.GTE, dateFrom));
-    if (dateTo)
-        parts.push(sieveFilter("auctionEndDate", SIEVE_OP.LTE, dateTo));
-    return parts.join(",");
-}
 export async function AuctionsListView({ searchParams = {} }) {
-    const std = parseListingSearchParams(searchParams);
-    const sort = std.sorts ?? DEFAULT_SORT;
-    const page = std.page ?? DEFAULT_PAGE;
-    const pageSize = std.pageSize ?? DEFAULT_PAGE_SIZE;
-    const filters = buildAuctionFilters(searchParams);
-    const result = await productRepository
-        .list({
-        filters,
-        sorts: sort,
-        page,
-        pageSize,
-    })
-        .catch(() => null);
-    const initial = result ?? null;
+    // Shared with /api/products. `hideEndedByDefault` mirrors
+    // AuctionsIndexListing's `showEnded ? … : dateFrom=now` default; because the
+    // default sort IS auctionEndDate, listPublicProducts pushes that range into
+    // Firestore rather than filtering in memory.
+    const initial = await listPublicProducts(parsePublicProductParams(searchParams, {
+        listingTypes: AUCTION_LISTING_TYPES,
+        pageSize: DEFAULT_PAGE_SIZE,
+        sorts: DEFAULT_SORT,
+        hideEndedByDefault: true,
+    }));
     return (_jsx(Main, { children: _jsx(Section, { padding: "y-2xl", children: _jsxs(Container, { size: "xl", children: [_jsx(Heading, { level: 1, className: "mb-8", color: "primary", size: "3xl", weight: "semibold", children: "Live Auctions" }), _jsx(AdSlot, { id: "listing-sidebar-top", className: "mb-6" }), _jsx(AuctionsIndexListing, { initialData: initial }), _jsx(AdSlot, { id: "listing-sidebar-bottom", className: "mt-8" })] }) }) }));
 }

package/dist/features/auctions/components/PlaceBidFormClient.js

@@ -96,7 +96,16 @@ export function PlaceBidFormClient({ productId, currentBid: ssrCurrentBid, start
                     return;
                 }
                 setSuccess(true);
-                router.refresh();
+                // Buy-Now writes a locked cart line, so send the buyer straight to the
+                // auction checkout lane to pay for it. This used to just call
+                // `router.refresh()` and discard the action's result entirely, leaving
+                // the buyer on the product page with no indication that anything was
+                // owed — the action returned an orderId nobody ever used.
+                const checkoutUrl = result?.checkoutUrl;
+                if (checkoutUrl)
+                    router.push(checkoutUrl);
+                else
+                    router.refresh();
             }
             catch (err) {
                 void normalizeError(err);

package/dist/features/auctions/repository/bid.repository.d.ts

@@ -50,6 +50,21 @@ export declare class BidRepository extends BaseRepository<BidDocument> {
         data: BidDocument;
     } | null>;
     markWon(batch: WriteBatch, ref: DocumentReference): void;
+    /**
+     * Link a won bid to the order it eventually became.
+     *
+     * `BidDocument` had no `orderId` at all before 2026-08-21, so a won bid and
+     * the thing the buyer paid for were two unrelated records — the "Won" row in
+     * /user/bids could not link anywhere, and nothing could tell a settled win
+     * from an unpaid one.
+     */
+    attachOrder(bidId: string, orderId: string): Promise<void>;
+    /**
+     * The winner never paid within their checkout window. Distinct from "lost"
+     * (outbid) — this bidder won and then defaulted, which a seller may want to
+     * act on.
+     */
+    markForfeited(bidId: string): Promise<void>;
     markLost(batch: WriteBatch, ref: DocumentReference): void;
     markOutbid(batch: WriteBatch, ref: DocumentReference): void;
     markWinning(batch: WriteBatch, ref: DocumentReference): void;

package/dist/features/auctions/repository/bid.repository.js

@@ -122,6 +122,25 @@ export class BidRepository extends BaseRepository {
             updatedAt: new Date(),
         });
     }
+    /**
+     * Link a won bid to the order it eventually became.
+     *
+     * `BidDocument` had no `orderId` at all before 2026-08-21, so a won bid and
+     * the thing the buyer paid for were two unrelated records — the "Won" row in
+     * /user/bids could not link anywhere, and nothing could tell a settled win
+     * from an unpaid one.
+     */
+    async attachOrder(bidId, orderId) {
+        await this.update(bidId, { orderId, updatedAt: new Date() });
+    }
+    /**
+     * The winner never paid within their checkout window. Distinct from "lost"
+     * (outbid) — this bidder won and then defaulted, which a seller may want to
+     * act on.
+     */
+    async markForfeited(bidId) {
+        await this.update(bidId, { status: "forfeited", isWinning: false, updatedAt: new Date() });
+    }
     markLost(batch, ref) {
         batch.update(ref, {
             status: "lost",

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

@@ -3,7 +3,9 @@
  */
 import { type GenerateBidIdInput } from "../../../utils/id-generators";
 import type { BaseDocument } from "../../../_internal/shared/types/base-document";
-export type BidStatus = "active" | "outbid" | "won" | "lost" | "cancelled";
+export type BidStatus = "active" | "outbid" | "won" | "lost" | "cancelled"
+/** Won, then the buyer let the 48h payment window lapse. */
+ | "forfeited";
 /** Runtime-accessible bid status values — use instead of bare string literals. */
 export declare const BidStatusValues: {
     readonly ACTIVE: "active";
@@ -11,6 +13,7 @@ export declare const BidStatusValues: {
     readonly WON: "won";
     readonly LOST: "lost";
     readonly CANCELLED: "cancelled";
+    readonly FORFEITED: "forfeited";
 };
 export interface BidDocument extends BaseDocument {
     productId: string;
@@ -25,6 +28,13 @@ export interface BidDocument extends BaseDocument {
     previousBidAmount?: number;
     bidDate: Date;
     autoMaxBid?: number;
+    /**
+     * The order this winning bid was settled into. Written by
+     * `finalizeLockedLines` once the winner actually pays; absent on a won-but-
+     * unpaid bid, which is what lets /user/bids show a "Pay now" CTA rather than
+     * a dead status badge.
+     */
+    orderId?: string;
 }
 export declare const BID_COLLECTION: "bids";
 export declare const BID_INDEXED_FIELDS: readonly ["productId", "userId", "status", "isWinning", "bidDate", "createdAt"];

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

@@ -9,6 +9,7 @@ export const BidStatusValues = {
     WON: "won",
     LOST: "lost",
     CANCELLED: "cancelled",
+    FORFEITED: "forfeited",
 };
 export const BID_COLLECTION = "bids";
 export const BID_INDEXED_FIELDS = [

package/dist/features/cart/actions/cart-actions.d.ts

@@ -6,6 +6,17 @@
  */
 import type { AddToCartInput, CartDocument, UpdateCartItemInput } from "../schemas";
 export declare function addItemToCart(userId: string, input: AddToCartInput): Promise<CartDocument>;
+/** Error code the client maps to a lane-aware message. */
+export declare const CART_LANE_BLOCKED = "CART_LANE_BLOCKED";
+/**
+ * Won-auction lines are non-removable and fixed-quantity — the buyer committed
+ * to the purchase by bidding, and letting them delete it would turn every
+ * auction into a free option. That's already enforced one layer down:
+ * `cartRepository.updateItem` / `removeItem` both reject a `locked` line, and
+ * auction settlement is the only writer that sets `locked: true`. Accepted
+ * offers deliberately do NOT set it — declining to buy is the buyer's right,
+ * and the offer simply lapses at its `checkoutDeadline`.
+ */
 export declare function updateCartItem(userId: string, itemId: string, input: UpdateCartItemInput): Promise<CartDocument>;
 export declare function removeCartItem(userId: string, itemId: string): Promise<CartDocument>;
 export declare function clearCart(userId: string): Promise<CartDocument>;

package/dist/features/cart/actions/cart-actions.js

@@ -11,6 +11,7 @@ import { productRepository } from "../../products/repository/products.repository
 import { storeRepository } from "../../stores/repository/store.repository";
 import { normalizeListingType } from "../../products/utils/listing-type";
 import { getDefaultCurrency } from "../../../core/baseline-resolver";
+import { CART_LANE, activeLane, canAddNewItems, } from "../../../_internal/shared/checkout/lanes";
 /**
  * Product documents don't always carry a denormalized `storeName` — the
  * create routes only set it when the caller explicitly passes one, so
@@ -35,9 +36,32 @@ export async function addItemToCart(userId, input) {
     if (!canAddToCart(input.listingType)) {
         throw new ValidationError(`Listings of type "${input.listingType}" cannot be added to the cart.`);
     }
+    // Lane gate. While a higher-obligation lane (a won auction, then an accepted
+    // offer) is outstanding, no NEW shopping may be added — otherwise the buyer
+    // can keep deferring something they already committed to by piling more into
+    // the cart. Enforced here, on the server, not only in the UI: the UI hint is
+    // a courtesy, this is the rule.
+    const cart = await cartRepository.getOrCreate(userId);
+    if (!canAddNewItems(cart.items ?? [])) {
+        const blocking = activeLane(cart.items ?? []);
+        throw new ValidationError(blocking === CART_LANE.AUCTION
+            ? "Settle your won auction first — you can add other items once it's paid for."
+            : "Complete your accepted offer first — you can add other items once it's paid for.", { code: CART_LANE_BLOCKED });
+    }
     const storeName = await resolveStoreName(input.storeId, input.storeName);
     return cartRepository.addItem(userId, { ...input, storeName });
 }
+/** Error code the client maps to a lane-aware message. */
+export const CART_LANE_BLOCKED = "CART_LANE_BLOCKED";
+/**
+ * Won-auction lines are non-removable and fixed-quantity — the buyer committed
+ * to the purchase by bidding, and letting them delete it would turn every
+ * auction into a free option. That's already enforced one layer down:
+ * `cartRepository.updateItem` / `removeItem` both reject a `locked` line, and
+ * auction settlement is the only writer that sets `locked: true`. Accepted
+ * offers deliberately do NOT set it — declining to buy is the buyer's right,
+ * and the offer simply lapses at its `checkoutDeadline`.
+ */
 export async function updateCartItem(userId, itemId, input) {
     return cartRepository.updateItem(userId, itemId, input);
 }

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

@@ -1,7 +1,7 @@
 import type { DocumentReference } from "firebase-admin/firestore";
 import type { DocumentSnapshot } from "../../../providers/db-firebase";
 import { BaseRepository, type FirebaseSieveResult, type SieveModel } from "../../../providers/db-firebase";
-import { type AddToCartInput, type CartAppliedCoupon, type CartDocument, type UpdateCartItemInput } from "../schemas";
+import { type AddToCartInput, type CartAppliedCoupon, type CartDocument, type CartItemDocument, type UpdateCartItemInput } from "../schemas";
 export declare class CartRepository extends BaseRepository<CartDocument> {
     private static readonly SIEVE_FIELDS;
     constructor();
@@ -19,6 +19,29 @@ export declare class CartRepository extends BaseRepository<CartDocument> {
     getSubtotal(cart: CartDocument): number;
     addCoupon(userId: string, coupon: CartAppliedCoupon): Promise<void>;
     removeCoupon(userId: string, code: string): Promise<void>;
+    /**
+     * Drop every locked line matching a predicate, bypassing the `locked` guard
+     * that blocks user-initiated removal.
+     *
+     * Only the expiry sweeps call this: a locked line whose claim has lapsed must
+     * be cleared, or it keeps the buyer's auction/offer lane non-empty forever
+     * and the lane gate blocks their ordinary checkout on something they can no
+     * longer act on.
+     */
+    private removeLockedLines;
+    /** Clear the cart line created for a specific accepted offer. */
+    removeItemsByOfferId(userId: string, offerId: string): Promise<number>;
+    /** Clear the cart line created for a specific won auction bid. */
+    removeItemsByBidId(userId: string, bidId: string): Promise<number>;
+    /**
+     * Every locked line across all carts whose `checkoutDeadline` has passed.
+     * Bounded per Rule #6 — the sweep runs on a schedule, so a backlog drains
+     * over successive runs rather than in one unbounded scan.
+     */
+    findExpiredLockedLines(now: Date, limit?: number): Promise<Array<{
+        userId: string;
+        item: CartItemDocument;
+    }>>;
     updateItemShipping(userId: string, itemId: string, providerId: string, fee: number): Promise<CartDocument>;
     clearAllCoupons(userId: string): Promise<void>;
     setSelectedItems(userId: string, itemIds: string[] | null): Promise<void>;

package/dist/features/cart/repository/cart.repository.js

@@ -61,14 +61,20 @@ export class CartRepository extends BaseRepository {
         try {
             const cart = await this.getOrCreate(userId);
             const items = [...cart.items];
-            if (input.offerId) {
-                const alreadyAdded = items.some((item) => item.offerId === input.offerId);
-                if (alreadyAdded)
-                    return cart;
+            // A locked line (accepted offer / won auction) is identified by its
+            // offerId or bidId, never merged by productId — two separate wins on the
+            // same listing are two separate obligations, and re-running the
+            // settlement sweep must not duplicate a line it already wrote.
+            if (input.offerId && items.some((item) => item.offerId === input.offerId)) {
+                return cart;
             }
-            const existingIndex = input.offerId
+            if (input.bidId && items.some((item) => item.bidId === input.bidId)) {
+                return cart;
+            }
+            const isLockedLine = Boolean(input.offerId || input.bidId);
+            const existingIndex = isLockedLine
                 ? -1
-                : items.findIndex((item) => item.productId === input.productId && !item.offerId);
+                : items.findIndex((item) => item.productId === input.productId && !item.offerId && !item.bidId);
             if (existingIndex >= 0) {
                 items[existingIndex] = {
                     ...items[existingIndex],
@@ -90,9 +96,15 @@ export class CartRepository extends BaseRepository {
                     listingType: input.listingType,
                     ...(input.isOffer !== undefined && { isOffer: input.isOffer }),
                     ...(input.offerId !== undefined && { offerId: input.offerId }),
+                    ...(input.isAuctionWin !== undefined && { isAuctionWin: input.isAuctionWin }),
+                    ...(input.auctionId !== undefined && { auctionId: input.auctionId }),
+                    ...(input.bidId !== undefined && { bidId: input.bidId }),
                     ...(input.lockedPrice !== undefined && {
                         lockedPrice: input.lockedPrice,
                     }),
+                    ...(input.checkoutDeadline !== undefined && {
+                        checkoutDeadline: input.checkoutDeadline,
+                    }),
                     ...(input.locked !== undefined && { locked: input.locked }),
                     // SB-UNI-4 2026-05-13 — propagate bundle identifiers when present.
                     ...(input.bundleCategorySlug !== undefined && {
@@ -231,6 +243,59 @@ export class CartRepository extends BaseRepository {
             .doc(userId)
             .set({ appliedCoupons: updated, updatedAt: new Date() }, { merge: true });
     }
+    /**
+     * Drop every locked line matching a predicate, bypassing the `locked` guard
+     * that blocks user-initiated removal.
+     *
+     * Only the expiry sweeps call this: a locked line whose claim has lapsed must
+     * be cleared, or it keeps the buyer's auction/offer lane non-empty forever
+     * and the lane gate blocks their ordinary checkout on something they can no
+     * longer act on.
+     */
+    async removeLockedLines(userId, matches) {
+        const cart = await this.findByUserId(userId);
+        if (!cart)
+            return 0;
+        const items = cart.items.filter((item) => !matches(item));
+        const removed = cart.items.length - items.length;
+        if (removed === 0)
+            return 0;
+        await this.db
+            .collection(this.collection)
+            .doc(userId)
+            .set(prepareForFirestore({ ...cart, items, updatedAt: new Date() }));
+        return removed;
+    }
+    /** Clear the cart line created for a specific accepted offer. */
+    async removeItemsByOfferId(userId, offerId) {
+        return this.removeLockedLines(userId, (item) => item.offerId === offerId);
+    }
+    /** Clear the cart line created for a specific won auction bid. */
+    async removeItemsByBidId(userId, bidId) {
+        return this.removeLockedLines(userId, (item) => item.bidId === bidId);
+    }
+    /**
+     * Every locked line across all carts whose `checkoutDeadline` has passed.
+     * Bounded per Rule #6 — the sweep runs on a schedule, so a backlog drains
+     * over successive runs rather than in one unbounded scan.
+     */
+    async findExpiredLockedLines(now, limit = 200) {
+        const snapshot = await this.getCollection().limit(limit).get();
+        const out = [];
+        for (const doc of snapshot.docs) {
+            const cart = this.mapDoc(doc);
+            for (const item of cart.items ?? []) {
+                if (!item.checkoutDeadline)
+                    continue;
+                const deadline = item.checkoutDeadline instanceof Date
+                    ? item.checkoutDeadline
+                    : new Date(item.checkoutDeadline);
+                if (deadline <= now)
+                    out.push({ userId: cart.userId ?? doc.id, item });
+            }
+        }
+        return out;
+    }
     async updateItemShipping(userId, itemId, providerId, fee) {
         try {
             const cart = await this.findByUserId(userId);

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

@@ -20,15 +20,32 @@ export interface CartItemDocument {
     /**
      * Snapshot of the product's listing-kind at add-to-cart time (SB1-G Phase 4).
      * Drives order-grouping (auctions/pre-orders settle separately from standard
-     * carts) and cart-side UI badges. Replaces the legacy `isAuction`/`isPreOrder`
+     * carts) and cart-side UI badges. Replaces the legacy `isAuctionWin`/`isPreOrder`
      * pair on the cart item.
      */
     listingType: ListingType;
     /** True when item was added from an accepted Make-an-Offer */
     isOffer?: boolean;
     offerId?: string;
-    /** Locked offer price — overrides normal product price at checkout */
+    /**
+     * True when the line was created by auction settlement for the winning
+     * bidder. Auctions are `canAddToCart: false` for user-initiated adds — this
+     * line is written by the settlement job through the repository directly, and
+     * is the ONLY way an auction reaches the cart.
+     */
+    isAuctionWin?: boolean;
+    /** The auction product this win refers to (= productId, kept explicit). */
+    auctionId?: string;
+    /** The winning bid, so the resulting order can be linked back to it. */
+    bidId?: string;
+    /** Locked offer/winning-bid price — overrides normal product price at checkout */
     lockedPrice?: number;
+    /**
+     * When the claim on this locked price lapses. Mirrors the offer's own
+     * `checkoutDeadline`; set to now + 48h for a won auction. The expiry sweep
+     * clears lines past this point.
+     */
+    checkoutDeadline?: Date;
     /** When true the item cannot be removed or have its quantity changed. Set on won-auction and accepted-offer items that require mandatory payment. */
     locked?: boolean;
     /**
@@ -114,7 +131,11 @@ export type AddToCartInput = {
     listingType: ListingType;
     isOffer?: boolean;
     offerId?: string;
+    isAuctionWin?: boolean;
+    auctionId?: string;
+    bidId?: string;
     lockedPrice?: number;
+    checkoutDeadline?: Date;
     locked?: boolean;
     /** SB-UNI-4 2026-05-13 — bundle identifier when the line is a bundle. */
     bundleCategorySlug?: string;

package/dist/features/contact/email.js

@@ -13,6 +13,8 @@ function renderToStaticMarkup(el) {
 }
 import { normalizeError } from "../../errors/normalize";
 import { getProviders } from "../../contracts";
+import { createResendProvider } from "../../providers/email-resend/provider";
+import { siteSettingsRepository } from "../admin/repository/site-settings.repository";
 import { serverLogger } from "../../monitoring";
 import { currentYear, formatCurrency, formatDateTime, nowMs, } from "../../utils";
 import { EmailBold, EmailButton, EmailContainer, EmailDivider, EmailDoc, EmailFooter, EmailHeader, EmailLink, EmailRow, } from "../email/primitives";
@@ -25,9 +27,58 @@ function getSiteUrl() {
 function getSupportEmail() {
     return process.env.EMAIL_SUPPORT?.trim() || "support@example.com";
 }
+/**
+ * Resolve an email provider that works in BOTH runtimes.
+ *
+ * The provider registry is populated by the consumer's `providers.config.ts`,
+ * which only runs from the Next.js instrumentation hook. Firebase Functions
+ * never call `registerProviders()`, so `getProviders()` throws there —
+ * silently failing every Functions-side `sendEmail()` with
+ * "Call registerProviders() before getProviders()". That is why the scheduled
+ * dailyStatusDigest never delivered: `sendEmail` catches the throw and returns
+ * it as `{ error }`, so it surfaced only as a logged "send failed".
+ *
+ * Falling back to a directly-constructed Resend provider mirrors exactly what
+ * `sendNotification()` already does for Functions-side email — Firestore
+ * credentials first, env vars second — so both paths resolve identically
+ * instead of one runtime silently having no provider at all.
+ */
+async function resolveEmailProvider() {
+    try {
+        return getProviders().email;
+    }
+    catch {
+        const [creds, settings] = await Promise.all([
+            siteSettingsRepository.getDecryptedCredentials().catch((err) => {
+                void normalizeError(err);
+                return {};
+            }),
+            siteSettingsRepository.getSingleton().catch((err) => {
+                void normalizeError(err);
+                return null;
+            }),
+        ]);
+        // A seeded placeholder ("re_PLACEHOLDER") is truthy but not a real key and
+        // must never win over a real env var — same guard as providers.config.ts.
+        const seeded = creds.resendApiKey?.trim() ?? "";
+        const apiKey = seeded && !seeded.includes("PLACEHOLDER")
+            ? seeded
+            : (process.env.RESEND_API_KEY?.trim() ?? "");
+        return createResendProvider({
+            apiKey,
+            fromEmail: settings?.emailSettings?.fromEmail?.trim() ||
+                process.env.EMAIL_FROM?.trim() ||
+                "",
+            fromName: settings?.emailSettings?.fromName?.trim() ||
+                process.env.EMAIL_FROM_NAME?.trim() ||
+                "App",
+        });
+    }
+}
 export async function sendEmail(opts) {
     try {
-        const data = await getProviders().email.send({
+        const provider = await resolveEmailProvider();
+        const data = await provider.send({
             to: opts.to,
             subject: opts.subject,
             html: typeof opts.html === "string" ? opts.html : "",

package/dist/features/grouped/components/GroupedListingsCarousel.js

@@ -3,7 +3,10 @@ import { jsx as _jsx } from "react/jsx-runtime";
 import { pluginFor } from "../../../_internal/shared/listing-types/_registry";
 import { SectionCarousel } from "../../homepage/components/SectionCarousel";
 import { ProductCard } from "../../products/components/ProductGrid";
-import { toProductItem } from "../../../_internal/server/features/products/data";
+// Must come from _internal/shared — importing this as a VALUE from
+// _internal/server/.../data.ts pulled firebase-admin into the client bundle
+// and failed the Turbopack production build (Root Cause #6).
+import { toProductItem } from "../../../_internal/shared/features/products/to-product-item";
 import { CAROUSEL_PER_VIEW } from "../../homepage/constants/carousel-per-view";
 import { Stack } from "../../../ui";
 const GROUP_THEME_TITLE = {

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

@@ -293,21 +293,6 @@ declare class OrderRepository extends BaseRepository<OrderDocument> {
      * Cloud Functions: stage a cancellation update into a caller-owned WriteBatch.
      */
     cancelInBatch(batch: WriteBatch, ref: DocumentReference): void;
-    /**
-     * Cloud Functions: create an auction-won order inside a caller-owned WriteBatch.
-     * Returns the new DocumentReference synchronously so the caller can chain further batch ops.
-     */
-    createFromAuction(batch: WriteBatch, input: {
-        productId: string;
-        productTitle: string;
-        userId: string;
-        userName: string;
-        userEmail: string;
-        storeId?: string;
-        amount: number;
-        currency: string;
-        auctionProductId: string;
-    }): DocumentReference;
 }
 declare const orderRepository: OrderRepository;
 export { OrderRepository, orderRepository };

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

@@ -482,33 +482,6 @@ class OrderRepository extends BaseRepository {
             updatedAt: serverTimestamp(),
         });
     }
-    /**
-     * Cloud Functions: create an auction-won order inside a caller-owned WriteBatch.
-     * Returns the new DocumentReference synchronously so the caller can chain further batch ops.
-     */
-    createFromAuction(batch, input) {
-        const ref = this.db.collection(this.collection).doc();
-        batch.create(ref, prepareForFirestore({
-            id: ref.id,
-            productId: input.productId,
-            productTitle: input.productTitle,
-            userId: input.userId,
-            userName: input.userName,
-            userEmail: input.userEmail,
-            storeId: input.storeId ?? null,
-            quantity: 1,
-            unitPrice: input.amount,
-            totalPrice: input.amount,
-            currency: input.currency,
-            status: OrderStatusValues.CONFIRMED,
-            paymentStatus: "pending",
-            orderDate: new Date(),
-            notes: `Won via auction bid — auction product ${input.auctionProductId}`,
-            createdAt: serverTimestamp(),
-            updatedAt: serverTimestamp(),
-        }));
-        return ref;
-    }
 }
 OrderRepository.SELLER_SIEVE_FIELDS = {
     id: { canFilter: true, canSort: false },

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

@@ -1,4 +1,5 @@
-import { getListingRule, offerRule, } from "../../../_internal/shared/checkout/rules";
+import { getListingRule, offerRule, auctionRule, } from "../../../_internal/shared/checkout/rules";
+import { CART_LANE, laneOf } from "../../../_internal/shared/checkout/lanes";
 /**
  * Split a sequence of cart-items into order groups by `OrderType`.
  *
@@ -18,7 +19,18 @@ export function splitCartIntoOrderGroups(checks) {
     for (const check of checks) {
         const { item } = check;
         const lt = (item.listingType ?? "standard");
-        const rule = item.isOffer ? offerRule : (getListingRule(lt) ?? getListingRule("standard"));
+        // Lane first, listing type second. A locked line's obligation — not the
+        // product's listing type — decides how it settles: an accepted offer is
+        // always its own order, and a won auction is always its own order even
+        // though `auctionRule` is otherwise unreachable (auctions are
+        // `cartEligible: false` for user-initiated adds; the only way one reaches
+        // the cart is auction settlement writing the winner's locked line).
+        const lane = laneOf(item);
+        const rule = lane === CART_LANE.OFFER
+            ? offerRule
+            : lane === CART_LANE.AUCTION
+                ? auctionRule
+                : (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);