@rebuy/rebuy 3.60.4 → 3.61.0

package/dist/index.cjs

@@ -1228,7 +1228,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)
 });
@@ -4124,7 +4139,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)
 });

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)
 });
@@ -3642,7 +3657,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)
 });

package/dist/schema/cabShopConfig.d.ts

@@ -138,7 +138,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>>>>;

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>>>>;
@@ -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>>>>;
@@ -312,4 +327,5 @@ export declare const SmartCartConfig: z.ZodObject<{
 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)
 });

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)
 });

package/dist/schema/userConfig.d.ts

@@ -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>>>>;

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];

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

@@ -5,16 +5,20 @@ import { type SectionDetails } from './shared';
  * One per-tier exclusion rule (onsite `getTierExclusionTotal`): cart lines matching the rule's `type` list
  * are subtracted from THIS tier's progress only, after the bar-level exclusions (gift lines, the exclusion
  * tag, `excludedVariantIds`) have already removed theirs — so a line is never double-counted. The client
- * resolves collections and tags per cart product from the Storefront API; `productIds` match the line's
- * product directly. Lists default empty so a rule always reads as "match nothing" rather than throwing.
+ * resolves collections and tags per cart product from the Storefront API; `products` match the line's
+ * product directly, narrowed to the entry's `variantIds` when it lists any. Lists default empty
+ * so a rule always reads as "match nothing" rather than throwing.
  */
 export declare const CABProgressTierExclusion: z.ZodObject<{
     collectionIds: z.ZodDefault<z.ZodArray<z.ZodNumber>>;
-    productIds: z.ZodDefault<z.ZodArray<z.ZodNumber>>;
+    products: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        productId: z.ZodNumber;
+        variantIds: z.ZodDefault<z.ZodArray<z.ZodNumber>>;
+    }, z.core.$strip>>>;
     tags: z.ZodDefault<z.ZodArray<z.ZodString>>;
     type: z.ZodEnum<{
-        tags: "tags";
         products: "products";
+        tags: "tags";
         collections: "collections";
     }>;
 }, z.core.$strip>;
@@ -29,11 +33,14 @@ export declare const CABProgressTier: z.ZodObject<{
     }, z.core.$strip>>;
     exclusions: z.ZodDefault<z.ZodArray<z.ZodObject<{
         collectionIds: z.ZodDefault<z.ZodArray<z.ZodNumber>>;
-        productIds: z.ZodDefault<z.ZodArray<z.ZodNumber>>;
+        products: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            productId: z.ZodNumber;
+            variantIds: z.ZodDefault<z.ZodArray<z.ZodNumber>>;
+        }, z.core.$strip>>>;
         tags: z.ZodDefault<z.ZodArray<z.ZodString>>;
         type: z.ZodEnum<{
-            tags: "tags";
             products: "products";
+            tags: "tags";
             collections: "collections";
         }>;
     }, z.core.$strip>>>;
@@ -373,11 +380,14 @@ export declare const CABProgressBarSection: z.ZodLazy<z.ZodObject<{
         }, z.core.$strip>>;
         exclusions: z.ZodDefault<z.ZodArray<z.ZodObject<{
             collectionIds: z.ZodDefault<z.ZodArray<z.ZodNumber>>;
-            productIds: z.ZodDefault<z.ZodArray<z.ZodNumber>>;
+            products: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                productId: z.ZodNumber;
+                variantIds: z.ZodDefault<z.ZodArray<z.ZodNumber>>;
+            }, z.core.$strip>>>;
             tags: z.ZodDefault<z.ZodArray<z.ZodString>>;
             type: z.ZodEnum<{
-                tags: "tags";
                 products: "products";
+                tags: "tags";
                 collections: "collections";
             }>;
         }, z.core.$strip>>>;

package/dist/server/index.cjs

@@ -1576,7 +1576,22 @@ var SmartCartTierProduct = import_zod19.z.looseObject({
 });
 var SmartCartTierExclusion = import_zod19.z.looseObject({
   collectionIds: import_zod19.z.array(import_zod19.z.coerce.number()).optional().catch(void 0),
-  productIds: import_zod19.z.array(import_zod19.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_zod19.z.array(
+    import_zod19.z.looseObject({
+      productId: import_zod19.z.coerce.number().optional().catch(void 0),
+      variantIds: import_zod19.z.array(import_zod19.z.coerce.number()).optional().catch(void 0)
+    })
+  ).optional().catch(void 0),
   tags: import_zod19.z.array(import_zod19.z.string()).optional().catch(void 0),
   type: import_zod19.z.string().optional().catch(void 0)
 });
@@ -2388,7 +2403,17 @@ var GIFT_LABELS = {
 // src/schema/widgets/checkout-and-beyond/progressBar.ts
 var CABProgressTierExclusion = import_zod33.z.object({
   collectionIds: import_zod33.z.array(import_zod33.z.number().int().positive()).default(() => []),
-  productIds: import_zod33.z.array(import_zod33.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_zod33.z.array(
+    import_zod33.z.object({
+      productId: import_zod33.z.number().int().positive(),
+      variantIds: import_zod33.z.array(import_zod33.z.number().int().positive()).default(() => [])
+    })
+  ).default(() => []),
   tags: import_zod33.z.array(import_zod33.z.string().min(1)).default(() => []),
   type: import_zod33.z.enum(progressTierExclusionTypes)
 });
@@ -3600,7 +3625,7 @@ var containsHtml = (text) => HTML_TAG_RE2.test(text);
 var isObject = (x) => x !== null && typeof x === "object" && !Array.isArray(x);
 var normalizeTextValue = (value, options2 = {}) => {
   const tokenized = normalizeTokens(value);
-  return containsHtml(tokenized) || options2.defaultTextStyle ? htmlToTiptap(tokenized, options2) : decodeTextEntities(tokenized);
+  return containsHtml(tokenized) || options2.defaultTextStyle || options2.blockSpacing ? htmlToTiptap(tokenized, options2) : decodeTextEntities(tokenized);
 };
 var normalizeLangValue = (value) => typeof value === "string" ? normalizeTextValue(value) : value;
 var normalizeTextContent = (node) => {
@@ -5325,13 +5350,21 @@ var giftOf = (tier) => {
     variantIds: positiveIds(product.variantIds)
   };
 };
-var RULE_LIST = { collections: "collectionIds", products: "productIds", tags: "tags" };
+var RULE_LIST = { collections: "collectionIds", products: "products", tags: "tags" };
+var exclusionProducts = (rule) => (rule.products ?? []).flatMap((entry) => {
+  const productId2 = entry.productId;
+  if (!Number.isInteger(productId2) || !productId2 || productId2 <= 0) return [];
+  const requested = entry.variantIds ?? [];
+  const variantIds = positiveIds(requested);
+  if (requested.length > 0 && variantIds.length === 0) return [];
+  return [{ productId: productId2, variantIds }];
+});
 var exclusionsOf = (tier) => {
   if (!tier.exclusionsEnabled) return void 0;
   const rules = (tier.exclusions ?? []).flatMap((rule) => {
     const parsed = CABProgressTierExclusion.safeParse({
       ...rule.type === "collections" && { collectionIds: positiveIds(rule.collectionIds) },
-      ...rule.type === "products" && { productIds: positiveIds(rule.productIds) },
+      ...rule.type === "products" && { products: exclusionProducts(rule) },
       ...rule.type === "tags" && { tags: (rule.tags ?? []).map((tag) => tag.trim()).filter(Boolean) },
       type: rule.type
     });
@@ -5844,7 +5877,7 @@ var label = (text) => ({
   content: { en: text },
   sectionType: SectionType.text
 });
-var AS_DOC = { defaultTextStyle: {} };
+var AS_DOC = { blockSpacing: Spacing.none, defaultTextStyle: {} };
 var safeTextValue = (raw, options2) => {
   const converted = normalizeTextValue(raw, options2);
   return checkForHTML(converted) ? converted : normalizeTextValue(htmlToPlainText(raw), options2);
@@ -5872,7 +5905,7 @@ var dspLabel = (raw, fallback) => ({
   sectionType: SectionType.text
 });
 var smallText = (raw) => ({
-  content: { en: safeTextValue(raw, { defaultTextStyle: { fontSize: "small" } }) },
+  content: { en: safeTextValue(raw, { blockSpacing: Spacing.none, defaultTextStyle: { fontSize: "small" } }) },
   sectionType: SectionType.text
 });
 var styled = (value, { align, bold, color, fontSize, href }) => ({

package/dist/server/index.mjs

@@ -1503,7 +1503,22 @@ var SmartCartTierProduct = z19.looseObject({
 });
 var SmartCartTierExclusion = z19.looseObject({
   collectionIds: z19.array(z19.coerce.number()).optional().catch(void 0),
-  productIds: z19.array(z19.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: z19.array(
+    z19.looseObject({
+      productId: z19.coerce.number().optional().catch(void 0),
+      variantIds: z19.array(z19.coerce.number()).optional().catch(void 0)
+    })
+  ).optional().catch(void 0),
   tags: z19.array(z19.string()).optional().catch(void 0),
   type: z19.string().optional().catch(void 0)
 });
@@ -2315,7 +2330,17 @@ var GIFT_LABELS = {
 // src/schema/widgets/checkout-and-beyond/progressBar.ts
 var CABProgressTierExclusion = z33.object({
   collectionIds: z33.array(z33.number().int().positive()).default(() => []),
-  productIds: z33.array(z33.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: z33.array(
+    z33.object({
+      productId: z33.number().int().positive(),
+      variantIds: z33.array(z33.number().int().positive()).default(() => [])
+    })
+  ).default(() => []),
   tags: z33.array(z33.string().min(1)).default(() => []),
   type: z33.enum(progressTierExclusionTypes)
 });
@@ -3527,7 +3552,7 @@ var containsHtml = (text) => HTML_TAG_RE2.test(text);
 var isObject = (x) => x !== null && typeof x === "object" && !Array.isArray(x);
 var normalizeTextValue = (value, options2 = {}) => {
   const tokenized = normalizeTokens(value);
-  return containsHtml(tokenized) || options2.defaultTextStyle ? htmlToTiptap(tokenized, options2) : decodeTextEntities(tokenized);
+  return containsHtml(tokenized) || options2.defaultTextStyle || options2.blockSpacing ? htmlToTiptap(tokenized, options2) : decodeTextEntities(tokenized);
 };
 var normalizeLangValue = (value) => typeof value === "string" ? normalizeTextValue(value) : value;
 var normalizeTextContent = (node) => {
@@ -5252,13 +5277,21 @@ var giftOf = (tier) => {
     variantIds: positiveIds(product.variantIds)
   };
 };
-var RULE_LIST = { collections: "collectionIds", products: "productIds", tags: "tags" };
+var RULE_LIST = { collections: "collectionIds", products: "products", tags: "tags" };
+var exclusionProducts = (rule) => (rule.products ?? []).flatMap((entry) => {
+  const productId2 = entry.productId;
+  if (!Number.isInteger(productId2) || !productId2 || productId2 <= 0) return [];
+  const requested = entry.variantIds ?? [];
+  const variantIds = positiveIds(requested);
+  if (requested.length > 0 && variantIds.length === 0) return [];
+  return [{ productId: productId2, variantIds }];
+});
 var exclusionsOf = (tier) => {
   if (!tier.exclusionsEnabled) return void 0;
   const rules = (tier.exclusions ?? []).flatMap((rule) => {
     const parsed = CABProgressTierExclusion.safeParse({
       ...rule.type === "collections" && { collectionIds: positiveIds(rule.collectionIds) },
-      ...rule.type === "products" && { productIds: positiveIds(rule.productIds) },
+      ...rule.type === "products" && { products: exclusionProducts(rule) },
       ...rule.type === "tags" && { tags: (rule.tags ?? []).map((tag) => tag.trim()).filter(Boolean) },
       type: rule.type
     });
@@ -5771,7 +5804,7 @@ var label = (text) => ({
   content: { en: text },
   sectionType: SectionType.text
 });
-var AS_DOC = { defaultTextStyle: {} };
+var AS_DOC = { blockSpacing: Spacing.none, defaultTextStyle: {} };
 var safeTextValue = (raw, options2) => {
   const converted = normalizeTextValue(raw, options2);
   return checkForHTML(converted) ? converted : normalizeTextValue(htmlToPlainText(raw), options2);
@@ -5799,7 +5832,7 @@ var dspLabel = (raw, fallback) => ({
   sectionType: SectionType.text
 });
 var smallText = (raw) => ({
-  content: { en: safeTextValue(raw, { defaultTextStyle: { fontSize: "small" } }) },
+  content: { en: safeTextValue(raw, { blockSpacing: Spacing.none, defaultTextStyle: { fontSize: "small" } }) },
   sectionType: SectionType.text
 });
 var styled = (value, { align, bold, color, fontSize, href }) => ({

package/dist/transforms/index.cjs

@@ -1146,7 +1146,17 @@ var GIFT_LABELS = {
 // src/schema/widgets/checkout-and-beyond/progressBar.ts
 var CABProgressTierExclusion = import_zod16.z.object({
   collectionIds: import_zod16.z.array(import_zod16.z.number().int().positive()).default(() => []),
-  productIds: import_zod16.z.array(import_zod16.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_zod16.z.array(
+    import_zod16.z.object({
+      productId: import_zod16.z.number().int().positive(),
+      variantIds: import_zod16.z.array(import_zod16.z.number().int().positive()).default(() => [])
+    })
+  ).default(() => []),
   tags: import_zod16.z.array(import_zod16.z.string().min(1)).default(() => []),
   type: import_zod16.z.enum(progressTierExclusionTypes)
 });
@@ -2358,7 +2368,7 @@ var containsHtml = (text) => HTML_TAG_RE2.test(text);
 var isObject = (x) => x !== null && typeof x === "object" && !Array.isArray(x);
 var normalizeTextValue = (value, options = {}) => {
   const tokenized = normalizeTokens(value);
-  return containsHtml(tokenized) || options.defaultTextStyle ? htmlToTiptap(tokenized, options) : decodeTextEntities(tokenized);
+  return containsHtml(tokenized) || options.defaultTextStyle || options.blockSpacing ? htmlToTiptap(tokenized, options) : decodeTextEntities(tokenized);
 };
 var normalizeLangValue = (value) => typeof value === "string" ? normalizeTextValue(value) : value;
 var normalizeTextContent = (node) => {
@@ -4875,13 +4885,21 @@ var giftOf = (tier) => {
     variantIds: positiveIds(product.variantIds)
   };
 };
-var RULE_LIST = { collections: "collectionIds", products: "productIds", tags: "tags" };
+var RULE_LIST = { collections: "collectionIds", products: "products", tags: "tags" };
+var exclusionProducts = (rule) => (rule.products ?? []).flatMap((entry) => {
+  const productId = entry.productId;
+  if (!Number.isInteger(productId) || !productId || productId <= 0) return [];
+  const requested = entry.variantIds ?? [];
+  const variantIds = positiveIds(requested);
+  if (requested.length > 0 && variantIds.length === 0) return [];
+  return [{ productId, variantIds }];
+});
 var exclusionsOf = (tier) => {
   if (!tier.exclusionsEnabled) return void 0;
   const rules = (tier.exclusions ?? []).flatMap((rule) => {
     const parsed = CABProgressTierExclusion.safeParse({
       ...rule.type === "collections" && { collectionIds: positiveIds(rule.collectionIds) },
-      ...rule.type === "products" && { productIds: positiveIds(rule.productIds) },
+      ...rule.type === "products" && { products: exclusionProducts(rule) },
       ...rule.type === "tags" && { tags: (rule.tags ?? []).map((tag) => tag.trim()).filter(Boolean) },
       type: rule.type
     });

package/dist/transforms/index.mjs

@@ -1085,7 +1085,17 @@ var GIFT_LABELS = {
 // src/schema/widgets/checkout-and-beyond/progressBar.ts
 var CABProgressTierExclusion = z16.object({
   collectionIds: z16.array(z16.number().int().positive()).default(() => []),
-  productIds: z16.array(z16.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: z16.array(
+    z16.object({
+      productId: z16.number().int().positive(),
+      variantIds: z16.array(z16.number().int().positive()).default(() => [])
+    })
+  ).default(() => []),
   tags: z16.array(z16.string().min(1)).default(() => []),
   type: z16.enum(progressTierExclusionTypes)
 });
@@ -2297,7 +2307,7 @@ var containsHtml = (text) => HTML_TAG_RE2.test(text);
 var isObject = (x) => x !== null && typeof x === "object" && !Array.isArray(x);
 var normalizeTextValue = (value, options = {}) => {
   const tokenized = normalizeTokens(value);
-  return containsHtml(tokenized) || options.defaultTextStyle ? htmlToTiptap(tokenized, options) : decodeTextEntities(tokenized);
+  return containsHtml(tokenized) || options.defaultTextStyle || options.blockSpacing ? htmlToTiptap(tokenized, options) : decodeTextEntities(tokenized);
 };
 var normalizeLangValue = (value) => typeof value === "string" ? normalizeTextValue(value) : value;
 var normalizeTextContent = (node) => {
@@ -4814,13 +4824,21 @@ var giftOf = (tier) => {
     variantIds: positiveIds(product.variantIds)
   };
 };
-var RULE_LIST = { collections: "collectionIds", products: "productIds", tags: "tags" };
+var RULE_LIST = { collections: "collectionIds", products: "products", tags: "tags" };
+var exclusionProducts = (rule) => (rule.products ?? []).flatMap((entry) => {
+  const productId = entry.productId;
+  if (!Number.isInteger(productId) || !productId || productId <= 0) return [];
+  const requested = entry.variantIds ?? [];
+  const variantIds = positiveIds(requested);
+  if (requested.length > 0 && variantIds.length === 0) return [];
+  return [{ productId, variantIds }];
+});
 var exclusionsOf = (tier) => {
   if (!tier.exclusionsEnabled) return void 0;
   const rules = (tier.exclusions ?? []).flatMap((rule) => {
     const parsed = CABProgressTierExclusion.safeParse({
       ...rule.type === "collections" && { collectionIds: positiveIds(rule.collectionIds) },
-      ...rule.type === "products" && { productIds: positiveIds(rule.productIds) },
+      ...rule.type === "products" && { products: exclusionProducts(rule) },
       ...rule.type === "tags" && { tags: (rule.tags ?? []).map((tag) => tag.trim()).filter(Boolean) },
       type: rule.type
     });

package/dist/transforms/normalizeTextContent.d.ts

@@ -1,6 +1,6 @@
 import { type TiptapDocument } from '../schema/widgets/checkout-and-beyond/text';
 import { type HtmlToTiptapOptions } from '../transforms/htmlToTiptap/htmlToTiptap';
-export type NormalizeTextOptions = Pick<HtmlToTiptapOptions, 'defaultTextStyle'>;
+export type NormalizeTextOptions = Pick<HtmlToTiptapOptions, 'blockSpacing' | 'defaultTextStyle'>;
 /**
  * THE text pipeline for one content value — the single path every text a CAB tree renders takes,
  * whether it is merchant-authored, converted from a legacy widget, or third-party ad creative:
@@ -16,7 +16,8 @@ export type NormalizeTextOptions = Pick<HtmlToTiptapOptions, 'defaultTextStyle'>
  *
  * `defaultTextStyle` is the server-side analogue of React's `defaultTextStyle` prop: the doc's runs
  * carry that `textStyle` unless the markup set their own. A default forces plain text through the
- * converter too, since only a doc can carry a mark.
+ * converter too, since only a doc can carry a mark. `blockSpacing` does the same, since only a doc
+ * carries it (REB-25181).
  *
  * NOT idempotent for entity-bearing strings (`&amp;amp;` → `&amp;` → `&`), by nature of decoding.
  * That is safe because this runs at SERVE time on the stored original and its output is returned,

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@rebuy/rebuy",
-    "version": "3.60.4",
+    "version": "3.61.0",
     "description": "Shared zod schemas, legacy-to-CAB widget transforms, and server orchestrators for Rebuy's Shopify consumers (rebuy-api, admin-nextjs, rebuy-shopify-extensions)",
     "license": "MIT",
     "author": "Rebuy, Inc.",