@mohasinac/appkit 4.47.0 → 4.48.1

package/dist/features/products/repository/category-assignment.d.ts

@@ -11,23 +11,70 @@ export declare const MAX_CATEGORY_ASSIGNMENTS = 4;
 /**
  * 🛑 THE FLIP. `false` = the leaf/non-leaf rule REPORTS; `true` = it refuses.
  *
- * It ships `false` and is flipped only once the data is clean, and the reason is
- * a measurement: **70 of the 71 hand-authored products file at a non-leaf
- * today** and not one of them is a lot. Enforcing first would make the whole
- * catalogue unsaveable — and worse, it would make the very seed writes that fix
- * the data fail, because those also go through `deriveTaxonomy`.
+ * It ships `false` and is flipped only once the data is clean. Enforcing first
+ * would make the whole catalogue unsaveable — and worse, it would make the very
+ * seed writes that fix the data fail, because those also go through
+ * `deriveTaxonomy`.
  *
  * This is the G3a lesson, which cost a symmetric rule its credibility: the plan
  * specified "a lot takes a non-leaf while singles take leaves", measurement
  * rejected the second half, and the half-rule has been live since. The rule is
  * right; enforcing it before its data is not.
  *
- * Flip procedure, and it is a ratchet rather than a judgement call: run
- * `findLeafRuleOffenders` over every seeded row, confirm **0**, then set `true`.
- * A hand count is not the measurement — the earlier one said 58 of 70 and this
- * pass measured 70 of 71.
+ * ## 🛑 The offender count: FOUR answers, one measurement
+ *
+ * This comment asserted "**70 of the 71** hand-authored products file at a
+ * non-leaf, and not one of them is a lot". Both halves were wrong.
+ *
+ * | Claim | Where it came from |
+ * |---|---|
+ * | 58 of 70 | an early hand count |
+ * | 70 of 71 | this comment, until 2026-10-13 |
+ * | 0 | a first scripted run that measured NOTHING — see below |
+ * | **24** | `scripts/measure-leaf-offenders.mjs`, running the real rule |
+ *
+ * The real figure was **24** (23 `single-at-branch` + **1 `lot-at-leaf`**, so
+ * the "not one is a lot" half was false too), now **14** after re-filing the
+ * ten that had an exact existing leaf.
+ *
+ * The `0` is the instructive one: that script reimplemented
+ * `readAssignments`' precedence inline as "`categoryIds`, else `category`" —
+ * its first two branches only. The seed writes **neither**; it writes
+ * `categorySlugs`, and the real function takes its HEAD. So it found no
+ * assignments on any product, examined nothing, and reported the flip safe.
+ *
+ * ## Flip procedure — a ratchet, not a judgement call
+ *
+ *     node scripts/measure-leaf-offenders.mjs     # must print 0 and exit 0
+ *
+ * Never flip on a hand count, and never on a zero the script produced while
+ * reporting `unassigned === products` — it exits 2 for exactly that case now,
+ * because a zero out of a corpus nothing could be read from is not a clean
+ * result.
+ *
+ * ## ✅ FLIPPED 2026-10-14, on a measurement
+ *
+ *     products : 71 · unassigned : 0 · categories : 1177 · offenders : 0
+ *
+ * `unassigned: 0` is the half that makes the zero mean something: every
+ * product resolved to a real assignment and every one of those satisfied the
+ * rule. Getting there took three kinds of fix, and the mix is worth knowing
+ * because it is NOT what the plan predicted:
+ *
+ *   - **11 re-filed** to a leaf that already existed. Nine were also in the
+ *     wrong GENERATION, which several products' own copy already contradicted.
+ *   - **4 corpus rows promoted** out of `review` with verified facts and
+ *     stated provenance (`VERIFIED_RESOLUTIONS` in `parse-bey-corpus.mjs`).
+ *   - **10 fixtures retitled**, because they named products that do not
+ *     exist — a Burst "B-215 Hells Scythe" (every HellsScythe is Beyblade X),
+ *     a "Wizard Fafnir 4-60F" (a Burst layer with an X part code), a ring
+ *     BOOSTER and a release WAVE, neither of which can ever have a model leaf.
+ *
+ * 🛑 If this ever needs to go back to `false`, the honest reason is "the data
+ * regressed", and the measurement will say so before the flag does. Re-run the
+ * script rather than reasoning about it.
  */
-export declare const ENFORCE_LEAF_FILING = false;
+export declare const ENFORCE_LEAF_FILING = true;
 /** A category document, reduced to the fields assignment actually needs. */
 export interface ResolvedCategory {
     id: string;
@@ -73,8 +120,30 @@ export declare function readAssignments(input: {
     category?: string;
     categorySlugs?: string[];
 }): string[];
+/**
+ * 🛑 THE LEAF RULE DOES NOT APPLY TO EVERY LISTING TYPE, and measuring the data
+ * is what showed that — the rule was wrong, not the catalogue.
+ *
+ * Of the 70 non-leaf singles, **31 are types that are not an instance of a
+ * named model at all**: 8 app/coaching redemption codes, 8 city classifieds
+ * (collections, kits, spare-part bundles), 6 sticker sheets, 5 art prints and
+ * 4 live animals or plants. "Beyblade X App — Starter Pack Code" is not a
+ * Dragoon G. A golden retriever puppy has no model leaf and never will.
+ *
+ * So the rule is scoped by the SAME predicate that already answers this
+ * question for the Parts tab: does a listing of this type HAVE a part
+ * composition — i.e. IS it the assembly, or does it merely depict one. Reusing
+ * it rather than writing a second list is the point: a tenth listing type must
+ * answer the question once, not twice, and two hand-written enumerations of one
+ * union is Root Cause #61.
+ *
+ * `classified` and `live` stay `true` there, and that is deliberate: a
+ * classified CAN be a single bey, and the seeded ones that are collections are
+ * `isLot: true`, which the lot branch already permits at a non-leaf.
+ */
+export declare function leafRuleApplies(listingType: string | undefined): boolean;
 /** Which assignments break the leaf rule, and why. Reporting shape, no throw. */
-export declare function findLeafRuleOffenders(resolved: ResolvedCategory[], isLot: boolean): {
+export declare function findLeafRuleOffenders(resolved: ResolvedCategory[], isLot: boolean, listingType?: string): {
     id: string;
     name?: string;
     reason: "lot-at-leaf" | "single-at-branch" | "not-indexed";
@@ -88,6 +157,8 @@ export declare function findLeafRuleOffenders(resolved: ResolvedCategory[], isLo
  */
 export declare function assertAssignmentShape(resolved: ResolvedCategory[], isLot: boolean, opts?: {
     enforceLeafFiling?: boolean;
+    /** Scopes the SINGLE half of the leaf rule — see `leafRuleApplies`. */
+    listingType?: string;
     warn?: (msg: string, meta?: object) => void;
 }): void;
 /**

package/dist/features/products/repository/category-assignment.js

@@ -47,6 +47,7 @@
  * @tag sideEffects:none
  */
 import { ConflictError, ValidationError } from "../../../errors/index.js";
+import { LISTING_TYPE_HAS_COMPOSITION } from "../../parts/schemas/firestore.js";
 /**
  * 🛑 A CAP, because the closure is `array-contains`-indexed and Firestore's
  * `array-contains-any` takes at most 30 comparison values.
@@ -60,23 +61,70 @@ export const MAX_CATEGORY_ASSIGNMENTS = 4;
 /**
  * 🛑 THE FLIP. `false` = the leaf/non-leaf rule REPORTS; `true` = it refuses.
  *
- * It ships `false` and is flipped only once the data is clean, and the reason is
- * a measurement: **70 of the 71 hand-authored products file at a non-leaf
- * today** and not one of them is a lot. Enforcing first would make the whole
- * catalogue unsaveable — and worse, it would make the very seed writes that fix
- * the data fail, because those also go through `deriveTaxonomy`.
+ * It ships `false` and is flipped only once the data is clean. Enforcing first
+ * would make the whole catalogue unsaveable — and worse, it would make the very
+ * seed writes that fix the data fail, because those also go through
+ * `deriveTaxonomy`.
  *
  * This is the G3a lesson, which cost a symmetric rule its credibility: the plan
  * specified "a lot takes a non-leaf while singles take leaves", measurement
  * rejected the second half, and the half-rule has been live since. The rule is
  * right; enforcing it before its data is not.
  *
- * Flip procedure, and it is a ratchet rather than a judgement call: run
- * `findLeafRuleOffenders` over every seeded row, confirm **0**, then set `true`.
- * A hand count is not the measurement — the earlier one said 58 of 70 and this
- * pass measured 70 of 71.
+ * ## 🛑 The offender count: FOUR answers, one measurement
+ *
+ * This comment asserted "**70 of the 71** hand-authored products file at a
+ * non-leaf, and not one of them is a lot". Both halves were wrong.
+ *
+ * | Claim | Where it came from |
+ * |---|---|
+ * | 58 of 70 | an early hand count |
+ * | 70 of 71 | this comment, until 2026-10-13 |
+ * | 0 | a first scripted run that measured NOTHING — see below |
+ * | **24** | `scripts/measure-leaf-offenders.mjs`, running the real rule |
+ *
+ * The real figure was **24** (23 `single-at-branch` + **1 `lot-at-leaf`**, so
+ * the "not one is a lot" half was false too), now **14** after re-filing the
+ * ten that had an exact existing leaf.
+ *
+ * The `0` is the instructive one: that script reimplemented
+ * `readAssignments`' precedence inline as "`categoryIds`, else `category`" —
+ * its first two branches only. The seed writes **neither**; it writes
+ * `categorySlugs`, and the real function takes its HEAD. So it found no
+ * assignments on any product, examined nothing, and reported the flip safe.
+ *
+ * ## Flip procedure — a ratchet, not a judgement call
+ *
+ *     node scripts/measure-leaf-offenders.mjs     # must print 0 and exit 0
+ *
+ * Never flip on a hand count, and never on a zero the script produced while
+ * reporting `unassigned === products` — it exits 2 for exactly that case now,
+ * because a zero out of a corpus nothing could be read from is not a clean
+ * result.
+ *
+ * ## ✅ FLIPPED 2026-10-14, on a measurement
+ *
+ *     products : 71 · unassigned : 0 · categories : 1177 · offenders : 0
+ *
+ * `unassigned: 0` is the half that makes the zero mean something: every
+ * product resolved to a real assignment and every one of those satisfied the
+ * rule. Getting there took three kinds of fix, and the mix is worth knowing
+ * because it is NOT what the plan predicted:
+ *
+ *   - **11 re-filed** to a leaf that already existed. Nine were also in the
+ *     wrong GENERATION, which several products' own copy already contradicted.
+ *   - **4 corpus rows promoted** out of `review` with verified facts and
+ *     stated provenance (`VERIFIED_RESOLUTIONS` in `parse-bey-corpus.mjs`).
+ *   - **10 fixtures retitled**, because they named products that do not
+ *     exist — a Burst "B-215 Hells Scythe" (every HellsScythe is Beyblade X),
+ *     a "Wizard Fafnir 4-60F" (a Burst layer with an X part code), a ring
+ *     BOOSTER and a release WAVE, neither of which can ever have a model leaf.
+ *
+ * 🛑 If this ever needs to go back to `false`, the honest reason is "the data
+ * regressed", and the measurement will say so before the flag does. Re-run the
+ * script rather than reasoning about it.
  */
-export const ENFORCE_LEAF_FILING = false;
+export const ENFORCE_LEAF_FILING = true;
 /**
  * The authored assignment list, from whichever field the caller used.
  *
@@ -123,9 +171,42 @@ export function readAssignments(input) {
     }
     return out;
 }
+/**
+ * 🛑 THE LEAF RULE DOES NOT APPLY TO EVERY LISTING TYPE, and measuring the data
+ * is what showed that — the rule was wrong, not the catalogue.
+ *
+ * Of the 70 non-leaf singles, **31 are types that are not an instance of a
+ * named model at all**: 8 app/coaching redemption codes, 8 city classifieds
+ * (collections, kits, spare-part bundles), 6 sticker sheets, 5 art prints and
+ * 4 live animals or plants. "Beyblade X App — Starter Pack Code" is not a
+ * Dragoon G. A golden retriever puppy has no model leaf and never will.
+ *
+ * So the rule is scoped by the SAME predicate that already answers this
+ * question for the Parts tab: does a listing of this type HAVE a part
+ * composition — i.e. IS it the assembly, or does it merely depict one. Reusing
+ * it rather than writing a second list is the point: a tenth listing type must
+ * answer the question once, not twice, and two hand-written enumerations of one
+ * union is Root Cause #61.
+ *
+ * `classified` and `live` stay `true` there, and that is deliberate: a
+ * classified CAN be a single bey, and the seeded ones that are collections are
+ * `isLot: true`, which the lot branch already permits at a non-leaf.
+ */
+export function leafRuleApplies(listingType) {
+    if (!listingType)
+        return true;
+    return LISTING_TYPE_HAS_COMPOSITION[listingType] !== false;
+}
 /** Which assignments break the leaf rule, and why. Reporting shape, no throw. */
-export function findLeafRuleOffenders(resolved, isLot) {
+export function findLeafRuleOffenders(resolved, isLot, listingType) {
     const out = [];
+    /*
+     * The LOT half still applies to every type — filing a lot of twelve beys
+     * under one model's leaf is a false claim about the items whatever the
+     * listing type is. Only the SINGLE half is scoped.
+     */
+    if (!isLot && !leafRuleApplies(listingType))
+        return out;
     for (const c of resolved) {
         if (isLot) {
             if (c.isLeaf === true)
@@ -179,7 +260,7 @@ export function assertAssignmentShape(resolved, isLot, opts = {}) {
         throw new ValidationError(`${named} are in the same category tree, so a listing cannot be filed under both. ` +
             `Pick one, or pick the category above them that covers both.`);
     }
-    const offenders = findLeafRuleOffenders(resolved, isLot);
+    const offenders = findLeafRuleOffenders(resolved, isLot, opts.listingType);
     if (offenders.length === 0)
         return;
     /*

package/dist/features/products/repository/products.repository.d.ts

@@ -190,7 +190,18 @@ export declare class ProductRepository extends BaseRepository<ProductDocument> {
      * stock decrement or a status flip pays none of it.
      */
     private applyCategoryDefaults;
-    /** The keys whose presence means a write could change the product's taxonomy. */
+    /**
+     * The keys whose presence means a write could change the product's taxonomy.
+     *
+     * 🛑 `categoryIds` is the ASSIGNED field — the one a human picks and the one
+     * `readAssignments` prefers over the `category` scalar. It was absent from
+     * this list, so a write naming only `categoryIds` skipped `deriveTaxonomy`
+     * entirely: the ordered closure, the `category` mirror and `categoryNames`
+     * were never re-derived, and `syncCategoryCounts` compared a document to
+     * itself and moved nothing. The write returned 200 and the product's own
+     * category pages did not change. Same shape as Root Cause #101 — a field
+     * accepted on the way in whose derivation never runs.
+     */
     private static readonly TAXONOMY_KEYS;
     update(id: string, data: Partial<ProductDocument>): Promise<ProductDocument>;
     /**

package/dist/features/products/repository/products.repository.js

@@ -13,7 +13,7 @@ import { parseSearchTxtQuery } from "../../../utils/search-txt.js";
 // The shared search plan/refine the other eleven migrated collections use.
 // `planSearchTxt` carries the `empty` guard that keeps a punctuation-only query
 // from returning the whole catalogue.
-import { planSearchTxt, SEARCH_REFINE_WINDOW, refineSearchTxt, emptySearchResult, } from "../../../utils/search-txt-query.js";
+import { planSearchTxt, beginSearchWindow, emptySearchResult, } from "../../../utils/search-txt-query.js";
 // One definition of "which fields feed searchTxt", shared with the seed
 // wrapper. Three copies existed and two were missing the same three fields.
 import { buildProductSearchTxt } from "../../../utils/search-txt-builders.js";
@@ -359,6 +359,7 @@ export class ProductRepository extends BaseRepository {
         if (resolved.length > 0) {
             assertAssignmentShape(resolved, input.isLot === true, {
                 enforceLeafFiling: ENFORCE_LEAF_FILING,
+                listingType: input.listingType,
                 warn: (msg, meta) => serverLogger.warn(msg, { productTitle: input.title, ...meta }),
             });
             /*
@@ -520,15 +521,20 @@ export class ProductRepository extends BaseRepository {
             return; // an exempt item has nothing to gross up
         out.price = grossFromTaxable(input.price, effectiveRate);
         /*
-         * 🛑 `compareAtPrice` is deliberately NOT converted here, because it does
-         * not exist. `SellerProductShell`'s pricing section lists it among its
-         * `fields` and renders an input for it, but `ProductDocument` has no such
-         * property — so whatever a seller types there is stripped by the schema and
-         * never stored. A declared-but-unpersisted form field is its own defect
-         * (and a strike-through price is a money figure, so it would need the same
-         * gross-up the day it becomes real); logged rather than silently worked
-         * around, since converting a field that is discarded would be theatre.
+         * 🛑 The strike-through price is grossed up TOO, now that it is a real
+         * field (F1 #25 — it was `compareAtPrice` in the form, `originalPrice` in
+         * both renderers, and nowhere in the document).
+         *
+         * It has to move with `price` or the discount it advertises is wrong: an
+         * ex-tax ₹1,000 "was" beside an inc-tax ₹1,050 "now" renders as a price
+         * RISE, and an ex-tax pair converted on one side only overstates the
+         * saving by the GST rate. The guard is the same one `price` uses — only a
+         * patch that carries the field is converted, so an unrelated save cannot
+         * re-convert an already-converted figure.
          */
+        if (input.originalPrice != null && input.originalPrice > 0) {
+            out.originalPrice = grossFromTaxable(input.originalPrice, effectiveRate);
+        }
         serverLogger.info("[gst] grossed up an ex-tax price for a pricesIncludeGst:false store", {
             storeId: input.storeId,
             rate: effectiveRate,
@@ -1196,7 +1202,11 @@ export class ProductRepository extends BaseRepository {
         if (searchTxt.length > 0) {
             // Firestore permits a single array operator per query, so when a search
             // and a category filter are both present the SEARCH takes the clause and
-            // the category is refined by the caller.
+            // the category is refined by the caller — which, since the `also`
+            // predicate in `list()`, is now true rather than merely asserted. This
+            // comment claimed it for as long as the gate below has existed and no
+            // caller did it, so a search inside a category returned the whole
+            // catalogue.
             //
             // Two shapes here have each been reverted once and are both guarded by
             // scripts/audit-search-semantics.mjs:
@@ -1270,25 +1280,34 @@ export class ProductRepository extends BaseRepository {
          * `SEARCH_REFINE_WINDOW`, and when that saturates the result carries
          * `truncated` so the total renders as a floor rather than a false total.
          */
-        const isMultiTerm = plan.rest.length > 0;
-        const requestedPage = Math.max(1, Number(model?.page ?? 1) || 1);
-        const requestedPageSize = Math.max(1, Number(model?.pageSize ?? 20) || 20);
-        const result = await this.sieveQuery(
         /*
-         * The window is requested through the MODEL, not a new `SieveOptions`
-         * field — `sieveQuery` already derives its page from `model.page` /
-         * `model.pageSize`, so overriding them needs no API change and no second
-         * way to express a page size.
+         * ── The category filter has to be refined for the SAME reason ───────────
+         *
+         * 🛑 `buildScopedQuery` gates `categoriesIn` on `searchTxt.length === 0`,
+         * because Firestore permits one array operator per query and the search
+         * term takes it. Its comment said "the category is refined by the caller"
+         * — and NO caller did, for as long as the gate has existed. So searching
+         * inside a category silently returned matches from the whole catalogue:
+         * a plausible, populated, wrong grid with a 200 (Root Cause #62's family).
+         *
+         * This is that caller. The refine rides the same bounded window the
+         * multi-term refine already uses, so the cost is one read either way and
+         * there is no second pagination implementation to disagree with the first.
          */
-        isMultiTerm ? { ...model, page: 1, pageSize: SEARCH_REFINE_WINDOW } : model, ProductRepository.SIEVE_FIELDS, {
+        const categoriesIn = opts?.categoriesIn ?? [];
+        const needsCategoryRefine = plan.head !== null && categoriesIn.length > 0;
+        const wanted = new Set(categoriesIn);
+        /*
+         * The window, the raised `maxPageSize` and the page slice are all one
+         * decision, so they come from one helper — `beginSearchWindow`. Keeping
+         * them hand-written here is what let the other ten repositories each get
+         * two of the three.
+         */
+        const win = beginSearchWindow(model, plan, { alsoRefining: needsCategoryRefine });
+        const result = await this.sieveQuery(win.model, ProductRepository.SIEVE_FIELDS, {
             baseQuery: this.buildScopedQuery(opts),
             defaultPageSize: 20,
-            /*
-             * 🛑 `maxPageSize` has to rise with the window or Sieve clamps the
-             * request back to 100 — and the window would silently be a page again,
-             * which is the original bug with a larger constant.
-             */
-            maxPageSize: isMultiTerm ? SEARCH_REFINE_WINDOW : 100,
+            maxPageSize: win.maxPageSize(100),
             aliases: ProductRepository.FILTER_ALIASES,
         });
         // Only the most selective term became the `array-contains` clause, because
@@ -1303,14 +1322,15 @@ export class ProductRepository extends BaseRepository {
         // this page only. That is the known post-pagination-filter debt, not a new
         // invention — reporting the pre-filter total would promise pages that
         // render empty.
-        return refineSearchTxt(result, plan.rest, isMultiTerm
-            ? {
-                page: requestedPage,
-                pageSize: requestedPageSize,
-                // Saturated means more may exist beyond the window, so `total` is a
-                // FLOOR and `truncated` says so.
-                windowSaturated: (result.items?.length ?? 0) >= SEARCH_REFINE_WINDOW,
-            }
+        /*
+         * 🛑 The category predicate matches against the CLOSURE, not the leaf.
+         * `categorySlugs` carries the full ancestor chain, so a category page
+         * passing its own id matches every product in its subtree — the same
+         * semantics the pushed-down `array-contains-any` has, which is what makes
+         * the refined result identical to the un-searched one.
+         */
+        return win.finish(result, needsCategoryRefine
+            ? (row) => (row.categorySlugs ?? []).some((slug) => wanted.has(slug))
             : undefined);
     }
     /**
@@ -1412,8 +1432,20 @@ export class ProductRepository extends BaseRepository {
     }
 }
 ProductRepository.CACHE_TTL_MS = 30000;
-/** The keys whose presence means a write could change the product's taxonomy. */
+/**
+ * The keys whose presence means a write could change the product's taxonomy.
+ *
+ * 🛑 `categoryIds` is the ASSIGNED field — the one a human picks and the one
+ * `readAssignments` prefers over the `category` scalar. It was absent from
+ * this list, so a write naming only `categoryIds` skipped `deriveTaxonomy`
+ * entirely: the ordered closure, the `category` mirror and `categoryNames`
+ * were never re-derived, and `syncCategoryCounts` compared a document to
+ * itself and moved nothing. The write returned 200 and the product's own
+ * category pages did not change. Same shape as Root Cause #101 — a field
+ * accepted on the way in whose derivation never runs.
+ */
 ProductRepository.TAXONOMY_KEYS = [
+    "categoryIds",
     "categorySlugs",
     "category",
     "brand",

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

@@ -217,6 +217,28 @@ export interface ProductDocument extends BaseDocument {
     brand?: string;
     brandSlug?: string;
     price: number;
+    /**
+     * The strike-through "was ₹X", for a listing the seller is discounting.
+     *
+     * 🛑 F1 #25, and it was TWO OWNERS of one value rather than a missing field.
+     * `SellerProductShell` renders an input called `compareAtPrice` and the eight
+     * store edit pages read `(product as any).compareAtPrice` — a property no
+     * document has ever carried — while BOTH public renderers (`ProductGrid`,
+     * `ProductDetailPageView`) read `originalPrice` and hand it to `GatedPrice`
+     * as `originalAmount`, which is what draws the strike-through and derives
+     * the discount %. The consumer write schema already accepted `originalPrice`
+     * too. So the authoring half wrote one name, the rendering half read
+     * another, and the document declared neither: a seller set a sale price,
+     * saw a 200, and nothing ever showed it.
+     *
+     * Declared here under the name the renderers and the write schema already
+     * use, rather than adding a second field beside them (Root Cause #75).
+     *
+     * 🛑 It is a MONEY figure, so it is grossed up with `price` for a
+     * `pricesIncludeGst: false` store — a "was" price that silently meant
+     * ex-tax while the live price meant inc-tax would overstate the discount.
+     */
+    originalPrice?: number;
     currency: string;
     stockQuantity: number;
     availableQuantity: number;
@@ -648,8 +670,8 @@ export declare const ProductStatusValues: {
 export declare const PRODUCT_COLLECTION: "products";
 export declare const PRODUCT_INDEXED_FIELDS: readonly ["storeId", "status", "category", "categoryIds", "featured", "listingType", "isPromoted", "isOnSale", "isSold", "searchTxt", "createdAt", "barcodeId", "physicalLocation.zone"];
 export declare const DEFAULT_PRODUCT_DATA: Partial<ProductDocument>;
-export declare const PRODUCT_PUBLIC_FIELDS: readonly ["allowOffers", "minOfferPercent", "id", "title", "description", "category", "categoryIds", "categoryIdNames", "subcategory", "brand", "price", "currency", "stockQuantity", "availableQuantity", "images", "status", "storeName", "featured", "tags", "specifications", "features", "shippingInfo", "returnPolicy", "finalSale", "isLot", "lotSize", "unitLabel", "partGlossaryId", "colourway", "mouldVariant", "assembledFrom", "views7d", "views30d", "unitLabel", "partGlossaryId", "colourway", "mouldVariant", "assembledFrom", "listingType", "auctionEndDate", "startingBid", "currentBid", "bidCount", "reservePrice", "buyNowPrice", "minBidIncrement", "autoExtendable", "auctionExtensionMinutes", "auctionShippingPaidBy", "bidsHaveStarted", "grading", "card", "classified", "digitalCode", "liveItem", "catalogProductId", "preOrderDeliveryDate", "preOrderDepositPercent", "preOrderDepositAmount", "preOrderMaxQuantity", "preOrderCurrentCount", "preOrderProductionStatus", "preOrderCancellable", "condition", "insurance", "insuranceCost", "shippingPaidBy", "isPromoted", "isOnSale", "isSold", "slug", "seoTitle", "seoDescription", "seoKeywords", "viewCount", "customFields", "customSections", "sublistingCategoryId", "groupId", "isGroupParent", "groupParentSlug", "groupChildSlugs", "groupTitle", "createdAt"];
-export declare const PRODUCT_UPDATABLE_FIELDS: readonly ["title", "description", "category", "categoryIds", "subcategory", "brand", "price", "stockQuantity", "images", "status", "tags", "specifications", "features", "shippingInfo", "returnPolicy", "finalSale", "isLot", "lotSize", "pickupAddressId", "condition", "insurance", "shippingPaidBy", "autoExtendable", "auctionExtensionMinutes", "auctionShippingPaidBy", "reservePrice", "buyNowPrice", "minBidIncrement", "bidsHaveStarted", "grading", "card", "classified", "digitalCode", "liveItem", "catalogProductId", "listingType", "preOrderDeliveryDate", "preOrderDepositPercent", "preOrderDepositAmount", "preOrderMaxQuantity", "preOrderProductionStatus", "preOrderCancellable", "isOnSale", "isSold", "allowShipBeforeEmiComplete", "gstRate", "hsnCode", "authenticity", "printMeta", "seoTitle", "seoDescription", "seoKeywords", "customFields", "customSections", "sublistingCategoryId", "groupId", "isGroupParent", "groupParentSlug", "groupChildSlugs", "groupTitle", "barcodeId"];
+export declare const PRODUCT_PUBLIC_FIELDS: readonly ["allowOffers", "minOfferPercent", "id", "title", "description", "category", "categoryIds", "categoryIdNames", "subcategory", "brand", "price", "originalPrice", "currency", "stockQuantity", "availableQuantity", "images", "status", "storeName", "featured", "tags", "specifications", "features", "shippingInfo", "returnPolicy", "finalSale", "isLot", "lotSize", "unitLabel", "partGlossaryId", "colourway", "mouldVariant", "assembledFrom", "views7d", "views30d", "unitLabel", "partGlossaryId", "colourway", "mouldVariant", "assembledFrom", "listingType", "auctionEndDate", "startingBid", "currentBid", "bidCount", "reservePrice", "buyNowPrice", "minBidIncrement", "autoExtendable", "auctionExtensionMinutes", "auctionShippingPaidBy", "bidsHaveStarted", "grading", "card", "classified", "digitalCode", "liveItem", "catalogProductId", "preOrderDeliveryDate", "preOrderDepositPercent", "preOrderDepositAmount", "preOrderMaxQuantity", "preOrderCurrentCount", "preOrderProductionStatus", "preOrderCancellable", "condition", "insurance", "insuranceCost", "shippingPaidBy", "isPromoted", "isOnSale", "isSold", "slug", "seoTitle", "seoDescription", "seoKeywords", "viewCount", "customFields", "customSections", "sublistingCategoryId", "groupId", "isGroupParent", "groupParentSlug", "groupChildSlugs", "groupTitle", "createdAt"];
+export declare const PRODUCT_UPDATABLE_FIELDS: readonly ["title", "description", "category", "categoryIds", "subcategory", "brand", "price", "originalPrice", "stockQuantity", "images", "status", "tags", "specifications", "features", "shippingInfo", "returnPolicy", "finalSale", "isLot", "lotSize", "pickupAddressId", "condition", "insurance", "shippingPaidBy", "autoExtendable", "auctionExtensionMinutes", "auctionShippingPaidBy", "reservePrice", "buyNowPrice", "minBidIncrement", "bidsHaveStarted", "grading", "card", "classified", "digitalCode", "liveItem", "catalogProductId", "listingType", "preOrderDeliveryDate", "preOrderDepositPercent", "preOrderDepositAmount", "preOrderMaxQuantity", "preOrderProductionStatus", "preOrderCancellable", "isOnSale", "isSold", "allowShipBeforeEmiComplete", "gstRate", "hsnCode", "authenticity", "printMeta", "seoTitle", "seoDescription", "seoKeywords", "customFields", "customSections", "sublistingCategoryId", "groupId", "isGroupParent", "groupParentSlug", "groupChildSlugs", "groupTitle", "barcodeId"];
 export type ProductCreateInput = Omit<ProductDocument, "id" | "createdAt" | "updatedAt" | "availableQuantity" | "bidCount" | "currentBid" | "auctionOriginalEndDate">;
 export type ProductUpdateInput = Partial<Pick<ProductDocument, (typeof PRODUCT_UPDATABLE_FIELDS)[number]>>;
 export type ProductAdminUpdateInput = Partial<Omit<ProductDocument, "id" | "createdAt">>;

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

@@ -84,6 +84,13 @@ export const PRODUCT_PUBLIC_FIELDS = [
     "subcategory",
     "brand",
     "price",
+    /*
+     * The strike-through "was ₹X". Public because that is the only place it
+     * means anything — `GatedPrice` renders it as `originalAmount` and derives
+     * the discount % from it, inside the guest gate, so it is published on
+     * exactly the same terms as `price` itself.
+     */
+    "originalPrice",
     "currency",
     "stockQuantity",
     "availableQuantity",
@@ -192,6 +199,9 @@ export const PRODUCT_UPDATABLE_FIELDS = [
     "subcategory",
     "brand",
     "price",
+    /* The strike-through "was" price — see the declaration on ProductDocument
+     * for why it is this name and not `compareAtPrice` (F1 #25). */
+    "originalPrice",
     "stockQuantity",
     "images",
     "status",
@@ -205,7 +215,9 @@ export const PRODUCT_UPDATABLE_FIELDS = [
      * `.passthrough()`, so a field absent from this list is dropped before it
      * reaches Firestore while the write still returns 200 — exactly how a
      * UI-created product lost its `categorySlugs` chain (Root Cause #101) and how
-     * `compareAtPrice` is silently discarded today (F1 #25). */
+     * the strike-through price was silently discarded until F1 #25 was closed —
+     * the form wrote `compareAtPrice`, nothing declared it, and `originalPrice`
+     * (which both renderers read) was not in this list either. */
     "isLot",
     "lotSize",
     "pickupAddressId",

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

@@ -406,6 +406,7 @@ export declare const productItemSchema: z.ZodObject<{
         description?: string | undefined;
         keywords?: string[] | undefined;
     } | undefined;
+    originalPrice?: number | undefined;
     allowShipBeforeEmiComplete?: boolean | undefined;
     printMeta?: {
         size?: string | undefined;
@@ -459,7 +460,6 @@ export declare const productItemSchema: z.ZodObject<{
     }[] | undefined;
     prizeGithubFileUrl?: string | undefined;
     inStock?: boolean | undefined;
-    originalPrice?: number | undefined;
     sellerAvatar?: string | undefined;
     stockCount?: number | undefined;
     attributes?: Record<string, string> | undefined;
@@ -545,6 +545,7 @@ export declare const productItemSchema: z.ZodObject<{
         description?: string | undefined;
         keywords?: string[] | undefined;
     } | undefined;
+    originalPrice?: number | undefined;
     allowShipBeforeEmiComplete?: boolean | undefined;
     printMeta?: {
         size?: string | undefined;
@@ -598,7 +599,6 @@ export declare const productItemSchema: z.ZodObject<{
     }[] | undefined;
     prizeGithubFileUrl?: string | undefined;
     inStock?: boolean | undefined;
-    originalPrice?: number | undefined;
     sellerAvatar?: string | undefined;
     stockCount?: number | undefined;
     attributes?: Record<string, string> | undefined;

package/dist/features/promotions/repository/coupons.repository.js

@@ -1,4 +1,4 @@
-import { planSearchTxt, refineSearchTxt, emptySearchResult, } from "../../../utils/search-txt-query.js";
+import { planSearchTxt, beginSearchWindow, emptySearchResult, } from "../../../utils/search-txt-query.js";
 import { buildCouponSearchTxt } from "../../../utils/search-txt-builders.js";
 import { normalizeError } from "../../../errors/normalize.js";
 import { serverLogger } from "../../../monitoring/server-logger.js";
@@ -500,12 +500,19 @@ export class CouponsRepository extends BaseRepository {
         if (plan.head) {
             baseQuery = baseQuery.where("searchTxt", "array-contains", plan.head);
         }
-        const result = await this.sieveQuery(model, CouponsRepository.SIEVE_FIELDS, {
+        /*
+         * One bounded window, one raised `maxPageSize`, one page slice — see
+         * `beginSearchWindow`. Hand-writing the three is how the other ten
+         * repositories each ended up with two of them, which reads as a working
+         * multi-word search and silently cannot reach page 2.
+         */
+        const win = beginSearchWindow(model, plan);
+        const result = await this.sieveQuery(win.model, CouponsRepository.SIEVE_FIELDS, {
             baseQuery,
             defaultPageSize: 50,
-            maxPageSize: 200,
+            maxPageSize: win.maxPageSize(200),
         });
-        return refineSearchTxt(result, plan.rest);
+        return win.finish(result);
     }
     /**
      * Cloud Functions: find active coupons whose validity period has expired.

package/dist/features/reviews/repository/reviews.repository.js

@@ -4,7 +4,7 @@ import { REVIEW_MAX_RATING, REVIEW_MIN_RATING } from "../../../_internal/shared/
 import { decryptPiiFields, REVIEW_PII_FIELDS, REVIEW_PII_INDEX_MAP, } from "../../../security/index.js";
 import { createReviewId, REVIEW_COLLECTION, } from "../schemas/index.js";
 import { buildReviewSearchTxt } from "../../../utils/search-txt-builders.js";
-import { planSearchTxt, refineSearchTxt, emptySearchResult, } from "../../../utils/search-txt-query.js";
+import { planSearchTxt, beginSearchWindow, emptySearchResult, } from "../../../utils/search-txt-query.js";
 const REVIEW_FIELDS = {
     /** Word-prefix search tokens. Derived on write by `buildSearchTxtFor`. */
     SEARCH_TXT: "searchTxt",
@@ -362,14 +362,21 @@ class ReviewRepository extends BaseRepository {
         if (plan.head) {
             baseQuery = baseQuery.where(REVIEW_FIELDS.SEARCH_TXT, "array-contains", plan.head);
         }
-        const result = await this.sieveQuery(model, ReviewRepository.SIEVE_FIELDS, {
+        /*
+         * One bounded window, one raised `maxPageSize`, one page slice — see
+         * `beginSearchWindow`. Hand-writing the three is how the other ten
+         * repositories each ended up with two of them, which reads as a working
+         * multi-word search and silently cannot reach page 2.
+         */
+        const win = beginSearchWindow(model, plan);
+        const result = await this.sieveQuery(win.model, ReviewRepository.SIEVE_FIELDS, {
             baseQuery,
             defaultPageSize: 50,
-            maxPageSize: 200,
+            maxPageSize: win.maxPageSize(200),
         });
         // Refine BEFORE decrypting: the refine reads `searchTxt`, which is never
         // encrypted, and decrypting rows that are about to be dropped is waste.
-        return this.decryptSieveResult(refineSearchTxt(result, plan.rest));
+        return this.decryptSieveResult(win.finish(result));
     }
 }
 ReviewRepository.SIEVE_FIELDS = {