@mohasinac/appkit 4.60.1 → 4.61.0

package/dist/features/promotions/schemas/index.js

@@ -18,9 +18,32 @@ export const discountConfigSchema = z.object({
     maxDiscount: rupeesSchema.optional(),
     minPurchase: rupeesSchema.optional(),
 });
+/*
+ * 🛑 THIS IS THE ONLY bxgy VALIDATOR. The four admin write paths — the POST
+ * and PATCH routes, both server actions, and `createCouponSchema` below — all
+ * import it rather than restating the shape.
+ *
+ * That is not tidiness. Until 2026-10-22 none of those four declared `bxgy` at
+ * all, and every one of them is a `z.object()`, which STRIPS unknown keys. So
+ * `AdminCouponEditorView` built a correct `bxgy` payload, the route answered
+ * 200, and the field was never written — an admin could create a BOGO coupon
+ * that discounted nothing, which is the exact silent-strip trap the `tiers`
+ * comment in the POST route already describes, recurring one field over.
+ *
+ * `maxItemPrice` is deliberately `.optional()` with no default: absent means
+ * "no ceiling", which is what every BOGO coupon written before it existed
+ * means. A default would retroactively shrink them.
+ */
 export const bxgyConfigSchema = z.object({
     buyQuantity: z.number().int().positive(),
     getQuantity: z.number().int().positive(),
+    // `.refine` rather than `.positive()` — `rupeesSchema` is a ZodEffects (it
+    // carries the 2-decimal check), and ZodNumber's numeric helpers are not on
+    // it. A zero ceiling would disqualify every unit, so it is rejected here as
+    // well as being treated as absent by `calculateBxgyDiscount`.
+    maxItemPrice: rupeesSchema
+        .refine((n) => n > 0, { message: "Price ceiling must be greater than zero" })
+        .optional(),
     applicableProducts: z.array(z.string()).optional(),
     applicableCategories: z.array(z.string()).optional(),
 });
@@ -70,6 +93,136 @@ export const couponFirestoreSchema = z.object({
     stats: couponStatsSchema,
     ...auditTimestampsShape,
 });
+/**
+ * The admin create-coupon REQUEST BODY.
+ *
+ * 🛑 It lives here, in appkit, because `bxgyConfigSchema` does — and a zod
+ * schema CANNOT cross the version boundary. The consumer root is on zod 4 and
+ * appkit depends on zod 3, so `/api/admin/coupons` composing
+ * `bxgy: bxgyConfigSchema.optional()` into a consumer `z.object({...})` did
+ * not merely infer `unknown`: zod 4 **throws** on it —
+ *
+ *     Invalid element at key "bx": expected a Zod schema
+ *
+ * — so every POST to that route failed. The type error was the only signal,
+ * and it reads as a cosmetic inference problem.
+ *
+ * Composed from the pieces above rather than restated, which is the concern
+ * the route's own comment raised about `bxgy`: "four write paths validate this
+ * shape and a fifth copy is how they drift". Re-declaring the shape in
+ * consumer zod would have been that fifth copy; moving the whole body schema
+ * to where the pieces live is the version of that fix which also works.
+ */
+export const couponCreateBodySchema = z
+    .object({
+    code: z.string().min(2).max(50),
+    name: z.string().min(1),
+    description: z.string().default(""),
+    type: couponTypeEnumSchema,
+    tiers: z.array(tieredDiscountSchema).max(6).optional(),
+    bxgy: bxgyConfigSchema.optional(),
+    discount: z.object({
+        value: z.number().min(0),
+        maxDiscount: z.number().optional(),
+        minPurchase: z.number().optional(),
+    }),
+    usage: z.object({
+        totalLimit: z.number().optional(),
+        perUserLimit: z.number().optional(),
+        currentUsage: z.number().default(0),
+    }),
+    validity: z.object({
+        startDate: z.string().transform((v) => new Date(v)),
+        endDate: z
+            .string()
+            .optional()
+            .transform((v) => (v ? new Date(v) : undefined)),
+        isActive: z.boolean().default(false),
+    }),
+    restrictions: z
+        .object({
+        applicableProducts: z.array(z.string()).optional(),
+        applicableCategories: z.array(z.string()).optional(),
+        applicableSellers: z.array(z.string()).optional(),
+        excludeProducts: z.array(z.string()).optional(),
+        excludeCategories: z.array(z.string()).optional(),
+        firstTimeUserOnly: z.boolean().default(false),
+    })
+        .default({ firstTimeUserOnly: false }),
+    createdBy: z.string().optional().default("admin"),
+})
+    .superRefine((data, ctx) => {
+    if (data.type === "percentage" && data.discount.value > 100) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: "Percentage discount cannot exceed 100%",
+            path: ["discount", "value"],
+        });
+    }
+});
+/**
+ * The admin update-coupon REQUEST BODY (`PATCH /api/admin/coupons/[id]`).
+ *
+ * 🛑 HERE FOR THE SAME REASON AS `couponCreateBodySchema` — read its note
+ * first. It embeds `bxgyConfigSchema`, and a zod-3 schema composed into a
+ * consumer zod-4 `z.object({...})` THROWS at parse time rather than merely
+ * mistyping. The POST route was migrated when that was discovered; this is
+ * the sibling PATCH, which has the same embed and would fail the same way.
+ *
+ * 🛑 NOT `couponCreateBodySchema.partial()`. That schema carries a
+ * `.superRefine`, so it is a ZodEffects and has no `.partial()` — and the
+ * update body is genuinely a different shape anyway: no `code` (a coupon's
+ * code is immutable after creation), plus the `action` discriminator the
+ * route uses for activate/deactivate.
+ *
+ * Every nested object stays OPTIONAL as a whole, which is what lets the route
+ * merge `validity` and `restrictions` against the stored document instead of
+ * replacing them — a caller sending only `{isActive: false}` must not wipe
+ * the coupon's real dates.
+ */
+export const couponUpdateBodySchema = z.object({
+    name: z.string().min(1).optional(),
+    description: z.string().optional(),
+    tiers: z.array(tieredDiscountSchema).max(6).optional(),
+    bxgy: bxgyConfigSchema.optional(),
+    discount: z
+        .object({
+        value: z.number().min(0),
+        maxDiscount: z.number().optional(),
+        minPurchase: z.number().optional(),
+    })
+        .optional(),
+    usage: z
+        .object({
+        totalLimit: z.number().optional(),
+        perUserLimit: z.number().optional(),
+    })
+        .optional(),
+    validity: z
+        .object({
+        startDate: z
+            .string()
+            .transform((v) => new Date(v))
+            .optional(),
+        endDate: z
+            .string()
+            .optional()
+            .transform((v) => (v ? new Date(v) : undefined)),
+        isActive: z.boolean().optional(),
+    })
+        .optional(),
+    restrictions: z
+        .object({
+        applicableProducts: z.array(z.string()).optional(),
+        applicableCategories: z.array(z.string()).optional(),
+        applicableSellers: z.array(z.string()).optional(),
+        excludeProducts: z.array(z.string()).optional(),
+        excludeCategories: z.array(z.string()).optional(),
+        firstTimeUserOnly: z.boolean().optional(),
+    })
+        .optional(),
+    action: z.enum(["activate", "deactivate"]).optional(),
+});
 export const couponUsageFirestoreSchema = z.object({
     id: z.string(),
     userId: z.string(),

package/dist/features/protection-claims/repository/protection-claims.repository.js

@@ -1,20 +1,11 @@
+// One shared predicate — this file had its own copy; see firestore-codes.ts.
+import { isAlreadyExistsError } from "../../../errors/firestore-codes.js";
 import { BaseRepository, prepareForFirestore } from "../../../providers/db-firebase/index.js";
 import { normalizeError } from "../../../errors/normalize.js";
 import { buildHistoryEntry } from "../../../_internal/shared/history/history.js";
 import { ConflictError } from "../../../errors/index.js";
 import { PROTECTION_CLAIMS_COLLECTION, PROTECTION_CLAIM_ACTIVE_STATUSES, PROTECTION_CLAIM_FIELDS, createProtectionClaimId, } from "../schemas/firestore.js";
-const GRPC_ALREADY_EXISTS = 6;
-function isAlreadyExists(err) {
-    if (typeof err !== "object" || err === null)
-        return false;
-    const code = err.code;
-    if (code === GRPC_ALREADY_EXISTS)
-        return true;
-    if (code === "already-exists" || code === "ALREADY_EXISTS")
-        return true;
-    const message = err.message;
-    return typeof message === "string" && message.includes("ALREADY_EXISTS");
-}
+import { serverLogger } from "../../../monitoring/index.js";
 export class ProtectionClaimsRepository extends BaseRepository {
     constructor() {
         super(PROTECTION_CLAIMS_COLLECTION);
@@ -64,7 +55,7 @@ export class ProtectionClaimsRepository extends BaseRepository {
             return doc;
         }
         catch (err) {
-            if (isAlreadyExists(err)) {
+            if (isAlreadyExistsError(err)) {
                 void normalizeError(err);
                 throw new ConflictError(`A ${input.kind} protection claim is already open on this order. Add to that claim rather than filing a second one.`);
             }
@@ -118,7 +109,15 @@ export class ProtectionClaimsRepository extends BaseRepository {
             await this.getCollection().doc(id).update({ refundId, updatedAt: now });
         }
         catch (err) {
-            void normalizeError(err);
+            /*
+             * Best effort, but RECORDED. `void normalizeError(err)` alone types the
+             * error and reports it nowhere — as silent as `catch {}` while looking
+             * handled, which is what audit-silent-degrade calls normalize theatre.
+             * Swallowing is still correct here (the claim row is already durable; this is a best-effort annotation); losing the reason is not.
+             */
+            serverLogger.warn("protectionClaims.write failed", {
+                error: normalizeError(err).message,
+            });
         }
     }
     async setStatus(id, status, reason, now = new Date()) {
@@ -142,7 +141,15 @@ export class ProtectionClaimsRepository extends BaseRepository {
             });
         }
         catch (err) {
-            void normalizeError(err);
+            /*
+             * Best effort, but RECORDED. `void normalizeError(err)` alone types the
+             * error and reports it nowhere — as silent as `catch {}` while looking
+             * handled, which is what audit-silent-degrade calls normalize theatre.
+             * Swallowing is still correct here (the claim row is already durable; this is a best-effort annotation); losing the reason is not.
+             */
+            serverLogger.warn("protectionClaims.write failed", {
+                error: normalizeError(err).message,
+            });
         }
     }
     async findByOrderAndKind(orderId, kind) {

package/dist/features/seller/schemas/coupon-form.d.ts

@@ -199,6 +199,7 @@ export declare const adminCouponFormSchema: z.ZodEffects<z.ZodObject<{
     description: z.ZodUnion<[z.ZodOptional<z.ZodString>, z.ZodLiteral<"">]>;
     buyQuantity: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
     getQuantity: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
+    maxItemPrice: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
     currentUsage: z.ZodOptional<z.ZodNumber>;
     tiers: z.ZodOptional<z.ZodArray<z.ZodObject<{
         minAmount: z.ZodNumber;
@@ -233,6 +234,7 @@ export declare const adminCouponFormSchema: z.ZodEffects<z.ZodObject<{
         discountValue: number;
     }[] | undefined;
     currentUsage?: number | undefined;
+    maxItemPrice?: string | undefined;
     maxDiscount?: string | undefined;
     buyQuantity?: string | undefined;
     getQuantity?: string | undefined;
@@ -257,6 +259,7 @@ export declare const adminCouponFormSchema: z.ZodEffects<z.ZodObject<{
         discountValue: number;
     }[] | undefined;
     currentUsage?: number | undefined;
+    maxItemPrice?: string | undefined;
     maxDiscount?: string | undefined;
     buyQuantity?: string | undefined;
     getQuantity?: string | undefined;
@@ -281,6 +284,7 @@ export declare const adminCouponFormSchema: z.ZodEffects<z.ZodObject<{
         discountValue: number;
     }[] | undefined;
     currentUsage?: number | undefined;
+    maxItemPrice?: string | undefined;
     maxDiscount?: string | undefined;
     buyQuantity?: string | undefined;
     getQuantity?: string | undefined;
@@ -305,6 +309,7 @@ export declare const adminCouponFormSchema: z.ZodEffects<z.ZodObject<{
         discountValue: number;
     }[] | undefined;
     currentUsage?: number | undefined;
+    maxItemPrice?: string | undefined;
     maxDiscount?: string | undefined;
     buyQuantity?: string | undefined;
     getQuantity?: string | undefined;

package/dist/features/seller/schemas/coupon-form.js

@@ -236,6 +236,24 @@ export const adminCouponFormSchema = couponFormBase
         section: "basics", order: 7, row: "pair", kind: "number",
         when: (v) => v.type === "buy_x_get_y",
     }),
+    /*
+     * The per-ITEM price ceiling — "buy 3 get 1 free on items under ₹2,000".
+     *
+     * 🛑 Genuinely optional, unlike the buy/get pair: `superRefine` below does
+     * NOT demand it when the type is buy_x_get_y, because a BOGO with no
+     * ceiling is a perfectly ordinary offer and every one written before
+     * 2026-10-22 is exactly that. Leaving it blank means no ceiling.
+     *
+     * 🛑 Not to be confused with `minPurchase`, which is the ORDER total. This
+     * is one unit's price, so a line of three ₹1,500 tops qualifies on all
+     * three units rather than failing a ₹4,500 test.
+     */
+    maxItemPrice: annotate(numericString("Maximum item price").optional(), {
+        section: "basics", order: 8, row: "pair", kind: "number",
+        when: (v) => v.type === "buy_x_get_y",
+        label: "Max item price (₹)",
+        help: "Only items at or below this price qualify. Leave blank for no limit.",
+    }),
     /*
      * Written by orders, never by this form. `t3-mirror` renders it read-only
      * instead of as a box an admin could set to whatever they liked — which is

package/dist/features/shell/SectionForm.js

@@ -391,6 +391,21 @@ export function SectionForm({ sections, values, onChange, onSubmit, submitLabel
      * sections").
      */
     const showRail = ordered.length >= 3;
+    /**
+     * One rail click: open the section if it is not already, then scroll to it.
+     * Named rather than inline in the button's `onClick`, where the `if` body
+     * sat a brace too deep inside the mapped JSX.
+     *
+     * Opening is conditional on purpose — in `single` mode an unconditional
+     * `setOpenIds([id])` would COLLAPSE the section you are already in when you
+     * click its own rail entry, so the rail would look like it closed the form.
+     */
+    const openAndScrollTo = (id) => {
+        if (!openIds.includes(id)) {
+            setOpenIds(expandMode === "single" ? [id] : [...openIds, id]);
+        }
+        scrollToSection(id);
+    };
     /*
      * `sticky` under the measured header, and it publishes NO height: per the
      * three-tier rule a sticky element CONSUMES the tier and never joins it.
@@ -408,21 +423,28 @@ export function SectionForm({ sections, values, onChange, onSubmit, submitLabel
      * comment syntax does not parse. That is the fourth time today; the rule is
      * simply that JSX comments belong in CHILDREN position and nowhere else.
      */
-    const rail = showRail ? (_jsx(Div, { overflow: "auto", className: "hidden lg:block w-56 flex-shrink-0 sticky self-start top-[calc(var(--header-height,3.5rem)+1rem)] max-h-[calc(100vh-var(--header-height,3.5rem)-2rem)]", children: _jsx(Nav, { "aria-label": "Form sections", children: _jsx(Stack, { gap: "px", children: ordered.map((section) => {
+    const rail = showRail ? (_jsx(Div, { overflow: "auto", 
+        /*
+         * <StickyToolbar> is a horizontal translucent bar: it ships `border-b`, a
+         * z-10 layer and the dismiss/re-expand CollapseStrip, and offers no
+         * `self-start`, `max-h` or overflow scrolling. Using it here would paint
+         * a bottom border under a 14rem sidebar and give it a horizontal bar's
+         * collapse affordance.
+         *
+         * 🛑 The marker below must stay on the line DIRECTLY above the className.
+         * Every one of these audits reads `lines[i - 1]` and nothing further, so
+         * a tidy explanation with the marker on its first line suppresses
+         * nothing while looking suppressed to a human (CLAUDE.md § Rule #5).
+         */
+        // audit-raw-sticky-toolbar-ok: a vertical RAIL, not a toolbar — see above.
+        className: "hidden lg:block w-56 flex-shrink-0 sticky self-start top-[calc(var(--header-height,3.5rem)+1rem)] max-h-[calc(100vh-var(--header-height,3.5rem)-2rem)]", children: _jsx(Nav, { "aria-label": "Form sections", children: _jsx(Stack, { gap: "px", children: ordered.map((section) => {
                     const errorCount = errorCountFor(section);
                     const isOpen = section.required === true ||
                         openIds.includes(section.id) ||
                         forceOpenIds.includes(section.id);
                     return (_jsxs(Button, { type: "button", 
                         /* `ghost`, not `bare` — UI_BUTTON has no `bare` variant. */
-                        variant: "ghost", size: "sm", justify: "between", gap: "sm", className: `w-full text-left ${isOpen ? "appkit-section-rail__item--active" : ""}`, "aria-current": isOpen ? "true" : undefined, onClick: () => {
-                            if (!openIds.includes(section.id)) {
-                                setOpenIds(expandMode === "single"
-                                    ? [section.id]
-                                    : [...openIds, section.id]);
-                            }
-                            scrollToSection(section.id);
-                        }, children: [_jsx(Span, { size: "sm", color: isOpen ? "primary" : "muted", children: section.label }), errorCount > 0 && (_jsx(Span, { size: "xs", color: "error", weight: "semibold", children: errorCount }))] }, section.id));
+                        variant: "ghost", size: "sm", justify: "between", gap: "sm", className: `w-full text-left ${isOpen ? "appkit-section-rail__item--active" : ""}`, "aria-current": isOpen ? "true" : undefined, onClick: () => openAndScrollTo(section.id), children: [_jsx(Span, { size: "sm", color: isOpen ? "primary" : "muted", children: section.label }), errorCount > 0 && (_jsx(Span, { size: "xs", color: "error", weight: "semibold", children: errorCount }))] }, section.id));
                 }) }) }) })) : null;
     const panels = (_jsxs(Stack, { gap: "md", children: [ordered.map((section) => {
                 const isRequired = section.required === true;

package/dist/features/sticker-trace/server.d.ts

@@ -6,3 +6,5 @@ export { rasterisePartToBox } from "../../_internal/shared/features/sticker-trac
 export { buildCutFileBytes, buildCutFileForRun } from "../../_internal/server/features/sticker-trace/build-cut-file";
 export { collectMosaicInputs, type MosaicInputs, type MosaicPartInput, } from "../../_internal/server/features/sticker-trace/mosaic-inputs";
 export type { PrintPageSizeId } from "../../_internal/shared/features/sticker-trace/export/page-sizes";
+export type { DecodeOptions, ImageCodec, PreviewOptions, ProbeResult, } from "../../_internal/shared/features/sticker-trace/codec";
+export type { DecodedRaster, EncodedImage, Rect as StickerRect, } from "../../_internal/shared/features/sticker-trace/types";

package/dist/http/api-handler.js

@@ -2,7 +2,10 @@ import { normalizeError } from "../errors/normalize.js";
 import { isAccountDisabled } from "../features/auth/role-predicates.js";
 import { createApiHandlerFactory } from "../next/api/apiHandler.js";
 import { applyRateLimit } from "../security/index.js";
-import { AuthenticationError, AuthorizationError, ERROR_MESSAGES, handleApiError, } from "../errors/index.js";
+import { AuthenticationError, AuthorizationError, ERROR_MESSAGES, } from "../errors/index.js";
+// Next-coupled, so it comes from the defining module — see errors/index.ts.
+// This file is an API-route handler, so `next/server` here is correct.
+import { handleApiError } from "../errors/error-handler.js";
 import { errorResponse } from "../next/api/api-response.js";
 import { serverLogger } from "../monitoring/index.js";
 import { getProviders } from "../contracts/index.js";

package/dist/index.d.ts

@@ -321,9 +321,9 @@ export { ERROR_CODES, BID_ERROR_CODES, OFFER_ERROR_CODES } from "./errors/index"
 export { ERROR_MESSAGES } from "./errors/index";
 export { NotFoundError } from "./errors/index";
 export { ValidationError } from "./errors/index";
-export { handleApiError } from "./errors/index";
-export { isAppError } from "./errors/index";
-export { logError } from "./errors/index";
+export { handleApiError } from "./errors/error-handler";
+export { isAppError } from "./errors/error-handler";
+export { logError } from "./errors/error-handler";
 export type { ErrorCode } from "./errors/index";
 export { PaymentProviderUnreachableError } from "./errors/index";
 export { mapToHttpError, HTTP_ERROR_CODES } from "./errors/index";

package/dist/index.js

@@ -552,13 +552,13 @@ export { NotFoundError } from "./errors/index.js";
 export { ValidationError } from "./errors/index.js";
 // [UTIL]-Pure utility â€" no framework or runtime dependency; safe to import from any environment.
 // handleApiError - Model for handle api error.
-export { handleApiError } from "./errors/index.js";
+export { handleApiError } from "./errors/error-handler.js";
 // [UTIL]-Pure utility â€" no framework or runtime dependency; safe to import from any environment.
 // isAppError - Model for is app error.
-export { isAppError } from "./errors/index.js";
+export { isAppError } from "./errors/error-handler.js";
 // [UTIL]-Pure utility â€" no framework or runtime dependency; safe to import from any environment.
 // logError - Helper for log error.
-export { logError } from "./errors/index.js";
+export { logError } from "./errors/error-handler.js";
 // [UTIL]-Pure utility — no framework or runtime dependency; safe to import from any environment.
 // PaymentProviderUnreachableError - Thrown when the payment gateway API exhausts retries.
 export { PaymentProviderUnreachableError } from "./errors/index.js";

package/dist/next/routing/route-map.d.ts

@@ -299,7 +299,6 @@ export declare const DEFAULT_ROUTE_MAP: {
     readonly ADMIN: {
         readonly DASHBOARD: "/admin/dashboard";
         readonly SHIPMENTS: "/admin/shipments";
-        readonly INVENTORY: "/admin/inventory";
         readonly INVENTORY_BOXES: "/admin/inventory/boxes";
         readonly INVENTORY_BOX_DETAIL: (id: string) => string;
         readonly INVENTORY_BOX_LABELS: "/admin/inventory/boxes/labels";
@@ -752,7 +751,6 @@ export declare const ROUTES: {
     readonly ADMIN: {
         readonly DASHBOARD: "/admin/dashboard";
         readonly SHIPMENTS: "/admin/shipments";
-        readonly INVENTORY: "/admin/inventory";
         readonly INVENTORY_BOXES: "/admin/inventory/boxes";
         readonly INVENTORY_BOX_DETAIL: (id: string) => string;
         readonly INVENTORY_BOX_LABELS: "/admin/inventory/boxes/labels";

package/dist/next/routing/route-map.js

@@ -433,7 +433,16 @@ export const DEFAULT_ROUTE_MAP = {
     ADMIN: {
         DASHBOARD: "/admin/dashboard",
         SHIPMENTS: "/admin/shipments",
-        INVENTORY: "/admin/inventory",
+        /*
+         * 🛑 There is deliberately NO `INVENTORY: "/admin/inventory"` key.
+         *
+         * I added one and never built the page behind it, and nothing ever
+         * referenced it — `audit-dead-route-key` caught it. A ROUTES key is a
+         * promise, and the two real surfaces (`INVENTORY_BOXES`,
+         * `INVENTORY_MOVEMENTS`) each carry their own nav entry, so an index page
+         * would be a third place to list the same two links. Build it only when
+         * there is a third child worth grouping.
+         */
         INVENTORY_BOXES: "/admin/inventory/boxes",
         INVENTORY_BOX_DETAIL: (id) => `/admin/inventory/boxes/${id}`,
         /*

package/dist/schemas/registry.d.ts

@@ -1994,6 +1994,9 @@ export declare const SCHEMAS: {
             }, import("zod").ZodTypeAny, "passthrough">;
             userId: string;
             couponCode: string;
+            claimedAt: string | Date | import("zod").objectOutputType<{
+                toDate: import("zod").ZodFunction<import("zod").ZodTuple<[], import("zod").ZodUnknown>, import("zod").ZodDate>;
+            }, import("zod").ZodTypeAny, "passthrough">;
             couponId: string;
             couponSnapshot: {
                 type: "fixed" | "percentage" | "free_shipping" | "buy_x_get_y";
@@ -2015,9 +2018,6 @@ export declare const SCHEMAS: {
                 storeId?: string | undefined;
                 description?: string | undefined;
             };
-            claimedAt: string | Date | import("zod").objectOutputType<{
-                toDate: import("zod").ZodFunction<import("zod").ZodTuple<[], import("zod").ZodUnknown>, import("zod").ZodDate>;
-            }, import("zod").ZodTypeAny, "passthrough">;
             expiresAt?: string | Date | import("zod").objectOutputType<{
                 toDate: import("zod").ZodFunction<import("zod").ZodTuple<[], import("zod").ZodUnknown>, import("zod").ZodDate>;
             }, import("zod").ZodTypeAny, "passthrough"> | null | undefined;
@@ -2034,6 +2034,9 @@ export declare const SCHEMAS: {
             }, import("zod").ZodTypeAny, "passthrough">;
             userId: string;
             couponCode: string;
+            claimedAt: string | Date | import("zod").objectInputType<{
+                toDate: import("zod").ZodFunction<import("zod").ZodTuple<[], import("zod").ZodUnknown>, import("zod").ZodDate>;
+            }, import("zod").ZodTypeAny, "passthrough">;
             couponId: string;
             couponSnapshot: {
                 type: "fixed" | "percentage" | "free_shipping" | "buy_x_get_y";
@@ -2055,9 +2058,6 @@ export declare const SCHEMAS: {
                 storeId?: string | undefined;
                 description?: string | undefined;
             };
-            claimedAt: string | Date | import("zod").objectInputType<{
-                toDate: import("zod").ZodFunction<import("zod").ZodTuple<[], import("zod").ZodUnknown>, import("zod").ZodDate>;
-            }, import("zod").ZodTypeAny, "passthrough">;
             expiresAt?: string | Date | import("zod").objectInputType<{
                 toDate: import("zod").ZodFunction<import("zod").ZodTuple<[], import("zod").ZodUnknown>, import("zod").ZodDate>;
             }, import("zod").ZodTypeAny, "passthrough"> | null | undefined;
@@ -2105,16 +2105,19 @@ export declare const SCHEMAS: {
             bxgy: import("zod").ZodOptional<import("zod").ZodObject<{
                 buyQuantity: import("zod").ZodNumber;
                 getQuantity: import("zod").ZodNumber;
+                maxItemPrice: import("zod").ZodOptional<import("zod").ZodEffects<import("zod").ZodEffects<import("zod").ZodNumber, number, number>, number, number>>;
                 applicableProducts: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
                 applicableCategories: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
             }, "strip", import("zod").ZodTypeAny, {
                 buyQuantity: number;
                 getQuantity: number;
+                maxItemPrice?: number | undefined;
                 applicableProducts?: string[] | undefined;
                 applicableCategories?: string[] | undefined;
             }, {
                 buyQuantity: number;
                 getQuantity: number;
+                maxItemPrice?: number | undefined;
                 applicableProducts?: string[] | undefined;
                 applicableCategories?: string[] | undefined;
             }>>;
@@ -2261,6 +2264,7 @@ export declare const SCHEMAS: {
             bxgy?: {
                 buyQuantity: number;
                 getQuantity: number;
+                maxItemPrice?: number | undefined;
                 applicableProducts?: string[] | undefined;
                 applicableCategories?: string[] | undefined;
             } | undefined;
@@ -2319,6 +2323,7 @@ export declare const SCHEMAS: {
             bxgy?: {
                 buyQuantity: number;
                 getQuantity: number;
+                maxItemPrice?: number | undefined;
                 applicableProducts?: string[] | undefined;
                 applicableCategories?: string[] | undefined;
             } | undefined;

package/dist/server.d.ts

@@ -571,7 +571,6 @@ export type { ActionIndexValidationContext, ActionIndexValidationIssue, } from "
 export { ActionIndexRepository, actionIndexRepository, } from "./features/search/action-index/repository";
 export type { ActionIndexDocument } from "./features/search/action-index/repository";
 export { REFUND_COPY } from "./_internal/shared/features/orders/refund-copy";
-export { wouldBeFullRefund } from "./_internal/shared/checkout/refundable-base";
 export { RETURN_REASON, FINAL_SALE_EXEMPT_REASONS, RETURN_REASON_LABEL, RETURN_REASON_GROUP_LABEL, isFinalSaleExempt, isReturnReason, selectableReturnReasons, } from "./_internal/shared/features/orders/return-reasons";
 export type { ReturnReason } from "./_internal/shared/features/orders/return-reasons";
 export { draftToProductInput, productToDraft, } from "./features/seller/utils/product-draft-mapping";

package/dist/server.js

@@ -1529,10 +1529,12 @@ export { validateActionIndexEntry, normaliseRoute, } from "./features/search/act
 export { ActionIndexRepository, actionIndexRepository, } from "./features/search/action-index/repository.js";
 export { REFUND_COPY } from "./_internal/shared/features/orders/refund-copy.js";
 /*
- * `wouldBeFullRefund` — from refundable-base, NOT return-reasons. It was
- * never exported at all, so the admin refund route could not import it.
+ * 🛑 `wouldBeFullRefund` is deliberately NOT exported. I added it here, and
+ * `audit-appkit-reexports` was right to refuse it: `_internal/shared/checkout/`
+ * is not a `features/` module, so exporting it would have made a money
+ * predicate public purely so one route could duplicate a decision
+ * `processRefundAction` already makes — see the note on `ProcessRefundInput`.
  */
-export { wouldBeFullRefund } from "./_internal/shared/checkout/refundable-base.js";
 // Return / refund reasons — the closed enum the final-sale gate branches on.
 // See the module docstring for why the exempt set is "seller or carrier fault"
 // rather than "serious reasons".

package/dist/styles.css

@@ -11350,6 +11350,57 @@ body:has(.appkit-page-breadcrumb) .appkit-auto-breadcrumbs {
  * plain file like this one can never win an importance tie.
  */
 
+/* The kiss-cut label sheet. Shipped unbundled when it was written — the
+   `.appkit-label-sheet` grid and its `@page` rules reached no consumer, so
+   every printed sheet fell back to browser defaults and the die-cut
+   alignment the component exists to produce could not happen. */
+/*
+ * Print-layout classes for physical labels and printable documents.
+ *
+ * 🛑 THESE LIVE IN A STATIC STYLESHEET, NOT ONLY IN `labelPageCss`'s STRING.
+ *
+ * `labelPageCss()` and `documentPageCss()` emit an `@page` rule plus these
+ * same `break-*` declarations into a runtime `<style>`. That is necessary for
+ * `@page` — its `size` is computed from the chosen profile, so it cannot be
+ * static — but it meant `.appkit-label` and `.appkit-label-sheet` existed
+ * ONLY inside a template literal.
+ *
+ * Consequence: `audit-dead-css-classes` reported them as classes generating no
+ * CSS rule, correctly, because nothing it can read defines them. A class whose
+ * only definition is a string concatenation is invisible to every tool — the
+ * audit, an editor's go-to-definition, and anyone grepping the stylesheets.
+ * Declaring them here makes them real; the runtime string still carries its
+ * own copy because a print view may be opened in a context where the bundled
+ * stylesheet has not loaded, and a duplicated `break-inside: avoid` is
+ * harmless where a missing one splits a label across two pages.
+ *
+ * @tag domain:print
+ * @tag layer:feature
+ */
+
+@media print {
+  /*
+   * A label must never be split across a page boundary. On thermal stock a
+   * page IS a label, so a split would print the top half on one label and the
+   * bottom half on the next — and the operator discovers it after both have
+   * been peeled and stuck to something.
+   */
+  .appkit-label {
+    break-inside: avoid;
+    page-break-inside: avoid;
+  }
+
+  /*
+   * A sheet is one A4 page of die-cut labels, or one contents sheet. Same
+   * rule, different unit — splitting it would offset every label after the
+   * break from its die-cut hole.
+   */
+  .appkit-label-sheet {
+    break-inside: avoid;
+    page-break-inside: avoid;
+  }
+}
+
 /*
  * Third-party stylesheet, vendored into dist/vendor by copy-assets.mjs.
  * It used to be a JS import inside ImageEditor.tsx, which made it invisible to

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mohasinac/appkit",
-  "version": "4.60.1",
+  "version": "4.61.0",
   "license": "MIT",
   "publishConfig": {
     "access": "public"