@mohasinac/appkit 4.2.0 → 4.3.1

package/dist/_internal/server/functions/firestore.js

@@ -6,7 +6,7 @@
  * The path patterns mirror the original `functions/src/index.ts` declarations
  * to preserve identical deploy behavior.
  */
-import { onBidPlacedHandler, onCategoryWriteHandler, onOrderCreateHandler, onOrderStatusChangeHandler, onProductStockChangeHandler, onProductWriteHandler, onReviewWriteHandler, onScamReportCreateHandler, onScamReportUpdateHandler, onStoreWriteHandler, onSupportTicketCreateHandler, onSupportTicketUpdateHandler, onUserBanChangeHandler, onShipmentItemWriteHandler, onShipmentLotWriteHandler, onShipmentHeaderWriteHandler, onShipmentDeletedHandler, onCatalogueSubmittedForApprovalHandler, onJobCreatedHandler, } from "../jobs/handlers";
+import { onBidPlacedHandler, onCategoryWriteHandler, onOrderCreateHandler, onOrderStatusChangeHandler, onProductStockChangeHandler, onProductWriteHandler, onReviewWriteHandler, onScamReportCreateHandler, onScamReportUpdateHandler, onStoreWriteHandler, onSupportTicketCreateHandler, onSupportTicketUpdateHandler, onUserBanChangeHandler, onShipmentItemWriteHandler, onShipmentLotWriteHandler, onShipmentHeaderWriteHandler, onShipmentDeletedHandler, onCatalogueSubmittedForApprovalHandler, onJobCreatedHandler, onPrizeDrawPaymentConfirmedHandler, prizeDrawSoldOutRevealHandler, } from "../jobs/handlers";
 import { defineFunction } from "./define";
 const REGION = "asia-south1";
 export const onBidPlaced = defineFunction({
@@ -44,6 +44,20 @@ export const onProductStockChange = defineFunction({
     handler: onProductStockChangeHandler,
     options: { region: REGION },
 });
+export const onPrizeDrawPaymentConfirmed = defineFunction({
+    name: "onPrizeDrawPaymentConfirmed",
+    description: "Instant-mode prize-draw winner assignment the moment an order's payment is confirmed.",
+    trigger: { kind: "documentUpdated", pathPattern: "orders/{orderId}" },
+    handler: onPrizeDrawPaymentConfirmedHandler,
+    options: { region: REGION },
+});
+export const prizeDrawSoldOutReveal = defineFunction({
+    name: "prizeDrawSoldOutReveal",
+    description: "Assign winners for all outstanding prize-draw orders the moment a scheduled-mode draw sells out.",
+    trigger: { kind: "documentWritten", pathPattern: "products/{productId}" },
+    handler: prizeDrawSoldOutRevealHandler,
+    options: { region: REGION },
+});
 export const onReviewWrite = defineFunction({
     name: "onReviewWrite",
     description: "Recompute product + store rating aggregates on review writes.",
@@ -155,6 +169,8 @@ export const FIRESTORE_TRIGGER_FUNCTIONS = [
     onOrderStatusChange,
     onProductWrite,
     onProductStockChange,
+    onPrizeDrawPaymentConfirmed,
+    prizeDrawSoldOutReveal,
     onReviewWrite,
     onCategoryWrite,
     onStoreWrite,

package/dist/_internal/server/functions/scheduled.d.ts

@@ -19,11 +19,8 @@ export declare const cleanupRtdbEvents: import("./types").ScheduledFunctionDefin
 export declare const mediaTmpCleanup: import("./types").ScheduledFunctionDefinition;
 export declare const draftPrune: import("./types").ScheduledFunctionDefinition;
 export declare const testerSandboxCleanup: import("./types").ScheduledFunctionDefinition;
-export declare const prizeRevealOpen: import("./types").ScheduledFunctionDefinition;
-export declare const prizeRevealClose: import("./types").ScheduledFunctionDefinition;
-export declare const prizeRevealExpiry: import("./types").ScheduledFunctionDefinition;
-export declare const prizeRevealReminder: import("./types").ScheduledFunctionDefinition;
+export declare const prizeDrawExpiryReveal: import("./types").ScheduledFunctionDefinition;
 export declare const bundleStockSync: import("./types").ScheduledFunctionDefinition;
 export declare const emiInstallmentReminder: import("./types").ScheduledFunctionDefinition;
 export declare const catalogueImageStalenessReminder: import("./types").ScheduledFunctionDefinition;
-export declare const SCHEDULED_FUNCTIONS: readonly [import("./types").ScheduledFunctionDefinition, import("./types").ScheduledFunctionDefinition, import("./types").ScheduledFunctionDefinition, import("./types").ScheduledFunctionDefinition, import("./types").ScheduledFunctionDefinition, import("./types").ScheduledFunctionDefinition, import("./types").ScheduledFunctionDefinition, import("./types").ScheduledFunctionDefinition, import("./types").ScheduledFunctionDefinition, import("./types").ScheduledFunctionDefinition, import("./types").ScheduledFunctionDefinition, import("./types").ScheduledFunctionDefinition, import("./types").ScheduledFunctionDefinition, import("./types").ScheduledFunctionDefinition, import("./types").ScheduledFunctionDefinition, import("./types").ScheduledFunctionDefinition, import("./types").ScheduledFunctionDefinition, import("./types").ScheduledFunctionDefinition, import("./types").ScheduledFunctionDefinition, import("./types").ScheduledFunctionDefinition, import("./types").ScheduledFunctionDefinition, import("./types").ScheduledFunctionDefinition, import("./types").ScheduledFunctionDefinition, import("./types").ScheduledFunctionDefinition, import("./types").ScheduledFunctionDefinition, import("./types").ScheduledFunctionDefinition, import("./types").ScheduledFunctionDefinition, import("./types").ScheduledFunctionDefinition];
+export declare const SCHEDULED_FUNCTIONS: readonly [import("./types").ScheduledFunctionDefinition, import("./types").ScheduledFunctionDefinition, import("./types").ScheduledFunctionDefinition, import("./types").ScheduledFunctionDefinition, import("./types").ScheduledFunctionDefinition, import("./types").ScheduledFunctionDefinition, import("./types").ScheduledFunctionDefinition, import("./types").ScheduledFunctionDefinition, import("./types").ScheduledFunctionDefinition, import("./types").ScheduledFunctionDefinition, import("./types").ScheduledFunctionDefinition, import("./types").ScheduledFunctionDefinition, import("./types").ScheduledFunctionDefinition, import("./types").ScheduledFunctionDefinition, import("./types").ScheduledFunctionDefinition, import("./types").ScheduledFunctionDefinition, import("./types").ScheduledFunctionDefinition, import("./types").ScheduledFunctionDefinition, import("./types").ScheduledFunctionDefinition, import("./types").ScheduledFunctionDefinition, import("./types").ScheduledFunctionDefinition, import("./types").ScheduledFunctionDefinition, import("./types").ScheduledFunctionDefinition, import("./types").ScheduledFunctionDefinition, import("./types").ScheduledFunctionDefinition];

package/dist/_internal/server/functions/scheduled.js

@@ -1,6 +1,6 @@
 // Scheduled function definitions (Cloud Scheduler triggers).
 // Cron syntax accepts both Firebase shorthand and standard cron expressions.
-import { auctionSettlementHandler, autoPayoutEligibilityHandler, bundleStockSyncHandler, cartPruneHandler, cleanupRtdbEventsHandler, countersReconcileHandler, couponExpiryHandler, dailyDataCleanupHandler, draftPruneHandler, emiInstallmentReminderHandler, catalogueImageStalenessReminderHandler, mediaTmpCleanupHandler, notificationPruneHandler, offerExpiryHandler, payoutBatchHandler, paymentWindowTimeoutHandler, hardBanReinstatementHandler, paymentReviewAutoApproveHandler, pendingOrderTimeoutHandler, positionsReconcileHandler, prizeRevealCloseHandler, prizeRevealExpiryHandler, prizeRevealOpenHandler, prizeRevealReminderHandler, productStatsSyncHandler, revenueRollupHandler, weeklyPayoutEligibilityHandler, testerSandboxCleanupHandler, } from "../jobs/handlers";
+import { auctionSettlementHandler, autoPayoutEligibilityHandler, bundleStockSyncHandler, cartPruneHandler, cleanupRtdbEventsHandler, countersReconcileHandler, couponExpiryHandler, dailyDataCleanupHandler, draftPruneHandler, emiInstallmentReminderHandler, catalogueImageStalenessReminderHandler, mediaTmpCleanupHandler, notificationPruneHandler, offerExpiryHandler, payoutBatchHandler, paymentWindowTimeoutHandler, hardBanReinstatementHandler, paymentReviewAutoApproveHandler, pendingOrderTimeoutHandler, positionsReconcileHandler, prizeDrawExpiryRevealHandler, productStatsSyncHandler, revenueRollupHandler, weeklyPayoutEligibilityHandler, testerSandboxCleanupHandler, } from "../jobs/handlers";
 import { defineFunction } from "./define";
 const REGION = "asia-south1";
 const EVERY_5_MIN = "every 5 minutes";
@@ -151,32 +151,11 @@ export const testerSandboxCleanup = defineFunction({
     handler: testerSandboxCleanupHandler,
     options: { region: REGION, timeoutSeconds: 300, memory: "256MiB", maxInstances: 1 },
 });
-export const prizeRevealOpen = defineFunction({
-    name: "prizeRevealOpen",
-    description: "Flip prize-draw reveals pending→open and send opening notifications.",
+export const prizeDrawExpiryReveal = defineFunction({
+    name: "prizeDrawExpiryReveal",
+    description: "Assign winners for outstanding paid orders on scheduled-mode prize draws past their expiry, then close them (every 5 minutes).",
     trigger: { kind: "schedule", cron: EVERY_5_MIN },
-    handler: prizeRevealOpenHandler,
-    options: { region: REGION, timeoutSeconds: 120, memory: "256MiB", maxInstances: 1 },
-});
-export const prizeRevealClose = defineFunction({
-    name: "prizeRevealClose",
-    description: "Flip prize-draw reveals open→closed.",
-    trigger: { kind: "schedule", cron: EVERY_5_MIN },
-    handler: prizeRevealCloseHandler,
-    options: { region: REGION, timeoutSeconds: 60, memory: "256MiB", maxInstances: 1 },
-});
-export const prizeRevealExpiry = defineFunction({
-    name: "prizeRevealExpiry",
-    description: "Auto-refund unrevealed prize-draw entries past deadline (every 6 hours UTC).",
-    trigger: { kind: "schedule", cron: "0 */6 * * *", timeZone: "UTC" },
-    handler: prizeRevealExpiryHandler,
-    options: { region: REGION, timeoutSeconds: 300, memory: "256MiB", maxInstances: 1 },
-});
-export const prizeRevealReminder = defineFunction({
-    name: "prizeRevealReminder",
-    description: "Nudge prize-draw buyers <24h to deadline (daily 10:00 IST).",
-    trigger: { kind: "schedule", cron: "0 10 * * *", timeZone: "Asia/Kolkata" },
-    handler: prizeRevealReminderHandler,
+    handler: prizeDrawExpiryRevealHandler,
     options: { region: REGION, timeoutSeconds: 300, memory: "256MiB", maxInstances: 1 },
 });
 export const bundleStockSync = defineFunction({
@@ -222,10 +201,7 @@ export const SCHEDULED_FUNCTIONS = [
     mediaTmpCleanup,
     draftPrune,
     testerSandboxCleanup,
-    prizeRevealOpen,
-    prizeRevealClose,
-    prizeRevealExpiry,
-    prizeRevealReminder,
+    prizeDrawExpiryReveal,
     bundleStockSync,
     emiInstallmentReminder,
     catalogueImageStalenessReminder,

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

@@ -16,9 +16,12 @@ function isMemberAvailable(data) {
         return false;
     return data.status === PRODUCT_FIELDS.STATUS_VALUES.PUBLISHED;
 }
-async function computeBundleStockStatus(productIds, ctx) {
+async function sweepBundleMembers(productIds, ctx) {
     if (productIds.length === 0)
-        return "out_of_stock";
+        return { stockStatus: "out_of_stock", originalTotal: undefined };
+    let stockStatus = "in_stock";
+    let originalTotal = 0;
+    let resolvedCount = 0;
     for (let i = 0; i < productIds.length; i += 30) {
         const chunk = productIds.slice(i, i + 30);
         const snap = await ctx.db
@@ -26,14 +29,26 @@ async function computeBundleStockStatus(productIds, ctx) {
             .where("__name__", "in", chunk)
             .get();
         if (snap.size < chunk.length)
-            return "out_of_stock";
+            stockStatus = "out_of_stock";
         for (const doc of snap.docs) {
             const data = doc.data();
             if (!isMemberAvailable(data))
-                return "out_of_stock";
+                stockStatus = "out_of_stock";
+            if (typeof data.price === "number" && originalTotal !== undefined) {
+                originalTotal += data.price;
+                resolvedCount++;
+            }
+            else {
+                originalTotal = undefined;
+            }
         }
     }
-    return "in_stock";
+    if (resolvedCount !== productIds.length)
+        originalTotal = undefined;
+    return {
+        stockStatus,
+        originalTotal: originalTotal !== undefined ? Math.round(originalTotal * 100) / 100 : undefined,
+    };
 }
 export async function runBundleStockSync(ctx) {
     if (ctx.env("FEATURE_BUNDLES") !== "true") {
@@ -57,10 +72,13 @@ export async function runBundleStockSync(ctx) {
         const productIds = data.bundleProductIds ?? [];
         if (productIds.length === 0)
             continue;
-        const nextStatus = await computeBundleStockStatus(productIds, ctx);
-        if (nextStatus !== data.bundleStockStatus) {
+        const { stockStatus: nextStatus, originalTotal: nextOriginalTotal } = await sweepBundleMembers(productIds, ctx);
+        const statusChanged = nextStatus !== data.bundleStockStatus;
+        const totalChanged = nextOriginalTotal !== data.bundleOriginalTotal;
+        if (statusChanged || totalChanged) {
             await bundleDoc.ref.update({
                 [CATEGORY_FIELDS.BUNDLE_STOCK_STATUS]: nextStatus,
+                [CATEGORY_FIELDS.BUNDLE_ORIGINAL_TOTAL]: nextOriginalTotal ?? null,
                 [CATEGORY_FIELDS.BUNDLE_QUERY_RESOLVED_AT]: ctx.now,
                 [COMMON_FIELDS.UPDATED_AT]: ctx.now,
             });

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

@@ -15,7 +15,13 @@ async function reconcileCategories(ctx) {
     const leafCounts = {};
     for (const doc of snap.docs) {
         const data = doc.data();
-        const catId = data.category;
+        // `category` is @deprecated in favor of `categorySlugs[]` — mirrors the
+        // same effective-category selection as onProductWrite.ts's live trigger
+        // so the nightly reconcile agrees with real-time updates instead of
+        // silently no-op'ing on products written via categorySlugs-only paths.
+        const catId = Array.isArray(data.categorySlugs) && data.categorySlugs.length > 0
+            ? data.categorySlugs[0]
+            : data.category;
         if (!catId)
             continue;
         if (!leafCounts[catId])

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

@@ -26,10 +26,10 @@ export { runWeeklyPayoutEligibility, type WeeklyPayoutEligibilityResult, } from
 export { runHardBanCascade } from "./hardBanCascade";
 export { JOB_RUNNERS, type JobRunner, type JobRunResult, } from "./jobRunners";
 export { runAuctionSettlement } from "./auctionSettlement";
-export { runPrizeRevealOpen } from "./prizeRevealOpen";
-export { runPrizeRevealClose } from "./prizeRevealClose";
-export { runPrizeRevealExpiry } from "./prizeRevealExpiry";
-export { runPrizeRevealReminder } from "./prizeRevealReminder";
+export { assignPrizeDrawWinner, type AssignPrizeDrawWinnerResult } from "./prizeDrawAssignWinner";
+export { handlePrizeDrawPaymentConfirmed } from "./onPrizeDrawPaymentConfirmed";
+export { handlePrizeDrawSoldOut } from "./prizeDrawSoldOutReveal";
+export { runPrizeDrawExpiryReveal } from "./prizeDrawExpiryReveal";
 export { runPromotions, type PromotionsCallableResult } from "./promotions";
 export { runListingProcessor, supportedListingCollections, type ListingRequestBody, type ListingResponseBody, } from "./listingProcessor";
 export { runStoreAnalytics, type StoreAnalyticsInput, type StoreAnalyticsResult, } from "./storeAnalytics";

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

@@ -27,10 +27,10 @@ export { runWeeklyPayoutEligibility, } from "./weeklyPayoutEligibility";
 export { runHardBanCascade } from "./hardBanCascade";
 export { JOB_RUNNERS, } from "./jobRunners";
 export { runAuctionSettlement } from "./auctionSettlement";
-export { runPrizeRevealOpen } from "./prizeRevealOpen";
-export { runPrizeRevealClose } from "./prizeRevealClose";
-export { runPrizeRevealExpiry } from "./prizeRevealExpiry";
-export { runPrizeRevealReminder } from "./prizeRevealReminder";
+export { assignPrizeDrawWinner } from "./prizeDrawAssignWinner";
+export { handlePrizeDrawPaymentConfirmed } from "./onPrizeDrawPaymentConfirmed";
+export { handlePrizeDrawSoldOut } from "./prizeDrawSoldOutReveal";
+export { runPrizeDrawExpiryReveal } from "./prizeDrawExpiryReveal";
 // Callables
 export { runPromotions } from "./promotions";
 export { runListingProcessor, supportedListingCollections, } from "./listingProcessor";

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

@@ -0,0 +1,19 @@
+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

@@ -0,0 +1,30 @@
+import { normalizeError } from "../../../../errors/normalize";
+import { assignPrizeDrawWinner } from "./prizeDrawAssignWinner";
+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/paymentWindowTimeout.d.ts

@@ -5,8 +5,8 @@ import type { JobContext } from "../runtime/types";
  * its `paymentDeadline`. Runs every 5 minutes (`EVERY_5_MIN`), so an order
  * can overshoot its 15-minute deadline by up to ~5 minutes before this
  * catches it — acceptable, matches the existing tight-interval precedent
- * (`prizeRevealOpen`/`prizeRevealClose`) rather than inventing a 1-minute
- * cron that would multiply invocation cost for marginal UX gain.
+ * (`prizeDrawExpiryReveal`) rather than inventing a 1-minute cron that would
+ * multiply invocation cost for marginal UX gain.
  *
  * Orders that already have a `paymentProofUrl` are excluded by the
  * repository query — those are the 2-hour auto-approve sweep's domain

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

@@ -11,8 +11,8 @@ import { ORDER_MESSAGES } from "../handlers/messages";
  * its `paymentDeadline`. Runs every 5 minutes (`EVERY_5_MIN`), so an order
  * can overshoot its 15-minute deadline by up to ~5 minutes before this
  * catches it — acceptable, matches the existing tight-interval precedent
- * (`prizeRevealOpen`/`prizeRevealClose`) rather than inventing a 1-minute
- * cron that would multiply invocation cost for marginal UX gain.
+ * (`prizeDrawExpiryReveal`) rather than inventing a 1-minute cron that would
+ * multiply invocation cost for marginal UX gain.
  *
  * Orders that already have a `paymentProofUrl` are excluded by the
  * repository query — those are the 2-hour auto-approve sweep's domain

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

@@ -0,0 +1,20 @@
+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

@@ -0,0 +1,113 @@
+import crypto from "node:crypto";
+import { normalizeError } from "../../../../errors/normalize";
+import { sendNotification } from "../../../../features/admin/actions/notification-actions";
+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) {
+    if (ctx.env("FEATURE_PRIZE_DRAWS") !== "true") {
+        ctx.logger.info("FEATURE_PRIZE_DRAWS disabled — skipping winner assignment");
+        return { kind: "not_eligible" };
+    }
+    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

@@ -0,0 +1,14 @@
+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

@@ -0,0 +1,74 @@
+import { normalizeError } from "../../../../errors/normalize";
+import { PRODUCT_FIELDS, ORDER_FIELDS, COMMON_FIELDS } from "../../../../constants/field-names";
+import { assignPrizeDrawWinner } from "./prizeDrawAssignWinner";
+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) {
+    if (ctx.env("FEATURE_PRIZE_DRAWS") !== "true") {
+        ctx.logger.info("FEATURE_PRIZE_DRAWS disabled — skipping prize-draw expiry reveal");
+        return;
+    }
+    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

@@ -0,0 +1,22 @@
+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

@@ -0,0 +1,68 @@
+import { normalizeError } from "../../../../errors/normalize";
+import { PRODUCT_FIELDS, ORDER_FIELDS, COMMON_FIELDS } from "../../../../constants/field-names";
+import { assignPrizeDrawWinner } from "./prizeDrawAssignWinner";
+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) {
+    if (ctx.env("FEATURE_PRIZE_DRAWS") !== "true")
+        return;
+    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/index.d.ts

@@ -38,11 +38,10 @@ export { onStoreWriteHandler } from "./onStoreWrite";
 export { adminAnalyticsHandler, type AdminAnalyticsResult } from "./adminAnalytics";
 export { storeAnalyticsHandler, type StoreAnalyticsInput, type StoreAnalyticsResult, } from "./storeAnalytics";
 export { listingProcessorHandler, supportedListingCollections, type ListingRequestBody, type ListingResponseBody, } from "./listingProcessor";
-export { prizeRevealOpenHandler } from "./prizeRevealOpen";
-export { prizeRevealCloseHandler } from "./prizeRevealClose";
-export { prizeRevealExpiryHandler } from "./prizeRevealExpiry";
-export { prizeRevealReminderHandler } from "./prizeRevealReminder";
 export { bundleStockSyncHandler } from "./bundleStockSync";
+export { onPrizeDrawPaymentConfirmedHandler } from "./onPrizeDrawPaymentConfirmed";
+export { prizeDrawSoldOutRevealHandler } from "./prizeDrawSoldOutReveal";
+export { prizeDrawExpiryRevealHandler } from "./prizeDrawExpiryReveal";
 export { onProductStockChangeHandler } from "./onProductStockChange";
 export { triggerEventRaffleHandler } from "./triggerEventRaffle";
 export { assignSpinPrizeHandler } from "./assignSpinPrize";