@mohasinac/appkit 4.45.0 → 4.46.0

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

@@ -1,5 +1,9 @@
 import { normalizeError } from "../../../errors/normalize.js";
 import { increment, serverTimestamp } from "../../../contracts/field-ops.js";
+// 🛑 `../../../errors` re-exports the REAL ValidationError (errors/validation-error),
+// which is the one `mapToHttpError` instanceof-checks to produce a 400. The
+// unrelated same-named class under `_internal/shared/errors` falls through every
+// classified branch to a generic 500 — Root Cause #53.
 import { DatabaseError } from "../../../errors/index.js";
 import { BaseRepository, prepareForFirestore, parseSieveDateValue, } from "../../../providers/db-firebase/index.js";
 import { cacheManager } from "../../../core/index.js";
@@ -19,6 +23,11 @@ import { PRODUCT_COLLECTION, ProductStatusValues } from "../schemas/index.js";
 // reads: no repository in this codebase imports another feature's, because of
 // the Turbopack import-chain trap (Root Cause #6/#18).
 import { CATEGORIES_COLLECTION } from "../../categories/schemas/firestore.js";
+import { CATEGORY_COUNTS_COLLECTION, sumCounts } from "../../categories/schemas/category-counts.js";
+import { ENFORCE_LEAF_FILING, assertAssignmentShape, buildTaxonomyClosure, pickDefaultAssignment, readAssignments, } from "./category-assignment.js";
+import { describeCountable, countsChanged, buildCountPatch, applyCountPatch, } from "../../categories/repository/category-counts.js";
+// The ONE availability predicate — never a second copy (Root Cause #73).
+import { isListingRowAvailable } from "../../../_internal/shared/listing-types/_registry.js";
 import { TAX_CODES_COLLECTION } from "../../tax-codes/schemas/firestore.js";
 // Collection id only, never the stores repository — no repository in this
 // codebase imports another feature's (the Turbopack import-chain trap).
@@ -294,9 +303,8 @@ export class ProductRepository extends BaseRepository {
          * either way. The two can only disagree when one of them is stale, and the
          * derived one is the one that goes stale.
          */
-        const leaf = input.category ||
-            (Array.isArray(input.categorySlugs) && input.categorySlugs[0]) ||
-            null;
+        const assignments = readAssignments(input);
+        const leaf = assignments[0] ?? null;
         /*
          * The brand selector's option value is the brand ROW's id (`brand-beyblade`),
          * but `ProductDocument.brand` is matched by DISPLAY NAME —
@@ -309,32 +317,91 @@ export class ProductRepository extends BaseRepository {
          * left exactly as it was.
          */
         const brandRef = input.brandSlug || input.brand || null;
-        const [catSnap, brandSnap] = await Promise.all([
-            leaf ? cats.doc(leaf).get() : Promise.resolve(null),
-            brandRef ? cats.doc(brandRef).get() : Promise.resolve(null),
-        ]);
-        if (catSnap?.exists) {
-            const cat = catSnap.data();
-            // `parentIds` is ordered root-first / nearest-last (category-tree.ts:107),
-            // and the stored chain is self-first / root-last. Reversing is what makes
-            // the derived value byte-identical to what the seed hand-writes — verified
-            // against products-standard-seed-data.ts:197.
-            out.categorySlugs = [leaf, ...(cat.parentIds ?? []).slice().reverse()];
-            out.category = leaf;
-            const names = [
-                cat.name,
-                ...(cat.ancestors ?? []).map((a) => a?.name).reverse(),
-            ].filter((n) => !!n);
-            if (names.length)
-                out.categoryNames = names;
+        /*
+         * ONE `getAll` for every assignment plus the brand, rather than a read per
+         * assignment. Rule #6 budgets ~3 sequential Firestore round-trips for a
+         * write path and this method is already one of them.
+         */
+        const refs = [...assignments.map((id) => cats.doc(id)), ...(brandRef ? [cats.doc(brandRef)] : [])];
+        const snaps = refs.length > 0 ? await this.db.getAll(...refs) : [];
+        const assignmentSnaps = snaps.slice(0, assignments.length);
+        const brandSnap = brandRef ? (snaps[assignments.length] ?? null) : null;
+        const catSnap = assignmentSnaps[0] ?? null;
+        /*
+         * I1/I2 — resolve every assignment, refuse the disallowed shapes, pick the
+         * default, then derive the ordered closure from all of them.
+         *
+         * 🛑 A row that does not resolve is DROPPED from the assignment list and
+         * warned about, never silently kept: an unresolvable id cannot be checked
+         * against the one-per-root rule and cannot contribute a chain, so keeping
+         * it would put an id in the closure that resolves to no page.
+         */
+        const resolved = [];
+        for (let i = 0; i < assignmentSnaps.length; i += 1) {
+            const snap = assignmentSnaps[i];
+            const id = assignments[i];
+            if (!snap?.exists) {
+                // Never destroy a chain we cannot improve on — see the `else if` below.
+                serverLogger.warn("Product category id does not resolve to a category", { leaf: id });
+                continue;
+            }
+            const d = snap.data();
+            resolved.push({
+                id,
+                name: d.name,
+                rootId: d.rootId,
+                tier: d.tier,
+                isLeaf: d.isLeaf,
+                parentIds: d.parentIds ?? [],
+                ancestorNames: (d.ancestors ?? []).map((a) => a?.name ?? ""),
+            });
         }
-        else if (leaf) {
-            // Never destroy a chain we cannot improve on. A leaf that is not a real
-            // category row is a data problem to report, not a reason to blank the field.
-            serverLogger.warn("Product category id does not resolve to a category", {
-                leaf,
+        if (resolved.length > 0) {
+            assertAssignmentShape(resolved, input.isLot === true, {
+                enforceLeafFiling: ENFORCE_LEAF_FILING,
+                warn: (msg, meta) => serverLogger.warn(msg, { productTitle: input.title, ...meta }),
             });
+            /*
+             * The default's tie-break reads listing counts — and ONLY on a genuine
+             * tie, so a single-assignment product (the overwhelming majority) pays
+             * nothing for it. See `pickDefaultAssignment` for why depth, not count,
+             * is the first criterion.
+             */
+            let counts;
+            const deepest = Math.max(...resolved.map((c) => c.tier ?? -1));
+            if (resolved.filter((c) => (c.tier ?? -1) === deepest).length > 1) {
+                counts = await this.readAssignmentCounts(resolved.map((c) => c.id));
+            }
+            const defaultIdx = pickDefaultAssignment(resolved, counts);
+            const closure = buildTaxonomyClosure(resolved, defaultIdx);
+            /*
+             * 🛑 `categoryIds` is written in the DEFAULT-FIRST order, not the order
+             * the seller picked, so it is parallel to `categoryIdNames` and index 0
+             * agrees with `categorySlugs[0]`. Three fields that must line up, lined
+             * up at the one place that produces all three.
+             */
+            out.categoryIds = closure.categoryIdNames.length
+                ? [resolved[defaultIdx].id, ...resolved.filter((_, i) => i !== defaultIdx).map((c) => c.id)]
+                : resolved.map((c) => c.id);
+            out.categorySlugs = closure.categorySlugs;
+            out.category = closure.categorySlugs[0];
+            if (closure.categoryNames.length)
+                out.categoryNames = closure.categoryNames;
+            if (closure.categoryIdNames.length)
+                out.categoryIdNames = closure.categoryIdNames;
         }
+        /*
+         * 🛑 The old single-leaf block that stood here is GONE, and its two jobs
+         * moved for different reasons:
+         *
+         *   - the chain + names build -> `buildTaxonomyClosure`, because it now has
+         *     to span every assignment while keeping index 0 the default leaf;
+         *   - the lot filing rule -> `assertAssignmentShape`, because it has to run
+         *     per assignment and is now one half of a two-directional rule.
+         *
+         * Its `else if (leaf)` warn also moved, into the resolve loop above, where
+         * it fires per unresolvable assignment instead of only for the first.
+         */
         if (brandSnap?.exists) {
             const brand = brandSnap.data();
             if (brand.categoryType === "brand") {
@@ -349,6 +416,49 @@ export class ProductRepository extends BaseRepository {
         await this.applyInclusivePricing(input, out);
         return out;
     }
+    /**
+     * Listing counts for a handful of category ids, for the default tie-break.
+     *
+     * 🛑 Called ONLY when two assignments tie at the deepest tier, so the common
+     * single-assignment write pays nothing. One `getAll` of at most
+     * `MAX_CATEGORY_ASSIGNMENTS` documents by id — no index, no query.
+     *
+     * 🛑 A missing row is OMITTED from the map rather than defaulted to 0.
+     * `categoryCounts` documents the same rule: `undefined` means "not counted
+     * yet", and defaulting it to zero would let an uncounted node lose a tie it
+     * might have won.
+     *
+     * Reads the collection through `this.db` rather than importing
+     * `categoryCountsRepository` — no repository here imports another feature's
+     * (Root Cause #6/#18), and a raw read by id has neither problem.
+     */
+    async readAssignmentCounts(ids) {
+        const out = new Map();
+        if (ids.length === 0)
+            return out;
+        try {
+            const refs = ids.map((id) => this.db.collection(CATEGORY_COUNTS_COLLECTION).doc(id));
+            const snaps = await this.db.getAll(...refs);
+            for (const snap of snaps) {
+                if (!snap.exists)
+                    continue;
+                const d = snap.data();
+                if (!d.total)
+                    continue;
+                out.set(snap.id, sumCounts(d.total));
+            }
+        }
+        catch (err) {
+            /*
+             * A tie-break is not worth failing a product write over. Falling through
+             * with an empty map drops to level 3 — the order the seller picked — which
+             * is a deterministic answer rather than a wrong one.
+             */
+            void normalizeError(err);
+            serverLogger.warn("Could not read category counts for the default tie-break", { ids });
+        }
+        return out;
+    }
     /**
      * Resolve the GST rate floor, and gross up an ex-tax price if the seller
      * authors that way.
@@ -713,8 +823,58 @@ export class ProductRepository extends BaseRepository {
             searchTxt: buildProductSearchTxt(merged),
         });
         this.cacheSet(updated);
+        await this.syncCategoryCounts(current ?? null, updated);
         return updated;
     }
+    /**
+     * G3b — move the leaf→root listing counters for one product transition.
+     *
+     * 🛑 Called from HERE rather than from a Firestore trigger because
+     * `FieldValue.increment` is atomic but **not idempotent** and a trigger is
+     * at-least-once: a redelivered trigger double-counts permanently and
+     * invisibly. See `repository/category-counts.ts` for the full argument.
+     *
+     * 🛑 And the guard is on (chain, leaf, type, isLot, AVAILABILITY) — not on
+     * the taxonomy alone. `draft → published` changes no `categorySlugs`, so a
+     * taxonomy-only guard would never move the count on the one transition that
+     * matters most, with nothing to notice.
+     *
+     * Availability comes from `isListingRowAvailable`, the SAME predicate the
+     * listing query and `countersReconcile` use, so the incremental and nightly
+     * values can agree. Four partial copies of that predicate is what Root Cause
+     * #73 cost; this module takes the verdict as an argument rather than
+     * recomputing it.
+     */
+    async syncCategoryCounts(before, after) {
+        const now = new Date();
+        const side = (row) => ({
+            delta: row ? describeCountable(row) : null,
+            // A draft or archived row is not "available" and must not be counted —
+            // the count is of what a visitor can actually see, which is why the
+            // badge and the tab agree.
+            countsNow: !!row
+                && row.status === ProductStatusValues.PUBLISHED
+                && isListingRowAvailable(row, now),
+        });
+        const b = side(before);
+        const a = side(after);
+        if (!countsChanged(b, a))
+            return;
+        const patch = buildCountPatch([
+            { delta: b.countsNow ? b.delta : null, sign: -1 },
+            { delta: a.countsNow ? a.delta : null, sign: 1 },
+        ]);
+        await applyCountPatch(this.db, patch, (err) => {
+            // Never fails the product write: a count is a display number, and losing
+            // a seller's publish over an ancestor counter would trade a cosmetic
+            // staleness for real data. The nightly reconciler's `drifted` is how a
+            // missed increment becomes visible.
+            serverLogger.warn("categoryCounts increment failed", {
+                productId: after?.id ?? before?.id,
+                error: err.message,
+            });
+        });
+    }
     async create(input) {
         // Slug = document ID: derive slug from title first, then ensure uniqueness.
         const baseSlug = input.slug || slugify(input.title);
@@ -750,6 +910,7 @@ export class ProductRepository extends BaseRepository {
             .set(prepareForFirestore(productData));
         const created = { id, ...productData };
         this.cacheSet(created);
+        await this.syncCategoryCounts(null, created);
         return created;
     }
     async findByStore(storeId) {
@@ -767,6 +928,32 @@ export class ProductRepository extends BaseRepository {
             .get();
         return snap.docs.map((d) => this.mapDoc(d));
     }
+    /**
+     * I4 — products ASSIGNED to this category, not merely descended from it.
+     *
+     * 🛑 The distinction is the whole point, and the category-delete cascade is
+     * what needs it. `findByCategory` matches the derived CLOSURE, so it also
+     * returns every product in the descendant subtree — those belong to the
+     * children and travel with them when the children are reparented.
+     * `findBy("category", id)` matches only the scalar, i.e. the DEFAULT leaf, so
+     * a product that named this category as its SECOND assignment was invisible
+     * and the delete left a dangling id in its `categoryIds`.
+     *
+     * This matches the assigned list, and falls back to the scalar for every row
+     * written before `categoryIds` existed — two queries, because Firestore
+     * permits one array operator per query and there is no OR across fields.
+     */
+    async findByAssignment(categoryId) {
+        const [assigned, legacy] = await Promise.all([
+            this.getCollection().where("categoryIds", "array-contains", categoryId).get(),
+            this.getCollection().where(PRODUCT_FIELDS.CATEGORY, "==", categoryId).get(),
+        ]);
+        const byId = new Map();
+        for (const d of [...assigned.docs, ...legacy.docs]) {
+            byId.set(d.id, this.mapDoc(d));
+        }
+        return [...byId.values()];
+    }
     /**
      * Published products sharing at least one tag with the given list — "you
      * might also like" style discovery. `array-contains-any` caps at 10 values,
@@ -957,7 +1144,33 @@ export class ProductRepository extends BaseRepository {
     }
     async delete(id) {
         this.cacheInvalidateForId(id);
-        return super.delete(id);
+        /*
+         * 🛑 Read BEFORE deleting, or there is no chain left to decrement and the
+         * counters keep the row forever — the one case where the delta cannot be
+         * recovered from the write itself. One extra read on a delete, which is
+         * the rarest product mutation there is.
+         *
+         * `safeRead`-shaped on purpose: a product that cannot be read must still
+         * be deletable, and the nightly reconciler corrects the count.
+         */
+        let prior = null;
+        try {
+            prior = await super.findById(id);
+        }
+        catch (err) {
+            const e = normalizeError(err);
+            // 🛑 Logged, not swallowed. A failed pre-read means this product's
+            // contribution stays on its ancestors' counters until the nightly
+            // reconciler corrects them — bounded and self-healing, but invisible
+            // unless it is said. `void normalizeError(err)` alone would look handled
+            // while reporting nothing (audit-silent-degrade's normalize theatre).
+            serverLogger.warn("product delete: pre-read failed, counts will drift until reconcile", {
+                productId: id,
+                error: e.message,
+            });
+        }
+        await super.delete(id);
+        await this.syncCategoryCounts(prior, null);
     }
     /**
      * Shared scope construction for `list()` and `countBy*()` — both must narrow
@@ -1229,7 +1442,21 @@ ProductRepository.SIEVE_FIELDS = {
     price: { canFilter: true, canSort: true },
     stockQuantity: { canFilter: true, canSort: true },
     availableQuantity: { canFilter: true, canSort: true },
-    viewCount: { canFilter: true, canSort: true },
+    /*
+     * 🛑 D8 closes F1 #1. `viewCount` was `canFilter`/`canSort` here with NO
+     * writer on any document — measured: absent from all 72 products and all 58
+     * categories — and a Firestore `orderBy` EXCLUDES every document lacking
+     * the ordering field, so `?sort=viewCount` returned zero rows with a valid
+     * index present (Root Cause #100). A5 removed the UI sort and the reachable
+     * field survived.
+     *
+     * Replaced by two fields that have a real nightly writer
+     * (`runProductViewWindows`) and whose names state the window, which
+     * `viewCount` never did — it read as a lifetime figure while nothing
+     * maintained it.
+     */
+    views7d: { canFilter: true, canSort: true },
+    views30d: { canFilter: true, canSort: true },
     currentBid: { canFilter: true, canSort: true },
     bidCount: { canFilter: true, canSort: true },
     bidsHaveStarted: { canFilter: true, canSort: false },

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

@@ -159,11 +159,57 @@ export interface ProductDocument extends BaseDocument {
     seoTitle?: string;
     seoDescription?: string;
     seoKeywords?: string[];
-    /** Primary category FK slugs (1-to-many). Use categorySlugs[0] for display. */
+    /**
+     * I1 — the ASSIGNED categories. What a human picked, and the only one of the
+     * three category fields that is authored rather than derived.
+     *
+     * At most `MAX_CATEGORY_ASSIGNMENTS` (4), and 🛑 **at most ONE per root** —
+     * "a category can be multiple, they should not be under same tree". A single
+     * files at LEAVES, a lot at NON-LEAVES. All of it is enforced in
+     * `assertAssignmentShape`, which `deriveTaxonomy` calls on every write path.
+     *
+     * `categoryIds[0]` is NOT the default — the default is the DEEPEST assignment
+     * (count breaks a tie), and `categorySlugs[0]` is what carries it.
+     */
+    categoryIds?: string[];
+    /**
+     * I5b — DERIVED. One display name per assignment, parallel to `categoryIds`.
+     *
+     * Lets the breadcrumb row offer the OTHER categories as real links without a
+     * second read on a cached page. Deliberately not their full chains: the
+     * alternate crumb shows the other categories, never N stacked trails.
+     */
+    categoryIdNames?: string[];
+    /**
+     * DERIVED closure over every assignment — the field every category QUERY
+     * matches on, via `array-contains` / `array-contains-any`.
+     *
+     * 🛑 ORDERED, and that is load-bearing: the DEFAULT chain first (so
+     * `categorySlugs[0]` is still the default leaf, which ~30 call sites read it
+     * as), then each remaining chain leaf-first, deduped. A set-shaped union
+     * would break all of them silently — see `category-assignment.ts`'s header.
+     *
+     * Never authored. An inbound value is treated as a legacy single leaf: only
+     * its HEAD is read, as one assignment.
+     */
     categorySlugs: string[];
-    /** Display-name cache parallel to categorySlugs[]. */
+    /**
+     * Display-name cache for the DEFAULT chain only, leaf-first.
+     *
+     * 🛑 Deliberately NOT parallel to `categorySlugs` once a product has two
+     * assignments: a union of two chains has no readable path, and the breadcrumb
+     * builder reverses this array to render root-first. Keeping it single-chain
+     * is what leaves every existing breadcrumb byte-identical.
+     */
     categoryNames?: string[];
-    /** @deprecated Read-only alias — normalised from legacy docs on load. */
+    /**
+     * The default leaf, mirrored. 🛑 NOT dead and NOT read-only, whatever the
+     * `@deprecated` tag here said for a long time: it is in
+     * `PRODUCT_UPDATABLE_FIELDS`, it is what `CategoryInlineSelect` writes, it is
+     * the one category key `productCreateSchema` declares, and `deriveTaxonomy`
+     * prefers it over the derived chain. Sending it alone still means exactly
+     * "one assignment".
+     */
     category?: string;
     /** @deprecated Read-only alias. */
     categoryName?: string;
@@ -224,6 +270,101 @@ export interface ProductDocument extends BaseDocument {
      * always accepted. See `_internal/shared/features/orders/return-reasons`.
      */
     finalSale?: boolean;
+    /**
+     * This listing is a multi-item LOT rather than a single item.
+     *
+     * 🛑 A lot files under a NON-LEAF category and a single may file anywhere —
+     * enforced one-directionally in `ProductRepository.deriveTaxonomy`, which
+     * already holds the leaf document so the check costs no extra read. The
+     * reason is a claim about the ITEMS, not about counting: filing "12 assorted
+     * Burst beys" under `category-dragoon-g` asserts all twelve are Dragoon G.
+     *
+     * Counting is disambiguated separately, by `categoryCounts` carrying its own
+     * `lots` pair — so singles and lots are never summed into one number.
+     *
+     * A lot is the INVERSE of per-unit selling: many objects, one listing, one
+     * stock count. Two physically distinct units of one model are two listings
+     * each at `stockQuantity: 1` (see `unitLabel`), never one listing of two.
+     */
+    isLot?: boolean;
+    /**
+     * How many items the lot contains. Drives the "lot of 12" label and the
+     * per-item price hint.
+     *
+     * Deliberately NOT required when `isLot` is true: a seller who knows it is a
+     * lot but has not counted the pile yet must still be able to save a draft.
+     */
+    lotSize?: number;
+    /**
+     * Distinguishes two physically distinct units of the SAME model and the same
+     * catalogue variant — both white Dragoon G, one with a scuffed attack ring.
+     *
+     * 🛑 Referenced by `isLot`'s comment above since G3a and declared NOWHERE
+     * until now, so the rule that comment states had no field to state it about.
+     *
+     * 🛑 NOT `itemCode`, which is the grading axis and documents `"PSA 10"` as
+     * its example — a grade is a third party's claim about condition. A unit
+     * label is a disambiguator the seller chose.
+     *
+     * It exists because the alternative is what the crawl measured at
+     * thelimitlesscorner: one listing per physical unit with the condition
+     * defects welded into the TITLE.
+     */
+    unitLabel?: string;
+    /**
+     * This listing is a COMPONENT, and this is which one.
+     *
+     * The `partGlossary` document id (`${slot}--${tail}`), stored whole.
+     *
+     * 🛑 A single id rather than the `{classification, code}` pair the plan
+     * proposed, and the departure is deliberate: a pair is a second place the
+     * key gets composed, and `partGlossaryId()` is already the one place that
+     * composes it. Two composers of one key is Root Cause #75's shape, and the
+     * id is also directly the URL (`/parts/{slot}/{tail}`) with no re-derivation.
+     *
+     * Optional even on a part listing: the glossary holds 753 rows and does not
+     * cover every component ever moulded, so a spare we cannot classify is still
+     * sellable and still countable.
+     */
+    partGlossaryId?: string;
+    /**
+     * What distinguishes two physical units of the same part code — "pink",
+     * "translucent blue", "gold".
+     *
+     * 🛑 NOT a `productFeature`. That vocabulary is ~169 curated terms in 13
+     * groups and `colour` is not one of them, deliberately: colourways are
+     * open-ended and per-part, and pouring them into a shared vocabulary gives a
+     * facet with hundreds of single-use values — the long-tail-tag anti-pattern
+     * this project REJECTED when redeyemerch was crawled (50–160 tags per
+     * product, 162 products on one tag).
+     *
+     * 🛑 Free text, and the VOCABULARY is deliberately not seeded. The corpus
+     * carries part names, codes and weights and no colours at all, so a seeded
+     * list would be invented. It accumulates from real spares (GAP-8: data
+     * entry, not code).
+     */
+    colourway?: string;
+    /** Mould/version variant — the "storm pegasus version" of a shared part. */
+    mouldVariant?: string;
+    /**
+     * Built HERE from components. Each entry decremented a part listing's stock.
+     *
+     * 🛑 The decrement must happen in a real transaction that RE-READS, and it
+     * must read `availableQuantity` rather than `stockQuantity`: a component with
+     * 10 in stock and 3 reserved has SEVEN assemblable, and assembling from the
+     * wrong field builds a bey out of parts somebody has already bought. The
+     * PhonePe path's `runBatch` over a snapshot read outside any transaction is
+     * the oversell this avoids, five components at a time.
+     */
+    assembledFrom?: Array<{
+        slotKey: string;
+        productId: string;
+        quantity: number;
+    }>;
+    /** Views in the trailing 7 days. */
+    views7d?: number;
+    /** Views in the trailing 30 days. */
+    views30d?: number;
     condition?: "new" | "like_new" | "good" | "fair" | "poor" | "used" | "refurbished" | "broken" | "graded";
     insurance?: boolean;
     insuranceCost?: number;
@@ -505,10 +646,10 @@ export declare const ProductStatusValues: {
     readonly ARCHIVED: "archived";
 };
 export declare const PRODUCT_COLLECTION: "products";
-export declare const PRODUCT_INDEXED_FIELDS: readonly ["storeId", "status", "category", "featured", "listingType", "isPromoted", "isOnSale", "isSold", "searchTxt", "createdAt", "barcodeId", "physicalLocation.zone"];
+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", "subcategory", "brand", "price", "currency", "stockQuantity", "availableQuantity", "images", "status", "storeName", "featured", "tags", "specifications", "features", "shippingInfo", "returnPolicy", "finalSale", "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", "subcategory", "brand", "price", "stockQuantity", "images", "status", "tags", "specifications", "features", "shippingInfo", "returnPolicy", "finalSale", "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", "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 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

@@ -16,6 +16,10 @@ export const PRODUCT_INDEXED_FIELDS = [
     "storeId",
     "status",
     "category",
+    /* Indexed: `array-contains` on the ASSIGNED list is what the category
+     * delete cascade queries to find a product filed here as its SECOND
+     * category — `findBy("category", id)` sees only the default leaf. */
+    "categoryIds",
     "featured",
     "listingType",
     "isPromoted",
@@ -74,6 +78,9 @@ export const PRODUCT_PUBLIC_FIELDS = [
     "title",
     "description",
     "category",
+    /* Public: the chips on a detail page render the assignments. */
+    "categoryIds",
+    "categoryIdNames",
     "subcategory",
     "brand",
     "price",
@@ -92,6 +99,35 @@ export const PRODUCT_PUBLIC_FIELDS = [
     // Buyer-facing: drives the "Final Sale" card pill and the detail-page
     // Delivery & Returns line. Absent means final sale — read via isFinalSale().
     "finalSale",
+    // Buyer-facing by necessity: "lot of 12" is the single most important thing
+    // about a lot listing, and a buyer who cannot see it thinks they are bidding
+    // on one item.
+    "isLot",
+    "lotSize",
+    /* D13/D14 — buyer-facing by definition: a colourway is WHY someone buys that
+     * particular spare, and a unit label is how they tell two identical listings
+     * apart. `assembledFrom` is listed too — it names product ids that are
+     * already public listings, and "built from these parts" is provenance a
+     * buyer should see. */
+    "unitLabel",
+    "partGlossaryId",
+    "colourway",
+    "mouldVariant",
+    "assembledFrom",
+    /* D8 — public because "N people viewed this this week" is the honest social
+     * proof H2 is built on, and it is a figure we measured. 🛑 Deliberately NOT
+     * in PRODUCT_UPDATABLE_FIELDS: a seller who could write their own view count
+     * turns a measurement into a claim. */
+    "views7d",
+    "views30d",
+    /* 🛑 D13/D14. Listed here or an update STRIPS them: the write schema has no
+     * `.passthrough()`, so a field absent from this list is dropped before it
+     * reaches Firestore while the write still returns 200 (Root Cause #101). */
+    "unitLabel",
+    "partGlossaryId",
+    "colourway",
+    "mouldVariant",
+    "assembledFrom",
     "listingType",
     "auctionEndDate",
     "startingBid",
@@ -147,6 +183,12 @@ export const PRODUCT_UPDATABLE_FIELDS = [
     "title",
     "description",
     "category",
+    /* I1 — the ASSIGNED list. 🛑 Named here or an update STRIPS it while still
+     * returning 200 (Root Cause #101), which is exactly how a UI-created
+     * product lost its chain. `categorySlugs`/`categoryNames` stay OUT: they
+     * are derived, and a caller that could set them could desync the closure
+     * from the assignments it is supposed to be the closure OF. */
+    "categoryIds",
     "subcategory",
     "brand",
     "price",
@@ -159,6 +201,13 @@ export const PRODUCT_UPDATABLE_FIELDS = [
     "shippingInfo",
     "returnPolicy",
     "finalSale",
+    /* 🛑 Listed here or an update STRIPS them. The write schema has no
+     * `.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). */
+    "isLot",
+    "lotSize",
     "pickupAddressId",
     "condition",
     "insurance",

package/dist/features/search/components/SearchResultsPageView.d.ts

@@ -0,0 +1,33 @@
+/**
+ * D2 Fix 4 — the cross-resource search RESULTS page.
+ *
+ * Replaces a pure redirect. Before this, `/search` mapped each of 15
+ * `SearchResourceType` values to a browse route and `redirect()`ed, so a buyer
+ * searching "dranzer" could not see that we have a product, a category, a blog
+ * post and an FAQ about it — the dropdown only chose which single listing page
+ * to send them to.
+ *
+ * Measured on production: "burst" returns 21 hits across SIX groups
+ * (listings, categories, brands, stores, articles, FAQs); "zzzznope" and "!!!"
+ * return none.
+ *
+ * 🛑 STILL `noindex`, and that is deliberate rather than inherited. A search
+ * results page is the classic crawl trap: one URL per query string, thin
+ * content, and no canonical answer to index. The redirect it replaces was
+ * `noindex` too, so this changes the page's usefulness to a HUMAN without
+ * changing its relationship to a crawler. The `moreHref` links go to the real
+ * indexable listing pages.
+ *
+ * 🛑 NO PRICES ANYWHERE. Prices are hidden from signed-out visitors and this
+ * is the one surface where gating every row would be most of the markup.
+ * A title plus a link is honest, needs no `<GatedPrice>`, and cannot leak —
+ * there is nothing on the row to leak.
+ */
+import React from "react";
+import type { SearchEverythingResult } from "../../../_internal/server/features/search/search-everything";
+export interface SearchResultsPageViewProps {
+    result: SearchEverythingResult;
+    /** Rendered above the groups — the consumer owns the input control. */
+    renderSearchInput?: () => React.ReactNode;
+}
+export declare function SearchResultsPageView({ result, renderSearchInput, }: SearchResultsPageViewProps): React.JSX.Element;