@mohasinac/appkit 2.6.0 → 2.6.2

package/dist/_internal/server/features/checkout/prize-bundle-gates.js

@@ -0,0 +1,99 @@
+/**
+ * Prize-draw + bundle + maxPerUser gates for the checkout pipeline (SB6-C, SB8-A).
+ *
+ * Shared helper used by both `createCheckoutOrderAction` (COD/UPI-manual path)
+ * and `verifyAndPlaceRazorpayOrderAction` (Razorpay path). Pulled out here so
+ * the two transactional flows enforce the same rules.
+ */
+import { ValidationError } from "../../../../errors";
+import { orderRepository } from "../../../../repositories";
+/**
+ * Pre-transaction read: for every cart item whose product has `maxPerUser`
+ * set, count the user's existing active orders and reject the checkout if
+ * the new request would push them over the cap.
+ *
+ * Active = pending / confirmed / processing / shipped / delivered. Cancelled
+ * + refunded orders do NOT count (stock was returned to circulation).
+ *
+ * Throws ValidationError with code `MAX_PER_USER` listing every violating
+ * product. The check is informational-rich on purpose — the UI surfaces all
+ * blocked items at once instead of revealing them one at a time.
+ */
+export async function enforceMaxPerUserForCart(args) {
+    const { userId, items } = args;
+    // Aggregate per productId so a cart with multiple lines for the same
+    // product still gets one accurate count.
+    const cartQuantityByProduct = new Map();
+    for (const { item } of items) {
+        cartQuantityByProduct.set(item.productId, (cartQuantityByProduct.get(item.productId) ?? 0) + item.quantity);
+    }
+    const violations = [];
+    for (const [productId, requested] of cartQuantityByProduct.entries()) {
+        const product = items.find((i) => i.item.productId === productId)?.product;
+        if (!product)
+            continue;
+        const cap = product.maxPerUser;
+        if (typeof cap !== "number" || cap <= 0)
+            continue;
+        const alreadyPurchased = await orderRepository.countByUserAndProduct(userId, productId);
+        if (alreadyPurchased + requested > cap) {
+            violations.push({
+                productId,
+                productTitle: product.title,
+                allowance: cap,
+                alreadyPurchased,
+                requested,
+            });
+        }
+    }
+    if (violations.length > 0) {
+        const summary = violations
+            .map((v) => `${v.productTitle}: ${v.alreadyPurchased}/${v.allowance} used, requested ${v.requested}`)
+            .join("; ");
+        throw Object.assign(new ValidationError(`Purchase limit reached for one or more items. ${summary}`), { code: "MAX_PER_USER", violations });
+    }
+}
+/**
+ * SB8-A — compute the deadline by which the buyer must claim their prize
+ * via the reveal API.
+ *
+ * Rules:
+ *   - If the reveal window has not yet opened:
+ *       deadline = min(revealWindowStart + revealDeadlineDays, revealWindowEnd)
+ *   - If the window is already open:
+ *       deadline = min(now + revealDeadlineDays, revealWindowEnd)
+ *
+ * Returns `undefined` if the product lacks the prize-draw fields.
+ */
+export function computePrizeRevealDeadline(product, now = new Date()) {
+    const windowStart = product.prizeRevealWindowStart
+        ? new Date(product.prizeRevealWindowStart)
+        : undefined;
+    const windowEnd = product.prizeRevealWindowEnd
+        ? new Date(product.prizeRevealWindowEnd)
+        : undefined;
+    if (!windowStart || !windowEnd)
+        return undefined;
+    const days = product.prizeRevealDeadlineDays ?? 3;
+    const dayMs = 86400000;
+    const base = windowStart.getTime() > now.getTime() ? windowStart : now;
+    const candidate = new Date(base.getTime() + days * dayMs);
+    return candidate.getTime() < windowEnd.getTime() ? candidate : windowEnd;
+}
+/**
+ * Inside the existing checkout transaction, validate the prize-pool cap for
+ * each prize-draw line. Caller must pass the fresh product snapshot read
+ * within the transaction (so `prizeCurrentEntries` is up-to-date).
+ *
+ * Throws ValidationError if any item would overflow the pool.
+ */
+export function enforcePrizePoolCap(args) {
+    const { productSnapshot, requestedQuantity } = args;
+    if (productSnapshot.listingType !== "prize-draw")
+        return;
+    const max = productSnapshot.prizeMaxEntries ?? 0;
+    const current = productSnapshot.prizeCurrentEntries ?? 0;
+    if (max > 0 && current + requestedQuantity > max) {
+        throw Object.assign(new ValidationError(`Draw is full for "${productSnapshot.title}". ${current}/${max} entries already in.`), { code: "PRIZE_POOL_FULL", productId: productSnapshot.id });
+    }
+}

package/dist/_internal/server/features/grouped/data.js

@@ -9,17 +9,24 @@ function mapDoc(doc) {
         const d = v?.toDate?.();
         return d ?? (v instanceof Date ? v : new Date());
     };
+    const productIds = Array.isArray(data.productIds)
+        ? data.productIds
+        : [];
+    const minActiveMembers = data.minActiveMembers ?? 2;
+    const activeMemberCount = data.activeMemberCount ?? productIds.length;
     return {
         id: doc.id,
         slug: data.slug ?? doc.id,
         title: data.title ?? "",
         description: data.description,
-        productIds: Array.isArray(data.productIds) ? data.productIds : [],
+        productIds,
         coverImage: data.coverImage,
-        bundlePrice: data.bundlePrice,
-        originalPrice: data.originalPrice,
-        discountPercent: data.discountPercent,
-        currency: (data.currency ?? "INR"),
+        // SB-UNI-V — pricing fields dropped; theme-group semantics.
+        groupTheme: data.groupTheme ?? "generic",
+        minActiveMembers,
+        activeMemberCount,
+        visibilityStatus: data.visibilityStatus ??
+            (activeMemberCount >= minActiveMembers ? "visible" : "hidden"),
         isActive: data.isActive === true,
         isFeatured: data.isFeatured === true,
         storeId: data.storeId,

package/dist/_internal/server/features/homepage/data.d.ts

@@ -10,7 +10,7 @@ export declare const getHomepageInitial: () => Promise<{
     featuredProducts: never[] | import("../../../..").ProductDocument[];
     activeAuctions: never[] | import("../../../..").ProductDocument[];
     activePreOrders: never[] | import("../../../..").ProductDocument[];
-    activeBrands: never[] | import("../../../..").BrandDocument[];
+    activeBrands: never[] | import("../../../..").CategoryDocument[];
     featuredReviews: never[] | import("../../../..").ReviewDocument[];
     recentBlogPosts: never[] | import("../../../..").BlogPostDocument[];
     activeEvents: never[] | import("../../../..").EventDocument[];

package/dist/_internal/server/features/homepage/data.js

@@ -1,5 +1,5 @@
 import { cache } from "react";
-import { homepageSectionsRepository, carouselRepository, productRepository, brandsRepository, reviewRepository, blogRepository, eventRepository, categoriesRepository, } from "../../../../repositories";
+import { homepageSectionsRepository, carouselRepository, productRepository, reviewRepository, blogRepository, eventRepository, categoriesRepository, } from "../../../../repositories";
 import { HOMEPAGE_FEATURED_REVIEWS_LIMIT, HOMEPAGE_RECENT_BLOG_POSTS_LIMIT, } from "../../../shared/features/homepage/config";
 export const getHomepageSections = cache(async () => {
     return homepageSectionsRepository.getEnabledSections().catch(() => []);
@@ -18,7 +18,7 @@ export const getHomepageInitial = cache(async () => {
         productRepository.findFeatured().catch(() => []),
         productRepository.findActiveAuctions().catch(() => []),
         productRepository.findActivePreOrders().catch(() => []),
-        brandsRepository.findActive().catch(() => []),
+        categoriesRepository.findActiveBrands().catch(() => []),
         reviewRepository.findFeatured(HOMEPAGE_FEATURED_REVIEWS_LIMIT).catch(() => []),
         blogRepository.listPublished({}, { page: 1, pageSize: HOMEPAGE_RECENT_BLOG_POSTS_LIMIT, sorts: "-publishedAt" }).then((r) => r.items ?? []).catch(() => []),
         eventRepository.listActive().catch(() => []),

package/dist/_internal/server/features/media/contextGuards.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Media context guardrails — shared by /api/media/sign and the legacy
+ * /api/media/upload routes. Validates per-context index caps + image-only
+ * vs PDF-only context affinity.
+ *
+ * Returns either an `{ ok: true }` payload with the derived filename + ext,
+ * or `{ ok: false, error, status, details? }` for an error response.
+ *
+ * Pure logic — no Firebase SDK calls, no `Buffer` work — so it's safe to
+ * import from any server route.
+ */
+import { type AllowedMime } from "../../../shared/media/limits";
+import { type MediaFilenameContext } from "../../../../utils/id-generators";
+export declare const CONTEXT_LIMITS: {
+    readonly PRODUCT_IMAGE_MAX: 5;
+    readonly PRODUCT_VIDEO_MAX: 1;
+    readonly REVIEW_IMAGE_MAX: 5;
+    readonly REVIEW_VIDEO_MAX: 1;
+    readonly AUCTION_IMAGE_MAX: 5;
+    readonly PREORDER_IMAGE_MAX: 5;
+    readonly EVENT_COVER_MAX: 1;
+    readonly EVENT_IMAGE_MAX: 10;
+    readonly EVENT_WINNER_IMAGE_MAX: 5;
+    readonly EVENT_ADDITIONAL_IMAGE_MAX: 10;
+    readonly BLOG_COVER_MAX: 1;
+    readonly BLOG_CONTENT_IMAGE_MAX: 10;
+    readonly BLOG_ADDITIONAL_IMAGE_MAX: 5;
+    readonly RICH_TEXT_IMAGE_MAX: 20;
+};
+export interface GuardError {
+    ok: false;
+    error: string;
+    status: number;
+    details?: Record<string, unknown>;
+}
+export interface GuardSuccess {
+    ok: true;
+    filename: string;
+    ext: string;
+}
+export type GuardResult = GuardError | GuardSuccess;
+interface GuardInput {
+    detectedMime: AllowedMime | string;
+    context: MediaFilenameContext;
+}
+/**
+ * Apply per-context guardrails to a parsed MediaFilenameContext and
+ * derive the SEO filename. Mirrors the inline logic that used to live
+ * in /api/media/upload.
+ */
+export declare function applyMediaContextGuards({ detectedMime, context: ctx, }: GuardInput): GuardResult;
+export {};

package/dist/_internal/server/features/media/contextGuards.js

@@ -0,0 +1,198 @@
+/**
+ * Media context guardrails — shared by /api/media/sign and the legacy
+ * /api/media/upload routes. Validates per-context index caps + image-only
+ * vs PDF-only context affinity.
+ *
+ * Returns either an `{ ok: true }` payload with the derived filename + ext,
+ * or `{ ok: false, error, status, details? }` for an error response.
+ *
+ * Pure logic — no Firebase SDK calls, no `Buffer` work — so it's safe to
+ * import from any server route.
+ */
+import { classifyMime, MIME_TO_EXT, } from "../../../shared/media/limits";
+import { generateMediaFilename, } from "../../../../utils/id-generators";
+// Per-context limits — mirrored from the previous inline constants in
+// /api/media/upload. Adjust here, not at the call site.
+export const CONTEXT_LIMITS = {
+    PRODUCT_IMAGE_MAX: 5,
+    PRODUCT_VIDEO_MAX: 1,
+    REVIEW_IMAGE_MAX: 5,
+    REVIEW_VIDEO_MAX: 1,
+    AUCTION_IMAGE_MAX: 5,
+    PREORDER_IMAGE_MAX: 5,
+    EVENT_COVER_MAX: 1,
+    EVENT_IMAGE_MAX: 10,
+    EVENT_WINNER_IMAGE_MAX: 5,
+    EVENT_ADDITIONAL_IMAGE_MAX: 10,
+    BLOG_COVER_MAX: 1,
+    BLOG_CONTENT_IMAGE_MAX: 10,
+    BLOG_ADDITIONAL_IMAGE_MAX: 5,
+    RICH_TEXT_IMAGE_MAX: 20,
+};
+const PDF_ONLY_CONTEXTS = ["invoice", "payout-doc"];
+const IMAGE_ONLY_CONTEXT_TYPES = new Set([
+    "store-logo",
+    "store-banner",
+    "user-avatar",
+    "event-cover",
+    "event-image",
+    "event-winner-image",
+    "event-additional-image",
+    "blog-cover",
+    "blog-content-image",
+    "blog-additional-image",
+]);
+function indexGuard(receivedIndex, max, errorMessage) {
+    if (receivedIndex < 1 || receivedIndex > max) {
+        return {
+            ok: false,
+            status: 400,
+            error: errorMessage,
+            details: { maxImages: max, receivedIndex },
+        };
+    }
+    return null;
+}
+/**
+ * Apply per-context guardrails to a parsed MediaFilenameContext and
+ * derive the SEO filename. Mirrors the inline logic that used to live
+ * in /api/media/upload.
+ */
+export function applyMediaContextGuards({ detectedMime, context: ctx, }) {
+    const kind = classifyMime(detectedMime);
+    if (!kind) {
+        return {
+            ok: false,
+            status: 400,
+            error: "Unsupported MIME type",
+            details: { detected: detectedMime },
+        };
+    }
+    const isVideo = kind === "video";
+    const isPdf = kind === "pdf";
+    if (ctx.type === "product-image") {
+        const idx = ctx.index ?? 1;
+        const err = indexGuard(idx, CONTEXT_LIMITS.PRODUCT_IMAGE_MAX, "Product image index exceeds max allowed");
+        if (err)
+            return err;
+    }
+    if (ctx.type === "product-video") {
+        const idx = ctx.index ?? 1;
+        const err = indexGuard(idx, CONTEXT_LIMITS.PRODUCT_VIDEO_MAX, "Only one product video is allowed");
+        if (err)
+            return err;
+    }
+    if (ctx.type === "review-image") {
+        const idx = ctx.index ?? 1;
+        const err = indexGuard(idx, CONTEXT_LIMITS.REVIEW_IMAGE_MAX, "Review image index exceeds max allowed");
+        if (err)
+            return err;
+    }
+    if (ctx.type === "review-video" && !isVideo) {
+        return {
+            ok: false,
+            status: 400,
+            error: "review-video context requires a video file",
+        };
+    }
+    if (ctx.type === "auction-image") {
+        const idx = ctx.index ?? 1;
+        const err = indexGuard(idx, CONTEXT_LIMITS.AUCTION_IMAGE_MAX, "Auction image index exceeds max allowed");
+        if (err)
+            return err;
+    }
+    if (ctx.type === "preorder-image") {
+        const idx = ctx.index ?? 1;
+        const err = indexGuard(idx, CONTEXT_LIMITS.PREORDER_IMAGE_MAX, "Pre-order image index exceeds max allowed");
+        if (err)
+            return err;
+    }
+    if (ctx.type === "event-cover") {
+        const idx = ctx.index ?? 1;
+        const err = indexGuard(idx, CONTEXT_LIMITS.EVENT_COVER_MAX, "Only one event cover image is allowed");
+        if (err)
+            return err;
+    }
+    if (ctx.type === "event-image") {
+        const idx = ctx.index ?? 1;
+        const err = indexGuard(idx, CONTEXT_LIMITS.EVENT_IMAGE_MAX, "Event image index exceeds max allowed");
+        if (err)
+            return err;
+    }
+    if (ctx.type === "event-winner-image") {
+        const idx = ctx.index ?? 1;
+        const err = indexGuard(idx, CONTEXT_LIMITS.EVENT_WINNER_IMAGE_MAX, "Event winner image index exceeds max allowed");
+        if (err)
+            return err;
+    }
+    if (ctx.type === "event-additional-image") {
+        const idx = ctx.index ?? 1;
+        const err = indexGuard(idx, CONTEXT_LIMITS.EVENT_ADDITIONAL_IMAGE_MAX, "Event additional image index exceeds max allowed");
+        if (err)
+            return err;
+    }
+    if (ctx.type === "blog-cover") {
+        const idx = ctx.index ?? 1;
+        const err = indexGuard(idx, CONTEXT_LIMITS.BLOG_COVER_MAX, "Only one blog cover image is allowed");
+        if (err)
+            return err;
+    }
+    if (ctx.type === "blog-content-image") {
+        const idx = ctx.index ?? 1;
+        const err = indexGuard(idx, CONTEXT_LIMITS.BLOG_CONTENT_IMAGE_MAX, "Blog content image index exceeds max allowed");
+        if (err)
+            return err;
+    }
+    if (ctx.type === "blog-additional-image") {
+        const idx = ctx.index ?? 1;
+        const err = indexGuard(idx, CONTEXT_LIMITS.BLOG_ADDITIONAL_IMAGE_MAX, "Blog additional image index exceeds max allowed");
+        if (err)
+            return err;
+    }
+    if (ctx.type === "rich-text-image") {
+        if (isVideo) {
+            return {
+                ok: false,
+                status: 400,
+                error: "rich-text-image context requires an image file",
+            };
+        }
+        const idx = ctx.index ?? 1;
+        const err = indexGuard(idx, CONTEXT_LIMITS.RICH_TEXT_IMAGE_MAX, "Rich text image index exceeds max allowed");
+        if (err)
+            return err;
+    }
+    if (IMAGE_ONLY_CONTEXT_TYPES.has(ctx.type) && isVideo) {
+        return {
+            ok: false,
+            status: 400,
+            error: `${ctx.type} must be an image file, not a video`,
+        };
+    }
+    const isPdfOnlyContext = (c) => PDF_ONLY_CONTEXTS.includes(c.type);
+    const ext = MIME_TO_EXT[detectedMime] ?? "bin";
+    if (isPdfOnlyContext(ctx)) {
+        if (!isPdf) {
+            return {
+                ok: false,
+                status: 400,
+                error: `${ctx.type} context requires a PDF file`,
+                details: { context: ctx.type, detected: detectedMime },
+            };
+        }
+        return { ok: true, filename: generateMediaFilename(ctx), ext };
+    }
+    if (isPdf) {
+        return {
+            ok: false,
+            status: 400,
+            error: "PDF uploads are only allowed for invoice or payout-doc contexts",
+            details: { context: ctx.type, detected: detectedMime },
+        };
+    }
+    return {
+        ok: true,
+        filename: generateMediaFilename({ ...ctx, ext }),
+        ext,
+    };
+}

package/dist/_internal/server/features/orders/adapters.js

@@ -7,6 +7,18 @@ export function orderDocumentToOrder(doc) {
             quantity: item.quantity,
             currency: doc.currency,
             storeId: doc.storeId,
+            // SB8-F — surface prize-draw reveal-state to the API response so
+            // user-orders pages can render the "X reveals pending" badge.
+            ...(item.listingType ? { listingType: item.listingType } : {}),
+            ...(item.prizeRevealStatus
+                ? { prizeRevealStatus: item.prizeRevealStatus }
+                : {}),
+            ...(item.prizeRevealDeadline
+                ? { prizeRevealDeadline: item.prizeRevealDeadline }
+                : {}),
+            ...(item.revealedItemNumber != null
+                ? { revealedItemNumber: item.revealedItemNumber }
+                : {}),
         }))
         : [
             {

package/dist/_internal/server/features/products/data.d.ts

@@ -8,7 +8,7 @@ export interface SitemapProduct {
     slugOrId: string;
     updatedAt: Date;
     /** Canonical listing-kind discriminator (SB1-G — Phase 4 dropped booleans). */
-    listingType: "standard" | "auction" | "pre-order" | "prize-draw" | "bundle";
+    listingType: "standard" | "auction" | "pre-order" | "prize-draw";
 }
 /** List all published products for sitemap generation. */
 export declare function listSitemapProducts(): Promise<SitemapProduct[]>;

package/dist/_internal/server/features/sublisting-categories/data.d.ts

@@ -1 +1 @@
-export declare const getSublistingCategoryForDetail: (slug: string) => Promise<import("../../../..").SublistingCategoryDocument | null>;
+export declare const getSublistingCategoryForDetail: (slug: string) => Promise<import("../../../..").CategoryDocument | null>;

package/dist/_internal/server/features/sublisting-categories/data.js

@@ -1,5 +1,5 @@
 import { cache } from "react";
-import { sublistingCategoriesRepository } from "../../../../repositories";
+import { categoriesRepository } from "../../../../repositories";
 export const getSublistingCategoryForDetail = cache(async (slug) => {
-    return sublistingCategoriesRepository.findBySlug(slug).catch(() => null);
+    return categoriesRepository.findBySlugAndType(slug, "sublisting").catch(() => null);
 });

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

@@ -0,0 +1,24 @@
+/**
+ * assignSpinPrize — HTTP callable (SB9-E).
+ *
+ * Weighted random selection from an event's `spinPrizes` config using
+ * `crypto.randomInt`. Enforces one spin per user (checks `spinUsed=true` on
+ * the user's event entry). Sets `spinPrizeId` + `spinWonAt` on the entry doc.
+ * Issues a coupon code if the prize has `spinPrizeCouponId` set.
+ */
+import type { CallableHandler } from "../runtime/types";
+interface AssignSpinPrizeInput {
+    eventId: string;
+    userId: string;
+}
+interface AssignSpinPrizeResult {
+    eventId: string;
+    userId: string;
+    spinPrizeId?: string;
+    spinPrizeTitle?: string;
+    spinPrizeCouponCode?: string;
+    alreadyUsed?: boolean;
+    reason?: string;
+}
+export declare const assignSpinPrizeHandler: CallableHandler<AssignSpinPrizeInput, AssignSpinPrizeResult>;
+export {};

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

@@ -0,0 +1,86 @@
+/**
+ * assignSpinPrize — HTTP callable (SB9-E).
+ *
+ * Weighted random selection from an event's `spinPrizes` config using
+ * `crypto.randomInt`. Enforces one spin per user (checks `spinUsed=true` on
+ * the user's event entry). Sets `spinPrizeId` + `spinWonAt` on the entry doc.
+ * Issues a coupon code if the prize has `spinPrizeCouponId` set.
+ */
+import crypto from "node:crypto";
+const EVENTS_COLLECTION = "events";
+const EVENT_ENTRIES_COLLECTION = "eventEntries";
+const COUPONS_COLLECTION = "coupons";
+export const assignSpinPrizeHandler = async (input, ctx) => {
+    const { eventId, userId } = input;
+    const eventSnap = await ctx.db.collection(EVENTS_COLLECTION).doc(eventId).get();
+    if (!eventSnap.exists) {
+        return { eventId, userId, reason: "event_not_found" };
+    }
+    const event = eventSnap.data();
+    const prizes = Array.isArray(event.spinPrizes) ? event.spinPrizes : [];
+    const totalWeight = prizes.reduce((s, p) => s + (p.weight ?? 0), 0);
+    if (totalWeight <= 0) {
+        return { eventId, userId, reason: "no_prizes_configured" };
+    }
+    const entriesSnap = await ctx.db
+        .collection(EVENT_ENTRIES_COLLECTION)
+        .where("eventId", "==", eventId)
+        .where("userId", "==", userId)
+        .limit(1)
+        .get();
+    if (entriesSnap.empty) {
+        return { eventId, userId, reason: "entry_not_found" };
+    }
+    const entryDoc = entriesSnap.docs[0];
+    const entry = entryDoc.data();
+    if (entry.spinUsed) {
+        return {
+            eventId,
+            userId,
+            spinPrizeId: entry.spinPrizeId,
+            alreadyUsed: true,
+        };
+    }
+    // Weighted pick: roll a uniform integer in [0, totalWeight) and walk.
+    const roll = crypto.randomInt(0, totalWeight);
+    let cumulative = 0;
+    let pick;
+    for (const p of prizes) {
+        cumulative += p.weight ?? 0;
+        if (roll < cumulative) {
+            pick = p;
+            break;
+        }
+    }
+    if (!pick)
+        pick = prizes[prizes.length - 1];
+    let spinPrizeCouponCode;
+    if (pick.couponId) {
+        const coupSnap = await ctx.db
+            .collection(COUPONS_COLLECTION)
+            .doc(pick.couponId)
+            .get();
+        if (coupSnap.exists) {
+            spinPrizeCouponCode = coupSnap.data().code;
+        }
+    }
+    await entryDoc.ref.update({
+        spinUsed: true,
+        spinPrizeId: pick.id,
+        spinWonAt: ctx.now,
+        spinPrizeCouponCode: spinPrizeCouponCode ?? null,
+        updatedAt: ctx.now,
+    });
+    ctx.logger.info("Spin prize assigned", {
+        eventId,
+        userId,
+        spinPrizeId: pick.id,
+    });
+    return {
+        eventId,
+        userId,
+        spinPrizeId: pick.id,
+        spinPrizeTitle: pick.title,
+        spinPrizeCouponCode,
+    };
+};

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

@@ -0,0 +1,18 @@
+/**
+ * scheduledBundleStockSync — daily 10am IST safety net.
+ *
+ * SB-UNI-V: bundles live on the `categories` collection with
+ * categoryType:"bundle". Each bundle row owns `bundleProductIds[]` +
+ * `bundleStockStatus`. This sweep recomputes `bundleStockStatus` for
+ * every active bundle by inspecting its members' product status.
+ *
+ * Status transitions:
+ *   all members published + available   → "in_stock"
+ *   ≥1 member unavailable, ≥minActive   → "partial"
+ *   ≥1 member unavailable, <minActive   → "out_of_stock"
+ *
+ * The realtime onProductStockChange Firestore-trigger handles individual
+ * writes; this is the cheap nightly safety net for any missed events.
+ */
+import type { ScheduleHandler } from "../runtime/types";
+export declare const bundleStockSyncHandler: ScheduleHandler;

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

@@ -0,0 +1,80 @@
+/**
+ * scheduledBundleStockSync — daily 10am IST safety net.
+ *
+ * SB-UNI-V: bundles live on the `categories` collection with
+ * categoryType:"bundle". Each bundle row owns `bundleProductIds[]` +
+ * `bundleStockStatus`. This sweep recomputes `bundleStockStatus` for
+ * every active bundle by inspecting its members' product status.
+ *
+ * Status transitions:
+ *   all members published + available   → "in_stock"
+ *   ≥1 member unavailable, ≥minActive   → "partial"
+ *   ≥1 member unavailable, <minActive   → "out_of_stock"
+ *
+ * The realtime onProductStockChange Firestore-trigger handles individual
+ * writes; this is the cheap nightly safety net for any missed events.
+ */
+const CATEGORIES_COLLECTION = "categories";
+const PRODUCT_COLLECTION = "products";
+const UNAVAILABLE = new Set(["sold", "out_of_stock", "discontinued"]);
+const MIN_ACTIVE_DEFAULT = 1;
+async function computeBundleStockStatus(productIds, minActive, ctx) {
+    if (productIds.length === 0)
+        return "out_of_stock";
+    let unavailable = 0;
+    for (let i = 0; i < productIds.length; i += 30) {
+        const chunk = productIds.slice(i, i + 30);
+        const snap = await ctx.db
+            .collection(PRODUCT_COLLECTION)
+            .where("__name__", "in", chunk)
+            .get();
+        for (const doc of snap.docs) {
+            const status = doc.data().status;
+            if (!status || UNAVAILABLE.has(status))
+                unavailable++;
+        }
+        // Account for missing docs (deleted products).
+        if (snap.size < chunk.length)
+            unavailable += chunk.length - snap.size;
+    }
+    const active = productIds.length - unavailable;
+    if (unavailable === 0)
+        return "in_stock";
+    if (active < minActive)
+        return "out_of_stock";
+    return "partial";
+}
+export const bundleStockSyncHandler = async (ctx) => {
+    ctx.logger.info("Bundle stock sync starting (SB-UNI-V categories)");
+    const snap = await ctx.db
+        .collection(CATEGORIES_COLLECTION)
+        .where("categoryType", "==", "bundle")
+        .where("isActive", "==", true)
+        .limit(500)
+        .get();
+    if (snap.empty) {
+        ctx.logger.info("No active bundle categories to scan");
+        return;
+    }
+    let updated = 0;
+    for (const bundleDoc of snap.docs) {
+        const data = bundleDoc.data();
+        const productIds = data.bundleProductIds ?? [];
+        if (productIds.length === 0)
+            continue;
+        const minActive = data.minActiveMembers ?? MIN_ACTIVE_DEFAULT;
+        const nextStatus = await computeBundleStockStatus(productIds, minActive, ctx);
+        if (nextStatus !== data.bundleStockStatus) {
+            await bundleDoc.ref.update({
+                bundleStockStatus: nextStatus,
+                bundleQueryResolvedAt: ctx.now,
+                updatedAt: ctx.now,
+            });
+            updated++;
+        }
+    }
+    ctx.logger.info("Bundle stock sync complete", {
+        scanned: snap.size,
+        updated,
+    });
+};

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

@@ -33,3 +33,11 @@ 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 { onProductStockChangeHandler } from "./onProductStockChange";
+export { triggerEventRaffleHandler } from "./triggerEventRaffle";
+export { assignSpinPrizeHandler } from "./assignSpinPrize";