@mohasinac/appkit 4.71.0 → 4.72.0

package/dist/_internal/server/features/lottery/actions.js

@@ -1,365 +0,0 @@
-"use server";
-/*
- * 🛑 From the DEFINING module, never "@mohasinac/appkit/server".
- *
- * appkit importing its own public server barrel is a self-reference that drags
- * the whole server surface in behind it — `dist/server.js` reaches next/og,
- * next/navigation, next/headers and driver.js. Twenty `actions.ts` files did
- * this for two symbols, and because `obligationSweep` reaches one of them, the
- * Firebase Functions tsup bundle (noExternal: appkit) had to resolve Next:
- * it failed on two `react-server-dom-webpack/*` requires and two @vercel/og
- * .wasm files, naming none of the responsible files. Root Cause #18.
- */
-import { wrapAction } from "../../../shared/types/action-result.js";
-import { getAdminDb } from "../../../../providers/db-firebase/index.js";
-import { eventRepository, productRepository, orderRepository } from "../../../../repositories/index.js";
-import { serverLogger } from "../../../../monitoring/index.js";
-import { lotteryEntryRepository } from "../../../../features/lottery/repository/lottery-entry.repository.js";
-import { requireRoleUser } from "../../../../providers/auth-firebase/helpers.js";
-import { ValidationError } from "../../../shared/errors/index.js";
-import { submitLotteryPullSchema, flagLotteryEntrySchema, reopenLotterySlotSchema, } from "../../../../features/lottery/schemas/zod.js";
-import { LotteryError, assignSlotWeights, pickWeightedSlot, } from "../../../../features/lottery/types/index.js";
-import { LOTTERY_ENTRIES_COLLECTION } from "../../../../features/lottery/schemas/firestore.js";
-// ── Helpers ──────────────────────────────────────────────────────────────────
-function isDrawWindowOpen(config) {
-    // Draw window is implicitly open when there are unclaimed slots.
-    // A real implementation would also check if the event status is "active".
-    return config.slots.some((s) => !s.isBooked);
-}
-// ── Public actions ────────────────────────────────────────────────────────────
-/**
- * User-initiated lottery pull.
- * Atomically:
- * 1. Validates inputs + limits
- * 2. Runs weighted slot selection on unclaimed slots
- * 3. Marks the slot as booked
- * 4. Creates the LotteryEntryDocument with assignedPrizeSlotNumber set
- *
- * Returns the assigned slot number so the user sees their prize immediately.
- */
-export async function submitLotteryPullAction(input) {
-    return wrapAction(async () => {
-        // Auth — must be logged in
-        const user = await requireRoleUser(["user", "buyer", "seller", "admin", "moderator", "employee"]);
-        const parsed = submitLotteryPullSchema.safeParse(input);
-        if (!parsed.success) {
-            throw new ValidationError(parsed.error.issues[0]?.message ?? "Invalid lottery pull input");
-        }
-        const data = parsed.data;
-        const sourceId = data.sourceType === "event" ? data.eventId : data.productId;
-        const sourceField = data.sourceType === "event" ? "eventId" : "productId";
-        // Load the event/product to get the lotteryConfig
-        let lotteryConfig;
-        if (data.sourceType === "event") {
-            const event = await eventRepository.findById(sourceId);
-            if (!event || event.type !== "lottery") {
-                throw new LotteryError("LOTTERY_WINDOW_CLOSED", "Lottery event not found or not of type lottery.");
-            }
-            if (event.status !== "active") {
-                throw new LotteryError("LOTTERY_WINDOW_CLOSED", "This lottery is not currently active.");
-            }
-            if (!event.lotteryConfig) {
-                throw new LotteryError("LOTTERY_WINDOW_CLOSED", "Lottery config not found on event.");
-            }
-            lotteryConfig = event.lotteryConfig;
-        }
-        else {
-            const product = await productRepository.findById(sourceId);
-            if (!product || product.listingType !== "prize-draw") {
-                throw new LotteryError("LOTTERY_WINDOW_CLOSED", "Prize-draw product not found.");
-            }
-            if (product.status !== "published") {
-                throw new LotteryError("LOTTERY_WINDOW_CLOSED", "This prize draw is not currently active.");
-            }
-            if (product.prizeDrawMode !== "lottery" || !product.lotteryConfig) {
-                throw new LotteryError("LOTTERY_WINDOW_CLOSED", "Lottery config not found on product.");
-            }
-            lotteryConfig = product.lotteryConfig;
-        }
-        // Check draw window
-        if (!isDrawWindowOpen(lotteryConfig)) {
-            throw new LotteryError("LOTTERY_FULL", "All slots have been claimed.");
-        }
-        // Enforce maxPullsPerUser
-        const existingUserPulls = await lotteryEntryRepository.countByUser(sourceId, sourceField, user.uid);
-        if (existingUserPulls >= lotteryConfig.maxPullsPerUser) {
-            throw new LotteryError("USER_LIMIT_REACHED", "You have reached the maximum number of pulls for this lottery.");
-        }
-        /*
-         * ── D52: THE TRANSACTION MUST BE A REAL, PAID, CALLER-OWNED ORDER ──────
-         *
-         * 🛑 Before this, `data.transactionId` was a user-supplied STRING
-         * (`z.string().min(4)`) and the only thing checked was a COUNT of prior
-         * entries carrying the same string. Nothing verified that the transaction
-         * existed, that it was paid, or that it belonged to the caller — and
-         * `paymentTime` was user-supplied too.
-         *
-         * So **anyone could claim a lottery slot for free** by typing any
-         * four-character string, up to `maxPullsPerUser`, and then another
-         * `maxPullsPerUser` under the next string. On a lottery whose slots carry
-         * real prices and real prizes.
-         *
-         * The code knew: `// FUTURE_FINANCIAL_DB: external_tx_id →
-         * lottery_transactions.external_tx_id`, pointing at a collection that does
-         * not exist. The gap was marked and left open.
-         *
-         * It does not need that collection: a prize-draw entry is bought through
-         * the ordinary cart, so a paid ORDER is the payment record we already
-         * have. `maxPullsPerTransaction` then does what its name says — it bounds
-         * pulls per PAYMENT rather than per guessed string.
-         *
-         * 🛑 THE TWO SOURCES HAVE DIFFERENT PAYMENT REALITIES, and pretending
-         * otherwise would either leave the hole open or break a working feature.
-         *
-         * · A PRODUCT-sourced lottery is a `prize-draw` listing bought through the
-         *   ordinary cart, so a paid ORDER exists and is verifiable. Required.
-         *
-         * · An EVENT-sourced lottery carries real slot prices (the seed has both
-         *   `uniform` and `variable` events) and has **no cart or checkout path at
-         *   all** — an event is not a product and cannot be added to a cart. So
-         *   the typed `transactionId` was the ENTIRE payment record: an
-         *   honour-system reference with nothing behind it.
-         *
-         *   Requiring an order here would break every event lottery. Accepting the
-         *   string silently is the hole. So the entry is accepted and marked
-         *   `isFlagged` for admin review BEFORE the draw — `flagLotteryEntry`
-         *   already exists for exactly this, and an admin can clear or void it.
-         *   That makes the unverified state VISIBLE instead of indistinguishable
-         *   from a paid one.
-         *
-         * 🛑 This is a stopgap, not a fix, and it is the honest one available
-         * without building a checkout path for events. The real fix is to make an
-         * event lottery purchasable (or free), which is a product decision.
-         */
-        let paymentUnverified = false;
-        if (data.sourceType === "product") {
-            const payingOrder = await orderRepository.findById(data.transactionId);
-            /*
-             * "Not found" and "not yours" share one message DELIBERATELY.
-             * Distinguishing them confirms that an order id exists and belongs to
-             * someone else, which is an enumeration oracle over order ids.
-             */
-            if (!payingOrder || payingOrder.userId !== user.uid) {
-                throw new LotteryError("TX_ALREADY_USED", "That order could not be found. Enter the order ID from your confirmation email.");
-            }
-            if (payingOrder.paymentStatus !== "paid") {
-                throw new LotteryError("TX_ALREADY_USED", "That order has not been paid yet. Once the payment is confirmed you can claim your slot.");
-            }
-            /*
-             * The order must contain THIS prize draw, or one paid order could be
-             * spent across every open lottery on the site.
-             *
-             * Both shapes are checked: `items[]` is the fan-out form, and the flat
-             * `productId` is the PRIMARY field on an order — CLAUDE.md's own
-             * correction records that `items` is OPTIONAL and the flat fields are
-             * not legacy residue, so checking only one misses real orders.
-             */
-            const orderCoversSource = payingOrder.productId === sourceId ||
-                (payingOrder.items ?? []).some((i) => i.productId === sourceId);
-            if (!orderCoversSource) {
-                throw new LotteryError("TX_ALREADY_USED", "That order does not include this prize draw. Check the order ID.");
-            }
-        }
-        else {
-            paymentUnverified = true;
-            serverLogger.warn("[lottery] event pull accepted with an UNVERIFIED payment reference — flagged for admin review", { eventId: sourceId, uid: user.uid, transactionId: data.transactionId });
-        }
-        // Enforce maxPullsPerTransaction — now per PAYMENT, not per guessed string.
-        const existingTxPulls = await lotteryEntryRepository.countByTransactionId(sourceId, sourceField, data.transactionId);
-        if (existingTxPulls >= lotteryConfig.maxPullsPerTransaction) {
-            throw new LotteryError("TX_ALREADY_USED", "This order has already been used for the maximum number of pulls.");
-        }
-        // Atomically: pick slot + create entry + mark slot booked
-        const db = getAdminDb();
-        const sourceCollectionName = data.sourceType === "event" ? "events" : "products";
-        const sourceDocRef = db.collection(sourceCollectionName).doc(sourceId);
-        const { assignedSlot, userLotteryNumber } = await db.runTransaction(async (tx) => {
-            // Re-read lotteryConfig inside transaction for freshness
-            const sourceSnap = await tx.get(sourceDocRef);
-            if (!sourceSnap.exists)
-                throw new LotteryError("LOTTERY_WINDOW_CLOSED", "Lottery source not found.");
-            const freshConfig = sourceSnap.data().lotteryConfig;
-            if (!freshConfig)
-                throw new LotteryError("LOTTERY_WINDOW_CLOSED", "Lottery config missing.");
-            const freshWeighted = assignSlotWeights(freshConfig);
-            const unclaimed = freshWeighted.filter((s) => !s.isBooked);
-            if (unclaimed.length === 0)
-                throw new LotteryError("LOTTERY_FULL", "All slots have been claimed.");
-            // Weighted pick
-            const chosen = pickWeightedSlot(unclaimed);
-            // Compute next userLotteryNumber (count + 1 inside tx via collection size)
-            const countSnap = await db
-                .collection(LOTTERY_ENTRIES_COLLECTION)
-                .where(sourceField, "==", sourceId)
-                .get();
-            const nextNumber = countSnap.size + 1;
-            // Mark slot booked in the source document
-            const updatedSlots = freshConfig.slots.map((s) => s.slotNumber === chosen.slotNumber
-                ? {
-                    ...s,
-                    isBooked: true,
-                    bookedByUserId: user.uid,
-                    bookedByDisplayName: user.displayName ?? user.name ?? undefined,
-                    bookedByUserLotteryNumber: nextNumber,
-                }
-                : s);
-            tx.update(sourceDocRef, {
-                "lotteryConfig.slots": updatedSlots,
-            });
-            return { assignedSlot: chosen, userLotteryNumber: nextNumber };
-        });
-        /*
-         * Create the entry document outside the transaction (acceptable — slot is
-         * already booked).
-         *
-         * Typed `LotteryEntryPlain`: this is PLAINTEXT from the session and the
-         * request body, and `createEntry` encrypts it. The document type now says
-         * `Encrypted<string>`, so annotating this `LotteryEntryDocument` is a
-         * compile error — correctly, because the values here are not ciphertext.
-         */
-        const entryData = {
-            sourceType: data.sourceType,
-            ...(data.sourceType === "event" ? { eventId: sourceId } : { productId: sourceId }),
-            userId: user.uid,
-            userDisplayName: user.displayName ?? user.name ?? undefined,
-            userEmail: user.email ?? undefined,
-            userPhone: data.userPhone,
-            transactionId: data.transactionId,
-            paymentTime: new Date(data.paymentTime),
-            purchasedItemNumber: data.purchasedItemNumber,
-            userLotteryNumber,
-            assignedPrizeSlotNumber: assignedSlot.slotNumber,
-            status: "drawn",
-            /*
-             * D52 — an EVENT pull carries no verifiable payment (events have no
-             * cart path), so it is flagged on creation rather than recorded as if it
-             * were paid. A product pull reached here only after its order was
-             * verified paid, caller-owned and covering this draw, so it is not
-             * flagged.
-             *
-             * This is what makes the unverified state visible to an admin before the
-             * draw instead of indistinguishable from a paid one.
-             */
-            isFlagged: paymentUnverified,
-            ...(paymentUnverified
-                ? {
-                    flagNote: "Payment reference not verified — event lotteries have no checkout path, so this reference was typed by the entrant. Confirm the payment before the draw.",
-                }
-                : {}),
-            submittedAt: new Date(),
-            drawnAt: new Date(),
-        };
-        await lotteryEntryRepository.createEntry(entryData);
-        return {
-            userLotteryNumber,
-            assignedPrizeSlotNumber: assignedSlot.slotNumber,
-            slotName: assignedSlot.name,
-        };
-    });
-}
-/**
- * Admin — flag a lottery entry as fraudulent.
- * Slot stays booked; use reopenLotterySlotAction to free it.
- */
-export async function flagLotteryEntryAction(input) {
-    return wrapAction(async () => {
-        await requireRoleUser(["admin", "moderator"]);
-        const parsed = flagLotteryEntrySchema.safeParse(input);
-        if (!parsed.success) {
-            throw new ValidationError(parsed.error.issues[0]?.message ?? "Invalid flag input");
-        }
-        return lotteryEntryRepository.flagEntry(parsed.data.entryId, parsed.data.flagNote, parsed.data.flaggedByUserId);
-    });
-}
-/**
- * Admin — reopen a slot from a flagged entry.
- * Clears isBooked on the slot so it can be claimed in a future pull.
- */
-export async function reopenLotterySlotAction(input) {
-    return wrapAction(async () => {
-        await requireRoleUser(["admin"]);
-        const parsed = reopenLotterySlotSchema.safeParse(input);
-        if (!parsed.success) {
-            throw new ValidationError(parsed.error.issues[0]?.message ?? "Invalid reopen input");
-        }
-        const { sourceType, sourceId, slotNumber } = parsed.data;
-        const db = getAdminDb();
-        const collectionName = sourceType === "event" ? "events" : "products";
-        const docRef = db.collection(collectionName).doc(sourceId);
-        await db.runTransaction(async (tx) => {
-            const snap = await tx.get(docRef);
-            if (!snap.exists)
-                throw new ValidationError("Source document not found.");
-            const config = snap.data().lotteryConfig;
-            if (!config?.slots)
-                throw new ValidationError("Lottery config not found.");
-            const updatedSlots = config.slots.map((s) => s.slotNumber === slotNumber
-                ? {
-                    ...s,
-                    isBooked: false,
-                    bookedByUserId: null,
-                    bookedByDisplayName: null,
-                    bookedByUserLotteryNumber: null,
-                }
-                : s);
-            tx.update(docRef, { "lotteryConfig.slots": updatedSlots });
-        });
-    });
-}
-/**
- * Admin — create a new lottery event.
- * Weights computed server-side; never returned to client.
- */
-export async function createLotteryEventAction(data) {
-    return wrapAction(async () => {
-        const user = await requireRoleUser(["admin", "moderator"]);
-        const rawData = data;
-        const lotteryConfig = rawData.lotteryConfig;
-        if (!lotteryConfig)
-            throw new ValidationError("lotteryConfig is required for lottery events.");
-        // Compute weights server-side
-        const withWeights = assignSlotWeights(lotteryConfig);
-        return eventRepository.createEvent({
-            ...rawData,
-            type: "lottery",
-            lotteryConfig: { ...lotteryConfig, slots: withWeights },
-            createdBy: user.uid,
-            status: rawData.status ?? "draft",
-            stats: { totalEntries: 0, approvedEntries: 0, flaggedEntries: 0 },
-        });
-    });
-}
-/**
- * Admin — update a lottery event.
- * Recomputes slot weights after update.
- */
-export async function updateLotteryEventAction(id, data) {
-    return wrapAction(async () => {
-        await requireRoleUser(["admin", "moderator"]);
-        const rawData = data;
-        const lotteryConfig = rawData.lotteryConfig;
-        if (lotteryConfig) {
-            const withWeights = assignSlotWeights(lotteryConfig);
-            return eventRepository.updateEvent(id, {
-                ...rawData,
-                lotteryConfig: { ...lotteryConfig, slots: withWeights },
-            });
-        }
-        return eventRepository.updateEvent(id, rawData);
-    });
-}
-/**
- * Store owner or Admin — switch a prize-draw product into lottery mode.
- * Store owners provide prizeSlotPrice but weight is NEVER returned to them.
- */
-export async function setProductLotteryModeAction(productId, lotteryConfig) {
-    return wrapAction(async () => {
-        await requireRoleUser(["admin", "moderator", "seller"]);
-        const withWeights = assignSlotWeights(lotteryConfig);
-        const db = getAdminDb();
-        await db.collection("products").doc(productId).update({
-            prizeDrawMode: "lottery",
-            lotteryConfig: { ...lotteryConfig, slots: withWeights },
-        });
-    });
-}

package/dist/_internal/server/features/lottery/adapters.d.ts

@@ -1,15 +0,0 @@
-/**
- * Lottery adapters — strips server-only fields (price, weight)
- * before any slot/config data leaves the server.
- */
-import type { LotteryConfig, LotterySlot, ClientLotteryConfig, ClientLotterySlot } from "../../../../features/lottery/types";
-/**
- * Strip price and weight from a single slot for client consumption.
- *
- * Takes the loose shape rather than `LotterySlot` so it can be applied to a
- * value already TYPED as projected but not actually projected — which is the
- * state `EventItem.lotteryConfig` is in when it comes off the repository.
- */
-export declare function toClientLotterySlot(slot: LotterySlot | ClientLotterySlot): ClientLotterySlot;
-/** Strip price/weight from the entire config for client consumption. */
-export declare function toClientLotteryConfig(config: LotteryConfig | ClientLotteryConfig): ClientLotteryConfig;

package/dist/_internal/server/features/lottery/adapters.js

@@ -1,31 +0,0 @@
-/**
- * Strip price and weight from a single slot for client consumption.
- *
- * Takes the loose shape rather than `LotterySlot` so it can be applied to a
- * value already TYPED as projected but not actually projected — which is the
- * state `EventItem.lotteryConfig` is in when it comes off the repository.
- */
-export function toClientLotterySlot(slot) {
-    // Allow-list, not a spread: every field named here is a deliberate public
-    // exposure with a known reader (§ Public Data Projections). `image` is read
-    // by the prize collage on the lottery detail page.
-    return {
-        slotNumber: slot.slotNumber,
-        name: slot.name,
-        image: slot.image,
-        isBooked: slot.isBooked,
-        bookedByUserLotteryNumber: slot.bookedByUserLotteryNumber,
-        bookedByDisplayName: slot.bookedByDisplayName,
-    };
-}
-/** Strip price/weight from the entire config for client consumption. */
-export function toClientLotteryConfig(config) {
-    return {
-        slots: config.slots.map(toClientLotterySlot),
-        totalSlots: config.totalSlots,
-        pricingMode: config.pricingMode,
-        drawWindowDurationMinutes: config.drawWindowDurationMinutes,
-        maxPullsPerTransaction: config.maxPullsPerTransaction,
-        maxPullsPerUser: config.maxPullsPerUser,
-    };
-}

package/dist/_internal/server/features/lottery/data.d.ts

@@ -1,19 +0,0 @@
-import type { SieveModel } from "../../../../providers/db-firebase";
-import type { EventDocument } from "../../../../features/events/schemas/firestore";
-import type { ClientLotteryConfig } from "../../../../features/lottery/types";
-/** Event shape with lottery config stripped of price/weight. */
-export type LotteryEventClient = Omit<EventDocument, "lotteryConfig"> & {
-    lotteryConfig?: ClientLotteryConfig;
-};
-/** Fetch a lottery-type event with price/weight stripped for client use. */
-export declare const getLotteryEventCached: (id: string) => Promise<LotteryEventClient | null>;
-/** List all lottery-type events with price/weight stripped. */
-export declare const listLotteryEvents: (opts?: {
-    status?: string;
-    page?: number;
-    pageSize?: number;
-}) => Promise<LotteryEventClient[]>;
-/** Fetch lottery entries for admin view (includes phone + txId via PII decrypt). */
-export declare function getLotteryEntriesForAdmin(sourceType: "event" | "product", sourceId: string, model: SieveModel): Promise<import("../../../..").FirebaseSieveResult<import("../../../..").LotteryEntryDocument>>;
-/** Fetch lottery entries for a specific user (own entries only). */
-export declare function getLotteryEntriesForUser(userId: string, model: SieveModel): Promise<import("../../../..").FirebaseSieveResult<import("../../../..").LotteryEntryDocument>>;

package/dist/_internal/server/features/lottery/data.js

@@ -1,41 +0,0 @@
-import { cache } from "react";
-import { eventRepository } from "../../../../repositories/index.js";
-import { lotteryEntryRepository } from "../../../../features/lottery/repository/lottery-entry.repository.js";
-import { toClientLotteryConfig } from "./adapters.js";
-/** Fetch a lottery-type event with price/weight stripped for client use. */
-export const getLotteryEventCached = cache(async (id) => {
-    const event = await eventRepository.findById(id);
-    if (!event || event.type !== "lottery")
-        return null;
-    return {
-        ...event,
-        lotteryConfig: event.lotteryConfig ? toClientLotteryConfig(event.lotteryConfig) : undefined,
-    };
-});
-/** List all lottery-type events with price/weight stripped. */
-export const listLotteryEvents = cache(async (opts) => {
-    // Build Sieve filter: type==lottery, optionally also status
-    let filters = "type==lottery";
-    if (opts?.status)
-        filters += `,status==${opts.status}`;
-    const result = await eventRepository.list({
-        filters,
-        sorts: "-startsAt",
-        page: opts?.page ?? 1,
-        pageSize: opts?.pageSize ?? 50,
-    });
-    const items = result.items ?? [];
-    return items.map((event) => ({
-        ...event,
-        lotteryConfig: event.lotteryConfig ? toClientLotteryConfig(event.lotteryConfig) : undefined,
-    }));
-});
-/** Fetch lottery entries for admin view (includes phone + txId via PII decrypt). */
-export async function getLotteryEntriesForAdmin(sourceType, sourceId, model) {
-    const field = sourceType === "event" ? "eventId" : "productId";
-    return lotteryEntryRepository.listForSource(sourceId, field, model);
-}
-/** Fetch lottery entries for a specific user (own entries only). */
-export async function getLotteryEntriesForUser(userId, model) {
-    return lotteryEntryRepository.listForUser(userId, model);
-}

package/dist/_internal/server/features/lottery/metadata.d.ts

@@ -1,6 +0,0 @@
-import type { Metadata } from "next";
-import type { LotteryEventClient } from "./data";
-export declare function buildLotteryMetadata(event: LotteryEventClient | null, opts?: {
-    siteName?: string;
-    baseUrl?: string;
-}): Metadata;

package/dist/_internal/server/features/lottery/metadata.js

@@ -1,31 +0,0 @@
-export function buildLotteryMetadata(event, opts) {
-    if (!event) {
-        return {
-            title: "Lottery Not Found",
-            description: "This lottery no longer exists.",
-        };
-    }
-    const siteName = opts?.siteName ?? "the platform";
-    const title = `${event.title} — ${siteName} Lottery`;
-    const description = typeof event.description === "string" && event.description.length > 0
-        ? event.description.slice(0, 155)
-        : `Enter the ${event.title} lottery on ${siteName}.`;
-    const coverUrl = event.coverImage && typeof event.coverImage.url === "string"
-        ? event.coverImage.url
-        : event.coverImageUrl;
-    return {
-        title,
-        description,
-        openGraph: {
-            title,
-            description,
-            ...(coverUrl ? { images: [{ url: coverUrl }] } : {}),
-        },
-        twitter: {
-            card: "summary_large_image",
-            title,
-            description,
-            ...(coverUrl ? { images: [coverUrl] } : {}),
-        },
-    };
-}

package/dist/_internal/server/features/lottery/og.d.ts

@@ -1,40 +0,0 @@
-/**
- * Lottery OG image renderer.
- *
- * ## Why this did not exist
- *
- * `lottery/[id]` was the single entry in `verify-og-coverage`'s
- * `OG_KNOWN_GAPS` — the one public dynamic detail page shipping without an
- * `opengraph-image.tsx`, carried as a baseline since 2026-05-23 with the note
- * "OG image follows in a follow-up". Metadata already resolved
- * (`buildLotteryMetadata`), so a shared link rendered a title and whatever the
- * event's cover image happened to be, with none of the branded card every
- * other listing type gets.
- *
- * ## 🛑 No money, and no per-slot prices
- *
- * An OG image is a public image URL with its contents burned into the pixels:
- * no sign-in gate reaches it and no paywall markup describes it, which is why
- * all eight money-bearing renderers were stripped (Root Cause #93). A lottery
- * is the sharpest case in the codebase — `toClientLotteryConfig` is an
- * allow-list that exists specifically to keep `price` and `weight` off every
- * slot — so this renderer takes the CLIENT shape and reads only what that
- * allow-list already permits: the slot count, and how many are still free.
- *
- * "6 of 200 slots left" is a fact about availability rather than a disclosed
- * amount, and it is the half of the card that earns the click — exactly the
- * line `renderPrizeDrawOg` draws for "Free entry".
- */
-import type { ReactElement } from "react";
-import type { LotteryEventClient } from "./data";
-export interface LotteryOgData {
-    title: string;
-    imageUrl?: string | null;
-    slotsLabel?: string | null;
-    statusLabel?: string | null;
-}
-export declare function renderLotteryOg(event: LotteryEventClient | null | undefined, opts: {
-    siteName: string;
-    baseUrl?: string;
-}): ReactElement;
-export declare function renderLotteryOgImage(data: LotteryOgData, siteName: string): ReactElement;

package/dist/_internal/server/features/lottery/og.js

@@ -1,79 +0,0 @@
-/**
- * Lottery OG image renderer.
- *
- * ## Why this did not exist
- *
- * `lottery/[id]` was the single entry in `verify-og-coverage`'s
- * `OG_KNOWN_GAPS` — the one public dynamic detail page shipping without an
- * `opengraph-image.tsx`, carried as a baseline since 2026-05-23 with the note
- * "OG image follows in a follow-up". Metadata already resolved
- * (`buildLotteryMetadata`), so a shared link rendered a title and whatever the
- * event's cover image happened to be, with none of the branded card every
- * other listing type gets.
- *
- * ## 🛑 No money, and no per-slot prices
- *
- * An OG image is a public image URL with its contents burned into the pixels:
- * no sign-in gate reaches it and no paywall markup describes it, which is why
- * all eight money-bearing renderers were stripped (Root Cause #93). A lottery
- * is the sharpest case in the codebase — `toClientLotteryConfig` is an
- * allow-list that exists specifically to keep `price` and `weight` off every
- * slot — so this renderer takes the CLIENT shape and reads only what that
- * allow-list already permits: the slot count, and how many are still free.
- *
- * "6 of 200 slots left" is a fact about availability rather than a disclosed
- * amount, and it is the half of the card that earns the click — exactly the
- * line `renderPrizeDrawOg` draws for "Free entry".
- */
-import { renderOgLayout } from "../seo/og-layout.js";
-import { resolveOgImageUrl } from "../seo/og.js";
-/**
- * The event's own status, as a human badge. `active` is deliberately absent:
- * a live lottery is the default case, so a chip saying so costs a badge slot
- * and tells the reader nothing they would not assume.
- */
-const STATUS_BADGE_TEXT = {
-    draft: "Not yet open",
-    paused: "Paused",
-    ended: "Closed",
-    cancelled: "Cancelled",
-};
-export function renderLotteryOg(event, opts) {
-    const cfg = event?.lotteryConfig;
-    const slots = cfg?.slots ?? [];
-    /*
-     * Counted from the slot array rather than read from `totalSlots`, which is
-     * the mirror the admin write path derives FROM `slots.length` — and a mirror
-     * is the field most likely to disagree (Root Cause #42). The array is here
-     * either way, so counting it costs nothing.
-     */
-    const total = slots.length;
-    const free = slots.filter((s) => !s.isBooked).length;
-    const slotsLabel = total > 0
-        ? free > 0
-            ? `${free.toLocaleString("en-IN")} of ${total.toLocaleString("en-IN")} slots left`
-            : `All ${total.toLocaleString("en-IN")} slots claimed`
-        : null;
-    const coverUrl = event?.coverImage && typeof event.coverImage.url === "string"
-        ? event.coverImage.url
-        : (event?.coverImageUrl ?? null);
-    return renderLotteryOgImage({
-        title: event?.title ?? "Lottery",
-        imageUrl: resolveOgImageUrl(coverUrl, opts.baseUrl),
-        slotsLabel,
-        statusLabel: event?.status ? (STATUS_BADGE_TEXT[event.status] ?? null) : null,
-    }, opts.siteName);
-}
-export function renderLotteryOgImage(data, siteName) {
-    const badges = [data.statusLabel].filter((s) => Boolean(s));
-    return renderOgLayout({
-        title: data.title,
-        subtitle: data.slotsLabel ?? undefined,
-        imageUrl: data.imageUrl,
-        siteName: `${siteName} · Lottery`,
-        badges: badges.length > 0 ? badges : undefined,
-        // Violet, distinct from the prize-draw amber beside it in the nav — the two
-        // are different products and a shared accent makes shared links ambiguous.
-        theme: { accentColor: "#8b5cf6" },
-    });
-}