@mohasinac/appkit 4.11.1 → 4.11.2

package/dist/_internal/server/features/products/list-public.js

@@ -0,0 +1,342 @@
+/*
+ * WHY: One implementation of "list products for a public listing page", shared by
+ *      every SSR listing view AND `/api/products`. Before 2026-08-21 there were five
+ *      hand-rolled copies of this filter logic (four SSR views + the route) and they
+ *      had drifted: the route had learned — via `6fe4e0dd8` and `efb7d1b6a` — that an
+ *      `inStock` (`stockQuantity>0`) or mismatched date-range inequality must NEVER be
+ *      pushed into the Firestore query, while the SSR views still pushed it and
+ *      swallowed the resulting FAILED_PRECONDITION as "no results". That is what made
+ *      /art render empty until "Show sold" was clicked.
+ *
+ * WHAT: `parsePublicProductParams` (URL/searchParams -> typed input) and
+ *       `listPublicProducts` (typed input -> page of documents). Firestore-safe
+ *       clauses go into the query; `inStock` and unsafe date ranges are applied as
+ *       in-memory predicates over one bounded fetch, then re-sorted into the caller's
+ *       requested order and re-paginated.
+ *
+ * EXPORTS:
+ *   PublicProductListInput, PublicProductListResult, PublicProductExecutor,
+ *   PublicProductListOptions, parsePublicProductParams, listPublicProducts
+ *
+ * @tag domain:products
+ * @tag layer:server-data
+ * @tag pattern:none
+ * @tag access:server-only
+ * @tag consumers:ProductsIndexPageView,ArtStickersListView,AuctionsListView,PreOrdersListView,api/products
+ * @tag sideEffects:firestore-read
+ */
+import { productRepository } from "../../../../repositories";
+import { normalizeError } from "../../../../errors/normalize";
+import { serverLogger } from "../../../../monitoring/server-logger";
+import { PRODUCT_FIELDS } from "../../../../constants/field-names";
+import { TABLE_KEYS } from "../../../../constants/table-keys";
+import { sortBy } from "../../../../constants/sort";
+import { SIEVE_OP, sieveAnd, sieveFilter, expandSieveParam, } from "../../../../utils/sieve-builder";
+/** Vercel Hobby Fluid Compute ceiling (CLAUDE.md Rule #6) — never fetch more at once. */
+export const PUBLIC_PRODUCT_MAX_PAGE_SIZE = 50;
+const DEFAULT_PAGE = 1;
+const DEFAULT_PAGE_SIZE = 24;
+const DEFAULT_SORTS = sortBy(PRODUCT_FIELDS.CREATED_AT);
+// ---------------------------------------------------------------------------
+// Param parsing
+// ---------------------------------------------------------------------------
+function first(params, key) {
+    if (params instanceof URLSearchParams)
+        return params.get(key) ?? "";
+    const v = params[key];
+    return (Array.isArray(v) ? v[0] : v) ?? "";
+}
+function num(raw) {
+    if (!raw)
+        return undefined;
+    const n = Number(raw);
+    return Number.isFinite(n) ? n : undefined;
+}
+/**
+ * Read the shared public-listing query params. SSR views hand in Next's
+ * `searchParams` record; the API route hands in `url.searchParams`. Both produce
+ * the same typed input, which is the whole point — the two paths cannot drift.
+ */
+export function parsePublicProductParams(params, defaults) {
+    const get = (k) => first(params, k);
+    // A single type chip narrows the page's span; anything else keeps the full span.
+    const typeParam = get(TABLE_KEYS.LISTING_TYPE);
+    const span = defaults?.listingTypes;
+    const listingTypes = typeParam
+        ? span && !span.includes(typeParam)
+            ? span // an unknown chip value must not widen the page beyond its own span
+            : [typeParam]
+        : span;
+    const featuresRaw = get(TABLE_KEYS.FEATURES);
+    return {
+        listingTypes,
+        q: get(TABLE_KEYS.QUERY) || undefined,
+        category: get(TABLE_KEYS.CATEGORY) || get(TABLE_KEYS.CATEGORY_SLUG) || undefined,
+        brand: get(TABLE_KEYS.BRAND) || undefined,
+        condition: get(TABLE_KEYS.CONDITION) || undefined,
+        storeId: get(TABLE_KEYS.STORE_ID) || get(TABLE_KEYS.SELLER) || undefined,
+        status: get(TABLE_KEYS.STATUS) || undefined,
+        minPrice: get(TABLE_KEYS.MIN_PRICE) || undefined,
+        maxPrice: get(TABLE_KEYS.MAX_PRICE) || undefined,
+        minBid: get(TABLE_KEYS.MIN_BID) || undefined,
+        maxBid: get(TABLE_KEYS.MAX_BID) || undefined,
+        featured: get(TABLE_KEYS.FEATURED) === "true" || undefined,
+        isPromoted: get("isPromoted") === "true" || undefined,
+        freeShipping: get(TABLE_KEYS.FREE_SHIPPING) === "true" || undefined,
+        isPartOfBundle: get(TABLE_KEYS.IS_PART_OF_BUNDLE) === "true" || undefined,
+        features: featuresRaw ? featuresRaw.split("|").filter(Boolean) : undefined,
+        preOrderProductionStatus: get(TABLE_KEYS.PREORDER_STATUS) || get("preOrderStatus") || undefined,
+        prizeRevealStatus: get(TABLE_KEYS.PRIZE_REVEAL_STATUS) || undefined,
+        // Three spellings of one intent — /products and /art call it "Show sold",
+        // /pre-orders calls it "Show closed", and the client hook sends `inStock`.
+        // Any of them turning the filter OFF wins, so SSR and the client refetch
+        // agree on what the default view means (Root Cause #30).
+        inStock: get(TABLE_KEYS.SHOW_SOLD) === "true" || get(TABLE_KEYS.SHOW_CLOSED) === "true"
+            ? undefined
+            : get(TABLE_KEYS.IN_STOCK)
+                ? get(TABLE_KEYS.IN_STOCK) === "true"
+                : defaults?.hideSoldByDefault
+                    ? true
+                    : undefined,
+        dateFrom: get(TABLE_KEYS.DATE_FROM) ||
+            (defaults?.hideEndedByDefault && get(TABLE_KEYS.SHOW_ENDED) !== "true"
+                ? new Date().toISOString()
+                : undefined),
+        dateTo: get(TABLE_KEYS.DATE_TO) || undefined,
+        page: num(get(TABLE_KEYS.PAGE)) ?? DEFAULT_PAGE,
+        pageSize: num(get(TABLE_KEYS.PAGE_SIZE)) ?? defaults?.pageSize ?? DEFAULT_PAGE_SIZE,
+        sorts: get(TABLE_KEYS.SORT) || defaults?.sorts || DEFAULT_SORTS,
+    };
+}
+// ---------------------------------------------------------------------------
+// Filter building
+// ---------------------------------------------------------------------------
+/**
+ * Only clauses Firestore can satisfy alongside an arbitrary `orderBy`. Notably
+ * ABSENT: `inStock` (a `stockQuantity` range) and, unless the sort matches, the
+ * auction/pre-order date ranges. Firestore appends an inequality field to the
+ * orderBy implicitly, so pairing one with an unrelated sort demands a composite
+ * index in an order nobody declares — it fails with FAILED_PRECONDITION, which
+ * upstream reads as a bare "no results".
+ */
+function buildFirestoreSafeFilters(input) {
+    const parts = [];
+    // Published-only unless the caller explicitly asks otherwise. Without this
+    // default, any refetch that omits `status` leaks drafts (Root Cause #30).
+    parts.push(sieveFilter(PRODUCT_FIELDS.STATUS, SIEVE_OP.EQ, input.status || PRODUCT_FIELDS.STATUS_VALUES.PUBLISHED));
+    const types = input.listingTypes?.filter(Boolean) ?? [];
+    if (types.length > 0) {
+        parts.push(sieveFilter(PRODUCT_FIELDS.LISTING_TYPE, SIEVE_OP.EQ, types.join("|")));
+    }
+    if (input.category) {
+        parts.push(expandSieveParam(PRODUCT_FIELDS.CATEGORY_SLUGS, input.category, SIEVE_OP.CONTAINS));
+    }
+    if (input.brand)
+        parts.push(sieveFilter(PRODUCT_FIELDS.BRAND, SIEVE_OP.EQ, input.brand));
+    if (input.condition) {
+        // Pipe-joined OR-group, NOT `sieveMultiEq` — that emits
+        // `condition==new,condition==used`, an AND of two equalities on one field,
+        // which can never match a document.
+        const values = input.condition.split("|").filter(Boolean);
+        if (values.length > 0) {
+            parts.push(sieveFilter(PRODUCT_FIELDS.CONDITION, SIEVE_OP.EQ, values.join("|")));
+        }
+    }
+    if (input.storeId)
+        parts.push(sieveFilter(PRODUCT_FIELDS.STORE_ID, SIEVE_OP.EQ, input.storeId));
+    const minPrice = num(input.minPrice ?? "");
+    if (minPrice !== undefined)
+        parts.push(sieveFilter(PRODUCT_FIELDS.PRICE, SIEVE_OP.GTE, minPrice));
+    const maxPrice = num(input.maxPrice ?? "");
+    if (maxPrice !== undefined)
+        parts.push(sieveFilter(PRODUCT_FIELDS.PRICE, SIEVE_OP.LTE, maxPrice));
+    const minBid = num(input.minBid ?? "");
+    if (minBid !== undefined)
+        parts.push(sieveFilter(PRODUCT_FIELDS.CURRENT_BID, SIEVE_OP.GTE, minBid));
+    const maxBid = num(input.maxBid ?? "");
+    if (maxBid !== undefined)
+        parts.push(sieveFilter(PRODUCT_FIELDS.CURRENT_BID, SIEVE_OP.LTE, maxBid));
+    if (input.featured)
+        parts.push(sieveFilter(PRODUCT_FIELDS.FEATURED, SIEVE_OP.EQ, true));
+    if (input.isPromoted)
+        parts.push(sieveFilter(PRODUCT_FIELDS.IS_PROMOTED, SIEVE_OP.EQ, true));
+    if (input.freeShipping) {
+        parts.push(sieveFilter(PRODUCT_FIELDS.SHIPPING_PAID_BY, SIEVE_OP.EQ, PRODUCT_FIELDS.SHIPPING_PAID_BY_VALUES.SELLER));
+    }
+    if (input.isPartOfBundle)
+        parts.push(sieveFilter("isPartOfBundle", SIEVE_OP.EQ, true));
+    if (input.preOrderProductionStatus) {
+        parts.push(sieveFilter(PRODUCT_FIELDS.PRE_ORDER_PRODUCTION_STATUS, SIEVE_OP.EQ, input.preOrderProductionStatus));
+    }
+    if (input.prizeRevealStatus) {
+        parts.push(sieveFilter(PRODUCT_FIELDS.PRIZE_REVEAL_STATUS, SIEVE_OP.EQ, input.prizeRevealStatus));
+    }
+    if (input.q)
+        parts.push(sieveFilter(PRODUCT_FIELDS.TITLE, SIEVE_OP.CONTAINS_CI, input.q));
+    // `array-contains-any` isn't supported by the Sieve Firebase adapter, so only a
+    // single feature can be pushed down; multi-select falls through to the caller.
+    if (input.features?.length === 1) {
+        parts.push(sieveFilter(PRODUCT_FIELDS.FEATURES, SIEVE_OP.CONTAINS, input.features[0]));
+    }
+    if (input.rawFilters)
+        parts.push(input.rawFilters);
+    return sieveAnd(...parts.filter(Boolean));
+}
+/** Which Timestamp field a date range refers to, given the requested listing types. */
+function dateFieldFor(types) {
+    if (!types || types.length !== 1)
+        return null;
+    if (types[0] === PRODUCT_FIELDS.LISTING_TYPE_VALUES.AUCTION) {
+        return PRODUCT_FIELDS.AUCTION_END_DATE;
+    }
+    if (types[0] === PRODUCT_FIELDS.LISTING_TYPE_VALUES.PRE_ORDER) {
+        return PRODUCT_FIELDS.PRE_ORDER_DELIVERY_DATE;
+    }
+    return null;
+}
+async function defaultExecutor(query) {
+    const result = await productRepository.list({
+        filters: query.filters,
+        sorts: query.sorts,
+        page: query.page,
+        pageSize: query.pageSize,
+    });
+    return {
+        items: result.items,
+        total: result.total,
+        page: result.page,
+        totalPages: result.totalPages,
+        hasMore: result.hasMore,
+        cursor: null,
+    };
+}
+// ---------------------------------------------------------------------------
+// The one public listing query
+// ---------------------------------------------------------------------------
+export async function listPublicProducts(input, opts) {
+    const page = Math.max(1, input.page ?? DEFAULT_PAGE);
+    const pageSize = Math.min(PUBLIC_PRODUCT_MAX_PAGE_SIZE, Math.max(1, input.pageSize ?? DEFAULT_PAGE_SIZE));
+    const sorts = input.sorts || DEFAULT_SORTS;
+    const requestedSortField = sorts.replace(/^-/, "");
+    const dateField = dateFieldFor(input.listingTypes);
+    const hasDateRange = Boolean((input.dateFrom || input.dateTo) && dateField);
+    // Firestore DOES accept one inequality when the query sorts by that same field —
+    // the auctions "Ending Soon" default is exactly that shape, so push it down.
+    const canPushDate = hasDateRange && !input.inStock && requestedSortField === dateField;
+    const safeFilters = buildFirestoreSafeFilters(input);
+    const filters = sieveAnd(safeFilters, ...(canPushDate && input.dateFrom
+        ? [sieveFilter(dateField, SIEVE_OP.GTE, input.dateFrom)]
+        : []), ...(canPushDate && input.dateTo
+        ? [sieveFilter(dateField, SIEVE_OP.LTE, input.dateTo)]
+        : []));
+    const hasUnsafeFilter = Boolean(input.inStock) || (hasDateRange && !canPushDate);
+    // When a date range stays in memory, fetch in whichever direction front-loads
+    // the rows that will PASS it: `dateFrom` (">=", still live) wants the most
+    // future dates first; `dateTo` ("<=", ends by) wants the earliest first.
+    // Fetching in the client's own order instead is what made live auctions
+    // invisible once ~50 had already ended.
+    const fetchSorts = hasUnsafeFilter && hasDateRange && dateField
+        ? input.dateFrom
+            ? sortBy(dateField, "DESC")
+            : sortBy(dateField, "ASC")
+        : sorts;
+    const executor = opts?.executor ?? defaultExecutor;
+    let result;
+    try {
+        result = await executor({
+            filters,
+            sorts: fetchSorts,
+            page: hasUnsafeFilter ? 1 : page,
+            pageSize: hasUnsafeFilter ? PUBLIC_PRODUCT_MAX_PAGE_SIZE : pageSize,
+            cursor: hasUnsafeFilter ? null : (input.cursor ?? null),
+        });
+    }
+    catch (error) {
+        void normalizeError(error);
+        // Loud. A swallowed query failure here is indistinguishable from an empty
+        // catalogue at every call site above, which is exactly how the /art bug hid.
+        serverLogger.error("listPublicProducts query failed", {
+            filters,
+            sorts: fetchSorts,
+            error: error instanceof Error ? error.message : String(error),
+        });
+        return null;
+    }
+    let items = result.items;
+    let total = result.total;
+    let totalPages = result.totalPages;
+    let resultPage = result.page;
+    let hasMore = result.hasMore;
+    let cursor = result.cursor ?? null;
+    if (hasUnsafeFilter) {
+        const filtered = items.filter((item) => {
+            if (input.inStock) {
+                const stock = item[PRODUCT_FIELDS.STOCK_QUANTITY];
+                if (!(typeof stock === "number" && stock > 0))
+                    return false;
+            }
+            if (hasDateRange && dateField) {
+                const raw = item[dateField];
+                if (!raw)
+                    return false;
+                const value = raw instanceof Date ? raw.toISOString() : String(raw);
+                if (input.dateFrom && value < input.dateFrom)
+                    return false;
+                if (input.dateTo && value > input.dateTo)
+                    return false;
+            }
+            return true;
+        });
+        const ordered = fetchSorts === sorts ? filtered : sortRows(filtered, requestedSortField, sorts.startsWith("-"));
+        total = ordered.length;
+        totalPages = Math.max(1, Math.ceil(total / pageSize));
+        resultPage = page;
+        const start = (page - 1) * pageSize;
+        items = ordered.slice(start, start + pageSize);
+        hasMore = start + pageSize < total;
+        cursor = null;
+    }
+    // Feature-flagged-off types never reach a public surface.
+    const enabled = opts?.enabledListingTypes;
+    if (enabled && enabled.size > 0) {
+        const before = items.length;
+        items = items.filter((it) => {
+            const lt = typeof it.listingType === "string" ? it.listingType : "standard";
+            return enabled.has(lt);
+        });
+        const removed = before - items.length;
+        if (removed > 0)
+            total = Math.max(0, total - removed);
+    }
+    return {
+        items,
+        total,
+        page: resultPage,
+        pageSize,
+        totalPages,
+        hasMore,
+        cursor,
+        filters,
+        sorts,
+    };
+}
+function sortRows(rows, field, desc) {
+    return [...rows].sort((a, b) => {
+        const av = a[field];
+        const bv = b[field];
+        if (av == null && bv == null)
+            return 0;
+        if (av == null)
+            return 1;
+        if (bv == null)
+            return -1;
+        const cmp = typeof av === "number" && typeof bv === "number"
+            ? av - bv
+            : String(av) < String(bv)
+                ? -1
+                : String(av) > String(bv)
+                    ? 1
+                    : 0;
+        return desc ? -cmp : cmp;
+    });
+}

package/dist/_internal/server/jobs/core/auctionSettlement.js

@@ -1,36 +1,105 @@
-import { bidRepository, orderRepository, productRepository, } from "../../../../repositories";
+import { bidRepository, cartRepository, productRepository, storeRepository, } from "../../../../repositories";
 import { sendNotification } from "../../../../features/admin/actions/notification-actions";
 import { AUCTION_MESSAGES } from "../handlers/messages";
+import { ROUTES } from "../../../../next/routing/route-map";
+import { CART_LANE } from "../../../shared/checkout/lanes";
+/**
+ * How long the winner has to pay before the locked cart line lapses. Mirrors
+ * the accepted-offer window so both locked lanes behave the same.
+ */
+const AUCTION_CHECKOUT_WINDOW_MS = 48 * 60 * 60 * 1000;
+/** Deep link the winner straight into the auction checkout lane. */
+const AUCTION_CHECKOUT_URL = `${String(ROUTES.USER.CHECKOUT)}?lane=${CART_LANE.AUCTION}`;
 async function settleAuction(ctx, product) {
     const activeBids = await bidRepository.getActiveByProduct(product.id);
-    const batch = ctx.db.batch();
     if (activeBids.length === 0) {
+        const batch = ctx.db.batch();
         productRepository.updateStatusInBatch(batch, product.id, "archived");
         await batch.commit();
         ctx.logger.info(AUCTION_MESSAGES.NO_BIDS_LOG(product.id));
         return;
     }
     const [winnerEntry, ...loserEntries] = activeBids;
+    // Reserve price. It exists on the product, is editable by the seller, is
+    // shown in both dashboards, and the buyer guide promises bids below it don't
+    // win — but settlement awarded activeBids[0] unconditionally until
+    // 2026-08-21. A below-reserve auction ends with NO winner.
+    const reserve = product.reservePrice;
+    if (typeof reserve === "number" && reserve > 0 && winnerEntry.data.bidAmount < reserve) {
+        const batch = ctx.db.batch();
+        activeBids.forEach(({ ref }) => bidRepository.markLost(batch, ref));
+        productRepository.updateStatusInBatch(batch, product.id, "archived");
+        await batch.commit();
+        const reserveStore = product.storeId
+            ? await storeRepository.findById(product.storeId).catch(() => null)
+            : null;
+        if (reserveStore?.ownerId) {
+            await sendNotification({
+                userId: reserveStore.ownerId,
+                type: "auction_ended",
+                priority: "normal",
+                title: AUCTION_MESSAGES.RESERVE_NOT_MET_TITLE,
+                message: AUCTION_MESSAGES.RESERVE_NOT_MET_MESSAGE(product.title, winnerEntry.data.currency, winnerEntry.data.bidAmount, reserve),
+                relatedId: product.id,
+                relatedType: "product",
+            });
+        }
+        await Promise.allSettled(activeBids.slice(0, 50).map(({ data: bid }) => sendNotification({
+            userId: bid.userId,
+            type: "bid_lost",
+            priority: "normal",
+            title: AUCTION_MESSAGES.LOST_TITLE,
+            message: AUCTION_MESSAGES.RESERVE_NOT_MET_BIDDER_MESSAGE(product.title),
+            relatedId: product.id,
+            relatedType: "product",
+        })));
+        ctx.logger.info(`Auction ${product.id} ended below reserve — no winner`, {
+            highestBid: winnerEntry.data.bidAmount,
+            reservePrice: reserve,
+        });
+        return;
+    }
+    const batch = ctx.db.batch();
     bidRepository.markWon(batch, winnerEntry.ref);
     loserEntries.forEach(({ ref }) => bidRepository.markLost(batch, ref));
-    const orderRef = orderRepository.createFromAuction(batch, {
-        productId: product.id,
-        productTitle: product.title,
-        userId: winnerEntry.data.userId,
-        userName: winnerEntry.data.userName,
-        userEmail: winnerEntry.data.userEmail,
-        storeId: product.storeId,
-        amount: winnerEntry.data.bidAmount,
-        currency: winnerEntry.data.currency,
-        auctionProductId: product.id,
-    });
-    // Two-axis model: mark as sold without changing publish status
+    // Two-axis model: mark as sold without changing publish status.
     batch.update(ctx.db.collection("products").doc(product.id), {
         isSold: true,
         availableQuantity: 0,
     });
     await batch.commit();
-    // Fan-out notifications after batch commits.
+    // The win becomes a LOCKED CART LINE, not an order.
+    //
+    // Settlement used to call `orderRepository.createFromAuction`, which wrote a
+    // document that was not an OrderDocument at all — flat productId/userId/
+    // unitPrice, no items[], no buyerId, no paymentMethod, no shippingAddress,
+    // and a Firestore auto-ID instead of the `order-…` semantic id. No orders UI
+    // could render it and the manual-payment panel returned null for it, so an
+    // auction winner had literally no way to pay, anywhere in the product.
+    //
+    // Routing the win through the cart instead means the winner goes through the
+    // ONE checkout that already knows how to collect an address, charge a payment
+    // method, run the high-value OTP, split per store and produce a real order.
+    // Auctions stay `canAddToCart: false` for user-initiated adds — this writes
+    // through the repository directly, the same deliberate bypass `checkoutOffer`
+    // uses for accepted offers.
+    await cartRepository.addItem(winnerEntry.data.userId, {
+        productId: product.id,
+        productTitle: product.title,
+        productImage: product.mainImage ?? "",
+        price: winnerEntry.data.bidAmount,
+        currency: winnerEntry.data.currency,
+        quantity: 1,
+        storeId: product.storeId,
+        storeName: product.storeName ?? "",
+        listingType: "auction",
+        isAuctionWin: true,
+        auctionId: product.id,
+        bidId: winnerEntry.data.id,
+        lockedPrice: winnerEntry.data.bidAmount,
+        checkoutDeadline: new Date(ctx.now.getTime() + AUCTION_CHECKOUT_WINDOW_MS),
+        locked: true,
+    });
     await sendNotification({
         userId: winnerEntry.data.userId,
         type: "bid_won",
@@ -39,6 +108,10 @@ async function settleAuction(ctx, product) {
         message: AUCTION_MESSAGES.WON_MESSAGE(product.title, winnerEntry.data.currency, winnerEntry.data.bidAmount),
         relatedId: product.id,
         relatedType: "product",
+        // Previously the winner's notification linked back to the product page and
+        // carried no CTA — the one place it should never send them.
+        actionUrl: AUCTION_CHECKOUT_URL,
+        actionLabel: AUCTION_MESSAGES.WON_ACTION_LABEL,
     });
     await Promise.allSettled(loserEntries.slice(0, 50).map(({ data: bid }) => sendNotification({
         userId: bid.userId,
@@ -53,7 +126,7 @@ async function settleAuction(ctx, product) {
         winner: winnerEntry.data.userId,
         winningBid: winnerEntry.data.bidAmount,
         losersCount: loserEntries.length,
-        orderId: orderRef.id,
+        bidId: winnerEntry.data.id,
     });
 }
 export async function runAuctionSettlement(ctx) {

package/dist/_internal/server/jobs/core/offerExpiry.js

@@ -1,5 +1,5 @@
 import { normalizeError } from "../../../../errors/normalize";
-import { offerRepository } from "../../../../repositories";
+import { bidRepository, cartRepository, offerRepository } from "../../../../repositories";
 import { sendNotification } from "../../../../features/admin/actions/notification-actions";
 export async function runOfferExpiry(ctx) {
     ctx.logger.info("Starting offer expiry sweep");
@@ -11,11 +11,15 @@ export async function runOfferExpiry(ctx) {
         ctx.logger.error("Failed to query expired offers", err);
         throw err;
     }
+    // NOTE: no early return here. This job sweeps three distinct things and the
+    // other two (accepted-past-deadline offers, unpaid auction wins) must still
+    // run when there happen to be no expired pending/countered offers.
     if (expiredOffers.length === 0) {
-        ctx.logger.info("No expired offers found");
-        return;
+        ctx.logger.info("No expired pending/countered offers found");
+    }
+    else {
+        ctx.logger.info(`Found ${expiredOffers.length} expired offer(s) to process`);
     }
-    ctx.logger.info(`Found ${expiredOffers.length} expired offer(s) to process`);
     const expiredIds = [];
     for (const offer of expiredOffers) {
         try {
@@ -46,8 +50,116 @@ export async function runOfferExpiry(ctx) {
             throw err;
         }
     }
+    await expireAcceptedPastCheckoutDeadline(ctx);
+    await lapseUnpaidAuctionWins(ctx);
     ctx.logger.info("Offer expiry complete", {
         processed: expiredIds.length,
         skipped: expiredOffers.length - expiredIds.length,
     });
 }
+/**
+ * The second half of the sweep, missing until 2026-08-21.
+ *
+ * `findExpiredActive` only looks at pending/countered offers past `expiresAt`.
+ * An offer the seller ACCEPTED but the buyer never paid for stayed "accepted"
+ * forever: its locked price remained claimable long after the 48h checkout
+ * window the buyer was shown, and the seller had no way to take the listing
+ * back. This lapses those offers and clears the matching locked cart lines, so
+ * the lane gate stops blocking a buyer on an offer that is no longer live.
+ */
+async function expireAcceptedPastCheckoutDeadline(ctx) {
+    let stale;
+    try {
+        stale = await offerRepository.findExpiredAccepted(ctx.now);
+    }
+    catch (err) {
+        void normalizeError(err);
+        ctx.logger.error("Failed to query accepted-but-unpaid offers", err);
+        return;
+    }
+    if (stale.length === 0)
+        return;
+    ctx.logger.info(`Found ${stale.length} accepted offer(s) past their checkout deadline`);
+    const ids = [];
+    for (const offer of stale) {
+        try {
+            // Drop the locked cart line first — leaving it behind would keep the
+            // buyer's offer lane non-empty and block their standard checkout on an
+            // offer they can no longer act on.
+            await cartRepository.removeItemsByOfferId(offer.buyerUid, offer.id);
+            ids.push(offer.id);
+            await sendNotification({
+                userId: offer.buyerUid,
+                type: "offer_expired",
+                priority: "normal",
+                title: "Accepted offer expired",
+                message: `The checkout window for your accepted offer on "${offer.productTitle}" has closed. You can make a new offer if it's still listed.`,
+                relatedId: offer.id,
+                relatedType: "offer",
+            });
+        }
+        catch (err) {
+            void normalizeError(err);
+            ctx.logger.warn(`Failed to lapse accepted offer ${offer.id}`, {
+                error: err instanceof Error ? err.message : String(err),
+            });
+        }
+    }
+    if (ids.length > 0) {
+        try {
+            await offerRepository.expireMany(ids);
+        }
+        catch (err) {
+            void normalizeError(err);
+            ctx.logger.error("Failed to batch-expire accepted offers", err);
+        }
+    }
+}
+/**
+ * A won auction the buyer never paid for.
+ *
+ * Folded into this job rather than given its own scheduled function: both are
+ * "a locked cart line whose claim has lapsed", they want the same cadence, and
+ * Cloud Scheduler bills per registered job (see CLAUDE.md's Firebase budget
+ * table — 27 jobs is already an accepted, documented cost).
+ *
+ * The listing is NOT silently relisted. A forfeited win is a seller decision
+ * (relist, offer to the runner-up, or ban the non-payer), so this clears the
+ * line, marks the bid forfeited, and notifies both sides.
+ */
+async function lapseUnpaidAuctionWins(ctx) {
+    let stale;
+    try {
+        stale = await cartRepository.findExpiredLockedLines(ctx.now);
+    }
+    catch (err) {
+        void normalizeError(err);
+        ctx.logger.error("Failed to scan for expired locked cart lines", err);
+        return;
+    }
+    const auctionLines = stale.filter(({ item }) => item.bidId && item.isAuctionWin);
+    if (auctionLines.length === 0)
+        return;
+    ctx.logger.info(`Found ${auctionLines.length} unpaid auction win(s) past deadline`);
+    for (const { userId, item } of auctionLines) {
+        try {
+            await cartRepository.removeItemsByBidId(userId, item.bidId);
+            await bidRepository.markForfeited(item.bidId);
+            await sendNotification({
+                userId,
+                type: "auction_ended",
+                priority: "high",
+                title: "Auction win forfeited",
+                message: `You didn't complete payment for "${item.productTitle}" in time, so the win has been forfeited. Repeated non-payment can restrict your account.`,
+                relatedId: item.auctionId ?? item.productId,
+                relatedType: "product",
+            });
+        }
+        catch (err) {
+            void normalizeError(err);
+            ctx.logger.warn(`Failed to lapse auction win ${item.bidId}`, {
+                error: err instanceof Error ? err.message : String(err),
+            });
+        }
+    }
+}

package/dist/_internal/server/jobs/handlers/messages.d.ts

@@ -10,6 +10,11 @@ export declare const AUCTION_MESSAGES: {
     LOST_TITLE: string;
     LOST_MESSAGE: (productTitle: string) => string;
     NO_BIDS_LOG: (productId: string) => string;
+    /** CTA on the winner's notification — links into the auction checkout lane. */
+    WON_ACTION_LABEL: string;
+    RESERVE_NOT_MET_TITLE: string;
+    RESERVE_NOT_MET_MESSAGE: (productTitle: string, currency: string, highestBid: number, reservePrice: number) => string;
+    RESERVE_NOT_MET_BIDDER_MESSAGE: (productTitle: string) => string;
 };
 export declare const BID_MESSAGES: {
     OUTBID_TITLE: string;

package/dist/_internal/server/jobs/handlers/messages.js

@@ -10,6 +10,11 @@ export const AUCTION_MESSAGES = {
     LOST_TITLE: "Auction ended",
     LOST_MESSAGE: (productTitle) => `The auction for "${productTitle}" has ended. You were outbid.`,
     NO_BIDS_LOG: (productId) => `Auction ${productId} ended with no bids`,
+    /** CTA on the winner's notification — links into the auction checkout lane. */
+    WON_ACTION_LABEL: "Pay now",
+    RESERVE_NOT_MET_TITLE: "Auction ended below reserve",
+    RESERVE_NOT_MET_MESSAGE: (productTitle, currency, highestBid, reservePrice) => `"${productTitle}" ended at ${currency} ${highestBid}, below your reserve of ${currency} ${reservePrice}. No winner was declared and the listing was archived.`,
+    RESERVE_NOT_MET_BIDDER_MESSAGE: (productTitle) => `The auction for "${productTitle}" ended without meeting the seller's reserve price, so it did not sell.`,
 };
 export const BID_MESSAGES = {
     OUTBID_TITLE: "You've been outbid",