@mohasinac/appkit 4.9.5 → 4.11.0

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

@@ -7,6 +7,7 @@ import { serverLogger } from "../../../../monitoring/server-logger";
 import { PRODUCT_COLLECTION } from "../../../../features/products/schemas/firestore";
 import { PRODUCTS_SITEMAP_LIMIT } from "../../../shared/features/products/config";
 import { PRODUCT_FIELDS } from "../../../../constants/field-names";
+import { SIEVE_OP, sieveAnd, sieveFilter, sortBy } from "../../../../utils/sieve-builder";
 // ---------------------------------------------------------------------------
 // Request-scoped cache — each function is deduplicated per RSC render tree.
 // Both generateMetadata() and the page component get the same promise.
@@ -23,6 +24,38 @@ export const getProductForDetail = cache(async (slugOrId) => {
 export const getReviewsForProduct = cache(async (productId) => {
     return reviewRepository.findApprovedByProduct(productId).catch(() => []);
 });
+/** Firestore review doc → client Review shape. Shared by every listing-type detail page's reviews tab. */
+export function toReview(doc) {
+    const images = Array.isArray(doc.images) ? doc.images : undefined;
+    const createdAt = doc.createdAt instanceof Date
+        ? doc.createdAt.toISOString()
+        : typeof doc.createdAt === "string"
+            ? doc.createdAt
+            : undefined;
+    const rawRating = typeof doc.rating === "number" ? doc.rating : 3;
+    const rating = Math.min(5, Math.max(1, Math.round(rawRating)));
+    return {
+        id: String(doc.id ?? ""),
+        productId: String(doc.productId ?? ""),
+        userId: String(doc.userId ?? ""),
+        userName: String(doc.userName ?? "Anonymous"),
+        userAvatar: typeof doc.userAvatar === "string" ? doc.userAvatar : undefined,
+        rating,
+        title: typeof doc.title === "string" ? doc.title : undefined,
+        comment: typeof doc.comment === "string" ? doc.comment : undefined,
+        images,
+        status: doc.status ?? "approved",
+        helpfulCount: typeof doc.helpfulCount === "number" ? doc.helpfulCount : undefined,
+        verified: doc.verified === true,
+        featured: doc.featured === true,
+        createdAt,
+    };
+}
+/** Fetch + map approved reviews for a product straight to the client Review shape, deduped per request. */
+export const getReviewItemsForProduct = cache(async (productId) => {
+    const docs = await reviewRepository.findApprovedByProduct(productId).catch(() => []);
+    return docs.map(toReview);
+});
 /** List all published products for sitemap generation. */
 export async function listSitemapProducts() {
     try {
@@ -54,3 +87,129 @@ export async function listSitemapProducts() {
         return [];
     }
 }
+// ---------------------------------------------------------------------------
+// Related items — same 4-signal computation shared by every listing-type
+// detail page (category / brand / tag-overlap / same-store).
+// ---------------------------------------------------------------------------
+const RELATED_QUERY_PAGE_SIZE = 9;
+const RELATED_DISPLAY_LIMIT = 8;
+/** Firestore doc → card-grid shape. Shared by every related/similar-items carousel. */
+export function toProductItem(doc) {
+    return {
+        id: String(doc.id ?? ""),
+        title: String(doc.title ?? doc.name ?? ""),
+        price: typeof doc.price === "number" ? doc.price : 0,
+        originalPrice: typeof doc.originalPrice === "number" ? doc.originalPrice : undefined,
+        mainImage: Array.isArray(doc.images)
+            ? doc.images[0]
+            : typeof doc.mainImage === "string"
+                ? doc.mainImage
+                : undefined,
+        status: doc.status ?? "published",
+        slug: typeof doc.slug === "string" ? doc.slug : undefined,
+        storeName: typeof doc.storeName === "string" ? doc.storeName : undefined,
+        rating: typeof doc.rating === "number" ? doc.rating : undefined,
+        reviewCount: typeof doc.reviewCount === "number" ? doc.reviewCount : undefined,
+        // Without this, every related-item card silently linked to the standard
+        // PDP regardless of its real type (pluginFor() defaults to "standard"
+        // when listingType is missing) — same bug class as the Phase 1 routing
+        // fix, one hop further downstream in the related-items card link path.
+        listingType: doc.listingType ?? undefined,
+    };
+}
+/**
+ * Excludes the current product plus any listing-type-specific "invalid to
+ * surface as related" state: sold/archived/out-of-stock/draft, ended
+ * auctions, closed prize-draws, sold-out pre-orders, depleted digital-code
+ * pools.
+ */
+function isValidRelatedItem(r, currentProductId, now) {
+    if (r.id === currentProductId)
+        return false;
+    const s = r.status;
+    if (s && ["sold", "out_of_stock", "archived", "discontinued", "draft"].includes(s))
+        return false;
+    if (r.isSold === true)
+        return false;
+    if (r.availableQuantity === 0)
+        return false;
+    if (r.listingType === "auction" && r.auctionEndDate) {
+        const end = r.auctionEndDate;
+        const endDate = typeof end.toDate === "function"
+            ? end.toDate()
+            : end instanceof Date
+                ? end
+                : new Date(String(end));
+        if (endDate <= now)
+            return false;
+    }
+    if (r.listingType === "prize-draw" && r.prizeRevealStatus === "closed")
+        return false;
+    if (r.listingType === "pre-order" &&
+        typeof r.preOrderMaxQuantity === "number" &&
+        typeof r.preOrderCurrentCount === "number" &&
+        r.preOrderCurrentCount >= r.preOrderMaxQuantity) {
+        return false;
+    }
+    if (r.listingType === "digital-code" && r.codesAvailable === 0)
+        return false;
+    return true;
+}
+function toRelatedItems(docs, currentProductId) {
+    const now = new Date();
+    return docs
+        .filter((r) => isValidRelatedItem(r, currentProductId, now))
+        .slice(0, RELATED_DISPLAY_LIMIT)
+        .map(toProductItem);
+}
+/**
+ * Same 4-signal related-items computation used across every listing-type
+ * detail page (category / brand / tag-overlap / same-store), each excluding
+ * invalid states for that item's own listing type. Extracted from
+ * ProductDetailPageView so pre-order/prize-draw/classified/digital-code/live
+ * pages can reuse it instead of having no related section at all.
+ */
+export const computeRelatedItems = cache(async (product) => {
+    const p = product;
+    const primaryCategorySlug = Array.isArray(p.categorySlugs) ? p.categorySlugs[0] : undefined;
+    const brand = typeof p.brand === "string" ? p.brand : undefined;
+    const tags = Array.isArray(p.tags) ? p.tags : [];
+    const storeId = typeof p.storeId === "string" ? p.storeId : undefined;
+    const currentProductId = product.id;
+    const [sameCategoryDocs, sameBrandDocs, tagOverlapDocs, sameStoreDocs] = await Promise.all([
+        primaryCategorySlug
+            ? productRepository.findByCategory(primaryCategorySlug).catch(() => [])
+            : Promise.resolve([]),
+        brand
+            ? productRepository
+                .list({
+                filters: sieveAnd(sieveFilter("status", SIEVE_OP.EQ, "published"), sieveFilter("brand", SIEVE_OP.EQ, brand)),
+                sorts: sortBy("createdAt", "DESC"),
+                page: 1,
+                pageSize: RELATED_QUERY_PAGE_SIZE,
+            })
+                .then((r) => r.items)
+                .catch(() => [])
+            : Promise.resolve([]),
+        tags.length > 0
+            ? productRepository.findByTagsOverlap(tags, RELATED_QUERY_PAGE_SIZE).catch(() => [])
+            : Promise.resolve([]),
+        storeId
+            ? productRepository
+                .list({
+                filters: sieveAnd(sieveFilter("status", SIEVE_OP.EQ, "published"), sieveFilter("storeId", SIEVE_OP.EQ, storeId)),
+                sorts: sortBy("createdAt", "DESC"),
+                page: 1,
+                pageSize: RELATED_QUERY_PAGE_SIZE,
+            })
+                .then((r) => r.items)
+                .catch(() => [])
+            : Promise.resolve([]),
+    ]);
+    return {
+        relatedItems: toRelatedItems(sameCategoryDocs, currentProductId),
+        relatedByBrand: toRelatedItems(sameBrandDocs, currentProductId),
+        relatedByTags: toRelatedItems(tagOverlapDocs, currentProductId),
+        relatedByStore: toRelatedItems(sameStoreDocs, currentProductId),
+    };
+});

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

@@ -1,4 +1,4 @@
-export { getProductForDetail, getReviewsForProduct, listSitemapProducts, type SitemapProduct, } from "./data";
+export { getProductForDetail, getReviewsForProduct, listSitemapProducts, type SitemapProduct, computeRelatedItems, toProductItem, toReview, getReviewItemsForProduct, type RelatedItemsResult, } from "./data";
 export { assertProductOwnership, assertStatusTransition, assertInStock, effectivePrice, isAvailableForPurchase, } from "./service";
 export { createProductAction, createAuctionAction, createPreOrderAction, updateProductAction, deleteProductAction, setProductStatusAction, setProductFeaturedAction, } from "./actions";
 export { PRODUCTS_PAGE_SIZE, PRODUCTS_FEATURED_LIMIT, PRODUCTS_RELATED_LIMIT, PRODUCTS_SITEMAP_LIMIT } from "../../../shared/features/products/config";

package/dist/_internal/server/features/products/index.js

@@ -1,4 +1,4 @@
-export { getProductForDetail, getReviewsForProduct, listSitemapProducts, } from "./data";
+export { getProductForDetail, getReviewsForProduct, listSitemapProducts, computeRelatedItems, toProductItem, toReview, getReviewItemsForProduct, } from "./data";
 export { assertProductOwnership, assertStatusTransition, assertInStock, effectivePrice, isAvailableForPurchase, } from "./service";
 export { createProductAction, createAuctionAction, createPreOrderAction, updateProductAction, deleteProductAction, setProductStatusAction, setProductFeaturedAction, } from "./actions";
 export { PRODUCTS_PAGE_SIZE, PRODUCTS_FEATURED_LIMIT, PRODUCTS_RELATED_LIMIT, PRODUCTS_SITEMAP_LIMIT } from "../../../shared/features/products/config";

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

@@ -7,6 +7,7 @@ export declare const couponExpiry: import("./types").ScheduledFunctionDefinition
 export declare const offerExpiry: import("./types").ScheduledFunctionDefinition;
 export declare const productStatsSync: import("./types").ScheduledFunctionDefinition;
 export declare const revenueRollup: import("./types").ScheduledFunctionDefinition;
+export declare const dailyStatusDigest: import("./types").ScheduledFunctionDefinition;
 export declare const dailyDataCleanup: import("./types").ScheduledFunctionDefinition;
 export declare const countersReconcile: import("./types").ScheduledFunctionDefinition;
 export declare const positionsReconcile: import("./types").ScheduledFunctionDefinition;
@@ -19,8 +20,9 @@ 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 testerSandboxRefresh: 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];
+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];

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, prizeDrawExpiryRevealHandler, 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, dailyStatusDigestHandler, weeklyPayoutEligibilityHandler, testerSandboxCleanupHandler, testerSandboxRefreshHandler, } from "../jobs/handlers";
 import { defineFunction } from "./define";
 const REGION = "asia-south1";
 const EVERY_5_MIN = "every 5 minutes";
@@ -67,6 +67,13 @@ export const revenueRollup = defineFunction({
     handler: revenueRollupHandler,
     options: { region: REGION, timeoutSeconds: 300, memory: "256MiB", maxInstances: 1 },
 });
+export const dailyStatusDigest = defineFunction({
+    name: "dailyStatusDigest",
+    description: "Email the previous 24h order summary + platform status to the team every morning at 10:00 IST.",
+    trigger: { kind: "schedule", cron: "0 10 * * *", timeZone: "Asia/Kolkata" },
+    handler: dailyStatusDigestHandler,
+    options: { region: REGION, timeoutSeconds: 120, memory: "256MiB", maxInstances: 1 },
+});
 export const dailyDataCleanup = defineFunction({
     name: "dailyDataCleanup",
     description: "Daily data cleanup (drafts, transient records) at 02:00 UTC.",
@@ -151,6 +158,13 @@ export const testerSandboxCleanup = defineFunction({
     handler: testerSandboxCleanupHandler,
     options: { region: REGION, timeoutSeconds: 300, memory: "256MiB", maxInstances: 1 },
 });
+export const testerSandboxRefresh = defineFunction({
+    name: "testerSandboxRefresh",
+    description: "Revert live tester QA sandbox fixtures to their canonical seed shape and prune tester-created extras (every 4 hours).",
+    trigger: { kind: "schedule", cron: "0 */4 * * *", timeZone: "UTC" },
+    handler: testerSandboxRefreshHandler,
+    options: { region: REGION, timeoutSeconds: 300, memory: "256MiB", maxInstances: 1 },
+});
 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).",
@@ -189,6 +203,7 @@ export const SCHEDULED_FUNCTIONS = [
     offerExpiry,
     productStatsSync,
     revenueRollup,
+    dailyStatusDigest,
     dailyDataCleanup,
     countersReconcile,
     positionsReconcile,
@@ -201,6 +216,7 @@ export const SCHEDULED_FUNCTIONS = [
     mediaTmpCleanup,
     draftPrune,
     testerSandboxCleanup,
+    testerSandboxRefresh,
     prizeDrawExpiryReveal,
     bundleStockSync,
     emiInstallmentReminder,

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

@@ -0,0 +1,40 @@
+/**
+ * Core: daily status digest email.
+ *
+ * Emails the previous 24h of order activity to the team every morning. The
+ * digest's arrival is itself the platform health signal — if it stops
+ * landing, something in the Firestore → Functions → Resend chain needs a
+ * look. Deliberately no separate error/exception tracking: there is no
+ * structured error-log collection to query, and building one just to fill
+ * this email would be scope no one asked for.
+ *
+ * Runs from a scheduled Firebase Function (not a Vercel route), so the
+ * unbounded-ish order scan below is safe against CLAUDE.md Rule #6's 10s
+ * sync ceiling — it has the Function's much larger budget.
+ */
+import type { JobContext } from "../runtime/types";
+export interface DailyStatusDigestSummary {
+    orderCount: number;
+    revenue: number;
+    statusBreakdown: Record<string, number>;
+    stuckPendingCount: number;
+    activeListingCount: number;
+}
+/** Gathers the last-24h numbers. Exported so the admin manual-trigger route can reuse it. */
+export declare function collectDailyStatusSummary(): Promise<DailyStatusDigestSummary>;
+export interface DailyStatusDigestResult {
+    sent: boolean;
+    reason?: string;
+    summary?: DailyStatusDigestSummary;
+}
+/**
+ * Sends the digest once per deployment version.
+ *
+ * Called from server startup. On Vercel that means EVERY lambda cold start,
+ * not once per deploy — so the version marker below is what makes this a
+ * per-deployment event rather than a per-cold-start email storm. The claim
+ * runs in a transaction because several cold starts can race on the first
+ * request after a deploy; exactly one wins and sends.
+ */
+export declare function runDeploymentDigest(ctx: JobContext, version: string): Promise<DailyStatusDigestResult>;
+export declare function runDailyStatusDigest(ctx: JobContext, version?: string): Promise<DailyStatusDigestResult>;

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

@@ -0,0 +1,164 @@
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * Core: daily status digest email.
+ *
+ * Emails the previous 24h of order activity to the team every morning. The
+ * digest's arrival is itself the platform health signal — if it stops
+ * landing, something in the Firestore → Functions → Resend chain needs a
+ * look. Deliberately no separate error/exception tracking: there is no
+ * structured error-log collection to query, and building one just to fill
+ * this email would be scope no one asked for.
+ *
+ * Runs from a scheduled Firebase Function (not a Vercel route), so the
+ * unbounded-ish order scan below is safe against CLAUDE.md Rule #6's 10s
+ * sync ceiling — it has the Function's much larger budget.
+ */
+import { renderToStaticMarkup } from "react-dom/server";
+import { getAdminDb } from "../../../../providers/db-firebase";
+import { sendEmail } from "../../../../features/contact/email";
+import { siteSettingsRepository } from "../../../../features/admin/repository/site-settings.repository";
+import { ORDER_COLLECTION, OrderStatusValues } from "../../../../features/orders/schemas/firestore";
+import { PRODUCT_COLLECTION, ProductStatusValues } from "../../../../features/products/schemas/firestore";
+import { ORDER_FIELDS, PRODUCT_FIELDS } from "../../../../constants/field-names";
+import { EmailBold, EmailContainer, EmailDivider, EmailDoc, EmailFooter, EmailHeader, EmailRow, } from "../../../../features/email/primitives";
+import { normalizeError } from "../../../../errors/normalize";
+const DAY_MS = 24 * 60 * 60 * 1000;
+/** Statuses that shouldn't count toward revenue for the day. */
+const NON_REVENUE_STATUSES = new Set([
+    OrderStatusValues.CANCELLED,
+    OrderStatusValues.REFUNDED,
+]);
+function currency(amount) {
+    return `₹${amount.toLocaleString("en-IN", { maximumFractionDigits: 2 })}`;
+}
+/** One "Label: value" line. Uses only email primitives — email clients need
+ *  inline-styled, table-based markup, which the Email* components provide. */
+function StatLine({ label, value }) {
+    return (_jsxs(_Fragment, { children: [label, ": ", _jsx(EmailBold, { children: String(value) }), _jsx("br", {})] }));
+}
+/** Gathers the last-24h numbers. Exported so the admin manual-trigger route can reuse it. */
+export async function collectDailyStatusSummary() {
+    const db = getAdminDb();
+    const since = new Date(Date.now() - DAY_MS);
+    const recentSnap = await db
+        .collection(ORDER_COLLECTION)
+        .where(ORDER_FIELDS.CREATED_AT, ">=", since)
+        .get();
+    let revenue = 0;
+    const statusBreakdown = {};
+    for (const doc of recentSnap.docs) {
+        const data = doc.data();
+        const status = data.status ?? "unknown";
+        statusBreakdown[status] = (statusBreakdown[status] ?? 0) + 1;
+        if (!NON_REVENUE_STATUSES.has(status)) {
+            revenue += Number(data.totalPrice ?? 0) || 0;
+        }
+    }
+    // Orders still sitting in PENDING beyond the 24h window — the one number
+    // here that signals something needs attention rather than just reporting
+    // volume.
+    const stuckSnap = await db
+        .collection(ORDER_COLLECTION)
+        .where(ORDER_FIELDS.STATUS, "==", OrderStatusValues.PENDING)
+        .where(ORDER_FIELDS.CREATED_AT, "<", since)
+        .count()
+        .get();
+    const activeSnap = await db
+        .collection(PRODUCT_COLLECTION)
+        .where(PRODUCT_FIELDS.STATUS, "==", ProductStatusValues.PUBLISHED)
+        .count()
+        .get();
+    return {
+        orderCount: recentSnap.size,
+        revenue,
+        statusBreakdown,
+        stuckPendingCount: stuckSnap.data().count,
+        activeListingCount: activeSnap.data().count,
+    };
+}
+function renderDigestHtml(summary, siteName, version) {
+    const statusRows = Object.entries(summary.statusBreakdown).sort(([a], [b]) => a.localeCompare(b));
+    const title = siteName ? `${siteName} — Daily Status` : "Daily Status";
+    return `<!DOCTYPE html>${renderToStaticMarkup(_jsx(EmailDoc, { title: title, children: _jsxs(EmailContainer, { children: [_jsx(EmailHeader, { brandName: siteName }), _jsxs(EmailRow, { children: [version
+                            ? `Deployment ${version} is live. Activity for the last 24 hours.`
+                            : "Activity for the last 24 hours.", _jsx("br", {}), _jsx("br", {}), _jsx(StatLine, { label: "Orders placed", value: summary.orderCount }), _jsx(StatLine, { label: "Revenue (excl. cancelled/refunded)", value: currency(summary.revenue) }), _jsx(StatLine, { label: "Active listings", value: summary.activeListingCount }), _jsx(StatLine, { label: "Pending > 24h (needs attention)", value: summary.stuckPendingCount })] }), _jsx(EmailDivider, {}), _jsxs(EmailRow, { children: [_jsx(EmailBold, { children: "Orders by status" }), _jsx("br", {}), _jsx("br", {}), statusRows.length === 0 ? ("No orders in this window.") : (statusRows.map(([status, count]) => (_jsx(StatLine, { label: status, value: count }, status))))] }), _jsx(EmailFooter, { copyright: `© ${new Date().getFullYear()}${siteName ? ` ${siteName}` : ""}. All rights reserved.` })] }) }))}`;
+}
+const DEPLOY_MARKER_COLLECTION = "system";
+const DEPLOY_MARKER_DOC = "deployDigest";
+/**
+ * Sends the digest once per deployment version.
+ *
+ * Called from server startup. On Vercel that means EVERY lambda cold start,
+ * not once per deploy — so the version marker below is what makes this a
+ * per-deployment event rather than a per-cold-start email storm. The claim
+ * runs in a transaction because several cold starts can race on the first
+ * request after a deploy; exactly one wins and sends.
+ */
+export async function runDeploymentDigest(ctx, version) {
+    if (!version)
+        return { sent: false, reason: "no_version" };
+    const markerRef = getAdminDb().collection(DEPLOY_MARKER_COLLECTION).doc(DEPLOY_MARKER_DOC);
+    let claimed = false;
+    try {
+        await getAdminDb().runTransaction(async (tx) => {
+            const snap = await tx.get(markerRef);
+            const lastVersion = snap.data()?.lastVersion;
+            if (lastVersion === version)
+                return;
+            tx.set(markerRef, { lastVersion: version, sentAt: new Date() }, { merge: true });
+            claimed = true;
+        });
+    }
+    catch (err) {
+        void normalizeError(err);
+        ctx.logger.warn("deploymentDigest: could not claim version marker — skipping", { version });
+        return { sent: false, reason: "claim_failed" };
+    }
+    if (!claimed)
+        return { sent: false, reason: "already_sent_for_version" };
+    ctx.logger.info("deploymentDigest: claimed version, sending", { version });
+    return runDailyStatusDigest(ctx, version);
+}
+export async function runDailyStatusDigest(ctx, version) {
+    const settings = await siteSettingsRepository.getSingleton().catch((err) => {
+        void normalizeError(err);
+        return null;
+    });
+    const digestConfig = settings?.emailSettings?.dailyDigest;
+    if (digestConfig?.enabled !== true) {
+        ctx.logger.info("dailyStatusDigest: disabled in site settings — skipping");
+        return { sent: false, reason: "disabled" };
+    }
+    const recipients = (digestConfig.recipients ?? []).filter((r) => r.trim().length > 0);
+    if (recipients.length === 0) {
+        ctx.logger.warn("dailyStatusDigest: enabled but no recipients configured — skipping");
+        return { sent: false, reason: "no_recipients" };
+    }
+    const ccRecipients = (digestConfig.ccRecipients ?? []).filter((r) => r.trim().length > 0);
+    const summary = await collectDailyStatusSummary();
+    // No hardcoded brand fallback — appkit is consumer-agnostic; the site name
+    // comes from settings or the consumer's own env var.
+    const siteName = settings?.siteName?.trim() || process.env.NEXT_PUBLIC_SITE_NAME?.trim() || "";
+    const { error } = await sendEmail({
+        to: recipients,
+        // Spread rather than `cc: undefined` — SendEmailOptions has a
+        // Record<string, JsonValue> index signature that rejects undefined.
+        ...(ccRecipients.length > 0 ? { cc: ccRecipients } : {}),
+        subject: "Daily Status",
+        html: renderDigestHtml(summary, siteName, version),
+        text: (version ? `Deployment ${version} is live.\n\n` : "") +
+            `Orders placed: ${summary.orderCount}\n` +
+            `Revenue: ${currency(summary.revenue)}\n` +
+            `Active listings: ${summary.activeListingCount}\n` +
+            `Pending > 24h: ${summary.stuckPendingCount}`,
+    });
+    if (error) {
+        ctx.logger.error("dailyStatusDigest: send failed", { error: String(error) });
+        throw new Error(`Daily status digest send failed: ${String(error)}`);
+    }
+    ctx.logger.info("dailyStatusDigest: sent", {
+        recipients: recipients.length,
+        orderCount: summary.orderCount,
+    });
+    return { sent: true, summary };
+}

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

@@ -21,6 +21,8 @@ import { userRepository, sessionRepository, storeRepository, productRepository,
 import { sendNotification } from "../../../../features/admin/actions/notification-actions";
 import { isSellerUser } from "../../../../features/auth/role-predicates";
 import { getAdminAuth } from "../../../../providers/db-firebase";
+import { recordAdminAction } from "../../features/audit-log/actions";
+import { AdminAuditActionValues } from "../../../../features/audit-log/schemas/firestore";
 async function cascadeAddressClusterBan(uid, banData) {
     const userAddresses = await addressesRepository.listByOwner("user", uid);
     const uniqueHashes = [...new Set(userAddresses.map((a) => a.addressHash).filter(Boolean))];
@@ -84,6 +86,15 @@ export async function runHardBanCascade(input, ctx) {
         hardBanExpiresAt: expiresAt ?? null,
         ...(fraudOrderId ? { hardBanFraudOrderId: fraudOrderId } : {}),
     });
+    void recordAdminAction({
+        actorUid: bannedBy,
+        action: AdminAuditActionValues.USER_HARD_BAN,
+        targetType: "user",
+        targetId: uid,
+        targetLabel: target.displayName ?? uid,
+        reason,
+        metadata: { expiresAt: expiresAt?.toISOString() ?? null, fraudOrderId: fraudOrderId ?? null },
+    });
     // 3. Delete active sessions
     try {
         const sessions = await sessionRepository.findActiveByUser(uid);

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

@@ -1,4 +1,5 @@
 import type { JobContext } from "../runtime/types";
+export declare const SANDBOX_COLLECTIONS: readonly ["categories", "stores", "products", "blogPosts", "events"];
 export interface TesterSandboxCleanupOptions {
     /** true = wipe every isTestData:true doc regardless of testDataExpiresAt (manual force-purge). */
     force?: boolean;

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

@@ -1,6 +1,9 @@
 import { batchDelete, getTestDataRefs } from "../handlers/_helpers";
 import { BID_FIELDS } from "../../../../constants/field-names";
-const SANDBOX_COLLECTIONS = ["categories", "stores", "products", "blogPosts", "events"];
+// Exported so testerSandboxRefresh.ts (the every-4h revert+prune job) reuses
+// the exact same collection scope instead of redefining it — one source of
+// truth for "what counts as sandbox scope."
+export const SANDBOX_COLLECTIONS = ["categories", "stores", "products", "blogPosts", "events"];
 const BID_CHUNK_SIZE = 30; // Firestore `in` query cap
 export async function runTesterSandboxCleanup(ctx, opts = {}) {
     const cutoff = opts.force ? null : new Date();

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

@@ -0,0 +1,12 @@
+import type { JobContext } from "../runtime/types";
+/**
+ * Reverts every live tester-sandbox fixture back to its canonical seeded
+ * shape (undoing edits made through admin/seller forms) and prunes any
+ * isTestData doc that isn't one of the known fixtures (something a tester
+ * created during QA, e.g. a cloned product). Runs every 4 hours — distinct
+ * from `runTesterSandboxCleanup`, which only deletes docs whose 7-day
+ * `testDataExpiresAt` TTL has actually lapsed and never touches still-live
+ * docs' fields. Scoped to the tester sandbox only (`isTestData: true`) —
+ * the permanent Beyblade catalog real visitors browse is never touched.
+ */
+export declare function runTesterSandboxRefresh(ctx: JobContext): Promise<void>;

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

@@ -0,0 +1,85 @@
+import { batchDelete, getTestDataRefs } from "../handlers/_helpers";
+import { BID_FIELDS } from "../../../../constants/field-names";
+import { SANDBOX_COLLECTIONS } from "./testerSandboxCleanup";
+// Direct imports from each defining module (not the seed-data barrel) —
+// this is internal appkit code, not part of the package's public API surface.
+import { categoriesTesterSeedData } from "../../../../features/tester/seed-data/categories-tester-seed-data";
+import { storesTesterSeedData } from "../../../../features/tester/seed-data/stores-tester-seed-data";
+import { productsTesterSeedData } from "../../../../features/tester/seed-data/products-tester-seed-data";
+import { blogTesterSeedData } from "../../../../features/tester/seed-data/blog-tester-seed-data";
+import { eventsTesterSeedData } from "../../../../features/tester/seed-data/events-tester-seed-data";
+import { bidsTesterSeedData } from "../../../../features/tester/seed-data/bids-tester-seed-data";
+const SEED_BY_COLLECTION = {
+    categories: categoriesTesterSeedData,
+    stores: storesTesterSeedData,
+    products: productsTesterSeedData,
+    blogPosts: blogTesterSeedData,
+    events: eventsTesterSeedData,
+};
+const BID_CHUNK_SIZE = 30; // Firestore `in` query cap
+/**
+ * Reverts every live tester-sandbox fixture back to its canonical seeded
+ * shape (undoing edits made through admin/seller forms) and prunes any
+ * isTestData doc that isn't one of the known fixtures (something a tester
+ * created during QA, e.g. a cloned product). Runs every 4 hours — distinct
+ * from `runTesterSandboxCleanup`, which only deletes docs whose 7-day
+ * `testDataExpiresAt` TTL has actually lapsed and never touches still-live
+ * docs' fields. Scoped to the tester sandbox only (`isTestData: true`) —
+ * the permanent Beyblade catalog real visitors browse is never touched.
+ */
+export async function runTesterSandboxRefresh(ctx) {
+    let reverted = 0;
+    let deletedExtras = 0;
+    for (const collection of SANDBOX_COLLECTIONS) {
+        const seedDocs = SEED_BY_COLLECTION[collection] ?? [];
+        const validIds = new Set(seedDocs.map((d) => d.id).filter((id) => Boolean(id)));
+        if (seedDocs.length > 0) {
+            const batch = ctx.db.batch();
+            for (const doc of seedDocs) {
+                const { id, ...data } = doc;
+                if (!id)
+                    continue;
+                // merge:true mirrors seed-cli.mjs's loadGeneric — the seed payload
+                // carries every canonical field, so this fully overwrites anything
+                // a tester edited through the UI.
+                batch.set(ctx.db.collection(collection).doc(id), data, { merge: true });
+                reverted++;
+            }
+            await batch.commit();
+        }
+        const testDataRefs = await getTestDataRefs(ctx.db, collection, null);
+        const extraRefs = testDataRefs.filter((ref) => !validIds.has(ref.id));
+        deletedExtras += await batchDelete(ctx, extraRefs);
+    }
+    // Bids aren't isTestData-flagged themselves — scoped by productId
+    // referencing a sandbox product instead, mirroring runTesterSandboxCleanup's
+    // cascade convention.
+    const sandboxProductIds = (SEED_BY_COLLECTION.products ?? [])
+        .map((d) => d.id)
+        .filter((id) => Boolean(id));
+    const validBidIds = new Set(bidsTesterSeedData.map((d) => d.id).filter((id) => Boolean(id)));
+    if (bidsTesterSeedData.length > 0) {
+        const bidBatch = ctx.db.batch();
+        for (const bid of bidsTesterSeedData) {
+            const { id, ...data } = bid;
+            if (!id)
+                continue;
+            bidBatch.set(ctx.db.collection("bids").doc(id), data, { merge: true });
+            reverted++;
+        }
+        await bidBatch.commit();
+    }
+    const extraBidRefs = [];
+    for (let i = 0; i < sandboxProductIds.length; i += BID_CHUNK_SIZE) {
+        const chunk = sandboxProductIds.slice(i, i + BID_CHUNK_SIZE);
+        if (chunk.length === 0)
+            continue;
+        const snap = await ctx.db.collection("bids").where(BID_FIELDS.PRODUCT_ID, "in", chunk).get();
+        for (const doc of snap.docs) {
+            if (!validBidIds.has(doc.id))
+                extraBidRefs.push(doc.ref);
+        }
+    }
+    deletedExtras += await batchDelete(ctx, extraBidRefs);
+    ctx.logger.info("Tester sandbox refresh complete", { reverted, deletedExtras });
+}