@mohasinac/appkit 4.53.1 → 4.54.0

package/dist/_internal/server/features/price-index/market.js

@@ -0,0 +1,120 @@
+/*
+ * WHY: The realised-price tool rendered "No completed sales recorded here yet"
+ *      for every single lookup, because the only data it read was OUR completed
+ *      sales and we have none for most leaves. Meanwhile the competitor crawl
+ *      measured ~60 real bands (`MARKET_BANDS` in
+ *      `seed/_helpers/category-content.ts`, evidence in
+ *      `docs/research/competitor-crawl-2026-10/price-bands.md`) which were
+ *      seeded onto the taxonomy and then read by exactly one surface — the
+ *      seller form's hint. The tool had a starting point the whole time and
+ *      never looked at it.
+ * WHAT: The MARKET half of the tool, resolved by the shared nearest-first
+ *       ancestor walk. Signed-in only — see the gate note below.
+ *
+ * EXPORTS:
+ *   PriceIndexMarketRow           — one leaf's market band, API shape
+ *   getPriceIndexMarketForIds     — N category ids -> their market bands
+ *
+ * ── 🛑 WHY THIS IS A SEPARATE, AUTHENTICATED ENDPOINT ───────────────────────
+ *
+ * The sold half (`searchPriceIndex`, `getPriceIndexBandsForIds`) is PUBLIC and
+ * edge-cached, deliberately: a day-stale aggregate of our own completed sales
+ * is the strongest content we can publish and is not what the guest price gate
+ * protects. The market half is the opposite call, and the reasoning is already
+ * written down at `categories/api/[id]/price-guidance/route.ts`: publishing a
+ * competitor-derived band on an unauthenticated, publicly-cacheable response
+ * "would be exactly the 'a neighbouring surface publishes the range' leak that
+ * gate exists to close".
+ *
+ * So the two halves cannot share a response. Merging `market` into
+ * `getPriceIndexBandsForIds` would either poison that public cache with
+ * viewer-dependent content — one signed-in lookup populating the entry every
+ * guest then reads, the exact failure `cachedPublicRead`'s rules exist to
+ * prevent — or force the public half to go private and lose its cache. A
+ * sibling endpoint keeps both postures correct, and it is the same split the
+ * codebase already uses for `description-template` (public) against
+ * `price-guidance` (gated).
+ *
+ * ── 🛑 WHAT IS NOT DONE HERE: the seller tax-basis conversion ───────────────
+ *
+ * The seller route restates the band on the caller's own `pricesIncludeGst`
+ * basis. This one does not, for two reasons. The figures are tax-inclusive
+ * (`PRICE_GUIDANCE_TAX_BASIS`) and so is every price a buyer sees anywhere on
+ * the site, so for the tool's audience no conversion is the correct answer
+ * rather than a missing feature. And the conversion needs a store read per
+ * lookup, which on a tool that resolves up to eight leaves at a time would be
+ * a per-request cost paid to restate a number most callers want as stored. The
+ * renderer labels the basis instead.
+ *
+ * @tag domain:price-index
+ * @tag layer:server
+ * @tag pattern:projection
+ * @tag access:server-only
+ * @tag consumers:api/tools/price-index/market
+ * @tag sideEffects:none
+ */
+import { resolveInheritedGuidanceMany } from "../categories/price-guidance-resolve.js";
+import { PRICE_GUIDANCE_TAX_BASIS } from "../../../shared/features/categories/price-guidance.js";
+import { PRICE_INDEX_SEARCH_LIMIT } from "./search.js";
+/**
+ * Market bands for the leaves the client already resolved.
+ *
+ * Bounded by `PRICE_INDEX_SEARCH_LIMIT` — the same cap the public half uses, so
+ * a crafted request cannot demand an unbounded read, and the two halves of one
+ * lookup can never disagree about how many rows a lookup covers.
+ *
+ * A leaf with no band at any level is ABSENT from the result rather than
+ * present with a null band. "We have no market evidence for this" and "this id
+ * does not exist" are different answers and the caller renders them
+ * differently; collapsing them is how a missing band becomes a confident ₹0.
+ */
+export async function getPriceIndexMarketForIds(rawIds) {
+    const ids = [...new Set(rawIds.filter((id) => typeof id === "string" && id.length > 0))].slice(0, PRICE_INDEX_SEARCH_LIMIT);
+    if (ids.length === 0)
+        return [];
+    const guidanceById = await resolveInheritedGuidanceMany(ids);
+    const rows = [];
+    for (const id of ids) {
+        const resolved = guidanceById.get(id);
+        const market = resolved?.guidance.market;
+        // No band anywhere up the chain. Omitted, never zeroed.
+        if (!market || !resolved)
+            continue;
+        rows.push({
+            categoryId: id,
+            median: market.median,
+            ...(market.p25 === undefined ? {} : { p25: market.p25 }),
+            ...(market.p75 === undefined ? {} : { p75: market.p75 }),
+            ...(market.sampleSize === undefined ? {} : { sampleSize: market.sampleSize }),
+            ...(toIso(market.asOf) ? { asOf: toIso(market.asOf) } : {}),
+            ...(market.soldOutShare === undefined ? {} : { soldOutShare: market.soldOutShare }),
+            ...(market.source ? { source: market.source } : {}),
+            inherited: resolved.inherited,
+            /*
+             * Only when inherited. Naming the leaf as its own source would be noise
+             * on a card that is already headed by that leaf's name.
+             */
+            ...(resolved.inherited
+                ? {
+                    viaCategoryId: resolved.fromCategoryId,
+                    ...(resolved.fromName ? { viaName: resolved.fromName } : {}),
+                }
+                : {}),
+            taxBasis: PRICE_GUIDANCE_TAX_BASIS,
+        });
+    }
+    return rows;
+}
+/** Firestore `Timestamp` | `Date` | ISO string -> ISO string. */
+function toIso(v) {
+    if (!v)
+        return undefined;
+    if (v instanceof Date)
+        return v.toISOString();
+    if (typeof v === "string")
+        return v;
+    const t = v;
+    if (typeof t.toDate === "function")
+        return t.toDate().toISOString();
+    return undefined;
+}

package/dist/_internal/server/features/products/list-public.d.ts

@@ -1,5 +1,6 @@
 import { type ViewerLike } from "../tester/visibility";
 import type { JsonValue } from "../../../../schemas/types";
+import type { UnavailableClause } from "../../../shared/listing-types/availability";
 import { type AvailabilityFilter } from "../../../../constants/field-names";
 /** Vercel Hobby Fluid Compute ceiling (CLAUDE.md Rule #6) — never fetch more at once. */
 export declare const PUBLIC_PRODUCT_MAX_PAGE_SIZE = 50;
@@ -250,6 +251,17 @@ export declare function parsePublicProductParams(params: URLSearchParams | Recor
      */
     availability?: AvailabilityFilter;
 }): PublicProductListInput;
+/** Render one `UnavailableClause` as a Sieve clause against a fixed `now`. */
+/**
+ * One unavailable clause → a Sieve fragment, with `"NOW"` bound to this
+ * query's timestamp.
+ *
+ * Exported so `listing-tab-counts` builds its clause queries with THIS
+ * function rather than a second copy. A rule reachable by copy-paste is one
+ * that gets copied wrong (Root Cause #75), and the two would only diverge the
+ * day someone adds a third `op`.
+ */
+export declare function clauseToSieve(clause: UnavailableClause, now: Date): string;
 export declare function listPublicProducts(input: PublicProductListInput, opts?: PublicProductListOptions): Promise<PublicProductListResult | null>;
 /**
  * One store tab's worth of listings.

package/dist/_internal/server/features/products/list-public.js

@@ -440,7 +440,16 @@ async function defaultExecutor(query) {
     };
 }
 /** Render one `UnavailableClause` as a Sieve clause against a fixed `now`. */
-function clauseToSieve(clause, now) {
+/**
+ * One unavailable clause → a Sieve fragment, with `"NOW"` bound to this
+ * query's timestamp.
+ *
+ * Exported so `listing-tab-counts` builds its clause queries with THIS
+ * function rather than a second copy. A rule reachable by copy-paste is one
+ * that gets copied wrong (Root Cause #75), and the two would only diverge the
+ * day someone adds a third `op`.
+ */
+export function clauseToSieve(clause, now) {
     const value = clause.value === "NOW" ? now.toISOString() : clause.value;
     return clause.op === "lt"
         ? sieveFilter(clause.field, SIEVE_OP.LT, value)

package/dist/_internal/server/features/products/listing-tab-counts.d.ts

@@ -31,6 +31,28 @@ export interface ListingTabScope {
  * `undefined` as "keep the tab visible" (Root Cause #59).
  */
 export type ListingTabCounts = Record<string, number | undefined>;
+/**
+ * The two numbers a tab bar needs, and they are NOT the same number.
+ *
+ * 🛑 A badge showing `total` while the panel below it defaults to the
+ * AVAILABLE scope is a tab that advertises rows it will not render. That was
+ * live: a category holding one `prizeRevealStatus: "closed"` draw showed
+ * "Prize Draws 1" above "No prize draws found." — accurate counting of the
+ * wrong question, Root Cause #72's family.
+ *
+ *   `available` — what the default scope will render. The BADGE.
+ *   `total`     — every published row in scope, across all availability
+ *                 scopes. The hide-at-zero decision, and the "N ended —
+ *                 view All" hint under an empty panel.
+ *
+ * 🛑 Hiding must stay keyed on `total`. A tab whose rows have all ended still
+ * has a browsable archive behind the Ended/All scopes; hiding it at
+ * `available === 0` would make that archive unreachable.
+ */
+export interface ListingTabCountResult {
+    available: ListingTabCounts;
+    total: ListingTabCounts;
+}
 /**
  * Count every tab in `tabs` within `scope`, in one parallel batch.
  *
@@ -41,4 +63,6 @@ export type ListingTabCounts = Record<string, number | undefined>;
  * `stores` is not counted here: only the category page has that tab and it
  * already resolves its store list eagerly to render the tab body.
  */
-export declare function listingTabCounts(tabs: readonly ListingTab[], scope: ListingTabScope): Promise<ListingTabCounts>;
+export declare function listingTabCounts(tabs: readonly ListingTab[], scope: ListingTabScope, opts?: {
+    now?: Date;
+}): Promise<ListingTabCountResult>;

package/dist/_internal/server/features/products/listing-tab-counts.js

@@ -11,9 +11,10 @@
  *       the tab bar renders, so a tenth listing type is counted automatically.
  *
  * EXPORTS:
- *   ListingTabScope   — the surface's scope (category / brand / store)
- *   ListingTabCounts  — tabSlug -> count, `undefined` meaning "query failed"
- *   listingTabCounts  — resolve every tab's count in one parallel batch
+ *   ListingTabScope       — the surface's scope (category / brand / store)
+ *   ListingTabCounts      — tabSlug -> count, `undefined` meaning "unknown"
+ *   ListingTabCountResult — the AVAILABLE and TOTAL maps, see below
+ *   listingTabCounts      — resolve every tab's counts in one parallel batch
  *
  * @tag domain:products,categories,stores
  * @tag layer:server
@@ -25,6 +26,11 @@
 import { categoriesRepository, productRepository } from "../../../../repositories/index.js";
 import { serverLogger } from "../../../../monitoring/index.js";
 import { normalizeError } from "../../../../errors/normalize.js";
+import { sieveAnd, sieveFilter, SIEVE_OP, sortBy } from "../../../../utils/sieve-builder.js";
+import { PRODUCT_FIELDS } from "../../../../constants/field-names.js";
+import { isListingRowAvailable, pluginFor, } from "../../../shared/listing-types/_registry.js";
+import { normalizeListingType } from "../../../../features/products/utils/listing-type.js";
+import { clauseToSieve, PUBLIC_PRODUCT_MAX_PAGE_SIZE } from "./list-public.js";
 const DEFAULT_STATUS = "published";
 /** Bundles a category owns, resolved by the same rule the bundles tab renders. */
 async function countBundles(scope) {
@@ -65,6 +71,154 @@ function bundleMatchesScope(bundle, scope) {
     }
     return true;
 }
+/**
+ * How many rows in scope are NOT available, per listing type.
+ *
+ * ── 🛑 WHY THIS IS NOT AN AGGREGATE COUNT ─────────────────────────────────
+ *
+ * Two independent reasons, either of which alone is disqualifying.
+ *
+ * 1. Unavailability is an OR across DIFFERENT fields (`availableQuantity == 0`
+ *    OR `isSold == true` OR `prizeRevealStatus == closed` …). Firestore cannot
+ *    express that in one query, and counting each clause separately and adding
+ *    them double-counts every row matching two of them.
+ *
+ * 2. A clause selects a SUPERSET, deliberately. `madeToOrder` is pointedly NOT
+ *    a clause (see the note in `availability.ts`), so a print-on-demand sticker
+ *    sitting at `availableQuantity: 0` matches `availableQuantity == 0` and is
+ *    nevertheless AVAILABLE. Only `isListingRowAvailable` knows that, and it is
+ *    a per-row predicate. Measured on the category that prompted this work,
+ *    a clause-count would have badged "Art & Stickers 2" over three available
+ *    rows — trading one wrong number for another.
+ *
+ * So this is Path C of `listPublicProducts` reused in miniature: one bounded
+ * query per DISTINCT clause, in parallel, merged and deduped by id, then every
+ * surviving row confirmed with the real predicate. Nine listing types collapse
+ * to five clauses, so the whole tab bar costs ~5 × 50 documents in one parallel
+ * round — the same fan-out and the same budget that scope already spends.
+ *
+ * 🛑 The queries are NOT narrowed to the tab's listing types. Firestore permits
+ * one array operator per query and the category scope already spends it on
+ * `categorySlugs array-contains-any`, so adding `listingType in (…)` risks an
+ * INVALID_ARGUMENT for no gain: unavailable rows are sparse, and tallying each
+ * row by its own `listingType` afterwards answers every tab from one pass.
+ */
+async function unavailableByType(scope, types, now) {
+    const byType = new Map();
+    const unknown = new Set();
+    /*
+     * One entry per DISTINCT clause, remembering which types depend on it, so a
+     * clause that cannot run takes down only those types' badges.
+     */
+    const distinct = new Map();
+    for (const type of types) {
+        for (const clause of pluginFor(type).unavailableClauses) {
+            const key = clause.field + "|" + clause.op + "|" + String(clause.value);
+            const entry = distinct.get(key) ?? { clause, types: new Set() };
+            entry.types.add(type);
+            distinct.set(key, entry);
+        }
+    }
+    if (distinct.size === 0)
+        return { byType, unknown };
+    const status = scope.status ?? DEFAULT_STATUS;
+    const results = await Promise.all([...distinct.values()].map(async (entry) => {
+        const { clause } = entry;
+        /*
+         * 🛑 NO SORT on an equality clause — load-bearing, not an omission.
+         *
+         * A tally does not care about order, and adding `orderBy createdAt`
+         * turns a query Firestore can merge-join from single-field indexes into
+         * one demanding a composite index PER CLAUSE PER SCOPE: fifteen new
+         * indexes on a collection already carrying 223, every one of them write
+         * amplification on every product write. Measured against the live
+         * project: all four equality clauses run index-free without the sort and
+         * return FAILED_PRECONDITION with it.
+         *
+         * An inequality is the exception Firestore forces — its first `orderBy`
+         * must be its own field (Root Cause #59) — so that one clause does need
+         * an index, which is exactly why `unknown` is tracked per type.
+         *
+         * 🛑 THE AUCTION INDEXES ARE NOT DECLARED, deliberately. Until they are,
+         * the auction clause returns FAILED_PRECONDITION, `unknown` gains
+         * `auction`, and that ONE badge falls back to its total — every other
+         * type stays exact. Adding them to
+         * `appkit/firebase/base/firestore.indexes.json` is only half the change:
+         * an undeployed index file fails `audit-firebase-rules-deployed`, so the
+         * three entries below and `npm run firebase -- deploy --only
+         * firestore:indexes` belong in the same session.
+         *
+         *   products: status ASC, categorySlugs CONTAINS, auctionEndDate DESC
+         *   products: brand  ASC, status ASC,             auctionEndDate DESC
+         *   products: storeId ASC, status ASC,            auctionEndDate DESC
+         *
+         * One per scope the tab bars count in, because `buildScopedQuery` leads
+         * with a different equality for each.
+         */
+        const sorts = clause.op === "lt" && clause.sortField
+            ? sortBy(clause.sortField, "DESC")
+            : undefined;
+        try {
+            const result = await productRepository.list({
+                filters: sieveAnd(sieveFilter(PRODUCT_FIELDS.STATUS, SIEVE_OP.EQ, status), clauseToSieve(clause, now)),
+                ...(sorts ? { sorts } : {}),
+                page: 1,
+                pageSize: PUBLIC_PRODUCT_MAX_PAGE_SIZE,
+            }, {
+                storeId: scope.storeId,
+                categoriesIn: scope.categoriesIn,
+                brandName: scope.brandName,
+            });
+            return { entry, result };
+        }
+        catch (error) {
+            const e = normalizeError(error);
+            // ERROR, not warn: a clause that cannot run is almost always a missing
+            // composite index — a permanent, silent skew of the badges that depend
+            // on it rather than a transient blip. The fields are named so the log
+            // says which index to create.
+            serverLogger.error("listingTabCounts: unavailable clause failed; those badges fall back to totals", {
+                field: clause.field,
+                op: clause.op,
+                types: [...entry.types],
+                error: e.message,
+            });
+            return { entry, result: null };
+        }
+    }));
+    const merged = new Map();
+    for (const { entry, result } of results) {
+        if (!result) {
+            for (const type of entry.types)
+                unknown.add(type);
+            continue;
+        }
+        const rows = result.items;
+        // A saturated window means there are more unavailable rows than were seen,
+        // so the tally is a floor for every type this clause serves.
+        if (rows.length >= PUBLIC_PRODUCT_MAX_PAGE_SIZE) {
+            for (const type of entry.types)
+                unknown.add(type);
+        }
+        for (const row of rows) {
+            const id = typeof row.id === "string" ? row.id : JSON.stringify(row.id);
+            if (!merged.has(id))
+                merged.set(id, row);
+        }
+    }
+    for (const row of merged.values()) {
+        // The clause matched a superset; this is the real answer.
+        if (isListingRowAvailable(row, now))
+            continue;
+        const type = normalizeListingType(row);
+        byType.set(type, (byType.get(type) ?? 0) + 1);
+    }
+    return { byType, unknown };
+}
+/** The listing types one tab spans — `"art|stickers"` is a pipe OR-group. */
+function typesOf(tab) {
+    return String(tab.listingType).split("|").filter(Boolean);
+}
 /**
  * Count every tab in `tabs` within `scope`, in one parallel batch.
  *
@@ -75,10 +229,12 @@ function bundleMatchesScope(bundle, scope) {
  * `stores` is not counted here: only the category page has that tab and it
  * already resolves its store list eagerly to render the tab body.
  */
-export async function listingTabCounts(tabs, scope) {
+export async function listingTabCounts(tabs, scope, opts) {
+    const now = opts?.now ?? new Date();
     const listingTabs = tabs.filter((tab) => Boolean(tab.listingType));
     const wantsBundles = tabs.some((tab) => tab.collection === "bundles");
-    const [typeCounts, bundleCount] = await Promise.all([
+    const allTypes = [...new Set(listingTabs.flatMap(typesOf))];
+    const [typeCounts, bundleCount, unavailable] = await Promise.all([
         productRepository.countByListingTypes(listingTabs.map((tab) => String(tab.listingType)), {
             status: scope.status ?? DEFAULT_STATUS,
             storeId: scope.storeId,
@@ -86,12 +242,30 @@ export async function listingTabCounts(tabs, scope) {
             brandName: scope.brandName,
         }),
         wantsBundles ? countBundles(scope) : Promise.resolve(undefined),
+        unavailableByType(scope, allTypes, now),
     ]);
-    const counts = {};
+    const total = {};
+    const available = {};
     for (const tab of listingTabs) {
-        counts[tab.id] = typeCounts[String(tab.listingType)];
+        const tabTypes = typesOf(tab);
+        const totalForTab = typeCounts[String(tab.listingType)];
+        total[tab.id] = totalForTab;
+        if (totalForTab === undefined ||
+            tabTypes.some((t) => unavailable.unknown.has(t))) {
+            // Falling back to the total reproduces the pre-split badge rather than
+            // inventing a number — and it keeps the hint silent, because the hint
+            // only speaks when both figures are known.
+            available[tab.id] = totalForTab;
+            continue;
+        }
+        const gone = tabTypes.reduce((sum, type) => sum + (unavailable.byType.get(type) ?? 0), 0);
+        available[tab.id] = Math.max(0, totalForTab - gone);
+    }
+    if (wantsBundles) {
+        // A bundle has no availability scope of its own — the bundles tab renders
+        // active bundle ROWS, not products, so the two numbers are one number.
+        total.bundles = bundleCount;
+        available.bundles = bundleCount;
     }
-    if (wantsBundles)
-        counts.bundles = bundleCount;
-    return counts;
+    return { available, total };
 }

package/dist/_internal/server/features/search/index-build/sources.js

@@ -195,7 +195,26 @@ export const PUBLIC_INDEX_SOURCES = [
     {
         typeKey: "part",
         collection: "partGlossary",
-        select: ["name", "code", "classification", "slot"],
+        /*
+         * 🛑 `aliases` IS IN THE SELECT BECAUSE AN ABBREVIATION IS HOW PEOPLE
+         * SEARCH FOR A PART.
+         *
+         * The wiki states a part's short form outright, and it reaches 1,072 of
+         * 2,490 rows: `EWD` is Eternal Wide Defense, `BWD` is Big Wide Defense,
+         * `ES` is Eternal Spike. Those are the names printed on the part and the
+         * names the community uses — but they lived only in Firestore, because
+         * this select carried name/code/classification/slot and nothing else.
+         *
+         * So the data was there, the page was there, and searching `EWD` found
+         * NOTHING. A gap between holding a fact and being able to find it is
+         * invisible from either end.
+         *
+         * 🛑 It must be `aliases`, not `aka`. The generator UNIONS the wiki's
+         * `aka` into the pre-existing `aliases` array rather than replacing it,
+         * so `aliases` is the superset — selecting `aka` would silently drop
+         * every alias the corpus contributed.
+         */
+        select: ["name", "code", "classification", "slot", "aliases"],
         slugOf: (id) => (id.includes("--") ? id.replace("--", "/") : null),
         toRecord: (id, d) => {
             const name = str(d.name);
@@ -214,11 +233,33 @@ export const PUBLIC_INDEX_SOURCES = [
                 return null;
             const code = str(d.code);
             const classification = str(d.classification);
+            /*
+             * The abbreviations, appended to `detail` because that is the only
+             * other field the record carries and the matcher reads both.
+             *
+             * 🛑 Bounded to four and de-duplicated against the name and code. A
+             * part can carry a dozen aliases, and the artifact is a public file
+             * fetched by every visitor — the whole point of it is that it stays
+             * small enough to ship whole. Four covers the abbreviation plus the
+             * other vendor's name, which is what anyone actually types.
+             */
+            const aliases = Array.isArray(d.aliases) ? d.aliases.map(str).filter(Boolean) : [];
+            const seen = new Set([name.toLowerCase(), (code ?? "").toLowerCase()]);
+            const extra = [];
+            for (const a of aliases) {
+                const k = String(a).toLowerCase();
+                if (seen.has(k))
+                    continue;
+                seen.add(k);
+                extra.push(String(a));
+                if (extra.length === 4)
+                    break;
+            }
             return {
                 title: name,
                 // The classification IS the disambiguation — it is why a user
                 // searching "105" can tell three results apart.
-                detail: [classification, code].filter(Boolean).join(" · "),
+                detail: [classification, code, ...extra].filter(Boolean).join(" · "),
             };
         },
     },

package/dist/_internal/server/features/site-settings/adapters.js

@@ -7,7 +7,7 @@ export const PUBLIC_SITE_SETTINGS_FIELDS = [
     "contact", // user/orders/[id]/payment — contact.whatsappNumber (narrowed: no address/upiVpa)
     "payment", // CheckoutRouteClient — payment.otpCheckoutThreshold (narrowed)
     "listings", // useListingTypeFlags — narrowed to listings.listingTypes; categoryTypes has no client reader
-    "notificationChannels", // NotificationPreferencesPanel + CheckoutRouteClient (whatsapp.otpEnabled)
+    "notificationChannels", // NotificationPreferencesPanel reads the per-channel toggles
     "announcementBar", // the homepage banner (AdminSiteSettingsView edits it)
     "navConfig", // NavbarWithSettings, DashboardLayoutClient
     "actionConfig", // useAuthGate

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", "supportsShippingProtection", "supportsSaleProtection", "createdAt"];
 /** Everything else, with the reason it stays server-side. */
-export declare const PRIVATE_STORE_FIELDS: readonly ["searchTxt", "updatedAt", "whatsappConfig", "adminNotes", "statusHistory", "statusHistoryTruncated", "isVerified", "suspensionReason", "capabilities", "customCommissionRate", "googleReviews", "shippingConfig", "emiEnabled", "pricesIncludeGst", "shippingPricing", "returnsDirectToSeller", "isFeatured", "vacationReturnDate", "isTestData", "testDataExpiresAt", "gstin", "legalName", "registeredAddress"];
+export declare const PRIVATE_STORE_FIELDS: readonly ["searchTxt", "updatedAt", "adminNotes", "statusHistory", "statusHistoryTruncated", "isVerified", "suspensionReason", "capabilities", "customCommissionRate", "googleReviews", "shippingConfig", "emiEnabled", "pricesIncludeGst", "shippingPricing", "returnsDirectToSeller", "isFeatured", "vacationReturnDate", "isTestData", "testDataExpiresAt", "gstin", "legalName", "registeredAddress"];
 /**
  * Accepted input: a `StoreDocument` (the common case) or a loosely-typed
  * Firestore row. The legacy top-level counters below predate `stats` and are

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

@@ -43,7 +43,6 @@ export const PRIVATE_STORE_FIELDS = [
     // hundred tokens.
     "searchTxt",
     "updatedAt", // bookkeeping; no public reader
-    "whatsappConfig", // Meta access token + WABA/catalog ids — secret
     "adminNotes", // schema comment: never shown to the owner or the public
     // Admin decisions with actor UIDs and suspension reasons. The store OWNER
     // sees this on their own admin surfaces; an anonymous visitor to /stores has

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

@@ -1,5 +1,5 @@
 import { isListingTypeEnabled } from "../../../shared/listing-types/feature-flags";
-import { type ListingTabCounts } from "../products/listing-tab-counts";
+import { type ListingTabCountResult } from "../products/listing-tab-counts";
 type SiteSettingsSnapshot = Parameters<typeof isListingTypeEnabled>[1];
 export interface StoreTabLink {
     value: string;
@@ -11,7 +11,12 @@ export interface ResolvedStoreTabs {
     dropdownTabs: StoreTabLink[];
     /** Coupons (if any), Reviews (if any), About — always non-empty. */
     tabs: StoreTabLink[];
-    listingCounts: ListingTabCounts;
+    /**
+     * Both numbers, because they answer different questions: `available` is what
+     * each tab badges, `total` is what decides whether the tab exists at all.
+     * See `ListingTabCountResult`.
+     */
+    listingCounts: ListingTabCountResult;
     couponsCount: number;
     reviewsCount: number;
 }

package/dist/_internal/server/features/stores/tabs.js

@@ -73,7 +73,7 @@ export async function resolveStoreTabs(storeSlug, storeId, settings) {
                 .then((r) => r.total)
                 .catch(() => 0),
         ])
-        : [{}, 0, 0];
+        : [{ available: {}, total: {} }, 0, 0];
     const visibleStoreTabs = STORE_PAGE_TABS.filter((tab) => {
         if (tab.id === "bundles") {
             if (!isCategoryTypeEnabled("bundle", settings))
@@ -92,12 +92,14 @@ export async function resolveStoreTabs(storeSlug, storeId, settings) {
         // that leads to an empty page. `undefined` means the count query FAILED,
         // not zero, so the tab stays visible rather than hiding real stock
         // behind a swallowed error (Root Cause #59).
-        const count = listingCounts[tab.id];
+        // TOTAL, not the badge: a tab whose rows have all ended still has an
+        // archive behind the Ended/All scopes, and hiding it would strand that.
+        const count = listingCounts.total[tab.id];
         return count === undefined || count > 0;
     });
     const dropdownTabs = visibleStoreTabs.map((tab) => ({
         value: tab.id,
-        label: tabLabel(tab.label, listingCounts[tab.id]),
+        label: tabLabel(tab.label, listingCounts.available[tab.id]),
         href: STORE_LISTING_HREF[tab.id](storeSlug),
     }));
     const tabs = [

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

@@ -299,7 +299,7 @@ function buildMetricCache(ctx, bucket, now, onSaturated) {
  * The owner's contact details, resolved once per owner.
  *
  * 🛑 This is how the seller's `notifyChannels` is HONOURED rather than
- * ignored. `sendNotification` decides email and WhatsApp eligibility itself
+ * ignored. `sendNotification` decides email eligibility itself
  * (type gate → admin allow-list → user prefs → daily budget) and takes no
  * channel list — but it cannot email an address it was not given. So omitting
  * `userEmail` when the seller did not tick email is a real narrowing through
@@ -389,9 +389,6 @@ export async function runAnalyticsAlertEvaluate(ctx) {
                 ...(alert.notifyChannels?.includes("email") && contact.email
                     ? { userEmail: contact.email }
                     : {}),
-                ...(alert.notifyChannels?.includes("whatsapp") && contact.phone
-                    ? { userPhone: contact.phone }
-                    : {}),
                 audience: b.scope === "admin" ? "admin" : "seller",
             });
         };
@@ -429,7 +426,7 @@ export async function runAnalyticsAlertEvaluate(ctx) {
                  *
                  * If the notification throws, the cooldown has still been recorded —
                  * so a persistently failing channel cannot turn into one attempt per
-                 * run forever. The inverse order would retry a broken WhatsApp send
+                 * run forever. The inverse order would retry a broken send
                  * every hour against a 100/day email allowance.
                  */
                 await ctx.db

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

@@ -11,9 +11,7 @@
 import { runWeeklyPayoutEligibility } from "./weeklyPayoutEligibility.js";
 import { runHardBanCascade } from "./hardBanCascade.js";
 import { runResetOtpVerification } from "./resetOtpVerification.js";
-import { runWhatsAppNotify } from "./whatsappNotify.js";
 import { runNewsletterExport } from "./newsletterExport.js";
-import { runWhatsAppCatalogImport } from "./whatsappCatalogImport.js";
 import { runStoreNameBackfill } from "./storeNameBackfill.js";
 import { runCategoryTaxonomyBackfill } from "./categoryTaxonomyBackfill.js";
 async function runPayoutsWeeklyJob(_payload, ctx) {
@@ -42,15 +40,9 @@ async function runHardBanCascadeJob(payload, ctx) {
 async function runResetOtpVerificationJob(_payload, ctx) {
     return runResetOtpVerification(ctx);
 }
-async function runWhatsAppNotifyJob(payload, ctx) {
-    return runWhatsAppNotify(payload, ctx);
-}
 async function runNewsletterExportJob(_payload, ctx) {
     return runNewsletterExport(ctx);
 }
-async function runWhatsAppCatalogImportJob(payload, ctx) {
-    return runWhatsAppCatalogImport({ storeSlug: String(payload.storeSlug ?? "") }, ctx);
-}
 async function runStoreNameBackfillJob(payload, ctx) {
     return runStoreNameBackfill({ storeId: String(payload.storeId ?? "") }, ctx);
 }
@@ -68,9 +60,7 @@ export const JOB_RUNNERS = {
     payoutsWeekly: runPayoutsWeeklyJob,
     hardBanCascade: runHardBanCascadeJob,
     resetOtpVerification: runResetOtpVerificationJob,
-    whatsappNotify: runWhatsAppNotifyJob,
     newsletterExport: runNewsletterExportJob,
-    whatsappCatalogImport: runWhatsAppCatalogImportJob,
     storeNameBackfill: runStoreNameBackfillJob,
     categoryTaxonomyBackfill: runCategoryTaxonomyBackfillJob,
 };