@mohasinac/appkit 4.13.1 → 4.15.0

package/dist/features/events/components/AdminEventsView.js

@@ -5,22 +5,26 @@ import { sortBy } from "@mohasinac/appkit/client";
 import React from "react";
 import { FilterChipGroup, ListingLayout } from "../../../ui";
 import { ADMIN_ENDPOINTS } from "../../../constants/api-endpoints";
-import { ADMIN_EVENT_STATUS_TABS } from "../../admin/constants/filter-tabs";
+import { ADMIN_EVENT_STATUS_TABS, ALL_TAB } from "../../admin/constants/filter-tabs";
+import { ALL_EVENT_TYPES, EVENT_TYPE_LABELS } from "../types";
 import { toRecordArray, toRelativeDate, toStringValue, } from "../../admin/hooks/useAdminListingData";
 import { DataListingView } from "../../admin/components/DataListingView";
 import { AdminEventEditorView } from "./AdminEventEditorView";
 import { ADMIN_BULK_ACTIONS, ROW_ACTION_META } from "../../products/constants/action-defs";
-// TODO(events): TYPE_OPTIONS list pre-dates the SB9 EventType union refresh
-// (sale|offer|poll|survey|feedback|raffle|spin_wheel). Keep current values to
-// avoid silently breaking saved-filter URLs — sync in a dedicated follow-up.
+/**
+ * Derived from the `EventType` union (2026-08-24).
+ *
+ * The hand-written list this replaces offered `contest`, `giveaway` and
+ * `flash-sale` — none of which are `EventType` values, so each was fed straight
+ * into `sieveFilter("type", EQ, id)` and matched zero rows forever — while
+ * omitting five real types (`offer`, `feedback`, `raffle`, `spin_wheel`,
+ * `lottery`). It carried a TODO deferring the fix on the grounds of "avoid
+ * silently breaking saved-filter URLs"; that reasoning didn't hold, since a URL
+ * naming a dead id was already returning nothing (Root Cause #33 + #61).
+ */
 const TYPE_OPTIONS = [
-    { id: "All", label: "All" },
-    { id: "contest", label: "Contest" },
-    { id: "giveaway", label: "Giveaway" },
-    { id: "sale", label: "Sale" },
-    { id: "poll", label: "Poll" },
-    { id: "survey", label: "Survey" },
-    { id: "flash-sale", label: "Flash Sale" },
+    ALL_TAB,
+    ...ALL_EVENT_TYPES.map((type) => ({ id: type, label: EVENT_TYPE_LABELS[type] })),
 ];
 export function AdminEventsView({ children, ...props }) {
     if (React.Children.count(children) > 0) {

package/dist/features/events/components/EventFilters.d.ts

@@ -104,5 +104,13 @@ export declare function getEventSortOptions(variant: EventFilterVariant): Readon
 export interface EventFiltersProps {
     table: UrlTable;
     variant?: EventFilterVariant;
+    /**
+     * Matching-row counts keyed by event type AND status value. Optional — when
+     * absent every facet renders uncounted and nothing is hidden, which is the
+     * pre-existing behaviour.
+     */
+    counts?: Record<string, number | undefined>;
+    /** Drop facets whose count is 0. Requires `counts`. */
+    hideEmpty?: boolean;
 }
-export declare function EventFilters({ table, variant }: EventFiltersProps): import("react").JSX.Element;
+export declare function EventFilters({ table, variant, counts, hideEmpty, }: EventFiltersProps): import("react").JSX.Element;

package/dist/features/events/components/EventFilters.js

@@ -8,6 +8,25 @@ import { Div } from "../../../ui";
 import { TABLE_KEYS } from "../../../constants/table-keys";
 import { EVENT_FIELDS } from "../../../constants/field-names";
 import { sortBy } from "../../../constants/sort";
+import { ALL_EVENT_STATUSES, ALL_EVENT_TYPES, } from "../types";
+/**
+ * `sale` -> `eventTypeSale`, `spin_wheel` -> `eventTypeSpinWheel`.
+ *
+ * Derived rather than a lookup map so a new union member cannot be silently
+ * label-less; a missing i18n key surfaces as the key itself, which is loud.
+ */
+function pascal(value) {
+    return value
+        .split("_")
+        .map((part) => part.charAt(0).toUpperCase() + part.slice(1))
+        .join("");
+}
+function eventTypeLabelKey(value) {
+    return `eventType${pascal(value)}`;
+}
+function eventStatusLabelKey(value) {
+    return `eventStatus${pascal(value)}`;
+}
 export const EVENT_FILTER_KEYS = {
     admin: ["type", TABLE_KEYS.STATUS, TABLE_KEYS.DATE_FROM, TABLE_KEYS.DATE_TO],
     seller: ["type", TABLE_KEYS.STATUS, TABLE_KEYS.DATE_FROM, TABLE_KEYS.DATE_TO],
@@ -48,27 +67,32 @@ export function getEventSortOptions(variant) {
             return EVENT_PUBLIC_SORT_OPTIONS;
     }
 }
-export function EventFilters({ table, variant = "admin" }) {
+export function EventFilters({ table, variant = "admin", counts, hideEmpty = false, }) {
     const t = useTranslations("filters");
-    const typeOptions = [
-        { value: "sale", label: t("eventTypeSale") },
-        { value: "offer", label: t("eventTypeOffer") },
-        { value: "poll", label: t("eventTypePoll") },
-        { value: "survey", label: t("eventTypeSurvey") },
-        { value: "feedback", label: t("eventTypeFeedback") },
-        { value: "raffle", label: t("eventTypeRaffle") },
-        { value: "spin_wheel", label: t("eventTypeSpinWheel") },
-    ];
-    const adminStatusOptions = [
-        { value: "draft", label: t("eventStatusDraft") },
-        { value: "active", label: t("eventStatusActive") },
-        { value: "paused", label: t("eventStatusPaused") },
-        { value: "ended", label: t("eventStatusEnded") },
-    ];
-    const publicStatusOptions = [
-        { value: "active", label: t("eventStatusActive") },
-        { value: "ended", label: t("eventStatusEnded") },
-    ];
+    // Derived from the unions, not hand-listed. The previous literals were
+    // missing `lottery` (type) and `cancelled` (admin status) — a facet that
+    // doesn't exist can never be selected, so those events were unfilterable
+    // (Root Cause #61).
+    const typeOptions = ALL_EVENT_TYPES.map((value) => ({
+        value,
+        label: t(eventTypeLabelKey(value)),
+        count: counts?.[value],
+    }));
+    const adminStatusOptions = ALL_EVENT_STATUSES.map((value) => ({
+        value,
+        label: t(eventStatusLabelKey(value)),
+        count: counts?.[value],
+    }));
+    // Deliberately narrower than the union: a shopper has no use for draft,
+    // paused or cancelled events, and the public list query only ever returns
+    // active ones anyway. Kept as an explicit subset of ALL_EVENT_STATUSES so it
+    // is a documented omission rather than another drifted literal.
+    const PUBLIC_STATUSES = ["active", "ended"];
+    const publicStatusOptions = PUBLIC_STATUSES.map((value) => ({
+        value,
+        label: t(eventStatusLabelKey(value)),
+        count: counts?.[value],
+    }));
     const statusOptions = variant === "public" ? publicStatusOptions : adminStatusOptions;
     const selectedType = table.get("type")
         ? table.get("type").split("|").filter(Boolean)
@@ -76,5 +100,5 @@ export function EventFilters({ table, variant = "admin" }) {
     const selectedStatus = table.get("status")
         ? table.get("status").split("|").filter(Boolean)
         : [];
-    return (_jsxs(Div, { children: [_jsx(FilterFacetSection, { title: t("type"), options: typeOptions, selected: selectedType, onChange: (vals) => table.set("type", vals.join("|")), searchable: false, defaultCollapsed: false }), _jsx(FilterFacetSection, { title: t("status"), options: statusOptions, selected: selectedStatus, onChange: (vals) => table.set("status", vals.join("|")), searchable: false, defaultCollapsed: false }), _jsx(RangeFilter, { title: t("dateRange"), type: "date", minValue: table.get("dateFrom"), maxValue: table.get("dateTo"), onMinChange: (v) => table.set("dateFrom", v), onMaxChange: (v) => table.set("dateTo", v), minPlaceholder: t("minDate"), maxPlaceholder: t("maxDate"), defaultCollapsed: true }), _jsx(SwitchFilter, { title: t("expired"), label: t("showExpiredOnly"), checked: table.get("showExpired") === "true", onChange: (v) => table.set("showExpired", v ? "true" : "") })] }));
+    return (_jsxs(Div, { children: [_jsx(FilterFacetSection, { title: t("type"), options: typeOptions, selected: selectedType, onChange: (vals) => table.set("type", vals.join("|")), searchable: false, defaultCollapsed: false, hideEmpty: hideEmpty }), _jsx(FilterFacetSection, { title: t("status"), options: statusOptions, selected: selectedStatus, onChange: (vals) => table.set("status", vals.join("|")), hideEmpty: hideEmpty, searchable: false, defaultCollapsed: false }), _jsx(RangeFilter, { title: t("dateRange"), type: "date", minValue: table.get("dateFrom"), maxValue: table.get("dateTo"), onMinChange: (v) => table.set("dateFrom", v), onMaxChange: (v) => table.set("dateTo", v), minPlaceholder: t("minDate"), maxPlaceholder: t("maxDate"), defaultCollapsed: true }), _jsx(SwitchFilter, { title: t("expired"), label: t("showExpiredOnly"), checked: table.get("showExpired") === "true", onChange: (v) => table.set("showExpired", v ? "true" : "") })] }));
 }

package/dist/features/events/components/EventsIndexListing.d.ts

@@ -1,5 +1,10 @@
 import React from "react";
 export interface EventsIndexListingProps {
+    /**
+     * Event counts keyed by type AND status value, resolved server-side. Drives
+     * both the facet count badges and hiding facets that would return nothing.
+     */
+    facetCounts?: Record<string, number | undefined>;
     initialData?: any;
 }
-export declare function EventsIndexListing({ initialData }: EventsIndexListingProps): React.JSX.Element;
+export declare function EventsIndexListing({ initialData, facetCounts }: EventsIndexListingProps): React.JSX.Element;

package/dist/features/events/components/EventsIndexListing.js

@@ -18,7 +18,7 @@ const __O = {
 };
 const PAGE_SIZE = 24;
 const FILTER_KEYS = [TABLE_KEYS.TYPE, TABLE_KEYS.STATUS, TABLE_KEYS.DATE_FROM, TABLE_KEYS.DATE_TO, TABLE_KEYS.SHOW_EXPIRED];
-export function EventsIndexListing({ initialData }) {
+export function EventsIndexListing({ initialData, facetCounts }) {
     const table = useUrlTable({ defaults: { pageSize: String(PAGE_SIZE), sort: sortBy(EVENT_FIELDS.STARTS_AT, "ASC") } });
     const [searchInput, setSearchInput] = useState(table.get(TABLE_KEYS.QUERY) || "");
     const [filterOpen, setFilterOpen] = useState(false);
@@ -123,5 +123,5 @@ export function EventsIndexListing({ initialData }) {
     }, [searchInput, table]);
     return (_jsxs(Div, { className: "min-h-screen", children: [_jsx(ListingToolbar, { filterCount: activeFilterCount, onFiltersClick: openFilters, searchValue: searchInput, searchPlaceholder: "Search events...", onSearchChange: setSearchInput, onSearchCommit: commitSearch, sortValue: table.get(TABLE_KEYS.SORT) || sortBy(EVENT_FIELDS.STARTS_AT, "ASC"), sortOptions: EVENT_PUBLIC_SORT_OPTIONS, onSortChange: (v) => { table.set(TABLE_KEYS.SORT, v); }, view: view, onViewChange: handleViewToggle, onResetAll: resetAll, hasActiveState: hasActiveState, toggles: [
                     { label: "Show expired", active: showExpired, onChange: (next) => table.set(TABLE_KEYS.SHOW_EXPIRED, next ? "true" : "") },
-                ] }), totalPages > 1 && (_jsx(StickyToolbar, { offset: "header+pagination", tone: "translucent", border: true, padding: "toolbar", children: _jsx(Row, { justify: "center", children: _jsx(Pagination, { currentPage: currentPage, totalPages: totalPages, onPageChange: (p) => table.setPage(p) }) }) })), _jsx(Div, { padding: "y-lg", children: isLoading ? (_jsx(Div, { layout: "grid", gap: "6", className: "grid-cols-1 sm:grid-cols-2 lg:grid-cols-3", children: Array.from({ length: 6 }).map((_, i) => (_jsxs(Div, { className: `${__O.hidden} animate-pulse`, border: "subtle", rounded: "xl", children: [_jsx(Div, { className: "aspect-video", surface: "subtle" }), _jsxs(Stack, { className: `${__P.p4}`, gap: "sm", children: [_jsx(Div, { className: "h-4 w-3/4", surface: "subtle", rounded: "default" }), _jsx(Div, { className: "h-3 w-full", surface: "subtle", rounded: "default" }), _jsx(Div, { className: "h-3 w-2/3", surface: "subtle", rounded: "default" }), _jsx(Div, { className: "h-8 mt-2", surface: "subtle", rounded: "default" })] })] }, i))) })) : events.length === 0 ? (_jsx(Text, { paddingY: "3xl", color: "muted", size: "sm", align: "start", children: "No events found." })) : view === "list" ? (_jsx(Stack, { className: "divide-y divide-zinc-100 divide-[var(--appkit-color-border-subtle)]", border: "subtle", rounded: "xl", children: events.map((event) => (_jsx(EventCard, { event: event }, event.id))) })) : (_jsx(Div, { layout: "grid", gap: "6", className: "grid-cols-1 sm:grid-cols-2 lg:grid-cols-3", children: events.map((event) => (_jsx(EventCard, { event: event }, event.id))) })) }), _jsx(ListingFilterDrawer, { open: filterOpen, onClose: () => setFilterOpen(false), onApply: applyFilters, onClear: clearFilters, activeCount: activeFilterCount, children: _jsx(EventFilters, { table: pendingTable, variant: "public" }) })] }));
+                ] }), totalPages > 1 && (_jsx(StickyToolbar, { offset: "header+pagination", tone: "translucent", border: true, padding: "toolbar", children: _jsx(Row, { justify: "center", children: _jsx(Pagination, { currentPage: currentPage, totalPages: totalPages, onPageChange: (p) => table.setPage(p) }) }) })), _jsx(Div, { padding: "y-lg", children: isLoading ? (_jsx(Div, { layout: "grid", gap: "6", className: "grid-cols-1 sm:grid-cols-2 lg:grid-cols-3", children: Array.from({ length: 6 }).map((_, i) => (_jsxs(Div, { className: `${__O.hidden} animate-pulse`, border: "subtle", rounded: "xl", children: [_jsx(Div, { className: "aspect-video", surface: "subtle" }), _jsxs(Stack, { className: `${__P.p4}`, gap: "sm", children: [_jsx(Div, { className: "h-4 w-3/4", surface: "subtle", rounded: "default" }), _jsx(Div, { className: "h-3 w-full", surface: "subtle", rounded: "default" }), _jsx(Div, { className: "h-3 w-2/3", surface: "subtle", rounded: "default" }), _jsx(Div, { className: "h-8 mt-2", surface: "subtle", rounded: "default" })] })] }, i))) })) : events.length === 0 ? (_jsx(Text, { paddingY: "3xl", color: "muted", size: "sm", align: "start", children: "No events found." })) : view === "list" ? (_jsx(Stack, { className: "divide-y divide-zinc-100 divide-[var(--appkit-color-border-subtle)]", border: "subtle", rounded: "xl", children: events.map((event) => (_jsx(EventCard, { event: event }, event.id))) })) : (_jsx(Div, { layout: "grid", gap: "6", className: "grid-cols-1 sm:grid-cols-2 lg:grid-cols-3", children: events.map((event) => (_jsx(EventCard, { event: event }, event.id))) })) }), _jsx(ListingFilterDrawer, { open: filterOpen, onClose: () => setFilterOpen(false), onApply: applyFilters, onClear: clearFilters, activeCount: activeFilterCount, children: _jsx(EventFilters, { table: pendingTable, variant: "public", counts: facetCounts, hideEmpty: Boolean(facetCounts) }) })] }));
 }

package/dist/features/events/components/EventsListPageView.js

@@ -45,8 +45,17 @@ export async function EventsListPageView({ searchParams = {} }) {
     const page = Number(sp(searchParams, "page")) || 1;
     const pageSize = Number(sp(searchParams, "pageSize")) || 24;
     const filters = buildEventFilters(searchParams);
-    const result = await eventRepository
-        .list({ filters, sorts: sort, page, pageSize })
-        .catch(() => null);
-    return (_jsx(Main, { children: _jsx(Section, { padding: "y-2xl", children: _jsxs(Container, { size: "xl", children: [_jsx(Heading, { level: 1, className: "mb-8", color: "primary", size: "3xl", weight: "semibold", children: "Events" }), _jsx(AdSlot, { id: "listing-sidebar-top", className: "mb-6" }), _jsx(EventsIndexListing, { initialData: result }), _jsx(AdSlot, { id: "listing-sidebar-bottom", className: "mt-8" })] }) }) }));
+    const [result, facetCounts] = await Promise.all([
+        eventRepository
+            .list({ filters, sorts: sort, page, pageSize })
+            .catch(() => null),
+        // Facet counts are deliberately NOT narrowed by the shopper's own type or
+        // status selection: a count that shrank to zero as you ticked boxes would
+        // hide the very facet you'd need to untick. They answer "does this kind of
+        // event exist at all", which is the question that decides visibility.
+        eventRepository
+            .facetCountsForTypesAndStatuses()
+            .catch(() => ({})),
+    ]);
+    return (_jsx(Main, { children: _jsx(Section, { padding: "y-2xl", children: _jsxs(Container, { size: "xl", children: [_jsx(Heading, { level: 1, className: "mb-8", color: "primary", size: "3xl", weight: "semibold", children: "Events" }), _jsx(AdSlot, { id: "listing-sidebar-top", className: "mb-6" }), _jsx(EventsIndexListing, { initialData: result, facetCounts: facetCounts }), _jsx(AdSlot, { id: "listing-sidebar-bottom", className: "mt-8" })] }) }) }));
 }

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

@@ -5,6 +5,23 @@ declare class EventRepository extends BaseRepository<EventDocument> {
     static readonly SIEVE_FIELDS: FirebaseSieveFields;
     constructor();
     list(model: SieveModel): Promise<FirebaseSieveResult<EventDocument>>;
+    /**
+     * How many events exist per `type` and per `status` — the numbers behind the
+     * facet checkboxes, and what lets a type with no events disappear from the
+     * filter instead of offering a guaranteed-empty result.
+     *
+     * Events carry no store/category/brand FK (verified against `EventDocument`),
+     * so these counts are global by nature; `baseFilters` narrows them only when
+     * a surface wants a subset (e.g. the public page counting active events).
+     *
+     * Both fields are counted in ONE parallel batch — 13 `.count()` aggregations,
+     * no document reads.
+     */
+    facetCountsForTypesAndStatuses(opts?: {
+        types?: readonly string[];
+        statuses?: readonly string[];
+        baseFilters?: string;
+    }): Promise<Record<string, number | undefined>>;
     findBySlug(slug: string): Promise<EventDocument | null>;
     findByIdOrSlug(idOrSlug: string): Promise<EventDocument | null>;
     /**

package/dist/features/events/repository/events.repository.js

@@ -1,6 +1,7 @@
 import { DatabaseError } from "../../../errors";
 import { serverLogger } from "../../../monitoring";
 import { slugify } from "../../../utils";
+import { ALL_EVENT_STATUSES, ALL_EVENT_TYPES } from "../types";
 import { normalizeError } from "../../../errors/normalize";
 import { BaseRepository, prepareForFirestore, parseSieveDateValue, } from "../../../providers/db-firebase";
 import { EVENT_FIELDS, EVENTS_COLLECTION, } from "../schemas";
@@ -12,6 +13,32 @@ class EventRepository extends BaseRepository {
     async list(model) {
         return this.sieveQuery(model, EventRepository.SIEVE_FIELDS);
     }
+    /**
+     * How many events exist per `type` and per `status` — the numbers behind the
+     * facet checkboxes, and what lets a type with no events disappear from the
+     * filter instead of offering a guaranteed-empty result.
+     *
+     * Events carry no store/category/brand FK (verified against `EventDocument`),
+     * so these counts are global by nature; `baseFilters` narrows them only when
+     * a surface wants a subset (e.g. the public page counting active events).
+     *
+     * Both fields are counted in ONE parallel batch — 13 `.count()` aggregations,
+     * no document reads.
+     */
+    async facetCountsForTypesAndStatuses(opts) {
+        const types = opts?.types ?? ALL_EVENT_TYPES;
+        const statuses = opts?.statuses ?? ALL_EVENT_STATUSES;
+        const [typeCounts, statusCounts] = await Promise.all([
+            this.facetCounts(EVENT_FIELDS.TYPE, types, EventRepository.SIEVE_FIELDS, {
+                baseFilters: opts?.baseFilters,
+            }),
+            this.facetCounts(EVENT_FIELDS.STATUS, statuses, EventRepository.SIEVE_FIELDS, { baseFilters: opts?.baseFilters }),
+        ]);
+        // Type and status values are disjoint, so one flat map is unambiguous and
+        // lets the filter component look either up by value without knowing which
+        // field it came from.
+        return { ...typeCounts, ...statusCounts };
+    }
     async findBySlug(slug) {
         return this.findOneBy(EVENT_FIELDS.SLUG, slug);
     }

package/dist/features/events/schemas/event-form.d.ts

@@ -0,0 +1,113 @@
+import { z } from "zod";
+/**
+ * ## `.passthrough()` STAYS here, deliberately
+ *
+ * `EventDraft` carries ~40 fields; this schema names seven. The blog form's
+ * equivalent was safe to tighten because its draft had fourteen fields and all
+ * fourteen could be named in one sitting. This one cannot: most of its fields
+ * are per-event-type (poll options, survey fields, spin prizes, raffle config)
+ * and only apply under a `type` discriminator, so naming them correctly means
+ * modelling the discriminated union rather than listing keys.
+ *
+ * Tightening it blind is the single most dangerous edit available in this
+ * codebase — `z.object()` strips unknown keys, so every field this schema
+ * failed to name would vanish from the draft the moment passthrough came off.
+ * That is exactly how `productBaseSchema` came to eat every `classified*` /
+ * `digitalCode*` / `liveItem*` / `prize*` field.
+ *
+ * The wire payload is NOT at risk either way: it is built explicitly below
+ * (`type`, `title`, `slug`, … plus `buildEventTypeConfig` /
+ * `buildEventRaffleFields`), never by spreading the draft.
+ *
+ * Prerequisite for removing it: a FULL-collection `roundtrip-diff --entity
+ * event --full`, not a sample — per the data-integrity protocol.
+ *
+ * 🛑 `annotate()` must be the OUTERMOST call on each field — it keys a WeakMap
+ * by schema instance and every zod wrapper returns a new one.
+ */
+export declare const eventDraftSchema: z.ZodEffects<z.ZodObject<{
+    type: z.ZodString;
+    title: z.ZodString;
+    startsAt: z.ZodString;
+    endsAt: z.ZodString;
+    couponId: z.ZodString;
+    displayCode: z.ZodString;
+    pollOptions: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        label: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        label: string;
+    }, {
+        id: string;
+        label: string;
+    }>, "many">;
+}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+    type: z.ZodString;
+    title: z.ZodString;
+    startsAt: z.ZodString;
+    endsAt: z.ZodString;
+    couponId: z.ZodString;
+    displayCode: z.ZodString;
+    pollOptions: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        label: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        label: string;
+    }, {
+        id: string;
+        label: string;
+    }>, "many">;
+}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+    type: z.ZodString;
+    title: z.ZodString;
+    startsAt: z.ZodString;
+    endsAt: z.ZodString;
+    couponId: z.ZodString;
+    displayCode: z.ZodString;
+    pollOptions: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        label: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        label: string;
+    }, {
+        id: string;
+        label: string;
+    }>, "many">;
+}, z.ZodTypeAny, "passthrough">>, z.objectOutputType<{
+    type: z.ZodString;
+    title: z.ZodString;
+    startsAt: z.ZodString;
+    endsAt: z.ZodString;
+    couponId: z.ZodString;
+    displayCode: z.ZodString;
+    pollOptions: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        label: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        label: string;
+    }, {
+        id: string;
+        label: string;
+    }>, "many">;
+}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+    type: z.ZodString;
+    title: z.ZodString;
+    startsAt: z.ZodString;
+    endsAt: z.ZodString;
+    couponId: z.ZodString;
+    displayCode: z.ZodString;
+    pollOptions: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        label: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        label: string;
+    }, {
+        id: string;
+        label: string;
+    }>, "many">;
+}, z.ZodTypeAny, "passthrough">>;

package/dist/features/events/schemas/event-form.js

@@ -0,0 +1,82 @@
+/*
+ * WHY: Same reason as the blog form schema — keeping it in the `.tsx` view
+ *      would have dragged a React component tree into every API route through
+ *      `SCHEMAS` -> `routeHandler`.
+ * WHAT: The event editor's form schema, with its UI metadata.
+ *
+ * EXPORTS:
+ *   eventDraftSchema
+ *
+ * @tag domain:events
+ * @tag layer:schema
+ * @tag pattern:none
+ * @tag access:isomorphic
+ * @tag consumers:AdminEventEditorView,SCHEMAS.forms
+ * @tag sideEffects:none
+ */
+import { z } from "zod";
+import { annotate } from "../../shell/field-ui-meta";
+/**
+ * ## `.passthrough()` STAYS here, deliberately
+ *
+ * `EventDraft` carries ~40 fields; this schema names seven. The blog form's
+ * equivalent was safe to tighten because its draft had fourteen fields and all
+ * fourteen could be named in one sitting. This one cannot: most of its fields
+ * are per-event-type (poll options, survey fields, spin prizes, raffle config)
+ * and only apply under a `type` discriminator, so naming them correctly means
+ * modelling the discriminated union rather than listing keys.
+ *
+ * Tightening it blind is the single most dangerous edit available in this
+ * codebase — `z.object()` strips unknown keys, so every field this schema
+ * failed to name would vanish from the draft the moment passthrough came off.
+ * That is exactly how `productBaseSchema` came to eat every `classified*` /
+ * `digitalCode*` / `liveItem*` / `prize*` field.
+ *
+ * The wire payload is NOT at risk either way: it is built explicitly below
+ * (`type`, `title`, `slug`, … plus `buildEventTypeConfig` /
+ * `buildEventRaffleFields`), never by spreading the draft.
+ *
+ * Prerequisite for removing it: a FULL-collection `roundtrip-diff --entity
+ * event --full`, not a sample — per the data-integrity protocol.
+ *
+ * 🛑 `annotate()` must be the OUTERMOST call on each field — it keys a WeakMap
+ * by schema instance and every zod wrapper returns a new one.
+ */
+export const eventDraftSchema = z.object({
+    type: annotate(z.string(), {
+        section: "details", sectionLabel: "Details", sectionRequired: true,
+        quick: true, order: 1, row: "pair", kind: "select",
+    }),
+    title: annotate(z.string().min(1, "Title is required"), {
+        section: "details", quick: true, order: 2, row: "full",
+    }),
+    startsAt: annotate(z.string().min(1, "Start date is required"), {
+        section: "details", quick: true, order: 3, row: "pair", kind: "date",
+    }),
+    endsAt: annotate(z.string().min(1, "End date is required"), {
+        section: "details", quick: true, order: 4, row: "pair", kind: "date",
+    }),
+    couponId: annotate(z.string(), {
+        section: "settings", sectionLabel: "Settings", order: 1, row: "pair",
+        help: "Required for offer events.",
+    }),
+    displayCode: annotate(z.string(), {
+        section: "settings", order: 2, row: "pair",
+        help: "Required for offer events.",
+    }),
+    pollOptions: annotate(z.array(z.object({ id: z.string(), label: z.string() })), {
+        section: "settings", order: 3, row: "full", kind: "list",
+    }),
+}).passthrough().superRefine((v, ctx) => {
+    if (v.type === "offer") {
+        if (!v.couponId.trim()) {
+            ctx.addIssue({ code: z.ZodIssueCode.custom, path: ["couponId"], message: "Coupon is required for offer events" });
+        }
+        if (!v.displayCode.trim()) {
+            ctx.addIssue({ code: z.ZodIssueCode.custom, path: ["displayCode"], message: "Display code is required for offer events" });
+        }
+    }
+    if (v.type === "poll" && v.pollOptions.filter((o) => o.label.trim()).length < 2) {
+        ctx.addIssue({ code: z.ZodIssueCode.custom, path: ["pollOptions"], message: "Poll events require at least 2 options" });
+    }
+});

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

@@ -128,6 +128,17 @@ export declare const EVENT_FIELDS: {
         readonly ENDED: EventStatus;
         readonly CANCELLED: EventStatus;
     };
+    /**
+     * Every `EventType`. `LOTTERY` was missing until 2026-08-24, which is why
+     * `events-seed-data.ts` — which imports EVENT_FIELDS from HERE, not from
+     * `constants/field-names.ts` — had to write `type: "lottery"` as a raw string
+     * literal while every other row used this map.
+     *
+     * NB. there are two `EVENT_FIELDS` constants (this one and the one in
+     * `constants/field-names.ts`) and they drifted independently. Same shape as
+     * the two competing `OrderStatus` types in Root Cause #36. Keep both in step
+     * with the `EventType` / `EventStatus` unions until one of them is retired.
+     */
     readonly TYPE_VALUES: {
         readonly SALE: EventType;
         readonly OFFER: EventType;
@@ -136,6 +147,7 @@ export declare const EVENT_FIELDS: {
         readonly FEEDBACK: EventType;
         readonly RAFFLE: EventType;
         readonly SPIN_WHEEL: EventType;
+        readonly LOTTERY: EventType;
     };
     readonly STATS: {
         readonly TOTAL_ENTRIES: "stats.totalEntries";

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

@@ -46,6 +46,17 @@ export const EVENT_FIELDS = {
         ENDED: "ended",
         CANCELLED: "cancelled",
     },
+    /**
+     * Every `EventType`. `LOTTERY` was missing until 2026-08-24, which is why
+     * `events-seed-data.ts` — which imports EVENT_FIELDS from HERE, not from
+     * `constants/field-names.ts` — had to write `type: "lottery"` as a raw string
+     * literal while every other row used this map.
+     *
+     * NB. there are two `EVENT_FIELDS` constants (this one and the one in
+     * `constants/field-names.ts`) and they drifted independently. Same shape as
+     * the two competing `OrderStatus` types in Root Cause #36. Keep both in step
+     * with the `EventType` / `EventStatus` unions until one of them is retired.
+     */
     TYPE_VALUES: {
         SALE: "sale",
         OFFER: "offer",
@@ -54,6 +65,7 @@ export const EVENT_FIELDS = {
         FEEDBACK: "feedback",
         RAFFLE: "raffle",
         SPIN_WHEEL: "spin_wheel",
+        LOTTERY: "lottery",
     },
     STATS: {
         TOTAL_ENTRIES: "stats.totalEntries",