@mohasinac/appkit 4.26.0 → 4.28.0

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/jobs/core/listingProcessor.d.ts

@@ -10,7 +10,6 @@ import type { JobContext } from "../runtime/types";
 import type { JsonValue } from "../../../../schemas/types";
 export interface ListingRequestBody {
     collection: string;
-    q?: string;
     f?: string;
     s?: string;
     p?: number | string;

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

@@ -36,6 +36,17 @@ function getBoolOpt(baseOpts, key, fallback) {
         return false;
     return fallback;
 }
+function getStringOpt(baseOpts, key) {
+    const value = baseOpts[key];
+    return typeof value === "string" && value.length > 0 ? value : undefined;
+}
+function getStringArrayOpt(baseOpts, key) {
+    const value = baseOpts[key];
+    if (!Array.isArray(value))
+        return undefined;
+    const strings = value.filter((v) => typeof v === "string" && v.length > 0);
+    return strings.length > 0 ? strings : undefined;
+}
 const LISTERS = {
     products: (m, o) => productRepository.list(m, o),
     categories: (m) => categoriesRepository.list(m),
@@ -52,7 +63,14 @@ const LISTERS = {
     payouts: (m) => payoutRepository.list(m),
     blogPosts: (m) => blogRepository.listAll(m),
     events: (m) => eventRepository.list(m),
-    faqs: (m) => faqsRepository.list(m),
+    // Forwards opts so `baseOpts.search` reaches the repository's token search.
+    // This was `(m) => faqsRepository.list(m)` — the second argument was dropped,
+    // which made FAQ token search structurally unreachable through the Function
+    // even though the repository has implemented it all along.
+    faqs: (m, o) => faqsRepository.list(m, {
+        search: getStringOpt(o, "search"),
+        tags: getStringArrayOpt(o, "tags"),
+    }),
     notifications: (m) => notificationRepository.list(m),
     scammers: (m) => scammerRepository.listAll(m),
     sublistingCategories: (m) => categoriesRepository.list({

package/dist/_internal/shared/actions/action-registry.js

@@ -2469,6 +2469,20 @@ export const ACTIONS = {
             description: "Advance from address selection to the payment step.",
             kind: "primary",
         },
+        "continue-to-payment": {
+            iconKey: "cart",
+            id: "checkout.continue-to-payment",
+            label: "Continue to payment",
+            description: "Advance from the add-ons & fees step to the payment step.",
+            kind: "primary",
+        },
+        back: {
+            iconKey: "back",
+            id: "checkout.back",
+            label: "Back",
+            description: "Return to the previous checkout step. Safe at any point before payment — add-on selections are persisted to the cart as they are made, so nothing is lost.",
+            kind: "ghost",
+        },
         "verify-otp": {
             iconKey: "verify",
             id: "checkout.verify-otp",

package/dist/_internal/shared/checkout/order-math.d.ts

@@ -4,8 +4,30 @@
  * directly, unlike `checkout/actions.ts` whose module graph pulls in
  * `server-only` guards that fail outside a real server-action test harness.
  */
-import type { CartItemDocument } from "../../../features/cart/schemas/firestore";
+import type { CartItemDocument, CartLineKind } from "../../../features/cart/schemas/firestore";
 import type { ProductDocument } from "../../../features/products/schemas/firestore";
+/**
+ * Exactly the fields `unitPriceFor` reads.
+ *
+ * Deliberately narrower than `CartItemDocument`, which a client cannot satisfy:
+ * `checkoutDeadline` is a `Date` on the document and a string once the cart has
+ * been through `JSON.parse`. Without this seam the checkout page would have to
+ * hand-roll a seventh copy of the pricing rule — the exact thing the docstring
+ * below spends a paragraph forbidding. `CartItemDocument` is structurally
+ * assignable to it, so every existing server call site is unaffected.
+ */
+export interface PricedCartLine {
+    price: number;
+    quantity: number;
+    lockedPrice?: number;
+    lineKind?: CartLineKind;
+    bundleCategorySlug?: string;
+    bundleProductIds?: string[];
+    groupMembers?: Array<{
+        unitPrice: number;
+        quantity: number;
+    }>;
+}
 /**
  * The single source of truth for "what do we charge for ONE COPY of this line".
  *
@@ -38,13 +60,13 @@ import type { ProductDocument } from "../../../features/products/schemas/firesto
  * for an accepted offer while the cart displayed the negotiated one. Call
  * `lineTotalFor` and let this function stay the only definition.
  */
-export declare function unitPriceFor(item: CartItemDocument, product: ProductDocument | null): number;
+export declare function unitPriceFor(item: PricedCartLine, product: ProductDocument | null): number;
 /**
  * What this line contributes to a subtotal: one copy's price × the number of
  * copies. THE call site should use this rather than multiplying `unitPriceFor`
  * itself — that multiplication is where the six hand-rolled copies diverged.
  */
-export declare function lineTotalFor(item: CartItemDocument, product: ProductDocument | null): number;
+export declare function lineTotalFor(item: PricedCartLine, product: ProductDocument | null): number;
 /** One taxable slice of a line. A single-product line has exactly one. */
 export interface LineTaxComponent {
     productId: string;

package/dist/_internal/shared/features/checkout/config.d.ts

@@ -6,11 +6,11 @@ export declare const CHECKOUT_DEFAULT_COMMISSIONS: {
     readonly codDepositPercent: 10;
     readonly codHandlingFeeMin: 200;
     readonly codHandlingFeePercent: 10;
-    readonly whatsappNotifyFeeEnabled: false;
+    readonly whatsappNotifyFeeEnabled: true;
     readonly whatsappNotifyFee: 10;
-    readonly giftWrapFeeEnabled: false;
+    readonly giftWrapFeeEnabled: true;
     readonly giftWrapFee: 49;
-    readonly shipmentProtectionFeeEnabled: false;
+    readonly shipmentProtectionFeeEnabled: true;
     readonly shipmentProtectionFeePercent: 2;
     readonly shipmentProtectionFeeMin: 30;
     readonly sellerShippingFixed: 50;

package/dist/_internal/shared/features/checkout/config.js

@@ -10,11 +10,14 @@ export const CHECKOUT_DEFAULT_COMMISSIONS = {
     codDepositPercent: 10,
     codHandlingFeeMin: 200,
     codHandlingFeePercent: 10,
-    whatsappNotifyFeeEnabled: false,
+    // Mirrors the SiteSettingsDocument defaults, which enable all three add-ons.
+    // Consequence of the mirror: if the settings read fails, an add-on already
+    // ticked on the cart document is still billed rather than silently dropped.
+    whatsappNotifyFeeEnabled: true,
     whatsappNotifyFee: 10,
-    giftWrapFeeEnabled: false,
+    giftWrapFeeEnabled: true,
     giftWrapFee: 49,
-    shipmentProtectionFeeEnabled: false,
+    shipmentProtectionFeeEnabled: true,
     shipmentProtectionFeePercent: 2,
     shipmentProtectionFeeMin: 30,
     sellerShippingFixed: 50,

package/dist/client.d.ts

@@ -11,6 +11,8 @@ export type { SurfaceErrorOptions } from "./client/api/surface-error";
 export { reportClientError, } from "./client/observability/reportClientError";
 export type { ClientErrorPayload } from "./client/observability/reportClientError";
 export { installClientErrorReporter, useClientErrorReporter, } from "./client/observability/installClientErrorReporter";
+export { setErrorTracker, trackError, ErrorCategory, ErrorSeverity, } from "./monitoring/error-tracking";
+export type { ErrorTrackerFn, ErrorContext, } from "./monitoring/error-tracking";
 export { useApiMutation } from "./client/api/useApiMutation";
 export type { UseApiMutationOptions } from "./client/api/useApiMutation";
 export { useApiQuery } from "./client/api/useApiQuery";
@@ -38,6 +40,8 @@ export type { SkeletonProps } from "./ui/components/Skeleton";
 export { Divider } from "./ui/components/Divider";
 export { Tabs, TabsList, TabsTrigger, TabsContent } from "./ui/components/Tabs";
 export type { TabsProps, TabsListProps, TabsTriggerProps, TabsContentProps } from "./ui/components/Tabs";
+export { TabBarShell, TabBarButton, TabsNavSelect } from "./ui/components/TabBarShell";
+export type { TabBarShellProps, TabBarButtonProps, TabsNavSelectProps } from "./ui/components/TabBarShell";
 export { SellerProductsView } from "./features/seller/components/SellerProductsView";
 export { SellerOrderDetailPanel } from "./features/seller/components/SellerOrdersView";
 export { SellerPayoutDetailContent } from "./features/seller/components/SellerPayoutsView";
@@ -90,6 +94,20 @@ export { LotteryDetailView } from "./_internal/client/features/lottery/LotteryDe
 export { LotteryEntriesView } from "./_internal/client/features/lottery/LotteryEntriesView";
 export { LotteryAdminSlotView } from "./_internal/client/features/lottery/LotteryAdminSlotView";
 export { LotteryAdminEditView } from "./_internal/client/features/lottery/LotteryAdminEditView";
+export { lotteryConfigWriteSchema, lotterySlotWriteSchema } from "./features/lottery/schemas/config-write";
+export { SectionForm, useSectionFormNav } from "./features/shell/SectionForm";
+export type { SectionDef, SectionFormProps } from "./features/shell/SectionForm";
+export { buildSectionsFromSchema } from "./features/shell/build-sections";
+export { reportCreateSchema } from "./features/store-extensions/schemas/report-create-form";
+export { itemRequestCreateSchema } from "./features/store-extensions/schemas/item-request-create-form";
+export { supportTicketCreateSchema } from "./features/support/schemas/ticket-create-form";
+export type { SupportTicketCreateValues } from "./features/support/schemas/ticket-create-form";
+export { analyticsCardCreateSchema, ANALYTICS_CARD_TYPES } from "./features/store-extensions/schemas/analytics-forms";
+export { QuickFormDrawer } from "./features/shell/QuickFormDrawer";
+export type { QuickFormDrawerProps, QuickFieldDef } from "./features/shell/QuickFormDrawer";
+export type { ItemRequestCreateValues } from "./features/store-extensions/schemas/item-request-create-form";
+export type { ReportCreateValues } from "./features/store-extensions/schemas/report-create-form";
+export type { LotteryConfigWriteInput } from "./features/lottery/schemas/config-write";
 export { PrizeDrawLotteryDetailView } from "./_internal/client/features/lottery/PrizeDrawLotteryDetailView";
 export type { LotteryConfig, LotterySlot, ClientLotterySlot, ClientLotteryConfig, LotteryPricingMode, LotteryEntryStatus } from "./features/lottery/types";
 export { BottomSheet } from "./features/layout/index";
@@ -220,13 +238,19 @@ export type { PageViewTrackerProps } from "./features/analytics/components/PageV
 export { PAGE_VIEW_ENTITY_TYPES } from "./features/analytics/types";
 export type { PageViewEntityType } from "./features/analytics/types";
 export { AuctionBidsTable } from "./features/auctions/components/AuctionBidsTable";
+export { buildBidDetailFields, bidStatusBadge } from "./features/auctions/components/bid-detail-fields";
+export { buildEventEntryDetailFields } from "./features/events/components/event-entry-detail-fields";
+export type { EntryFieldRow } from "./features/events/components/event-entry-detail-fields";
+export type { BidDetailViewer } from "./features/auctions/components/bid-detail-fields";
 export type { AuctionBidsTableProps, AuctionWithBids } from "./features/auctions/components/AuctionBidsTable";
 export { ProtectedRoute, AuthStatusPanel, ForgotPasswordView, LoginForm, RegisterForm, ResetPasswordView, VerifyEmailView } from "./features/auth/index";
 export type { AuthGuardUser, ForgotPasswordViewProps, LoginFormProps, LoginFormValues, RegisterFormProps, RegisterFormValues, ResetPasswordViewProps, VerifyEmailViewProps, } from "./features/auth/index";
 export { useLogout, useLogin, useGoogleLogin, useLinkGoogleAccount, useRegister, useForgotPassword, useResetPassword, useVerifyEmail, useChangeEmail } from "./features/auth/index";
 export type { LoginCredentials, RegisterData, ForgotPasswordData, ResetPasswordData, VerifyEmailData, ChangeEmailData } from "./features/auth/index";
 export { CartView, CartItemRow, CartGroupLineRow, CartSummary, CartPriceBreakdown, CartDrawer, CheckoutView, CheckoutSuccessView, CheckoutAddressStep, useGuestCart, useCartCount, useAddToCart, useCart, useGuestCartMerge, useCartQuery } from "./features/cart/index";
-export { StoreAddonsPicker } from "./features/cart/index";
+export { StoreAddonsPicker, hasAnyStoreAddon } from "./features/cart/index";
+export { clientLineTotal } from "./features/cart/utils/line-total";
+export type { PricedCartLine } from "./features/cart/utils/line-total";
 export type { CartPriceBreakdownData, CartPriceBreakdownStore, StoreAddonsValue, StoreAddonsRates } from "./features/cart/index";
 export { getCartOps, CART_OPS_CHANGE_EVENT } from "./features/cart/utils/pending-ops";
 export type { CartOp } from "./features/cart/utils/pending-ops";
@@ -258,12 +282,16 @@ export type { AdSlotId, AdProvider, AdSlotConfig } from "./features/homepage/ad-
 export { WishlistView, useGuestWishlist, useWishlistWithGuest } from "./features/wishlist/index";
 export type { WishlistViewProps, GuestWishlistItem, WishlistItem, WishlistResponse, WishlistProductData, EnrichedWishlistItem } from "./features/wishlist/index";
 export { WishlistCapWatcher } from "./features/wishlist/components/WishlistCapWatcher";
+export { WishlistHeartButton } from "./features/wishlist/components/WishlistHeartButton";
+export type { WishlistHeartButtonProps, WishlistHeartPlacement, } from "./features/wishlist/components/WishlistHeartButton";
 export { SyncManagerMount } from "./core/components/SyncManagerMount";
 export { useWishlistCount, useWishlistCountWithLimit, WISHLIST_CAP_EVENT } from "./features/wishlist/hooks/useWishlistCount";
 export type { WishlistCapEventDetail } from "./features/wishlist/hooks/useWishlistCount";
 export { getGuestWishlistItems, addToGuestWishlist, removeFromGuestWishlist, isInGuestWishlist, clearGuestWishlist, getGuestWishlistCount, getGuestWishlistByType, } from "./features/wishlist/utils/guest-wishlist";
 export { InteractiveProductCard } from "./features/products/index";
 export type { InteractiveProductCardProps } from "./features/products/index";
+export { GroupedListingEditorView } from "./features/grouped/components/GroupedListingEditorView";
+export type { GroupedListingEditorViewProps } from "./features/grouped/components/GroupedListingEditorView";
 export { GroupedListingDetailView } from "./features/grouped/components/GroupedListingDetailView";
 export type { GroupedListingDetailViewProps } from "./features/grouped/components/GroupedListingDetailView";
 export { GroupMemberPicker } from "./features/products/components/GroupMemberPicker";
@@ -414,8 +442,10 @@ export type { PaymentProofReviewMessageInput } from "./features/whatsapp-bot/typ
 export type { AdminNotificationDocument, ItemRequestDocument, ModerationQueueDocument, ReportDocument, CustomRoleDocument, AnalyticsCardDocument, ListingTemplateDocument, } from "./features/store-extensions/index";
 export { CommandPalette, useCommandPaletteHotkey } from "./features/shell/index";
 export type { CommandPaletteGroup } from "./features/shell/index";
-export { AdminBlogEditorView, AdminBundleEditorView, AdminCarouselEditorView, AdminCategoryEditorView, AdminCouponEditorView, AdminFaqEditorView, AdminFeatureEditorView, AdminOrderEditorView, AdminPayoutMarkPaidModal, AdminAuditLogView, ViewAuditLogEntryModal, AdminProductEditorView, AdminScammerEditorView, AdminStoreEditorView, AdminSublistingCategoryEditorView, AdminSupportTicketDetailView, } from "./features/admin/index";
+export { AdminBlogEditorView, AdminBundleEditorView, AdminCarouselEditorView, AdminCategoryEditorView, AdminCouponEditorView, AdminFaqEditorView, AdminFeatureEditorView, AdminOrderEditorView, AdminPayoutMarkPaidModal, AdminAuditLogView, ViewAuditLogEntryModal, AdminProductEditorView, AdminScammerEditorView, AdminEmployeeEditorView, AdminNavEditorView, AdminUserEditorView, AdminStoreEditorView, AdminSublistingCategoryEditorView, AdminSupportTicketDetailView, } from "./features/admin/index";
 export type { AdminStoreEditorViewProps, AdminPayoutMarkPaidModalProps, AdminAuditLogViewProps, AuditLogEntryDetail, ViewAuditLogEntryModalProps } from "./features/admin/index";
+export type { NavItemData } from "./features/admin/index";
+export { PageLoader } from "./ui/index";
 export { ADMIN_CHECKOUT_BYPASS_FLAG_KEY } from "./features/admin/schemas/firestore";
 export { SpinWheelView, EventRaffleEntryForm } from "./features/events/index";
 export { Card, CardBody } from "./ui/index";