@mohasinac/appkit 4.64.1 → 4.65.0

package/dist/.build-stamp.json

@@ -1,8 +1,8 @@
 {
   "stampVersion": 1,
-  "version": "4.64.1",
-  "head": "e32e109a86e927632104a20ca85625cb9210ba77",
+  "version": "4.65.0",
+  "head": "3061d7d6d7b6dc89f57b2fa015b3e2f8243099a1",
   "branch": "main",
   "dirty": false,
-  "builtAt": "2026-10-24T02:57:20.572Z"
+  "builtAt": "2026-10-25T08:53:27.001Z"
 }

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

@@ -1145,7 +1145,7 @@ async function createOrderForGroup(group, orderType, ctx) {
      */
     const pointsOptedIn = useAllPoints === true;
     const pointsAccepted = pointsOptedIn && acceptsPoints;
-    const { pointsApplied, amountDue } = resolvePointsTender({
+    const { pointsApplied } = resolvePointsTender({
         orderTotal,
         balance: pointsAccepted ? pointsBudget.remaining : 0,
         accepted: pointsAccepted,
@@ -3496,6 +3496,23 @@ export async function verifyAndPlaceGatewayOrderAction(input) {
             phonepeOrderId: gatewayOrder.gatewayOrderId,
             transactionId: gatewayOrder.transactionId,
             shippingAddress,
+            /*
+             * 🛑 Was MISSING until 2026-10-24, and nothing reported it. The snapshot was
+             * computed ~490 lines above with a comment explaining why it must be revealed
+             * first — and then never passed, so every order settled through the gateway
+             * path lost its immutable delivery copy while the COD/UPI path (which calls
+             * `createOrderForGroup` and does pass it) kept one.
+             *
+             * Two consequences, both silent: the invoice address was not frozen at
+             * purchase time (Part 14's whole point), and `placeOfSupply` fell through to
+             * `buyerState` — so the CGST/SGST-vs-IGST split was decided by the buyer's
+             * profile state rather than the address they actually shipped to.
+             *
+             * Root Cause #39's shape exactly: two create paths, one applies a transform
+             * the other does not. Found as an unused-variable warning, which is the only
+             * signal a dropped value ever gives.
+             */
+            deliverySnapshot,
             // For the CGST/SGST vs IGST split. The TOTAL does not depend on it
             // (see createPhonePeGroupOrder), which is what let the pre-payment
             // amount be computed before this address was known.

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

@@ -39,6 +39,7 @@
  * @tag sideEffects:none
  */
 import { pluginFor } from "../../../../shared/listing-types/_registry.js";
+import { ROUTES } from "../../../../../next/routing/route-map.js";
 // Defined here, not in `_registry` — imported from the DEFINING module
 // (Root Cause #18).
 import { ALL_LISTING_TYPES } from "../../../../shared/listing-types/feature-flags.js";
@@ -82,23 +83,37 @@ export const INDEX_TYPES = [
             weight: t === "standard" ? 1.0 : 0.98,
         };
     }),
-    { key: "category", hrefTemplate: "/categories/{s}", moreHref: "/categories", weight: 0.95 },
-    { key: "brand", hrefTemplate: "/brands/{s}", moreHref: "/brands", weight: 0.9 },
-    { key: "part", hrefTemplate: "/parts/{s}", moreHref: "/parts", weight: 0.9 },
-    { key: "model", hrefTemplate: "/categories/{s}", moreHref: "/categories", weight: 0.85 },
-    { key: "store", hrefTemplate: "/stores/{s}", moreHref: "/stores", weight: 0.8 },
-    { key: "blog", hrefTemplate: "/blog/{s}", moreHref: "/blog", weight: 0.7 },
-    { key: "event", hrefTemplate: "/events/{s}", moreHref: "/events", weight: 0.7 },
-    { key: "faq", hrefTemplate: "/faqs/{s}", moreHref: "/faqs", weight: 0.6 },
-    { key: "review", hrefTemplate: "/reviews/{s}", moreHref: "/reviews", weight: 0.5 },
-    { key: "group", hrefTemplate: "/groups/{s}", moreHref: "/products", weight: 0.5 },
-    { key: "scammer", hrefTemplate: "/scams/{s}", moreHref: "/scams", weight: 0.5 },
+    /*
+     * 🛑 Built from ROUTES, exactly as the listing-type entries above are built
+     * from `pluginFor`. These ten were hand-written path literals until
+     * 2026-10-24 — sitting directly beside a block whose own comment says "One
+     * source of truth, no second mapping" and cites Root Cause #48 for the
+     * version of this bug that shipped. A renamed segment would have moved every
+     * real page and left the search index pointing at the old one, with each
+     * result rendering correctly and navigating to a 404.
+     *
+     * `{s}` is the placeholder the template engine substitutes, so the builder
+     * functions are handed it directly — the same trick `detailRoute("{s}")` uses
+     * above rather than re-deriving the shape.
+     */
+    { key: "category", hrefTemplate: ROUTES.PUBLIC.CATEGORY_DETAIL("{s}"), moreHref: String(ROUTES.PUBLIC.CATEGORIES), weight: 0.95 },
+    { key: "brand", hrefTemplate: ROUTES.PUBLIC.BRAND_DETAIL("{s}"), moreHref: String(ROUTES.PUBLIC.BRANDS), weight: 0.9 },
+    { key: "part", hrefTemplate: ROUTES.PUBLIC.PART_CLASSIFICATION("{s}"), moreHref: String(ROUTES.PUBLIC.PARTS), weight: 0.9 },
+    /* A model IS a category row, which is why it shares the category route. */
+    { key: "model", hrefTemplate: ROUTES.PUBLIC.CATEGORY_DETAIL("{s}"), moreHref: String(ROUTES.PUBLIC.CATEGORIES), weight: 0.85 },
+    { key: "store", hrefTemplate: ROUTES.PUBLIC.STORE_DETAIL("{s}"), moreHref: String(ROUTES.PUBLIC.STORES), weight: 0.8 },
+    { key: "blog", hrefTemplate: ROUTES.BLOG.ARTICLE("{s}"), moreHref: String(ROUTES.BLOG.LIST), weight: 0.7 },
+    { key: "event", hrefTemplate: ROUTES.PUBLIC.EVENT_DETAIL("{s}"), moreHref: String(ROUTES.PUBLIC.EVENTS), weight: 0.7 },
+    { key: "faq", hrefTemplate: ROUTES.PUBLIC.FAQ_CATEGORY("{s}"), moreHref: String(ROUTES.PUBLIC.FAQS), weight: 0.6 },
+    { key: "review", hrefTemplate: ROUTES.PUBLIC.REVIEW_DETAIL("{s}"), moreHref: String(ROUTES.PUBLIC.REVIEWS), weight: 0.5 },
+    { key: "group", hrefTemplate: ROUTES.PUBLIC.GROUP_DETAIL("{s}"), moreHref: String(ROUTES.PUBLIC.PRODUCTS), weight: 0.5 },
+    { key: "scammer", hrefTemplate: ROUTES.PUBLIC.SCAM_DETAIL("{s}"), moreHref: String(ROUTES.PUBLIC.SCAMS), weight: 0.5 },
     /* `/promotions` has no per-coupon page, so `{s}` is absent on purpose and
      * `hrefFor`'s replace is a no-op. Eleven rows all landing on one page would
      * be noise in the federated GROUP (which is why `search-sources.ts` omits
      * coupons), but in the index it is the difference between a code being
      * findable and not. */
-    { key: "coupon", hrefTemplate: "/promotions", moreHref: "/promotions", weight: 0.4 },
+    { key: "coupon", hrefTemplate: String(ROUTES.PUBLIC.PROMOTIONS), moreHref: String(ROUTES.PUBLIC.PROMOTIONS), weight: 0.4 },
 ];
 const facet = (pairs) => {
     const parts = pairs

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

@@ -14,6 +14,9 @@ import { PART_GLOSSARY_COLLECTION, ALL_PART_SLOTS } from "../../../../features/p
 import { serverLogger } from "../../../../monitoring/server-logger.js";
 import { PRODUCT_FIELDS } from "../../../../constants/field-names.js";
 import { PRODUCT_DETAIL_LISTING_TYPES } from "./product-detail-types.js";
+import { safeRead } from "../../../../errors/safe-read.js";
+import { siteSettingsRepository } from "../../../../repositories/index.js";
+import { ALL_BROWSE_PAGES, browsePageForPath, isBrowsePageEnabled, } from "../../../shared/listing-types/feature-flags.js";
 // Product field strings — matches consumer field-names.ts
 const PRODUCT_STATUS = "status";
 const PRODUCT_STATUS_PUBLISHED = "published";
@@ -618,17 +621,43 @@ export async function buildSitemap({ baseUrl }) {
         bey: beyUrls.length,
         part: partUrls.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 [
+    /*
+     * Drop every URL belonging to a CLOSED browse section.
+     *
+     * 🛑 A single filter over the assembled list, not a condition threaded
+     * through the eighteen fetchers above. Section URLs are emitted from several
+     * of them plus `staticPages`, so gating from the inside is five edits and
+     * five chances to miss the sixth — and `browsePageForPath` is the same rule
+     * the navbar and the footer use, so the sitemap cannot end up disagreeing
+     * with the chrome about which sections exist.
+     *
+     * Advertising a URL that answers 404 is worse than omitting it: it is Root
+     * Cause #81's host/sitemap disagreement in miniature, and it spends crawl
+     * budget on pages we have deliberately withdrawn.
+     *
+     * 🛑 Applied BEFORE the per-section digest below. The digest is what
+     * `scripts/deploy.mjs` asserts against, so counting pre-filter would log
+     * URLs the response does not carry.
+     */
+    const settings = await safeRead(() => siteSettingsRepository.findById("global"), {
+        route: "sitemap.xml",
+        key: "sitemap.siteSettings",
+        // Fails OPEN: an unreadable settings document is not evidence that a
+        // section was closed, and silently dropping the catalogue from the sitemap
+        // on a transient Firestore error is the expensive direction of this guess.
+        fallback: null,
+    });
+    const closed = new Set(ALL_BROWSE_PAGES.filter((p) => !isBrowsePageEnabled(p, settings)));
+    const keep = (entry) => {
+        if (closed.size === 0)
+            return true;
+        const path = entry.url.startsWith("http")
+            ? new URL(entry.url).pathname
+            : entry.url;
+        const page = browsePageForPath(path);
+        return page === null || !closed.has(page);
+    };
+    const all = [
         ...staticUrls,
         ...categoryUrls,
         ...brandUrls,
@@ -648,5 +677,42 @@ export async function buildSitemap({ baseUrl }) {
         ...scammerUrls,
         ...beyUrls,
         ...partUrls,
-    ];
+    ].filter(keep);
+    /*
+     * Recount AFTER the filter, and exclude a deliberately-closed section from
+     * the "produced 0 URLs" alarm.
+     *
+     * 🛑 Without this the feature would make its own monitoring cry wolf: the
+     * warning exists because `category: 0` once survived unnoticed for months,
+     * and a warning that fires every build for a reason everyone knows about is
+     * how the next real zero gets ignored. "Closed on purpose" and "broken" must
+     * not look the same in the log.
+     */
+    const sectionPage = {
+        category: "categories",
+        brand: "brands",
+        franchise: "franchise",
+        store: "stores",
+    };
+    for (const name of Object.keys(sections)) {
+        const page = sectionPage[name];
+        if (page && closed.has(page))
+            sections[name] = 0;
+    }
+    const empty = Object.entries(sections)
+        .filter(([name, n]) => n === 0 && !closed.has(sectionPage[name]))
+        .map(([name]) => name);
+    const total = all.length;
+    if (closed.size > 0) {
+        serverLogger.info("sitemap: browse section(s) closed, URLs withheld", {
+            closed: [...closed],
+        });
+    }
+    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 all;
 }

package/dist/_internal/server/features/site-settings/adapters.d.ts

@@ -39,7 +39,7 @@ import type { PublicSiteSettings } from "../../../shared/features/site-settings/
  */
 export declare const PUBLIC_SITE_SETTINGS_FIELDS: readonly ["contact", "payment", "listings", "notificationChannels", "announcementBar", "support", "navConfig", "actionConfig", "background", "watermark", "disabledRoutes", "chat", "search"];
 /** Everything else, with the reason it stays server-side. */
-export declare const PRIVATE_SITE_SETTINGS_FIELDS: readonly ["rateChanges", "id", "createdAt", "updatedAt", "credentials", "emailSettings", "legalPages", "commissions", "emi", "gst", "laborRate", "adSettings", "integrations", "platformLimits", "auctionConfig", "siteName", "tagline", "motto", "logo", "favicon", "seo", "socialLinks", "features", "shipping", "returns", "faq", "aboutContent", "navbarConfig", "footerConfig", "theme", "featuredResults", "messaging"];
+export declare const PRIVATE_SITE_SETTINGS_FIELDS: readonly ["rateChanges", "id", "createdAt", "updatedAt", "credentials", "emailSettings", "legalPages", "commissions", "emi", "gst", "laborRate", "adSettings", "integrations", "platformLimits", "auctionConfig", "siteName", "tagline", "motto", "logo", "favicon", "seo", "socialLinks", "features", "shipping", "returns", "faq", "aboutContent", "navbarConfig", "footerConfig", "theme", "featuredResults", "messaging", "whatsappFeed"];
 export interface ToPublicSiteSettingsOptions {
     /**
      * The resolved marker → wordmark → text watermark chain. Injected because

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

@@ -6,7 +6,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
+    "listings", // useListingTypeFlags + LayoutShellClient nav filter — narrowed to listings.{listingTypes,browsePages}; categoryTypes has no client reader
     "notificationChannels", // NARROWED: only {email,whatsapp,sms}.enabled — see the projection below
     "announcementBar", // the homepage banner (AdminSiteSettingsView edits it)
     /*
@@ -118,6 +118,18 @@ export const PRIVATE_SITE_SETTINGS_FIELDS = [
     // checkbox, which disables itself when email is off — is behind the admin
     // API, which returns the full document.
     "messaging",
+    /*
+     * The WhatsApp catalogue feed kill switch. Read ONLY by
+     * `/whatsapp/{storeSlug}/feed.csv`, which is a server route doing its own
+     * settings read — the same shape as `auctionConfig` above.
+     *
+     * 🛑 Deliberately NOT public, unlike its sibling `search`. That one is public
+     * because its reader is a GUEST's search box, so a server-only flag could not
+     * reach the visitor it governs. This flag's only reader is Meta's crawler
+     * fetching a CSV; no browser consults it, and publishing "catalogue feeds are
+     * currently off platform-wide" is operational detail with no client to serve.
+     */
+    "whatsappFeed",
 ];
 export function toPublicSiteSettings(doc, opts) {
     return {
@@ -137,6 +149,9 @@ export function toPublicSiteSettings(doc, opts) {
         },
         listings: {
             listingTypes: doc.listings?.listingTypes,
+            // Read by LayoutShellClient to drop nav/footer links into a closed
+            // section. `categoryTypes` is still withheld — it has no client reader.
+            browsePages: doc.listings?.browsePages,
         },
         /*
          * 🛑 Narrowed to the three booleans a client reads, not the group by

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", "allowSharedPurchase", "sharedPurchaseHandlingFee", "sharedPurchaseExtraShippingPerDestination", "isVerified", "sellerTier", "standing", "createdAt"];
 /** Everything else, with the reason it stays server-side. */
-export declare const PRIVATE_STORE_FIELDS: readonly ["whatsappNotifySubscribed", "trustedSeller", "acceptsPoints", "searchTxt", "whatsappNotifySubscribed", "updatedAt", "whatsappConfig", "adminNotes", "statusHistory", "statusHistoryTruncated", "tierLockedByAdmin", "suspensionReason", "capabilities", "customCommissionRate", "googleReviews", "shippingConfig", "emiEnabled", "pricesIncludeGst", "shippingPricing", "returnsDirectToSeller", "isFeatured", "vacationReturnDate", "isTestData", "testDataExpiresAt", "gstin", "legalName", "registeredAddress"];
+export declare const PRIVATE_STORE_FIELDS: readonly ["whatsappNotifySubscribed", "whatsappFeedEnabled", "trustedSeller", "acceptsPoints", "searchTxt", "whatsappNotifySubscribed", "updatedAt", "whatsappConfig", "adminNotes", "statusHistory", "statusHistoryTruncated", "tierLockedByAdmin", "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

@@ -104,6 +104,20 @@ export const PRIVATE_STORE_FIELDS = [
      * someone can name the client that reads it.
      */
     "whatsappNotifySubscribed",
+    /*
+     * 🛑 `whatsappFeedEnabled` — a seller's own DISTRIBUTION PLUMBING.
+     *
+     * Whether this store currently publishes `/whatsapp/{slug}/feed.csv` with
+     * rows in it. Absent means enabled, so the field is only ever present when a
+     * seller (or an admin) has switched the feed off.
+     *
+     * No public reader, which is this file's bar on its own. Beyond that, a buyer
+     * learns nothing from it — it says nothing about the goods, the price or the
+     * dispatch record — while publishing it would advertise which stores are
+     * reachable on WhatsApp at all, which is the same disclosure
+     * `whatsappNotifySubscribed` directly above is private to avoid.
+     */
+    "whatsappFeedEnabled",
     /*
      * 🛑 `trustedSeller` — OUR RISK POSTURE, not a badge.
      *

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

@@ -24,22 +24,26 @@ export declare function resolveStoreTabs(storeSlug: string, storeId: string | un
 /**
  * Where the bare `/stores/[slug]` route should land.
  *
- * Order: **About when the store has written one**, else the first
- * listing-type tab holding anything, else Coupons, else Reviews, else About.
- * `about` is always present in `tabs`, so this never falls through to nothing.
+ * Order: the first listing-type tab holding anything, else Coupons, else
+ * Reviews, else About. `about` is always present in `tabs`, so this never
+ * falls through to nothing.
  *
- * 🛑 About was promoted to first on 2026-10-21, deliberately. Previously the
- * richest listing tab always won, so any stocked store sent every visitor
- * straight to a filtered product grid — the storefront read as a search
- * result, and a seller who had written an introduction was the only person who
- * ever saw it.
+ * 🛑 About was promoted to FIRST on 2026-10-21 and REVERTED on 2026-10-24.
+ * The argument for it was that a stocked storefront opening on a filtered
+ * product grid "reads as a search result". What it actually produced is worse
+ * and was reported as a bug: `store-letitrip-official` carries a
+ * `storeDescription`, so every visit to `/stores/store-letitrip-official`
+ * 307'd to `/about` — a page with no merchandise on it — and the shop read as
+ * having **no products at all**. Measured the day of the revert: the store
+ * holds 22 published listings, its `/products` tab renders 12 of them and its
+ * WhatsApp feed emits all 22, while the landing page showed none of it.
  *
- * It is gated on the store ACTUALLY having About content rather than applied
- * unconditionally: landing on an empty About page would be strictly worse than
- * landing on products, so the old behaviour remains the fallback. The caller
- * supplies the flag because this module takes a `storeId`, not the document,
- * and giving it store-shape knowledge it does not otherwise need would make it
- * a second place that decides what "has an About" means.
+ * A storefront's job is to show stock. An introduction is a tab, and the tab
+ * is right there in the nav bar.
+ *
+ * 🛑 Do NOT re-add a `hasAboutContent` parameter to re-litigate this. It was
+ * the mechanism of the regression, not a safeguard against it: having written
+ * a description is not evidence that a shopper wants to read one.
  */
-export declare function getDefaultStoreTabPath(storeSlug: string, storeId: string | undefined, settings: SiteSettingsSnapshot, hasAboutContent?: boolean): Promise<string>;
+export declare function getDefaultStoreTabPath(storeSlug: string, storeId: string | undefined, settings: SiteSettingsSnapshot): Promise<string>;
 export {};

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

@@ -27,7 +27,7 @@ import { ROUTES } from "../../../../next/routing/route-map.js";
 import { STORE_PAGE_TABS } from "../../../../features/products/constants/listing-tabs.js";
 import { isListingTypeEnabled, isCategoryTypeEnabled } from "../../../shared/listing-types/feature-flags.js";
 import { pluginFor } from "../../../shared/listing-types/_registry.js";
-import { listingTabCounts, } from "../products/listing-tab-counts.js";
+import { listingTabCounts } from "../products/listing-tab-counts.js";
 function tabLabel(base, count) {
     if (!count)
         return base;
@@ -116,29 +116,28 @@ export async function resolveStoreTabs(storeSlug, storeId, settings) {
 /**
  * Where the bare `/stores/[slug]` route should land.
  *
- * Order: **About when the store has written one**, else the first
- * listing-type tab holding anything, else Coupons, else Reviews, else About.
- * `about` is always present in `tabs`, so this never falls through to nothing.
+ * Order: the first listing-type tab holding anything, else Coupons, else
+ * Reviews, else About. `about` is always present in `tabs`, so this never
+ * falls through to nothing.
  *
- * 🛑 About was promoted to first on 2026-10-21, deliberately. Previously the
- * richest listing tab always won, so any stocked store sent every visitor
- * straight to a filtered product grid — the storefront read as a search
- * result, and a seller who had written an introduction was the only person who
- * ever saw it.
+ * 🛑 About was promoted to FIRST on 2026-10-21 and REVERTED on 2026-10-24.
+ * The argument for it was that a stocked storefront opening on a filtered
+ * product grid "reads as a search result". What it actually produced is worse
+ * and was reported as a bug: `store-letitrip-official` carries a
+ * `storeDescription`, so every visit to `/stores/store-letitrip-official`
+ * 307'd to `/about` — a page with no merchandise on it — and the shop read as
+ * having **no products at all**. Measured the day of the revert: the store
+ * holds 22 published listings, its `/products` tab renders 12 of them and its
+ * WhatsApp feed emits all 22, while the landing page showed none of it.
  *
- * It is gated on the store ACTUALLY having About content rather than applied
- * unconditionally: landing on an empty About page would be strictly worse than
- * landing on products, so the old behaviour remains the fallback. The caller
- * supplies the flag because this module takes a `storeId`, not the document,
- * and giving it store-shape knowledge it does not otherwise need would make it
- * a second place that decides what "has an About" means.
+ * A storefront's job is to show stock. An introduction is a tab, and the tab
+ * is right there in the nav bar.
+ *
+ * 🛑 Do NOT re-add a `hasAboutContent` parameter to re-litigate this. It was
+ * the mechanism of the regression, not a safeguard against it: having written
+ * a description is not evidence that a shopper wants to read one.
  */
-export async function getDefaultStoreTabPath(storeSlug, storeId, settings, hasAboutContent) {
+export async function getDefaultStoreTabPath(storeSlug, storeId, settings) {
     const { dropdownTabs, tabs } = await resolveStoreTabs(storeSlug, storeId, settings);
-    if (hasAboutContent) {
-        const about = tabs.find((t) => t.value === "about");
-        if (about)
-            return about.href;
-    }
     return (dropdownTabs[0] ?? tabs[0]).href;
 }

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

@@ -54,7 +54,6 @@ const QUERY_LIMIT = 500;
  * uses.
  */
 const ORDERS_COLLECTION = "orders";
-const REVIEWS_COLLECTION = "reviews";
 const PAYOUTS_COLLECTION = "payouts";
 const REPORTS_COLLECTION = "reports";
 const USERS_COLLECTION = "users";
@@ -142,9 +141,15 @@ function buildMetricCache(ctx, bucket, now, onSaturated) {
         const snap = await build().limit(QUERY_LIMIT).get();
         return { value: snap.size, saturated: snap.size >= QUERY_LIMIT };
     };
-    function buildQuery() {
-        return ctx.db.collection(PRODUCT_COLLECTION);
-    }
+    /*
+     * 🛑 A `buildQuery()` helper used to sit here and was removed 2026-10-24. It
+     * was never CALLED — its only reference was `ReturnType<typeof buildQuery>` in
+     * the signature above, and since `Q` is declared one line up and the function
+     * returned `Q`, that resolved to `Q` anyway. So the whole function existed to
+     * name a type that already had a name, which is why it read as used to a human
+     * and as unused to eslint. Every caller builds its own query because each
+     * needs different `where` clauses.
+     */
     /** Seller metrics scope to the store; admin metrics span the platform. */
     const storeScoped = (q) => bucket.scope === "seller" ? q.where(PRODUCT_FIELDS.STORE_ID, "==", bucket.ownerId) : q;
     const compute = async (metric, windowHours) => {

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

@@ -219,6 +219,28 @@ export async function runCategoryTaxonomyBackfill(payload, ctx) {
                 skipped.push(doc.id);
                 continue;
             }
+            /*
+             * 🛑 PARTIAL resolution is reported, not acted on — and the distinction is
+             * the reason. `unresolved` was set here and never read until 2026-10-24, so
+             * a product carrying one dangling category id had that id silently dropped
+             * from its closure: exactly the shortening the comment above this loop warns
+             * about ("dropping it would shorten the closure and un-list the product from
+             * a category it is genuinely in").
+             *
+             * It is NOT turned into a skip, because the two causes are indistinguishable
+             * from inside this job: a dangling id may be a category that was legitimately
+             * DELETED, in which case dropping it is the correct repair, or a data error,
+             * in which case writing the short chain is the defect. Skipping would leave
+             * the first case permanently un-repaired; guessing on a job that mutates
+             * every product in a subtree is worse than reporting it.
+             */
+            if (unresolved) {
+                ctx.logger.warn("categoryTaxonomyBackfill: product has unresolvable category ids", {
+                    productId: doc.id,
+                    assigned: assignments.length,
+                    resolved: resolved.length,
+                });
+            }
             /*
              * The default is the DEEPEST assignment, and the tie-break is deliberately
              * NOT consulted here: reading counts per product would be one extra read

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

@@ -6,7 +6,6 @@ import { CATEGORY_COUNTS_COLLECTION } from "../../../../features/categories/sche
 import { ORDER_FIELDS, PRODUCT_FIELDS } from "../../../../constants/field-names.js";
 import { isListingRowAvailable } from "../../../shared/listing-types/_registry.js";
 import { QUERY_LIMIT } from "../handlers/messages.js";
-const STORES_COLLECTION = "stores";
 const ORDERS_COLLECTION = "orders";
 /** Page size for the products scan. Bounded reads, unbounded total coverage. */
 const PAGE_SIZE = 500;

package/dist/_internal/server/jobs/handlers/onCatalogueSubmittedForApproval.js

@@ -1,5 +1,5 @@
 import { adminNotificationsRepository } from "../../../../repositories/index.js";
-export const onCatalogueSubmittedForApprovalHandler = async (event, ctx) => {
+export const onCatalogueSubmittedForApprovalHandler = async (event) => {
     const before = event.before?.listingStatus;
     const after = event.after?.listingStatus;
     if (before === "pending_admin_approval" || after !== "pending_admin_approval")

package/dist/_internal/shared/features/site-settings/types.d.ts

@@ -38,17 +38,25 @@ export interface PublicSiteSettings {
         otpCheckoutThreshold?: number;
     };
     /**
-     * Which listing types the site offers — the client needs this to avoid
-     * rendering a browse tab for a type nothing will return.
+     * Which listing types the site offers, and which browse sections are open —
+     * the client needs both to avoid rendering a nav entry or a browse tab that
+     * leads somewhere nothing will return.
      *
      * Deliberately NOT the whole `listings` block: `categoryTypes` has no client
      * reader. This was `featureFlags.listingTypes` until that group was deleted
      * on 2026-08-29; the projection stayed narrow for the same reason it always
      * was — a public payload carries what a client demonstrably reads, nothing
      * more (Root Cause #70).
+     *
+     * `browsePages` HAS a client reader and must be published: `LayoutShellClient`
+     * filters the navbar, the sidebar, the mobile sheet and the footer from it.
+     * Withholding it would leave every link to a closed section in the chrome,
+     * pointing at a route that now 404s — a dead-end CTA on every page of the
+     * site, which is a worse outcome than not having the flag at all.
      */
     listings: {
         listingTypes?: NonNullable<SiteSettingsDocument["listings"]>["listingTypes"];
+        browsePages?: NonNullable<SiteSettingsDocument["listings"]>["browsePages"];
     };
     /** D9 — off by default; `enabled: false` is emitted rather than omitted, same `always-present` reasoning as `disabledRoutes` below. */
     chat?: {

package/dist/_internal/shared/features/sticker-trace/trace/segment.js

@@ -155,7 +155,6 @@ export function segmentSheet(raster, params) {
     let labelled;
     let beforeBridge;
     let merges = 0;
-    let sameMaterialDropped = 0;
     /*
      * 1 on the art path, where the flood never runs and the question of "was
      * there anything to flood through" does not arise. Reporting 0 there would
@@ -179,7 +178,19 @@ export function segmentSheet(raster, params) {
         const lines = detectLines(filtered, width, height);
         const lineBarrier = thresholdAdaptive(lines.response, width, height, params.ridgeHysteresisLow, params.ridgeHysteresisHigh);
         const material = sameMaterialScore(raster, lineBarrier, filtered, params.paperTolerance * 2);
-        sameMaterialDropped = Math.round(material.meanScore * 1000);
+        /*
+         * 🛑 `sameMaterialDropped = Math.round(material.meanScore * 1000)` used to sit
+         * here and was removed 2026-10-24: the local was assigned and never read, is
+         * not in the `diagnostics` object this function returns, and is not declared on
+         * that type — so nothing anywhere could observe it.
+         *
+         * The `sameMaterialScore` call above stays, and that distinction is the point:
+         * `material.score` feeds `mergeWeakBoundaries` a few lines down, so the pass is
+         * load-bearing even though that one derived number was not. I deleted the call
+         * first, on a grep for `sameMaterialDropped` rather than for `material` — `tsc`
+         * caught it. Re-add the metric with a declared diagnostics field if it is ever
+         * actually wanted.
+         */
         const open = new Uint8Array(width * height);
         for (let i = 0; i < open.length; i++)
             open[i] = lineBarrier[i] ? 0 : 1;

package/dist/_internal/shared/listing-types/feature-flags.d.ts

@@ -24,8 +24,62 @@ interface FeatureFlagSnapshot {
     listings?: {
         listingTypes?: Partial<Record<ListingType, boolean>>;
         categoryTypes?: Partial<Record<CategoryType, boolean>>;
+        browsePages?: Partial<Record<BrowsePageKey, boolean>>;
     };
 }
+/**
+ * A public BROWSE SECTION that can be withdrawn as a whole.
+ *
+ * 🛑 This is a THIRD axis, not a rename of either of the two above, and the
+ * distinction is what stops it becoming a duplicate control:
+ *
+ *   `listingTypes`  — what the marketplace SELLS (is there such a thing as an
+ *                     auction here?)
+ *   `categoryTypes` — what a taxonomy ROW may be (may a category row be a
+ *                     brand?)
+ *   `browsePages`   — whether a public ENTRY POINT is open (is there a /brands
+ *                     directory to walk?)
+ *
+ * They are genuinely independent. `brand` rows still tag products and still
+ * drive `BrandDetailPageView`'s query with `/brands` closed; closing the
+ * directory withdraws the front door, it does not untag the catalogue. That is
+ * why this cannot be folded into `categoryTypes` — and `categories`, `stores`
+ * and `franchise` have no `categoryTypes` member to fold into at all.
+ *
+ * `stores` covers BOTH `/stores` and `/sellers`: they are two doors onto the
+ * same directory (the footer lists them as "Stores" and "Verified Sellers"),
+ * and leaving one open while closing the other publishes exactly what the
+ * other was closed to hide.
+ */
+export type BrowsePageKey = "categories" | "brands" | "franchise" | "stores";
+export declare const ALL_BROWSE_PAGES: BrowsePageKey[];
+/**
+ * `true` when the section is missing from the flag map OR explicitly enabled.
+ *
+ * Absent-means-enabled, matching its two siblings: a section has to be
+ * EXPLICITLY `false` to close. An install that predates this setting keeps
+ * every section open, so adding the field cannot take a site's navigation away
+ * from it.
+ */
+export declare function isBrowsePageEnabled(page: BrowsePageKey, settings: FeatureFlagSnapshot | null | undefined): boolean;
+export declare function enabledBrowsePages(settings: FeatureFlagSnapshot | null | undefined): BrowsePageKey[];
+/** Narrow an untrusted string — a route param, a form value — to the union. */
+export declare function isBrowsePageKey(value: unknown): value is BrowsePageKey;
+/**
+ * Which browse section a link points into, or `null` for a link that is not in
+ * one. Used to drop nav, sidebar, mobile-sheet and footer entries for a closed
+ * section.
+ *
+ * 🛑 Matches on an EXACT path or a `/`-delimited descendant, never a bare
+ * `startsWith`. `/store` is the SELLER DASHBOARD and `/stores` is the public
+ * directory, so a prefix test would hide a signed-in seller's own dashboard
+ * link the moment an admin closed the public storefronts — a different
+ * surface, a different audience, one character apart.
+ *
+ * Query strings and hashes are tolerated because footer and nav hrefs are
+ * hand-authored and some carry them.
+ */
+export declare function browsePageForPath(href: string | undefined | null): BrowsePageKey | null;
 /**
  * `true` when the type is missing from the flag map OR explicitly enabled.
  * Defaulting to enabled keeps legacy data working — a flag has to be