@mohasinac/appkit 4.53.2 → 4.54.0

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

@@ -28,7 +28,7 @@ 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, unavailableClausesFor, } from "../../../shared/listing-types/_registry.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";
@@ -105,21 +105,63 @@ function bundleMatchesScope(bundle, scope) {
  */
 async function unavailableByType(scope, types, now) {
     const byType = new Map();
-    const clauses = unavailableClausesFor(types);
-    if (clauses.length === 0)
-        return { byType, truncated: false };
+    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(clauses.map(async (clause) => {
-        // An inequality must be ordered by its own field — Firestore appends it
-        // to the `orderBy` implicitly, so any other sort demands a composite
-        // index nobody declared (Root Cause #59).
+    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")
-            : sortBy(PRODUCT_FIELDS.CREATED_AT, "DESC");
+            : undefined;
         try {
-            return await productRepository.list({
+            const result = await productRepository.list({
                 filters: sieveAnd(sieveFilter(PRODUCT_FIELDS.STATUS, SIEVE_OP.EQ, status), clauseToSieve(clause, now)),
-                sorts,
+                ...(sorts ? { sorts } : {}),
                 page: 1,
                 pageSize: PUBLIC_PRODUCT_MAX_PAGE_SIZE,
             }, {
@@ -127,26 +169,37 @@ async function unavailableByType(scope, types, now) {
                 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 every badge on the
-            // page rather than a transient blip.
-            serverLogger.error(`listingTabCounts: unavailable clause failed (${clause.field} ${clause.op}); badges fall back to totals`, { field: clause.field, op: clause.op, error: e.message });
-            return null;
+            // 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();
-    let truncated = false;
-    for (const result of results) {
+    for (const { entry, result } of results) {
         if (!result) {
-            truncated = true;
+            for (const type of entry.types)
+                unknown.add(type);
             continue;
         }
         const rows = result.items;
-        if (rows.length >= PUBLIC_PRODUCT_MAX_PAGE_SIZE)
-            truncated = true;
+        // 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))
@@ -160,7 +213,7 @@ async function unavailableByType(scope, types, now) {
         const type = normalizeListingType(row);
         byType.set(type, (byType.get(type) ?? 0) + 1);
     }
-    return { byType, truncated };
+    return { byType, unknown };
 }
 /** The listing types one tab spans — `"art|stickers"` is a pipe OR-group. */
 function typesOf(tab) {
@@ -194,15 +247,18 @@ export async function listingTabCounts(tabs, scope, opts) {
     const total = {};
     const available = {};
     for (const tab of listingTabs) {
+        const tabTypes = typesOf(tab);
         const totalForTab = typeCounts[String(tab.listingType)];
         total[tab.id] = totalForTab;
-        if (totalForTab === undefined || unavailable.truncated) {
-            // Unknown beats a number that is quietly too high. Falling back to the
-            // total reproduces the pre-2026-10-20 badge rather than inventing one.
+        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 = typesOf(tab).reduce((sum, type) => sum + (unavailable.byType.get(type) ?? 0), 0);
+        const gone = tabTypes.reduce((sum, type) => sum + (unavailable.byType.get(type) ?? 0), 0);
         available[tab.id] = Math.max(0, totalForTab - gone);
     }
     if (wantsBundles) {

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/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,
 };

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

@@ -1,77 +1,7 @@
 import { normalizeError } from "../../../../errors/normalize.js";
 import { ORDER_PII_FIELDS, revealPii } from "../../../../security/index.js";
-import { adminNotificationsRepository, storeRepository, userRepository } from "../../../../repositories/index.js";
-import { decryptPii } from "../../../../security/index.js";
-import { sendWhatsAppBusinessMessage, buildPurchaseAnnouncementMessage, } from "../../../../features/whatsapp-bot/server.js";
-import { resolveKeys } from "../../../../core/integration-keys.js";
-import { guardSend, logSuppressedSend } from "../../notifications/send-guard.js";
-async function sendAnnouncement(ctx, toPhone, message, phoneNumberId, accessToken, label, orderId) {
-    try {
-        const sent = await sendWhatsAppBusinessMessage({
-            toPhone,
-            message,
-            phoneNumberId,
-            accessToken,
-        });
-        if (sent) {
-            ctx.logger.info(`Announcement sent to ${label}`, {
-                orderId,
-                toPhone: `...${toPhone.slice(-4)}`,
-            });
-        }
-        else {
-            ctx.logger.error(`Announcement delivery failed for ${label} (non-fatal)`, null, { orderId });
-        }
-    }
-    catch (err) {
-        void normalizeError(err);
-        ctx.logger.error(`Announcement send threw for ${label} (non-fatal)`, err, { orderId });
-    }
-}
-async function notifyStoreOwner(ctx, storeId, message, phoneNumberId, accessToken, orderId) {
-    try {
-        const store = await storeRepository.findBySlug(storeId);
-        if (!store?.ownerId)
-            return;
-        const owner = await userRepository.findById(store.ownerId);
-        const encryptedPhone = owner?.phoneNumber;
-        if (!encryptedPhone)
-            return;
-        const ownerPhone = decryptPii(encryptedPhone);
-        if (ownerPhone) {
-            await sendAnnouncement(ctx, ownerPhone, message, phoneNumberId, accessToken, "store-owner", orderId);
-        }
-    }
-    catch (err) {
-        void normalizeError(err);
-        ctx.logger.error("Store owner lookup failed (non-fatal)", err, { orderId, storeId });
-    }
-}
-/**
- * Seeded credentials are `*_PLACEHOLDER` strings rather than empty, so an
- * emptiness test alone would happily send with a fake token. Mirrors the guard
- * in checkout-value-otp-actions.ts.
- */
-function usable(value) {
-    const v = value?.trim() ?? "";
-    return v && !v.includes("PLACEHOLDER") ? v : "";
-}
-async function resolveWhatsAppCredentials(ctx, orderId) {
-    let db = {};
-    try {
-        db = await resolveKeys();
-    }
-    catch (err) {
-        void normalizeError(err);
-        // Firestore unreachable from the Functions runtime — env-only is still a
-        // valid configuration, so this is a warning, not a failure.
-        ctx.logger.warn("Credential lookup failed — falling back to env", { orderId });
-    }
-    return {
-        phoneNumberId: usable(db.whatsappPhoneNumberId) || usable(ctx.env("WHATSAPP_PHONE_NUMBER_ID")),
-        accessToken: usable(db.whatsappCloudApiToken) || usable(ctx.env("WHATSAPP_CLOUD_API_TOKEN")),
-    };
-}
+import { adminNotificationsRepository } from "../../../../repositories/index.js";
+import { buildPurchaseAnnouncementMessage } from "../../../../features/orders/utils/order-announcement-message.js";
 export async function handleOrderCreate(input, ctx) {
     const { orderId, order } = input;
     const items = order.items ?? [];
@@ -140,37 +70,13 @@ export async function handleOrderCreate(input, ctx) {
         ctx.logger.error("Failed to write admin order notification (non-fatal)", err, { orderId });
     }
     /*
-     * Seller side keeps WhatsApp: it is ONE message to ONE person about their
-     * own sale, which is the case the channel is good at. Credentials resolve
-     * DB-first (Admin → Site Settings → WhatsApp) with an env fallback — this
-     * read `ctx.env()` only until 2026-08-22, so credentials saved in Site
-     * Settings never reached the announcement and it silently no-op'd.
+     * The seller is told about their own sale by the `order_placed`
+     * notification `createOrderForGroup` already sends (in-app + email). This
+     * handler used to ALSO push a WhatsApp Cloud API message here — a duplicate
+     * channel for the same event, and the only thing in this file that needed a
+     * Meta token, a registered number and a billing relationship. Removed with
+     * the rest of the WhatsApp integration on 2026-10-20; no signal was lost,
+     * because the notification path is independent and unchanged.
      */
-    const storeId = order.storeId;
-    if (!storeId) {
-        ctx.logger.info("Order has no storeId — nothing to announce to a seller", { orderId });
-        return;
-    }
-    const { phoneNumberId, accessToken } = await resolveWhatsAppCredentials(ctx, orderId);
-    if (!phoneNumberId || !accessToken) {
-        ctx.logger.info("WhatsApp Cloud API not configured — skipping seller announcement", { orderId });
-        return;
-    }
-    // Audience is "user": a seller receiving news of their own sale is a
-    // marketplace participant, not an operator of the site. Staff exemption is
-    // for the digest and the payout summary, and widening it to "anyone we think
-    // ought to see this" would make the kill switch mean nothing.
-    const guard = {
-        channel: "whatsapp",
-        feature: "order_placed_seller",
-        audience: "user",
-    };
-    const decision = await guardSend(guard);
-    if (!decision.allow) {
-        logSuppressedSend(guard, decision);
-        ctx.logger.info("Seller order announcement suppressed by messaging guard", { orderId, storeId });
-        return;
-    }
-    await notifyStoreOwner(ctx, storeId, message, phoneNumberId, accessToken, orderId);
-    ctx.logger.info(`Order announcement complete`, { orderId, storeId });
+    ctx.logger.info("Order announcement complete", { orderId, storeId: order.storeId ?? null });
 }

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

@@ -6,8 +6,6 @@ export type OrderAfter = {
     userEmail: string;
     productTitle: string;
     trackingNumber?: string;
-    /** Buyer opted into the ₹10 WhatsApp order-updates addon at checkout. */
-    whatsappNotifyAddon?: boolean;
 };
 export type OrderBefore = {
     status: OrderStatus;

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

@@ -54,7 +54,6 @@ export async function handleOrderStatusChange(input, ctx) {
             relatedId: orderId,
             relatedType: "order",
             userEmail,
-            orderWhatsappAddonPaid: after.whatsappNotifyAddon === true,
         });
         // The RTDB mirror that used to live here has been removed. `sendNotification`
         // above is the real path (in-app + email + WhatsApp); the extra

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

@@ -30,7 +30,6 @@ export async function handleScamReportCreate(input, ctx) {
                 relatedId: scammerId,
                 relatedType: "scammer",
                 userEmail: reporterPlain?.email ?? undefined,
-                userPhone: reporterPlain?.phoneNumber ?? undefined,
             });
         }
         catch (err) {

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

@@ -28,7 +28,6 @@ export async function handleScamReportRejected(input, ctx) {
             relatedId: scammerId,
             relatedType: "scammer",
             userEmail: reporterPlain?.email ?? undefined,
-            userPhone: reporterPlain?.phoneNumber ?? undefined,
         });
     }
     catch (err) {

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

@@ -28,7 +28,6 @@ export async function handleScamReportVerified(input, ctx) {
             relatedId: scammerId,
             relatedType: "scammer",
             userEmail: reporterPlain?.email ?? undefined,
-            userPhone: reporterPlain?.phoneNumber ?? undefined,
         });
     }
     catch (err) {

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

@@ -56,7 +56,6 @@ export async function runPaymentWindowTimeout(ctx) {
                 message: ORDER_MESSAGES.CANCELLED_PAYMENT_WINDOW_MESSAGE(entry.data.productTitle),
                 relatedId: entry.id,
                 relatedType: "order",
-                orderWhatsappAddonPaid: entry.data.whatsappNotifyAddon === true,
             });
         }
         catch (err) {

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

@@ -67,7 +67,6 @@ export async function runPendingOrderTimeout(ctx) {
                 message: ORDER_MESSAGES.CANCELLED_TIMEOUT_MESSAGE(entry.data.productTitle, timeoutHours),
                 relatedId: entry.id,
                 relatedType: "order",
-                orderWhatsappAddonPaid: entry.data.whatsappNotifyAddon === true,
             });
         }
         catch (err) {

package/dist/_internal/server/notifications/channel-health.d.ts

@@ -1,5 +1,5 @@
 /**
- * Circuit breaker for outbound notification channels (email, WhatsApp).
+ * Circuit breaker for outbound notification channels.
  *
  * Persisted as a singleton Firestore doc `system/channelHealth` so the
  * "is this channel currently known-bad" state survives across requests and
@@ -9,7 +9,11 @@
  * provider). After the cooldown, the next attempt is a half-open probe:
  * its own outcome decides whether the circuit re-closes or re-opens.
  */
-export type NotificationChannel = "email" | "whatsapp";
+/**
+ * Email is the only outbound channel with a transport. "whatsapp" was the
+ * other arm until 2026-10-20, when the Cloud API integration was removed.
+ */
+export type NotificationChannel = "email";
 /**
  * Returns false only when the circuit is open and still within its cooldown
  * window. Any other state (closed, or open-but-cooldown-elapsed) is treated
@@ -20,7 +24,7 @@ export declare function recordChannelOutcome(channel: NotificationChannel, succe
 /**
  * Runs `fn` up to 3 times (500ms then 1.5s between attempts) and records the
  * final outcome against the channel's health state. `fn` must throw on
- * failure — for a helper that returns a boolean instead (e.g. the WhatsApp
+ * failure — for a helper that returns a boolean instead (e.g. a sender
  * Cloud API helpers), convert `false` into a thrown error at the call site
  * before passing it in.
  */

package/dist/_internal/server/notifications/channel-health.js

@@ -1,5 +1,5 @@
 /**
- * Circuit breaker for outbound notification channels (email, WhatsApp).
+ * Circuit breaker for outbound notification channels.
  *
  * Persisted as a singleton Firestore doc `system/channelHealth` so the
  * "is this channel currently known-bad" state survives across requests and
@@ -72,7 +72,7 @@ function delay(ms) {
 /**
  * Runs `fn` up to 3 times (500ms then 1.5s between attempts) and records the
  * final outcome against the channel's health state. `fn` must throw on
- * failure — for a helper that returns a boolean instead (e.g. the WhatsApp
+ * failure — for a helper that returns a boolean instead (e.g. a sender
  * Cloud API helpers), convert `false` into a thrown error at the call site
  * before passing it in.
  */

package/dist/_internal/server/notifications/send-guard.d.ts

@@ -15,7 +15,7 @@
  * message.
  *
  * The guarantee that nothing bypasses this is STRUCTURAL instead: the guard
- * argument is REQUIRED on `sendEmail` and on both WhatsApp senders, so an
+ * argument is REQUIRED on `sendEmail`, so an
  * unguarded send does not typecheck, and `scripts/audit-unguarded-send.mjs`
  * fails the build on a raw `createResendProvider().send()`. Make the wrong
  * thing unrepresentable rather than adding a second layer of defence that has

package/dist/_internal/server/notifications/send-guard.js

@@ -15,7 +15,7 @@
  * message.
  *
  * The guarantee that nothing bypasses this is STRUCTURAL instead: the guard
- * argument is REQUIRED on `sendEmail` and on both WhatsApp senders, so an
+ * argument is REQUIRED on `sendEmail`, so an
  * unguarded send does not typecheck, and `scripts/audit-unguarded-send.mjs`
  * fails the build on a raw `createResendProvider().send()`. Make the wrong
  * thing unrepresentable rather than adding a second layer of defence that has
@@ -69,9 +69,7 @@ export async function guardSend(ctx) {
     if (ctx.audience === "user" && !ctx.transactional) {
         const channelEnabled = ctx.channel === "email"
             ? (messaging?.emailEnabled ?? MESSAGE_BUDGET_DEFAULTS.emailEnabled)
-            : ctx.channel === "whatsapp"
-                ? (messaging?.whatsappEnabled ?? MESSAGE_BUDGET_DEFAULTS.whatsappEnabled)
-                : false; // sms has no sender; if one appears it starts disabled.
+            : false; // sms has no sender; if one appears it starts disabled.
         if (!channelEnabled) {
             return {
                 allow: false,

package/dist/_internal/shared/actions/action-registry.d.ts

@@ -29,7 +29,7 @@ import type { IconKey } from "../../../ui/icons/icon-registry";
 /** What KIND of action — drives default UI affordance (link vs button vs danger). */
 export type ActionKind = "primary" | "secondary" | "danger" | "ghost" | "link" | "chip";
 /** Resource bucket — keyed top-level in the ACTIONS tree. */
-export type ActionResource = "PRODUCT" | "AUCTION" | "PRE_ORDER" | "PRIZE_DRAW" | "DIGITAL_CODE" | "BUNDLE" | "GROUP" | "CATEGORY" | "BRAND" | "SUBLISTING" | "STORE" | "BLOG" | "EVENT" | "SHIPMENT" | "CATALOGUE" | "USER" | "SELLER" | "ADMIN" | "CART" | "CHECKOUT" | "NAV" | "MEDIA" | "SUPPORT" | "LOTTERY" | "TESTER";
+export type ActionResource = "PRODUCT" | "AUCTION" | "PRE_ORDER" | "PRIZE_DRAW" | "DIGITAL_CODE" | "BUNDLE" | "GROUP" | "CATEGORY" | "BRAND" | "SUBLISTING" | "STORE" | "BLOG" | "EVENT" | "REVIEW" | "SHIPMENT" | "CATALOGUE" | "USER" | "SELLER" | "ADMIN" | "CART" | "CHECKOUT" | "NAV" | "MEDIA" | "SUPPORT" | "LOTTERY" | "TESTER";
 /** Confirmation modal config — when set, <Button action={...}> opens
  *  a confirm dialog before firing the actual handler. */
 export interface ActionConfirmation {