@mohasinac/appkit 4.30.18 → 4.31.0

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

@@ -4,11 +4,19 @@
  * pages to hand `productFeatures` down as a prop and avoid per-card waterfalls.
  */
 import { productFeaturesRepository } from "./product-features.repository";
+import { safeRead } from "../../../errors/safe-read";
 export async function loadProductFeaturesForStore(storeId) {
+    // Feature badges decorate a card; a page without them is still correct, so
+    // both reads degrade — but a failure here silently strips "Free shipping" /
+    // "Authenticity guaranteed" from every card, which nobody would notice.
     const [platform, store] = await Promise.all([
-        productFeaturesRepository.listPlatform().catch(() => []),
+        safeRead(() => productFeaturesRepository.listPlatform(), {
+            route: "productFeatures", key: "productFeatures.platform", fallback: [],
+        }),
         storeId
-            ? productFeaturesRepository.listForStore(storeId).catch(() => [])
+            ? safeRead(() => productFeaturesRepository.listForStore(storeId), {
+                route: "productFeatures", key: "productFeatures.store", fallback: [],
+            })
             : Promise.resolve([]),
     ]);
     const seen = new Set();

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

@@ -281,7 +281,7 @@ export declare class ProductRepository extends BaseRepository<ProductDocument> {
             canFilter: boolean;
             canSort: boolean;
         };
-        "classified.meetupArea": {
+        "classified.meetupArea.city": {
             canFilter: boolean;
             canSort: boolean;
         };
@@ -317,6 +317,10 @@ export declare class ProductRepository extends BaseRepository<ProductDocument> {
             canFilter: boolean;
             canSort: boolean;
         };
+        "liveItem.transport.method": {
+            canFilter: boolean;
+            canSort: boolean;
+        };
     };
     /**
      * Virtual filter aliases — callers can pass `f=listingType==auction` for

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

@@ -452,10 +452,11 @@ export class ProductRepository extends BaseRepository {
                 .update({
                 [PRODUCT_FIELDS.VIEW_COUNT]: increment(1),
             });
+            // Fire-and-forget analytics: a lost view increment changes no rendered
+            // content, so it must never break the product read path it rides with.
         }
         catch (_err) {
             void normalizeError(_err);
-            // View analytics must not break product read path.
         }
     }
     /**
@@ -593,7 +594,22 @@ ProductRepository.SIEVE_FIELDS = {
     // silently skipped. The toggle did nothing at all until 2026-08-21.
     shippingPaidBy: { canFilter: true, canSort: false },
     searchTxt: { canFilter: true, canSort: false },
-    "classified.meetupArea": { canFilter: true, canSort: false },
+    /*
+     * `classified.meetupArea.city`, NOT `classified.meetupArea`.
+     *
+     * `meetupArea` is an OBJECT (`{city, locality, pincode}`), so an equality
+     * on the parent could never match anything a user typed. The city facet
+     * emits `classified.meetupArea.city` (TYPE_FACET_FIELD), `findField` is an
+     * exact-key lookup, and `throwExceptions:false` drops what it cannot
+     * resolve — so the /classified city filter rendered, counted toward the
+     * badge, and changed nothing. Both halves of Root Cause #62 in one entry:
+     * an orphan key that matches no field, beside a real field with no entry.
+     *
+     * The schema's own docstring already named the right path ("drives the
+     * (listingType, classified.meetupArea.city, createdAt) index"), and the
+     * store-scoped index has always been on `.city`.
+     */
+    "classified.meetupArea.city": { canFilter: true, canSort: false },
     "classified.acceptsShipping": { canFilter: true, canSort: false },
     "classified.negotiable": { canFilter: true, canSort: false },
     "digitalCode.codeDeliveryMethod": { canFilter: true, canSort: false },
@@ -602,6 +618,13 @@ ProductRepository.SIEVE_FIELDS = {
     "liveItem.sex": { canFilter: true, canSort: false },
     "liveItem.jurisdictionAllowed": { canFilter: true, canSort: false },
     "liveItem.cites": { canFilter: true, canSort: false },
+    /*
+     * The live-items transport facet. `StoreLiveItemsListing` has listed
+     * `liveTransportMethod` in its FILTER_KEYS — so ticking it inflated the
+     * active-filter badge — while the key had no TYPE_FACET_FIELD mapping and
+     * this field had no entry, so it never reached Firestore from either end.
+     */
+    "liveItem.transport.method": { canFilter: true, canSort: false },
 };
 /**
  * Virtual filter aliases — callers can pass `f=listingType==auction` for

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

@@ -64,11 +64,15 @@ export interface ProductClassifiedMeta {
         locality?: string;
         pincode?: string;
     };
-    /** How the buyer reaches the seller (chat | phone | both). */
-    contactMethod?: "chat" | "phone" | "both";
     /** Seller offers shipping in addition to meetup. */
     acceptsShipping?: boolean;
-    /** Price is negotiable — UI hints "₹X (negotiable)". */
+    /**
+     * Price is negotiable — UI hints "₹X (negotiable)".
+     *
+     * Its sibling `allowOffers` is what actually gates the offer FLOOR on this
+     * type: unset means the buyer may still request to buy, but only at the
+     * asking price.
+     */
     negotiable?: boolean;
 }
 export interface ProductDigitalCodeMeta {

package/dist/features/products/schemas/product-features.validators.js

@@ -110,6 +110,9 @@ export const productFeatureFormSchema = z.object({
     storeId: annotate(productFeatureAdminCreateSchema.shape.storeId, {
         section: "scope", order: 4, row: "pair",
         help: "Only used when scope is \"store\".",
+        // Hidden for a global feature, and paired with visibleValues at the
+        // payload so a store id chosen and then abandoned is not saved.
+        when: (v) => v.scope === "store",
     }),
     isActive: annotate(productFeatureAdminCreateSchema.shape.isActive, {
         section: "visibility", sectionLabel: "Visibility", order: 1, row: "quarter",

package/dist/features/promotions/components/CouponCard.js

@@ -5,7 +5,6 @@ import { useState } from "react";
 import { Pencil, Trash2, ToggleLeft, ToggleRight } from "lucide-react";
 import { Badge, BaseListingCard, Button, ConfirmDeleteModal, Div, IconButton, Row, Span, Stack, Text } from "../../../ui";
 import { useLongPress } from "../../../react/hooks/useLongPress";
-import { useFeatureFlags } from "../../../client/api/useFeatureFlags";
 import { ACCOUNT_ENDPOINTS } from "../../../constants/api-endpoints";
 const CLS_TOGGLE_ON = "h-4 w-4 text-success dark:text-success";
 const CLS_DELETE_BTN = "p-[var(--appkit-space-1-5)] text-[var(--appkit-color-text-muted)] hover:bg-error-surface dark:hover:bg-error-surface hover:text-error dark:hover:text-error transition-colors disabled:opacity-50";
@@ -102,12 +101,14 @@ export function CouponCard({ coupon, labels: labelsProp, onCopy, className = "",
     const discountLabel = formatDiscount(n, labels);
     const hasAdminActions = Boolean(onEdit || onToggleActive || onDelete);
     // Show Claim by default on public surfaces; hide automatically when this
-    // card is being rendered with admin/CRUD actions wired. Also hidden
-    // whenever the COUPONS feature is disabled — the claim endpoint 404s in
-    // that state, and previously that 404 was silently swallowed (see
-    // handleClaim below) instead of the CTA simply not being offered.
-    const { flags: featureFlags } = useFeatureFlags();
-    const showClaim = (hideClaim === undefined ? !hasAdminActions : !hideClaim) && featureFlags.COUPONS === true;
+    // card is being rendered with admin/CRUD actions wired.
+    //
+    // This also consulted the `COUPONS` env feature flag, because the claim
+    // endpoint 404'd when it was off. Both flag systems were deleted 2026-08-29 —
+    // the flag was `true` in every environment, and the endpoint now answers
+    // unconditionally under its own auth — so the fetch that backed this check
+    // is gone too, along with a network request on every coupon card render.
+    const showClaim = hideClaim === undefined ? !hasAdminActions : !hideClaim;
     const handleCopy = () => {
         if (!n.code)
             return;
@@ -131,10 +132,12 @@ export function CouponCard({ coupon, labels: labelsProp, onCopy, className = "",
                     credentials: "include",
                     body: JSON.stringify({ couponCode: n.code, source: claimSource }),
                 });
+                // An anonymous visitor gets a 401 here by design, so a failure cannot
+                // be distinguished from the expected case. The redirect below still
+                // pre-fills the code, which is what the user actually asked for.
             }
             catch (_err) {
                 void normalizeError(_err);
-                /* anon/network — non-fatal */
             }
             if (typeof window !== "undefined") {
                 window.location.href = `/cart?coupon=${encodeURIComponent(n.code)}`;

package/dist/features/reviews/actions/review-actions.js

@@ -10,6 +10,7 @@ import { serverLogger } from "../../../monitoring";
 import { maskPublicReview } from "../../../security";
 import { finalizeStagedMediaArray, finalizeStagedMediaUrl, } from "../../media/finalize";
 import { reviewRepository } from "../repository/reviews.repository";
+import { safeRead } from "../../../errors/safe-read";
 import { productRepository } from "../../products/repository/products.repository";
 import { ProductStatusValues } from "../../products/schemas";
 import { userRepository } from "../../auth/repository/user.repository";
@@ -185,7 +186,13 @@ export async function listReviewsBySeller(sellerId) {
     }
     const reviewBatches = await Promise.all(productIds
         .slice(0, 20)
-        .map((id) => reviewRepository.findApprovedByProduct(id, 50).catch(() => [])));
+        // One product's reviews failing must not empty the whole seller feed —
+        // but it silently thins it, so each miss is recorded.
+        .map((id) => safeRead(() => reviewRepository.findApprovedByProduct(id, 50), {
+        route: "reviews.bySeller",
+        key: "reviews.findApprovedByProduct",
+        fallback: [],
+    })));
     // Each per-product batch is newest-first, but concatenating them yields product order,
     // not chronological order — the flattened list has to be re-sorted or callers get an
     // arbitrarily interleaved "latest reviews" list.

package/dist/features/reviews/components/ReviewDetailPageView.js

@@ -1,12 +1,16 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import Link from "next/link";
 import { reviewRepository } from "../../../repositories";
+import { safeRead } from "../../../errors/safe-read";
 import { Container, Div, Grid, Heading, Main, Nav, Section, Span, Text } from "../../../ui";
 import { ROUTES } from "../../../next";
 import { ReviewDetailShell } from "./ReviewDetailShell";
 import { ReviewCard } from "./ReviewsList";
 export async function ReviewDetailPageView({ id }) {
-    const doc = await reviewRepository.findById(id).catch(() => null);
+    // The review IS this page's subject — a read failure must surface rather than
+    // become the same `null` a removed review produces, which the "Review not
+    // found" branch below already handles.
+    const doc = await reviewRepository.findById(id);
     const review = doc;
     // storeId === storeSlug for stores in this project (pure slug IDs)
     const storeSlug = doc?.storeId ?? null;
@@ -15,8 +19,14 @@ export async function ReviewDetailPageView({ id }) {
     }
     const [sameProductDocs, sameStoreDocs] = await Promise.all([
         // 12 = the 6 rendered below, with headroom for the current review + any filtered out.
-        reviewRepository.findApprovedByProduct(review.productId, 12).catch(() => []),
-        storeSlug ? reviewRepository.findApprovedByStore(storeSlug).catch(() => []) : Promise.resolve([]),
+        safeRead(() => reviewRepository.findApprovedByProduct(review.productId, 12), {
+            route: "/reviews/[id]", key: "review.sameProduct", fallback: [],
+        }),
+        storeSlug
+            ? safeRead(() => reviewRepository.findApprovedByStore(storeSlug), {
+                route: "/reviews/[id]", key: "review.sameStore", fallback: [],
+            })
+            : Promise.resolve([]),
     ]);
     const sameProductReviews = sameProductDocs.filter((r) => r.id !== review.id).slice(0, 6);
     const sameStoreReviews = sameStoreDocs.filter((r) => r.id !== review.id).slice(0, 6);

package/dist/features/reviews/components/ReviewDetailShell.js

@@ -80,10 +80,12 @@ export function ReviewDetailShell({ review, storeHref }) {
             }
             setVoted(true);
             localStorage.setItem(storageKey, "1");
+            // The button stays un-voted and the count unchanged, so the user can
+            // simply press it again — this shell has no toast host of its own, and a
+            // failed helpful-vote costs nothing.
         }
         catch (_err) {
             void normalizeError(_err);
-            // silently fail
         }
         finally {
             setVoting(false);

package/dist/features/scams/actions/scam-actions.d.ts

@@ -30,7 +30,15 @@ export declare function getPublicScammerById(id: string): Promise<ScammerDocumen
  * Returns null if not found or not verified.
  */
 export declare function getScammerProfilePageData(id: string): Promise<ScammerProfilePageData | null>;
-export type SellerTrustStatus = "clear" | "flagged";
+/**
+ * `unknown` exists because `clear` is a POSITIVE SAFETY CLAIM — it renders as
+ * "✓ Verified Safe" next to a seller's name. Every read in
+ * `getSellerTrustStatus` used to fail open to `clear`, so a scam-registry
+ * outage actively endorsed a seller nobody had checked. Failing open is still
+ * right (an outage must not brand a legitimate seller a scammer), but the
+ * honest failure state is "we could not check", not "we checked and it's fine".
+ */
+export type SellerTrustStatus = "clear" | "flagged" | "unknown";
 export interface SellerTrustResult {
     status: SellerTrustStatus;
     /** seoSlug of matched verified scammer profiles — links to /scams/[slug]. Empty when clear. */

package/dist/features/scams/actions/scam-actions.js

@@ -1,6 +1,7 @@
 "use server";
 import { sieveFilter, SIEVE_OP } from "@mohasinac/appkit";
 import { scammerRepository } from "../repository/scammer.repository";
+import { safeRead } from "../../../errors/safe-read";
 import { userRepository } from "../../auth/repository/user.repository";
 import { storeRepository } from "../../stores/repository/store.repository";
 import { safeFireAndForget } from "../../../utils/safe-fire-forget";
@@ -39,9 +40,12 @@ export async function listVerifiedScammers(searchParams) {
  */
 export async function getPublicScammerById(id) {
     // Try direct id lookup first; fall back to seoSlug query.
-    let doc = await scammerRepository.findById(id).catch(() => null);
+    // The profile IS the caller's subject, and both lookups already return null
+    // for "no such id/slug" — swallowing a read failure into that same null would
+    // report a real outage as a missing profile.
+    let doc = await scammerRepository.findById(id);
     if (!doc) {
-        doc = await scammerRepository.findBySeoSlug(id).catch(() => null);
+        doc = await scammerRepository.findBySeoSlug(id);
     }
     if (!doc || doc.status !== "verified")
         return null;
@@ -66,27 +70,63 @@ export async function getScammerProfilePageData(id) {
     return { scammer, incidents, comments, relatedScammers, similarScamReports };
 }
 const TRUST_STATUS_CLEAR = { status: "clear", matchedProfileSlugs: [] };
+const TRUST_STATUS_UNKNOWN = { status: "unknown", matchedProfileSlugs: [] };
+/**
+ * Wrap a read so a FAILURE is distinguishable from a legitimate empty result.
+ *
+ * `safeRead` alone cannot express this: its fallback has the same type as a
+ * successful read, so `null` from a failed store lookup and `null` from a store
+ * that does not exist are the same value. Tagging the outcome is what lets the
+ * caller answer "unknown" instead of "clear".
+ */
+async function readTagged(fn, key) {
+    return safeRead(async () => ({ ok: true, value: await fn() }), {
+        route: "sellerTrust",
+        key,
+        fallback: { ok: false, value: null },
+    });
+}
 /**
  * P-12 — resolves a store owner's phone/email against the verified (admin-published)
  * scammer registry only. Never surfaces "under review" reports to buyers — a report
  * that hasn't been verified must not damage a seller's storefront reputation.
  */
 export async function getSellerTrustStatus(storeId) {
-    const store = await storeRepository.findById(storeId).catch(() => null);
-    if (!store?.ownerId)
+    // Every read below fails OPEN to "clear" — a deliberate choice, because a
+    // registry outage must not brand a legitimate seller a scammer. But "clear"
+    // is a positive safety claim, so a failure that produces one has to be
+    // recorded rather than inferred from a silent null.
+    const store = await readTagged(() => storeRepository.findById(storeId), "sellerTrust.store");
+    if (!store.ok)
+        return TRUST_STATUS_UNKNOWN;
+    if (!store.value?.ownerId)
         return TRUST_STATUS_CLEAR;
-    const owner = await userRepository.findById(store.ownerId).catch(() => null);
-    if (!owner)
+    const ownerId = store.value.ownerId;
+    const owner = await readTagged(() => userRepository.findById(ownerId), "sellerTrust.owner");
+    if (!owner.ok)
+        return TRUST_STATUS_UNKNOWN;
+    if (!owner.value)
         return TRUST_STATUS_CLEAR;
+    const ownerDoc = owner.value;
     const lookups = [];
-    if (owner.phoneNumber)
-        lookups.push(scammerRepository.findByContactField("phones", owner.phoneNumber));
-    if (owner.email)
-        lookups.push(scammerRepository.findByContactField("emails", owner.email));
+    if (ownerDoc.phoneNumber) {
+        const phone = ownerDoc.phoneNumber;
+        lookups.push(() => scammerRepository.findByContactField("phones", phone));
+    }
+    if (ownerDoc.email) {
+        const email = ownerDoc.email;
+        lookups.push(() => scammerRepository.findByContactField("emails", email));
+    }
     if (lookups.length === 0)
         return TRUST_STATUS_CLEAR;
-    const results = await Promise.all(lookups.map((p) => p.catch(() => [])));
-    const verified = results.flat().filter((s) => s.status === "verified");
+    const results = await Promise.all(lookups.map((fn) => readTagged(fn, "sellerTrust.registryLookup")));
+    // A partial answer is not an answer: if ANY registry lookup failed we cannot
+    // say the seller is clear, only that we could not check.
+    if (results.some((r) => !r.ok))
+        return TRUST_STATUS_UNKNOWN;
+    const verified = results
+        .flatMap((r) => r.value ?? [])
+        .filter((s) => s.status === "verified");
     if (verified.length === 0)
         return TRUST_STATUS_CLEAR;
     return {

package/dist/features/scams/components/SellerTrustBadge.d.ts

@@ -13,4 +13,4 @@ export interface SellerTrustBadgeProps {
  * unrelated homepage-section `TrustBadge` config type in
  * features/homepage/index.ts (marketing trust-badge icons row).
  */
-export declare function SellerTrustBadge({ trust, className }: SellerTrustBadgeProps): import("react").JSX.Element;
+export declare function SellerTrustBadge({ trust, className }: SellerTrustBadgeProps): import("react").JSX.Element | null;

package/dist/features/scams/components/SellerTrustBadge.js

@@ -13,6 +13,19 @@ import { ROUTES } from "../../../next";
  * features/homepage/index.ts (marketing trust-badge icons row).
  */
 export function SellerTrustBadge({ trust, className = "" }) {
+    // 🛑 `unknown` MUST be handled before the flagged fallthrough below, and must
+    // never render as "Verified Safe".
+    //
+    // Every read in getSellerTrustStatus used to fail open to "clear", so a
+    // scam-registry outage produced an explicit safety endorsement for a seller
+    // nobody had checked. Failing open is still right — an outage must not brand
+    // a legitimate seller a scammer — but the honest failure state is "we could
+    // not check", which is neither of the two claims this badge otherwise makes.
+    // Rendering nothing is deliberate: a neutral badge would still be a statement,
+    // and the absence of a badge already means "no verified match" everywhere the
+    // registry is not consulted.
+    if (trust.status === "unknown")
+        return null;
     if (trust.status === "clear") {
         return (_jsx(Badge, { variant: "success", className: className, children: "\u2713 Verified Safe" }));
     }

package/dist/features/scams/repository/scammer.repository.js

@@ -122,10 +122,11 @@ class ScammerRepository extends BaseRepository {
             await this.getCollection()
                 .doc(id)
                 .update({ [SCAMMER_FIELDS.VIEWS]: increment(1) });
+            // Fire-and-forget analytics: a lost view increment changes no rendered
+            // content, so it must never break the profile read it rides along with.
         }
         catch (_err) {
             void normalizeError(_err);
-            // Fire-and-forget by design.
         }
     }
     /**

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

@@ -138,6 +138,20 @@ export interface ScammerDocument extends BaseDocument {
      * Admin records keep the uid; public page shows "Anonymous".
      */
     reportedByAnon: boolean;
+    /**
+     * The reporter ticked "I confirm this report is truthful and accurate".
+     *
+     * 🛑 The form has always REQUIRED this — a `z.literal(true)` in
+     * `scamReportFormSchema` and a hard gate on submit — and never sent it. On a
+     * surface where a false report gets someone listed publicly and has account
+     * consequences for the reporter, the attestation is precisely the record you
+     * want to keep, and it existed only as a client-side gate that any direct
+     * call to the route bypassed entirely.
+     *
+     * Optional on the document so the rows written before 2026-08-29 stay valid;
+     * absent means "not recorded", which is honest, and is NOT the same as false.
+     */
+    reporterAttested?: boolean;
     status: ScammerStatus;
     /** UID of admin/employee who verified or rejected. */
     verifiedBy?: string;
@@ -342,7 +356,7 @@ export declare const SCAMMER_INDEXED_FIELDS: readonly ["status", "scamType", "sc
 export declare const DEFAULT_SCAMMER_DATA: Partial<ScammerDocument>;
 /** Max pending submissions per user — prevents spam flooding. */
 export declare const MAX_PENDING_SCAMMER_REPORTS_PER_USER = 5;
-export type ScammerCreateInput = Pick<ScammerDocument, "displayNames" | "phones" | "upiIds" | "emails" | "socialMedia" | "scamType" | "scamPlatform" | "description" | "amountLost" | "itemInvolved" | "evidence" | "reportedBy" | "reportedByAnon">;
+export type ScammerCreateInput = Pick<ScammerDocument, "displayNames" | "phones" | "upiIds" | "emails" | "socialMedia" | "scamType" | "scamPlatform" | "description" | "amountLost" | "itemInvolved" | "evidence" | "reportedBy" | "reportedByAnon" | "reporterAttested">;
 export type ScammerAdminUpdateInput = Partial<Pick<ScammerDocument, "status" | "verifiedBy" | "verifiedAt" | "verificationNote" | "relatedScammerIds" | "mergedFromIds" | "tags" | "displayNames" | "phones" | "upiIds" | "emails" | "socialMedia" | "isContested">>;
 export declare const SCAMMER_FIELDS: {
     readonly ID: "id";

package/dist/features/scams/schemas/report-form.d.ts

@@ -5,7 +5,7 @@ export declare const scamReportFormSchema: z.ZodEffects<z.ZodObject<{
     upiIds: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
     emails: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
     scamType: z.ZodString;
-    scamPlatform: z.ZodOptional<z.ZodString>;
+    scamPlatform: z.ZodString;
     amountLost: z.ZodOptional<z.ZodNumber>;
     itemInvolved: z.ZodOptional<z.ZodString>;
     description: z.ZodString;
@@ -15,9 +15,9 @@ export declare const scamReportFormSchema: z.ZodEffects<z.ZodObject<{
     displayName: string;
     description: string;
     scamType: string;
+    scamPlatform: string;
     agreed: true;
     reportedByAnon?: boolean | undefined;
-    scamPlatform?: string | undefined;
     amountLost?: number | undefined;
     itemInvolved?: string | undefined;
     phones?: string[] | undefined;
@@ -27,9 +27,9 @@ export declare const scamReportFormSchema: z.ZodEffects<z.ZodObject<{
     displayName: string;
     description: string;
     scamType: string;
+    scamPlatform: string;
     agreed: true;
     reportedByAnon?: boolean | undefined;
-    scamPlatform?: string | undefined;
     amountLost?: number | undefined;
     itemInvolved?: string | undefined;
     phones?: string[] | undefined;
@@ -39,9 +39,9 @@ export declare const scamReportFormSchema: z.ZodEffects<z.ZodObject<{
     displayName: string;
     description: string;
     scamType: string;
+    scamPlatform: string;
     agreed: true;
     reportedByAnon?: boolean | undefined;
-    scamPlatform?: string | undefined;
     amountLost?: number | undefined;
     itemInvolved?: string | undefined;
     phones?: string[] | undefined;
@@ -51,9 +51,9 @@ export declare const scamReportFormSchema: z.ZodEffects<z.ZodObject<{
     displayName: string;
     description: string;
     scamType: string;
+    scamPlatform: string;
     agreed: true;
     reportedByAnon?: boolean | undefined;
-    scamPlatform?: string | undefined;
     amountLost?: number | undefined;
     itemInvolved?: string | undefined;
     phones?: string[] | undefined;

package/dist/features/scams/schemas/report-form.js

@@ -45,8 +45,17 @@ export const scamReportFormSchema = z
     scamType: annotate(z.string().trim().min(1, "Choose what kind of scam this was."), {
         section: "what", sectionLabel: "What happened", sectionRequired: true, quick: true, order: 1, row: "pair",
     }),
-    scamPlatform: annotate(z.string().trim().max(120).optional(), {
-        section: "what", order: 2, row: "pair",
+    /*
+     * Required, matching `POST /api/scams/reports` (`z.string().min(1)`).
+     *
+     * It was `.optional()` here, so a report with no platform passed every
+     * client check and came back a 400. The page papered over it with a
+     * hand-written `if (!form.scamType || !form.scamPlatform)` guard — which is
+     * the same drift as the address postal rule: two rules for one field, and
+     * the looser one is the client's.
+     */
+    scamPlatform: annotate(z.string().trim().min(1, "Choose where this happened.").max(120), {
+        section: "what", order: 2, row: "pair", kind: "select",
     }),
     /*
      * Coerced and bounded. It arrives from a text input and is rendered on the
@@ -62,10 +71,16 @@ export const scamReportFormSchema = z
     itemInvolved: annotate(z.string().trim().max(200).optional(), {
         section: "what", order: 4, row: "pair",
     }),
+    /*
+     * 100, matching the route. It was 30 here, so a 31-character description
+     * satisfied every client check and came back a 400 — and the page's own
+     * hand-written guard used 100, which is the number that was actually
+     * enforced. Two rules, three values.
+     */
     description: annotate(z
         .string()
         .trim()
-        .min(30, "Describe what happened in at least 30 characters — this is the evidence.")
+        .min(100, "Describe what happened in at least 100 characters — this is the evidence.")
         .max(5000, "Keep the description under 5000 characters."), { section: "what", order: 5, row: "full", kind: "textarea" }),
     reportedByAnon: annotate(z.boolean().optional(), {
         section: "declare", sectionLabel: "Declaration", order: 1, row: "quarter",

package/dist/features/search/action-index/derive.d.ts

@@ -0,0 +1,49 @@
+import type { NavPortal, SidebarNavGroup } from "../../../_internal/shared/features/layout/types";
+import type { ActionIndexEntry } from "./types";
+/** A nav group set, with the portal it belongs to. */
+export interface PortalNavGroups {
+    portal: NavPortal;
+    /** Human name for the breadcrumb — "Admin", "Seller", "Account". */
+    portalLabel: string;
+    groups: readonly SidebarNavGroup[];
+}
+/**
+ * Every sidebar entry, as an index entry.
+ *
+ * `sectionPath` is the breadcrumb a result row shows — "Admin › System › Site
+ * Settings" — and it is the reason the group title is worth carrying: two
+ * portals both have "Orders", and without the path a result list shows the
+ * same word twice with no way to tell which one you want.
+ */
+export declare function deriveNavEntries(sources: readonly PortalNavGroups[]): ActionIndexEntry[];
+/** One quick action, as the registry stores it. */
+export interface QuickActionSource {
+    id: string;
+    label: string;
+    description?: string;
+    keywords?: string[];
+    href?: string;
+    routeKey?: string;
+    iconKey?: string;
+    requiredPermission?: string;
+    requiredRole?: string;
+    requiresAuth?: boolean;
+}
+/**
+ * Quick actions, as index entries.
+ *
+ * 🛑 An action with no resolvable href is DROPPED, not indexed with a blank
+ * one. `DASHBOARD_QUICK_ACTION_META`'s `routeKey` is dead — every page
+ * re-declares its own `*_QUICK_ACTION_HREFS` map instead — so a registry entry
+ * may genuinely have nowhere to go. Indexing it anyway produces a search
+ * result that does nothing when clicked, which is worse than not finding it.
+ */
+export declare function deriveQuickActionEntries(actions: readonly QuickActionSource[], portal: NavPortal, portalLabel: string, hrefFor: (action: QuickActionSource) => string | undefined): ActionIndexEntry[];
+/**
+ * Assemble the static base.
+ *
+ * Deduplicated by id, first writer winning, so a quick action that shares an
+ * id with a nav entry does not produce two rows for one destination — and the
+ * nav entry, being passed first, is the one that survives.
+ */
+export declare function buildActionIndexBase(...groups: readonly ActionIndexEntry[][]): ActionIndexEntry[];