@mohasinac/appkit 3.0.4 → 3.1.0

package/dist/_internal/server/jobs/core/__tests__/triggerEventRaffle.test.js

@@ -0,0 +1,252 @@
+import { describe, it, expect, vi } from "vitest";
+// No repository mocks needed — function uses ctx.db directly.
+import { runTriggerEventRaffle } from "../triggerEventRaffle";
+// ── Helpers ─────────────────────────────────────────────────────────────────
+function makeCtx(dbOverrides = {}) {
+    return {
+        db: buildMockDb(dbOverrides),
+        now: new Date("2026-01-01T00:00:00Z"),
+        env: vi.fn().mockReturnValue(""),
+        logger: { info: vi.fn(), warn: vi.fn(), error: vi.fn() },
+    };
+}
+/**
+ * Builds a mock Firestore db that:
+ *  - eventSnap: resolved by the 'events' collection path
+ *  - entriesSnap: resolved by the 'eventEntries' collection path
+ */
+function buildMockDb(overrides = {}) {
+    const { eventExists = true, eventData = {}, entriesDocs = [], updateFn = vi.fn().mockResolvedValue(undefined), } = overrides;
+    const mockUpdate = updateFn;
+    // Chain for event: db.collection("events").doc(id).get()
+    const eventSnap = { exists: eventExists, data: () => eventData };
+    const eventDocRef = { get: vi.fn().mockResolvedValue(eventSnap), update: mockUpdate };
+    const eventsCollection = { doc: vi.fn().mockReturnValue(eventDocRef) };
+    // Chain for entries: db.collection("eventEntries").where(...).where(...).get()
+    const entriesSnap = {
+        docs: entriesDocs,
+        size: entriesDocs.length,
+    };
+    const entriesQuery = {
+        where: vi.fn().mockReturnThis(),
+        get: vi.fn().mockResolvedValue(entriesSnap),
+    };
+    const entriesCollection = { where: vi.fn().mockReturnValue(entriesQuery) };
+    const db = {
+        collection: vi.fn((name) => {
+            if (name === "events")
+                return eventsCollection;
+            if (name === "eventEntries")
+                return entriesCollection;
+            return eventsCollection;
+        }),
+        mockUpdate, // expose for assertions
+    };
+    return db;
+}
+function makeEntry(overrides = {}) {
+    const { id = "entry-1", userId = "user-ravi", displayName = "Ravi Kumar", points = 0, createdAt = new Date() } = overrides;
+    return {
+        id,
+        data: () => ({ userId, userDisplayName: displayName, points, createdAt }),
+    };
+}
+const INPUT_BASE = { eventId: "event-summer-raffle" };
+// ── Tests ────────────────────────────────────────────────────────────────────
+describe("runTriggerEventRaffle — event not found", () => {
+    it("returns reason=event_not_found when event does not exist", async () => {
+        const ctx = makeCtx({ eventExists: false });
+        const result = await runTriggerEventRaffle(INPUT_BASE, ctx);
+        expect(result.reason).toBe("event_not_found");
+        expect(result.raffleEntryCount).toBe(0);
+    });
+    it("does NOT update eventRef when event not found", async () => {
+        const ctx = makeCtx({ eventExists: false });
+        await runTriggerEventRaffle(INPUT_BASE, ctx);
+        expect(ctx.db.mockUpdate).not.toHaveBeenCalled();
+    });
+});
+describe("runTriggerEventRaffle — already triggered (idempotency)", () => {
+    it("returns alreadyTriggered=true when winner already set", async () => {
+        const ctx = makeCtx({ eventData: { raffleWinnerUserId: "user-already-won" } });
+        const result = await runTriggerEventRaffle(INPUT_BASE, ctx);
+        expect(result.alreadyTriggered).toBe(true);
+        expect(result.raffleWinnerUserId).toBe("user-already-won");
+    });
+    it("does NOT query entries or update event when already triggered", async () => {
+        const ctx = makeCtx({ eventData: { raffleWinnerUserId: "user-already-won" } });
+        await runTriggerEventRaffle(INPUT_BASE, ctx);
+        expect(ctx.db.mockUpdate).not.toHaveBeenCalled();
+    });
+});
+describe("runTriggerEventRaffle — no eligible entries", () => {
+    it("returns reason=no_eligible_entries when no CONFIRMED entries exist", async () => {
+        const ctx = makeCtx({ entriesDocs: [] });
+        const result = await runTriggerEventRaffle(INPUT_BASE, ctx);
+        expect(result.reason).toBe("no_eligible_entries");
+        expect(result.raffleEntryCount).toBe(0);
+    });
+    it("does NOT update event when no entries", async () => {
+        const ctx = makeCtx({ entriesDocs: [] });
+        await runTriggerEventRaffle(INPUT_BASE, ctx);
+        expect(ctx.db.mockUpdate).not.toHaveBeenCalled();
+    });
+});
+describe("runTriggerEventRaffle — open_raffle (default)", () => {
+    it("all confirmed entries are in the pool", async () => {
+        const entries = [
+            makeEntry({ id: "e1", userId: "user-1" }),
+            makeEntry({ id: "e2", userId: "user-2" }),
+            makeEntry({ id: "e3", userId: "user-3" }),
+        ];
+        const ctx = makeCtx({ eventData: { raffleType: "open_raffle" }, entriesDocs: entries });
+        const result = await runTriggerEventRaffle(INPUT_BASE, ctx);
+        expect(["user-1", "user-2", "user-3"]).toContain(result.raffleWinnerUserId);
+    });
+    it("winner fields written back to event doc", async () => {
+        const updateFn = vi.fn().mockResolvedValue(undefined);
+        const entries = [makeEntry({ id: "e1", userId: "user-ravi", displayName: "Ravi" })];
+        const ctx = makeCtx({ entriesDocs: entries, updateFn });
+        await runTriggerEventRaffle(INPUT_BASE, ctx);
+        expect(updateFn).toHaveBeenCalledWith(expect.objectContaining({
+            raffleWinnerUserId: "user-ravi",
+            raffleWinnerDisplayName: "Ravi",
+            raffleWinnerEntryId: "e1",
+            raffleEntryCount: 1,
+        }));
+    });
+    it("raffleTriggeredAt = ctx.now", async () => {
+        const updateFn = vi.fn().mockResolvedValue(undefined);
+        const now = new Date("2026-03-15T10:00:00Z");
+        const entries = [makeEntry({ id: "e1" })];
+        const ctx = makeCtx({ entriesDocs: entries, updateFn });
+        ctx.now = now;
+        await runTriggerEventRaffle(INPUT_BASE, ctx);
+        expect(updateFn).toHaveBeenCalledWith(expect.objectContaining({ raffleTriggeredAt: now }));
+    });
+    it("raffleEntryCount = total entries (not pool size)", async () => {
+        const updateFn = vi.fn().mockResolvedValue(undefined);
+        const entries = [
+            makeEntry({ id: "e1", userId: "user-1" }),
+            makeEntry({ id: "e2", userId: "user-2" }),
+        ];
+        const ctx = makeCtx({ entriesDocs: entries, updateFn });
+        await runTriggerEventRaffle({ ...INPUT_BASE, raffleType: "open_raffle" }, ctx);
+        expect(updateFn).toHaveBeenCalledWith(expect.objectContaining({ raffleEntryCount: 2 }));
+    });
+    it("returns correct winner in result object", async () => {
+        const entries = [makeEntry({ id: "e1", userId: "user-only", displayName: "Only User" })];
+        const ctx = makeCtx({ entriesDocs: entries });
+        const result = await runTriggerEventRaffle(INPUT_BASE, ctx);
+        expect(result.raffleWinnerUserId).toBe("user-only");
+        expect(result.raffleWinnerDisplayName).toBe("Only User");
+        expect(result.raffleEntryCount).toBe(1);
+    });
+});
+describe("runTriggerEventRaffle — top_n_scorers", () => {
+    it("pool limited to top N by points descending", async () => {
+        const entries = [
+            makeEntry({ id: "e1", userId: "user-low", points: 10 }),
+            makeEntry({ id: "e2", userId: "user-high", points: 100 }),
+            makeEntry({ id: "e3", userId: "user-mid", points: 50 }),
+        ];
+        const ctx = makeCtx({ entriesDocs: entries });
+        // topN=1 means only the highest scorer can win
+        const result = await runTriggerEventRaffle({ ...INPUT_BASE, raffleType: "top_n_scorers", topN: 1 }, ctx);
+        expect(result.raffleWinnerUserId).toBe("user-high");
+    });
+    it("topN=2: winner is either top-1 or top-2 scorer, NOT bottom scorer", async () => {
+        const entries = [
+            makeEntry({ id: "e1", userId: "user-bottom", points: 1 }),
+            makeEntry({ id: "e2", userId: "user-top", points: 100 }),
+            makeEntry({ id: "e3", userId: "user-second", points: 50 }),
+        ];
+        const ctx = makeCtx({ entriesDocs: entries });
+        const result = await runTriggerEventRaffle({ ...INPUT_BASE, raffleType: "top_n_scorers", topN: 2 }, ctx);
+        expect(["user-top", "user-second"]).toContain(result.raffleWinnerUserId);
+        expect(result.raffleWinnerUserId).not.toBe("user-bottom");
+    });
+    it("topN=0 → entire pool used (topN disabled)", async () => {
+        const entries = [
+            makeEntry({ id: "e1", userId: "user-1", points: 10 }),
+            makeEntry({ id: "e2", userId: "user-2", points: 20 }),
+        ];
+        const ctx = makeCtx({ entriesDocs: entries });
+        const result = await runTriggerEventRaffle({ ...INPUT_BASE, raffleType: "top_n_scorers", topN: 0 }, ctx);
+        expect(["user-1", "user-2"]).toContain(result.raffleWinnerUserId);
+    });
+    it("reads raffleTopN from event when topN not in input", async () => {
+        const entries = [
+            makeEntry({ id: "e1", userId: "user-low", points: 5 }),
+            makeEntry({ id: "e2", userId: "user-high", points: 999 }),
+        ];
+        const ctx = makeCtx({
+            eventData: { raffleType: "top_n_scorers", raffleTopN: 1 },
+            entriesDocs: entries,
+        });
+        const result = await runTriggerEventRaffle(INPUT_BASE, ctx);
+        expect(result.raffleWinnerUserId).toBe("user-high");
+    });
+});
+describe("runTriggerEventRaffle — top_n_participants", () => {
+    it("pool limited to first N by createdAt ascending", async () => {
+        const t1 = new Date("2026-01-01");
+        const t2 = new Date("2026-01-02");
+        const t3 = new Date("2026-01-03");
+        const entries = [
+            makeEntry({ id: "e3", userId: "user-last", createdAt: t3 }),
+            makeEntry({ id: "e1", userId: "user-first", createdAt: t1 }),
+            makeEntry({ id: "e2", userId: "user-second", createdAt: t2 }),
+        ];
+        const ctx = makeCtx({ entriesDocs: entries });
+        // topN=1 means only the earliest registrant wins
+        const result = await runTriggerEventRaffle({ ...INPUT_BASE, raffleType: "top_n_participants", topN: 1 }, ctx);
+        expect(result.raffleWinnerUserId).toBe("user-first");
+    });
+    it("handles Firestore Timestamp-like createdAt objects (via toDate)", async () => {
+        const entries = [
+            makeEntry({
+                id: "e1",
+                userId: "user-a",
+                createdAt: { toDate: () => new Date("2026-01-01") },
+            }),
+            makeEntry({
+                id: "e2",
+                userId: "user-b",
+                createdAt: { toDate: () => new Date("2026-01-02") },
+            }),
+        ];
+        const ctx = makeCtx({ entriesDocs: entries });
+        const result = await runTriggerEventRaffle({ ...INPUT_BASE, raffleType: "top_n_participants", topN: 1 }, ctx);
+        expect(result.raffleWinnerUserId).toBe("user-a");
+    });
+});
+describe("runTriggerEventRaffle — input override precedence", () => {
+    it("input.raffleType overrides event.raffleType", async () => {
+        const entries = [
+            makeEntry({ id: "e1", userId: "user-low", points: 1 }),
+            makeEntry({ id: "e2", userId: "user-high", points: 999 }),
+        ];
+        // Event says open_raffle, but input says top_n_scorers topN=1
+        const ctx = makeCtx({
+            eventData: { raffleType: "open_raffle" },
+            entriesDocs: entries,
+        });
+        const result = await runTriggerEventRaffle({ ...INPUT_BASE, raffleType: "top_n_scorers", topN: 1 }, ctx);
+        expect(result.raffleWinnerUserId).toBe("user-high");
+    });
+    it("input.topN overrides event.raffleTopN", async () => {
+        const entries = [
+            makeEntry({ id: "e1", userId: "user-low", points: 5 }),
+            makeEntry({ id: "e2", userId: "user-high", points: 100 }),
+            makeEntry({ id: "e3", userId: "user-mid", points: 50 }),
+        ];
+        // Event says topN=3 (all), but input says topN=1 (only highest)
+        const ctx = makeCtx({
+            eventData: { raffleType: "top_n_scorers", raffleTopN: 3 },
+            entriesDocs: entries,
+        });
+        const result = await runTriggerEventRaffle({ ...INPUT_BASE, raffleType: "top_n_scorers", topN: 1 }, ctx);
+        expect(result.raffleWinnerUserId).toBe("user-high");
+    });
+});

package/dist/_internal/server/jobs/core/__tests__/wrapJobHandler.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/_internal/server/jobs/core/__tests__/wrapJobHandler.test.js

@@ -0,0 +1,129 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+const { mockRecord, mockMapToHttpError } = vi.hoisted(() => ({
+    mockRecord: vi.fn().mockResolvedValue(undefined),
+    mockMapToHttpError: vi.fn().mockReturnValue({ code: 500, message: "Internal error" }),
+}));
+vi.mock("../../../../../features/server-errors/repository/server-errors.repository", () => ({
+    serverErrorsRepository: vi.fn(() => ({ record: mockRecord })),
+}));
+vi.mock("../../../../../errors/error-mapping", () => ({
+    mapToHttpError: mockMapToHttpError,
+}));
+import { wrapScheduleHandler, wrapTriggerHandler, wrapCallableHandler, wrapJobHandler, } from "../wrapJobHandler";
+function makeCtx() {
+    return {
+        db: {},
+        now: new Date("2026-01-01"),
+        logger: { info: vi.fn(), warn: vi.fn(), error: vi.fn() },
+    };
+}
+beforeEach(() => {
+    vi.clearAllMocks();
+    mockRecord.mockResolvedValue(undefined);
+    mockMapToHttpError.mockReturnValue({ code: 500, message: "Internal error" });
+});
+// ── wrapScheduleHandler ──────────────────────────────────────────────────────
+describe("wrapScheduleHandler", () => {
+    it("returns handler result when handler succeeds", async () => {
+        const handler = vi.fn().mockResolvedValue(undefined);
+        const wrapped = wrapScheduleHandler("my-job", handler);
+        await expect(wrapped(makeCtx())).resolves.toBeUndefined();
+    });
+    it("persists error to serverErrors when handler throws", async () => {
+        const handler = vi.fn().mockRejectedValue(new Error("job failed"));
+        const wrapped = wrapScheduleHandler("my-job", handler);
+        try {
+            await wrapped(makeCtx());
+        }
+        catch { /* expected */ }
+        expect(mockRecord).toHaveBeenCalledWith(expect.objectContaining({ source: "function", route: "my-job" }));
+    });
+    it("re-throws the original error after persisting", async () => {
+        const err = new Error("job failed");
+        const handler = vi.fn().mockRejectedValue(err);
+        const wrapped = wrapScheduleHandler("my-job", handler);
+        await expect(wrapped(makeCtx())).rejects.toThrow("job failed");
+    });
+    it("persist failure does NOT prevent re-throw", async () => {
+        const err = new Error("job failed");
+        mockRecord.mockRejectedValue(new Error("DB write failed"));
+        const handler = vi.fn().mockRejectedValue(err);
+        const wrapped = wrapScheduleHandler("my-job", handler);
+        await expect(wrapped(makeCtx())).rejects.toThrow("job failed");
+    });
+    it("calls mapToHttpError to normalise the error", async () => {
+        const err = new Error("Something broke");
+        const handler = vi.fn().mockRejectedValue(err);
+        const wrapped = wrapScheduleHandler("my-job", handler);
+        try {
+            await wrapped(makeCtx());
+        }
+        catch { /* expected */ }
+        expect(mockMapToHttpError).toHaveBeenCalledWith(err);
+    });
+    it("requestId includes handler name", async () => {
+        const handler = vi.fn().mockRejectedValue(new Error("oops"));
+        const wrapped = wrapScheduleHandler("audit-run", handler);
+        try {
+            await wrapped(makeCtx());
+        }
+        catch { /* expected */ }
+        const call = mockRecord.mock.calls[0][0];
+        expect(call.requestId).toMatch(/audit-run/);
+    });
+});
+// ── wrapTriggerHandler ───────────────────────────────────────────────────────
+describe("wrapTriggerHandler", () => {
+    const mockEvent = { path: "test/doc1", params: {}, before: null, after: {} };
+    it("returns handler result when handler succeeds", async () => {
+        const handler = vi.fn().mockResolvedValue(undefined);
+        const wrapped = wrapTriggerHandler("trigger-fn", handler);
+        await expect(wrapped(mockEvent, makeCtx())).resolves.toBeUndefined();
+    });
+    it("persists error and re-throws when handler throws", async () => {
+        const err = new Error("trigger failed");
+        const handler = vi.fn().mockRejectedValue(err);
+        const wrapped = wrapTriggerHandler("trigger-fn", handler);
+        await expect(wrapped(mockEvent, makeCtx())).rejects.toThrow("trigger failed");
+        expect(mockRecord).toHaveBeenCalled();
+    });
+});
+// ── wrapCallableHandler ──────────────────────────────────────────────────────
+describe("wrapCallableHandler", () => {
+    it("returns handler result when handler succeeds", async () => {
+        const handler = vi.fn().mockResolvedValue({ result: "ok" });
+        const wrapped = wrapCallableHandler("callable-fn", handler);
+        await expect(wrapped({}, makeCtx())).resolves.toEqual({ result: "ok" });
+    });
+    it("persists error and re-throws when handler throws", async () => {
+        const handler = vi.fn().mockRejectedValue(new Error("callable failed"));
+        const wrapped = wrapCallableHandler("callable-fn", handler);
+        await expect(wrapped({}, makeCtx())).rejects.toThrow("callable failed");
+        expect(mockRecord).toHaveBeenCalled();
+    });
+});
+// ── wrapJobHandler ───────────────────────────────────────────────────────────
+describe("wrapJobHandler", () => {
+    it("returns handler result for a generic handler", async () => {
+        const handler = vi.fn().mockResolvedValue(42);
+        const wrapped = wrapJobHandler("generic-fn", handler);
+        await expect(wrapped()).resolves.toBe(42);
+    });
+    it("persists error with handler name and re-throws", async () => {
+        const handler = vi.fn().mockRejectedValue(new Error("generic failed"));
+        const wrapped = wrapJobHandler("generic-fn", handler);
+        await expect(wrapped()).rejects.toThrow("generic failed");
+        expect(mockRecord).toHaveBeenCalledWith(expect.objectContaining({ route: "generic-fn", source: "function" }));
+    });
+    it("extracts JobContext from last arg if it has .now", async () => {
+        const now = new Date("2026-06-15T12:00:00Z");
+        const handler = vi.fn().mockRejectedValue(new Error("err"));
+        const wrapped = wrapJobHandler("fn-with-ctx", handler);
+        try {
+            await wrapped({ now });
+        }
+        catch { /* expected */ }
+        const call = mockRecord.mock.calls[0][0];
+        expect(call.occurredAt).toBe(now.getTime());
+    });
+});

package/dist/_internal/shared/actions/action-registry.d.ts

@@ -28,7 +28,7 @@ import type { CategoryType } from "../../../features/categories/types/index";
 /** What KIND of action — drives default UI affordance (link vs button vs danger). */
 export type ActionKind = "primary" | "secondary" | "danger" | "ghost" | "link" | "chip";
 /** Resource bucket — keyed top-level in the ACTIONS tree. */
-export type ActionResource = "PRODUCT" | "AUCTION" | "PRE_ORDER" | "PRIZE_DRAW" | "CLASSIFIED" | "DIGITAL_CODE" | "LIVE" | "BUNDLE" | "GROUP" | "CATEGORY" | "BRAND" | "SUBLISTING" | "STORE" | "BLOG" | "EVENT" | "USER" | "SELLER" | "ADMIN" | "CART" | "CHECKOUT" | "NAV" | "MEDIA" | "SUPPORT";
+export type ActionResource = "PRODUCT" | "AUCTION" | "PRE_ORDER" | "PRIZE_DRAW" | "CLASSIFIED" | "DIGITAL_CODE" | "LIVE" | "BUNDLE" | "GROUP" | "CATEGORY" | "BRAND" | "SUBLISTING" | "STORE" | "BLOG" | "EVENT" | "USER" | "SELLER" | "ADMIN" | "CART" | "CHECKOUT" | "NAV" | "MEDIA" | "SUPPORT" | "LOTTERY";
 /** Confirmation modal config — when set, <Button action={...}> opens
  *  a confirm dialog before firing the actual handler. */
 export interface ActionConfirmation {

package/dist/_internal/shared/actions/action-registry.js

@@ -1732,6 +1732,52 @@ export const ACTIONS = {
             },
         },
     },
+    LOTTERY: {
+        "pull": {
+            id: "lottery.pull",
+            label: "Submit Entry",
+            description: "Submit a lottery pull entry — slot assigned immediately.",
+            kind: "primary",
+        },
+        "flag-entry": {
+            id: "lottery.flag-entry",
+            label: "Flag as Scammer",
+            description: "Flag a lottery entry as fraudulent.",
+            kind: "danger",
+            permissions: ["admin", "moderator"],
+            confirmation: {
+                title: "Flag this entry?",
+                body: "Entry will be marked fraudulent. Their claimed slot stays booked until you manually reopen it.",
+                confirmLabel: "Flag entry",
+                confirmKind: "danger",
+            },
+        },
+        "reopen-slot": {
+            id: "lottery.reopen-slot",
+            label: "Reopen Slot",
+            description: "Free a flagged entry's slot so it can be claimed again.",
+            kind: "secondary",
+            permissions: ["admin"],
+            confirmation: {
+                title: "Reopen this slot?",
+                body: "The slot will be available for new pulls. The flagged entry's slot assignment is removed.",
+                confirmLabel: "Reopen",
+            },
+        },
+        "cancel": {
+            id: "lottery.cancel",
+            label: "Cancel Lottery",
+            description: "Close the draw window and reject pending pulls.",
+            kind: "danger",
+            permissions: ["admin", "moderator"],
+            confirmation: {
+                title: "Cancel lottery?",
+                body: "Draw window closes immediately. Pending pulls rejected.",
+                confirmLabel: "Cancel",
+                confirmKind: "danger",
+            },
+        },
+    },
 };
 /** Sugar — `act("PRODUCT", "add-to-cart")` reads more naturally at call sites. */
 export function act(resource, id) {

package/dist/_internal/shared/features/cart/schema.d.ts

@@ -8,14 +8,14 @@ export declare const addToCartSchema: z.ZodObject<{
     storeId: z.ZodString;
     storeName: z.ZodDefault<z.ZodString>;
     quantity: z.ZodDefault<z.ZodNumber>;
-    listingType: z.ZodEnum<["standard", "auction", "pre-order", "prize-draw"]>;
+    listingType: z.ZodEnum<["standard", "auction", "pre-order", "prize-draw", "classified", "digital-code", "live"]>;
     isOffer: z.ZodOptional<z.ZodBoolean>;
     offerId: z.ZodOptional<z.ZodString>;
     lockedPrice: z.ZodOptional<z.ZodNumber>;
 }, "strip", z.ZodTypeAny, {
     currency: string;
     storeId: string;
-    listingType: "standard" | "auction" | "pre-order" | "prize-draw";
+    listingType: "standard" | "auction" | "pre-order" | "prize-draw" | "classified" | "digital-code" | "live";
     price: number;
     storeName: string;
     productId: string;
@@ -27,7 +27,7 @@ export declare const addToCartSchema: z.ZodObject<{
     isOffer?: boolean | undefined;
 }, {
     storeId: string;
-    listingType: "standard" | "auction" | "pre-order" | "prize-draw";
+    listingType: "standard" | "auction" | "pre-order" | "prize-draw" | "classified" | "digital-code" | "live";
     price: number;
     productId: string;
     productTitle: string;
@@ -66,14 +66,14 @@ export declare const mergeGuestCartSchema: z.ZodObject<{
         storeId: z.ZodString;
         storeName: z.ZodDefault<z.ZodString>;
         quantity: z.ZodDefault<z.ZodNumber>;
-        listingType: z.ZodEnum<["standard", "auction", "pre-order", "prize-draw"]>;
+        listingType: z.ZodEnum<["standard", "auction", "pre-order", "prize-draw", "classified", "digital-code", "live"]>;
         isOffer: z.ZodOptional<z.ZodBoolean>;
         offerId: z.ZodOptional<z.ZodString>;
         lockedPrice: z.ZodOptional<z.ZodNumber>;
     }, "strip", z.ZodTypeAny, {
         currency: string;
         storeId: string;
-        listingType: "standard" | "auction" | "pre-order" | "prize-draw";
+        listingType: "standard" | "auction" | "pre-order" | "prize-draw" | "classified" | "digital-code" | "live";
         price: number;
         storeName: string;
         productId: string;
@@ -85,7 +85,7 @@ export declare const mergeGuestCartSchema: z.ZodObject<{
         isOffer?: boolean | undefined;
     }, {
         storeId: string;
-        listingType: "standard" | "auction" | "pre-order" | "prize-draw";
+        listingType: "standard" | "auction" | "pre-order" | "prize-draw" | "classified" | "digital-code" | "live";
         price: number;
         productId: string;
         productTitle: string;
@@ -101,7 +101,7 @@ export declare const mergeGuestCartSchema: z.ZodObject<{
     guestItems: {
         currency: string;
         storeId: string;
-        listingType: "standard" | "auction" | "pre-order" | "prize-draw";
+        listingType: "standard" | "auction" | "pre-order" | "prize-draw" | "classified" | "digital-code" | "live";
         price: number;
         storeName: string;
         productId: string;
@@ -115,7 +115,7 @@ export declare const mergeGuestCartSchema: z.ZodObject<{
 }, {
     guestItems: {
         storeId: string;
-        listingType: "standard" | "auction" | "pre-order" | "prize-draw";
+        listingType: "standard" | "auction" | "pre-order" | "prize-draw" | "classified" | "digital-code" | "live";
         price: number;
         productId: string;
         productTitle: string;

package/dist/_internal/shared/features/cart/schema.js

@@ -15,6 +15,9 @@ const cartItemBaseSchema = z.object({
         "auction",
         "pre-order",
         "prize-draw",
+        "classified",
+        "digital-code",
+        "live",
     ]),
     isOffer: z.boolean().optional(),
     offerId: z.string().optional(),

package/dist/_internal/shared/features/products/schema.d.ts

@@ -41,7 +41,7 @@ export declare const productInputSchema: z.ZodObject<{
     features?: string[] | undefined;
     shippingInfo?: string | undefined;
     returnPolicy?: string | undefined;
-    condition?: "new" | "used" | "refurbished" | "broken" | "like_new" | "good" | "fair" | "poor" | undefined;
+    condition?: "new" | "used" | "refurbished" | "like_new" | "good" | "fair" | "poor" | "broken" | undefined;
     insurance?: boolean | undefined;
     insuranceCost?: number | undefined;
     shippingPaidBy?: "seller" | "buyer" | undefined;
@@ -65,7 +65,7 @@ export declare const productInputSchema: z.ZodObject<{
     features?: string[] | undefined;
     shippingInfo?: string | undefined;
     returnPolicy?: string | undefined;
-    condition?: "new" | "used" | "refurbished" | "broken" | "like_new" | "good" | "fair" | "poor" | undefined;
+    condition?: "new" | "used" | "refurbished" | "like_new" | "good" | "fair" | "poor" | "broken" | undefined;
     insurance?: boolean | undefined;
     insuranceCost?: number | undefined;
     shippingPaidBy?: "seller" | "buyer" | undefined;
@@ -114,7 +114,7 @@ export declare const productUpdateSchema: z.ZodObject<{
     features?: string[] | undefined;
     shippingInfo?: string | undefined;
     returnPolicy?: string | undefined;
-    condition?: "new" | "used" | "refurbished" | "broken" | "like_new" | "good" | "fair" | "poor" | undefined;
+    condition?: "new" | "used" | "refurbished" | "like_new" | "good" | "fair" | "poor" | "broken" | undefined;
     insurance?: boolean | undefined;
     insuranceCost?: number | undefined;
     shippingPaidBy?: "seller" | "buyer" | undefined;
@@ -138,7 +138,7 @@ export declare const productUpdateSchema: z.ZodObject<{
     features?: string[] | undefined;
     shippingInfo?: string | undefined;
     returnPolicy?: string | undefined;
-    condition?: "new" | "used" | "refurbished" | "broken" | "like_new" | "good" | "fair" | "poor" | undefined;
+    condition?: "new" | "used" | "refurbished" | "like_new" | "good" | "fair" | "poor" | "broken" | undefined;
     insurance?: boolean | undefined;
     insuranceCost?: number | undefined;
     shippingPaidBy?: "seller" | "buyer" | undefined;
@@ -201,7 +201,7 @@ export declare const auctionInputSchema: z.ZodObject<{
     features?: string[] | undefined;
     shippingInfo?: string | undefined;
     returnPolicy?: string | undefined;
-    condition?: "new" | "used" | "refurbished" | "broken" | "like_new" | "good" | "fair" | "poor" | undefined;
+    condition?: "new" | "used" | "refurbished" | "like_new" | "good" | "fair" | "poor" | "broken" | undefined;
     insurance?: boolean | undefined;
     insuranceCost?: number | undefined;
     shippingPaidBy?: "seller" | "buyer" | undefined;
@@ -233,7 +233,7 @@ export declare const auctionInputSchema: z.ZodObject<{
     features?: string[] | undefined;
     shippingInfo?: string | undefined;
     returnPolicy?: string | undefined;
-    condition?: "new" | "used" | "refurbished" | "broken" | "like_new" | "good" | "fair" | "poor" | undefined;
+    condition?: "new" | "used" | "refurbished" | "like_new" | "good" | "fair" | "poor" | "broken" | undefined;
     insurance?: boolean | undefined;
     insuranceCost?: number | undefined;
     shippingPaidBy?: "seller" | "buyer" | undefined;
@@ -299,7 +299,7 @@ export declare const preOrderInputSchema: z.ZodObject<{
     features?: string[] | undefined;
     shippingInfo?: string | undefined;
     returnPolicy?: string | undefined;
-    condition?: "new" | "used" | "refurbished" | "broken" | "like_new" | "good" | "fair" | "poor" | undefined;
+    condition?: "new" | "used" | "refurbished" | "like_new" | "good" | "fair" | "poor" | "broken" | undefined;
     insurance?: boolean | undefined;
     insuranceCost?: number | undefined;
     shippingPaidBy?: "seller" | "buyer" | undefined;
@@ -327,7 +327,7 @@ export declare const preOrderInputSchema: z.ZodObject<{
     features?: string[] | undefined;
     shippingInfo?: string | undefined;
     returnPolicy?: string | undefined;
-    condition?: "new" | "used" | "refurbished" | "broken" | "like_new" | "good" | "fair" | "poor" | undefined;
+    condition?: "new" | "used" | "refurbished" | "like_new" | "good" | "fair" | "poor" | "broken" | undefined;
     insurance?: boolean | undefined;
     insuranceCost?: number | undefined;
     shippingPaidBy?: "seller" | "buyer" | undefined;

package/dist/_internal/shared/listing-types/_registry.js

@@ -28,6 +28,8 @@ export const LISTING_TYPE_REGISTRY = {
     "digital-code": digitalCode.config,
     live: live.config,
 };
+// Returns undefined for "bundle" — bundles are CategoryDocument, not in this registry.
+// Callers must null-check: `pluginFor(lt) ?? fallbackBehavior`.
 export function pluginFor(type) {
     return LISTING_TYPE_REGISTRY[type];
 }

package/dist/_internal/shared/listing-types/auction/schema.d.ts

@@ -1 +1,3 @@
-export {};
+import type { ProductDocument } from "../../../../features/products/schemas/firestore";
+export declare function isAuctionProduct(doc: ProductDocument): boolean;
+export declare function isActiveAuction(doc: ProductDocument): boolean;

package/dist/_internal/shared/listing-types/auction/schema.js

@@ -1 +1,7 @@
-export {};
+export function isAuctionProduct(doc) {
+    return doc.listingType === "auction" && doc.auctionEndDate != null;
+}
+// True when the auction end date is in the future — gates the Bid button.
+export function isActiveAuction(doc) {
+    return isAuctionProduct(doc) && doc.auctionEndDate > new Date();
+}

package/dist/_internal/shared/listing-types/classified/schema.d.ts

@@ -1 +1,2 @@
-export {};
+import type { ProductDocument } from "../../../../features/products/schemas/firestore";
+export declare function isClassifiedProduct(doc: ProductDocument): boolean;

package/dist/_internal/shared/listing-types/classified/schema.js

@@ -1 +1,3 @@
-export {};
+export function isClassifiedProduct(doc) {
+    return doc.listingType === "classified";
+}

package/dist/_internal/shared/listing-types/digital-code/schema.d.ts

@@ -1 +1,3 @@
-export {};
+import type { ProductDocument } from "../../../../features/products/schemas/firestore";
+export declare function isDigitalCodeProduct(doc: ProductDocument): boolean;
+export declare function hasCodesAvailable(doc: ProductDocument): boolean;