@mohasinac/appkit 4.71.0 → 4.71.2

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

@@ -1,240 +0,0 @@
-import { bidRepository, cartRepository, productRepository, storeRepository, } from "../../../../repositories/index.js";
-import { sendNotification } from "../../../../features/admin/actions/notification-actions.js";
-import { normalizeError } from "../../../../errors/normalize.js";
-import { safeRead } from "../../../../errors/safe-read.js";
-import { AUCTION_MESSAGES, BID_MESSAGES } from "../handlers/messages.js";
-import { ROUTES } from "../../../../next/routing/route-map.js";
-import { CART_LANE, LANE_CHECKOUT_WINDOW_MS } from "../../../shared/checkout/lanes.js";
-/**
- * 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.
- */
-// Was a local `48 * 60 * 60 * 1000` here AND an identical one in bid-actions.ts
-// (the Buy-Now path), with nothing linking them — changing one would have given
-// the same kind of win two different deadlines depending on how it was won.
-const AUCTION_CHECKOUT_WINDOW_MS = LANE_CHECKOUT_WINDOW_MS.auction;
-/** Deep link the winner straight into the auction checkout lane. */
-const AUCTION_CHECKOUT_URL = `${String(ROUTES.USER.CHECKOUT)}?lane=${CART_LANE.AUCTION}`;
-/**
- * Clear every unpaid Buy Now hold on an auction whose clock just ran out.
- *
- * This is the user's explicit rule: "if by the time the checkout is not
- * finished but auction timeout ends the buyout should fail as well." The item
- * goes to whoever actually won the bidding, and the claimants get their carts
- * back — the line is `locked: true`, so they cannot clear it themselves.
- *
- * `cancelled`, never `forfeited`: forfeiture means "won, then defaulted" and
- * carries a warning about account restrictions. Nobody won anything here, and
- * losing a race against a clock is not misconduct.
- *
- * Best-effort per hold — one failure must not abort settling the auction.
- */
-async function releasePendingBuyouts(ctx, product, holds) {
-    for (const hold of holds) {
-        try {
-            await cartRepository.removeItemsByBidId(hold.data.userId, hold.id);
-            await bidRepository.markCancelled(hold.id, {
-                actor: { role: "system" },
-                trigger: "auctionSettlement:lapsedBuyoutHold",
-                reason: "The auction ended before this Buy Now claim was paid for.",
-            });
-            await sendNotification({
-                userId: hold.data.userId,
-                type: "auction_ended",
-                priority: "high",
-                title: BID_MESSAGES.BUY_NOW_AUCTION_ENDED_TITLE,
-                message: BID_MESSAGES.BUY_NOW_AUCTION_ENDED_MESSAGE(product.title),
-                relatedId: product.id,
-                relatedType: "product",
-            });
-        }
-        catch (err) {
-            void normalizeError(err);
-            ctx.logger.warn(`Failed to release buyout hold ${hold.id}`, {
-                error: err instanceof Error ? err.message : String(err),
-            });
-        }
-    }
-    ctx.logger.info(`Released ${holds.length} unpaid buyout hold(s) on ${product.id}`);
-}
-async function settleAuction(ctx, product) {
-    const allActive = await bidRepository.getActiveByProduct(product.id);
-    /**
-     * A pending Buy Now claim is `active` and sits at the BIN price, so it would
-     * be `activeBids[0]` and win by default the instant the clock ran out —
-     * handing the item to somebody who explicitly did NOT complete their purchase
-     * in time. A buyout only counts once it has been paid for, at which point
-     * `claimAuctionForCheckout` has already marked it `won` and flipped the
-     * product to `isSold`, so this job never sees that auction at all.
-     *
-     * The stale holds are released below, after the real winner is decided.
-     */
-    const pendingBuyouts = allActive.filter((e) => e.data.isBuyout === true);
-    const activeBids = allActive.filter((e) => e.data.isBuyout !== true);
-    if (pendingBuyouts.length > 0) {
-        await releasePendingBuyouts(ctx, product, pendingBuyouts);
-    }
-    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();
-        // `data` comes from the same query as `ref`, so the timeline entry is
-        // free even on an auction that closed with hundreds of bids (Rule #6).
-        activeBids.forEach(({ ref, data }) => bidRepository.markLost(batch, ref, { actor: { role: "system" }, trigger: "auctionSettlement" }, data));
-        productRepository.updateStatusInBatch(batch, product.id, "archived");
-        await batch.commit();
-        const reserveStore = product.storeId
-            ? await safeRead(() => storeRepository.findById(product.storeId), {
-                route: "job:auctionSettlement",
-                key: "auctionSettlement.reserveNotMet.store",
-                fallback: 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",
-            });
-        }
-        // audit-unguarded-send-ok: `bid_lost` is email-INELIGIBLE — these return at
-        // the eligibility gate having written only the bell row, so they never
-        // reach the budget counter. Same reasoning as the settled-auction fan-out
-        // below.
-        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, { actor: { role: "system" }, trigger: "auctionSettlement" }, winnerEntry.data);
-    loserEntries.forEach(({ ref, data }) => bidRepository.markLost(batch, ref, { actor: { role: "system" }, trigger: "auctionSettlement" }, data));
-    // 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();
-    // 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",
-        priority: "high",
-        title: AUCTION_MESSAGES.WON_TITLE,
-        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,
-    });
-    // audit-unguarded-send-ok: `bid_lost` is email-INELIGIBLE, so every one of
-    // these returns at the eligibility gate in sendNotification having written
-    // only the in-app bell row — it never reaches guardSend or the daily budget
-    // counter, so there is nothing here to contend on. This was THE fan-out that
-    // motivated the whole change (50 concurrent emails per settled auction, with
-    // every expired auction settling at once); it is now 50 concurrent Firestore
-    // writes to 50 DIFFERENT notification documents, which is what this loop
-    // always was underneath. If `bid_lost` is ever made eligible, this must
-    // become sequential and the counter must be sharded first.
-    await Promise.allSettled(loserEntries.slice(0, 50).map(({ data: bid }) => sendNotification({
-        userId: bid.userId,
-        type: "bid_lost",
-        priority: "normal",
-        title: AUCTION_MESSAGES.LOST_TITLE,
-        message: AUCTION_MESSAGES.LOST_MESSAGE(product.title),
-        relatedId: product.id,
-        relatedType: "product",
-    })));
-    ctx.logger.info(`Settled auction ${product.id}`, {
-        winner: winnerEntry.data.userId,
-        winningBid: winnerEntry.data.bidAmount,
-        losersCount: loserEntries.length,
-        bidId: winnerEntry.data.id,
-    });
-}
-export async function runAuctionSettlement(ctx) {
-    /*
-     * 🛑 `FEATURE_AUCTIONS` gate DELETED 2026-10-19, and this one was live.
-     *
-     * The flag mechanism was retired on 2026-08-29, but `audit-feature-flags`
-     * only matched `process.env.FEATURE_*` and this read it through
-     * `ctx.env(...)` — so it survived unseen. This is a SCHEDULED Firebase
-     * Function, which reads `functions/.env.<projectId>`, and measured on
-     * 2026-10-19 that file contains exactly one flag: `FEATURE_PAYOUTS=true`.
-     * `FEATURE_AUCTIONS` was never set there, so this sweep returned on its
-     * first line on every run — no expired auction was ever settled in
-     * production, no winner ever got a cart line, and the only trace was an
-     * `info` log saying it had been skipped.
-     */
-    ctx.logger.info("Starting auction settlement sweep");
-    const expired = await productRepository.getExpiredAuctions(ctx.now);
-    if (expired.length === 0) {
-        ctx.logger.info("No expired auctions found");
-        return;
-    }
-    ctx.logger.info(`Found ${expired.length} expired auction(s) to settle`);
-    const results = await Promise.allSettled(expired.map(({ data }) => settleAuction(ctx, data)));
-    const failed = results.filter((r) => r.status === "rejected");
-    if (failed.length > 0) {
-        ctx.logger.error(`${failed.length} auction(s) failed to settle`, failed);
-    }
-    ctx.logger.info(`Settlement complete — ${expired.length - failed.length} succeeded, ${failed.length} failed`);
-}

package/dist/_internal/server/jobs/core/onPrizeDrawPaymentConfirmed.d.ts

@@ -1,19 +0,0 @@
-import type { JobContext } from "../runtime/types";
-export interface PrizeDrawOrderSnapshot {
-    paymentStatus?: string;
-    prizeDrawProductId?: string;
-    items?: Array<{
-        listingType?: string;
-    }>;
-}
-/**
- * Instant-mode prize-draw winner assignment. Fires when an order's
- * paymentStatus transitions into "paid" — not at order creation, since a
- * prize-draw order isn't guaranteed to be paid yet at that point (manual
- * bank/UPI payments are confirmed later by the seller/admin; Razorpay
- * confirms near-instantly but still goes through this same status flip).
- */
-export declare function handlePrizeDrawPaymentConfirmed(input: {
-    orderId: string;
-    order: PrizeDrawOrderSnapshot;
-}, ctx: JobContext): Promise<void>;

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

@@ -1,30 +0,0 @@
-import { normalizeError } from "../../../../errors/normalize.js";
-import { assignPrizeDrawWinner } from "./prizeDrawAssignWinner.js";
-const PRODUCT_COLLECTION = "products";
-/**
- * Instant-mode prize-draw winner assignment. Fires when an order's
- * paymentStatus transitions into "paid" — not at order creation, since a
- * prize-draw order isn't guaranteed to be paid yet at that point (manual
- * bank/UPI payments are confirmed later by the seller/admin; Razorpay
- * confirms near-instantly but still goes through this same status flip).
- */
-export async function handlePrizeDrawPaymentConfirmed(input, ctx) {
-    const { orderId, order } = input;
-    if (!order.prizeDrawProductId)
-        return;
-    if (!order.items?.some((it) => it.listingType === "prize-draw"))
-        return;
-    let product;
-    try {
-        const snap = await ctx.db.collection(PRODUCT_COLLECTION).doc(order.prizeDrawProductId).get();
-        product = snap.exists ? snap.data() : undefined;
-    }
-    catch (err) {
-        void normalizeError(err);
-        ctx.logger.error("Failed to load prize-draw product for instant reveal", err, { orderId });
-        return;
-    }
-    if (!product || product.prizeRevealMode !== "instant")
-        return;
-    await assignPrizeDrawWinner(ctx, { orderId, productId: order.prizeDrawProductId });
-}

package/dist/_internal/server/jobs/core/prizeDrawAssignWinner.d.ts

@@ -1,20 +0,0 @@
-import type { JobContext } from "../runtime/types";
-import type { OrderDocument } from "../../../../features/orders/schemas/firestore";
-export interface AssignPrizeDrawWinnerResult {
-    kind: "revealed" | "already_revealed" | "pool_exhausted" | "not_eligible";
-    prizeWon?: OrderDocument["prizeWon"];
-}
-/**
- * The single place a prize-draw winner is ever picked. Called by every
- * trigger point (payment-confirmed for "instant" mode, sellout-detection,
- * and the expiry sweep for "scheduled" mode) — never call the underlying
- * transaction logic anywhere else.
- *
- * Preserves the exact `crypto.randomInt` rejection-sampled fairness RNG that
- * buyers are shown a public GitHub source link for (product.prizeGithubFileUrl)
- * — do not change the selection algorithm.
- */
-export declare function assignPrizeDrawWinner(ctx: JobContext, args: {
-    orderId: string;
-    productId: string;
-}): Promise<AssignPrizeDrawWinnerResult>;

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

@@ -1,114 +0,0 @@
-import crypto from "node:crypto";
-import { normalizeError } from "../../../../errors/normalize.js";
-import { sendNotification } from "../../../../features/admin/actions/notification-actions.js";
-const PRODUCT_COLLECTION = "products";
-const ORDER_COLLECTION = "orders";
-/**
- * The single place a prize-draw winner is ever picked. Called by every
- * trigger point (payment-confirmed for "instant" mode, sellout-detection,
- * and the expiry sweep for "scheduled" mode) — never call the underlying
- * transaction logic anywhere else.
- *
- * Preserves the exact `crypto.randomInt` rejection-sampled fairness RNG that
- * buyers are shown a public GitHub source link for (product.prizeGithubFileUrl)
- * — do not change the selection algorithm.
- */
-export async function assignPrizeDrawWinner(ctx, args) {
-    // The `FEATURE_PRIZE_DRAWS` gate here was deleted 2026-10-19 with the other
-    // four readers — see the header of `assignSpinPrize.ts`. This one was the
-    // worst-shaped of them: it returned `kind: "not_eligible"`, which every
-    // caller treats as "this order does not win anything", so with the env var
-    // unset a paid prize-draw entry was silently recorded as a non-winner.
-    const { orderId, productId } = args;
-    const orderRef = ctx.db.collection(ORDER_COLLECTION).doc(orderId);
-    const productRef = ctx.db.collection(PRODUCT_COLLECTION).doc(productId);
-    const result = await ctx.db.runTransaction(async (tx) => {
-        const [productSnap, orderSnap] = await Promise.all([
-            tx.get(productRef),
-            tx.get(orderRef),
-        ]);
-        if (!productSnap.exists || !orderSnap.exists) {
-            return { kind: "not_eligible" };
-        }
-        const product = productSnap.data();
-        const order = orderSnap.data();
-        // Idempotent — a winner was already assigned to this order.
-        if (order.prizeWon) {
-            return { kind: "already_revealed", prizeWon: order.prizeWon };
-        }
-        if (order.paymentStatus !== "paid" ||
-            order.status === "cancelled" ||
-            order.status === "refunded") {
-            return { kind: "not_eligible" };
-        }
-        const items = Array.isArray(product.prizeDrawItems)
-            ? [...product.prizeDrawItems]
-            : [];
-        const unwonIndices = items
-            .map((it, idx) => (it.isWon ? -1 : idx))
-            .filter((idx) => idx >= 0);
-        if (unwonIndices.length === 0) {
-            // Defensive only — preflightChecks already blocks overselling past
-            // prizeMaxEntries, so this should be unreachable outside a genuine
-            // race between two concurrent checkouts. No auto-refund here (that
-            // was the old buyer-claim-deadline behavior, now retired) — just
-            // report it so the caller can log/notify.
-            return { kind: "pool_exhausted" };
-        }
-        // crypto.randomInt is rejection-sampled and uniform — safe for fairness.
-        const pickPosition = crypto.randomInt(0, unwonIndices.length);
-        const pickIndex = unwonIndices[pickPosition];
-        const winningItem = items[pickIndex];
-        items[pickIndex] = { ...winningItem, isWon: true, wonByOrderId: orderId };
-        tx.update(productRef, {
-            prizeDrawItems: items,
-            updatedAt: ctx.now,
-        });
-        const prizeWon = {
-            itemNumber: winningItem.itemNumber,
-            title: winningItem.title,
-            images: winningItem.images,
-            wonAt: ctx.now,
-        };
-        const orderItems = Array.isArray(order.items) ? [...order.items] : [];
-        const revealedItems = orderItems.map((it) => it.listingType === "prize-draw" ? { ...it, prizeRevealStatus: "revealed" } : it);
-        tx.update(orderRef, {
-            prizeWon,
-            ...(revealedItems.length > 0 ? { items: revealedItems } : {}),
-            updatedAt: ctx.now,
-        });
-        return { kind: "revealed", prizeWon, userId: order.userId, productTitle: product.title };
-    });
-    if (result.kind === "revealed") {
-        ctx.logger.info("Prize-draw winner assigned", {
-            orderId,
-            productId,
-            itemNumber: result.prizeWon.itemNumber,
-        });
-        if (result.userId) {
-            try {
-                await sendNotification({
-                    userId: result.userId,
-                    type: "prize_won",
-                    priority: "high",
-                    title: "Your prize is ready!",
-                    message: `You won "${result.prizeWon.title}" in "${result.productTitle ?? "the draw"}" — check your order for details.`,
-                    relatedId: orderId,
-                    relatedType: "order",
-                    actionUrl: `/user/orders/view/${orderId}`,
-                });
-            }
-            catch (err) {
-                void normalizeError(err);
-                ctx.logger.warn("Prize-won notification failed", {
-                    err: err instanceof Error ? err.message : String(err),
-                });
-            }
-        }
-        return { kind: "revealed", prizeWon: result.prizeWon };
-    }
-    if (result.kind === "pool_exhausted") {
-        ctx.logger.warn("Prize-draw pool exhausted at assignment time", { orderId, productId });
-    }
-    return result;
-}

package/dist/_internal/server/jobs/core/prizeDrawExpiryReveal.d.ts

@@ -1,14 +0,0 @@
-import type { JobContext } from "../runtime/types";
-/**
- * "Scheduled" reveal mode, expiry half. Fires once a draw's
- * prizeRevealWindowEnd passes: assigns a winner to every paid, unrevealed
- * order for that draw, then closes it. Any prize items with no corresponding
- * order simply stay unrevealed / with the seller — that's expected on a
- * partial sellout, not an error.
- *
- * The sellout half of "scheduled" mode lives in prizeDrawSoldOutReveal.ts —
- * whichever fires first (expiry here, or a full sellout there) closes the
- * draw; this sweep naturally no-ops afterward since the product is already
- * "closed".
- */
-export declare function runPrizeDrawExpiryReveal(ctx: JobContext): Promise<void>;

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

@@ -1,71 +0,0 @@
-import { normalizeError } from "../../../../errors/normalize.js";
-import { PRODUCT_FIELDS, ORDER_FIELDS, COMMON_FIELDS } from "../../../../constants/field-names.js";
-import { assignPrizeDrawWinner } from "./prizeDrawAssignWinner.js";
-const PRODUCT_COLLECTION = "products";
-const ORDER_COLLECTION = "orders";
-const PRIZE_DRAW_LISTING_TYPE = "prize-draw";
-/**
- * "Scheduled" reveal mode, expiry half. Fires once a draw's
- * prizeRevealWindowEnd passes: assigns a winner to every paid, unrevealed
- * order for that draw, then closes it. Any prize items with no corresponding
- * order simply stay unrevealed / with the seller — that's expected on a
- * partial sellout, not an error.
- *
- * The sellout half of "scheduled" mode lives in prizeDrawSoldOutReveal.ts —
- * whichever fires first (expiry here, or a full sellout there) closes the
- * draw; this sweep naturally no-ops afterward since the product is already
- * "closed".
- */
-export async function runPrizeDrawExpiryReveal(ctx) {
-    // `FEATURE_PRIZE_DRAWS` gate deleted 2026-10-19 — see `assignSpinPrize.ts`.
-    ctx.logger.info("Prize-draw expiry reveal sweep starting");
-    const snap = await ctx.db
-        .collection(PRODUCT_COLLECTION)
-        .where(PRODUCT_FIELDS.LISTING_TYPE, "==", PRIZE_DRAW_LISTING_TYPE)
-        .where(PRODUCT_FIELDS.PRIZE_REVEAL_STATUS, "==", PRODUCT_FIELDS.PRIZE_REVEAL_STATUS_VALUES.OPEN)
-        .where(PRODUCT_FIELDS.PRIZE_REVEAL_WINDOW_END, "<=", ctx.now)
-        .limit(100)
-        .get();
-    if (snap.empty) {
-        ctx.logger.info("No prize draws past expiry");
-        return;
-    }
-    for (const doc of snap.docs) {
-        const product = doc.data();
-        if (product.prizeDrawMode === "lottery")
-            continue; // out of scope — separate mechanic
-        const orders = await ctx.db
-            .collection(ORDER_COLLECTION)
-            .where(ORDER_FIELDS.PRIZE_DRAW_PRODUCT_ID, "==", doc.id)
-            .where(ORDER_FIELDS.PAYMENT_STATUS, "==", ORDER_FIELDS.PAYMENT_STATUS_VALUES.PAID)
-            .where(ORDER_FIELDS.STATUS, "in", [
-            ORDER_FIELDS.STATUS_VALUES.PENDING,
-            ORDER_FIELDS.STATUS_VALUES.CONFIRMED,
-            ORDER_FIELDS.STATUS_VALUES.PROCESSING,
-        ])
-            .get();
-        let revealed = 0;
-        for (const orderDoc of orders.docs) {
-            const order = orderDoc.data();
-            if (order.prizeWon)
-                continue;
-            try {
-                const result = await assignPrizeDrawWinner(ctx, {
-                    orderId: orderDoc.id,
-                    productId: doc.id,
-                });
-                if (result.kind === "revealed")
-                    revealed++;
-            }
-            catch (err) {
-                void normalizeError(err);
-                ctx.logger.error("Expiry reveal failed for order", err, { orderId: orderDoc.id, productId: doc.id });
-            }
-        }
-        await doc.ref.update({
-            [PRODUCT_FIELDS.PRIZE_REVEAL_STATUS]: PRODUCT_FIELDS.PRIZE_REVEAL_STATUS_VALUES.CLOSED,
-            [COMMON_FIELDS.UPDATED_AT]: ctx.now,
-        });
-        ctx.logger.info("Closed prize draw at expiry", { productId: doc.id, revealed });
-    }
-}

package/dist/_internal/server/jobs/core/prizeDrawSoldOutReveal.d.ts

@@ -1,22 +0,0 @@
-import type { JobContext } from "../runtime/types";
-export interface PrizeDrawStockSnapshot {
-    listingType?: string;
-    prizeDrawMode?: string;
-    prizeRevealMode?: string;
-    prizeRevealStatus?: string;
-    prizeMaxEntries?: number;
-    prizeCurrentEntries?: number;
-}
-export interface HandlePrizeDrawSoldOutInput {
-    productId: string;
-    before: PrizeDrawStockSnapshot | null;
-    after: PrizeDrawStockSnapshot | null;
-}
-/**
- * "Scheduled" reveal mode, sellout half — the other trigger condition besides
- * expiry (prizeDrawExpiryReveal.ts). Fires the instant a scheduled-mode draw's
- * last entry sells, so buyers don't have to wait for the expiry sweep once
- * every ticket is gone. Assigns a winner to every paid, unrevealed order for
- * the draw, then closes it.
- */
-export declare function handlePrizeDrawSoldOut(input: HandlePrizeDrawSoldOutInput, ctx: JobContext): Promise<void>;

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

@@ -1,67 +0,0 @@
-import { normalizeError } from "../../../../errors/normalize.js";
-import { PRODUCT_FIELDS, ORDER_FIELDS, COMMON_FIELDS } from "../../../../constants/field-names.js";
-import { assignPrizeDrawWinner } from "./prizeDrawAssignWinner.js";
-const ORDER_COLLECTION = "orders";
-function isSoldOut(doc) {
-    if (!doc)
-        return false;
-    const max = doc.prizeMaxEntries ?? 0;
-    if (max <= 0)
-        return false;
-    return (doc.prizeCurrentEntries ?? 0) >= max;
-}
-/**
- * "Scheduled" reveal mode, sellout half — the other trigger condition besides
- * expiry (prizeDrawExpiryReveal.ts). Fires the instant a scheduled-mode draw's
- * last entry sells, so buyers don't have to wait for the expiry sweep once
- * every ticket is gone. Assigns a winner to every paid, unrevealed order for
- * the draw, then closes it.
- */
-export async function handlePrizeDrawSoldOut(input, ctx) {
-    // `FEATURE_PRIZE_DRAWS` gate deleted 2026-10-19 — see `assignSpinPrize.ts`.
-    const { productId, before, after } = input;
-    if (!after)
-        return;
-    if (after.listingType !== "prize-draw")
-        return;
-    if (after.prizeDrawMode === "lottery")
-        return; // out of scope — separate mechanic
-    if (after.prizeRevealMode !== "scheduled")
-        return;
-    if (after.prizeRevealStatus !== PRODUCT_FIELDS.PRIZE_REVEAL_STATUS_VALUES.OPEN)
-        return;
-    // Only act on the crossing transition into sold-out — avoids re-firing on
-    // every later write to an already-closed draw.
-    if (isSoldOut(before) || !isSoldOut(after))
-        return;
-    const orders = await ctx.db
-        .collection(ORDER_COLLECTION)
-        .where(ORDER_FIELDS.PRIZE_DRAW_PRODUCT_ID, "==", productId)
-        .where(ORDER_FIELDS.PAYMENT_STATUS, "==", ORDER_FIELDS.PAYMENT_STATUS_VALUES.PAID)
-        .where(ORDER_FIELDS.STATUS, "in", [
-        ORDER_FIELDS.STATUS_VALUES.PENDING,
-        ORDER_FIELDS.STATUS_VALUES.CONFIRMED,
-        ORDER_FIELDS.STATUS_VALUES.PROCESSING,
-    ])
-        .get();
-    let revealed = 0;
-    for (const orderDoc of orders.docs) {
-        const order = orderDoc.data();
-        if (order.prizeWon)
-            continue;
-        try {
-            const result = await assignPrizeDrawWinner(ctx, { orderId: orderDoc.id, productId });
-            if (result.kind === "revealed")
-                revealed++;
-        }
-        catch (err) {
-            void normalizeError(err);
-            ctx.logger.error("Sellout reveal failed for order", err, { orderId: orderDoc.id, productId });
-        }
-    }
-    await ctx.db.collection("products").doc(productId).update({
-        [PRODUCT_FIELDS.PRIZE_REVEAL_STATUS]: PRODUCT_FIELDS.PRIZE_REVEAL_STATUS_VALUES.CLOSED,
-        [COMMON_FIELDS.UPDATED_AT]: ctx.now,
-    });
-    ctx.logger.info("Closed prize draw on sellout", { productId, revealed });
-}

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

@@ -1,2 +0,0 @@
-import type { ScheduleHandler } from "../runtime/types";
-export declare const auctionSettlementHandler: ScheduleHandler;

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

@@ -1,2 +0,0 @@
-import { runAuctionSettlement } from "../core/auctionSettlement.js";
-export const auctionSettlementHandler = runAuctionSettlement;

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

@@ -1,3 +0,0 @@
-import type { FirestoreTriggerHandler } from "../runtime/types";
-import { type PrizeDrawOrderSnapshot } from "../core/onPrizeDrawPaymentConfirmed";
-export declare const onPrizeDrawPaymentConfirmedHandler: FirestoreTriggerHandler<PrizeDrawOrderSnapshot, PrizeDrawOrderSnapshot>;

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

@@ -1,11 +0,0 @@
-import { handlePrizeDrawPaymentConfirmed, } from "../core/onPrizeDrawPaymentConfirmed.js";
-export const onPrizeDrawPaymentConfirmedHandler = async (event, ctx) => {
-    const before = event.before;
-    const after = event.after;
-    if (!after)
-        return;
-    // Only act on the paid transition — avoids re-firing on every other order write.
-    if (before?.paymentStatus === "paid" || after.paymentStatus !== "paid")
-        return;
-    await handlePrizeDrawPaymentConfirmed({ orderId: event.params.orderId, order: after }, ctx);
-};

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

@@ -1,2 +0,0 @@
-import type { ScheduleHandler } from "../runtime/types";
-export declare const prizeDrawExpiryRevealHandler: ScheduleHandler;

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

@@ -1,2 +0,0 @@
-import { runPrizeDrawExpiryReveal } from "../core/prizeDrawExpiryReveal.js";
-export const prizeDrawExpiryRevealHandler = runPrizeDrawExpiryReveal;

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

@@ -1,3 +0,0 @@
-import type { FirestoreTriggerHandler } from "../runtime/types";
-import { type PrizeDrawStockSnapshot } from "../core/prizeDrawSoldOutReveal";
-export declare const prizeDrawSoldOutRevealHandler: FirestoreTriggerHandler<PrizeDrawStockSnapshot, PrizeDrawStockSnapshot>;

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

@@ -1,4 +0,0 @@
-import { handlePrizeDrawSoldOut, } from "../core/prizeDrawSoldOutReveal.js";
-export const prizeDrawSoldOutRevealHandler = async (event, ctx) => {
-    await handlePrizeDrawSoldOut({ productId: event.params.productId, before: event.before, after: event.after }, ctx);
-};