@mohasinac/appkit 4.33.1 → 4.34.1

package/dist/features/seller/utils/product-draft-mapping.d.ts

@@ -0,0 +1,117 @@
+import type { SellerProductDraft } from "../components/SellerProductShell";
+/**
+ * Seller listing form draft <-> product write payload.
+ *
+ * ## The bug this closes
+ *
+ * `SellerProductDraft` is FLAT — `classifiedCity`, `liveSpecies`,
+ * `digitalCodeDelivery`, `printSize` — because that is the shape a form wants:
+ * one key per control, no nesting to thread through `onChange`.
+ *
+ * `productCreateSchema` is NESTED — `classified.meetupArea.city`,
+ * `liveItem.species`, `digitalCode.codeDeliveryMethod`, `printMeta.size` —
+ * because that is the shape `ProductDocument` stores.
+ *
+ * Nothing translated between them. Every `store/*\/new/page.tsx` spread the
+ * draft straight into `createSellerProductAction`, and `productBaseSchema` is
+ * a plain `z.object()` with no `.passthrough()`, so **every flat per-type key
+ * was stripped before the write**. A seller filled in a classified's meetup
+ * city, a live animal's species and permitted jurisdictions, a digital code's
+ * delivery method, or an art print's size and edition — pressed Publish, got a
+ * success toast — and the listing was saved without the fields that made it
+ * that KIND of listing.
+ *
+ * ## Why this lives in the ACTION, not in the pages
+ *
+ * There are ~10 `new/page.tsx` and ~10 `[id]/edit/page.tsx` files and every
+ * one of them does `{ ...draft, listingType, status }`. Applying the mapping
+ * at each is 20 chances to forget, and a new listing type's page would start
+ * out broken in exactly the way this fixes. `createSellerProductAction` and
+ * `sellerUpdateProductAction` are the single choke point every seller write
+ * already passes through, so the mapping happens once and cannot be bypassed
+ * by a page that did not know about it (the lesson of Root Cause #75).
+ *
+ * ## Round-trip
+ *
+ * `draftToProductInput` and `productToDraft` are a matched pair in one file so
+ * they cannot drift: a field added to one and not the other is visible in a
+ * single screen of code. The edit pages need the inverse to seed the form from
+ * a stored document.
+ */
+/**
+ * The parts of a stored product this mapper reads.
+ *
+ * Declared structurally rather than importing `ProductDocument`: the inbound
+ * value comes from a server action's `JsonValue` payload where dates are
+ * strings, and every block is optional because documents written before the
+ * nested shapes existed carry none of them.
+ */
+export interface StoredProductBlocks {
+    finalSale?: boolean;
+    returnPolicy?: string;
+    classified?: {
+        meetupArea?: {
+            city?: string;
+            locality?: string;
+            pincode?: string;
+        };
+        acceptsShipping?: boolean;
+        negotiable?: boolean;
+    };
+    digitalCode?: {
+        codeDeliveryMethod?: string;
+        codePoolSize?: number;
+        redemptionInstructions?: string;
+        expiresAt?: string;
+    };
+    liveItem?: {
+        species?: string;
+        ageMonths?: number;
+        sex?: string;
+        careInfo?: string;
+        transport?: {
+            method?: string;
+            handlingFee?: number;
+        };
+        jurisdictionAllowed?: string[];
+        cites?: string;
+    };
+    printMeta?: {
+        size?: string;
+        material?: string;
+        finish?: string;
+        editionSize?: number;
+    };
+}
+/**
+ * The nested blocks this mapper WRITES, plus whatever else the draft carried.
+ * `ProductWritePayload` is deliberately not `ProductDocument`: the draft holds
+ * form-shaped values (ISO date strings, a `MediaField` video) that the write
+ * schema coerces, so typing it as the document would be a lie the compiler
+ * would then make everyone cast around.
+ */
+export interface ProductWritePayload {
+    classified?: NonNullable<StoredProductBlocks["classified"]>;
+    digitalCode?: NonNullable<StoredProductBlocks["digitalCode"]>;
+    liveItem?: NonNullable<StoredProductBlocks["liveItem"]>;
+    printMeta?: NonNullable<StoredProductBlocks["printMeta"]>;
+    [key: string]: unknown;
+}
+/**
+ * Fold the draft's flat per-type keys into the nested blocks the write schema
+ * expects. Every other key passes through untouched.
+ *
+ * A block is emitted only when the draft actually carries something for it, so
+ * saving a standard listing does not write an empty `classified: {}`.
+ */
+export declare function draftToProductInput(draft: SellerProductDraft & {
+    [key: string]: unknown;
+}): ProductWritePayload;
+/**
+ * The inverse — seed the form from a stored document.
+ *
+ * Tolerant of documents written before the nested blocks existed: a missing
+ * block yields undefined flat keys, which render as empty inputs rather than
+ * throwing.
+ */
+export declare function productToDraft(product: StoredProductBlocks): Partial<SellerProductDraft>;

package/dist/features/seller/utils/product-draft-mapping.js

@@ -0,0 +1,147 @@
+function pick(v) {
+    return v === undefined || v === null || v === "" ? undefined : v;
+}
+/** Drop keys whose value is undefined so they never reach Firestore. */
+function compact(obj) {
+    const out = {};
+    for (const [k, v] of Object.entries(obj)) {
+        if (v !== undefined)
+            out[k] = v;
+    }
+    return out;
+}
+/**
+ * The flat draft keys this mapper OWNS.
+ *
+ * Stripped from the payload after being folded into their nested homes — the
+ * write schema does not name them, so leaving them in would be harmless today
+ * and confusing forever ("is `classifiedCity` stored or not?").
+ */
+const OWNED_FLAT_KEYS = [
+    "classifiedCity", "classifiedLocality", "classifiedPincode",
+    "classifiedContactMethod", "classifiedAcceptsShipping", "classifiedNegotiable",
+    "digitalCodeDelivery", "digitalCodePoolSize",
+    "digitalCodeRedemptionInstructions", "digitalCodeExpiresAt",
+    "liveSpecies", "liveAgeMonths", "liveSex", "liveCareInfo",
+    "liveTransportMethod", "liveHandlingFee", "liveJurisdictions", "liveCites",
+    "printSize", "printMaterial", "printFinish", "printEditionSize",
+];
+/**
+ * Fold the draft's flat per-type keys into the nested blocks the write schema
+ * expects. Every other key passes through untouched.
+ *
+ * A block is emitted only when the draft actually carries something for it, so
+ * saving a standard listing does not write an empty `classified: {}`.
+ */
+export function draftToProductInput(draft) {
+    const out = { ...draft };
+    for (const k of OWNED_FLAT_KEYS)
+        delete out[k];
+    // ── classified ────────────────────────────────────────────────────────────
+    if (pick(draft.classifiedCity) !== undefined) {
+        out.classified = compact({
+            meetupArea: compact({
+                city: draft.classifiedCity,
+                locality: pick(draft.classifiedLocality),
+                pincode: pick(draft.classifiedPincode),
+            }),
+            acceptsShipping: draft.classifiedAcceptsShipping,
+            negotiable: draft.classifiedNegotiable,
+        });
+    }
+    // ── digital code ──────────────────────────────────────────────────────────
+    if (pick(draft.digitalCodeDelivery) !== undefined) {
+        out.digitalCode = compact({
+            codeDeliveryMethod: draft.digitalCodeDelivery,
+            codePoolSize: pick(draft.digitalCodePoolSize),
+            redemptionInstructions: pick(draft.digitalCodeRedemptionInstructions),
+            expiresAt: pick(draft.digitalCodeExpiresAt),
+        });
+    }
+    // ── live item ─────────────────────────────────────────────────────────────
+    if (pick(draft.liveSpecies) !== undefined) {
+        out.liveItem = compact({
+            species: draft.liveSpecies,
+            ageMonths: pick(draft.liveAgeMonths),
+            sex: pick(draft.liveSex),
+            careInfo: pick(draft.liveCareInfo),
+            /*
+             * `transport` is a REQUIRED object on the schema, and `method` inside it
+             * is required too — so a live listing whose form left the transport
+             * method blank must still produce the object, or the whole `liveItem`
+             * block fails to parse and takes the species with it. "courier" is the
+             * form's own default.
+             */
+            transport: compact({
+                method: draft.liveTransportMethod ?? "courier",
+                handlingFee: pick(draft.liveHandlingFee),
+            }),
+            // Required, min 1. Left empty the schema rejects the listing with a
+            // real message — which is correct: shipping a live animal into a
+            // jurisdiction that forbids it is what the field exists to prevent.
+            jurisdictionAllowed: draft.liveJurisdictions ?? [],
+            // `cites` is a STRING permit number on the document, while the form
+            // carries a boolean "CITES applies" checkbox. Only the affirmative case
+            // means anything, and it means "documented" until a number is entered.
+            cites: draft.liveCites ? "documented" : undefined,
+        });
+    }
+    // ── print meta (art + stickers share one block) ───────────────────────────
+    const printEntries = compact({
+        size: pick(draft.printSize),
+        material: pick(draft.printMaterial),
+        finish: pick(draft.printFinish),
+        editionSize: pick(draft.printEditionSize),
+    });
+    if (Object.keys(printEntries).length > 0)
+        out.printMeta = printEntries;
+    return out;
+}
+/**
+ * The inverse — seed the form from a stored document.
+ *
+ * Tolerant of documents written before the nested blocks existed: a missing
+ * block yields undefined flat keys, which render as empty inputs rather than
+ * throwing.
+ */
+export function productToDraft(product) {
+    const { classified, digitalCode, liveItem, printMeta } = product;
+    return compact({
+        /*
+         * Flat fields the edit pages' hand-written `initialValues` blocks omit.
+         *
+         * Not a nesting mismatch like the rest of this function — just fields
+         * nobody added to ten near-identical literals. `finalSale` matters most:
+         * unseeded it renders as `undefined`, which `isFinalSale` reads as TRUE,
+         * so a listing the seller had opted into returns would open its own edit
+         * form showing "final sale". The stored value survives an untouched save
+         * (an absent key is stripped, and the update is partial), but the form was
+         * telling the seller something untrue about their own listing.
+         */
+        finalSale: product.finalSale,
+        returnPolicy: product.returnPolicy,
+        classifiedCity: classified?.meetupArea?.city,
+        classifiedLocality: classified?.meetupArea?.locality,
+        classifiedPincode: classified?.meetupArea?.pincode,
+        classifiedAcceptsShipping: classified?.acceptsShipping,
+        classifiedNegotiable: classified?.negotiable,
+        digitalCodeDelivery: digitalCode?.codeDeliveryMethod,
+        digitalCodePoolSize: digitalCode?.codePoolSize,
+        digitalCodeRedemptionInstructions: digitalCode?.redemptionInstructions,
+        digitalCodeExpiresAt: digitalCode?.expiresAt,
+        liveSpecies: liveItem?.species,
+        liveAgeMonths: liveItem?.ageMonths,
+        liveSex: liveItem?.sex,
+        liveCareInfo: liveItem?.careInfo,
+        liveTransportMethod: liveItem?.transport?.method,
+        liveHandlingFee: liveItem?.transport?.handlingFee,
+        liveJurisdictions: liveItem?.jurisdictionAllowed,
+        // String -> boolean, mirroring the outbound direction: any recorded permit
+        // means the checkbox is ticked.
+        liveCites: liveItem?.cites ? true : undefined,
+        printSize: printMeta?.size,
+        printMaterial: printMeta?.material,
+        printFinish: printMeta?.finish,
+        printEditionSize: printMeta?.editionSize,
+    });
+}

package/dist/features/shell/SectionForm.js

@@ -9,6 +9,7 @@ import { FormShellContext } from "../../ui/forms/FormShell";
 import { useFormBottomActions } from "../layout/hooks/useFormBottomActions";
 import { useSectionState } from "../account/hooks/useCollapsedSections";
 import { FormSchemaContext } from "./FormShell";
+import { EASE_OUT_MS } from "../../tokens/motion";
 /** Sections in render order: required first, original order preserved within each group. */
 export function orderSections(sections) {
     return [...sections.filter((s) => s.required), ...sections.filter((s) => !s.required)];
@@ -78,8 +79,34 @@ export function scrollToSection(id) {
         return;
     requestAnimationFrame(() => {
         const el = document.getElementById(sectionAnchorId(id));
-        el?.scrollIntoView({ behavior: "smooth", block: "start" });
-        el?.querySelector("[aria-invalid='true']")?.focus();
+        if (!el)
+            return;
+        /*
+         * The header is already at its final position, so scrolling can happen on
+         * the next frame.
+         */
+        el.scrollIntoView({ behavior: "smooth", block: "start" });
+        /*
+         * Focusing the offending field cannot.
+         *
+         * `<Collapse>` animates height 0 -> auto over EASE_OUT_MS, and Framer
+         * drives that with rAF rather than a CSS transition — so there is no
+         * `transitionend` to wait for, and one `requestAnimationFrame` lands while
+         * the panel is still ~0px tall inside `overflow: hidden`. Focusing there
+         * makes the browser scroll-anchor against a box that is about to grow,
+         * which is why "jump to error" could leave the field off-screen.
+         *
+         * A required section renders with no <Collapse> at all, so it is already
+         * at full height and this simply fires a tick later than it needs to.
+         */
+        const reduced = typeof window !== "undefined" &&
+            typeof window.matchMedia === "function" &&
+            window.matchMedia("(prefers-reduced-motion: reduce)").matches;
+        const focusInvalid = () => el.querySelector("[aria-invalid='true']")?.focus();
+        if (reduced)
+            focusInvalid();
+        else
+            window.setTimeout(focusInvalid, EASE_OUT_MS);
     });
 }
 export function SectionForm({ sections, values, onChange, onSubmit, submitLabel = "Save", isLoading = false, schema, openIds: controlledOpenIds, onOpenChange, expandMode = "multi", hideActions = false, destructiveAction, onValidationChange, onCancel, cancelLabel, bottomBar = true, }) {
@@ -112,7 +139,20 @@ export function SectionForm({ sections, values, onChange, onSubmit, submitLabel
             setUncontrolledOpenIds(ids);
         onOpenChange?.(ids);
     }, [controlledOpenIds, onOpenChange]);
-    const fieldToSectionIndex = useMemo(() => buildFieldToSectionIndex(ordered), [ordered]);
+    /*
+     * `ordered` depends on `values`, so it is a NEW array on every keystroke.
+     * Anything derived from it must key on the visible section SET instead, or
+     * the effect below re-fires per character — running a second full-tree
+     * `safeParse` on top of the one `handleFieldChange` already performs, and
+     * rebuilding every downstream callback with it.
+     *
+     * `ordered` itself must keep recomputing: a `when()` predicate can flip
+     * mid-typing and a section can appear or disappear. It is only the DERIVED
+     * values that are stable across that.
+     */
+    const visibleSectionKey = ordered.map((s) => s.id).join("|");
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    const fieldToSectionIndex = useMemo(() => buildFieldToSectionIndex(ordered), [visibleSectionKey]);
     // Keep the latest callback without making runValidation depend on it — the
     // caller usually passes an inline arrow, which would otherwise rebuild the
     // validator on every render and re-fire the effect below in a loop.
@@ -227,14 +267,29 @@ export function SectionForm({ sections, values, onChange, onSubmit, submitLabel
     }, [fieldErrors]);
     return (_jsxs(Stack, { gap: "md", children: [ordered.map((section) => {
                 const isRequired = section.required === true;
-                // A required section is always open — it holds the fields without
-                // which the record cannot be saved, so hiding it is never useful.
+                /*
+                 * A required section is always open — it holds the fields without
+                 * which the record cannot be saved, so hiding it is never useful.
+                 *
+                 * `collapsible={!isRequired}` below is what makes that VISIBLE: the
+                 * header renders as a plain heading with no control. Previously this
+                 * flag only forced `isCollapsed` false while the header still drew a
+                 * chevron button, so the section was permanently open AND appeared
+                 * broken. `onToggle` no longer needs its `if (!isRequired)` guard,
+                 * because a static header has nothing to click.
+                 */
                 const isCollapsed = isRequired
                     ? false
                     : !(openIds.includes(section.id) || forceOpenIds.includes(section.id));
                 const errorCount = errorCountFor(section);
-                return (_jsx(CollapsibleSection, { id: sectionAnchorId(section.id), title: _jsxs(Row, { align: "center", gap: "xs", children: [_jsx(Span, { weight: "semibold", size: "sm", children: section.heading ?? section.label }), isRequired && _jsx(Span, { size: "xs", color: "muted", children: "Required" })] }), isCollapsed: isCollapsed, onToggle: () => { if (!isRequired)
-                        toggle(section.id); }, keepMounted: section.keepMounted, renderHeaderExtra: errorCount > 0
+                return (_jsx(CollapsibleSection, { id: sectionAnchorId(section.id), title: 
+                    /*
+                     * `as="span"` matters: a collapsible section's header renders
+                     * this INSIDE a <button>, and <Row>'s default <div> made that
+                     * <button><div><span><div> — invalid, since a button may only
+                     * contain phrasing content. Same variant props, legal element.
+                     */
+                    _jsxs(Row, { as: "span", align: "center", gap: "xs", className: "min-w-0", children: [_jsx(Span, { weight: "semibold", size: "sm", children: section.heading ?? section.label }), isRequired && _jsx(Span, { size: "xs", color: "muted", children: "Required" })] }), isCollapsed: isCollapsed, collapsible: !isRequired, onToggle: () => toggle(section.id), keepMounted: section.keepMounted, renderHeaderExtra: errorCount > 0
                         ? () => (_jsxs(Badge, { variant: "danger", children: [errorCount, " ", errorCount === 1 ? "issue" : "issues"] }))
                         : undefined, children: section.render({ values, onChange: handleFieldChange, errors: fieldErrors }) }, section.id));
             }), !hideActions && (

package/dist/features/shell/form-sections.js

@@ -92,6 +92,10 @@ export const SECTION_GROUP_DEFAULTS = {
     // logistics
     address: "logistics", shipping: "logistics", delivery: "logistics",
     routing: "logistics",
+    // Returns sit with logistics rather than with pricing: the seller is
+    // describing what happens to the goods after delivery, and the section
+    // reads directly after Shipping on the listing form.
+    returns: "logistics",
     // relationships
     owner: "relationships", members: "relationships", link: "relationships",
     google: "relationships", sync: "relationships", subscribe: "relationships",

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/seed-data/events-tester-seed-data.js

@@ -1,11 +1,17 @@
 /*
- * WHY: Shared tester sandbox — 1 disposable test event with both raffle and spin-wheel
- *      fields populated, so testers can exercise the events/raffle/spin flow end to end.
- *      Auto-expires after 7 days (testerSandboxCleanup).
- * WHAT: Exports eventsTesterSeedData — 1 Partial<EventDocument> tagged isTestData:true.
+ * WHY: Shared tester sandbox — disposable test events covering spin-wheel, both raffle
+ *      variants, a coupon offer, and a lottery with a pre-booked slot, so testers can
+ *      exercise each flow end to end.
+ * WHAT: Exports eventsTesterSeedData — 5 Partial<EventDocument> tagged isTestData:true.
+ *
+ *      The lottery's draw window is expressed via tester-window.ts rather than a fixed
+ *      duration, so an automated run can shorten it and still watch the window close.
+ *      The other four stay long-lived on purpose: they are meant to read as ACTIVE
+ *      events for a human tester who seeds today and returns tomorrow. A fixture that
+ *      must expire mid-session should be added as its own row, not by re-timing these.
  *
  * EXPORTS:
- *   eventsTesterSeedData — Array of 1 Partial<EventDocument> for the seed runner
+ *   eventsTesterSeedData — Array of 5 Partial<EventDocument> for the seed runner
  *
  * @tag domain:events,tester
  * @tag layer:seed
@@ -17,6 +23,7 @@
 import { EVENT_FIELDS } from "../../../constants/field-names";
 import { seedPhoto } from "../../../seed/_helpers/media";
 import { testDataExpiresAt } from "./tester-ttl";
+import { windowMinutes, windowOffset } from "./tester-window";
 const TEST_EVENT_COVER_ALT = "Test event cover";
 const TEST_RAFFLE_PRIZE = "Test prize — not a real reward";
 export const eventsTesterSeedData = [
@@ -118,4 +125,69 @@ export const eventsTesterSeedData = [
         createdAt: new Date(),
         updatedAt: new Date(),
     },
+    // ── Lottery, with one slot ALREADY BOOKED ───────────────────────────────────
+    // This fixture exists for exactly two checklist cases, both marked 🛑:
+    //   page-wiring/data-loss/lottery-edit-preserves-bookings
+    //   page-wiring/data-loss/lottery-booked-slot-cannot-be-deleted
+    // Neither could be tested before, because no lottery fixture existed anywhere —
+    // lottery events could previously only come from a hand-run seed.
+    //
+    // 🛑 Slot 3's booking IS the fixture. A booked slot carries a buyer id, a display
+    // name and a lottery number, and the bug being guarded silently cleared all three
+    // while returning a success message. Do not "tidy" this into an all-unbooked
+    // lottery — an unbooked slot cannot demonstrate the loss, and the case would then
+    // pass against the very bug it exists to catch.
+    //
+    // price/weight are server-only (toClientLotterySlot strips them). Uniform pricing
+    // means every slot is weight 50 by definition — see computeWeight().
+    {
+        id: "event-tester-sandbox-lottery",
+        slug: "tester-sandbox-lottery",
+        type: EVENT_FIELDS.TYPE_VALUES.LOTTERY,
+        title: "Tester Sandbox — Lottery",
+        description: "Disposable test lottery for the tester QA program. Slot 3 is pre-booked: edit an unrelated slot, save, reopen, and confirm slot 3 is STILL booked to the same buyer with the same lottery number.",
+        status: EVENT_FIELDS.STATUS_VALUES.ACTIVE,
+        startsAt: new Date(),
+        endsAt: windowOffset(1),
+        coverImage: {
+            type: "image",
+            url: seedPhoto("event-cover-tester-sandbox-lottery-20260101", 1200, 600),
+            alt: TEST_EVENT_COVER_ALT,
+        },
+        tags: ["test"],
+        lotteryConfig: {
+            totalSlots: 6,
+            pricingMode: "uniform",
+            uniformPrice: 100,
+            // Must outlast the run, or late batches meet a closed lottery. windowOffset(1)
+            // is the run's end, so the draw window is expressed in the same units.
+            drawWindowDurationMinutes: Math.ceil(windowMinutes()),
+            maxPullsPerTransaction: 1,
+            maxPullsPerUser: 1,
+            slots: [
+                { slotNumber: 1, name: "Test Prize — Dragoon Storm", price: 100, weight: 50, isBooked: false, image: seedPhoto("lottery-slot-tester-1-20260101", 600, 600) },
+                { slotNumber: 2, name: "Test Prize — Dranzer S", price: 100, weight: 50, isBooked: false, image: seedPhoto("lottery-slot-tester-2-20260101", 600, 600) },
+                {
+                    slotNumber: 3,
+                    name: "Test Prize — Draciel Shield",
+                    price: 100,
+                    weight: 50,
+                    isBooked: true,
+                    bookedByUserId: "user-ash-trainer",
+                    bookedByDisplayName: "Mock User 4",
+                    bookedByUserLotteryNumber: 1,
+                    image: seedPhoto("lottery-slot-tester-3-20260101", 600, 600),
+                },
+                { slotNumber: 4, name: "Test Prize — Driger F", price: 100, weight: 50, isBooked: false },
+                { slotNumber: 5, name: "Test Prize — Wolborg", price: 100, weight: 50, isBooked: false },
+                { slotNumber: 6, name: "Test Prize — Trygle", price: 100, weight: 50, isBooked: false },
+            ],
+        },
+        stats: { totalEntries: 1, approvedEntries: 1, flaggedEntries: 0 },
+        createdBy: "user-admin-letitrip",
+        isTestData: true,
+        testDataExpiresAt: testDataExpiresAt(),
+        createdAt: new Date(),
+        updatedAt: new Date(),
+    },
 ];

package/dist/features/tester/seed-data/offers-tester-seed-data.js

@@ -11,7 +11,7 @@
  *       drive it straight through the Offers checkout lane.
  *
  * Every date is Date.now()-relative (per CLAUDE.md's tester-fixture standards)
- * so the 4-hour testerSandboxRefresh re-arms it instead of letting it go stale.
+ * so each seed run re-arms it instead of letting it go stale.
  *
  * EXPORTS:
  *   offersTesterSeedData — Array of 1 Partial<OfferDocument> for the seed runner
@@ -25,9 +25,23 @@
  */
 import { OfferStatusValues } from "../../seller/schemas/firestore";
 import { testDataExpiresAt } from "./tester-ttl";
+import { windowOffset } from "./tester-window";
 const NOW = new Date();
 const hoursAgo = (n) => new Date(NOW.getTime() - n * 3600000);
-const hoursFromNow = (n) => new Date(NOW.getTime() + n * 3600000);
+/*
+ * Deadlines expressed as fractions of the testing window rather than fixed hours.
+ *
+ * "An accepted offer past its checkoutDeadline cannot be checked out" is a real
+ * checklist case, and a fixed 36-hour deadline makes it untestable in any session
+ * shorter than a day and a half. Fractions scale with TESTER_WINDOW_MINUTES, so the
+ * lapse actually happens while someone is watching.
+ *
+ * OUTLASTS_RUN is deliberately greater than 1: the "still live" offers must NOT
+ * lapse mid-run, or every other offer case starts failing for the wrong reason.
+ */
+const OUTLASTS_RUN = 2;
+const LAPSES_MID_RUN = 1 / 3;
+const CHECKOUT_LAPSES_MID_RUN = 1 / 6;
 export const offersTesterSeedData = [
     {
         id: "offer-tester-sandbox-accepted",
@@ -52,11 +66,11 @@ export const offersTesterSeedData = [
         status: OfferStatusValues.ACCEPTED,
         buyerNote: "Sandbox offer — already accepted so testers can drive checkout.",
         sellerNote: "Accepted for QA sandbox testing.",
-        expiresAt: hoursFromNow(24),
+        expiresAt: windowOffset(OUTLASTS_RUN),
         acceptedAt: hoursAgo(1),
         respondedAt: hoursAgo(1),
         // Well inside the 48h window so the lane is live for a whole test session.
-        checkoutDeadline: hoursFromNow(36),
+        checkoutDeadline: windowOffset(OUTLASTS_RUN),
         createdAt: hoursAgo(2),
         updatedAt: hoursAgo(1),
         isTestData: true,
@@ -83,7 +97,7 @@ export const offersTesterSeedData = [
         status: OfferStatusValues.COUNTERED,
         buyerNote: "Sandbox offer — seller has countered, accept it to test the counter path.",
         sellerNote: "Counter: ₹1,150.",
-        expiresAt: hoursFromNow(24),
+        expiresAt: windowOffset(OUTLASTS_RUN),
         respondedAt: hoursAgo(1),
         createdAt: hoursAgo(2),
         updatedAt: hoursAgo(1),
@@ -112,10 +126,10 @@ export const offersTesterSeedData = [
         status: OfferStatusValues.ACCEPTED,
         buyerNote: "Sandbox offer — accepted with a short checkout window.",
         sellerNote: "Accepted. Pay soon!",
-        expiresAt: hoursFromNow(1),
+        expiresAt: windowOffset(LAPSES_MID_RUN),
         acceptedAt: hoursAgo(0),
         respondedAt: hoursAgo(0),
-        checkoutDeadline: new Date(NOW.getTime() + 30 * 60000),
+        checkoutDeadline: windowOffset(CHECKOUT_LAPSES_MID_RUN),
         createdAt: hoursAgo(1),
         updatedAt: hoursAgo(0),
         isTestData: true,
@@ -141,7 +155,7 @@ export const offersTesterSeedData = [
         currency: "INR",
         status: OfferStatusValues.PENDING,
         buyerNote: "Sandbox offer — still pending, withdraw it to test that path.",
-        expiresAt: hoursFromNow(24),
+        expiresAt: windowOffset(OUTLASTS_RUN),
         createdAt: hoursAgo(1),
         updatedAt: hoursAgo(1),
         isTestData: true,
@@ -168,7 +182,7 @@ export const offersTesterSeedData = [
         currency: "INR",
         status: OfferStatusValues.PENDING,
         buyerNote: "Sandbox inbound offer — accept, counter, or decline it from your store dashboard.",
-        expiresAt: hoursFromNow(24),
+        expiresAt: windowOffset(OUTLASTS_RUN),
         createdAt: hoursAgo(2),
         updatedAt: hoursAgo(2),
         isTestData: true,