@mohasinac/appkit 4.13.1 → 4.15.0

package/dist/features/store-extensions/schemas/admin-notification-form.d.ts

@@ -0,0 +1,36 @@
+import { z } from "zod";
+import type { AdminNotificationCategory, AdminNotificationDocument } from "./rbac";
+export declare const ADMIN_NOTIFICATION_CATEGORIES: [AdminNotificationCategory, ...AdminNotificationCategory[]];
+type Severity = AdminNotificationDocument["severity"];
+export declare const ADMIN_NOTIFICATION_SEVERITIES: [Severity, ...Severity[]];
+/**
+ * 🛑 `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 adminNotificationCreateSchema: z.ZodObject<{
+    title: z.ZodString;
+    body: z.ZodString;
+    category: z.ZodEnum<[AdminNotificationCategory, ...AdminNotificationCategory[]]>;
+    severity: z.ZodEnum<["warning" | "error" | "info", ...("warning" | "error" | "info")[]]>;
+    audienceUserIds: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    entityType: z.ZodOptional<z.ZodString>;
+    entityId: z.ZodOptional<z.ZodString>;
+}, "strict", z.ZodTypeAny, {
+    title: string;
+    body: string;
+    category: AdminNotificationCategory;
+    severity: "warning" | "error" | "info";
+    entityId?: string | undefined;
+    entityType?: string | undefined;
+    audienceUserIds?: string[] | undefined;
+}, {
+    title: string;
+    body: string;
+    category: AdminNotificationCategory;
+    severity: "warning" | "error" | "info";
+    entityId?: string | undefined;
+    entityType?: string | undefined;
+    audienceUserIds?: string[] | undefined;
+}>;
+export type AdminNotificationCreateValues = z.infer<typeof adminNotificationCreateSchema>;
+export {};

package/dist/features/store-extensions/schemas/admin-notification-form.js

@@ -0,0 +1,114 @@
+/*
+ * WHY: `POST /api/admin/admin-notifications` spread the raw request body into
+ *      Firestore with only `isRead: false` pinned. The last unvalidated write
+ *      path in `src/app/api`.
+ *
+ *      `category` and `severity` are both closed unions that the admin
+ *      notification bell filters and colours by, and neither was checked — so
+ *      a notification could be stored with a category no filter chip matches
+ *      and a severity no badge renders, which is the shape that produces a row
+ *      visible in the raw collection and invisible in the UI (Recurrent Root
+ *      Cause #33).
+ *
+ *      `audienceUserIds` decides WHO SEES IT. Unvalidated and unbounded, it
+ *      could arrive as a string rather than an array — silently narrowing or
+ *      widening the audience of an admin notification.
+ *
+ * WHAT: The create contract.
+ *
+ * ## `isRead` / `readAt` are absent on purpose
+ *
+ * Both are per-admin read state, owned by the read/dismiss path. A creator
+ * marking its own notification as already read would file it straight into the
+ * history nobody looks at.
+ *
+ * EXPORTS:
+ *   adminNotificationCreateSchema, ADMIN_NOTIFICATION_CATEGORIES,
+ *   ADMIN_NOTIFICATION_SEVERITIES, type AdminNotificationCreateValues
+ *
+ * @tag domain:store-extensions,admin-notifications
+ * @tag layer:schema
+ * @tag pattern:none
+ * @tag access:isomorphic
+ * @tag consumers:/api/admin/admin-notifications
+ * @tag sideEffects:none
+ */
+import { z } from "zod";
+import { annotate } from "../../shell/field-ui-meta";
+/*
+ * Keyed `Record<Union, true>` so BOTH mistakes are compile errors — a member
+ * added to the union and forgotten here, and a value here that is not real.
+ */
+const CATEGORY_MAP = {
+    system: true,
+    security: true,
+    moderation: true,
+    payouts: true,
+    fraud: true,
+    growth: true,
+};
+export const ADMIN_NOTIFICATION_CATEGORIES = Object.keys(CATEGORY_MAP);
+const SEVERITY_MAP = {
+    info: true,
+    warning: true,
+    error: true,
+};
+export const ADMIN_NOTIFICATION_SEVERITIES = Object.keys(SEVERITY_MAP);
+/**
+ * 🛑 `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 adminNotificationCreateSchema = z
+    .object({
+    title: annotate(z.string().min(1, "Give the notification a title.").max(200), {
+        section: "message",
+        sectionLabel: "Message",
+        sectionRequired: true,
+        quick: true,
+        order: 1,
+        row: "full",
+    }),
+    body: annotate(z.string().min(1, "Say what happened.").max(2000), {
+        section: "message",
+        quick: true,
+        order: 2,
+        row: "full",
+        kind: "textarea",
+    }),
+    category: annotate(z.enum(ADMIN_NOTIFICATION_CATEGORIES), {
+        section: "routing",
+        sectionLabel: "Routing",
+        sectionRequired: true,
+        quick: true,
+        order: 1,
+        row: "pair",
+    }),
+    severity: annotate(z.enum(ADMIN_NOTIFICATION_SEVERITIES), {
+        section: "routing",
+        quick: true,
+        order: 2,
+        row: "pair",
+    }),
+    // Empty (or omitted) means every admin — that is the documented meaning of
+    // the field, so an empty array must stay expressible and is NOT `.min(1)`.
+    // Capped because this is the audience of a broadcast.
+    audienceUserIds: annotate(z.array(z.string().min(1)).max(200).optional(), {
+        section: "routing",
+        order: 3,
+        row: "full",
+        kind: "list",
+        help: "Leave empty to notify every admin.",
+    }),
+    entityType: annotate(z.string().max(80).optional(), {
+        section: "link",
+        sectionLabel: "Linked record",
+        order: 1,
+        row: "pair",
+    }),
+    entityId: annotate(z.string().max(200).optional(), {
+        section: "link",
+        order: 2,
+        row: "pair",
+    }),
+})
+    .strict();

package/dist/features/store-extensions/schemas/analytics-forms.d.ts

@@ -0,0 +1,57 @@
+import { z } from "zod";
+import type { AlertOperator, AnalyticsCardType } from "./firestore";
+export declare const ANALYTICS_ALERT_OPERATORS: [AlertOperator, ...AlertOperator[]];
+export declare const ANALYTICS_CARD_TYPES: [AnalyticsCardType, ...AnalyticsCardType[]];
+/**
+ * 🛑 `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 analyticsAlertCreateSchema: z.ZodObject<{
+    label: z.ZodString;
+    metric: z.ZodString;
+    operator: z.ZodEnum<[AlertOperator, ...AlertOperator[]]>;
+    threshold: z.ZodNumber;
+    windowHours: z.ZodNumber;
+    isActive: z.ZodOptional<z.ZodBoolean>;
+    notifyChannels: z.ZodOptional<z.ZodArray<z.ZodEnum<["in-app", "email", "whatsapp"]>, "many">>;
+}, "strict", z.ZodTypeAny, {
+    label: string;
+    operator: AlertOperator;
+    threshold: number;
+    metric: string;
+    windowHours: number;
+    isActive?: boolean | undefined;
+    notifyChannels?: ("email" | "whatsapp" | "in-app")[] | undefined;
+}, {
+    label: string;
+    operator: AlertOperator;
+    threshold: number;
+    metric: string;
+    windowHours: number;
+    isActive?: boolean | undefined;
+    notifyChannels?: ("email" | "whatsapp" | "in-app")[] | undefined;
+}>;
+export type AnalyticsAlertCreateValues = z.infer<typeof analyticsAlertCreateSchema>;
+export declare const analyticsCardCreateSchema: z.ZodObject<{
+    title: z.ZodString;
+    type: z.ZodEnum<[AnalyticsCardType, ...AnalyticsCardType[]]>;
+    metric: z.ZodString;
+    filters: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<import("../../..").FirestoreValue, z.ZodTypeDef, import("../../..").FirestoreValue>>>;
+    position: z.ZodOptional<z.ZodNumber>;
+    isVisible: z.ZodOptional<z.ZodBoolean>;
+}, "strict", z.ZodTypeAny, {
+    type: AnalyticsCardType;
+    title: string;
+    metric: string;
+    position?: number | undefined;
+    filters?: Record<string, import("../../..").FirestoreValue> | undefined;
+    isVisible?: boolean | undefined;
+}, {
+    type: AnalyticsCardType;
+    title: string;
+    metric: string;
+    position?: number | undefined;
+    filters?: Record<string, import("../../..").FirestoreValue> | undefined;
+    isVisible?: boolean | undefined;
+}>;
+export type AnalyticsCardCreateValues = z.infer<typeof analyticsCardCreateSchema>;

package/dist/features/store-extensions/schemas/analytics-forms.js

@@ -0,0 +1,158 @@
+/*
+ * WHY: `POST /api/store/analytics/alerts` and `POST /api/store/analytics/cards`
+ *      both spread the raw request body into Firestore.
+ *
+ *      The alert one matters most. An analytics alert is a rule that FIRES —
+ *      `metric`, `operator`, `threshold` and `windowHours` are what a scheduled
+ *      job evaluates, and none of the four was checked. A `threshold` arriving
+ *      as the string "50" from a number input was written as a string, so the
+ *      comparison the alert exists to perform would run against a string; an
+ *      `operator` outside the real six matched nothing; and `windowHours` was
+ *      unbounded, so a rule could ask a job to look back a hundred years.
+ *
+ *      Neither failure surfaces as an error. The alert is created, listed, and
+ *      looks configured — it simply never fires, or fires wrongly.
+ *
+ * WHAT: The two create contracts.
+ *
+ * ## `scope` / `ownerId` / `isBuiltIn` are absent on purpose
+ *
+ * The routes pin all three. `scope` in particular decides whether a row is a
+ * seller's or the platform's, so accepting it from the body would let a seller
+ * file an admin-scoped card.
+ *
+ * EXPORTS:
+ *   analyticsAlertCreateSchema, analyticsCardCreateSchema,
+ *   ANALYTICS_ALERT_OPERATORS, ANALYTICS_CARD_TYPES,
+ *   type AnalyticsAlertCreateValues, type AnalyticsCardCreateValues
+ *
+ * @tag domain:store-extensions,analytics
+ * @tag layer:schema
+ * @tag pattern:none
+ * @tag access:isomorphic
+ * @tag consumers:/api/store/analytics/alerts,/api/store/analytics/cards
+ * @tag sideEffects:none
+ */
+import { z } from "zod";
+import { annotate } from "../../shell/field-ui-meta";
+import { firestoreValueSchema } from "../../../schemas/firestore-value";
+/*
+ * Keyed `Record<Union, true>` so BOTH mistakes are compile errors — a value
+ * added to the union and forgotten here, and a value here that is not real.
+ */
+const ALERT_OPERATOR_MAP = {
+    ">": true,
+    "<": true,
+    ">=": true,
+    "<=": true,
+    "==": true,
+    "!=": true,
+};
+export const ANALYTICS_ALERT_OPERATORS = Object.keys(ALERT_OPERATOR_MAP);
+const CARD_TYPE_MAP = {
+    metric: true,
+    line: true,
+    bar: true,
+    pie: true,
+    table: true,
+    custom: true,
+};
+export const ANALYTICS_CARD_TYPES = Object.keys(CARD_TYPE_MAP);
+/** One year. A window beyond this is a typo, not a reporting period. */
+const MAX_WINDOW_HOURS = 24 * 365;
+/**
+ * 🛑 `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 analyticsAlertCreateSchema = z
+    .object({
+    label: annotate(z.string().min(1, "Give the alert a name.").max(120), {
+        section: "alert",
+        sectionLabel: "Alert",
+        sectionRequired: true,
+        quick: true,
+        order: 1,
+        row: "full",
+    }),
+    metric: annotate(z.string().min(1, "Choose a metric to watch."), {
+        section: "rule",
+        sectionLabel: "When to fire",
+        sectionRequired: true,
+        quick: true,
+        order: 1,
+        row: "pair",
+    }),
+    operator: annotate(z.enum(ANALYTICS_ALERT_OPERATORS), {
+        section: "rule",
+        quick: true,
+        order: 2,
+        row: "pair",
+    }),
+    // Coerced. A number input sends a string, and an uncoerced threshold is
+    // compared as a string by whatever evaluates the rule — "9" > "10".
+    threshold: annotate(z.coerce.number({ invalid_type_error: "Set a numeric threshold." }), {
+        section: "rule",
+        quick: true,
+        order: 3,
+        row: "pair",
+        kind: "number",
+    }),
+    windowHours: annotate(z.coerce
+        .number()
+        .int("The window must be a whole number of hours.")
+        .min(1, "The window must be at least an hour.")
+        .max(MAX_WINDOW_HOURS, "That window is longer than a year."), { section: "rule", quick: true, order: 4, row: "pair", kind: "number" }),
+    isActive: annotate(z.boolean().optional(), {
+        section: "delivery",
+        sectionLabel: "Delivery",
+        order: 1,
+        row: "quarter",
+    }),
+    notifyChannels: annotate(z.array(z.enum(["in-app", "email", "whatsapp"])).min(1).optional(), { section: "delivery", order: 2, row: "full", kind: "list" }),
+})
+    .strict();
+export const analyticsCardCreateSchema = z
+    .object({
+    title: annotate(z.string().min(1, "Give the card a title.").max(120), {
+        section: "card",
+        sectionLabel: "Card",
+        sectionRequired: true,
+        quick: true,
+        order: 1,
+        row: "full",
+    }),
+    type: annotate(z.enum(ANALYTICS_CARD_TYPES), {
+        section: "card",
+        quick: true,
+        order: 2,
+        row: "pair",
+    }),
+    metric: annotate(z.string().min(1, "Choose a metric."), {
+        section: "card",
+        quick: true,
+        order: 3,
+        row: "pair",
+    }),
+    // Deliberately open — filter shape varies by card type, and a closed schema
+    // would silently strip whatever the builder produced for a type it did not
+    // enumerate.
+    filters: annotate(z.record(firestoreValueSchema).optional(), {
+        section: "card",
+        order: 4,
+        row: "full",
+        kind: "list",
+    }),
+    position: annotate(z.coerce.number().int().min(0).optional(), {
+        section: "layout",
+        sectionLabel: "Layout",
+        order: 1,
+        row: "pair",
+        kind: "number",
+    }),
+    isVisible: annotate(z.boolean().optional(), {
+        section: "layout",
+        order: 2,
+        row: "quarter",
+    }),
+})
+    .strict();

package/dist/features/store-extensions/schemas/custom-role-form.d.ts

@@ -0,0 +1,85 @@
+import { z } from "zod";
+/** Whether a string is a permission this system can actually grant. */
+export declare function isKnownPermission(value: string): boolean;
+/**
+ * 🛑 `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 customRoleFormSchema: z.ZodObject<{
+    name: z.ZodString;
+    slug: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    scope: z.ZodEnum<["global", "store"]>;
+    permissions: z.ZodArray<z.ZodEffects<z.ZodString, string, string>, "many">;
+    inheritsFrom: z.ZodOptional<z.ZodString>;
+    isActive: z.ZodBoolean;
+}, "strip", z.ZodTypeAny, {
+    scope: "store" | "global";
+    name: string;
+    slug: string;
+    isActive: boolean;
+    permissions: string[];
+    description?: string | undefined;
+    inheritsFrom?: string | undefined;
+}, {
+    scope: "store" | "global";
+    name: string;
+    slug: string;
+    isActive: boolean;
+    permissions: string[];
+    description?: string | undefined;
+    inheritsFrom?: string | undefined;
+}>;
+export type CustomRoleFormValues = z.infer<typeof customRoleFormSchema>;
+/** Create contract. `createdBy` is absent — the route sets it from the session. */
+export declare const customRoleCreateSchema: z.ZodObject<{
+    name: z.ZodString;
+    slug: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    scope: z.ZodEnum<["global", "store"]>;
+    permissions: z.ZodArray<z.ZodEffects<z.ZodString, string, string>, "many">;
+    inheritsFrom: z.ZodOptional<z.ZodString>;
+    isActive: z.ZodBoolean;
+}, "strip", z.ZodTypeAny, {
+    scope: "store" | "global";
+    name: string;
+    slug: string;
+    isActive: boolean;
+    permissions: string[];
+    description?: string | undefined;
+    inheritsFrom?: string | undefined;
+}, {
+    scope: "store" | "global";
+    name: string;
+    slug: string;
+    isActive: boolean;
+    permissions: string[];
+    description?: string | undefined;
+    inheritsFrom?: string | undefined;
+}>;
+/**
+ * Update contract — partial and `.strict()`, so an unknown key is a 400 rather
+ * than a silent write into a document the permission system reads.
+ */
+export declare const customRoleUpdateSchema: z.ZodObject<{
+    name: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    scope: z.ZodOptional<z.ZodEnum<["global", "store"]>>;
+    permissions: z.ZodOptional<z.ZodArray<z.ZodEffects<z.ZodString, string, string>, "many">>;
+    inheritsFrom: z.ZodOptional<z.ZodString>;
+    isActive: z.ZodOptional<z.ZodBoolean>;
+}, "strict", z.ZodTypeAny, {
+    scope?: "store" | "global" | undefined;
+    name?: string | undefined;
+    description?: string | undefined;
+    isActive?: boolean | undefined;
+    permissions?: string[] | undefined;
+    inheritsFrom?: string | undefined;
+}, {
+    scope?: "store" | "global" | undefined;
+    name?: string | undefined;
+    description?: string | undefined;
+    isActive?: boolean | undefined;
+    permissions?: string[] | undefined;
+    inheritsFrom?: string | undefined;
+}>;

package/dist/features/store-extensions/schemas/custom-role-form.js

@@ -0,0 +1,118 @@
+/*
+ * WHY: Custom roles GRANT PERMISSIONS, and neither creating nor updating one
+ *      validated anything. Measured 2026-08-24:
+ *        · `POST /api/admin/roles` — `parseJsonBody` then `...body` spread
+ *          into `.create()`.
+ *        · `PATCH /api/admin/roles/[id]` — the raw body handed straight to
+ *          `.update()`.
+ *        · Both pages (`admin/roles/new`, `.../[id]/edit`) are raw controls
+ *          with no Zod anywhere.
+ *      So a role could be written with no name, a `permissions` array holding
+ *      arbitrary strings, a `scope` outside its union, or any invented key —
+ *      all persisted verbatim into the document the permission system reads.
+ * WHAT: One schema for both pages AND both routes.
+ *
+ * ## Permissions are checked against the real catalogue
+ *
+ * `Permission` is a closed union of ~85 `admin:resource:action` strings, and
+ * `PERMISSION_GROUPS` is its runtime form. A permission string that is not in
+ * it grants nothing — it silently never matches — so a role built from typos
+ * looks configured and does nothing, which is worse than being rejected.
+ *
+ * `"*"` is accepted deliberately: `security/rbac/types.ts` defines it as the
+ * wildcard, and rejecting it here would break a legitimate super-role.
+ *
+ * ## What is NOT accepted from the body
+ *
+ * `createdBy` is set from the session by the route. `id`/`createdAt`/
+ * `updatedAt` are the repository's. A caller able to set `createdBy` could
+ * attribute a privilege grant to somebody else, which is precisely the field
+ * an audit trail depends on.
+ *
+ * EXPORTS:
+ *   customRoleFormSchema, customRoleCreateSchema, customRoleUpdateSchema,
+ *   isKnownPermission, type CustomRoleFormValues
+ *
+ * @tag domain:store-extensions,rbac
+ * @tag layer:schema
+ * @tag pattern:none
+ * @tag access:isomorphic
+ * @tag consumers:admin/roles pages,/api/admin/roles
+ * @tag sideEffects:none
+ */
+import { z } from "zod";
+import { annotate } from "../../shell/field-ui-meta";
+import { PERMISSION_GROUPS } from "../../auth/permissions/constants";
+/**
+ * Every permission the catalogue actually defines, plus the wildcard.
+ *
+ * Derived from `PERMISSION_GROUPS` rather than restated — a hand-written copy
+ * would be the second list of ~85 strings to keep in sync, and the first one
+ * to drift (Root Cause #61).
+ */
+const KNOWN_PERMISSIONS = new Set([
+    "*",
+    ...Object.values(PERMISSION_GROUPS).flat(),
+]);
+/** Whether a string is a permission this system can actually grant. */
+export function isKnownPermission(value) {
+    return KNOWN_PERMISSIONS.has(value);
+}
+const permissionSchema = z.string().refine(isKnownPermission, {
+    message: "Not a permission this system defines — it would grant nothing.",
+});
+/**
+ * 🛑 `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 customRoleFormSchema = z.object({
+    name: annotate(z.string().min(1, "A role needs a name.").max(80, "Keep the name under 80 characters."), {
+        section: "basics", sectionLabel: "Role", sectionRequired: true,
+        quick: true, order: 1, row: "pair",
+    }),
+    slug: annotate(z
+        .string()
+        .min(1, "A slug is required.")
+        .max(80)
+        .regex(/^[a-z0-9-]+$/, "Use lowercase letters, numbers and hyphens only."), {
+        section: "basics", quick: true, order: 2, row: "pair",
+        tier: "t1-derive",
+        help: "Generated from the name when left blank.",
+    }),
+    description: annotate(z.string().max(300, "Keep the description under 300 characters.").optional(), {
+        section: "basics", order: 3, row: "full",
+    }),
+    scope: annotate(z.enum(["global", "store"]), {
+        section: "basics", quick: true, order: 4, row: "pair",
+    }),
+    permissions: annotate(z.array(permissionSchema), {
+        section: "permissions", sectionLabel: "Permissions",
+        order: 1, row: "full", kind: "list",
+    }),
+    inheritsFrom: annotate(z.string().max(80).optional(), {
+        section: "permissions", order: 2, row: "pair",
+        help: "Another role whose permissions this one starts from.",
+    }),
+    isActive: annotate(z.boolean(), {
+        section: "visibility", sectionLabel: "Visibility", order: 1, row: "quarter",
+    }),
+});
+/** Create contract. `createdBy` is absent — the route sets it from the session. */
+export const customRoleCreateSchema = customRoleFormSchema;
+/**
+ * Update contract — partial and `.strict()`, so an unknown key is a 400 rather
+ * than a silent write into a document the permission system reads.
+ */
+export const customRoleUpdateSchema = z
+    .object({
+    name: z.string().min(1).max(80).optional(),
+    description: z.string().max(300).optional(),
+    scope: z.enum(["global", "store"]).optional(),
+    permissions: z.array(permissionSchema).optional(),
+    inheritsFrom: z.string().max(80).optional(),
+    isActive: z.boolean().optional(),
+    // `slug` is deliberately absent: it is the role's stable identifier and
+    // renaming it would orphan every user already assigned the role. Same
+    // create-only rule every other slug in this codebase follows.
+})
+    .strict();

package/dist/features/store-extensions/schemas/firestore.d.ts

@@ -100,7 +100,25 @@ export interface StoreCategoryDocument extends BaseDocument {
 export declare const STORE_CATEGORIES_COLLECTION: "storeCategories";
 export declare const STORE_CATEGORY_INDEXED_FIELDS: readonly ["storeId", "slug", "isActive", "displayOrder", "createdAt"];
 export declare const DEFAULT_STORE_CATEGORY_DATA: Partial<StoreCategoryDocument>;
-export type ListingTemplateType = "standard" | "auction" | "pre-order" | "prize-draw" | "bundle" | "classified" | "digital-code" | "live";
+/**
+ * The listing kinds a seller can save a template for.
+ *
+ * A runtime array, with the type DERIVED from it — so the Zod enum in
+ * `listing-template-form.ts` reads this rather than restating it. That was the
+ * eleventh hand-written copy of the listing-type union in this codebase, and
+ * the tenth had already drifted (Root Cause #61).
+ *
+ * Two deliberate differences from `ListingType`:
+ *  - `bundle` is KEPT even though SB-UNI-D stopped it being a listingType. A
+ *    seeded template stores it (`store-extensions-seed-data.ts:202`), so
+ *    dropping it here would make that template fail validation and become
+ *    unsaveable — the same defect as the blog `slug` regex no stored row
+ *    satisfied.
+ *  - `art` and `stickers` are ADDED. They are real listing types a seller can
+ *    create, and their absence meant a template could never be saved for them.
+ */
+export declare const LISTING_TEMPLATE_TYPES: readonly ["standard", "auction", "pre-order", "prize-draw", "bundle", "classified", "digital-code", "live", "art", "stickers"];
+export type ListingTemplateType = (typeof LISTING_TEMPLATE_TYPES)[number];
 export interface ListingTemplateDocument extends BaseDocument {
     storeId: string;
     ownerId: string;
@@ -151,6 +169,8 @@ export interface ReportDocument extends BaseDocument {
     resolution?: string;
     resolvedAt?: Date;
 }
+export declare const REPORT_ENTITY_TYPES: [ReportEntityType, ...ReportEntityType[]];
+export declare const REPORT_REASONS: [ReportReason, ...ReportReason[]];
 export declare const REPORTS_COLLECTION: "reports";
 export declare const REPORT_INDEXED_FIELDS: readonly ["entityType", "entityId", "reporterId", "reason", "status", "createdAt"];
 export declare const DEFAULT_REPORT_DATA: Partial<ReportDocument>;

package/dist/features/store-extensions/schemas/firestore.js

@@ -63,6 +63,36 @@ export const DEFAULT_STORE_CATEGORY_DATA = {
     displayOrder: 0,
     productIds: [],
 };
+// 6. ───── listingTemplates ───────────────────────────────────────────────
+/**
+ * The listing kinds a seller can save a template for.
+ *
+ * A runtime array, with the type DERIVED from it — so the Zod enum in
+ * `listing-template-form.ts` reads this rather than restating it. That was the
+ * eleventh hand-written copy of the listing-type union in this codebase, and
+ * the tenth had already drifted (Root Cause #61).
+ *
+ * Two deliberate differences from `ListingType`:
+ *  - `bundle` is KEPT even though SB-UNI-D stopped it being a listingType. A
+ *    seeded template stores it (`store-extensions-seed-data.ts:202`), so
+ *    dropping it here would make that template fail validation and become
+ *    unsaveable — the same defect as the blog `slug` regex no stored row
+ *    satisfied.
+ *  - `art` and `stickers` are ADDED. They are real listing types a seller can
+ *    create, and their absence meant a template could never be saved for them.
+ */
+export const LISTING_TEMPLATE_TYPES = [
+    "standard",
+    "auction",
+    "pre-order",
+    "prize-draw",
+    "bundle",
+    "classified",
+    "digital-code",
+    "live",
+    "art",
+    "stickers",
+];
 export const LISTING_TEMPLATES_COLLECTION = "listingTemplates";
 export const LISTING_TEMPLATE_INDEXED_FIELDS = [
     "storeId",
@@ -92,6 +122,36 @@ export const MODERATION_QUEUE_INDEXED_FIELDS = [
 export const DEFAULT_MODERATION_QUEUE_DATA = {
     status: "pending",
 };
+/*
+ * Runtime companions for the three report unions above.
+ *
+ * Keyed `Record<Union, true>` rather than written as arrays, because that is
+ * the only shape where BOTH mistakes are compile errors: a member added to the
+ * union and forgotten here, AND a value here that is not a real member. An
+ * array literal catches neither, which is how ten independent enumerations of
+ * `ListingType` came to disagree (Recurrent Root Cause #61).
+ */
+const REPORT_ENTITY_TYPE_MAP = {
+    product: true,
+    store: true,
+    review: true,
+    event: true,
+    user: true,
+    blog: true,
+    comment: true,
+};
+export const REPORT_ENTITY_TYPES = Object.keys(REPORT_ENTITY_TYPE_MAP);
+const REPORT_REASON_MAP = {
+    scam: true,
+    counterfeit: true,
+    prohibited: true,
+    inappropriate: true,
+    harassment: true,
+    spam: true,
+    "ip-violation": true,
+    other: true,
+};
+export const REPORT_REASONS = Object.keys(REPORT_REASON_MAP);
 export const REPORTS_COLLECTION = "reports";
 export const REPORT_INDEXED_FIELDS = [
     "entityType",