@mohasinac/appkit 4.52.4 → 4.53.0

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

@@ -0,0 +1,53 @@
+import type { SearchIndexType } from "../../../../shared/search/index-record";
+import type { FirestoreValue } from "../../../../../schemas/types";
+export type IndexDocData = Record<string, FirestoreValue>;
+/** One record under construction. `null` drops the document from the index. */
+export interface BuiltRecord {
+    readonly title: string;
+    readonly detail: string;
+    readonly facets?: string;
+}
+export interface IndexSource {
+    /** Matches a `SearchIndexType.key`. */
+    readonly typeKey: string;
+    readonly collection: string;
+    /** Fields to project. A builder reads documents, not whole collections. */
+    readonly select: readonly string[];
+    /**
+     * Extra equality narrowing applied as a query clause. Only use this for a
+     * value every public row genuinely carries — otherwise filter in `toRecord`,
+     * because a Firestore equality on an absent field matches nothing and an
+     * inequality excludes every document lacking it.
+     */
+    readonly where?: ReadonlyArray<readonly [string, unknown]>;
+    /**
+     * The record's stable identity, and the artifact's patch key.
+     *
+     * 🛑 SEPARATE from `toRecord` on purpose. An incremental build must be able
+     * to key a document it is REMOVING — one that just became unpublished — and
+     * at that moment `toRecord` has returned null and cannot supply a slug. With
+     * the slug folded into `toRecord` the two paths keyed differently (doc id on
+     * the way out, slug on the way in), which agrees only where slug === id: so
+     * every changed product would have been ADDED as a duplicate rather than
+     * replaced, while categories and stores looked fine.
+     */
+    /**
+     * Resolve the type PER DOCUMENT, when one collection holds several.
+     * `products` is the only such collection today: all nine listing types live
+     * in it and each has its own detail route.
+     */
+    readonly typeKeyOf?: (d: IndexDocData) => string;
+    readonly slugOf: (id: string, d: IndexDocData) => string | null;
+    readonly toRecord: (id: string, d: IndexDocData) => BuiltRecord | null;
+}
+/**
+ * The type table shipped inside the artifact.
+ *
+ * 🛑 No `label`. The client maps `key` to a translated string; a heading baked
+ * in here could not be localised. Weights are a ranking nudge between types
+ * that scored equally, not a statement about importance.
+ */
+export declare const INDEX_TYPES: readonly SearchIndexType[];
+export declare const PUBLIC_INDEX_SOURCES: readonly IndexSource[];
+/** Index into `INDEX_TYPES` for a source's type key. */
+export declare function typeIndexFor(typeKey: string): number;

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

@@ -0,0 +1,385 @@
+/*
+ * WHY: What goes into the public search artifact — an unauthenticated,
+ *      immutable, CDN-cached body downloaded by every visitor who searches.
+ * WHAT: The membership allowlist and the per-collection record mapping.
+ *
+ * ## 🛑 MEMBERSHIP IS AN ALLOWLIST. It is deliberately NOT `LISTERS`.
+ *
+ * `listingProcessor.ts`'s `LISTERS` is a tempting source registry — one entry
+ * per collection, already routed through the Sieve adapter, with its own
+ * header inviting "a one-line addition". It is the wrong list. Counted
+ * 2026-10-19 it holds **20** entries, and four of them are **`users`,
+ * `payouts`, `orders`, `notifications`**. "Index everything LISTERS knows
+ * about" is one line away from publishing every customer's name to every
+ * browser, permanently, for the life of that artifact version.
+ *
+ * So this file names what is public, and `LISTERS` is only used to READ it.
+ * `audit-search-index-artifact` R6 asserts the intersection of this list with
+ * the PII and private registries is empty, with "add `users` → must fail" as
+ * its negative control.
+ *
+ * ## 🛑 Every field here was read off the LIVE documents
+ *
+ * The same rule `search-sources.ts` states, and it earned its keep again:
+ * `scammerProfiles` carries `displayNames` (an ARRAY) not `displayName`, and
+ * a string read would have produced a null title for every row — the group
+ * would simply never have appeared. `partGlossary`'s page needs TWO path
+ * segments and its document id already encodes them as `${slot}--${code}`.
+ *
+ * ## What a record carries, and what it must never carry
+ *
+ * Title, a one-line detail, a slug and optional facets. No amount of any kind
+ * (§ Guest price gating cannot reach an unauthenticated artifact) and no PII.
+ *
+ * @tag domain:search
+ * @tag layer:server
+ * @tag pattern:none
+ * @tag access:server
+ * @tag consumers:index-build/build,searchIndexBuild
+ * @tag sideEffects:none
+ */
+import { pluginFor } from "../../../../shared/listing-types/_registry.js";
+// Defined here, not in `_registry` — imported from the DEFINING module
+// (Root Cause #18).
+import { ALL_LISTING_TYPES } from "../../../../shared/listing-types/feature-flags.js";
+const str = (v) => typeof v === "string" && v.trim() ? v.trim() : null;
+/**
+ * The type table shipped inside the artifact.
+ *
+ * 🛑 No `label`. The client maps `key` to a translated string; a heading baked
+ * in here could not be localised. Weights are a ranking nudge between types
+ * that scored equally, not a statement about importance.
+ */
+export const INDEX_TYPES = [
+    /*
+     * 🛑 ONE ENTRY PER LISTING TYPE, DERIVED from the plugin registry — not one
+     * `product` entry for the whole collection.
+     *
+     * The first draft had a single `{ key: "product", hrefTemplate:
+     * "/products/{s}" }`, which is Root Cause #48 rebuilt from scratch: "a
+     * per-listing-type detailRoute() that silently defaults to the standard
+     * product page". An auction lives at `/auctions/{slug}`, a pre-order at
+     * `/pre-orders/{slug}`, a classified at `/classified/{slug}`. Every one of
+     * those results would have rendered correctly and navigated to the wrong
+     * page — the exact failure that made non-standard listings "revert to
+     * standard" the first time.
+     *
+     * `detailRoute` and `browseRoute` come from `pluginFor`, so a tenth listing
+     * type is covered the day it is added rather than the day someone notices.
+     * Hand-writing them here would be the eleventh enumeration of that union
+     * (Root Cause #61).
+     */
+    ...ALL_LISTING_TYPES.map((t) => {
+        const plugin = pluginFor(t);
+        return {
+            key: t,
+            // `detailRoute` builds a concrete path, so hand it the placeholder and
+            // let it produce the template. One source of truth, no second mapping.
+            hrefTemplate: plugin.detailRoute("{s}"),
+            moreHref: String(plugin.browseRoute),
+            // Standard listings are the catalogue's centre of gravity; the rest sit
+            // just below so a same-score tie favours the commonest thing.
+            weight: t === "standard" ? 1.0 : 0.98,
+        };
+    }),
+    { key: "category", hrefTemplate: "/categories/{s}", moreHref: "/categories", weight: 0.95 },
+    { key: "brand", hrefTemplate: "/brands/{s}", moreHref: "/brands", weight: 0.9 },
+    { key: "part", hrefTemplate: "/parts/{s}", moreHref: "/parts", weight: 0.9 },
+    { key: "model", hrefTemplate: "/categories/{s}", moreHref: "/categories", weight: 0.85 },
+    { key: "store", hrefTemplate: "/stores/{s}", moreHref: "/stores", weight: 0.8 },
+    { key: "blog", hrefTemplate: "/blog/{s}", moreHref: "/blog", weight: 0.7 },
+    { key: "event", hrefTemplate: "/events/{s}", moreHref: "/events", weight: 0.7 },
+    { key: "faq", hrefTemplate: "/faqs/{s}", moreHref: "/faqs", weight: 0.6 },
+    { key: "review", hrefTemplate: "/reviews/{s}", moreHref: "/reviews", weight: 0.5 },
+    { key: "group", hrefTemplate: "/groups/{s}", moreHref: "/products", weight: 0.5 },
+    { key: "scammer", hrefTemplate: "/scams/{s}", moreHref: "/scams", weight: 0.5 },
+    /* `/promotions` has no per-coupon page, so `{s}` is absent on purpose and
+     * `hrefFor`'s replace is a no-op. Eleven rows all landing on one page would
+     * be noise in the federated GROUP (which is why `search-sources.ts` omits
+     * coupons), but in the index it is the difference between a code being
+     * findable and not. */
+    { key: "coupon", hrefTemplate: "/promotions", moreHref: "/promotions", weight: 0.4 },
+];
+const facet = (pairs) => {
+    const parts = pairs
+        .filter(([, v]) => typeof v === "string" && v)
+        .map(([k, v]) => `${k}:${v}`);
+    return parts.length > 0 ? parts.join("|") : undefined;
+};
+export const PUBLIC_INDEX_SOURCES = [
+    {
+        /*
+         * 🛑 The type key is RESOLVED PER DOCUMENT — see `typeKeyOf`. A source
+         * normally maps one collection to one type, but `products` holds all nine
+         * listing types and each has its own detail route.
+         */
+        typeKey: "standard",
+        typeKeyOf: (d) => {
+            const lt = str(d.listingType);
+            return lt && ALL_LISTING_TYPES.includes(lt) ? lt : "standard";
+        },
+        collection: "products",
+        where: [["status", "published"]],
+        select: ["title", "slug", "brand", "categoryNames", "listingType", "condition", "franchiseSlug"],
+        slugOf: (id, d) => str(d.slug) ?? id,
+        toRecord: (id, d) => {
+            const title = str(d.title);
+            if (!title)
+                return null;
+            const names = Array.isArray(d.categoryNames) ? d.categoryNames : [];
+            /*
+             * 🛑 The enum VALUES go in `detail`, which is SEARCHED — the `facets`
+             * string is filter-only and never matched as text. Without this,
+             * typing "auction" or "sealed" finds nothing, because the only place
+             * those words appeared was a facet nobody searches. Humanised, so
+             * "pre-order" and "digital code" read as words rather than slugs.
+             */
+            const human = (v) => (str(v) ?? "").replace(/[-_]/g, " ");
+            return {
+                title,
+                // Leaf-first, so [0] is the most specific label.
+                detail: [
+                    str(d.brand),
+                    str(names[0]),
+                    human(d.listingType),
+                    human(d.condition),
+                ]
+                    .filter(Boolean)
+                    .join(" · "),
+                facets: facet([
+                    ["lt", d.listingType],
+                    ["cn", d.condition],
+                    ["fr", d.franchiseSlug],
+                ]),
+            };
+        },
+    },
+    {
+        typeKey: "category",
+        collection: "categories",
+        /*
+         * 🛑 No `where` on `categoryType`. A plain listing category OMITS the
+         * field entirely — the convention CLAUDE.md records — so `== "category"`
+         * matches nothing and `!=` excludes every real row. Brands are their own
+         * type below and are rejected here rather than dropped.
+         */
+        select: ["name", "slug", "categoryType", "path", "isActive"],
+        slugOf: (id) => id,
+        toRecord: (id, d) => {
+            const name = str(d.name);
+            if (!name)
+                return null;
+            const type = str(d.categoryType);
+            if (type && type !== "sublisting")
+                return null;
+            if (d.isActive === false)
+                return null;
+            return { title: name, detail: str(d.path) ?? "", slug: id };
+        },
+    },
+    {
+        typeKey: "brand",
+        collection: "categories",
+        where: [["categoryType", "brand"]],
+        select: ["name", "brandCountry", "isActive"],
+        slugOf: (id) => id,
+        toRecord: (id, d) => {
+            const name = str(d.name);
+            if (!name)
+                return null;
+            if (d.isActive === false)
+                return null;
+            return { title: name, detail: str(d.brandCountry) ?? "", slug: id };
+        },
+    },
+    {
+        typeKey: "part",
+        collection: "partGlossary",
+        select: ["name", "code", "classification", "slot"],
+        slugOf: (id) => (id.includes("--") ? id.replace("--", "/") : null),
+        toRecord: (id, d) => {
+            const name = str(d.name);
+            if (!name)
+                return null;
+            /*
+             * 🛑 TWO path segments, and the document id already encodes them.
+             * `ROUTES.PUBLIC.PART_DETAIL` is `/parts/{classification}/{code}`, and
+             * the route-map comment explains why a code alone cannot be a URL:
+             * "`105` is a Metal Fight spin-track height, a bare number in Burst is
+             * a disc, and `1-60` is a Beyblade X ratchet." The id is
+             * `${slot}--${code}` (e.g. `armour--1b`), so splitting it is the one
+             * derivation guaranteed to agree with the page that exists.
+             */
+            if (!id.includes("--"))
+                return null;
+            const code = str(d.code);
+            const classification = str(d.classification);
+            return {
+                title: name,
+                // The classification IS the disambiguation — it is why a user
+                // searching "105" can tell three results apart.
+                detail: [classification, code].filter(Boolean).join(" · "),
+            };
+        },
+    },
+    {
+        typeKey: "model",
+        collection: "modelComposition",
+        select: ["name", "system", "categoryId"],
+        slugOf: (_id, d) => str(d.categoryId),
+        toRecord: (_id, d) => {
+            const name = str(d.name);
+            if (!name)
+                return null;
+            /*
+             * 🛑 A composition has no page of its own — it is rendered on its model
+             * CATEGORY page, reached by `categoryId`. Measured in `parts/data.ts`:
+             * 210 of 259 join. The 49 that do not are DROPPED rather than linked to
+             * a guess, because a search result that navigates to the wrong bey is
+             * worse than one that does not exist. The builder reports the count.
+             */
+            const categoryId = str(d.categoryId);
+            if (!categoryId)
+                return null;
+            return { title: name, detail: str(d.system) ?? "", slug: categoryId };
+        },
+    },
+    {
+        typeKey: "store",
+        collection: "stores",
+        where: [["status", "active"]],
+        // `storeName`, not `name` — read off the live documents.
+        select: ["storeName", "storeCategory"],
+        slugOf: (id) => id,
+        toRecord: (id, d) => {
+            const name = str(d.storeName);
+            if (!name)
+                return null;
+            return { title: name, detail: str(d.storeCategory) ?? "", slug: id };
+        },
+    },
+    {
+        typeKey: "blog",
+        collection: "blogPosts",
+        where: [["status", "published"]],
+        select: ["title", "slug", "category", "excerpt"],
+        slugOf: (id, d) => str(d.slug) ?? id,
+        toRecord: (id, d) => {
+            const title = str(d.title);
+            if (!title)
+                return null;
+            return {
+                title,
+                detail: str(d.category) ?? (str(d.excerpt) ?? "").slice(0, 90),
+            };
+        },
+    },
+    {
+        typeKey: "event",
+        collection: "events",
+        // Three public statuses, one `==` — so it is filtered in memory, the same
+        // reason `search-sources.ts` gives.
+        select: ["title", "slug", "type", "status"],
+        slugOf: (id, d) => str(d.slug) ?? id,
+        toRecord: (id, d) => {
+            const title = str(d.title);
+            if (!title)
+                return null;
+            const status = str(d.status);
+            if (status === "draft" || status === "cancelled")
+                return null;
+            return { title, detail: (str(d.type) ?? "").replace(/_/g, " "), slug: str(d.slug) ?? id };
+        },
+    },
+    {
+        typeKey: "faq",
+        collection: "faqs",
+        where: [["isActive", true]],
+        select: ["question", "category"],
+        slugOf: (_id, d) => str(d.category),
+        toRecord: (_id, d) => {
+            const question = str(d.question);
+            const category = str(d.category);
+            // `/faqs/[category]`, never a question slug — the route matches on the
+            // category key and silently falls back to "all" for anything else.
+            if (!question || !category)
+                return null;
+            return { title: question, detail: category.replace(/_/g, " "), slug: category };
+        },
+    },
+    {
+        typeKey: "review",
+        collection: "reviews",
+        where: [["status", "approved"]],
+        // 🛑 `productTitle`, never `userName`. The field exists on the document
+        // and is deliberately absent from `buildReviewSearchTxt` because it is
+        // encrypted; a public artifact must not carry a reviewer's name.
+        select: ["title", "productTitle"],
+        slugOf: (id) => id,
+        toRecord: (id, d) => {
+            const title = str(d.title);
+            if (!title)
+                return null;
+            return { title, detail: str(d.productTitle) ?? "", slug: id };
+        },
+    },
+    {
+        typeKey: "group",
+        collection: "groupedListings",
+        where: [["isActive", true]],
+        select: ["title", "slug", "groupTheme", "visibilityStatus"],
+        slugOf: (id, d) => str(d.slug) ?? id,
+        toRecord: (id, d) => {
+            const title = str(d.title);
+            if (!title)
+                return null;
+            if (str(d.visibilityStatus) !== "visible")
+                return null;
+            return { title, detail: str(d.groupTheme) ?? "", slug: str(d.slug) ?? id };
+        },
+    },
+    {
+        typeKey: "scammer",
+        collection: "scammerProfiles",
+        /*
+         * 🛑 `verified` ONLY. Live: verified 3, pending_review 1, rejected 1.
+         * Publishing an unaccepted allegation against a named person — with their
+         * phone and UPI on the destination page — into an artifact every browser
+         * downloads is the most consequential clause in this file.
+         */
+        where: [["status", "verified"]],
+        select: ["displayNames", "scamType", "slug"],
+        slugOf: (id, d) => str(d.slug) ?? id,
+        toRecord: (id, d) => {
+            const names = Array.isArray(d.displayNames) ? d.displayNames : [];
+            const title = str(names[0]);
+            if (!title)
+                return null;
+            return {
+                title,
+                detail: (str(d.scamType) ?? "").replace(/_/g, " "),
+            };
+        },
+    },
+    {
+        typeKey: "coupon",
+        collection: "coupons",
+        select: ["code", "name", "validity"],
+        slugOf: (_id, d) => str(d.code),
+        toRecord: (_id, d) => {
+            const code = str(d.code);
+            if (!code)
+                return null;
+            const validity = d.validity;
+            if (validity?.isActive === false)
+                return null;
+            // No amount — the discount VALUE is money and stays out. The code and
+            // its name are what someone types.
+            return { title: code, detail: str(d.name) ?? "", slug: code };
+        },
+    },
+];
+/** Index into `INDEX_TYPES` for a source's type key. */
+export function typeIndexFor(typeKey) {
+    return INDEX_TYPES.findIndex((t) => t.key === typeKey);
+}

package/dist/_internal/server/features/search/search-sources.d.ts

@@ -1,17 +1,2 @@
-/**
- * D2 Fix 4 — which collections `/search` spans, and how each row becomes a hit.
- *
- * 🛑 SIX SOURCES, not fifteen. The redirect page maps 15 `SearchResourceType`
- * values, but nine of them are LISTING TYPES inside `products` — auctions,
- * pre-orders, prize-draws, classified, digital-codes, live, art, bundles. One
- * `products` query covers all of them, and a per-type query would be nine
- * fan-outs returning overlapping rows from one collection.
- *
- * 🛑 Every field here was read off the live documents, not assumed. `stores`
- * uses `storeName` (not `name`), `faqs` uses `question` + `seo.slug`, and
- * `categories` must be filtered to listing rows because brands and bundles
- * share the collection — the same trap that made the `/products` category
- * facet offer "Takara-Tomy" as a browsable category (A1 item 4).
- */
 import type { SearchSource } from "./search-everything";
 export declare const SEARCH_SOURCES: readonly SearchSource[];

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

@@ -1,3 +1,39 @@
+/**
+ * D2 Fix 4 — which collections `/search` spans, and how each row becomes a hit.
+ *
+ * 🛑 NINE SOURCES, not fifteen. The redirect page maps 15 `SearchResourceType`
+ * values, but nine of them are LISTING TYPES inside `products` — auctions,
+ * pre-orders, prize-draws, classified, digital-codes, live, art, bundles. One
+ * `products` query covers all of them, and a per-type query would be nine
+ * fan-outs returning overlapping rows from one collection.
+ *
+ * 🛑 THREE MORE WERE PLANNED FOR THIS PASS AND DELIBERATELY LEFT OUT. Each
+ * would have been a source that renders as a working group and matches
+ * nothing, which is worse than an absent one:
+ *
+ *   partGlossary (752 rows) and groupedListings (10) — **0% `searchTxt`
+ *     coverage**, measured 2026-10-19. This file's mechanism is a single
+ *     `array-contains` push-down on that field, so a source over either
+ *     returns zero rows for every query, forever, with a 200. They are the
+ *     headline gap and they are answered by the prebuilt client index, which
+ *     needs a title and a slug rather than tokens — not by adding a token
+ *     writer for 762 documents to serve a query path that index replaces.
+ *
+ *   coupons — 100% token coverage, but there is no per-coupon public route.
+ *     Every hit would link to `/promotions`, which is already this group's
+ *     `moreHref`, so eleven rows would all point at one page. The code is
+ *     worth finding; a group of identical links is not the way.
+ *
+ * 🛑 Every field here was read off the live documents, not assumed. `stores`
+ * uses `storeName` (not `name`), `faqs` uses `question` + `seo.slug`, and
+ * `categories` must be filtered to listing rows because brands and bundles
+ * share the collection — the same trap that made the `/products` category
+ * facet offer "Takara-Tomy" as a browsable category (A1 item 4).
+ */
+// Imported from the DEFINING module, not a barrel (Root Cause #18) — and
+// never from `@mohasinac/appkit/client`, which is `"use client"` and would
+// make ROUTES a client-reference proxy in this server file (Root Cause #76).
+import { ROUTES } from "../../../../next/routing/route-map.js";
 const str = (v) => typeof v === "string" && v.trim() ? v.trim() : null;
 const withQ = (base, q) => q.trim() ? `${base}?q=${encodeURIComponent(q.trim())}` : base;
 export const SEARCH_SOURCES = [
@@ -28,7 +64,7 @@ export const SEARCH_SOURCES = [
                 ...(detail ? { detail } : {}),
             };
         },
-        moreHref: (q) => withQ("/products", q),
+        moreHref: (q) => withQ(ROUTES.PUBLIC.PRODUCTS, q),
     },
     {
         key: "categories",
@@ -55,7 +91,7 @@ export const SEARCH_SOURCES = [
                 return null;
             return { id, title: name, href: `/categories/${id}` };
         },
-        moreHref: (q) => withQ("/categories", q),
+        moreHref: (q) => withQ(ROUTES.PUBLIC.CATEGORIES, q),
     },
     {
         key: "brands",
@@ -71,7 +107,7 @@ export const SEARCH_SOURCES = [
             const detail = str(d.brandCountry);
             return { id, title: name, href: `/brands/${id}`, ...(detail ? { detail } : {}) };
         },
-        moreHref: (q) => withQ("/brands", q),
+        moreHref: (q) => withQ(ROUTES.PUBLIC.BRANDS, q),
     },
     {
         key: "stores",
@@ -86,7 +122,7 @@ export const SEARCH_SOURCES = [
                 return null;
             return { id, title: name, href: `/stores/${id}` };
         },
-        moreHref: (q) => withQ("/stores", q),
+        moreHref: (q) => withQ(ROUTES.PUBLIC.STORES, q),
     },
     {
         key: "blog",
@@ -106,7 +142,7 @@ export const SEARCH_SOURCES = [
                 ...(detail ? { detail } : {}),
             };
         },
-        moreHref: (q) => withQ("/blog", q),
+        moreHref: (q) => withQ(ROUTES.BLOG.LIST, q),
     },
     {
         key: "faqs",
@@ -129,10 +165,109 @@ export const SEARCH_SOURCES = [
             return {
                 id,
                 title: question,
-                href: category ? `/faqs/${category}` : "/faqs",
+                href: category ? ROUTES.PUBLIC.FAQ_CATEGORY(category) : ROUTES.PUBLIC.FAQS,
                 ...(category ? { detail: category.replace(/_/g, " ") } : {}),
             };
         },
-        moreHref: (q) => withQ("/faqs", q),
+        moreHref: (q) => withQ(ROUTES.PUBLIC.FAQS, q),
+    },
+    {
+        key: "events",
+        label: "Events",
+        collection: "events",
+        /*
+         * 🛑 No `where` clause, and that is forced rather than lazy. Measured on
+         * the live collection: `active` 8, `draft` 1, `paused` 1, `ended` 1,
+         * `cancelled` 1. The public set is "not draft, not cancelled" — three
+         * values — and `where` here applies `==` only, so a single clause would
+         * either publish drafts or hide every paused and ended event. Firestore
+         * cannot express the negation either (Root Cause #59). Same in-memory
+         * shape the `categories` source uses, for the same reason.
+         *
+         * `ended` stays visible deliberately: a search answers "do you have this",
+         * and an event that happened is a real answer with a real page.
+         */
+        select: ["title", "slug", "type", "status"],
+        toHit: (id, d) => {
+            const title = str(d.title);
+            if (!title)
+                return null;
+            const status = str(d.status);
+            if (status === "draft" || status === "cancelled")
+                return null;
+            const detail = str(d.type);
+            return {
+                id,
+                title,
+                href: ROUTES.PUBLIC.EVENT_DETAIL(str(d.slug) ?? id),
+                ...(detail ? { detail: detail.replace(/_/g, " ") } : {}),
+            };
+        },
+        moreHref: (q) => withQ(ROUTES.PUBLIC.EVENTS, q),
+    },
+    {
+        key: "reviews",
+        label: "Reviews",
+        collection: "reviews",
+        // All 79 live rows are `approved`; the clause is still explicit, because a
+        // rejected review surfacing publicly is the failure that matters here.
+        where: [["status", "approved"]],
+        /*
+         * 🛑 `productTitle` as the detail, NEVER `userName`. The field exists on
+         * the document and is deliberately absent from `buildReviewSearchTxt`
+         * because it is encrypted; `maskPublicReview` is what the public read path
+         * uses. A search hit is a public surface and has no business carrying a
+         * reviewer's name even in a subtitle.
+         */
+        select: ["title", "productTitle", "status"],
+        toHit: (id, d) => {
+            const title = str(d.title);
+            if (!title)
+                return null;
+            const detail = str(d.productTitle);
+            return {
+                id,
+                title,
+                href: ROUTES.PUBLIC.REVIEW_DETAIL(id),
+                ...(detail ? { detail } : {}),
+            };
+        },
+        moreHref: (q) => withQ(ROUTES.PUBLIC.REVIEWS, q),
+    },
+    {
+        key: "scammers",
+        label: "Scam reports",
+        collection: "scammerProfiles",
+        /*
+         * 🛑 `verified` ONLY, and this clause is the whole point of the source.
+         * Measured live: `verified` 3, `pending_review` 1, `rejected` 1. Surfacing
+         * an unverified or rejected accusation in site-wide search publishes an
+         * allegation the moderation queue has not accepted — against a named
+         * person, with their phone and UPI on the page. The scam registry is
+         * deliberately public and plaintext-indexed for SEO, which makes getting
+         * this clause right more load-bearing here than anywhere else, not less.
+         */
+        where: [["status", "verified"]],
+        /*
+         * 🛑 `displayNames` is an ARRAY, not a string — read off the live
+         * documents, which is what this file's header asks for and what caught it.
+         * A `str(d.displayName)` would have returned null for every row and the
+         * group would simply never have appeared.
+         */
+        select: ["displayNames", "scamType", "slug"],
+        toHit: (id, d) => {
+            const names = Array.isArray(d.displayNames) ? d.displayNames : [];
+            const title = str(names[0]);
+            if (!title)
+                return null;
+            const detail = str(d.scamType);
+            return {
+                id,
+                title,
+                href: ROUTES.PUBLIC.SCAM_DETAIL(str(d.slug) ?? id),
+                ...(detail ? { detail: detail.replace(/_/g, " ") } : {}),
+            };
+        },
+        moreHref: (q) => withQ(ROUTES.PUBLIC.SCAMS, q),
     },
 ];