@mohasinac/appkit 4.27.0 → 4.29.0

package/dist/_internal/client/features/lottery/LotteryAdminEditView.d.ts

@@ -1,4 +1,5 @@
 import React from "react";
+import type { LotteryConfigWriteInput } from "../../../../features/lottery/schemas/config-write";
 interface LotterySlotRow {
     slotNumber: number;
     name: string;
@@ -6,26 +7,25 @@ interface LotterySlotRow {
     /** Prize photo — rendered publicly in the prize collage on the detail page. */
     image?: string;
 }
+/**
+ * What this form hands its caller.
+ *
+ * `lotteryConfig` is the WRITE input — deliberately not `LotteryConfig`. It
+ * carries no `isBooked`, no `bookedBy*` and no `weight`, because an admin
+ * editing a lottery is describing prizes, not attendance. The stored config
+ * gains those in `mergeLotteryConfig`, server-side, from the slots that are
+ * already there.
+ *
+ * `totalSlots` is absent for the same reason: derived from `slots.length` by
+ * the merge, never sent. A caller-supplied count that disagrees with the array
+ * is the mirror-drift trap (Root Cause #42), and the count is what the
+ * fullness check reads.
+ */
 interface LotteryEventFormData {
     title: string;
     description?: string;
     type: "lottery";
-    lotteryConfig: {
-        slots: Array<{
-            slotNumber: number;
-            name: string;
-            image?: string;
-            price: number;
-            weight: number;
-            isBooked: boolean;
-        }>;
-        totalSlots: number;
-        pricingMode: "uniform" | "variable";
-        uniformPrice?: number;
-        drawWindowDurationMinutes: number;
-        maxPullsPerTransaction: number;
-        maxPullsPerUser: number;
-    };
+    lotteryConfig: LotteryConfigWriteInput;
 }
 interface LotteryAdminEditViewProps {
     eventId?: string;

package/dist/_internal/client/features/lottery/LotteryAdminEditView.js

@@ -5,6 +5,7 @@ import { normalizeError } from "../../../../errors/normalize";
 import { Stack, Row, Text, Heading, Section, Container, Button, DataTable, } from "../../../../ui";
 import { Form, FieldInput, FieldSelect, Input } from "../../../../ui";
 import { lotteryConfigFormSchema } from "../../../shared/features/lottery/config-form";
+import { lotteryConfigWriteSchema } from "../../../../features/lottery/schemas/config-write";
 import { FormErrorSummary } from "../../../../ui/forms/FormErrorSummary";
 export function LotteryAdminEditView({ eventId, initialData, onSubmit, }) {
     const [isPending, startTransition] = useTransition();
@@ -35,23 +36,45 @@ export function LotteryAdminEditView({ eventId, initialData, onSubmit, }) {
         setError(null);
         startTransition(async () => {
             try {
-                const lotteryConfig = {
+                /*
+                 * 🛑 This used to send `isBooked: false` and `weight: 0` on every slot,
+                 * and drop `bookedByUserId` / `bookedByDisplayName` /
+                 * `bookedByUserLotteryNumber` entirely — against a `.passthrough()`
+                 * PATCH, which made the first save of a live lottery erase every
+                 * purchased slot, silently, with a 200.
+                 *
+                 * The write shape now has NO booking fields at all and is `.strict()`,
+                 * so a slot's buyer is not something this form can express, let alone
+                 * overwrite. `PUT /lottery-config` merges by `slotNumber` against the
+                 * stored config and is the only writer.
+                 */
+                const candidate = {
                     slots: slots.map((s) => ({
                         slotNumber: s.slotNumber,
                         name: s.name,
                         image: s.image?.trim() || undefined,
                         price: s.price,
-                        weight: 0,
-                        isBooked: false,
                     })),
-                    totalSlots: slots.length,
                     pricingMode,
-                    uniformPrice: pricingMode === "uniform" ? Math.round(parseFloat(uniformPrice) * 100) / 100 || 0 : undefined,
+                    uniformPrice: pricingMode === "uniform"
+                        ? Math.round(parseFloat(uniformPrice) * 100) / 100 || 0
+                        : undefined,
                     drawWindowDurationMinutes: parseInt(drawWindowMinutes, 10) || 5,
                     maxPullsPerTransaction: parseInt(maxPullsPerTx, 10) || 1,
                     maxPullsPerUser: parseInt(maxPullsPerUser, 10) || 1,
                 };
-                await onSubmit({ title, description, type: "lottery", lotteryConfig });
+                /*
+                 * The schema was passed to `<Form>` and never actually run — so the
+                 * `parseFloat(x) || 0` coercions above, which it exists to catch, were
+                 * still live. Parsed here so a bad slot is refused on the client
+                 * rather than discovered as a 400.
+                 */
+                const parsed = lotteryConfigWriteSchema.safeParse(candidate);
+                if (!parsed.success) {
+                    setError(parsed.error.issues[0]?.message ?? "Check the lottery settings.");
+                    return;
+                }
+                await onSubmit({ title, description, type: "lottery", lotteryConfig: parsed.data });
             }
             catch (err) {
                 void normalizeError(err);

package/dist/_internal/client/features/lottery/LotteryListView.js

@@ -2,6 +2,7 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { Stack, Row, Text, Heading, Badge, Card, Section, Container, Anchor, Div, Grid, } from "../../../../ui";
 import { MediaImage } from "../../../../features/media/MediaImage";
+import { ROUTES } from "../../../../next/routing/route-map";
 /**
  * Card grid of lotteries.
  * Admin sees all statuses; public sees active only.
@@ -17,7 +18,18 @@ export function LotteryListView({ items, adminMode = false }) {
                             const claimed = event.lotteryConfig?.slots.filter((s) => s.isBooked).length ?? 0;
                             const total = event.lotteryConfig?.totalSlots ?? 0;
                             const slotsLeft = total - claimed;
-                            return (_jsx(Anchor, { href: `/lottery/${event.id}`, tone: "brand", rounded: "2xl", className: "block focus:outline-none focus-visible:ring-2 focus-visible:ring-primary", "aria-label": `${event.title} lottery`, children: _jsxs(Card, { variant: "default", padding: "none", animate: "hoverLift", className: "overflow-hidden", children: [event.coverImageUrl || event.coverImage?.url ? (_jsx(Div, { className: "relative aspect-video overflow-hidden", children: _jsx(MediaImage, { src: event.coverImageUrl || event.coverImage?.url || "", alt: event.title, size: "card" }) })) : (_jsx(Div, { className: "aspect-video", surface: "muted", align: "center", justify: "center", children: _jsx(Text, { size: "3xl", children: "\uD83C\uDFB0" }) })), _jsxs(Stack, { gap: "xs", padding: "md", children: [_jsxs(Row, { gap: "xs", align: "center", wrap: true, children: [_jsx(Badge, { variant: event.status === "active"
+                            return (_jsx(Anchor, { 
+                                /*
+                                 * In adminMode this used to link to the PUBLIC lottery page,
+                                 * so an admin on the admin list had no route to slot
+                                 * configuration at all — which went unnoticed because the
+                                 * editor was orphaned and there was nowhere to link TO.
+                                 * Nested anchors are invalid, so the card itself changes
+                                 * target rather than gaining a second link.
+                                 */
+                                href: adminMode
+                                    ? String(ROUTES.ADMIN.LOTTERY_CONFIG(event.id))
+                                    : `/lottery/${event.id}`, tone: "brand", rounded: "2xl", className: "block focus:outline-none focus-visible:ring-2 focus-visible:ring-primary", "aria-label": `${event.title} lottery`, children: _jsxs(Card, { variant: "default", padding: "none", animate: "hoverLift", className: "overflow-hidden", children: [event.coverImageUrl || event.coverImage?.url ? (_jsx(Div, { className: "relative aspect-video overflow-hidden", children: _jsx(MediaImage, { src: event.coverImageUrl || event.coverImage?.url || "", alt: event.title, size: "card" }) })) : (_jsx(Div, { className: "aspect-video", surface: "muted", align: "center", justify: "center", children: _jsx(Text, { size: "3xl", children: "\uD83C\uDFB0" }) })), _jsxs(Stack, { gap: "xs", padding: "md", children: [_jsxs(Row, { gap: "xs", align: "center", wrap: true, children: [_jsx(Badge, { variant: event.status === "active"
                                                                 ? "success"
                                                                 : event.status === "ended"
                                                                     ? "danger"

package/dist/_internal/server/features/checkout/actions.js

@@ -80,7 +80,7 @@ async function claimDigitalCodeForOrder(db, productId, orderId, userId, opts) {
             userName: opts.userName ?? "there",
             productTitle: opts.productTitle ?? "your product",
             orderId,
-        }).catch((e) => serverLogger.error("claimDigitalCode: email failed", e));
+        }).catch((e) => serverLogger.error("claimDigitalCode: email failed", { error: normalizeError(e).message }));
     }
 }
 /**
@@ -550,7 +550,7 @@ async function createOrderForGroup(group, orderType, ctx) {
             userEmail: userEmail || undefined,
             userName,
             productTitle: firstItem.productTitle,
-        }).catch((e) => serverLogger.error("claimDigitalCode", e));
+        }).catch((e) => serverLogger.error("claimDigitalCode", { error: normalizeError(e).message }));
     }
     for (const code of groupCouponCodes) {
         const entry = couponUsageAccumulator.get(code);
@@ -892,8 +892,10 @@ export async function previewCheckoutPricing(input) {
         // A preview never throws — it just shows the lane the buyer can actually
         // check out, matching what the checkout page's active tab displays.
         (!previewLane || laneOf(item) === previewLane));
+    // A fresh object, not the module singleton — an in-process caller mutating
+    // the returned preview would otherwise poison every later empty result.
     if (cartItems.length === 0)
-        return EMPTY_PRICING_PREVIEW;
+        return { ...EMPTY_PRICING_PREVIEW, stores: [] };
     // Best-effort product lookup — a preview never throws on a since-unpublished
     // product, it just falls back to the item's cart-snapshot price for that
     // line (same fallback cartRepository.getSubtotal() implicitly relies on).
@@ -1268,7 +1270,7 @@ async function createRazorpayGroupOrder(group, orderType, ctx) {
             userEmail: userEmail || undefined,
             userName,
             productTitle: firstItem.productTitle,
-        }).catch((e) => serverLogger.error("claimDigitalCode", e));
+        }).catch((e) => serverLogger.error("claimDigitalCode", { error: normalizeError(e).message }));
     }
     for (const code of groupCouponCodes) {
         const entry = couponUsageAccumulator.get(code);

package/dist/_internal/server/features/classified/metadata.js

@@ -21,7 +21,9 @@ export function buildClassifiedMetadata(product, opts) {
             : product.description?.slice(0, 160) ?? "";
     const image = opts?.ogImageUrl ?? (product.mainImage || product.images?.[0] || null);
     const siteUrl = opts?.siteUrl?.replace(/\/+$/, "");
-    const canonical = siteUrl ? `${siteUrl}/classified/${product.id}` : undefined;
+    // Prefer `slug` — the route is `/classified/[slug]`, so a canonical built from
+    // `id` names a URL the router does not serve whenever the two differ.
+    const canonical = siteUrl ? `${siteUrl}/classified/${product.slug ?? product.id}` : undefined;
     return {
         title,
         description,

package/dist/_internal/server/features/digital-code/metadata.js

@@ -14,7 +14,9 @@ export function buildDigitalCodeMetadata(product, opts) {
         : product.description?.slice(0, 160) ?? "";
     const image = opts?.ogImageUrl ?? (product.mainImage || product.images?.[0] || null);
     const siteUrl = opts?.siteUrl?.replace(/\/+$/, "");
-    const canonical = siteUrl ? `${siteUrl}/digital-codes/${product.id}` : undefined;
+    // Prefer `slug` — the route is `/digital-codes/[slug]`, so a canonical built
+    // from `id` names a URL the router does not serve whenever the two differ.
+    const canonical = siteUrl ? `${siteUrl}/digital-codes/${product.slug ?? product.id}` : undefined;
     return {
         title,
         description,

package/dist/_internal/server/features/live/metadata.js

@@ -17,7 +17,9 @@ export function buildLiveItemMetadata(product, opts) {
         : product.description?.slice(0, 160) ?? "";
     const image = opts?.ogImageUrl ?? (product.mainImage || product.images?.[0] || null);
     const siteUrl = opts?.siteUrl?.replace(/\/+$/, "");
-    const canonical = siteUrl ? `${siteUrl}/live/${product.id}` : undefined;
+    // Prefer `slug` — the route is `/live/[slug]`, so a canonical built from `id`
+    // names a URL the router does not serve whenever the two differ.
+    const canonical = siteUrl ? `${siteUrl}/live/${product.slug ?? product.id}` : undefined;
     return {
         title,
         description,

package/dist/_internal/server/features/refunds/actions.js

@@ -16,6 +16,7 @@ import { wrapAction } from "@mohasinac/appkit/server";
  */
 import { randomUUID } from "crypto";
 import { getProviders } from "../../../../contracts/registry";
+import { normalizeError } from "../../../../errors/normalize";
 import { rupeesToPaise } from "../../../../providers/payment-razorpay/index";
 import { orderRepository } from "../../../..";
 import { ORDER_FIELDS } from "../../../../constants/field-names";
@@ -65,7 +66,7 @@ function revokeAvailableDigitalCodes(orderId, items) {
             .limit(1)
             .get()
             .then((snap) => revokeFirstSnapDoc(snap))
-            .catch((e) => serverLogger.error("refund: code query failed", e));
+            .catch((e) => serverLogger.error("refund: code query failed", { error: normalizeError(e).message }));
     }
 }
 function revokeFirstSnapDoc(snap) {
@@ -73,7 +74,7 @@ function revokeFirstSnapDoc(snap) {
         return;
     snap.docs[0].ref
         .update({ status: "revoked", updatedAt: new Date() })
-        .catch((e) => serverLogger.error("refund: code revoke failed", e));
+        .catch((e) => serverLogger.error("refund: code revoke failed", { error: normalizeError(e).message }));
 }
 export async function processRefundAction(input) {
     return wrapAction(async () => {

package/dist/_internal/server/features/reviews/actions.js

@@ -71,8 +71,9 @@ export async function deleteReviewAction(input) {
 }
 export async function markReviewHelpfulAction(reviewId) {
     return wrapAction(async () => {
-        await requireRoleUser(["buyer", "seller", "admin"]);
+        const user = await requireRoleUser(["buyer", "seller", "admin"]);
         await getReviewOrThrow(reviewId);
-        await reviewRepository.incrementHelpful(reviewId);
+        // Keyed on the voter so a repeated call is a no-op rather than another +1.
+        return reviewRepository.voteHelpful(reviewId, user.uid);
     });
 }

package/dist/_internal/server/features/seo/sitemap.js

@@ -14,6 +14,50 @@ const PRODUCT_STATUS = "status";
 const PRODUCT_STATUS_PUBLISHED = "published";
 const PRODUCT_SLUG = "slug";
 const PRODUCT_UPDATED_AT = "updatedAt";
+/**
+ * Tester-sandbox fixtures must never reach the public sitemap. They are created
+ * and destroyed on a cycle by `testerSandboxCleanup` / `testerSandboxRefresh`,
+ * so anything Google indexes from them 404s shortly after. 34 of 182 sitemap
+ * URLs were disposable test fixtures before this filter existed.
+ *
+ * 🛑 This MUST be an in-memory filter, never a Firestore inequality on the
+ * field. An inequality silently excludes every document that does not have the
+ * field at all — which is every real product, store, category and post, since
+ * the flag is optional and was added later. Such a query returns ONLY test
+ * data. Same trap documented in CLAUDE.md § Tester QA Program.
+ *
+ * The field must therefore appear in each fetcher's `.select(...)` list, or it
+ * comes back undefined and nothing is filtered.
+ *
+ * The flag is not product-specific — it is set on categories, stores, blog
+ * posts and events too — but `PRODUCT_FIELDS` is where the canonical constant
+ * lives, so alias it rather than reintroducing a raw string.
+ */
+const TEST_DATA_FIELD = PRODUCT_FIELDS.IS_TEST_DATA;
+const isTestDoc = (data) => data.isTestData === true;
+/**
+ * A sitemap section that throws returns `[]` so a single broken query degrades
+ * the sitemap instead of 500-ing the whole route. That trade-off is right, but
+ * it is also why `fetchCategoryUrls` could return zero URLs for months without
+ * anyone noticing — it was logged at `warn` and looked identical to "this site
+ * genuinely has no categories".
+ *
+ * Log at `error`, and always name the section, so a section dropping to zero is
+ * greppable in production logs. `buildSitemap` additionally logs a per-section
+ * count digest on every build (see below), and `scripts/deploy.mjs` fails the
+ * deploy when any section is empty.
+ *
+ * NOTE: callers must still call `normalizeError(err)` themselves, in the catch
+ * block, BEFORE delegating here. `audit-catch-normalize` requires that call to
+ * be lexically inside the `catch` — a helper that normalises on the caller's
+ * behalf reads as an unnormalised catch and fails the audit. Keeping the call at
+ * the catch site is also what guarantees `unknown` never escapes into downstream
+ * logic, which is the rule's actual point.
+ */
+function sitemapSectionFailed(label, err) {
+    serverLogger.error(`sitemap: section "${label}" failed and returned 0 URLs`, { section: label, error: err });
+    return [];
+}
 function staticPages(baseUrl) {
     const page = (path, changeFreq, priority) => ({ url: `${baseUrl}${path}`, lastModified: new Date(), changeFrequency: changeFreq, priority });
     return [
@@ -70,10 +114,12 @@ async function fetchProductUrls(baseUrl) {
             .collection(PRODUCT_COLLECTION)
             .where(PRODUCT_STATUS, "==", PRODUCT_STATUS_PUBLISHED)
             .where("listingType", "in", PRODUCT_DETAIL_LISTING_TYPES)
-            .select(PRODUCT_SLUG, PRODUCT_UPDATED_AT)
+            .select(PRODUCT_SLUG, PRODUCT_UPDATED_AT, TEST_DATA_FIELD)
             .limit(5000)
             .get();
-        return snap.docs.map((doc) => {
+        return snap.docs
+            .filter((doc) => !isTestDoc(doc.data()))
+            .map((doc) => {
             const data = doc.data();
             const slug = data[PRODUCT_SLUG] ?? doc.id;
             return {
@@ -86,8 +132,7 @@ async function fetchProductUrls(baseUrl) {
     }
     catch (err) {
         void normalizeError(err);
-        serverLogger.warn("sitemap: failed to fetch product URLs", { error: err });
-        return [];
+        return sitemapSectionFailed("product", err);
     }
 }
 async function fetchListingTypeUrls(baseUrl, listingType, buildUrl, label) {
@@ -97,10 +142,12 @@ async function fetchListingTypeUrls(baseUrl, listingType, buildUrl, label) {
             .collection(PRODUCT_COLLECTION)
             .where(PRODUCT_STATUS, "==", PRODUCT_STATUS_PUBLISHED)
             .where("listingType", "==", listingType)
-            .select(PRODUCT_SLUG, PRODUCT_UPDATED_AT)
+            .select(PRODUCT_SLUG, PRODUCT_UPDATED_AT, TEST_DATA_FIELD)
             .limit(2000)
             .get();
-        return snap.docs.map((doc) => {
+        return snap.docs
+            .filter((doc) => !isTestDoc(doc.data()))
+            .map((doc) => {
             const data = doc.data();
             const slug = data[PRODUCT_SLUG] ?? doc.id;
             return {
@@ -113,8 +160,7 @@ async function fetchListingTypeUrls(baseUrl, listingType, buildUrl, label) {
     }
     catch (err) {
         void normalizeError(err);
-        serverLogger.warn(`sitemap: failed to fetch ${label} URLs`, { error: err });
-        return [];
+        return sitemapSectionFailed(label, err);
     }
 }
 const fetchPreOrderUrls = (baseUrl) => fetchListingTypeUrls(baseUrl, "pre-order", (slug) => ROUTES.PUBLIC.PRE_ORDER_DETAIL(slug), "pre-order");
@@ -129,10 +175,12 @@ async function fetchAuctionUrls(baseUrl) {
             .collection(PRODUCT_COLLECTION)
             .where(PRODUCT_STATUS, "==", PRODUCT_STATUS_PUBLISHED)
             .where("listingType", "==", "auction")
-            .select(PRODUCT_SLUG, PRODUCT_UPDATED_AT)
+            .select(PRODUCT_SLUG, PRODUCT_UPDATED_AT, TEST_DATA_FIELD)
             .limit(2000)
             .get();
-        return snap.docs.map((doc) => {
+        return snap.docs
+            .filter((doc) => !isTestDoc(doc.data()))
+            .map((doc) => {
             const data = doc.data();
             const slug = data[PRODUCT_SLUG] ?? doc.id;
             return {
@@ -145,8 +193,7 @@ async function fetchAuctionUrls(baseUrl) {
     }
     catch (err) {
         void normalizeError(err);
-        serverLogger.warn("sitemap: failed to fetch auction URLs", { error: err });
-        return [];
+        return sitemapSectionFailed("auction", err);
     }
 }
 async function fetchEventUrls(baseUrl) {
@@ -155,10 +202,12 @@ async function fetchEventUrls(baseUrl) {
         const snap = await db
             .collection(EVENTS_COLLECTION)
             .where(EVENT_FIELDS.STATUS, "==", EVENT_FIELDS.STATUS_VALUES.ACTIVE)
-            .select(EVENT_FIELDS.UPDATED_AT, EVENT_FIELDS.SLUG)
+            .select(EVENT_FIELDS.UPDATED_AT, EVENT_FIELDS.SLUG, TEST_DATA_FIELD)
             .limit(500)
             .get();
-        return snap.docs.map((doc) => {
+        return snap.docs
+            .filter((doc) => !isTestDoc(doc.data()))
+            .map((doc) => {
             const data = doc.data();
             const slug = typeof data[EVENT_FIELDS.SLUG] === "string" ? data[EVENT_FIELDS.SLUG] : undefined;
             return {
@@ -171,15 +220,25 @@ async function fetchEventUrls(baseUrl) {
     }
     catch (err) {
         void normalizeError(err);
-        serverLogger.warn("sitemap: failed to fetch event URLs", { error: err });
-        return [];
+        return sitemapSectionFailed("event", err);
     }
 }
-// categories is a discriminated-union collection (categoryType: "listing" |
-// "brand" | "bundle" — see CLAUDE.md's SB-UNI-C/SB-UNI-D). Each discriminator
-// renders at a different public route, so each needs its own filtered query;
-// querying the collection without a categoryType filter (the prior bug here)
-// mapped brand/bundle rows onto the wrong /categories/{slug} URL.
+// `categories` is a discriminated-union collection. Each discriminator renders
+// at a different public route, so each needs its own filtered query; querying
+// the collection without a categoryType filter (an older bug here) mapped
+// brand/bundle rows onto the wrong /categories/{slug} URL.
+//
+// 🛑 The union is `"category" | "sublisting" | "brand" | "bundle"` — see
+// CategoryType in features/categories/types/index.ts. There is NO "listing"
+// value and there never was. This function used to be called with "listing"
+// for the plain-category case, which matched zero documents, so ~47 category
+// pages were missing from the sitemap for as long as that call existed — with
+// no error, because a zero-row query is indistinguishable from "no categories".
+//
+// It is still only safe to use this helper for discriminators that are actually
+// STORED. A plain listing category OMITS `categoryType` entirely (that is the
+// convention every seeded listing category follows), so no equality can select
+// it — see fetchCategoryUrls below, which inverts the test instead.
 async function fetchCategoryTypeUrls(baseUrl, categoryType, buildUrl, label) {
     try {
         const db = getAdminDb();
@@ -187,10 +246,12 @@ async function fetchCategoryTypeUrls(baseUrl, categoryType, buildUrl, label) {
             .collection(CATEGORIES_COLLECTION)
             .where(CATEGORY_FIELDS.CATEGORY_TYPE, "==", categoryType)
             .where(CATEGORY_FIELDS.IS_ACTIVE, "==", true)
-            .select(CATEGORY_FIELDS.SLUG, CATEGORY_FIELDS.UPDATED_AT)
+            .select(CATEGORY_FIELDS.SLUG, CATEGORY_FIELDS.UPDATED_AT, TEST_DATA_FIELD)
             .limit(500)
             .get();
-        return snap.docs.map((doc) => {
+        return snap.docs
+            .filter((doc) => !isTestDoc(doc.data()))
+            .map((doc) => {
             const data = doc.data();
             const slug = data[CATEGORY_FIELDS.SLUG] ?? doc.id;
             return {
@@ -203,11 +264,57 @@ async function fetchCategoryTypeUrls(baseUrl, categoryType, buildUrl, label) {
     }
     catch (err) {
         void normalizeError(err);
-        serverLogger.warn(`sitemap: failed to fetch ${label} URLs`, { error: err });
-        return [];
+        return sitemapSectionFailed(label, err);
+    }
+}
+/**
+ * Plain listing categories — the /categories/{slug} pages.
+ *
+ * These CANNOT be selected by an equality on `categoryType`, because a plain
+ * listing category omits the field entirely rather than storing "category".
+ * `.where(CATEGORY_TYPE, "==", <anything>)` therefore excludes every one of
+ * them, and a Firestore `!=` would be worse still — it silently drops documents
+ * that lack the field, which is exactly the set we want.
+ *
+ * So: select on `isActive` alone (the one predicate that IS stored on every
+ * row) and reject the three discriminated kinds in memory. `categoryType` must
+ * stay in the `.select()` list or it comes back undefined and nothing is
+ * rejected.
+ */
+const NON_LISTING_CATEGORY_TYPES = new Set(["brand", "bundle", "sublisting"]);
+async function fetchCategoryUrls(baseUrl) {
+    try {
+        const db = getAdminDb();
+        const snap = await db
+            .collection(CATEGORIES_COLLECTION)
+            .where(CATEGORY_FIELDS.IS_ACTIVE, "==", true)
+            .select(CATEGORY_FIELDS.SLUG, CATEGORY_FIELDS.UPDATED_AT, CATEGORY_FIELDS.CATEGORY_TYPE, TEST_DATA_FIELD)
+            .limit(500)
+            .get();
+        return snap.docs
+            .filter((doc) => {
+            const data = doc.data();
+            if (isTestDoc(data))
+                return false;
+            const kind = data[CATEGORY_FIELDS.CATEGORY_TYPE];
+            return typeof kind !== "string" || !NON_LISTING_CATEGORY_TYPES.has(kind);
+        })
+            .map((doc) => {
+            const data = doc.data();
+            const slug = data[CATEGORY_FIELDS.SLUG] ?? doc.id;
+            return {
+                url: `${baseUrl}${ROUTES.PUBLIC.CATEGORY_DETAIL(slug)}`,
+                lastModified: data[CATEGORY_FIELDS.UPDATED_AT]?.toDate?.() ?? new Date(),
+                changeFrequency: "weekly",
+                priority: 0.7,
+            };
+        });
+    }
+    catch (err) {
+        void normalizeError(err);
+        return sitemapSectionFailed("category", err);
     }
 }
-const fetchCategoryUrls = (baseUrl) => fetchCategoryTypeUrls(baseUrl, "listing", (slug) => ROUTES.PUBLIC.CATEGORY_DETAIL(slug), "category");
 const fetchBrandUrls = (baseUrl) => fetchCategoryTypeUrls(baseUrl, "brand", (slug) => ROUTES.PUBLIC.BRAND_DETAIL(slug), "brand");
 const fetchBundleUrls = (baseUrl) => fetchCategoryTypeUrls(baseUrl, "bundle", (slug) => ROUTES.PUBLIC.BUNDLE_DETAIL(slug), "bundle");
 /**
@@ -228,7 +335,9 @@ async function fetchGroupedListingUrls(baseUrl) {
     }
     catch (err) {
         void normalizeError(err);
-        return [];
+        // This catch used to swallow silently — no log at all, so a failure here was
+        // indistinguishable from "this site has no grouped listings".
+        return sitemapSectionFailed("grouped-listing", err);
     }
 }
 async function fetchBlogPostUrls(baseUrl) {
@@ -237,10 +346,12 @@ async function fetchBlogPostUrls(baseUrl) {
         const snap = await db
             .collection(BLOG_POSTS_COLLECTION)
             .where(BLOG_POST_FIELDS.STATUS, "==", BLOG_POST_FIELDS.STATUS_VALUES.PUBLISHED)
-            .select(BLOG_POST_FIELDS.SLUG, BLOG_POST_FIELDS.PUBLISHED_AT, BLOG_POST_FIELDS.UPDATED_AT)
+            .select(BLOG_POST_FIELDS.SLUG, BLOG_POST_FIELDS.PUBLISHED_AT, BLOG_POST_FIELDS.UPDATED_AT, TEST_DATA_FIELD)
             .limit(1000)
             .get();
-        return snap.docs.map((doc) => {
+        return snap.docs
+            .filter((doc) => !isTestDoc(doc.data()))
+            .map((doc) => {
             const data = doc.data();
             const slug = data[BLOG_POST_FIELDS.SLUG] ?? doc.id;
             const lastModified = data[BLOG_POST_FIELDS.UPDATED_AT]?.toDate?.() ??
@@ -256,8 +367,7 @@ async function fetchBlogPostUrls(baseUrl) {
     }
     catch (err) {
         void normalizeError(err);
-        serverLogger.warn("sitemap: failed to fetch blog post URLs", { error: err });
-        return [];
+        return sitemapSectionFailed("blog-post", err);
     }
 }
 async function fetchStoreUrls(baseUrl) {
@@ -267,10 +377,12 @@ async function fetchStoreUrls(baseUrl) {
             .collection(STORE_COLLECTION)
             .where(STORE_FIELDS.STATUS, "==", STORE_FIELDS.STATUS_VALUES.ACTIVE)
             .where(STORE_FIELDS.IS_PUBLIC, "==", true)
-            .select(STORE_FIELDS.STORE_SLUG, STORE_FIELDS.UPDATED_AT)
+            .select(STORE_FIELDS.STORE_SLUG, STORE_FIELDS.UPDATED_AT, TEST_DATA_FIELD)
             .limit(1000)
             .get();
-        return snap.docs.map((doc) => {
+        return snap.docs
+            .filter((doc) => !isTestDoc(doc.data()))
+            .map((doc) => {
             const data = doc.data();
             const slug = data[STORE_FIELDS.STORE_SLUG] ?? doc.id;
             return {
@@ -283,8 +395,7 @@ async function fetchStoreUrls(baseUrl) {
     }
     catch (err) {
         void normalizeError(err);
-        serverLogger.warn("sitemap: failed to fetch store URLs", { error: err });
-        return [];
+        return sitemapSectionFailed("store", err);
     }
 }
 async function fetchScammerUrls(baseUrl) {
@@ -293,10 +404,12 @@ async function fetchScammerUrls(baseUrl) {
         const snap = await db
             .collection(SCAMMER_COLLECTION)
             .where(PRODUCT_FIELDS.STATUS, "==", "verified")
-            .select("seo", "updatedAt")
+            .select("seo", "updatedAt", TEST_DATA_FIELD)
             .limit(2000)
             .get();
-        return snap.docs.map((doc) => {
+        return snap.docs
+            .filter((doc) => !isTestDoc(doc.data()))
+            .map((doc) => {
             const data = doc.data();
             const slug = data.seo?.slug ?? doc.id;
             return {
@@ -309,8 +422,7 @@ async function fetchScammerUrls(baseUrl) {
     }
     catch (err) {
         void normalizeError(err);
-        serverLogger.warn("sitemap: failed to fetch scammer URLs", { error: err });
-        return [];
+        return sitemapSectionFailed("scammer", err);
     }
 }
 export async function buildSitemap({ baseUrl }) {
@@ -331,8 +443,45 @@ export async function buildSitemap({ baseUrl }) {
         fetchStoreUrls(baseUrl),
         fetchScammerUrls(baseUrl),
     ]);
+    const staticUrls = staticPages(baseUrl);
+    // Per-section count digest. A section that drops to zero is otherwise
+    // indistinguishable from a site that genuinely has none of that thing — which
+    // is exactly how `category: 0` survived unnoticed while every other section
+    // worked (the query filtered on a `categoryType` value that does not exist).
+    //
+    // `scripts/deploy.mjs` asserts the same counts against the deployed sitemap
+    // and fails the deploy on an empty section; this log is the production-side
+    // record for when a section empties out later, between deploys.
+    const sections = {
+        static: staticUrls.length,
+        category: categoryUrls.length,
+        brand: brandUrls.length,
+        bundle: bundleUrls.length,
+        group: groupedListingUrls.length,
+        blog: blogUrls.length,
+        product: productUrls.length,
+        auction: auctionUrls.length,
+        preOrder: preOrderUrls.length,
+        prizeDraw: prizeDrawUrls.length,
+        classified: classifiedUrls.length,
+        digitalCode: digitalCodeUrls.length,
+        live: liveUrls.length,
+        event: eventUrls.length,
+        store: storeUrls.length,
+        scammer: scammerUrls.length,
+    };
+    const empty = Object.entries(sections)
+        .filter(([, n]) => n === 0)
+        .map(([name]) => name);
+    const total = Object.values(sections).reduce((a, b) => a + b, 0);
+    if (empty.length > 0) {
+        serverLogger.warn(`sitemap: ${empty.length} section(s) produced 0 URLs`, { empty, sections, total });
+    }
+    else {
+        serverLogger.info("sitemap: built", { sections, total });
+    }
     return [
-        ...staticPages(baseUrl),
+        ...staticUrls,
         ...categoryUrls,
         ...brandUrls,
         ...bundleUrls,

package/dist/_internal/server/features/stores/adapters.d.ts

@@ -27,7 +27,7 @@ import type { StoreDetail, StoreListItem } from "../../../../features/stores/typ
  */
 export declare const PUBLIC_STORE_FIELDS: readonly ["id", "storeSlug", "ownerId", "storeName", "storeDescription", "storeCategory", "storeLogoURL", "storeBannerURL", "status", "isPublic", "stats", "bio", "location", "website", "socialLinks", "returnPolicy", "shippingPolicy", "isVacationMode", "vacationMessage", "createdAt"];
 /** Everything else, with the reason it stays server-side. */
-export declare const PRIVATE_STORE_FIELDS: readonly ["updatedAt", "whatsappConfig", "adminNotes", "statusHistory", "statusHistoryTruncated", "isVerified", "suspensionReason", "capabilities", "customCommissionRate", "googleReviews", "shippingConfig", "emiEnabled", "isFeatured", "vacationReturnDate", "isTestData", "testDataExpiresAt"];
+export declare const PRIVATE_STORE_FIELDS: readonly ["searchTxt", "updatedAt", "whatsappConfig", "adminNotes", "statusHistory", "statusHistoryTruncated", "isVerified", "suspensionReason", "capabilities", "customCommissionRate", "googleReviews", "shippingConfig", "emiEnabled", "isFeatured", "vacationReturnDate", "isTestData", "testDataExpiresAt"];
 /**
  * Accepted input: a `StoreDocument` (the common case) or a loosely-typed
  * Firestore row. The legacy top-level counters below predate `stats` and are