@mohasinac/appkit 4.34.0 → 4.35.0

package/dist/_internal/client/features/lottery/LotteryAdminEditView.js

@@ -96,8 +96,38 @@ export function LotteryAdminEditView({ eventId, initialData, onSubmit, }) {
  * `audit-code-quality`'s DEEP_NESTING rule exists to stop.
  */
 function SlotTable({ slots, showPrice, onSlotsChange, }) {
-    const addSlot = () => onSlotsChange([...slots, { slotNumber: slots.length + 1, name: "", price: 0 }]);
-    const removeSlot = (idx) => onSlotsChange(slots.filter((_, i) => i !== idx).map((s, i) => ({ ...s, slotNumber: i + 1 })));
+    /**
+     * Next number is max+1, not length+1.
+     *
+     * Now that removeSlot preserves numbering, `slots.length + 1` collides: delete
+     * slot 1 of 25 and you hold 24 slots numbered 2..25, so length+1 is 25 — a
+     * duplicate, which the write schema rejects outright (slot numbers must be
+     * unique). Deriving from the highest number in use is stable under any gaps.
+     */
+    const addSlot = () => onSlotsChange([
+        ...slots,
+        { slotNumber: slots.reduce((max, s) => Math.max(max, s.slotNumber), 0) + 1, name: "", price: 0 },
+    ]);
+    /**
+     * 🛑 Remove the slot. Do NOT renumber the survivors.
+     *
+     * `slotNumber` is the stable identity a booking is attached to, and renumbering
+     * silently defeated the server's own protection. `mergeLotteryConfig` refuses a
+     * save that drops a BOOKED slot by checking `isBooked && !incoming.has(slotNumber)`
+     * — but this function used to renumber the remaining slots to `i + 1`, so deleting
+     * slot 1 of 25 sent back numbers 1..24. Every booked number (1–5) still *appeared*
+     * in that set, the check found nothing to refuse, and the save went through.
+     *
+     * The damage was worse than the deletion: the merge re-attaches bookings by
+     * slotNumber, so the buyer of the deleted slot 1 had their booking moved onto
+     * whatever prize now occupied number 1. That is precisely the hazard the schema
+     * header describes — "hands slot 7's buyer the prize that used to be slot 8".
+     *
+     * Numbers may therefore be non-contiguous after a delete (2..25), which the write
+     * schema allows: it requires slot numbers to be UNIQUE, not gapless, and totalSlots
+     * is derived from slots.length rather than from the highest number.
+     */
+    const removeSlot = (idx) => onSlotsChange(slots.filter((_, i) => i !== idx));
     const updateSlot = (idx, field, value) => onSlotsChange(slots.map((s, i) => i === idx
         ? {
             ...s,

package/dist/_internal/server/features/seo/sitemap.js

@@ -16,8 +16,8 @@ const PRODUCT_SLUG = "slug";
 const PRODUCT_UPDATED_AT = "updatedAt";
 /**
  * Tester-sandbox fixtures must never reach the public sitemap. They are created
- * and destroyed on a cycle by `testerSandboxCleanup` / `testerSandboxRefresh`,
- * so anything Google indexes from them 404s shortly after. 34 of 182 sitemap
+ * and destroyed on a cycle by `testerSandboxCleanup` and by each tester run's
+ * wipe/seed, so anything Google indexes from them 404s shortly after. 34 of 182 sitemap
  * URLs were disposable test fixtures before this filter existed.
  *
  * 🛑 This MUST be an in-memory filter, never a Firestore inequality on the

package/dist/_internal/server/functions/scheduled.d.ts

@@ -22,9 +22,8 @@ export declare const cleanupRtdbEvents: import("./types").ScheduledFunctionDefin
 export declare const mediaTmpCleanup: import("./types").ScheduledFunctionDefinition;
 export declare const draftPrune: import("./types").ScheduledFunctionDefinition;
 export declare const testerSandboxCleanup: import("./types").ScheduledFunctionDefinition;
-export declare const testerSandboxRefresh: import("./types").ScheduledFunctionDefinition;
 export declare const prizeDrawExpiryReveal: import("./types").ScheduledFunctionDefinition;
 export declare const bundleStockSync: import("./types").ScheduledFunctionDefinition;
 export declare const emiInstallmentReminder: import("./types").ScheduledFunctionDefinition;
 export declare const catalogueImageStalenessReminder: import("./types").ScheduledFunctionDefinition;
-export declare const SCHEDULED_FUNCTIONS: readonly [import("./types").ScheduledFunctionDefinition, import("./types").ScheduledFunctionDefinition, import("./types").ScheduledFunctionDefinition, import("./types").ScheduledFunctionDefinition, import("./types").ScheduledFunctionDefinition, import("./types").ScheduledFunctionDefinition, import("./types").ScheduledFunctionDefinition, import("./types").ScheduledFunctionDefinition, import("./types").ScheduledFunctionDefinition, import("./types").ScheduledFunctionDefinition, import("./types").ScheduledFunctionDefinition, import("./types").ScheduledFunctionDefinition, import("./types").ScheduledFunctionDefinition, import("./types").ScheduledFunctionDefinition, import("./types").ScheduledFunctionDefinition, import("./types").ScheduledFunctionDefinition, import("./types").ScheduledFunctionDefinition, import("./types").ScheduledFunctionDefinition, import("./types").ScheduledFunctionDefinition, import("./types").ScheduledFunctionDefinition, import("./types").ScheduledFunctionDefinition, import("./types").ScheduledFunctionDefinition, import("./types").ScheduledFunctionDefinition, import("./types").ScheduledFunctionDefinition, import("./types").ScheduledFunctionDefinition, import("./types").ScheduledFunctionDefinition, import("./types").ScheduledFunctionDefinition, import("./types").ScheduledFunctionDefinition, import("./types").ScheduledFunctionDefinition];
+export declare const SCHEDULED_FUNCTIONS: readonly [import("./types").ScheduledFunctionDefinition, import("./types").ScheduledFunctionDefinition, import("./types").ScheduledFunctionDefinition, import("./types").ScheduledFunctionDefinition, import("./types").ScheduledFunctionDefinition, import("./types").ScheduledFunctionDefinition, import("./types").ScheduledFunctionDefinition, import("./types").ScheduledFunctionDefinition, import("./types").ScheduledFunctionDefinition, import("./types").ScheduledFunctionDefinition, import("./types").ScheduledFunctionDefinition, import("./types").ScheduledFunctionDefinition, import("./types").ScheduledFunctionDefinition, import("./types").ScheduledFunctionDefinition, import("./types").ScheduledFunctionDefinition, import("./types").ScheduledFunctionDefinition, import("./types").ScheduledFunctionDefinition, import("./types").ScheduledFunctionDefinition, import("./types").ScheduledFunctionDefinition, import("./types").ScheduledFunctionDefinition, import("./types").ScheduledFunctionDefinition, import("./types").ScheduledFunctionDefinition, import("./types").ScheduledFunctionDefinition, import("./types").ScheduledFunctionDefinition, import("./types").ScheduledFunctionDefinition, import("./types").ScheduledFunctionDefinition, import("./types").ScheduledFunctionDefinition, import("./types").ScheduledFunctionDefinition];

package/dist/_internal/server/functions/scheduled.js

@@ -1,6 +1,6 @@
 // Scheduled function definitions (Cloud Scheduler triggers).
 // Cron syntax accepts both Firebase shorthand and standard cron expressions.
-import { auctionSettlementHandler, autoPayoutEligibilityHandler, bundleStockSyncHandler, cartPruneHandler, cleanupRtdbEventsHandler, countersReconcileHandler, couponExpiryHandler, dailyDataCleanupHandler, draftPruneHandler, emiInstallmentReminderHandler, catalogueImageStalenessReminderHandler, mediaTmpCleanupHandler, notificationPruneHandler, offerExpiryHandler, payoutBatchHandler, paymentWindowTimeoutHandler, hardBanReinstatementHandler, paymentReviewAutoApproveHandler, pendingOrderTimeoutHandler, positionsReconcileHandler, prizeDrawExpiryRevealHandler, productStatsSyncHandler, revenueRollupHandler, pageViewRollupHandler, pageViewPruneHandler, dailyStatusDigestHandler, weeklyPayoutEligibilityHandler, testerSandboxCleanupHandler, testerSandboxRefreshHandler, } from "../jobs/handlers";
+import { auctionSettlementHandler, autoPayoutEligibilityHandler, bundleStockSyncHandler, cartPruneHandler, cleanupRtdbEventsHandler, countersReconcileHandler, couponExpiryHandler, dailyDataCleanupHandler, draftPruneHandler, emiInstallmentReminderHandler, catalogueImageStalenessReminderHandler, mediaTmpCleanupHandler, notificationPruneHandler, offerExpiryHandler, payoutBatchHandler, paymentWindowTimeoutHandler, hardBanReinstatementHandler, paymentReviewAutoApproveHandler, pendingOrderTimeoutHandler, positionsReconcileHandler, prizeDrawExpiryRevealHandler, productStatsSyncHandler, revenueRollupHandler, pageViewRollupHandler, pageViewPruneHandler, dailyStatusDigestHandler, weeklyPayoutEligibilityHandler, testerSandboxCleanupHandler, } from "../jobs/handlers";
 import { defineFunction } from "./define";
 const REGION = "asia-south1";
 const EVERY_5_MIN = "every 5 minutes";
@@ -182,13 +182,13 @@ export const testerSandboxCleanup = defineFunction({
     handler: testerSandboxCleanupHandler,
     options: { region: REGION, timeoutSeconds: 300, memory: "256MiB", maxInstances: 1 },
 });
-export const testerSandboxRefresh = defineFunction({
-    name: "testerSandboxRefresh",
-    description: "Revert live tester QA sandbox fixtures to their canonical seed shape and prune tester-created extras (every 4 hours).",
-    trigger: { kind: "schedule", cron: "0 */4 * * *", timeZone: "UTC" },
-    handler: testerSandboxRefreshHandler,
-    options: { region: REGION, timeoutSeconds: 300, memory: "256MiB", maxInstances: 1 },
-});
+// testerSandboxRefresh (every 4h: revert fixtures to seed shape, prune extras) was
+// REMOVED. The tester runner now owns fixture state — it seeds a known catalog at the
+// start of a run and wipes at the end — so a background job independently rewriting
+// those same documents was redundant and, worse, raced a run in progress: it reset
+// currentBid and recomputed auctionEndDate underneath a test that was mid-assertion.
+// Do not reinstate it without also deciding who owns fixture state; two owners is the
+// bug it caused. See tester/scripts/lifecycle.mjs.
 export const prizeDrawExpiryReveal = defineFunction({
     name: "prizeDrawExpiryReveal",
     description: "Assign winners for outstanding paid orders on scheduled-mode prize draws past their expiry, then close them (every 5 minutes).",
@@ -242,7 +242,6 @@ export const SCHEDULED_FUNCTIONS = [
     mediaTmpCleanup,
     draftPrune,
     testerSandboxCleanup,
-    testerSandboxRefresh,
     prizeDrawExpiryReveal,
     bundleStockSync,
     emiInstallmentReminder,

package/dist/_internal/server/jobs/core/testerSandboxCleanup.d.ts

@@ -1,4 +1,19 @@
 import type { JobContext } from "../runtime/types";
+/**
+ * 🛑 THE definition of "sandbox scope" — six collections, and nothing else.
+ *
+ * Everything OUTSIDE this list is permanent: neither this job nor anything else
+ * reclaims it. That is why `users`, `addresses`, `sessions` and `siteSettings`
+ * survive a tester run untouched, and why the tester lifecycle's cascade delete
+ * (tester/scripts/lib/collections.mjs) mirrors this list rather than inventing
+ * its own — a second definition is how the two silently disagree.
+ *
+ * Adding a collection here makes it disposable. Do not add one without also
+ * adding a seed fixture for it, or a run will delete rows nothing recreates.
+ *
+ * (This used to be shared with testerSandboxRefresh.ts, which was removed when
+ * the tester runner took over fixture state — see scheduled.ts.)
+ */
 export declare const SANDBOX_COLLECTIONS: readonly ["categories", "stores", "products", "blogPosts", "events", "offers"];
 export interface TesterSandboxCleanupOptions {
     /** true = wipe every isTestData:true doc regardless of testDataExpiresAt (manual force-purge). */

package/dist/_internal/server/jobs/core/testerSandboxCleanup.js

@@ -1,11 +1,20 @@
 import { batchDelete, getTestDataRefs } from "../handlers/_helpers";
 import { BID_FIELDS } from "../../../../constants/field-names";
-// Exported so testerSandboxRefresh.ts (the every-4h revert+prune job) reuses
-// the exact same collection scope instead of redefining it — one source of
-// truth for "what counts as sandbox scope."
-// Keep in sync with testerSandboxRefresh.ts's SEED_BY_COLLECTION — the daily
-// TTL cleanup and the 4-hourly revert+prune must agree on what "sandbox" means
-// (CLAUDE.md § Tester QA standards #3).
+/**
+ * 🛑 THE definition of "sandbox scope" — six collections, and nothing else.
+ *
+ * Everything OUTSIDE this list is permanent: neither this job nor anything else
+ * reclaims it. That is why `users`, `addresses`, `sessions` and `siteSettings`
+ * survive a tester run untouched, and why the tester lifecycle's cascade delete
+ * (tester/scripts/lib/collections.mjs) mirrors this list rather than inventing
+ * its own — a second definition is how the two silently disagree.
+ *
+ * Adding a collection here makes it disposable. Do not add one without also
+ * adding a seed fixture for it, or a run will delete rows nothing recreates.
+ *
+ * (This used to be shared with testerSandboxRefresh.ts, which was removed when
+ * the tester runner took over fixture state — see scheduled.ts.)
+ */
 export const SANDBOX_COLLECTIONS = ["categories", "stores", "products", "blogPosts", "events", "offers"];
 const BID_CHUNK_SIZE = 30; // Firestore `in` query cap
 export async function runTesterSandboxCleanup(ctx, opts = {}) {

package/dist/_internal/server/jobs/handlers/index.d.ts

@@ -54,7 +54,6 @@ export { onScamReportCreateHandler } from "./onScamReportCreate";
 export { onScamReportUpdateHandler } from "./onScamReportUpdate";
 export { draftPruneHandler } from "./draftPrune";
 export { testerSandboxCleanupHandler } from "./testerSandboxCleanup";
-export { testerSandboxRefreshHandler } from "./testerSandboxRefresh";
 export { emiInstallmentReminderHandler } from "./emiInstallmentReminder";
 export { onShipmentItemWriteHandler } from "./onShipmentItemWrite";
 export { onShipmentLotWriteHandler, onShipmentHeaderWriteHandler } from "./onShipmentAllocationSync";

package/dist/_internal/server/jobs/handlers/index.js

@@ -67,7 +67,6 @@ export { draftPruneHandler } from "./draftPrune";
 // Tester program — 7-day auto-expiry sweep for the shared admin-seeded test sandbox
 export { testerSandboxCleanupHandler } from "./testerSandboxCleanup";
 // Tester program — every-4h revert-live-edits + prune-extras refresh (faster than the 7-day sweep above)
-export { testerSandboxRefreshHandler } from "./testerSandboxRefresh";
 // EMI — installment reminder + overdue-flagging sweep
 export { emiInstallmentReminderHandler } from "./emiInstallmentReminder";
 // Procurement Shipments — 3-function recompute cascade (item→lot, lot/header→shipment allocation, cascade-delete)

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

@@ -69,6 +69,7 @@ export interface UserDocument extends BaseDocument {
     storeStatus?: "pending" | "approved" | "rejected";
     isTester?: boolean;
     canTestAdmin?: boolean;
+    isBot?: boolean;
     publicProfile?: {
         isPublic: boolean;
         showEmail: boolean;

package/dist/features/tester/components/TesterChecklistStepRow.d.ts

@@ -1,10 +1,18 @@
 import React from "react";
-import type { TesterAnswer } from "../schemas/firestore";
+import type { TesterAnswer, TesterCaseRole } from "../schemas/firestore";
 export interface TesterChecklistStepItem {
     checklistItemId: string;
     label: string;
     description?: string;
     href?: string;
+    roles?: TesterCaseRole[];
+    startPage?: string;
+    steps?: string[];
+    inputs?: Record<string, string | number | boolean>;
+    expectedBehaviour?: string;
+    expectedUiState?: string;
+    expectedData?: Record<string, string | number | boolean>;
+    endResult?: string;
     answer: TesterAnswer | null;
     comment?: string;
     screenshotUrl?: string;

package/dist/features/tester/components/TesterChecklistStepRow.js

@@ -1,10 +1,34 @@
 "use client";
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import React from "react";
-import { Anchor, Button, Div, FieldTextarea, Row, Stack, Text } from "../../../ui";
+import { Anchor, Button, Details, Div, FieldTextarea, Li, Ol, Row, Stack, Summary, Text } from "../../../ui";
 import { MediaUploadField } from "../../media/upload/MediaUploadField";
 import { useMediaUpload } from "../../media/hooks/useMedia";
 import { ACTIONS } from "../../../_internal/shared/actions/action-registry";
+/** Human-facing labels for the role chip. `seller` is specifically the listing's OWNER. */
+const ROLE_LABEL = {
+    guest: "Signed out",
+    buyer: "As a buyer",
+    seller: "As the owning seller",
+    admin: "As an admin",
+    employee: "As an employee",
+};
+/**
+ * `inputs` / `expectedData` as a two-column list.
+ *
+ * Rendered as key/value rather than pretty-printed JSON because the reader is a
+ * person about to type these into a form — braces and quotes are noise, and a
+ * value they have to mentally unescape is a value they will get wrong.
+ *
+ * Renders nothing at all when the case has no such data, which is the common case:
+ * a read-only page enters nothing and has nothing checkable behind the screen.
+ */
+function KeyValueBlock({ label, data, }) {
+    const entries = Object.entries(data ?? {});
+    if (!entries.length)
+        return null;
+    return (_jsxs(Stack, { gap: "none", children: [_jsx(Text, { size: "xs", weight: "semibold", color: "muted", children: label }), entries.map(([k, v]) => (_jsxs(Row, { gap: "xs", align: "baseline", wrap: true, children: [_jsx(Text, { size: "sm", color: "muted", children: k }), _jsx(Text, { size: "sm", weight: "medium", numeric: typeof v === "number", children: String(v) })] }, k)))] }));
+}
 export function TesterChecklistStepRow({ item, testerDisplayName, onAnswer, onSaveNote, }) {
     const [expanded, setExpanded] = React.useState(false);
     const [comment, setComment] = React.useState(item.comment ?? "");
@@ -25,5 +49,10 @@ export function TesterChecklistStepRow({ item, testerDisplayName, onAnswer, onSa
             setSaving(false);
         }
     };
-    return (_jsxs(Stack, { gap: "xs", padding: "sm", border: "default", rounded: "md", children: [_jsxs(Row, { gap: "sm", justify: "between", align: "center", wrap: true, children: [_jsxs(Stack, { gap: "none", className: "min-w-0", children: [_jsx(Text, { weight: "medium", children: item.label }), item.description && (_jsx(Text, { size: "xs", color: "muted", children: item.description })), item.href && (_jsx(Anchor, { href: item.href, tone: "brand", underline: "hover", target: "_blank", rel: "noopener noreferrer", children: "Go test this \u2192" }))] }), _jsxs(Row, { gap: "xs", children: [_jsx(Button, { type: "button", size: "sm", variant: item.answer === "yes" ? "primary" : "outline", onClick: () => onAnswer(item.checklistItemId, "yes"), children: "Yes" }), _jsx(Button, { type: "button", size: "sm", variant: item.answer === "no" ? "danger" : "outline", onClick: () => onAnswer(item.checklistItemId, "no"), children: "No" }), _jsx(Button, { type: "button", size: "sm", variant: "ghost", onClick: () => setExpanded((v) => !v), children: expanded ? "Hide note" : "Add note" })] })] }), expanded && (_jsx(Div, { padding: "t-sm", border: "default", className: "border-t", children: _jsxs(Stack, { gap: "sm", children: [_jsx(FieldTextarea, { name: `comment-${item.checklistItemId}`, label: "Comment", value: comment, onChange: setComment, placeholder: "What did you notice? Colors, styles, readability, bugs..." }), _jsx(MediaUploadField, { label: "Screenshot (optional)", value: screenshotUrl, onChange: setScreenshotUrl, onUpload: handleUpload, kind: "image" }), _jsx(Row, { children: _jsx(Button, { type: "button", action: ACTIONS.TESTER["save-note"], isLoading: saving, onClick: handleSave }) })] }) }))] }));
+    return (_jsxs(Stack, { gap: "xs", padding: "sm", border: "default", rounded: "md", children: [_jsxs(Row, { gap: "sm", justify: "between", align: "center", wrap: true, children: [_jsxs(Stack, { gap: "none", className: "min-w-0", children: [_jsxs(Row, { gap: "xs", align: "center", wrap: true, children: [item.roles?.map((r) => (_jsx(Text, { size: "xs", weight: "semibold", color: "muted", children: ROLE_LABEL[r] }, r))), _jsx(Text, { weight: "medium", children: item.label })] }), item.description && (_jsx(Text, { size: "xs", color: "muted", children: item.description })), item.href && (_jsx(Anchor, { href: item.href, tone: "brand", underline: "hover", target: "_blank", rel: "noopener noreferrer", children: "Go test this \u2192" }))] }), _jsxs(Row, { gap: "xs", children: [_jsx(Button, { type: "button", size: "sm", variant: item.answer === "yes" ? "primary" : "outline", onClick: () => onAnswer(item.checklistItemId, "yes"), children: "Yes" }), _jsx(Button, { type: "button", size: "sm", variant: item.answer === "no" ? "danger" : "outline", onClick: () => onAnswer(item.checklistItemId, "no"), children: "No" }), _jsx(Button, { type: "button", size: "sm", variant: "ghost", onClick: () => setExpanded((v) => !v), children: expanded ? "Hide note" : "Add note" })] })] }), (item.steps?.length ||
+                item.expectedBehaviour ||
+                item.expectedUiState ||
+                item.endResult ||
+                item.inputs ||
+                item.expectedData) && (_jsxs(Details, { tone: "card", padding: "sm", defaultOpen: false, children: [_jsx(Summary, { children: item.steps?.length ? `Steps (${item.steps.length})` : "Expected result" }), _jsxs(Stack, { gap: "sm", children: [item.startPage && (_jsxs(Stack, { gap: "none", children: [_jsx(Text, { size: "xs", weight: "semibold", color: "muted", children: "Start" }), _jsx(Text, { size: "sm", children: item.startPage })] })), item.steps?.length ? (_jsxs(Stack, { gap: "none", children: [_jsx(Text, { size: "xs", weight: "semibold", color: "muted", children: "Steps" }), _jsx(Ol, { marker: "decimal", indent: "md", spacing: "tight", size: "sm", children: item.steps.map((step, i) => (_jsx(Li, { children: step }, i))) })] })) : null, _jsx(KeyValueBlock, { label: "Enter exactly", data: item.inputs }), item.expectedBehaviour && (_jsxs(Stack, { gap: "none", children: [_jsx(Text, { size: "xs", weight: "semibold", color: "muted", children: "Expected behaviour" }), _jsx(Text, { size: "sm", children: item.expectedBehaviour })] })), item.expectedUiState && (_jsxs(Stack, { gap: "none", children: [_jsx(Text, { size: "xs", weight: "semibold", color: "muted", children: "Expected UI state" }), _jsx(Text, { size: "sm", children: item.expectedUiState })] })), _jsx(KeyValueBlock, { label: "Values that must be correct", data: item.expectedData }), item.endResult && (_jsxs(Stack, { gap: "none", children: [_jsx(Text, { size: "xs", weight: "semibold", color: "muted", children: "After reload" }), _jsx(Text, { size: "sm", children: item.endResult })] }))] })] })), expanded && (_jsx(Div, { padding: "t-sm", border: "default", className: "border-t", children: _jsxs(Stack, { gap: "sm", children: [_jsx(FieldTextarea, { name: `comment-${item.checklistItemId}`, label: "Comment", value: comment, onChange: setComment, placeholder: "What did you notice? Colors, styles, readability, bugs..." }), _jsx(MediaUploadField, { label: "Screenshot (optional)", value: screenshotUrl, onChange: setScreenshotUrl, onUpload: handleUpload, kind: "image" }), _jsx(Row, { children: _jsx(Button, { type: "button", action: ACTIONS.TESTER["save-note"], isLoading: saving, onClick: handleSave }) })] }) }))] }));
 }

package/dist/features/tester/components/TesterHubView.js

@@ -25,6 +25,14 @@ function TesterChecklistPageSection({ page, testerDisplayName, onAnswer, onSaveN
                             label: item.label,
                             description: item.description,
                             href: item.href,
+                            roles: item.roles,
+                            startPage: item.startPage,
+                            steps: item.steps,
+                            inputs: item.inputs,
+                            expectedBehaviour: item.expectedBehaviour,
+                            expectedUiState: item.expectedUiState,
+                            expectedData: item.expectedData,
+                            endResult: item.endResult,
                             answer: item.answer,
                             comment: item.comment,
                             screenshotUrl: item.screenshotUrl,

package/dist/features/tester/repository/tester-checklist-item.repository.d.ts

@@ -15,9 +15,24 @@ export declare class TesterChecklistItemRepository extends BaseRepository<Tester
     /** Reopens a fixed, bug-confirmed case as a new, active version for retest.
      * The old item stays disabled forever with its bug-hunter credit intact. */
     reopenAsNewVersion(oldItemId: string): Promise<TesterChecklistItemDocument>;
+    /**
+     * Ids of automated (non-human) accounts, excluded from the PUBLIC leaderboard.
+     *
+     * Read as a bare collection query rather than through `userRepository` on purpose:
+     * no repository in this codebase imports another, and this needs a key set, not
+     * user documents. `.select()` with no fields returns refs only, so the read is as
+     * cheap as Firestore allows, and `isBot == true` is a single-field equality served
+     * by the automatic index — no composite index to declare.
+     */
+    private botHunterIds;
     /** Single-query, in-memory aggregation of bug credits per hunter — mirrors
      * EventEntryRepository.getLeaderboard()'s shape. Includes old/disabled/
-     * superseded items, since bug credit is permanent. */
+     * superseded items, since bug credit is permanent.
+     *
+     * Bot accounts are aggregated out (not merely ranked last): the board exists to
+     * credit people, and a runner working all 943 cases would otherwise dominate it.
+     * The credit still lives on the item, so admin triage and the item's own
+     * `bugHunterName` are unaffected. */
     getBugHunterLeaderboard(limit?: number): Promise<BugHunterLeaderboardEntry[]>;
 }
 export declare const testerChecklistItemRepository: TesterChecklistItemRepository;

package/dist/features/tester/repository/tester-checklist-item.repository.js

@@ -1,6 +1,7 @@
 import { BaseRepository, parseSieveDateValue } from "../../../providers/db-firebase";
 import { buildSearchTxt } from "../../../utils/search-txt";
 import { DatabaseError } from "../../../errors";
+import { USER_COLLECTION } from "../../auth/schemas/firestore";
 import { TESTER_CHECKLIST_ITEM_COLLECTION, TESTER_CHECKLIST_ITEM_FIELDS, createChecklistItemId, } from "../schemas/firestore";
 export class TesterChecklistItemRepository extends BaseRepository {
     constructor() {
@@ -86,18 +87,43 @@ export class TesterChecklistItemRepository extends BaseRepository {
         await this.update(old.id, { supersededByItemId: newId });
         return newItem;
     }
+    /**
+     * Ids of automated (non-human) accounts, excluded from the PUBLIC leaderboard.
+     *
+     * Read as a bare collection query rather than through `userRepository` on purpose:
+     * no repository in this codebase imports another, and this needs a key set, not
+     * user documents. `.select()` with no fields returns refs only, so the read is as
+     * cheap as Firestore allows, and `isBot == true` is a single-field equality served
+     * by the automatic index — no composite index to declare.
+     */
+    async botHunterIds() {
+        const snapshot = await this.db
+            .collection(USER_COLLECTION)
+            .where("isBot", "==", true)
+            .select()
+            .get();
+        return new Set(snapshot.docs.map((d) => d.id));
+    }
     /** Single-query, in-memory aggregation of bug credits per hunter — mirrors
      * EventEntryRepository.getLeaderboard()'s shape. Includes old/disabled/
-     * superseded items, since bug credit is permanent. */
+     * superseded items, since bug credit is permanent.
+     *
+     * Bot accounts are aggregated out (not merely ranked last): the board exists to
+     * credit people, and a runner working all 943 cases would otherwise dominate it.
+     * The credit still lives on the item, so admin triage and the item's own
+     * `bugHunterName` are unaffected. */
     async getBugHunterLeaderboard(limit = 50) {
-        const snapshot = await this.db
-            .collection(this.collection)
-            .where(TESTER_CHECKLIST_ITEM_FIELDS.BUG_CONFIRMED, "==", true)
-            .get();
+        const [snapshot, botIds] = await Promise.all([
+            this.db
+                .collection(this.collection)
+                .where(TESTER_CHECKLIST_ITEM_FIELDS.BUG_CONFIRMED, "==", true)
+                .get(),
+            this.botHunterIds(),
+        ]);
         const byHunter = new Map();
         for (const doc of snapshot.docs) {
             const item = this.mapDoc(doc);
-            if (!item.bugHunterId)
+            if (!item.bugHunterId || botIds.has(item.bugHunterId))
                 continue;
             const entry = byHunter.get(item.bugHunterId) ?? {
                 name: item.bugHunterName ?? "Unknown tester",

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

@@ -13,6 +13,101 @@ export interface TesterChecklistItemDocument extends BaseDocument {
     pageLabel: string;
     label: string;
     description?: string;
+    /**
+     * WHICH ROLES this case affects. Not decoration — it changes what "correct" means.
+     *
+     * The same page is a different page per role: /products/<slug> shows a buyer
+     * Add to Cart and Make Offer, shows the OWNING seller Edit listing and no Make
+     * Offer (you cannot bid on your own listing), shows an admin moderation
+     * controls, and shows a guest a sign-in prompt. So `expectedUiState` is
+     * meaningless without this, and a case omitting it is really three untested
+     * cases wearing one label.
+     *
+     * 🛑 A LIST, because the interesting content is usually the DIFFERENCE between
+     * roles — "the owning seller must NOT see Make Offer where a buyer does" is one
+     * case, not two, and splitting it loses the comparison that is the whole point.
+     * Where roles differ, `expectedBehaviour` and `expectedUiState` say so in prose
+     * ("Buyer: … Owning seller: …"). Deliberately NOT a parallel per-role structure:
+     * that would be four more fields to keep in sync for something a sentence
+     * expresses perfectly well.
+     *
+     * Also drives which session the automated harness browses with.
+     */
+    roles?: TesterCaseRole[];
+    /** WHERE the tester begins. One unambiguous URL, unprefixed (/products, not /en/products). */
+    startPage?: string;
+    /**
+     * WHAT the tester does. One action per entry, concrete fixtures named, literal
+     * values ("Enter 780", not "enter an amount below the listed price") so two
+     * runs are comparable and a regression can be spotted by diffing.
+     *
+     * 🛑 No assertions in here — they belong in the three expectation fields. A
+     * step reading "click Save and confirm it worked" is two things wearing one
+     * number, and the confirming half silently goes unchecked.
+     *
+     * Length varies with the case. "This page renders" is one honest step; a
+     * multi-role negotiation is fifteen. There is no target, and padding toward one
+     * produces the mechanical "Open X. Verify Y." shape that fills the field while
+     * encoding nothing the label did not already say.
+     */
+    steps?: string[];
+    /**
+     * The exact data the tester enters or selects, as flat key/value pairs.
+     *
+     * 🛑 WHY THIS IS NOT JUST PROSE
+     *
+     * "Enter 780, the listed price is 999" reads fine and still lets two testers type
+     * two different numbers, and gives an automated runner nothing to consume but a
+     * sentence. The steps say WHAT TO DO; this says WITH WHAT — so the procedure is
+     * repeatable by construction and a runner can fill a form from it directly.
+     *
+     * Flat and scalar on purpose: nested objects invite a shape nobody validates, and
+     * every real value here is a string, number or boolean.
+     *
+     * Omitted entirely by a case that enters nothing — a read-only page has no inputs.
+     */
+    inputs?: Record<string, string | number | boolean>;
+    /**
+     * What the system must DO — the functional outcome, including side effects no
+     * screen shows (a notification sent, stock decremented, an order created).
+     *
+     * Kept apart from `expectedUiState` because the gap between them is a real bug
+     * class: the write succeeds and the screen never updates.
+     */
+    expectedBehaviour?: string;
+    /**
+     * What the tester must SEE — exact on-screen text and control states.
+     *
+     * Quote the screen ("the button reads 'Offer sent'"), never "the UI updates
+     * correctly", which cannot be checked against a screenshot. This is what makes
+     * the mandatory screenshot reviewable: the image is compared to a written
+     * claim instead of to a guess about what "works" looked like.
+     */
+    expectedUiState?: string;
+    /**
+     * The values that must be CORRECT afterwards, as flat key/value pairs.
+     *
+     * `expectedUiState` settles what the screen looks like; this settles whether the
+     * data behind it is right. The two are different questions, and a screen can be
+     * entirely plausible over a wrong number — which is most of this codebase's bug
+     * history, where a defect returns HTTP 200 with believable rows.
+     *
+     * Machine-readable so a runner asserts against it rather than re-reading English,
+     * and so "it looked right" becomes a comparison.
+     *
+     * Omitted by a case with nothing checkable behind the screen.
+     */
+    expectedData?: Record<string, string | number | boolean>;
+    /**
+     * What is still true after a RELOAD — the persistence oracle.
+     *
+     * Several of the worst bugs here returned a normal 200, rendered
+     * optimistically, and wrote nothing (the grouped-listing rename, the dropped
+     * address landmark). Reloading is the only thing that catches them. Where a
+     * case genuinely persists nothing, say so explicitly rather than leaving the
+     * field to mean two different things.
+     */
+    endResult?: string;
     href?: string;
     order: number;
     phase: number;
@@ -48,6 +143,20 @@ export interface BugHunterLeaderboardEntry {
 }
 export declare function slugifyChecklistLabel(label: string): string;
 export declare function createChecklistItemId(groupKey: string, pageKey: string, label: string): string;
+/**
+ * Whose point of view a checklist case is written from.
+ *
+ * `guest` is a real role, not the absence of one — a signed-out visitor sees a
+ * sign-in prompt where a buyer sees a wishlist heart, and that path had never
+ * been exercised before this field existed.
+ *
+ * `seller` means the seller who OWNS the listing under test. A different
+ * seller looking at someone else's listing is a `buyer` for that case — the
+ * distinction matters because the owning seller is precisely who must NOT see
+ * Make Offer.
+ */
+export declare const TESTER_CASE_ROLES: readonly ["guest", "buyer", "seller", "admin", "employee"];
+export type TesterCaseRole = (typeof TESTER_CASE_ROLES)[number];
 export type TesterAnswer = "yes" | "no";
 export type TesterFeedbackStatus = "new" | "reviewed";
 export interface TesterChecklistResponseDocument extends BaseDocument {

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

@@ -42,6 +42,20 @@ export function slugifyChecklistLabel(label) {
 export function createChecklistItemId(groupKey, pageKey, label) {
     return generateChecklistItemId({ groupKey, pageKey, label });
 }
+// --- Checklist response (tester answers) --------------------------------------
+/**
+ * Whose point of view a checklist case is written from.
+ *
+ * `guest` is a real role, not the absence of one — a signed-out visitor sees a
+ * sign-in prompt where a buyer sees a wishlist heart, and that path had never
+ * been exercised before this field existed.
+ *
+ * `seller` means the seller who OWNS the listing under test. A different
+ * seller looking at someone else's listing is a `buyer` for that case — the
+ * distinction matters because the owning seller is precisely who must NOT see
+ * Make Offer.
+ */
+export const TESTER_CASE_ROLES = ["guest", "buyer", "seller", "admin", "employee"];
 export const TESTER_CHECKLIST_RESPONSE_COLLECTION = "testerChecklistResponses";
 export const TESTER_CHECKLIST_RESPONSE_INDEXED_FIELDS = [
     "testerId",

package/dist/features/tester/seed-data/_money-flows.d.ts

@@ -0,0 +1,23 @@
+import type { TesterCaseRole } from "../schemas";
+interface MoneyFlowCase {
+    key: string;
+    label: string;
+    /** Every role the case affects; per-role detail goes inline in the expectations. */
+    roles: TesterCaseRole[];
+    startPage?: string;
+    steps: string[];
+    inputs?: Record<string, string | number | boolean>;
+    expectedBehaviour: string;
+    expectedUiState: string;
+    expectedData?: Record<string, string | number | boolean>;
+    endResult: string;
+    href?: string;
+}
+interface MoneyFlowPage {
+    pageKey: string;
+    pageLabel: string;
+    href?: string;
+    cases: MoneyFlowCase[];
+}
+export declare const moneyFlowsPages: MoneyFlowPage[];
+export {};