@rebuy/rebuy 3.60.5 → 3.62.0

package/dist/index.cjs

@@ -121,6 +121,7 @@ __export(src_exports, {
   DiscountSource: () => DiscountSource,
   DiscountType: () => DiscountType,
   EditorMode: () => EditorMode,
+  EngineSmartCart: () => EngineSmartCart,
   EventCalculationSchema: () => EventCalculationSchema,
   ExitPolicySchema: () => ExitPolicySchema,
   FinishedPurchaseSchema: () => FinishedPurchaseSchema,
@@ -1228,7 +1229,22 @@ var SmartCartTierProduct = import_zod.z.looseObject({
 });
 var SmartCartTierExclusion = import_zod.z.looseObject({
   collectionIds: import_zod.z.array(import_zod.z.coerce.number()).optional().catch(void 0),
-  productIds: import_zod.z.array(import_zod.z.coerce.number()).optional().catch(void 0),
+  /**
+   * onsite keeps each excluded product with ITS OWN variants, the same shape the bar-level
+   * `excludedProducts` uses, so a rule can exclude one variant of B without touching A.
+   * Flat parallel id lists cannot express that mapping.
+   *
+   * camelCase like every other key in this file, NOT the `product_id` / `variant_ids` the onsite
+   * payload spells: `parseShielded` runs `deepCamelCase` over the tree BEFORE any schema sees it.
+   * A snake_case key here reads as absent, every entry drops, and the converter discards the whole
+   * rule in silence — the exclusion just never reaches checkout.
+   */
+  products: import_zod.z.array(
+    import_zod.z.looseObject({
+      productId: import_zod.z.coerce.number().optional().catch(void 0),
+      variantIds: import_zod.z.array(import_zod.z.coerce.number()).optional().catch(void 0)
+    })
+  ).optional().catch(void 0),
   tags: import_zod.z.array(import_zod.z.string()).optional().catch(void 0),
   type: import_zod.z.string().optional().catch(void 0)
 });
@@ -1363,6 +1379,7 @@ var SmartCartComponent = import_zod.z.looseObject({
 var SmartCartConfig = import_zod.z.looseObject({
   components: import_zod.z.array(SmartCartComponent).optional()
 });
+var EngineSmartCart = import_zod.z.preprocess((value) => value === false ? null : value, SmartCartConfig.nullish());
 
 // src/schema/cabShopConfig.ts
 var CabActiveExperiment = import_zod2.z.object({
@@ -1460,7 +1477,7 @@ var CabShopConfig = import_zod2.z.object({
 });
 var CabUserConfig = import_zod2.z.object({
   shop: CabShopConfig,
-  smartCart: SmartCartConfig.nullish().catch(DRIFTED_SMART_CART)
+  smartCart: EngineSmartCart.catch(DRIFTED_SMART_CART)
 });
 
 // src/schema/metadata.ts
@@ -4124,7 +4141,17 @@ var GIFT_LABELS = {
 // src/schema/widgets/checkout-and-beyond/progressBar.ts
 var CABProgressTierExclusion = import_zod61.z.object({
   collectionIds: import_zod61.z.array(import_zod61.z.number().int().positive()).default(() => []),
-  productIds: import_zod61.z.array(import_zod61.z.number().int().positive()).default(() => []),
+  /**
+   * `products` rules: each excluded product with ITS OWN variants, mirroring the bar-level
+   * excluded products. An empty `variantIds` means "the whole product", which is how the admin
+   * picker stores a whole-product selection, and a populated one means those variants.
+   */
+  products: import_zod61.z.array(
+    import_zod61.z.object({
+      productId: import_zod61.z.number().int().positive(),
+      variantIds: import_zod61.z.array(import_zod61.z.number().int().positive()).default(() => [])
+    })
+  ).default(() => []),
   tags: import_zod61.z.array(import_zod61.z.string().min(1)).default(() => []),
   type: import_zod61.z.enum(progressTierExclusionTypes)
 });
@@ -5238,10 +5265,14 @@ var import_zod93 = require("zod");
 var UserConfig = import_zod93.z.object({
   shop: ShopConfig,
   /**
-   * `.catch(undefined)` is the safety bar: smart-cart shape drift can NEVER fail `fetchUserConfig`,
-   * which resolves the apiKey for every offers/monetize/analytics/gift request.
+   * Parsed like `CabUserConfig.smartCart`: the engine's `false` reads as `null` ({@link EngineSmartCart}), a
+   * drifted component loses only its own settings (`SmartCartComponent.settings` catches per component), and
+   * `.catch(undefined)` is the last safety bar so a wholly unreadable config can never fail the parse that
+   * resolves the shop's apiKey. It lands on `undefined`, not the `DRIFTED_SMART_CART` sentinel: no drift
+   * reporter reads this schema (the server parses `CabUserConfig`), and that sentinel's identity is not
+   * exported from `./schema`, so a consumer could not tell it apart from an empty config anyway.
    */
-  smartCart: SmartCartConfig.nullish().catch(void 0),
+  smartCart: EngineSmartCart.catch(void 0),
   smartFlows: import_zod93.z.array(import_zod93.z.unknown())
 });
 

package/dist/index.mjs

@@ -746,7 +746,22 @@ var SmartCartTierProduct = z.looseObject({
 });
 var SmartCartTierExclusion = z.looseObject({
   collectionIds: z.array(z.coerce.number()).optional().catch(void 0),
-  productIds: z.array(z.coerce.number()).optional().catch(void 0),
+  /**
+   * onsite keeps each excluded product with ITS OWN variants, the same shape the bar-level
+   * `excludedProducts` uses, so a rule can exclude one variant of B without touching A.
+   * Flat parallel id lists cannot express that mapping.
+   *
+   * camelCase like every other key in this file, NOT the `product_id` / `variant_ids` the onsite
+   * payload spells: `parseShielded` runs `deepCamelCase` over the tree BEFORE any schema sees it.
+   * A snake_case key here reads as absent, every entry drops, and the converter discards the whole
+   * rule in silence — the exclusion just never reaches checkout.
+   */
+  products: z.array(
+    z.looseObject({
+      productId: z.coerce.number().optional().catch(void 0),
+      variantIds: z.array(z.coerce.number()).optional().catch(void 0)
+    })
+  ).optional().catch(void 0),
   tags: z.array(z.string()).optional().catch(void 0),
   type: z.string().optional().catch(void 0)
 });
@@ -881,6 +896,7 @@ var SmartCartComponent = z.looseObject({
 var SmartCartConfig = z.looseObject({
   components: z.array(SmartCartComponent).optional()
 });
+var EngineSmartCart = z.preprocess((value) => value === false ? null : value, SmartCartConfig.nullish());
 
 // src/schema/cabShopConfig.ts
 var CabActiveExperiment = z2.object({
@@ -978,7 +994,7 @@ var CabShopConfig = z2.object({
 });
 var CabUserConfig = z2.object({
   shop: CabShopConfig,
-  smartCart: SmartCartConfig.nullish().catch(DRIFTED_SMART_CART)
+  smartCart: EngineSmartCart.catch(DRIFTED_SMART_CART)
 });
 
 // src/schema/metadata.ts
@@ -3642,7 +3658,17 @@ var GIFT_LABELS = {
 // src/schema/widgets/checkout-and-beyond/progressBar.ts
 var CABProgressTierExclusion = z61.object({
   collectionIds: z61.array(z61.number().int().positive()).default(() => []),
-  productIds: z61.array(z61.number().int().positive()).default(() => []),
+  /**
+   * `products` rules: each excluded product with ITS OWN variants, mirroring the bar-level
+   * excluded products. An empty `variantIds` means "the whole product", which is how the admin
+   * picker stores a whole-product selection, and a populated one means those variants.
+   */
+  products: z61.array(
+    z61.object({
+      productId: z61.number().int().positive(),
+      variantIds: z61.array(z61.number().int().positive()).default(() => [])
+    })
+  ).default(() => []),
   tags: z61.array(z61.string().min(1)).default(() => []),
   type: z61.enum(progressTierExclusionTypes)
 });
@@ -4756,10 +4782,14 @@ import { z as z93 } from "zod";
 var UserConfig = z93.object({
   shop: ShopConfig,
   /**
-   * `.catch(undefined)` is the safety bar: smart-cart shape drift can NEVER fail `fetchUserConfig`,
-   * which resolves the apiKey for every offers/monetize/analytics/gift request.
+   * Parsed like `CabUserConfig.smartCart`: the engine's `false` reads as `null` ({@link EngineSmartCart}), a
+   * drifted component loses only its own settings (`SmartCartComponent.settings` catches per component), and
+   * `.catch(undefined)` is the last safety bar so a wholly unreadable config can never fail the parse that
+   * resolves the shop's apiKey. It lands on `undefined`, not the `DRIFTED_SMART_CART` sentinel: no drift
+   * reporter reads this schema (the server parses `CabUserConfig`), and that sentinel's identity is not
+   * exported from `./schema`, so a consumer could not tell it apart from an empty config anyway.
    */
-  smartCart: SmartCartConfig.nullish().catch(void 0),
+  smartCart: EngineSmartCart.catch(void 0),
   smartFlows: z93.array(z93.unknown())
 });
 
@@ -6753,6 +6783,7 @@ export {
   DiscountSource,
   DiscountType,
   EditorMode,
+  EngineSmartCart,
   EventCalculationSchema,
   ExitPolicySchema,
   FinishedPurchaseSchema,

package/dist/schema/cabShopConfig.d.ts

@@ -62,8 +62,9 @@ export type CabShopConfig = z.infer<typeof CabShopConfig>;
  *
  * The catch lands on the {@link DRIFTED_SMART_CART} identity sentinel (no components ⇒ no bars), not
  * `undefined`, so the server's progress-bar resolution can tell a drifted config from a shop with no smart
- * cart (`null`/absent stay `null`/`undefined`) and emit a `shopConfig` drift (REB-25139: this catch used to
- * drop every progress bar for the shop silently).
+ * cart (`null`/absent stay `null`/`undefined`, and the engine's `false` reads as `null` via
+ * {@link EngineSmartCart}) and emit a `shopConfig` drift (REB-25139: this catch used to drop every progress
+ * bar for the shop silently; REB-25187: `false` used to land on the sentinel and report a false drift).
  */
 export declare const CabUserConfig: z.ZodObject<{
     shop: z.ZodObject<{
@@ -98,7 +99,7 @@ export declare const CabUserConfig: z.ZodObject<{
         shopId: z.ZodCatch<z.ZodOptional<z.ZodNumber>>;
         shopName: z.ZodCatch<z.ZodOptional<z.ZodNullable<z.ZodString>>>;
     }, z.core.$strip>;
-    smartCart: z.ZodCatch<z.ZodOptional<z.ZodNullable<z.ZodObject<{
+    smartCart: z.ZodCatch<z.ZodPreprocess<z.ZodOptional<z.ZodNullable<z.ZodObject<{
         components: z.ZodOptional<z.ZodArray<z.ZodObject<{
             settings: z.ZodCatch<z.ZodPreprocess<z.ZodOptional<z.ZodObject<{
                 bars: z.ZodOptional<z.ZodArray<z.ZodObject<{
@@ -138,7 +139,10 @@ export declare const CabUserConfig: z.ZodObject<{
                         discountType: z.ZodOptional<z.ZodString>;
                         exclusions: z.ZodCatch<z.ZodOptional<z.ZodArray<z.ZodObject<{
                             collectionIds: z.ZodCatch<z.ZodOptional<z.ZodArray<z.ZodCoercedNumber<unknown>>>>;
-                            productIds: z.ZodCatch<z.ZodOptional<z.ZodArray<z.ZodCoercedNumber<unknown>>>>;
+                            products: z.ZodCatch<z.ZodOptional<z.ZodArray<z.ZodObject<{
+                                productId: z.ZodCatch<z.ZodOptional<z.ZodCoercedNumber<unknown>>>;
+                                variantIds: z.ZodCatch<z.ZodOptional<z.ZodArray<z.ZodCoercedNumber<unknown>>>>;
+                            }, z.core.$loose>>>>;
                             tags: z.ZodCatch<z.ZodOptional<z.ZodArray<z.ZodString>>>;
                             type: z.ZodCatch<z.ZodOptional<z.ZodString>>;
                         }, z.core.$loose>>>>;
@@ -169,6 +173,6 @@ export declare const CabUserConfig: z.ZodObject<{
             }, z.core.$loose>>>>;
             type: z.ZodOptional<z.ZodString>;
         }, z.core.$loose>>>;
-    }, z.core.$loose>>>>;
+    }, z.core.$loose>>>>>;
 }, z.core.$strip>;
 export type CabUserConfig = z.infer<typeof CabUserConfig>;

package/dist/schema/checkout-and-beyond/index.cjs

@@ -1317,7 +1317,17 @@ var GIFT_LABELS = {
 // src/schema/widgets/checkout-and-beyond/progressBar.ts
 var CABProgressTierExclusion = import_zod15.z.object({
   collectionIds: import_zod15.z.array(import_zod15.z.number().int().positive()).default(() => []),
-  productIds: import_zod15.z.array(import_zod15.z.number().int().positive()).default(() => []),
+  /**
+   * `products` rules: each excluded product with ITS OWN variants, mirroring the bar-level
+   * excluded products. An empty `variantIds` means "the whole product", which is how the admin
+   * picker stores a whole-product selection, and a populated one means those variants.
+   */
+  products: import_zod15.z.array(
+    import_zod15.z.object({
+      productId: import_zod15.z.number().int().positive(),
+      variantIds: import_zod15.z.array(import_zod15.z.number().int().positive()).default(() => [])
+    })
+  ).default(() => []),
   tags: import_zod15.z.array(import_zod15.z.string().min(1)).default(() => []),
   type: import_zod15.z.enum(progressTierExclusionTypes)
 });

package/dist/schema/checkout-and-beyond/index.mjs

@@ -1102,7 +1102,17 @@ var GIFT_LABELS = {
 // src/schema/widgets/checkout-and-beyond/progressBar.ts
 var CABProgressTierExclusion = z15.object({
   collectionIds: z15.array(z15.number().int().positive()).default(() => []),
-  productIds: z15.array(z15.number().int().positive()).default(() => []),
+  /**
+   * `products` rules: each excluded product with ITS OWN variants, mirroring the bar-level
+   * excluded products. An empty `variantIds` means "the whole product", which is how the admin
+   * picker stores a whole-product selection, and a populated one means those variants.
+   */
+  products: z15.array(
+    z15.object({
+      productId: z15.number().int().positive(),
+      variantIds: z15.array(z15.number().int().positive()).default(() => [])
+    })
+  ).default(() => []),
   tags: z15.array(z15.string().min(1)).default(() => []),
   type: z15.enum(progressTierExclusionTypes)
 });

package/dist/schema/smartCart.d.ts

@@ -23,7 +23,10 @@ export declare const SmartCartTierProduct: z.ZodObject<{
  */
 export declare const SmartCartTierExclusion: z.ZodObject<{
     collectionIds: z.ZodCatch<z.ZodOptional<z.ZodArray<z.ZodCoercedNumber<unknown>>>>;
-    productIds: z.ZodCatch<z.ZodOptional<z.ZodArray<z.ZodCoercedNumber<unknown>>>>;
+    products: z.ZodCatch<z.ZodOptional<z.ZodArray<z.ZodObject<{
+        productId: z.ZodCatch<z.ZodOptional<z.ZodCoercedNumber<unknown>>>;
+        variantIds: z.ZodCatch<z.ZodOptional<z.ZodArray<z.ZodCoercedNumber<unknown>>>>;
+    }, z.core.$loose>>>>;
     tags: z.ZodCatch<z.ZodOptional<z.ZodArray<z.ZodString>>>;
     type: z.ZodCatch<z.ZodOptional<z.ZodString>>;
 }, z.core.$loose>;
@@ -61,7 +64,10 @@ export declare const SmartCartTier: z.ZodObject<{
     discountType: z.ZodOptional<z.ZodString>;
     exclusions: z.ZodCatch<z.ZodOptional<z.ZodArray<z.ZodObject<{
         collectionIds: z.ZodCatch<z.ZodOptional<z.ZodArray<z.ZodCoercedNumber<unknown>>>>;
-        productIds: z.ZodCatch<z.ZodOptional<z.ZodArray<z.ZodCoercedNumber<unknown>>>>;
+        products: z.ZodCatch<z.ZodOptional<z.ZodArray<z.ZodObject<{
+            productId: z.ZodCatch<z.ZodOptional<z.ZodCoercedNumber<unknown>>>;
+            variantIds: z.ZodCatch<z.ZodOptional<z.ZodArray<z.ZodCoercedNumber<unknown>>>>;
+        }, z.core.$loose>>>>;
         tags: z.ZodCatch<z.ZodOptional<z.ZodArray<z.ZodString>>>;
         type: z.ZodCatch<z.ZodOptional<z.ZodString>>;
     }, z.core.$loose>>>>;
@@ -130,7 +136,10 @@ export declare const SmartCartBar: z.ZodObject<{
         discountType: z.ZodOptional<z.ZodString>;
         exclusions: z.ZodCatch<z.ZodOptional<z.ZodArray<z.ZodObject<{
             collectionIds: z.ZodCatch<z.ZodOptional<z.ZodArray<z.ZodCoercedNumber<unknown>>>>;
-            productIds: z.ZodCatch<z.ZodOptional<z.ZodArray<z.ZodCoercedNumber<unknown>>>>;
+            products: z.ZodCatch<z.ZodOptional<z.ZodArray<z.ZodObject<{
+                productId: z.ZodCatch<z.ZodOptional<z.ZodCoercedNumber<unknown>>>;
+                variantIds: z.ZodCatch<z.ZodOptional<z.ZodArray<z.ZodCoercedNumber<unknown>>>>;
+            }, z.core.$loose>>>>;
             tags: z.ZodCatch<z.ZodOptional<z.ZodArray<z.ZodString>>>;
             type: z.ZodCatch<z.ZodOptional<z.ZodString>>;
         }, z.core.$loose>>>>;
@@ -198,7 +207,10 @@ export declare const SmartCartComponent: z.ZodObject<{
                 discountType: z.ZodOptional<z.ZodString>;
                 exclusions: z.ZodCatch<z.ZodOptional<z.ZodArray<z.ZodObject<{
                     collectionIds: z.ZodCatch<z.ZodOptional<z.ZodArray<z.ZodCoercedNumber<unknown>>>>;
-                    productIds: z.ZodCatch<z.ZodOptional<z.ZodArray<z.ZodCoercedNumber<unknown>>>>;
+                    products: z.ZodCatch<z.ZodOptional<z.ZodArray<z.ZodObject<{
+                        productId: z.ZodCatch<z.ZodOptional<z.ZodCoercedNumber<unknown>>>;
+                        variantIds: z.ZodCatch<z.ZodOptional<z.ZodArray<z.ZodCoercedNumber<unknown>>>>;
+                    }, z.core.$loose>>>>;
                     tags: z.ZodCatch<z.ZodOptional<z.ZodArray<z.ZodString>>>;
                     type: z.ZodCatch<z.ZodOptional<z.ZodString>>;
                 }, z.core.$loose>>>>;
@@ -233,7 +245,7 @@ export declare const SmartCartComponent: z.ZodObject<{
  * The subset of the shop's smart-cart config the checkout extension reads: the
  * `tiered_progress_bar` component(s) and their bars/tiers. The rest of the onsite
  * smart-cart config (buy-more-save-more, custom templates/CSS, callbacks) is out of
- * scope — `looseObject` preserves-but-ignores it. Parsed under `UserConfig.smartCart`
+ * scope — `looseObject` preserves-but-ignores it. Parsed via {@link EngineSmartCart} under `UserConfig.smartCart`
  * (`.catch(undefined)`) and `CabUserConfig.smartCart` (`.catch` to a drift sentinel) so a shape
  * drift here can NEVER break apiKey resolution for offers / monetize / analytics / gift validation.
  */
@@ -277,7 +289,10 @@ export declare const SmartCartConfig: z.ZodObject<{
                     discountType: z.ZodOptional<z.ZodString>;
                     exclusions: z.ZodCatch<z.ZodOptional<z.ZodArray<z.ZodObject<{
                         collectionIds: z.ZodCatch<z.ZodOptional<z.ZodArray<z.ZodCoercedNumber<unknown>>>>;
-                        productIds: z.ZodCatch<z.ZodOptional<z.ZodArray<z.ZodCoercedNumber<unknown>>>>;
+                        products: z.ZodCatch<z.ZodOptional<z.ZodArray<z.ZodObject<{
+                            productId: z.ZodCatch<z.ZodOptional<z.ZodCoercedNumber<unknown>>>;
+                            variantIds: z.ZodCatch<z.ZodOptional<z.ZodArray<z.ZodCoercedNumber<unknown>>>>;
+                        }, z.core.$loose>>>>;
                         tags: z.ZodCatch<z.ZodOptional<z.ZodArray<z.ZodString>>>;
                         type: z.ZodCatch<z.ZodOptional<z.ZodString>>;
                     }, z.core.$loose>>>>;
@@ -309,7 +324,90 @@ export declare const SmartCartConfig: z.ZodObject<{
         type: z.ZodOptional<z.ZodString>;
     }, z.core.$loose>>>;
 }, z.core.$loose>;
+/**
+ * The `smartCart` field of `/api/v1/user/config` as the engine actually sends it. A shop with no enabled
+ * Smart Cart arrives as `smart_cart: false` (the engine's "none" vocabulary, like `null`/absent), so `false`
+ * reads as `null` before the object schema sees it: no smart cart, no bars, and no drift. Only `false` — a
+ * `true`, a string or a number is a genuine retype and falls through to the reader's own `.catch`.
+ * `UserConfig` and `CabUserConfig` both parse through this, each adding its own config-level `.catch`.
+ */
+export declare const EngineSmartCart: z.ZodPreprocess<z.ZodOptional<z.ZodNullable<z.ZodObject<{
+    components: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        settings: z.ZodCatch<z.ZodPreprocess<z.ZodOptional<z.ZodObject<{
+            bars: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                countryCodes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                excludeDiscountInSubtotal: z.ZodOptional<z.ZodBoolean>;
+                excludedProducts: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    variantIds: z.ZodOptional<z.ZodArray<z.ZodCoercedNumber<unknown>>>;
+                }, z.core.$loose>>>;
+                freeShippingOnSubscription: z.ZodOptional<z.ZodBoolean>;
+                geolocationEnabled: z.ZodOptional<z.ZodBoolean>;
+                id: z.ZodOptional<z.ZodString>;
+                language: z.ZodPreprocess<z.ZodOptional<z.ZodObject<{
+                    freeShippingReached: z.ZodOptional<z.ZodString>;
+                    freeShippingRemaining: z.ZodOptional<z.ZodString>;
+                    giftAreaTitle: z.ZodOptional<z.ZodString>;
+                }, z.core.$loose>>>;
+                name: z.ZodOptional<z.ZodString>;
+                tiers: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    allProducts: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                        handle: z.ZodOptional<z.ZodString>;
+                        id: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+                        productId: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+                        title: z.ZodOptional<z.ZodString>;
+                        variantIds: z.ZodOptional<z.ZodArray<z.ZodCoercedNumber<unknown>>>;
+                    }, z.core.$loose>>>;
+                    customTierLabel: z.ZodOptional<z.ZodBoolean>;
+                    customTierLabelText: z.ZodOptional<z.ZodString>;
+                    decorativeAmountReachedLabel: z.ZodOptional<z.ZodBoolean>;
+                    decorativeAmountReachedLabelText: z.ZodOptional<z.ZodString>;
+                    decorativeAmountRemainingLabel: z.ZodOptional<z.ZodBoolean>;
+                    decorativeAmountRemainingLabelText: z.ZodOptional<z.ZodString>;
+                    discountAmountFromTotal: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+                    discountAmountReachedLabel: z.ZodOptional<z.ZodBoolean>;
+                    discountAmountReachedLabelText: z.ZodOptional<z.ZodString>;
+                    discountAmountRemainingLabel: z.ZodOptional<z.ZodBoolean>;
+                    discountAmountRemainingLabelText: z.ZodOptional<z.ZodString>;
+                    discountType: z.ZodOptional<z.ZodString>;
+                    exclusions: z.ZodCatch<z.ZodOptional<z.ZodArray<z.ZodObject<{
+                        collectionIds: z.ZodCatch<z.ZodOptional<z.ZodArray<z.ZodCoercedNumber<unknown>>>>;
+                        products: z.ZodCatch<z.ZodOptional<z.ZodArray<z.ZodObject<{
+                            productId: z.ZodCatch<z.ZodOptional<z.ZodCoercedNumber<unknown>>>;
+                            variantIds: z.ZodCatch<z.ZodOptional<z.ZodArray<z.ZodCoercedNumber<unknown>>>>;
+                        }, z.core.$loose>>>>;
+                        tags: z.ZodCatch<z.ZodOptional<z.ZodArray<z.ZodString>>>;
+                        type: z.ZodCatch<z.ZodOptional<z.ZodString>>;
+                    }, z.core.$loose>>>>;
+                    exclusionsEnabled: z.ZodCatch<z.ZodOptional<z.ZodBoolean>>;
+                    filterOosVariants: z.ZodOptional<z.ZodBoolean>;
+                    id: z.ZodOptional<z.ZodString>;
+                    minimum: z.ZodPreprocess<z.ZodOptional<z.ZodCoercedNumber<unknown>>>;
+                    presentmentCurrencies: z.ZodPreprocess<z.ZodOptional<z.ZodObject<{
+                        enabled: z.ZodOptional<z.ZodBoolean>;
+                    }, z.core.$loose>>>;
+                    productAmountReachedLabel: z.ZodOptional<z.ZodBoolean>;
+                    productAmountReachedLabelText: z.ZodOptional<z.ZodString>;
+                    productAmountRemainingLabel: z.ZodOptional<z.ZodBoolean>;
+                    productAmountRemainingLabelText: z.ZodOptional<z.ZodString>;
+                    products: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                        handle: z.ZodOptional<z.ZodString>;
+                        id: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+                        productId: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+                        title: z.ZodOptional<z.ZodString>;
+                        variantIds: z.ZodOptional<z.ZodArray<z.ZodCoercedNumber<unknown>>>;
+                    }, z.core.$loose>>>;
+                    productTierElementSize: z.ZodCatch<z.ZodOptional<z.ZodString>>;
+                    productTierImage: z.ZodCatch<z.ZodOptional<z.ZodBoolean>>;
+                    type: z.ZodOptional<z.ZodString>;
+                    unlockConditionType: z.ZodOptional<z.ZodString>;
+                }, z.core.$loose>>>;
+            }, z.core.$loose>>>;
+        }, z.core.$loose>>>>;
+        type: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>>>;
+}, z.core.$loose>>>>;
 export type SmartCartBar = z.infer<typeof SmartCartBar>;
 export type SmartCartConfig = z.infer<typeof SmartCartConfig>;
 export type SmartCartTier = z.infer<typeof SmartCartTier>;
+export type SmartCartTierExclusion = z.infer<typeof SmartCartTierExclusion>;
 export type SmartCartTierProduct = z.infer<typeof SmartCartTierProduct>;

package/dist/schema/user-config.cjs

@@ -127,7 +127,22 @@ var SmartCartTierProduct = import_zod2.z.looseObject({
 });
 var SmartCartTierExclusion = import_zod2.z.looseObject({
   collectionIds: import_zod2.z.array(import_zod2.z.coerce.number()).optional().catch(void 0),
-  productIds: import_zod2.z.array(import_zod2.z.coerce.number()).optional().catch(void 0),
+  /**
+   * onsite keeps each excluded product with ITS OWN variants, the same shape the bar-level
+   * `excludedProducts` uses, so a rule can exclude one variant of B without touching A.
+   * Flat parallel id lists cannot express that mapping.
+   *
+   * camelCase like every other key in this file, NOT the `product_id` / `variant_ids` the onsite
+   * payload spells: `parseShielded` runs `deepCamelCase` over the tree BEFORE any schema sees it.
+   * A snake_case key here reads as absent, every entry drops, and the converter discards the whole
+   * rule in silence — the exclusion just never reaches checkout.
+   */
+  products: import_zod2.z.array(
+    import_zod2.z.looseObject({
+      productId: import_zod2.z.coerce.number().optional().catch(void 0),
+      variantIds: import_zod2.z.array(import_zod2.z.coerce.number()).optional().catch(void 0)
+    })
+  ).optional().catch(void 0),
   tags: import_zod2.z.array(import_zod2.z.string()).optional().catch(void 0),
   type: import_zod2.z.string().optional().catch(void 0)
 });
@@ -262,14 +277,19 @@ var SmartCartComponent = import_zod2.z.looseObject({
 var SmartCartConfig = import_zod2.z.looseObject({
   components: import_zod2.z.array(SmartCartComponent).optional()
 });
+var EngineSmartCart = import_zod2.z.preprocess((value) => value === false ? null : value, SmartCartConfig.nullish());
 
 // src/schema/userConfig.ts
 var UserConfig = import_zod3.z.object({
   shop: ShopConfig,
   /**
-   * `.catch(undefined)` is the safety bar: smart-cart shape drift can NEVER fail `fetchUserConfig`,
-   * which resolves the apiKey for every offers/monetize/analytics/gift request.
+   * Parsed like `CabUserConfig.smartCart`: the engine's `false` reads as `null` ({@link EngineSmartCart}), a
+   * drifted component loses only its own settings (`SmartCartComponent.settings` catches per component), and
+   * `.catch(undefined)` is the last safety bar so a wholly unreadable config can never fail the parse that
+   * resolves the shop's apiKey. It lands on `undefined`, not the `DRIFTED_SMART_CART` sentinel: no drift
+   * reporter reads this schema (the server parses `CabUserConfig`), and that sentinel's identity is not
+   * exported from `./schema`, so a consumer could not tell it apart from an empty config anyway.
    */
-  smartCart: SmartCartConfig.nullish().catch(void 0),
+  smartCart: EngineSmartCart.catch(void 0),
   smartFlows: import_zod3.z.array(import_zod3.z.unknown())
 });

package/dist/schema/user-config.mjs

@@ -103,7 +103,22 @@ var SmartCartTierProduct = z2.looseObject({
 });
 var SmartCartTierExclusion = z2.looseObject({
   collectionIds: z2.array(z2.coerce.number()).optional().catch(void 0),
-  productIds: z2.array(z2.coerce.number()).optional().catch(void 0),
+  /**
+   * onsite keeps each excluded product with ITS OWN variants, the same shape the bar-level
+   * `excludedProducts` uses, so a rule can exclude one variant of B without touching A.
+   * Flat parallel id lists cannot express that mapping.
+   *
+   * camelCase like every other key in this file, NOT the `product_id` / `variant_ids` the onsite
+   * payload spells: `parseShielded` runs `deepCamelCase` over the tree BEFORE any schema sees it.
+   * A snake_case key here reads as absent, every entry drops, and the converter discards the whole
+   * rule in silence — the exclusion just never reaches checkout.
+   */
+  products: z2.array(
+    z2.looseObject({
+      productId: z2.coerce.number().optional().catch(void 0),
+      variantIds: z2.array(z2.coerce.number()).optional().catch(void 0)
+    })
+  ).optional().catch(void 0),
   tags: z2.array(z2.string()).optional().catch(void 0),
   type: z2.string().optional().catch(void 0)
 });
@@ -238,15 +253,20 @@ var SmartCartComponent = z2.looseObject({
 var SmartCartConfig = z2.looseObject({
   components: z2.array(SmartCartComponent).optional()
 });
+var EngineSmartCart = z2.preprocess((value) => value === false ? null : value, SmartCartConfig.nullish());
 
 // src/schema/userConfig.ts
 var UserConfig = z3.object({
   shop: ShopConfig,
   /**
-   * `.catch(undefined)` is the safety bar: smart-cart shape drift can NEVER fail `fetchUserConfig`,
-   * which resolves the apiKey for every offers/monetize/analytics/gift request.
+   * Parsed like `CabUserConfig.smartCart`: the engine's `false` reads as `null` ({@link EngineSmartCart}), a
+   * drifted component loses only its own settings (`SmartCartComponent.settings` catches per component), and
+   * `.catch(undefined)` is the last safety bar so a wholly unreadable config can never fail the parse that
+   * resolves the shop's apiKey. It lands on `undefined`, not the `DRIFTED_SMART_CART` sentinel: no drift
+   * reporter reads this schema (the server parses `CabUserConfig`), and that sentinel's identity is not
+   * exported from `./schema`, so a consumer could not tell it apart from an empty config anyway.
    */
-  smartCart: SmartCartConfig.nullish().catch(void 0),
+  smartCart: EngineSmartCart.catch(void 0),
   smartFlows: z3.array(z3.unknown())
 });
 export {

package/dist/schema/userConfig.d.ts

@@ -78,7 +78,7 @@ export declare const UserConfig: z.ZodObject<{
         storefrontAccessToken: z.ZodNullable<z.ZodString>;
         useRebuyIcons: z.ZodBoolean;
     }, z.core.$strip>;
-    smartCart: z.ZodCatch<z.ZodOptional<z.ZodNullable<z.ZodObject<{
+    smartCart: z.ZodCatch<z.ZodPreprocess<z.ZodOptional<z.ZodNullable<z.ZodObject<{
         components: z.ZodOptional<z.ZodArray<z.ZodObject<{
             settings: z.ZodCatch<z.ZodPreprocess<z.ZodOptional<z.ZodObject<{
                 bars: z.ZodOptional<z.ZodArray<z.ZodObject<{
@@ -118,7 +118,10 @@ export declare const UserConfig: z.ZodObject<{
                         discountType: z.ZodOptional<z.ZodString>;
                         exclusions: z.ZodCatch<z.ZodOptional<z.ZodArray<z.ZodObject<{
                             collectionIds: z.ZodCatch<z.ZodOptional<z.ZodArray<z.ZodCoercedNumber<unknown>>>>;
-                            productIds: z.ZodCatch<z.ZodOptional<z.ZodArray<z.ZodCoercedNumber<unknown>>>>;
+                            products: z.ZodCatch<z.ZodOptional<z.ZodArray<z.ZodObject<{
+                                productId: z.ZodCatch<z.ZodOptional<z.ZodCoercedNumber<unknown>>>;
+                                variantIds: z.ZodCatch<z.ZodOptional<z.ZodArray<z.ZodCoercedNumber<unknown>>>>;
+                            }, z.core.$loose>>>>;
                             tags: z.ZodCatch<z.ZodOptional<z.ZodArray<z.ZodString>>>;
                             type: z.ZodCatch<z.ZodOptional<z.ZodString>>;
                         }, z.core.$loose>>>>;
@@ -149,7 +152,7 @@ export declare const UserConfig: z.ZodObject<{
             }, z.core.$loose>>>>;
             type: z.ZodOptional<z.ZodString>;
         }, z.core.$loose>>>;
-    }, z.core.$loose>>>>;
+    }, z.core.$loose>>>>>;
     smartFlows: z.ZodArray<z.ZodUnknown>;
 }, z.core.$strip>;
 export type UserConfig = z.infer<typeof UserConfig>;

package/dist/schema/widget-data.cjs

@@ -1138,7 +1138,17 @@ var GIFT_LABELS = {
 // src/schema/widgets/checkout-and-beyond/progressBar.ts
 var CABProgressTierExclusion = import_zod18.z.object({
   collectionIds: import_zod18.z.array(import_zod18.z.number().int().positive()).default(() => []),
-  productIds: import_zod18.z.array(import_zod18.z.number().int().positive()).default(() => []),
+  /**
+   * `products` rules: each excluded product with ITS OWN variants, mirroring the bar-level
+   * excluded products. An empty `variantIds` means "the whole product", which is how the admin
+   * picker stores a whole-product selection, and a populated one means those variants.
+   */
+  products: import_zod18.z.array(
+    import_zod18.z.object({
+      productId: import_zod18.z.number().int().positive(),
+      variantIds: import_zod18.z.array(import_zod18.z.number().int().positive()).default(() => [])
+    })
+  ).default(() => []),
   tags: import_zod18.z.array(import_zod18.z.string().min(1)).default(() => []),
   type: import_zod18.z.enum(progressTierExclusionTypes)
 });

package/dist/schema/widget-data.mjs

@@ -1113,7 +1113,17 @@ var GIFT_LABELS = {
 // src/schema/widgets/checkout-and-beyond/progressBar.ts
 var CABProgressTierExclusion = z18.object({
   collectionIds: z18.array(z18.number().int().positive()).default(() => []),
-  productIds: z18.array(z18.number().int().positive()).default(() => []),
+  /**
+   * `products` rules: each excluded product with ITS OWN variants, mirroring the bar-level
+   * excluded products. An empty `variantIds` means "the whole product", which is how the admin
+   * picker stores a whole-product selection, and a populated one means those variants.
+   */
+  products: z18.array(
+    z18.object({
+      productId: z18.number().int().positive(),
+      variantIds: z18.array(z18.number().int().positive()).default(() => [])
+    })
+  ).default(() => []),
   tags: z18.array(z18.string().min(1)).default(() => []),
   type: z18.enum(progressTierExclusionTypes)
 });

package/dist/schema/widgets/checkout-and-beyond/common.d.ts

@@ -235,8 +235,8 @@ export type ProgressTierUnit = (typeof progressTierUnits)[number];
 /** What a per-tier exclusion rule matches cart lines by (onsite `CartProgressBarTierExclusionType`). */
 export declare const progressTierExclusionTypes: readonly ["collections", "products", "tags"];
 export declare const ProgressTierExclusionType: {
-    readonly tags: "tags";
     readonly products: "products";
+    readonly tags: "tags";
     readonly collections: "collections";
 };
 export type ProgressTierExclusionType = (typeof progressTierExclusionTypes)[number];