@mohasinac/appkit 2.7.16 → 2.7.18

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

@@ -8,7 +8,7 @@ export async function placeBidAction(input) {
     const user = await requireRoleUser(["buyer", "seller", "admin"]);
     const parsed = placeBidSchema.safeParse(input);
     if (!parsed.success)
-        throw new ValidationError(parsed.error.errors[0]?.message ?? "Invalid bid input");
+        throw new ValidationError(parsed.error.issues[0]?.message ?? "Invalid bid input");
     const { auctionId, amount } = parsed.data;
     const product = await assertAuctionActive(auctionId);
     assertNotAuctionOwner(product, user.uid);

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

@@ -8,7 +8,7 @@ export async function createBlogPostAction(input) {
     const user = await requireRoleUser(["admin", "moderator"]);
     const parsed = blogPostInputSchema.safeParse(input);
     if (!parsed.success)
-        throw new ValidationError(parsed.error.errors[0]?.message ?? "Invalid blog post input");
+        throw new ValidationError(parsed.error.issues[0]?.message ?? "Invalid blog post input");
     await assertBlogSlugUnique(parsed.data.slug);
     const readTime = computeReadTime(parsed.data.content);
     return blogRepository.createWithId(parsed.data.slug, {
@@ -25,7 +25,7 @@ export async function updateBlogPostAction(postId, input) {
     const post = await assertBlogPostExists(postId);
     const parsed = blogPostUpdateSchema.safeParse(input);
     if (!parsed.success)
-        throw new ValidationError(parsed.error.errors[0]?.message ?? "Invalid blog post input");
+        throw new ValidationError(parsed.error.issues[0]?.message ?? "Invalid blog post input");
     const updates = { ...parsed.data };
     if (parsed.data.content)
         updates.readTimeMinutes = computeReadTime(parsed.data.content);

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

@@ -40,7 +40,7 @@ export async function createBrandAction(input) {
     await requireRoleUser("admin");
     const parsed = brandInputSchema.safeParse(input);
     if (!parsed.success)
-        throw new ValidationError(parsed.error.errors[0]?.message ?? "Invalid brand input");
+        throw new ValidationError(parsed.error.issues[0]?.message ?? "Invalid brand input");
     await assertBrandSlugUnique(parsed.data.slug);
     const fields = brandInputToCategoryFields(parsed.data);
     return categoriesRepository.createWithId(parsed.data.slug, {
@@ -84,7 +84,7 @@ export async function updateBrandAction(brandId, input) {
     await assertBrandExists(brandId);
     const parsed = brandUpdateSchema.safeParse(input);
     if (!parsed.success)
-        throw new ValidationError(parsed.error.errors[0]?.message ?? "Invalid brand input");
+        throw new ValidationError(parsed.error.issues[0]?.message ?? "Invalid brand input");
     return categoriesRepository.update(brandId, brandInputToCategoryFields(parsed.data));
 }
 export async function deleteBrandAction(brandId) {

package/dist/_internal/server/features/bundles/actions.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Bundle server actions — appkit internal.
+ *
+ * `addBundleToCartAction` is the shared business logic called by the
+ * consumer's `"use server"` wrapper. The consumer is responsible for:
+ *   1. Resolving the authenticated userId (throw AuthError when unauthenticated
+ *      so BundleBuyNowCta's isAuthError guard shows the login modal).
+ *   2. Calling redirect(ROUTES.PUBLIC.CHECKOUT) after this returns.
+ *
+ * Bundles are categoryType:"bundle" rows — they bypass the regular
+ * addItemToCart capability gate and write directly to cartRepository with
+ * bundleCategorySlug + bundleProductIds so checkout's bundle-expansion
+ * helpers can fan out stock decrements to member products.
+ */
+export declare function addBundleToCartAction(userId: string, bundleSlug: string): Promise<void>;

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

@@ -0,0 +1,48 @@
+/**
+ * Bundle server actions — appkit internal.
+ *
+ * `addBundleToCartAction` is the shared business logic called by the
+ * consumer's `"use server"` wrapper. The consumer is responsible for:
+ *   1. Resolving the authenticated userId (throw AuthError when unauthenticated
+ *      so BundleBuyNowCta's isAuthError guard shows the login modal).
+ *   2. Calling redirect(ROUTES.PUBLIC.CHECKOUT) after this returns.
+ *
+ * Bundles are categoryType:"bundle" rows — they bypass the regular
+ * addItemToCart capability gate and write directly to cartRepository with
+ * bundleCategorySlug + bundleProductIds so checkout's bundle-expansion
+ * helpers can fan out stock decrements to member products.
+ */
+import { NotFoundError, ValidationError } from "../../../../errors";
+import { categoriesRepository } from "../../../../repositories";
+import { cartRepository } from "../../../../features/cart/repository/cart.repository";
+import { getDefaultCurrency } from "../../../../core/baseline-resolver";
+export async function addBundleToCartAction(userId, bundleSlug) {
+    if (!userId)
+        throw new ValidationError("User id is required");
+    if (!bundleSlug)
+        throw new ValidationError("Bundle slug is required");
+    const bundle = await categoriesRepository.findBySlugAndType(bundleSlug, "bundle");
+    if (!bundle)
+        throw new NotFoundError("Bundle not found");
+    if (!bundle.isActive)
+        throw new ValidationError("Bundle is not available");
+    if (bundle.bundleStockStatus === "out_of_stock") {
+        throw new ValidationError("Bundle is currently out of stock");
+    }
+    if (!bundle.bundlePriceInPaise || bundle.bundlePriceInPaise < 1) {
+        throw new ValidationError("Bundle price is not configured");
+    }
+    await cartRepository.addItem(userId, {
+        productId: bundle.id,
+        productTitle: bundle.name,
+        productImage: bundle.display?.coverImage ?? "",
+        price: bundle.bundlePriceInPaise,
+        currency: getDefaultCurrency(),
+        quantity: 1,
+        storeId: bundle.createdByStoreId ?? "",
+        storeName: bundle.createdByStoreName ?? "",
+        listingType: "standard",
+        bundleCategorySlug: bundle.slug,
+        bundleProductIds: bundle.bundleProductIds ?? [],
+    });
+}

package/dist/_internal/server/features/bundles/index.d.ts

@@ -1,3 +1,4 @@
 export { getBundleForDetail, listBundleMembers, listFeaturedBundles, type BundleDataOptions, } from "./data";
 export { buildBundleMetadata, type BundleMetadataOptions } from "./metadata";
 export { renderBundleOg, renderBundleOgImage, type BundleOgData, } from "./og";
+export { addBundleToCartAction } from "./actions";

package/dist/_internal/server/features/bundles/index.js

@@ -2,3 +2,4 @@ export { getBundleForDetail, listBundleMembers, listFeaturedBundles, } from "./d
 export { buildBundleMetadata } from "./metadata";
 // S-SBUNI-4 2026-05-13 — bundle OG renderer.
 export { renderBundleOg, renderBundleOgImage, } from "./og";
+export { addBundleToCartAction } from "./actions";

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

@@ -8,7 +8,7 @@ export async function addToCartAction(input) {
     const user = await requireRoleUser(["buyer", "seller", "admin"]);
     const parsed = addToCartSchema.safeParse(input);
     if (!parsed.success)
-        throw new ValidationError(parsed.error.errors[0]?.message ?? "Invalid cart input");
+        throw new ValidationError(parsed.error.issues[0]?.message ?? "Invalid cart input");
     await upsertCartItem(user.uid, parsed.data);
     return { success: true };
 }
@@ -16,7 +16,7 @@ export async function removeFromCartAction(input) {
     const user = await requireRoleUser(["buyer", "seller", "admin"]);
     const parsed = removeFromCartSchema.safeParse(input);
     if (!parsed.success)
-        throw new ValidationError(parsed.error.errors[0]?.message ?? "Invalid input");
+        throw new ValidationError(parsed.error.issues[0]?.message ?? "Invalid input");
     await cartRepository.removeItem(user.uid, parsed.data.productId);
     return { success: true };
 }
@@ -29,7 +29,7 @@ export async function mergeGuestCartAction(input) {
     const user = await requireRoleUser(["buyer", "seller", "admin"]);
     const parsed = mergeGuestCartSchema.safeParse(input);
     if (!parsed.success)
-        throw new ValidationError(parsed.error.errors[0]?.message ?? "Invalid cart data");
+        throw new ValidationError(parsed.error.issues[0]?.message ?? "Invalid cart data");
     await mergeGuestItems(user.uid, parsed.data.guestItems);
     return { success: true };
 }

package/dist/_internal/server/features/checkout/actions.d.ts

@@ -16,6 +16,10 @@ export interface CreateCheckoutOrderInput {
     paymentMethod: CheckoutPaymentMethod;
     notes?: string;
     excludedProductIds?: string[];
+    /** When true this is an admin test order — OTP consent is pre-granted and the order is created paid/processing. */
+    adminBypass?: boolean;
+    /** UID of the admin who triggered the bypass. Set when adminBypass is true. */
+    adminBypassBy?: string;
 }
 /**
  * Place order(s) from the user's cart in a single Firestore transaction.

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

@@ -76,7 +76,7 @@ function emitOrderPlacedNotifications(args) {
  * auth + rate-limiting before calling this and supply the resolved user fields.
  */
 export async function createCheckoutOrderAction(input) {
-    const { userId: uid, userName, userEmail, addressId, paymentMethod, notes, excludedProductIds = [], } = input;
+    const { userId: uid, userName, userEmail, addressId, paymentMethod, notes, excludedProductIds = [], adminBypass = false, adminBypassBy, } = input;
     const siteSettings = await siteSettingsRepository.getSingleton();
     const commissions = siteSettings?.commissions ?? CHECKOUT_DEFAULT_COMMISSIONS;
     const cart = await unitOfWork.carts.getOrCreate(uid);
@@ -147,7 +147,7 @@ export async function createCheckoutOrderAction(input) {
                 const reason = !otpData ? "otp_not_verified" : "consent_expired";
                 throw Object.assign(new ApiError(403, "Order verification required. Please complete OTP verification before placing this order."), { _failReason: reason });
             }
-            const emailOtpUsed = otpData.verifiedVia !== "sms";
+            const emailOtpUsed = otpData.verifiedVia !== "sms" && otpData.verifiedVia !== "admin_bypass";
             // SB-UNI-5 2026-05-13 — bundle-aware stock fan-out. Build the unique
             // product-id set across the whole cart (regular items + each bundle's
             // members) and fetch each one ONCE. Validation walks per cart-line and
@@ -249,6 +249,11 @@ export async function createCheckoutOrderAction(input) {
     }
     const appliedCoupons = cart.appliedCoupons ?? [];
     const orderGroups = splitCartIntoOrderGroups(available);
+    // Admin-bypass orders are immediately paid and processing; generate a shared
+    // transaction reference for all orders in this checkout batch.
+    const adminBatchId = adminBypass
+        ? `ADMIN-${Date.now().toString(36).toUpperCase()}-${Math.random().toString(36).slice(2, 6).toUpperCase()}`
+        : undefined;
     const orderIds = [];
     let total = 0;
     const emailsToSend = [];
@@ -389,14 +394,16 @@ export async function createCheckoutOrderAction(input) {
             items: orderItems,
             orderType,
             offerId: firstItem.offerId ?? undefined,
-            status: OrderStatusValues.PENDING,
-            paymentStatus: PaymentStatusValues.PENDING,
-            paymentMethod,
+            status: adminBypass ? OrderStatusValues.PROCESSING : OrderStatusValues.PENDING,
+            paymentStatus: adminBypass ? PaymentStatusValues.PAID : PaymentStatusValues.PENDING,
+            paymentMethod: adminBypass ? PaymentMethodValues.ADMIN_BYPASS : paymentMethod,
+            paymentId: adminBatchId,
+            adminBypassBy: adminBypassBy,
             shippingAddress,
             notes,
             shippingFee: shippingFee > 0 ? shippingFee : undefined,
-            depositAmount,
-            codRemainingAmount,
+            depositAmount: adminBypass ? undefined : depositAmount,
+            codRemainingAmount: adminBypass ? undefined : codRemainingAmount,
             couponCode: appliedDiscounts[0]?.code,
             couponDiscount: couponDiscount > 0 ? couponDiscount : undefined,
             appliedDiscounts: appliedDiscounts.length > 0 ? appliedDiscounts : undefined,
@@ -429,7 +436,7 @@ export async function createCheckoutOrderAction(input) {
             buyerName: userName,
             storeOwnerId,
             productLabel: orderItems.length > 1 ? `${orderItems.length} items` : firstItem.productTitle,
-            paid: false,
+            paid: adminBypass,
         });
     }
     if (couponUsageAccumulator.size > 0) {
@@ -487,7 +494,8 @@ export async function attachPaymentAction(input) {
 export async function verifyAndPlaceRazorpayOrderAction(input) {
     const { userId: uid, userName, userEmail, razorpay_order_id, razorpay_payment_id, razorpay_signature, addressId, notes, } = input;
     const siteSettings = await siteSettingsRepository.getSingleton();
-    const razorpayFeePercent = siteSettings?.commissions?.razorpayFeePercent ?? 5;
+    const platformFeePercent = siteSettings?.commissions?.platformFeePercent ?? 5;
+    const gstPercent = siteSettings?.commissions?.gstPercent ?? 18;
     const commissions = siteSettings?.commissions ?? CHECKOUT_DEFAULT_COMMISSIONS;
     const isValid = await verifyPaymentSignatureWithKeys({
         razorpay_order_id,
@@ -596,8 +604,9 @@ export async function verifyAndPlaceRazorpayOrderAction(input) {
             const unit = isBundle ? item.price : product.price;
             return sum + unit * item.quantity;
         }, 0);
-        const expectedPlatformFee = Math.round(cartSubtotalRs * (razorpayFeePercent / 100) * 100) / 100;
-        const expectedPaymentAmountRs = cartSubtotalRs + expectedPlatformFee;
+        const expectedPlatformFee = Math.round(cartSubtotalRs * (platformFeePercent / 100) * 100) / 100;
+        const expectedGstOnFee = Math.round(expectedPlatformFee * (gstPercent / 100) * 100) / 100;
+        const expectedPaymentAmountRs = cartSubtotalRs + expectedPlatformFee + expectedGstOnFee;
         const rzpOrderRecord = await fetchRazorpayOrder(razorpay_order_id);
         const paidAmountRs = paiseToRupees(rzpOrderRecord.amount);
         if (paidAmountRs < expectedPaymentAmountRs - 1) {
@@ -684,7 +693,9 @@ export async function verifyAndPlaceRazorpayOrderAction(input) {
             }
         }
         couponDiscount = Math.min(couponDiscount, groupTotal);
-        const platformFee = Math.round(groupTotal * (razorpayFeePercent / 100) * 100) / 100;
+        const rawPlatformFee = Math.round(groupTotal * (platformFeePercent / 100) * 100) / 100;
+        const gstOnFee = Math.round(rawPlatformFee * (gstPercent / 100) * 100) / 100;
+        const platformFee = rawPlatformFee + gstOnFee;
         const orderTotal = Math.max(0, groupTotal - couponDiscount) + shippingFee;
         total += orderTotal;
         // S-SBUNI-RULES 2026-05-13 — order-item decoration via rule registry.

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

@@ -9,7 +9,7 @@ export async function createEventAction(input) {
     const user = await requireRoleUser(["admin", "moderator"]);
     const parsed = eventInputSchema.safeParse(input);
     if (!parsed.success)
-        throw new ValidationError(parsed.error.errors[0]?.message ?? "Invalid event input");
+        throw new ValidationError(parsed.error.issues[0]?.message ?? "Invalid event input");
     return eventRepository.createEvent({
         ...parsed.data,
         createdBy: user.uid,
@@ -24,14 +24,14 @@ export async function updateEventAction(eventId, input) {
         throw new EventNotFoundError(eventId);
     const parsed = eventUpdateSchema.safeParse(input);
     if (!parsed.success)
-        throw new ValidationError(parsed.error.errors[0]?.message ?? "Invalid event input");
+        throw new ValidationError(parsed.error.issues[0]?.message ?? "Invalid event input");
     return eventRepository.updateEvent(eventId, parsed.data);
 }
 export async function registerForEventAction(input) {
     const user = await requireRoleUser(["buyer", "seller", "admin"]);
     const parsed = registerForEventSchema.safeParse(input);
     if (!parsed.success)
-        throw new ValidationError(parsed.error.errors[0]?.message ?? "Invalid registration input");
+        throw new ValidationError(parsed.error.issues[0]?.message ?? "Invalid registration input");
     const { eventId } = parsed.data;
     await assertEventActive(eventId);
     // Check if already registered

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

@@ -9,7 +9,7 @@ export async function createOrderAction(input) {
     const user = await requireRoleUser(["buyer", "seller", "admin"]);
     const parsed = createOrderSchema.safeParse(input);
     if (!parsed.success)
-        throw new ValidationError(parsed.error.errors[0]?.message ?? "Invalid order input");
+        throw new ValidationError(parsed.error.issues[0]?.message ?? "Invalid order input");
     return orderRepository.create({
         ...parsed.data,
         userId: user.uid,
@@ -20,7 +20,7 @@ export async function cancelOrderAction(input) {
     const user = await requireRoleUser(["buyer", "seller", "admin"]);
     const parsed = cancelOrderSchema.safeParse(input);
     if (!parsed.success)
-        throw new ValidationError(parsed.error.errors[0]?.message ?? "Invalid input");
+        throw new ValidationError(parsed.error.issues[0]?.message ?? "Invalid input");
     await assertOrderCancellable(parsed.data.orderId, user.uid);
     return orderRepository.cancelOrder(parsed.data.orderId, parsed.data.reason ?? "Cancelled by user");
 }
@@ -28,7 +28,7 @@ export async function requestReturnAction(input) {
     const user = await requireRoleUser(["buyer", "seller", "admin"]);
     const parsed = cancelOrderSchema.safeParse(input);
     if (!parsed.success)
-        throw new ValidationError(parsed.error.errors[0]?.message ?? "Invalid input");
+        throw new ValidationError(parsed.error.issues[0]?.message ?? "Invalid input");
     await assertReturnWindowOpen(parsed.data.orderId, user.uid);
     return orderRepository.updateStatus(parsed.data.orderId, "return_requested");
 }
@@ -36,7 +36,7 @@ export async function updateOrderStatusAction(input) {
     const user = await requireRoleUser(["seller", "admin"]);
     const parsed = updateOrderStatusSchema.safeParse(input);
     if (!parsed.success)
-        throw new ValidationError(parsed.error.errors[0]?.message ?? "Invalid input");
+        throw new ValidationError(parsed.error.issues[0]?.message ?? "Invalid input");
     const order = await orderRepository.findById(parsed.data.orderId).catch(() => null);
     if (!order)
         throw new OrderNotFoundError(parsed.data.orderId);

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

@@ -1,11 +1,13 @@
 export interface ResolvedPaymentFee {
     baseAmount: number;
     platformFee: number;
+    gstOnFee: number;
     totalAmount: number;
 }
 /**
- * Returns the cart total inflated by the configured Razorpay processing fee.
- * The percent comes from siteSettings.commissions.razorpayFeePercent and
- * falls back to the default if unset.
+ * Inflates the cart total by our platform fee + GST on that fee.
+ * platformFeePercent = siteSettings.commissions.platformFeePercent (our cut %).
+ * gstPercent = siteSettings.commissions.gstPercent (18% GST on our fee, not on full order).
+ * minimumTransactionFee = per-gateway-transaction floor in rupees.
  */
 export declare function resolvePaymentFee(baseAmount: number): Promise<ResolvedPaymentFee>;

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

@@ -1,14 +1,19 @@
 import { siteSettingsRepository } from "../../../../repositories";
-import { PAYMENTS_DEFAULT_RAZORPAY_FEE_PERCENT } from "../../../shared/features/payments/config";
+import { PAYMENTS_DEFAULT_PLATFORM_FEE_PERCENT, PAYMENTS_DEFAULT_GST_PERCENT, } from "../../../shared/features/payments/config";
 /**
- * Returns the cart total inflated by the configured Razorpay processing fee.
- * The percent comes from siteSettings.commissions.razorpayFeePercent and
- * falls back to the default if unset.
+ * Inflates the cart total by our platform fee + GST on that fee.
+ * platformFeePercent = siteSettings.commissions.platformFeePercent (our cut %).
+ * gstPercent = siteSettings.commissions.gstPercent (18% GST on our fee, not on full order).
+ * minimumTransactionFee = per-gateway-transaction floor in rupees.
  */
 export async function resolvePaymentFee(baseAmount) {
     const siteSettings = await siteSettingsRepository.getSingleton();
-    const razorpayFeePercent = siteSettings?.commissions?.razorpayFeePercent ?? PAYMENTS_DEFAULT_RAZORPAY_FEE_PERCENT;
-    const platformFee = Math.round(baseAmount * (razorpayFeePercent / 100) * 100) / 100;
-    const totalAmount = baseAmount + platformFee;
-    return { baseAmount, platformFee, totalAmount };
+    const platformFeePercent = siteSettings?.commissions?.platformFeePercent ?? PAYMENTS_DEFAULT_PLATFORM_FEE_PERCENT;
+    const gstPercent = siteSettings?.commissions?.gstPercent ?? PAYMENTS_DEFAULT_GST_PERCENT;
+    const minimumTransactionFee = Math.max(0, siteSettings?.commissions?.minimumTransactionFee ?? 0);
+    const platformFee = Math.round(baseAmount * (platformFeePercent / 100) * 100) / 100;
+    const gstOnFee = Math.round(platformFee * (gstPercent / 100) * 100) / 100;
+    const rawTotal = baseAmount + platformFee + gstOnFee;
+    const totalAmount = Math.max(rawTotal, baseAmount + minimumTransactionFee);
+    return { baseAmount, platformFee, gstOnFee, totalAmount };
 }

package/dist/_internal/server/features/payments/index.d.ts

@@ -1,3 +1,3 @@
 export { createPaymentIntentAction, verifyPaymentSignatureAction, type CreatePaymentIntentInput, type CreatePaymentIntentResult, type VerifyPaymentSignatureInput, } from "./actions";
 export { resolvePaymentFee, type ResolvedPaymentFee } from "./data";
-export { PAYMENTS_DEFAULT_RAZORPAY_FEE_PERCENT, PAYMENTS_RECEIPT_PREFIX, } from "../../../shared/features/payments/config";
+export { PAYMENTS_DEFAULT_PLATFORM_FEE_PERCENT, PAYMENTS_DEFAULT_GST_PERCENT, PAYMENTS_RECEIPT_PREFIX, } from "../../../shared/features/payments/config";

package/dist/_internal/server/features/payments/index.js

@@ -1,3 +1,3 @@
 export { createPaymentIntentAction, verifyPaymentSignatureAction, } from "./actions";
 export { resolvePaymentFee } from "./data";
-export { PAYMENTS_DEFAULT_RAZORPAY_FEE_PERCENT, PAYMENTS_RECEIPT_PREFIX, } from "../../../shared/features/payments/config";
+export { PAYMENTS_DEFAULT_PLATFORM_FEE_PERCENT, PAYMENTS_DEFAULT_GST_PERCENT, PAYMENTS_RECEIPT_PREFIX, } from "../../../shared/features/payments/config";

package/dist/_internal/server/features/pre-orders/actions.js

@@ -8,7 +8,7 @@ export async function reservePreOrderAction(input) {
     const user = await requireRoleUser(["buyer", "seller", "admin"]);
     const parsed = reservePreOrderSchema.safeParse(input);
     if (!parsed.success)
-        throw new ValidationError(parsed.error.errors[0]?.message ?? "Invalid reservation input");
+        throw new ValidationError(parsed.error.issues[0]?.message ?? "Invalid reservation input");
     const { preOrderId, quantity } = parsed.data;
     const product = await assertPreOrderAvailable(preOrderId, quantity);
     const deposit = computeDeposit(product);

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

@@ -8,7 +8,7 @@ export async function createProductAction(input) {
     const user = await requireRoleUser(["seller", "admin"]);
     const parsed = productInputSchema.safeParse(input);
     if (!parsed.success)
-        throw new ValidationError(parsed.error.errors[0]?.message ?? "Invalid input");
+        throw new ValidationError(parsed.error.issues[0]?.message ?? "Invalid input");
     return productRepository.create({
         ...parsed.data,
         storeId: user.uid,
@@ -21,7 +21,7 @@ export async function createAuctionAction(input) {
     const user = await requireRoleUser(["seller", "admin"]);
     const parsed = auctionInputSchema.safeParse(input);
     if (!parsed.success)
-        throw new ValidationError(parsed.error.errors[0]?.message ?? "Invalid input");
+        throw new ValidationError(parsed.error.issues[0]?.message ?? "Invalid input");
     return productRepository.create({
         ...parsed.data,
         storeId: user.uid,
@@ -34,7 +34,7 @@ export async function createPreOrderAction(input) {
     const user = await requireRoleUser(["seller", "admin"]);
     const parsed = preOrderInputSchema.safeParse(input);
     if (!parsed.success)
-        throw new ValidationError(parsed.error.errors[0]?.message ?? "Invalid input");
+        throw new ValidationError(parsed.error.issues[0]?.message ?? "Invalid input");
     return productRepository.create({
         ...parsed.data,
         storeId: user.uid,
@@ -48,7 +48,7 @@ export async function updateProductAction(productId, input) {
     await assertProductOwnership(productId, user.uid);
     const parsed = productUpdateSchema.safeParse(input);
     if (!parsed.success)
-        throw new ValidationError(parsed.error.errors[0]?.message ?? "Invalid input");
+        throw new ValidationError(parsed.error.issues[0]?.message ?? "Invalid input");
     return productRepository.update(productId, parsed.data);
 }
 export async function deleteProductAction(productId) {
@@ -60,7 +60,7 @@ export async function setProductStatusAction(input) {
     const user = await requireRoleUser(["seller", "admin"]);
     const parsed = setStatusSchema.safeParse(input);
     if (!parsed.success)
-        throw new ValidationError(parsed.error.errors[0]?.message ?? "Invalid input");
+        throw new ValidationError(parsed.error.issues[0]?.message ?? "Invalid input");
     const product = await assertProductOwnership(parsed.data.productId, user.uid);
     assertStatusTransition(product.status, parsed.data.status);
     return productRepository.update(parsed.data.productId, { status: parsed.data.status });
@@ -69,6 +69,6 @@ export async function setProductFeaturedAction(input) {
     await requireRoleUser("admin");
     const parsed = setFeaturedSchema.safeParse(input);
     if (!parsed.success)
-        throw new ValidationError(parsed.error.errors[0]?.message ?? "Invalid input");
+        throw new ValidationError(parsed.error.issues[0]?.message ?? "Invalid input");
     return productRepository.update(parsed.data.productId, { featured: parsed.data.featured });
 }

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

@@ -9,7 +9,7 @@ export async function applyCouponAction(input) {
     const user = await requireRoleUser(["buyer", "seller", "admin"]);
     const parsed = applyCouponSchema.safeParse(input);
     if (!parsed.success)
-        throw new ValidationError(parsed.error.errors[0]?.message ?? "Invalid coupon input");
+        throw new ValidationError(parsed.error.issues[0]?.message ?? "Invalid coupon input");
     const coupon = await validateCoupon(parsed.data, user.uid);
     const discount = computeDiscount(coupon, parsed.data.cartTotal);
     await couponsRepository.applyCoupon(coupon.id, coupon.code, user.uid, [], discount);
@@ -19,7 +19,7 @@ export async function createCouponAction(input) {
     const user = await requireRoleUser(["admin", "seller"]);
     const parsed = createCouponSchema.safeParse(input);
     if (!parsed.success)
-        throw new ValidationError(parsed.error.errors[0]?.message ?? "Invalid coupon input");
+        throw new ValidationError(parsed.error.issues[0]?.message ?? "Invalid coupon input");
     return couponsRepository.createWithId(`coupon-${parsed.data.code.toLowerCase()}`, { ...parsed.data, createdBy: user.uid, usage: { ...parsed.data.usage, currentUsage: 0 } });
 }
 export async function updateCouponAction(couponId, input) {
@@ -29,7 +29,7 @@ export async function updateCouponAction(couponId, input) {
         throw new CouponNotFoundError(couponId);
     const parsed = updateCouponSchema.safeParse(input);
     if (!parsed.success)
-        throw new ValidationError(parsed.error.errors[0]?.message ?? "Invalid coupon input");
+        throw new ValidationError(parsed.error.issues[0]?.message ?? "Invalid coupon input");
     return couponsRepository.update(couponId, parsed.data);
 }
 export async function deactivateCouponAction(couponId) {

package/dist/_internal/shared/features/categories/bundle-config.d.ts

@@ -15,3 +15,27 @@ export declare const BUNDLE_MAX_PER_USER_DEFAULT: 3;
 export declare const BUNDLES_PAGE_SIZE: 24;
 /** Cap on homepage featured-bundles strip. */
 export declare const BUNDLES_FEATURED_LIMIT: 12;
+/**
+ * Listing types that may be added to a bundle.
+ *   - standard — regular product
+ *   - pre-order — pre-order product
+ *   - prize-draw — added as N draws/entries (see BundleItemDetail.drawCount)
+ *
+ * Auctions and bundles themselves are never eligible.
+ */
+export declare const BUNDLE_ELIGIBLE_LISTING_TYPES: readonly ["standard", "pre-order", "prize-draw"];
+export type BundleEligibleListingType = (typeof BUNDLE_ELIGIBLE_LISTING_TYPES)[number];
+/**
+ * "special" — explicitly curated admin bundle. Only special bundles write
+ * reverse `partOfBundleIds` pointers on member products and are displayed in
+ * the "Bundled" badge on product cards / detail pages.
+ *
+ * "brand" — auto-generated collection driven by a dynamic brand query rule.
+ * Does NOT update `partOfBundleIds` on products; treated as a discovery
+ * surface, not a priced product grouping.
+ */
+export declare const BUNDLE_KIND_SPECIAL: "special";
+export declare const BUNDLE_KIND_BRAND: "brand";
+export type BundleKind = typeof BUNDLE_KIND_SPECIAL | typeof BUNDLE_KIND_BRAND;
+/** Max draw entries a prize-draw item contributes when added to a bundle. */
+export declare const BUNDLE_DRAW_COUNT_MAX: 500;

package/dist/_internal/shared/features/categories/bundle-config.js

@@ -15,3 +15,31 @@ export const BUNDLE_MAX_PER_USER_DEFAULT = 3;
 export const BUNDLES_PAGE_SIZE = 24;
 /** Cap on homepage featured-bundles strip. */
 export const BUNDLES_FEATURED_LIMIT = 12;
+// ── Bundle eligibility ───────────────────────────────────────────────────────
+/**
+ * Listing types that may be added to a bundle.
+ *   - standard — regular product
+ *   - pre-order — pre-order product
+ *   - prize-draw — added as N draws/entries (see BundleItemDetail.drawCount)
+ *
+ * Auctions and bundles themselves are never eligible.
+ */
+export const BUNDLE_ELIGIBLE_LISTING_TYPES = [
+    "standard",
+    "pre-order",
+    "prize-draw",
+];
+// ── Bundle kinds ─────────────────────────────────────────────────────────────
+/**
+ * "special" — explicitly curated admin bundle. Only special bundles write
+ * reverse `partOfBundleIds` pointers on member products and are displayed in
+ * the "Bundled" badge on product cards / detail pages.
+ *
+ * "brand" — auto-generated collection driven by a dynamic brand query rule.
+ * Does NOT update `partOfBundleIds` on products; treated as a discovery
+ * surface, not a priced product grouping.
+ */
+export const BUNDLE_KIND_SPECIAL = "special";
+export const BUNDLE_KIND_BRAND = "brand";
+/** Max draw entries a prize-draw item contributes when added to a bundle. */
+export const BUNDLE_DRAW_COUNT_MAX = 500;

package/dist/_internal/shared/features/categories/bundle-copy.d.ts

@@ -86,6 +86,13 @@ export declare const BUNDLE_COPY: {
         readonly ruleTypeLabel: "Bundle members source";
         readonly ruleTypeStatic: "Hand-picked products";
         readonly ruleTypeDynamic: "Dynamic query (auto-resolves)";
+        readonly bundleKindLabel: "Bundle kind";
+        readonly bundleKindHint: "Special bundles show the 'Bundled' badge on product cards and update member product metadata. Brand bundles are discovery collections only.";
+        readonly bundleKindSpecial: "Special bundle";
+        readonly bundleKindBrand: "Brand collection";
+        readonly drawCountLabel: "Draw entries included";
+        readonly drawCountHint: "How many raffle entries the buyer receives for this prize-draw when purchasing the bundle.";
+        readonly drawCountPlaceholder: "e.g. 5";
         readonly dynamic: {
             readonly title: "Dynamic query rule";
             readonly hint: "onProductStockChange resolves bundleProductIds; bundleQueryResolvedAt tracks the last refresh.";

package/dist/_internal/shared/features/categories/bundle-copy.js

@@ -96,6 +96,15 @@ export const BUNDLE_COPY = {
         ruleTypeLabel: "Bundle members source",
         ruleTypeStatic: "Hand-picked products",
         ruleTypeDynamic: "Dynamic query (auto-resolves)",
+        // Bundle kind
+        bundleKindLabel: "Bundle kind",
+        bundleKindHint: "Special bundles show the 'Bundled' badge on product cards and update member product metadata. Brand bundles are discovery collections only.",
+        bundleKindSpecial: "Special bundle",
+        bundleKindBrand: "Brand collection",
+        // Prize-draw draw count
+        drawCountLabel: "Draw entries included",
+        drawCountHint: "How many raffle entries the buyer receives for this prize-draw when purchasing the bundle.",
+        drawCountPlaceholder: "e.g. 5",
         dynamic: {
             title: "Dynamic query rule",
             hint: "onProductStockChange resolves bundleProductIds; bundleQueryResolvedAt tracks the last refresh.",