@mohasinac/appkit 4.43.0 → 4.44.0

package/dist/features/categories/schemas/index.js

@@ -47,6 +47,97 @@ export const bundleQueryRuleSchema = z.discriminatedUnion("type", [
         limit: z.number().int().positive(),
     }),
 ]);
+/*
+ * ── Category-owned content (B3), mirrored here in B5 ────────────────────────
+ *
+ * 🛑 These three were added to `CategoryDocument` in B3 and NOT to this
+ * schema, which is the drift this file has a history of: `highlights` and
+ * `faqs` sat in the interface with no mirror for months, and nothing enforces
+ * parity between the two. Mirroring them is what lets the admin category
+ * editor (C2) validate a template body server-side instead of trusting the
+ * form.
+ */
+export const categoryDescriptionTemplateSchema = z.object({
+    id: z.string(),
+    label: z.string(),
+    variant: z.enum(["default", "new_in_box", "new_in_packet", "pre_owned", "replica"]),
+    body: z.string(),
+    /** Absent means "re-parse", never "no slots" — see the field's own doc. */
+    placeholders: z.array(z.string()).optional(),
+    isTested: z.boolean().optional(),
+    version: z.number().int().optional(),
+});
+export const categorySpecificationSchema = z.object({
+    name: z.string(),
+    value: z.string(),
+    unit: z.string().optional(),
+});
+export const categoryPriceGuidanceSchema = z.object({
+    currency: z.literal("INR"),
+    market: z
+        .object({
+        median: rupeesSchema,
+        // Optional on purpose — see the field docs in category-content.ts. The
+        // crawl measured quartiles for some verticals and a median-plus-range
+        // for others, and a required p25 would force a range to be retyped as a
+        // quartile.
+        p25: rupeesSchema.optional(),
+        p75: rupeesSchema.optional(),
+        sampleSize: z.number().int().positive().optional(),
+        asOf: firestoreDateSchema,
+        soldOutShare: z.number().min(0).max(1).optional(),
+        source: z.string().optional(),
+    })
+        .optional(),
+    /*
+     * 🛑 No `.default()` anywhere in here. An absent `sold` means "we have no
+     * sales yet" and a zeroed one would render as "things sell here for ₹0" —
+     * which is worse than silence, and is exactly what a defaulting schema would
+     * manufacture on the first quiet night.
+     */
+    sold: z
+        .object({
+        min: rupeesSchema,
+        median: rupeesSchema,
+        max: rupeesSchema,
+        sampleSize: z.number().int().positive(),
+        windowDays: z.number().int().positive(),
+        byPath: z
+            .object({
+            standard: z.number().int().nonnegative().optional(),
+            auction: z.number().int().nonnegative().optional(),
+            offer: z.number().int().nonnegative().optional(),
+        })
+            .optional(),
+    })
+        .optional(),
+    lastSold: z
+        .object({
+        amount: rupeesSchema,
+        at: firestoreDateSchema,
+        via: z.enum(["standard", "auction", "offer"]).optional(),
+    })
+        .optional(),
+});
+export const categoryProductDefaultsSchema = z.object({
+    taxCodeId: z.string().optional(),
+    specifications: z.array(categorySpecificationSchema).optional(),
+    defaultFeatures: z.array(z.string()).optional(),
+    defaultCondition: z.string().optional(),
+    defaultAuthenticity: z.enum(["original", "reproduction", "unverified"]).optional(),
+    inTheBox: z.array(z.string()).optional(),
+    priceGuidance: categoryPriceGuidanceSchema.optional(),
+    seoTitleTemplate: z.string().optional(),
+    seoDescriptionTemplate: z.string().optional(),
+    seoKeywords: z.array(z.string()).optional(),
+    weightG: z.number().nonnegative().optional(),
+    dimensionsCm: z
+        .object({ l: z.number().positive(), w: z.number().positive(), h: z.number().positive() })
+        .optional(),
+    shippingPaidBy: z.string().optional(),
+    fragile: z.boolean().optional(),
+    faqTemplates: z.array(z.object({ question: z.string(), answer: z.string() })).optional(),
+});
 export const bundleItemDetailSchema = z.object({
     productId: z.string(),
     drawCount: z.number().int().nonnegative().optional(),
@@ -78,6 +169,11 @@ export const categoryFirestoreSchema = z.object({
     brandFounded: z.number().int().optional(),
     highlights: z.array(z.string()).optional(),
     faqs: z.array(z.object({ question: z.string(), answer: z.string() })).optional(),
+    aliases: z.array(z.string()).optional(),
+    contentBody: z.string().optional(),
+    descriptionTemplates: z.array(categoryDescriptionTemplateSchema).optional(),
+    productDefaults: categoryProductDefaultsSchema.optional(),
+    searchTxt: z.array(z.string()).optional(),
     bundleKind: z.enum(["special", "brand"]).optional(),
     brandSlug: z.string().optional(),
     bundlePrice: rupeesSchema.optional(),

package/dist/features/categories/server.d.ts

@@ -7,3 +7,4 @@ export * from "./actions";
 export { CategoriesRepository, categoriesRepository, } from "./repository/categories.repository";
 export { GET as categoriesGET, GET, POST } from "./api/route";
 export { categoryItemGET, categoryItemPATCH, categoryItemDELETE, } from "./api/[id]/route";
+export { GET as categoryDescriptionTemplateGET } from "./api/[id]/description-template/route";

package/dist/features/categories/server.js

@@ -7,3 +7,10 @@ export * from "./actions";
 export { CategoriesRepository, categoriesRepository, } from "./repository/categories.repository";
 export { GET as categoriesGET, GET, POST } from "./api/route";
 export { categoryItemGET, categoryItemPATCH, categoryItemDELETE, } from "./api/[id]/route";
+/*
+ * The seller form's template read. A separate route rather than a field on
+ * `categoryItemGET` because that one returns the whole document and is not
+ * edge-cached — this is a narrow, hour-cacheable answer to one question, hit
+ * on every category change in the form.
+ */
+export { GET as categoryDescriptionTemplateGET } from "./api/[id]/description-template/route";

package/dist/features/categories/types/index.d.ts

@@ -57,6 +57,15 @@ export interface CategoryItem {
     metrics?: CategoryMetrics;
     isFeatured?: boolean;
     featuredPriority?: number;
+    /**
+     * Whether the category is live. Declared here because `AdminCategoriesView`
+     * reads it off THIS route to render its Status column, and its fallback is
+     * `toStringValue(item.status, "Active")` — a field `CategoryDocument` does
+     * not have. So an absent `isActive` does not render "unknown", it renders
+     * **every row as "Active"**, which is the same silent-wrong-value shape the
+     * `parentId` comment in that file documents.
+     */
+    isActive?: boolean;
     /** @deprecated Use categoryType === "brand" */ isBrand?: boolean;
     seo?: CategorySeo;
     display?: CategoryDisplay;

package/dist/features/events/schemas/firestore.d.ts

@@ -16,9 +16,9 @@ export interface EventDocument extends BaseDocument {
     title: string;
     description: string;
     status: EventStatus;
-    /** Tester sandbox flag — set on the shared admin-seeded test event; swept by testerSandboxCleanup. */
+    /** Test-data flag — set on the shared admin-seeded test event; swept by testDataCleanup. */
     isTestData?: boolean;
-    /** When isTestData, the cutoff after which testerSandboxCleanup deletes this doc. */
+    /** When isTestData, the cutoff after which testDataCleanup deletes this doc. */
     testDataExpiresAt?: Date;
     startsAt: Date;
     endsAt: Date;

package/dist/features/faq/schemas/firestore.d.ts

@@ -4,6 +4,7 @@
 import type { FAQCategory, FAQAnswer, FAQStats } from "../types";
 export type { FAQCategory, FAQAnswer, FAQStats } from "../types";
 import type { BaseDocument } from "../../../_internal/shared/types/base-document";
+import { extractPlaceholders } from "../../../_internal/shared/templating/placeholders";
 export interface FAQSEO {
     slug: string;
     metaTitle?: string;
@@ -53,7 +54,7 @@ export declare const faqQueryHelpers: {
     readonly byTag: (tag: string) => readonly ["tags", "array-contains", string];
     readonly byCreator: (userId: string) => readonly ["createdBy", "==", string];
 };
-export declare function extractVariablePlaceholders(text: string): string[];
+export declare const extractVariablePlaceholders: typeof extractPlaceholders;
 export declare function usesVariableInterpolation(faq: FAQDocument): boolean;
 export declare function validateFAQVariables(faq: FAQDocument, siteSettingsVariables: Record<string, string | number>): string[];
 export declare function isPopularFAQ(faq: FAQDocument): boolean;

package/dist/features/faq/schemas/firestore.js

@@ -2,6 +2,8 @@
  * FAQ Feature Firestore Document Types & Constants
  */
 import { generateFAQId } from "../../../utils/id-generators";
+// Imported from the DEFINING module, not a barrel (Root Cause #18).
+import { extractPlaceholders, missingPlaceholders, } from "../../../_internal/shared/templating/placeholders";
 export const FAQS_COLLECTION = "faqs";
 export const FAQS_INDEXED_FIELDS = [
     "slug",
@@ -74,21 +76,31 @@ export const faqQueryHelpers = {
     byTag: (tag) => ["tags", "array-contains", tag],
     byCreator: (userId) => ["createdBy", "==", userId],
 };
-export function extractVariablePlaceholders(text) {
-    const regex = /\{\{(\w+)\}\}/g;
-    return Array.from(text.matchAll(regex), (m) => m[1]);
-}
+/*
+ * The `{{placeholder}}` grammar moved to `_internal/shared/templating/
+ * placeholders.ts` so category description templates can share it instead of
+ * carrying a second regex (Root Cause #75).
+ *
+ * These three keep their original NAMES and signatures on purpose: they have
+ * FAQ-specific behaviour layered on the shared primitive — both gate on
+ * `useSiteSettings`, and `validateFAQVariables` merges the FAQ's own
+ * `variables` over the site-settings map. That layer is why this is a
+ * re-export-with-wrapper rather than a plain re-export, and why no FAQ call
+ * site changed.
+ */
+export const extractVariablePlaceholders = extractPlaceholders;
 export function usesVariableInterpolation(faq) {
     if (!faq.useSiteSettings)
         return false;
-    return extractVariablePlaceholders(faq.answer.text).length > 0;
+    return extractPlaceholders(faq.answer.text).length > 0;
 }
 export function validateFAQVariables(faq, siteSettingsVariables) {
     if (!faq.useSiteSettings)
         return [];
-    const placeholders = extractVariablePlaceholders(faq.answer.text);
-    const available = { ...siteSettingsVariables, ...(faq.variables || {}) };
-    return placeholders.filter((v) => !(v in available));
+    return missingPlaceholders(faq.answer.text, {
+        ...siteSettingsVariables,
+        ...(faq.variables || {}),
+    });
 }
 export function isPopularFAQ(faq) {
     const { views, helpful, notHelpful } = faq.stats;

package/dist/features/orders/schemas/firestore.d.ts

@@ -180,6 +180,25 @@ export interface OrderDocumentItem {
     totalPrice: number;
     /** SB8-F â€" set when the item is a prize-draw entry; drives the reveals badge. */
     listingType?: ListingType;
+    /**
+     * The product's LEAF category, snapshotted at order time (C1).
+     *
+     * 🛑 A SNAPSHOT, not a join, and not for performance alone. `priceIndexRollup`
+     * needs to know which category band a realised sale belongs to, and this
+     * interface carried no taxonomy field at all — `bundleCategorySlug` is a
+     * bundle key, not a category — so the only route was a full products scan
+     * per run, which answers nothing for an item whose product has since been
+     * deleted.
+     *
+     * It is also the correct answer rather than the cheap one: a product
+     * re-categorised next year must not retroactively move last year's sale into
+     * a band it was never part of. Same reasoning as the `hsnCode` / `gstRate` /
+     * `finalSale` snapshots below — a past sale's facts are fixed.
+     *
+     * Absent on every order written before C1, which is why the rollup keeps the
+     * products-map fallback rather than treating absence as "no category".
+     */
+    categorySlug?: string;
     /** SB8-F â€" per-item reveal status; flips through pending â†' open â†' revealed/closed. */
     prizeRevealStatus?: "pending" | "open" | "closed" | "revealed";
     /** Set when the buyer cancels this specific line item post-order (partial cancellation). */
@@ -358,6 +377,57 @@ export interface OrderDocument extends BaseDocument {
     sgst?: number;
     /** Inter-state: buyer and seller/store pickup address are in different states. */
     igst?: number;
+    /**
+     * Taxable value of 0%-rated (EXEMPT) goods in this order — live plants and
+     * animals. **Not** part of `taxableAmount`, which covers positively-rated
+     * slices only.
+     *
+     * 🛑 Without it a mixed exempt/taxed order cannot reconcile its own invoice:
+     * `sumGroupGst` skipped exempt slices entirely, so `taxableAmount` excluded
+     * them while `items[]` included them, and the Taxable column could never
+     * sum to the summary. Exempt is a real, reportable state (nil-rated supply),
+     * not an absence.
+     */
+    exemptAmount?: number;
+    /**
+     * Per-rate rollup — taxable value and tax for each distinct `gstRate` in the
+     * order.
+     *
+     * 🛑 Required for a Rule 46-compliant invoice, which asks for taxable value
+     * and tax **per rate**. The aggregate `taxableAmount`/`gstAmount`/cgst/sgst/
+     * igst fields above lose that dimension, so a mixed 5% + 18% order could not
+     * produce a compliant document without re-deriving the split downstream —
+     * i.e. a second implementation of the loop that already computed it.
+     */
+    gstByRate?: Array<{
+        gstRate: number;
+        taxableAmount: number;
+        cgst: number;
+        sgst: number;
+        igst: number;
+        gstAmount: number;
+    }>;
+    /**
+     * OUR GST registration as it stood at the moment of supply — LetItRip is the
+     * seller of record and invoices under its own GSTIN.
+     *
+     * 🛑 Snapshotted for two independent reasons, and both matter.
+     *
+     * **Compliance**: changing our registered details must never rewrite an
+     * invoice already issued. Same discipline as `items[].hsnCode` / `gstRate` /
+     * `finalSale`, and the same reason `TaxCodeDocument` edits change future
+     * derivations only.
+     *
+     * **Access**: `gst` sits in `PRIVATE_SITE_FIELDS` — withheld from the public
+     * site-settings projection precisely because an earlier deny-list version
+     * shipped the GSTIN and registered legal name to anonymous callers (Root
+     * Cause #70). So the invoice page cannot read it from site settings, and it
+     * should not: the buyer is entitled to the GSTIN *on their own invoice*,
+     * which is an authenticated per-order read, not public data.
+     */
+    supplierGstin?: string;
+    supplierLegalName?: string;
+    supplierAddress?: string;
     emiEnabled?: boolean;
     /** Number of monthly installments the buyer chose (2–6). */
     emiTenureMonths?: number;

package/dist/features/orders/types/index.d.ts

@@ -53,6 +53,18 @@ export interface OrderItem {
      * gate reads the document, so this is a rendering hint only.
      */
     finalSale?: boolean;
+    /**
+     * HSN code and GST rate, snapshotted onto the order item at purchase.
+     *
+     * 🛑 Surfaced here because the INVOICE needs them per line and could not
+     * previously get them: `orderDocumentToOrder` mapped `tax: doc.gstAmount`
+     * and nothing else tax-related, so the buyer-facing invoice rendered
+     * `["Item", "Qty", "Price"]` and one aggregate Tax row — not because the
+     * renderer was lazy, but because the adapter never handed it a rate, an HSN
+     * or a split to show. Root Cause #57's exact shape.
+     */
+    hsnCode?: string;
+    gstRate?: 0 | 5 | 12 | 18 | 28;
 }
 /**
  * One entry on an order's timeline — the client-facing shape of
@@ -100,7 +112,50 @@ export interface Order {
     subtotal: number;
     shippingCost?: number;
     discount?: number;
+    /** Total GST — product GST plus the GST on our platform fee. */
     tax?: number;
+    /**
+     * The GST breakdown the INVOICE needs, and which the adapter did not map
+     * until 2026-10-10 — so `/user/orders/[id]/invoice` had no GSTIN, no HSN
+     * column, no rate column and one undifferentiated "Tax (GST)" row, and was
+     * therefore not Rule 46-compliant in any respect.
+     *
+     * 🛑 `taxableAmount` excludes `exemptAmount`: a 0%-rated supply is a real
+     * reportable state, not an absence, and keeping them separate is what lets
+     * the invoice's columns reconcile against its own summary.
+     */
+    taxableAmount?: number;
+    exemptAmount?: number;
+    cgst?: number;
+    sgst?: number;
+    igst?: number;
+    /**
+     * Taxable value and tax PER RATE — what Rule 46 actually asks for.
+     *
+     * ✅ This is also why no per-item `gstAmount` was added. Rule 46 requires the
+     * tax amount per **rate**, not per **line**; the per-line requirements are
+     * HSN, quantity, taxable value and rate, all of which the item already
+     * carries or derives from `price × quantity`. A per-item tax amount would be
+     * a denormalised mirror of what this array already holds — Root Cause #42's
+     * shape — so it was deliberately NOT added.
+     */
+    gstByRate?: Array<{
+        gstRate: number;
+        taxableAmount: number;
+        cgst: number;
+        sgst: number;
+        igst: number;
+        gstAmount: number;
+    }>;
+    /**
+     * Our GST registration as snapshotted on this order. A tax invoice without
+     * the supplier's GSTIN is not a tax invoice — and the invoice page cannot
+     * read it from site settings, because `gst` is in `PRIVATE_SITE_FIELDS`
+     * after an earlier deny-list projection shipped it publicly (Root Cause #70).
+     */
+    supplierGstin?: string;
+    supplierLegalName?: string;
+    supplierAddress?: string;
     total: number;
     currency: string;
     /**

package/dist/features/products/columns/index.d.ts

@@ -8,7 +8,6 @@ export declare const PRODUCT_SORT_VALUES: {
     readonly PRICE_LOW: "price";
     readonly PRICE_HIGH: "-price";
     readonly RATING_HIGH: "-avgRating";
-    readonly POPULAR: "-viewCount";
     readonly NAME_AZ: "title";
     readonly NAME_ZA: "-title";
 };

package/dist/features/products/columns/index.js

@@ -6,7 +6,11 @@ export const PRODUCT_SORT_VALUES = {
     PRICE_LOW: "price",
     PRICE_HIGH: "-price",
     RATING_HIGH: "-avgRating",
-    POPULAR: "-viewCount",
+    // 🛑 `POPULAR: "-viewCount"` removed 2026-10-10 — `viewCount` is on no
+    // document (0/72 products, 0/58 categories) and nothing writes it, so a
+    // Firestore orderBy on it excludes every row. Verified: 0 results against a
+    // valid index. See STANDARD_SORT_OPTIONS for the full writeup.
+    // `RATING_HIGH` above is fine by contrast — `avgRating` is present on 72/72.
     NAME_AZ: "title",
     NAME_ZA: "-title",
 };

package/dist/features/products/components/ProductFilters.d.ts

@@ -37,9 +37,6 @@ export declare const PRODUCT_ADMIN_SORT_OPTIONS: readonly [{
 }, {
     readonly value: string;
     readonly label: "Recently Updated";
-}, {
-    readonly value: string;
-    readonly label: "Most Viewed";
 }];
 export declare const PRODUCT_SELLER_SORT_OPTIONS: readonly [{
     readonly value: string;
@@ -68,9 +65,6 @@ export declare const PRODUCT_SELLER_SORT_OPTIONS: readonly [{
 }, {
     readonly value: string;
     readonly label: "Recently Updated";
-}, {
-    readonly value: string;
-    readonly label: "Most Viewed";
 }];
 export declare const PRODUCT_PUBLIC_SORT_OPTIONS: readonly [{
     readonly value: string;
@@ -90,9 +84,6 @@ export declare const PRODUCT_PUBLIC_SORT_OPTIONS: readonly [{
 }, {
     readonly value: string;
     readonly label: "Name: Z–A";
-}, {
-    readonly value: string;
-    readonly label: "Most Viewed";
 }];
 export declare function getProductFilterKeys(variant: ProductFilterVariant): readonly string[];
 export declare function getProductSortOptions(variant: ProductFilterVariant): ReadonlyArray<{

package/dist/features/products/components/ProductForm.d.ts

@@ -33,6 +33,32 @@ export interface ProductFormProps {
     product: ProductFormValue;
     onChange: (updated: ProductFormValue) => void;
     isReadonly?: boolean;
+    /**
+     * Show the Tax & GST section (`gstRate` + `hsnCode`). **Admin only.**
+     *
+     * 🛑 Defaults to `false`, and the default is the point. LetItRip is the
+     * seller of record and invoices under its OWN GSTIN, so a supplier choosing
+     * the tax rate on goods we invoice is a compliance hole, not a convenience.
+     * The rate is a tax determination: it belongs to the category (via
+     * `productDefaults.taxCodeId`, resolved server-side by `deriveTaxonomy`) and
+     * to the admin who maintains the tax codes.
+     *
+     * There is also a one-click foot-gun behind it. The select renders
+     * `String(gstRate ?? 0)`, so an undetermined rate DISPLAYS as "0%" — and
+     * because `0` is a deliberate exemption while `undefined` means "nobody has
+     * said" (see `ProductDocument.gstRate`), a seller who touches that control
+     * at all, even re-picking the 0% already shown, writes a hard `0` and
+     * **permanently suppresses the category derivation**: `deriveTaxonomy` only
+     * derives when `input.gstRate == null`.
+     *
+     * 🛑 The display default does NOT corrupt the field on its own. `FormField`'s
+     * select fires `onChange` from a real DOM event only, and the draft is
+     * seeded from the stored document — so an untouched save preserves
+     * `undefined`. Verified rather than assumed; an earlier plan revision
+     * asserted every save converted "nobody has said" into "exempt", and that
+     * was not true of this code.
+     */
+    canEditTax?: boolean;
     /**
      * Render a custom rich-text description editor.
      * If omitted, a standard textarea field is used.
@@ -76,5 +102,5 @@ export interface ProductFormProps {
         disabled: boolean;
     }) => React.ReactNode;
 }
-export declare function ProductForm({ product, onChange, isReadonly, renderDescriptionEditor, renderCategorySelector, renderBrandSelector, renderStoreAddressSelector, onMediaAbort, currencyPrefix, renderGroupSettings, renderGroupJoinField, }: ProductFormProps): React.JSX.Element;
+export declare function ProductForm({ product, onChange, isReadonly, canEditTax, renderDescriptionEditor, renderCategorySelector, renderBrandSelector, renderStoreAddressSelector, onMediaAbort, currencyPrefix, renderGroupSettings, renderGroupJoinField, }: ProductFormProps): React.JSX.Element;
 export {};

package/dist/features/products/components/ProductForm.js

@@ -50,7 +50,9 @@ function readFileAsDataUrl(file) {
         reader.readAsDataURL(file);
     });
 }
-export function ProductForm({ product, onChange, isReadonly = false, renderDescriptionEditor, renderCategorySelector, renderBrandSelector, renderStoreAddressSelector, onMediaAbort, currencyPrefix = "", renderGroupSettings, renderGroupJoinField, }) {
+export function ProductForm({ product, onChange, isReadonly = false, 
+/* Defaults to false — the seller path must not reach it. See the prop's docs. */
+canEditTax = false, renderDescriptionEditor, renderCategorySelector, renderBrandSelector, renderStoreAddressSelector, onMediaAbort, currencyPrefix = "", renderGroupSettings, renderGroupJoinField, }) {
     const t = useTranslations("adminProducts");
     const { upload } = useMediaUpload();
     const galleryIndexRef = useRef(0);
@@ -179,17 +181,29 @@ export function ProductForm({ product, onChange, isReadonly = false, renderDescr
                             minOfferPercent: e.target.checked
                                 ? product.minOfferPercent ?? DEFAULT_MIN_OFFER_PERCENT
                                 : undefined,
-                        }), disabled: isReadonly })] }), product.allowOffers && (_jsxs(_Fragment, { children: [_jsx(Alert, { variant: "info", title: t("formAllowOffersHelp"), children: t("formAllowOffersHelp") }), _jsx(FormField, { name: "minOfferPercent", label: t("formMinOfferPercent"), type: "number", value: String(product.minOfferPercent ?? ""), onChange: (value) => update({ minOfferPercent: Number(value) }), disabled: isReadonly, placeholder: String(DEFAULT_MIN_OFFER_PERCENT) })] })), _jsx(Heading, { level: 4, className: "mt-4", children: t("sectionTaxGst") }), _jsxs(FormGroup, { columns: 2, children: [_jsx(FormField, { name: "gstRate", label: t("formGstRate"), type: "select", 
-                        // Unset is semantically "exempt" (see ProductDocument.gstRate JSDoc),
-                        // same as 0% — default the control to 0 so the select stays a fixed
-                        // 5-option enum instead of adding a 6th "unset" placeholder entry.
-                        value: String(product.gstRate ?? 0), onChange: (value) => update({ gstRate: Number(value) }), disabled: isReadonly, options: [
-                            { value: "0", label: "0%" },
-                            { value: "5", label: "5%" },
-                            { value: "12", label: "12%" },
-                            { value: "18", label: "18%" },
-                            { value: "28", label: "28%" },
-                        ] }), _jsx(FormField, { name: "hsnCode", label: t("formHsnCode"), type: "text", value: product.hsnCode ?? "", onChange: (value) => update({ hsnCode: value }), disabled: isReadonly, placeholder: "e.g. 9503" })] }), _jsx(Heading, { level: 4, className: "mt-4", children: t("sectionConditionShipping") }), _jsxs(FormGroup, { columns: 2, children: [_jsx(FormField, { name: "condition", label: t("formCondition"), type: "select", value: product.condition || "new", onChange: (value) => update({
+                        }), disabled: isReadonly })] }), product.allowOffers && (_jsxs(_Fragment, { children: [_jsx(Alert, { variant: "info", title: t("formAllowOffersHelp"), children: t("formAllowOffersHelp") }), _jsx(FormField, { name: "minOfferPercent", label: t("formMinOfferPercent"), type: "number", value: String(product.minOfferPercent ?? ""), onChange: (value) => update({ minOfferPercent: Number(value) }), disabled: isReadonly, placeholder: String(DEFAULT_MIN_OFFER_PERCENT) })] })), canEditTax ? (_jsxs(_Fragment, { children: [_jsx(Heading, { level: 4, className: "mt-4", children: t("sectionTaxGst") }), _jsxs(FormGroup, { columns: 2, children: [_jsx(FormField, { name: "gstRate", label: t("formGstRate"), type: "select", 
+                                /*
+                                 * 🛑 "" is the UNSET option, and it is not cosmetic.
+                                 * `ProductDocument.gstRate` documents that `undefined` and `0`
+                                 * mean different things — zero is a deliberate exemption (live
+                                 * plants and animals), undefined is "nobody has said" — and
+                                 * `deriveTaxonomy` only derives the category's rate while it is
+                                 * `== null`. Collapsing unset to "0%", which this control did
+                                 * until 2026-10-10, made an undetermined rate read as exempt and
+                                 * put a hard `0` one click away.
+                                 */
+                                value: product.gstRate == null ? "" : String(product.gstRate), onChange: (value) => update({
+                                    gstRate: value === ""
+                                        ? undefined
+                                        : Number(value),
+                                }), disabled: isReadonly, options: [
+                                    { value: "", label: t("formGstRateUnset") },
+                                    { value: "0", label: "0%" },
+                                    { value: "5", label: "5%" },
+                                    { value: "12", label: "12%" },
+                                    { value: "18", label: "18%" },
+                                    { value: "28", label: "28%" },
+                                ] }), _jsx(FormField, { name: "hsnCode", label: t("formHsnCode"), type: "text", value: product.hsnCode ?? "", onChange: (value) => update({ hsnCode: value }), disabled: isReadonly, placeholder: "e.g. 9503" })] })] })) : null, _jsx(Heading, { level: 4, className: "mt-4", children: t("sectionConditionShipping") }), _jsxs(FormGroup, { columns: 2, children: [_jsx(FormField, { name: "condition", label: t("formCondition"), type: "select", value: product.condition || "new", onChange: (value) => update({
                             condition: value,
                         }), disabled: isReadonly, options: [
                             { value: "new", label: t("formConditionNew") },

package/dist/features/products/constants/sieve.d.ts

@@ -57,9 +57,6 @@ export declare const STANDARD_SORT_OPTIONS: readonly [{
 }, {
     readonly value: string;
     readonly label: "Recently Updated";
-}, {
-    readonly value: string;
-    readonly label: "Most Viewed";
 }];
 export declare const STANDARD_PUBLIC_SORT_OPTIONS: readonly [{
     readonly value: string;
@@ -79,9 +76,6 @@ export declare const STANDARD_PUBLIC_SORT_OPTIONS: readonly [{
 }, {
     readonly value: string;
     readonly label: "Name: Z–A";
-}, {
-    readonly value: string;
-    readonly label: "Most Viewed";
 }];
 export declare const AUCTION_SORT_OPTIONS: readonly [{
     readonly value: string;

package/dist/features/products/constants/sieve.js

@@ -68,7 +68,31 @@ export const STANDARD_SORT_OPTIONS = [
     { value: sortBy(PRODUCT_FIELDS.FEATURED), label: "Featured First" },
     { value: sortBy(PRODUCT_FIELDS.IS_PROMOTED), label: "Promoted First" },
     { value: sortBy(PRODUCT_FIELDS.UPDATED_AT), label: "Recently Updated" },
-    { value: sortBy(PRODUCT_FIELDS.VIEW_COUNT), label: "Most Viewed" },
+    /*
+     * 🛑 "Most Viewed" REMOVED 2026-10-10 — it returned zero products, always.
+     *
+     * It sorted by `viewCount`, and **no document has that field**: measured on
+     * production, 0 of 72 published products and 0 of 58 categories carry it.
+     * Nothing writes it either — `incrementViewCount` was removed from the
+     * render path on 2026-08-31 (correctly: a Firestore write per render) and
+     * both repositories' copies have had zero callers since.
+     *
+     * A Firestore `orderBy` EXCLUDES every document that lacks the ordering
+     * field, so this was Root Cause #100 verbatim. Confirmed against the real
+     * query shape — `status==published` + `listingType==standard`:
+     *
+     *     no sort            -> 16 rows
+     *     orderBy title      -> 16 rows
+     *     orderBy viewCount  ->  0 rows      <- and the index EXISTS
+     *
+     * So it was not a missing index. It was a served query, costing a real
+     * round trip, guaranteed to return nothing — and picking it emptied the
+     * catalogue with no error anywhere.
+     *
+     * Real view counts arrive from the `pageViews` collection (already
+     * collected on ~30 surfaces) as `metrics.views7d`/`views30d`, rolled up by
+     * the daily job. A sort can come back then, against a field that exists.
+     */
 ];
 export const STANDARD_PUBLIC_SORT_OPTIONS = [
     STANDARD_SORT_OPTIONS[0],
@@ -77,7 +101,16 @@ export const STANDARD_PUBLIC_SORT_OPTIONS = [
     STANDARD_SORT_OPTIONS[3],
     STANDARD_SORT_OPTIONS[4],
     STANDARD_SORT_OPTIONS[5],
-    STANDARD_SORT_OPTIONS[9],
+    /*
+     * 🛑 `STANDARD_SORT_OPTIONS[9]` removed — it WAS "Most Viewed", and its
+     * presence here means the zero-result sort was offered on the PUBLIC
+     * products page, not only in admin. A shopper picking it emptied the
+     * catalogue.
+     *
+     * Indices 6–8 (Featured First / Promoted First / Recently Updated) are
+     * omitted deliberately and always have been — this list is a curated public
+     * subset, not a prefix.
+     */
 ];
 // ---------------------------------------------------------------------------
 // Auctions — auction-specific base puts auctionEndDate primary