@rebuy/rebuy 3.19.0 → 3.20.0

package/dist/index.cjs

@@ -54,6 +54,7 @@ __export(src_exports, {
   CABProductsSection: () => CABProductsSection,
   CABProgressBarSection: () => CABProgressBarSection,
   CABProgressTier: () => CABProgressTier,
+  CABProgressTierExclusion: () => CABProgressTierExclusion,
   CABQuantitySection: () => CABQuantitySection,
   CABResultCountTrigger: () => CABResultCountTrigger,
   CABResultTagTrigger: () => CABResultTagTrigger,
@@ -127,6 +128,7 @@ __export(src_exports, {
   ProductInformationBlock: () => ProductInformationBlock,
   ProductType: () => ProductType,
   ProgressBar: () => ProgressBar,
+  ProgressTierExclusionType: () => ProgressTierExclusionType,
   ProgressTierType: () => ProgressTierType,
   ProgressTierUnit: () => ProgressTierUnit,
   QuantityInput: () => QuantityInput,
@@ -156,6 +158,7 @@ __export(src_exports, {
   SmartCartComponent: () => SmartCartComponent,
   SmartCartConfig: () => SmartCartConfig,
   SmartCartTier: () => SmartCartTier,
+  SmartCartTierExclusion: () => SmartCartTierExclusion,
   SmartCartTierProduct: () => SmartCartTierProduct,
   Spacing: () => Spacing,
   TextAlignment: () => TextAlignment,
@@ -248,6 +251,7 @@ __export(src_exports, {
   popoverPositions: () => popoverPositions,
   productImageObject: () => productImageObject,
   productTypes: () => productTypes,
+  progressTierExclusionTypes: () => progressTierExclusionTypes,
   progressTierTypes: () => progressTierTypes,
   progressTierUnits: () => progressTierUnits,
   quantityInputs: () => quantityInputs,
@@ -1025,6 +1029,12 @@ var SmartCartTierProduct = import_zod.z.looseObject({
   title: import_zod.z.string().optional(),
   variantIds: import_zod.z.array(import_zod.z.coerce.number()).optional()
 });
+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),
+  tags: import_zod.z.array(import_zod.z.string()).optional().catch(void 0),
+  type: import_zod.z.string().optional().catch(void 0)
+});
 var SmartCartTier = import_zod.z.looseObject({
   allProducts: import_zod.z.array(SmartCartTierProduct).optional(),
   /** Merchant-set tier label (e.g. "Free gift", "$100 reward"), shown on the step row when enabled. */
@@ -1041,6 +1051,19 @@ var SmartCartTier = import_zod.z.looseObject({
   discountAmountRemainingLabel: import_zod.z.boolean().optional(),
   discountAmountRemainingLabelText: import_zod.z.string().optional(),
   discountType: import_zod.z.string().optional(),
+  /**
+   * onsite `exclusions` + `exclusions_enabled` (REB-22305): per-tier rules the converter carries onto
+   * `CABProgressTier.exclusions`. `.catch(undefined)` for the same blast-radius reason as `productTierImage`:
+   * one drifted value must degrade to "no tier exclusions", never drop every progress bar for the shop.
+   *
+   * `exclusionsEnabled` is a STRICT boolean on purpose, even though failing open here changes the tier's math
+   * (a non-boolean reads as disabled) rather than just an icon. onsite reads its sibling tier flags strictly —
+   * `shouldFilterOutOfStockVariantsFromTier` is `tier?.filter_oos_variants === true`, and its `progressBar.ts`
+   * types every tier flag as `boolean` — so a stored `1` / `"1"` / `"true"` is "disabled" on the onsite bar too.
+   * A truthiness preprocess would make CAB exclude where onsite does not: the opposite parity break.
+   */
+  exclusions: import_zod.z.array(SmartCartTierExclusion).optional().catch(void 0),
+  exclusionsEnabled: import_zod.z.boolean().optional().catch(void 0),
   filterOosVariants: import_zod.z.boolean().optional(),
   id: import_zod.z.string().optional(),
   /**
@@ -1750,6 +1773,8 @@ var progressTierTypes = ["decorative", "discount", "product", "shipping"];
 var ProgressTierType = freezeEnum(progressTierTypes);
 var progressTierUnits = ["currency", "item"];
 var ProgressTierUnit = freezeEnum(progressTierUnits);
+var progressTierExclusionTypes = ["collections", "products", "tags"];
+var ProgressTierExclusionType = freezeEnum(progressTierExclusionTypes);
 var quantityInputs = ["select", "number"];
 var QuantityInput = freezeEnum(quantityInputs);
 var resultCountOperators = ["equals", "greater_than", "less_than"];
@@ -2721,6 +2746,12 @@ var GIFT_LABELS = {
 };
 
 // src/schema/widgets/checkout-and-beyond/progressBar.ts
+var CABProgressTierExclusion = import_zod24.z.object({
+  collectionIds: import_zod24.z.array(import_zod24.z.number().int().positive()).default(() => []),
+  productIds: import_zod24.z.array(import_zod24.z.number().int().positive()).default(() => []),
+  tags: import_zod24.z.array(import_zod24.z.string().min(1)).default(() => []),
+  type: import_zod24.z.enum(progressTierExclusionTypes)
+});
 var CABProgressTier = import_zod24.z.object({
   /**
    * Order-discount tiers only (onsite `discount`): the reward the order-discount Function applies at
@@ -2729,6 +2760,13 @@ var CABProgressTier = import_zod24.z.object({
    * `percentage`: the whole-percent number rendered raw (`{n}%`). Absent on non-discount tiers.
    */
   discount: import_zod24.z.object({ amount: import_zod24.z.number().nonnegative(), type: import_zod24.z.enum(["fixedAmount", "percentage"]) }).optional(),
+  /**
+   * Per-tier exclusion rules (onsite `exclusions` when `exclusions_enabled`): lines they match don't count
+   * toward this tier. Empty (the default, and the converter's output for a disabled or ruleless tier) means
+   * the tier measures the plain bar-level adjusted progress. Consumers read ONLY the list named by the rule's
+   * `type` — the converter leaves the other two at `[]`, so a populated off-type list never reaches the tree.
+   */
+  exclusions: import_zod24.z.array(CABProgressTierExclusion).default(() => []),
   /**
    * Smart-cart product (gift) tiers only (onsite `filter_oos_variants`): when set, the client drops this
    * tier entirely once its gift has NO in-stock eligible variant — the milestone, fill slot and gift

package/dist/index.mjs

@@ -739,6 +739,12 @@ var SmartCartTierProduct = z.looseObject({
   title: z.string().optional(),
   variantIds: z.array(z.coerce.number()).optional()
 });
+var SmartCartTierExclusion = z.looseObject({
+  collectionIds: z.array(z.coerce.number()).optional().catch(void 0),
+  productIds: z.array(z.coerce.number()).optional().catch(void 0),
+  tags: z.array(z.string()).optional().catch(void 0),
+  type: z.string().optional().catch(void 0)
+});
 var SmartCartTier = z.looseObject({
   allProducts: z.array(SmartCartTierProduct).optional(),
   /** Merchant-set tier label (e.g. "Free gift", "$100 reward"), shown on the step row when enabled. */
@@ -755,6 +761,19 @@ var SmartCartTier = z.looseObject({
   discountAmountRemainingLabel: z.boolean().optional(),
   discountAmountRemainingLabelText: z.string().optional(),
   discountType: z.string().optional(),
+  /**
+   * onsite `exclusions` + `exclusions_enabled` (REB-22305): per-tier rules the converter carries onto
+   * `CABProgressTier.exclusions`. `.catch(undefined)` for the same blast-radius reason as `productTierImage`:
+   * one drifted value must degrade to "no tier exclusions", never drop every progress bar for the shop.
+   *
+   * `exclusionsEnabled` is a STRICT boolean on purpose, even though failing open here changes the tier's math
+   * (a non-boolean reads as disabled) rather than just an icon. onsite reads its sibling tier flags strictly —
+   * `shouldFilterOutOfStockVariantsFromTier` is `tier?.filter_oos_variants === true`, and its `progressBar.ts`
+   * types every tier flag as `boolean` — so a stored `1` / `"1"` / `"true"` is "disabled" on the onsite bar too.
+   * A truthiness preprocess would make CAB exclude where onsite does not: the opposite parity break.
+   */
+  exclusions: z.array(SmartCartTierExclusion).optional().catch(void 0),
+  exclusionsEnabled: z.boolean().optional().catch(void 0),
   filterOosVariants: z.boolean().optional(),
   id: z.string().optional(),
   /**
@@ -1464,6 +1483,8 @@ var progressTierTypes = ["decorative", "discount", "product", "shipping"];
 var ProgressTierType = freezeEnum(progressTierTypes);
 var progressTierUnits = ["currency", "item"];
 var ProgressTierUnit = freezeEnum(progressTierUnits);
+var progressTierExclusionTypes = ["collections", "products", "tags"];
+var ProgressTierExclusionType = freezeEnum(progressTierExclusionTypes);
 var quantityInputs = ["select", "number"];
 var QuantityInput = freezeEnum(quantityInputs);
 var resultCountOperators = ["equals", "greater_than", "less_than"];
@@ -2435,6 +2456,12 @@ var GIFT_LABELS = {
 };
 
 // src/schema/widgets/checkout-and-beyond/progressBar.ts
+var CABProgressTierExclusion = z24.object({
+  collectionIds: z24.array(z24.number().int().positive()).default(() => []),
+  productIds: z24.array(z24.number().int().positive()).default(() => []),
+  tags: z24.array(z24.string().min(1)).default(() => []),
+  type: z24.enum(progressTierExclusionTypes)
+});
 var CABProgressTier = z24.object({
   /**
    * Order-discount tiers only (onsite `discount`): the reward the order-discount Function applies at
@@ -2443,6 +2470,13 @@ var CABProgressTier = z24.object({
    * `percentage`: the whole-percent number rendered raw (`{n}%`). Absent on non-discount tiers.
    */
   discount: z24.object({ amount: z24.number().nonnegative(), type: z24.enum(["fixedAmount", "percentage"]) }).optional(),
+  /**
+   * Per-tier exclusion rules (onsite `exclusions` when `exclusions_enabled`): lines they match don't count
+   * toward this tier. Empty (the default, and the converter's output for a disabled or ruleless tier) means
+   * the tier measures the plain bar-level adjusted progress. Consumers read ONLY the list named by the rule's
+   * `type` — the converter leaves the other two at `[]`, so a populated off-type list never reaches the tree.
+   */
+  exclusions: z24.array(CABProgressTierExclusion).default(() => []),
   /**
    * Smart-cart product (gift) tiers only (onsite `filter_oos_variants`): when set, the client drops this
    * tier entirely once its gift has NO in-stock eligible variant — the milestone, fill slot and gift
@@ -4705,6 +4739,7 @@ export {
   CABProductsSection,
   CABProgressBarSection,
   CABProgressTier,
+  CABProgressTierExclusion,
   CABQuantitySection,
   CABResultCountTrigger,
   CABResultTagTrigger,
@@ -4778,6 +4813,7 @@ export {
   ProductInformationBlock,
   ProductType,
   ProgressBar,
+  ProgressTierExclusionType,
   ProgressTierType,
   ProgressTierUnit,
   QuantityInput,
@@ -4807,6 +4843,7 @@ export {
   SmartCartComponent,
   SmartCartConfig,
   SmartCartTier,
+  SmartCartTierExclusion,
   SmartCartTierProduct,
   Spacing,
   TextAlignment,
@@ -4899,6 +4936,7 @@ export {
   popoverPositions,
   productImageObject,
   productTypes,
+  progressTierExclusionTypes,
   progressTierTypes,
   progressTierUnits,
   quantityInputs,

package/dist/schema/cabShopConfig.d.ts

@@ -131,6 +131,13 @@ export declare const CabUserConfig: z.ZodObject<{
                         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>>>>;
+                            productIds: z.ZodCatch<z.ZodOptional<z.ZodArray<z.ZodCoercedNumber<unknown>>>>;
+                            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>>>;

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

@@ -39,6 +39,7 @@ __export(common_exports, {
   OffersDirection: () => OffersDirection,
   PopoverPosition: () => PopoverPosition,
   ProductType: () => ProductType,
+  ProgressTierExclusionType: () => ProgressTierExclusionType,
   ProgressTierType: () => ProgressTierType,
   ProgressTierUnit: () => ProgressTierUnit,
   QuantityInput: () => QuantityInput,
@@ -77,6 +78,7 @@ __export(common_exports, {
   popoverPositionMap: () => popoverPositionMap,
   popoverPositions: () => popoverPositions,
   productTypes: () => productTypes,
+  progressTierExclusionTypes: () => progressTierExclusionTypes,
   progressTierTypes: () => progressTierTypes,
   progressTierUnits: () => progressTierUnits,
   quantityInputs: () => quantityInputs,
@@ -218,6 +220,8 @@ var progressTierTypes = ["decorative", "discount", "product", "shipping"];
 var ProgressTierType = freezeEnum(progressTierTypes);
 var progressTierUnits = ["currency", "item"];
 var ProgressTierUnit = freezeEnum(progressTierUnits);
+var progressTierExclusionTypes = ["collections", "products", "tags"];
+var ProgressTierExclusionType = freezeEnum(progressTierExclusionTypes);
 var quantityInputs = ["select", "number"];
 var QuantityInput = freezeEnum(quantityInputs);
 var resultCountOperators = ["equals", "greater_than", "less_than"];

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

@@ -121,6 +121,8 @@ var progressTierTypes = ["decorative", "discount", "product", "shipping"];
 var ProgressTierType = freezeEnum(progressTierTypes);
 var progressTierUnits = ["currency", "item"];
 var ProgressTierUnit = freezeEnum(progressTierUnits);
+var progressTierExclusionTypes = ["collections", "products", "tags"];
+var ProgressTierExclusionType = freezeEnum(progressTierExclusionTypes);
 var quantityInputs = ["select", "number"];
 var QuantityInput = freezeEnum(quantityInputs);
 var resultCountOperators = ["equals", "greater_than", "less_than"];
@@ -216,6 +218,7 @@ export {
   OffersDirection,
   PopoverPosition,
   ProductType,
+  ProgressTierExclusionType,
   ProgressTierType,
   ProgressTierUnit,
   QuantityInput,
@@ -254,6 +257,7 @@ export {
   popoverPositionMap,
   popoverPositions,
   productTypes,
+  progressTierExclusionTypes,
   progressTierTypes,
   progressTierUnits,
   quantityInputs,

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

@@ -51,6 +51,7 @@ __export(checkout_and_beyond_exports, {
   CABProductsSection: () => CABProductsSection,
   CABProgressBarSection: () => CABProgressBarSection,
   CABProgressTier: () => CABProgressTier,
+  CABProgressTierExclusion: () => CABProgressTierExclusion,
   CABQuantitySection: () => CABQuantitySection,
   CABResultCountTrigger: () => CABResultCountTrigger,
   CABResultTagTrigger: () => CABResultTagTrigger,
@@ -97,6 +98,7 @@ __export(checkout_and_beyond_exports, {
   OffersDirection: () => OffersDirection,
   PopoverPosition: () => PopoverPosition,
   ProductType: () => ProductType,
+  ProgressTierExclusionType: () => ProgressTierExclusionType,
   ProgressTierType: () => ProgressTierType,
   ProgressTierUnit: () => ProgressTierUnit,
   QuantityInput: () => QuantityInput,
@@ -172,6 +174,7 @@ __export(checkout_and_beyond_exports, {
   popoverPositionMap: () => popoverPositionMap,
   popoverPositions: () => popoverPositions,
   productTypes: () => productTypes,
+  progressTierExclusionTypes: () => progressTierExclusionTypes,
   progressTierTypes: () => progressTierTypes,
   progressTierUnits: () => progressTierUnits,
   quantityInputs: () => quantityInputs,
@@ -321,6 +324,8 @@ var progressTierTypes = ["decorative", "discount", "product", "shipping"];
 var ProgressTierType = freezeEnum(progressTierTypes);
 var progressTierUnits = ["currency", "item"];
 var ProgressTierUnit = freezeEnum(progressTierUnits);
+var progressTierExclusionTypes = ["collections", "products", "tags"];
+var ProgressTierExclusionType = freezeEnum(progressTierExclusionTypes);
 var quantityInputs = ["select", "number"];
 var QuantityInput = freezeEnum(quantityInputs);
 var resultCountOperators = ["equals", "greater_than", "less_than"];
@@ -1254,6 +1259,12 @@ var GIFT_LABELS = {
 };
 
 // src/schema/widgets/checkout-and-beyond/progressBar.ts
+var CABProgressTierExclusion = import_zod14.z.object({
+  collectionIds: import_zod14.z.array(import_zod14.z.number().int().positive()).default(() => []),
+  productIds: import_zod14.z.array(import_zod14.z.number().int().positive()).default(() => []),
+  tags: import_zod14.z.array(import_zod14.z.string().min(1)).default(() => []),
+  type: import_zod14.z.enum(progressTierExclusionTypes)
+});
 var CABProgressTier = import_zod14.z.object({
   /**
    * Order-discount tiers only (onsite `discount`): the reward the order-discount Function applies at
@@ -1262,6 +1273,13 @@ var CABProgressTier = import_zod14.z.object({
    * `percentage`: the whole-percent number rendered raw (`{n}%`). Absent on non-discount tiers.
    */
   discount: import_zod14.z.object({ amount: import_zod14.z.number().nonnegative(), type: import_zod14.z.enum(["fixedAmount", "percentage"]) }).optional(),
+  /**
+   * Per-tier exclusion rules (onsite `exclusions` when `exclusions_enabled`): lines they match don't count
+   * toward this tier. Empty (the default, and the converter's output for a disabled or ruleless tier) means
+   * the tier measures the plain bar-level adjusted progress. Consumers read ONLY the list named by the rule's
+   * `type` — the converter leaves the other two at `[]`, so a populated off-type list never reaches the tree.
+   */
+  exclusions: import_zod14.z.array(CABProgressTierExclusion).default(() => []),
   /**
    * Smart-cart product (gift) tiers only (onsite `filter_oos_variants`): when set, the client drops this
    * tier entirely once its gift has NO in-stock eligible variant — the milestone, fill slot and gift

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

@@ -124,6 +124,8 @@ var progressTierTypes = ["decorative", "discount", "product", "shipping"];
 var ProgressTierType = freezeEnum(progressTierTypes);
 var progressTierUnits = ["currency", "item"];
 var ProgressTierUnit = freezeEnum(progressTierUnits);
+var progressTierExclusionTypes = ["collections", "products", "tags"];
+var ProgressTierExclusionType = freezeEnum(progressTierExclusionTypes);
 var quantityInputs = ["select", "number"];
 var QuantityInput = freezeEnum(quantityInputs);
 var resultCountOperators = ["equals", "greater_than", "less_than"];
@@ -1057,6 +1059,12 @@ var GIFT_LABELS = {
 };
 
 // src/schema/widgets/checkout-and-beyond/progressBar.ts
+var CABProgressTierExclusion = z14.object({
+  collectionIds: z14.array(z14.number().int().positive()).default(() => []),
+  productIds: z14.array(z14.number().int().positive()).default(() => []),
+  tags: z14.array(z14.string().min(1)).default(() => []),
+  type: z14.enum(progressTierExclusionTypes)
+});
 var CABProgressTier = z14.object({
   /**
    * Order-discount tiers only (onsite `discount`): the reward the order-discount Function applies at
@@ -1065,6 +1073,13 @@ var CABProgressTier = z14.object({
    * `percentage`: the whole-percent number rendered raw (`{n}%`). Absent on non-discount tiers.
    */
   discount: z14.object({ amount: z14.number().nonnegative(), type: z14.enum(["fixedAmount", "percentage"]) }).optional(),
+  /**
+   * Per-tier exclusion rules (onsite `exclusions` when `exclusions_enabled`): lines they match don't count
+   * toward this tier. Empty (the default, and the converter's output for a disabled or ruleless tier) means
+   * the tier measures the plain bar-level adjusted progress. Consumers read ONLY the list named by the rule's
+   * `type` — the converter leaves the other two at `[]`, so a populated off-type list never reaches the tree.
+   */
+  exclusions: z14.array(CABProgressTierExclusion).default(() => []),
   /**
    * Smart-cart product (gift) tiers only (onsite `filter_oos_variants`): when set, the client drops this
    * tier entirely once its gift has NO in-stock eligible variant — the milestone, fill slot and gift
@@ -1859,6 +1874,7 @@ export {
   CABProductsSection,
   CABProgressBarSection,
   CABProgressTier,
+  CABProgressTierExclusion,
   CABQuantitySection,
   CABResultCountTrigger,
   CABResultTagTrigger,
@@ -1905,6 +1921,7 @@ export {
   OffersDirection,
   PopoverPosition,
   ProductType,
+  ProgressTierExclusionType,
   ProgressTierType,
   ProgressTierUnit,
   QuantityInput,
@@ -1980,6 +1997,7 @@ export {
   popoverPositionMap,
   popoverPositions,
   productTypes,
+  progressTierExclusionTypes,
   progressTierTypes,
   progressTierUnits,
   quantityInputs,

package/dist/schema/smartCart.d.ts

@@ -10,6 +10,23 @@ export declare const SmartCartTierProduct: z.ZodObject<{
     title: z.ZodOptional<z.ZodString>;
     variantIds: z.ZodOptional<z.ZodArray<z.ZodCoercedNumber<unknown>>>;
 }, z.core.$loose>;
+/**
+ * onsite `exclusions[]` entry on a tier (REB-22305): products, collections or tags whose cart lines do NOT count
+ * toward that tier's progress. Loose and coerced like the rest of the config; the converter validates `type`
+ * and drops junk ids, so a malformed rule degrades to "matches nothing" rather than failing the tier.
+ *
+ * `.catch(undefined)` sits on EACH field, not on the rule or the array: `SmartCartTier.exclusions` catches at
+ * the array level, so without these a single drifted field (a bare `tags: 'sale'`, a `gid://` collection id
+ * that coerces to `NaN`) would fail its element, fail the array, and silently drop every rule on the tier.
+ * Per-field, the bad list reads as absent, the converter drops just that rule (empty matching list), and the
+ * tier's other rules still apply.
+ */
+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>>>>;
+    tags: z.ZodCatch<z.ZodOptional<z.ZodArray<z.ZodString>>>;
+    type: z.ZodCatch<z.ZodOptional<z.ZodString>>;
+}, z.core.$loose>;
 /**
  * One reward tier on a smart-cart tiered progress bar. `type` is `product` (gift), `shipping`,
  * `discount` (order discount applied by the order-discount Function, keyed by `_barId`) or
@@ -42,6 +59,13 @@ export declare const SmartCartTier: z.ZodObject<{
     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>>>>;
+        productIds: z.ZodCatch<z.ZodOptional<z.ZodArray<z.ZodCoercedNumber<unknown>>>>;
+        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>>>;
@@ -104,6 +128,13 @@ export declare const SmartCartBar: z.ZodObject<{
         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>>>>;
+            productIds: z.ZodCatch<z.ZodOptional<z.ZodArray<z.ZodCoercedNumber<unknown>>>>;
+            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>>>;
@@ -165,6 +196,13 @@ export declare const SmartCartComponent: z.ZodObject<{
                 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>>>>;
+                    productIds: z.ZodCatch<z.ZodOptional<z.ZodArray<z.ZodCoercedNumber<unknown>>>>;
+                    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>>>;
@@ -237,6 +275,13 @@ export declare const SmartCartConfig: z.ZodObject<{
                     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>>>>;
+                        productIds: z.ZodCatch<z.ZodOptional<z.ZodArray<z.ZodCoercedNumber<unknown>>>>;
+                        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>>>;

package/dist/schema/user-config.cjs

@@ -118,6 +118,12 @@ var SmartCartTierProduct = import_zod2.z.looseObject({
   title: import_zod2.z.string().optional(),
   variantIds: import_zod2.z.array(import_zod2.z.coerce.number()).optional()
 });
+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),
+  tags: import_zod2.z.array(import_zod2.z.string()).optional().catch(void 0),
+  type: import_zod2.z.string().optional().catch(void 0)
+});
 var SmartCartTier = import_zod2.z.looseObject({
   allProducts: import_zod2.z.array(SmartCartTierProduct).optional(),
   /** Merchant-set tier label (e.g. "Free gift", "$100 reward"), shown on the step row when enabled. */
@@ -134,6 +140,19 @@ var SmartCartTier = import_zod2.z.looseObject({
   discountAmountRemainingLabel: import_zod2.z.boolean().optional(),
   discountAmountRemainingLabelText: import_zod2.z.string().optional(),
   discountType: import_zod2.z.string().optional(),
+  /**
+   * onsite `exclusions` + `exclusions_enabled` (REB-22305): per-tier rules the converter carries onto
+   * `CABProgressTier.exclusions`. `.catch(undefined)` for the same blast-radius reason as `productTierImage`:
+   * one drifted value must degrade to "no tier exclusions", never drop every progress bar for the shop.
+   *
+   * `exclusionsEnabled` is a STRICT boolean on purpose, even though failing open here changes the tier's math
+   * (a non-boolean reads as disabled) rather than just an icon. onsite reads its sibling tier flags strictly —
+   * `shouldFilterOutOfStockVariantsFromTier` is `tier?.filter_oos_variants === true`, and its `progressBar.ts`
+   * types every tier flag as `boolean` — so a stored `1` / `"1"` / `"true"` is "disabled" on the onsite bar too.
+   * A truthiness preprocess would make CAB exclude where onsite does not: the opposite parity break.
+   */
+  exclusions: import_zod2.z.array(SmartCartTierExclusion).optional().catch(void 0),
+  exclusionsEnabled: import_zod2.z.boolean().optional().catch(void 0),
   filterOosVariants: import_zod2.z.boolean().optional(),
   id: import_zod2.z.string().optional(),
   /**

package/dist/schema/user-config.mjs

@@ -94,6 +94,12 @@ var SmartCartTierProduct = z2.looseObject({
   title: z2.string().optional(),
   variantIds: z2.array(z2.coerce.number()).optional()
 });
+var SmartCartTierExclusion = z2.looseObject({
+  collectionIds: z2.array(z2.coerce.number()).optional().catch(void 0),
+  productIds: z2.array(z2.coerce.number()).optional().catch(void 0),
+  tags: z2.array(z2.string()).optional().catch(void 0),
+  type: z2.string().optional().catch(void 0)
+});
 var SmartCartTier = z2.looseObject({
   allProducts: z2.array(SmartCartTierProduct).optional(),
   /** Merchant-set tier label (e.g. "Free gift", "$100 reward"), shown on the step row when enabled. */
@@ -110,6 +116,19 @@ var SmartCartTier = z2.looseObject({
   discountAmountRemainingLabel: z2.boolean().optional(),
   discountAmountRemainingLabelText: z2.string().optional(),
   discountType: z2.string().optional(),
+  /**
+   * onsite `exclusions` + `exclusions_enabled` (REB-22305): per-tier rules the converter carries onto
+   * `CABProgressTier.exclusions`. `.catch(undefined)` for the same blast-radius reason as `productTierImage`:
+   * one drifted value must degrade to "no tier exclusions", never drop every progress bar for the shop.
+   *
+   * `exclusionsEnabled` is a STRICT boolean on purpose, even though failing open here changes the tier's math
+   * (a non-boolean reads as disabled) rather than just an icon. onsite reads its sibling tier flags strictly —
+   * `shouldFilterOutOfStockVariantsFromTier` is `tier?.filter_oos_variants === true`, and its `progressBar.ts`
+   * types every tier flag as `boolean` — so a stored `1` / `"1"` / `"true"` is "disabled" on the onsite bar too.
+   * A truthiness preprocess would make CAB exclude where onsite does not: the opposite parity break.
+   */
+  exclusions: z2.array(SmartCartTierExclusion).optional().catch(void 0),
+  exclusionsEnabled: z2.boolean().optional().catch(void 0),
   filterOosVariants: z2.boolean().optional(),
   id: z2.string().optional(),
   /**

package/dist/schema/userConfig.d.ts

@@ -116,6 +116,13 @@ export declare const UserConfig: z.ZodObject<{
                         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>>>>;
+                            productIds: z.ZodCatch<z.ZodOptional<z.ZodArray<z.ZodCoercedNumber<unknown>>>>;
+                            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>>>;

package/dist/schema/widget-data.cjs

@@ -152,6 +152,8 @@ var progressTierTypes = ["decorative", "discount", "product", "shipping"];
 var ProgressTierType = freezeEnum(progressTierTypes);
 var progressTierUnits = ["currency", "item"];
 var ProgressTierUnit = freezeEnum(progressTierUnits);
+var progressTierExclusionTypes = ["collections", "products", "tags"];
+var ProgressTierExclusionType = freezeEnum(progressTierExclusionTypes);
 var quantityInputs = ["select", "number"];
 var QuantityInput = freezeEnum(quantityInputs);
 var resultCountOperators = ["equals", "greater_than", "less_than"];
@@ -1095,6 +1097,12 @@ var GIFT_LABELS = {
 };
 
 // src/schema/widgets/checkout-and-beyond/progressBar.ts
+var CABProgressTierExclusion = import_zod17.z.object({
+  collectionIds: import_zod17.z.array(import_zod17.z.number().int().positive()).default(() => []),
+  productIds: import_zod17.z.array(import_zod17.z.number().int().positive()).default(() => []),
+  tags: import_zod17.z.array(import_zod17.z.string().min(1)).default(() => []),
+  type: import_zod17.z.enum(progressTierExclusionTypes)
+});
 var CABProgressTier = import_zod17.z.object({
   /**
    * Order-discount tiers only (onsite `discount`): the reward the order-discount Function applies at
@@ -1103,6 +1111,13 @@ var CABProgressTier = import_zod17.z.object({
    * `percentage`: the whole-percent number rendered raw (`{n}%`). Absent on non-discount tiers.
    */
   discount: import_zod17.z.object({ amount: import_zod17.z.number().nonnegative(), type: import_zod17.z.enum(["fixedAmount", "percentage"]) }).optional(),
+  /**
+   * Per-tier exclusion rules (onsite `exclusions` when `exclusions_enabled`): lines they match don't count
+   * toward this tier. Empty (the default, and the converter's output for a disabled or ruleless tier) means
+   * the tier measures the plain bar-level adjusted progress. Consumers read ONLY the list named by the rule's
+   * `type` — the converter leaves the other two at `[]`, so a populated off-type list never reaches the tree.
+   */
+  exclusions: import_zod17.z.array(CABProgressTierExclusion).default(() => []),
   /**
    * Smart-cart product (gift) tiers only (onsite `filter_oos_variants`): when set, the client drops this
    * tier entirely once its gift has NO in-stock eligible variant — the milestone, fill slot and gift

package/dist/schema/widget-data.mjs

@@ -127,6 +127,8 @@ var progressTierTypes = ["decorative", "discount", "product", "shipping"];
 var ProgressTierType = freezeEnum(progressTierTypes);
 var progressTierUnits = ["currency", "item"];
 var ProgressTierUnit = freezeEnum(progressTierUnits);
+var progressTierExclusionTypes = ["collections", "products", "tags"];
+var ProgressTierExclusionType = freezeEnum(progressTierExclusionTypes);
 var quantityInputs = ["select", "number"];
 var QuantityInput = freezeEnum(quantityInputs);
 var resultCountOperators = ["equals", "greater_than", "less_than"];
@@ -1070,6 +1072,12 @@ var GIFT_LABELS = {
 };
 
 // src/schema/widgets/checkout-and-beyond/progressBar.ts
+var CABProgressTierExclusion = z17.object({
+  collectionIds: z17.array(z17.number().int().positive()).default(() => []),
+  productIds: z17.array(z17.number().int().positive()).default(() => []),
+  tags: z17.array(z17.string().min(1)).default(() => []),
+  type: z17.enum(progressTierExclusionTypes)
+});
 var CABProgressTier = z17.object({
   /**
    * Order-discount tiers only (onsite `discount`): the reward the order-discount Function applies at
@@ -1078,6 +1086,13 @@ var CABProgressTier = z17.object({
    * `percentage`: the whole-percent number rendered raw (`{n}%`). Absent on non-discount tiers.
    */
   discount: z17.object({ amount: z17.number().nonnegative(), type: z17.enum(["fixedAmount", "percentage"]) }).optional(),
+  /**
+   * Per-tier exclusion rules (onsite `exclusions` when `exclusions_enabled`): lines they match don't count
+   * toward this tier. Empty (the default, and the converter's output for a disabled or ruleless tier) means
+   * the tier measures the plain bar-level adjusted progress. Consumers read ONLY the list named by the rule's
+   * `type` — the converter leaves the other two at `[]`, so a populated off-type list never reaches the tree.
+   */
+  exclusions: z17.array(CABProgressTierExclusion).default(() => []),
   /**
    * Smart-cart product (gift) tiers only (onsite `filter_oos_variants`): when set, the client drops this
    * tier entirely once its gift has NO in-stock eligible variant — the milestone, fill slot and gift

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

@@ -214,6 +214,14 @@ export declare const ProgressTierUnit: {
     readonly item: "item";
 };
 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 collections: "collections";
+};
+export type ProgressTierExclusionType = (typeof progressTierExclusionTypes)[number];
 export declare const quantityInputs: readonly ["select", "number"];
 export declare const QuantityInput: {
     readonly number: "number";

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

@@ -1,6 +1,24 @@
 import { z } from 'zod';
 import { CABLayoutSection } from './layout';
 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.
+ */
+export declare const CABProgressTierExclusion: z.ZodObject<{
+    collectionIds: z.ZodDefault<z.ZodArray<z.ZodNumber>>;
+    productIds: z.ZodDefault<z.ZodArray<z.ZodNumber>>;
+    tags: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    type: z.ZodEnum<{
+        tags: "tags";
+        products: "products";
+        collections: "collections";
+    }>;
+}, z.core.$strip>;
+export type CABProgressTierExclusion = z.infer<typeof CABProgressTierExclusion>;
 export declare const CABProgressTier: z.ZodObject<{
     discount: z.ZodOptional<z.ZodObject<{
         amount: z.ZodNumber;
@@ -9,6 +27,16 @@ export declare const CABProgressTier: z.ZodObject<{
             fixedAmount: "fixedAmount";
         }>;
     }, z.core.$strip>>;
+    exclusions: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        collectionIds: z.ZodDefault<z.ZodArray<z.ZodNumber>>;
+        productIds: z.ZodDefault<z.ZodArray<z.ZodNumber>>;
+        tags: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        type: z.ZodEnum<{
+            tags: "tags";
+            products: "products";
+            collections: "collections";
+        }>;
+    }, z.core.$strip>>>;
     filterOosVariants: z.ZodDefault<z.ZodBoolean>;
     gift: z.ZodOptional<z.ZodObject<{
         productId: z.ZodNumber;
@@ -329,6 +357,16 @@ export declare const CABProgressBarSection: z.ZodLazy<z.ZodObject<{
                 fixedAmount: "fixedAmount";
             }>;
         }, z.core.$strip>>;
+        exclusions: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            collectionIds: z.ZodDefault<z.ZodArray<z.ZodNumber>>;
+            productIds: z.ZodDefault<z.ZodArray<z.ZodNumber>>;
+            tags: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            type: z.ZodEnum<{
+                tags: "tags";
+                products: "products";
+                collections: "collections";
+            }>;
+        }, z.core.$strip>>>;
         filterOosVariants: z.ZodDefault<z.ZodBoolean>;
         gift: z.ZodOptional<z.ZodObject<{
             productId: z.ZodNumber;

package/dist/server/index.cjs

@@ -459,6 +459,12 @@ var SmartCartTierProduct = import_zod5.z.looseObject({
   title: import_zod5.z.string().optional(),
   variantIds: import_zod5.z.array(import_zod5.z.coerce.number()).optional()
 });
+var SmartCartTierExclusion = import_zod5.z.looseObject({
+  collectionIds: import_zod5.z.array(import_zod5.z.coerce.number()).optional().catch(void 0),
+  productIds: import_zod5.z.array(import_zod5.z.coerce.number()).optional().catch(void 0),
+  tags: import_zod5.z.array(import_zod5.z.string()).optional().catch(void 0),
+  type: import_zod5.z.string().optional().catch(void 0)
+});
 var SmartCartTier = import_zod5.z.looseObject({
   allProducts: import_zod5.z.array(SmartCartTierProduct).optional(),
   /** Merchant-set tier label (e.g. "Free gift", "$100 reward"), shown on the step row when enabled. */
@@ -475,6 +481,19 @@ var SmartCartTier = import_zod5.z.looseObject({
   discountAmountRemainingLabel: import_zod5.z.boolean().optional(),
   discountAmountRemainingLabelText: import_zod5.z.string().optional(),
   discountType: import_zod5.z.string().optional(),
+  /**
+   * onsite `exclusions` + `exclusions_enabled` (REB-22305): per-tier rules the converter carries onto
+   * `CABProgressTier.exclusions`. `.catch(undefined)` for the same blast-radius reason as `productTierImage`:
+   * one drifted value must degrade to "no tier exclusions", never drop every progress bar for the shop.
+   *
+   * `exclusionsEnabled` is a STRICT boolean on purpose, even though failing open here changes the tier's math
+   * (a non-boolean reads as disabled) rather than just an icon. onsite reads its sibling tier flags strictly —
+   * `shouldFilterOutOfStockVariantsFromTier` is `tier?.filter_oos_variants === true`, and its `progressBar.ts`
+   * types every tier flag as `boolean` — so a stored `1` / `"1"` / `"true"` is "disabled" on the onsite bar too.
+   * A truthiness preprocess would make CAB exclude where onsite does not: the opposite parity break.
+   */
+  exclusions: import_zod5.z.array(SmartCartTierExclusion).optional().catch(void 0),
+  exclusionsEnabled: import_zod5.z.boolean().optional().catch(void 0),
   filterOosVariants: import_zod5.z.boolean().optional(),
   id: import_zod5.z.string().optional(),
   /**
@@ -775,6 +794,8 @@ var progressTierTypes = ["decorative", "discount", "product", "shipping"];
 var ProgressTierType = freezeEnum(progressTierTypes);
 var progressTierUnits = ["currency", "item"];
 var ProgressTierUnit = freezeEnum(progressTierUnits);
+var progressTierExclusionTypes = ["collections", "products", "tags"];
+var ProgressTierExclusionType = freezeEnum(progressTierExclusionTypes);
 var quantityInputs = ["select", "number"];
 var QuantityInput = freezeEnum(quantityInputs);
 var resultCountOperators = ["equals", "greater_than", "less_than"];
@@ -1689,6 +1710,12 @@ var GIFT_LABELS = {
 };
 
 // src/schema/widgets/checkout-and-beyond/progressBar.ts
+var CABProgressTierExclusion = import_zod21.z.object({
+  collectionIds: import_zod21.z.array(import_zod21.z.number().int().positive()).default(() => []),
+  productIds: import_zod21.z.array(import_zod21.z.number().int().positive()).default(() => []),
+  tags: import_zod21.z.array(import_zod21.z.string().min(1)).default(() => []),
+  type: import_zod21.z.enum(progressTierExclusionTypes)
+});
 var CABProgressTier = import_zod21.z.object({
   /**
    * Order-discount tiers only (onsite `discount`): the reward the order-discount Function applies at
@@ -1697,6 +1724,13 @@ var CABProgressTier = import_zod21.z.object({
    * `percentage`: the whole-percent number rendered raw (`{n}%`). Absent on non-discount tiers.
    */
   discount: import_zod21.z.object({ amount: import_zod21.z.number().nonnegative(), type: import_zod21.z.enum(["fixedAmount", "percentage"]) }).optional(),
+  /**
+   * Per-tier exclusion rules (onsite `exclusions` when `exclusions_enabled`): lines they match don't count
+   * toward this tier. Empty (the default, and the converter's output for a disabled or ruleless tier) means
+   * the tier measures the plain bar-level adjusted progress. Consumers read ONLY the list named by the rule's
+   * `type` — the converter leaves the other two at `[]`, so a populated off-type list never reaches the tree.
+   */
+  exclusions: import_zod21.z.array(CABProgressTierExclusion).default(() => []),
   /**
    * Smart-cart product (gift) tiers only (onsite `filter_oos_variants`): when set, the client drops this
    * tier entirely once its gift has NO in-stock eligible variant — the milestone, fill slot and gift
@@ -3663,6 +3697,7 @@ var iconSizeOf = (tier) => {
   const px = Math.round(Number.parseFloat(String(tier.productTierElementSize ?? "")));
   return Number.isFinite(px) && px > 0 ? Math.min(px, MAX_ICON_SIZE_PX) : void 0;
 };
+var positiveIds = (ids) => (ids ?? []).filter((id) => Number.isInteger(id) && id > 0);
 var giftOf = (tier) => {
   if (tier.type !== "product") return void 0;
   const product = tier.products?.[0] ?? tier.allProducts?.[0];
@@ -3672,12 +3707,26 @@ var giftOf = (tier) => {
   return {
     productId,
     title: product.title,
-    // One junk (non-positive) variant id must not fail the whole tier's schema — drop only the bad ids.
-    variantIds: (product.variantIds ?? []).filter((id) => Number.isInteger(id) && id > 0)
+    variantIds: positiveIds(product.variantIds)
   };
 };
+var RULE_LIST = { collections: "collectionIds", products: "productIds", tags: "tags" };
+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 === "tags" && { tags: (rule.tags ?? []).map((tag) => tag.trim()).filter(Boolean) },
+      type: rule.type
+    });
+    return parsed.success && parsed.data[RULE_LIST[parsed.data.type]].length > 0 ? [parsed.data] : [];
+  });
+  return rules.length > 0 ? rules : void 0;
+};
 var toTierMeta = (tier) => {
   const discount = discountOf(tier);
+  const exclusions = exclusionsOf(tier);
   const gift = giftOf(tier);
   const iconSizePx = iconSizeOf(tier);
   const isItemCount = tier.unlockConditionType === "item_quantity";
@@ -3685,6 +3734,8 @@ var toTierMeta = (tier) => {
   const type = tier.type;
   return {
     ...discount && { discount },
+    /** Carry per-tier exclusion rules only when enabled and non-empty — absent ⇒ the schema's `[]`, the plain bar-level progress. */
+    ...exclusions && { exclusions },
     /** Carry the OOS-filter flag only on gift tiers that set it — the client drops the tier when its gift is fully out of stock. */
     ...gift && tier.filterOosVariants && { filterOosVariants: true },
     ...gift && { gift },

package/dist/server/index.mjs

@@ -408,6 +408,12 @@ var SmartCartTierProduct = z5.looseObject({
   title: z5.string().optional(),
   variantIds: z5.array(z5.coerce.number()).optional()
 });
+var SmartCartTierExclusion = z5.looseObject({
+  collectionIds: z5.array(z5.coerce.number()).optional().catch(void 0),
+  productIds: z5.array(z5.coerce.number()).optional().catch(void 0),
+  tags: z5.array(z5.string()).optional().catch(void 0),
+  type: z5.string().optional().catch(void 0)
+});
 var SmartCartTier = z5.looseObject({
   allProducts: z5.array(SmartCartTierProduct).optional(),
   /** Merchant-set tier label (e.g. "Free gift", "$100 reward"), shown on the step row when enabled. */
@@ -424,6 +430,19 @@ var SmartCartTier = z5.looseObject({
   discountAmountRemainingLabel: z5.boolean().optional(),
   discountAmountRemainingLabelText: z5.string().optional(),
   discountType: z5.string().optional(),
+  /**
+   * onsite `exclusions` + `exclusions_enabled` (REB-22305): per-tier rules the converter carries onto
+   * `CABProgressTier.exclusions`. `.catch(undefined)` for the same blast-radius reason as `productTierImage`:
+   * one drifted value must degrade to "no tier exclusions", never drop every progress bar for the shop.
+   *
+   * `exclusionsEnabled` is a STRICT boolean on purpose, even though failing open here changes the tier's math
+   * (a non-boolean reads as disabled) rather than just an icon. onsite reads its sibling tier flags strictly —
+   * `shouldFilterOutOfStockVariantsFromTier` is `tier?.filter_oos_variants === true`, and its `progressBar.ts`
+   * types every tier flag as `boolean` — so a stored `1` / `"1"` / `"true"` is "disabled" on the onsite bar too.
+   * A truthiness preprocess would make CAB exclude where onsite does not: the opposite parity break.
+   */
+  exclusions: z5.array(SmartCartTierExclusion).optional().catch(void 0),
+  exclusionsEnabled: z5.boolean().optional().catch(void 0),
   filterOosVariants: z5.boolean().optional(),
   id: z5.string().optional(),
   /**
@@ -724,6 +743,8 @@ var progressTierTypes = ["decorative", "discount", "product", "shipping"];
 var ProgressTierType = freezeEnum(progressTierTypes);
 var progressTierUnits = ["currency", "item"];
 var ProgressTierUnit = freezeEnum(progressTierUnits);
+var progressTierExclusionTypes = ["collections", "products", "tags"];
+var ProgressTierExclusionType = freezeEnum(progressTierExclusionTypes);
 var quantityInputs = ["select", "number"];
 var QuantityInput = freezeEnum(quantityInputs);
 var resultCountOperators = ["equals", "greater_than", "less_than"];
@@ -1638,6 +1659,12 @@ var GIFT_LABELS = {
 };
 
 // src/schema/widgets/checkout-and-beyond/progressBar.ts
+var CABProgressTierExclusion = z21.object({
+  collectionIds: z21.array(z21.number().int().positive()).default(() => []),
+  productIds: z21.array(z21.number().int().positive()).default(() => []),
+  tags: z21.array(z21.string().min(1)).default(() => []),
+  type: z21.enum(progressTierExclusionTypes)
+});
 var CABProgressTier = z21.object({
   /**
    * Order-discount tiers only (onsite `discount`): the reward the order-discount Function applies at
@@ -1646,6 +1673,13 @@ var CABProgressTier = z21.object({
    * `percentage`: the whole-percent number rendered raw (`{n}%`). Absent on non-discount tiers.
    */
   discount: z21.object({ amount: z21.number().nonnegative(), type: z21.enum(["fixedAmount", "percentage"]) }).optional(),
+  /**
+   * Per-tier exclusion rules (onsite `exclusions` when `exclusions_enabled`): lines they match don't count
+   * toward this tier. Empty (the default, and the converter's output for a disabled or ruleless tier) means
+   * the tier measures the plain bar-level adjusted progress. Consumers read ONLY the list named by the rule's
+   * `type` — the converter leaves the other two at `[]`, so a populated off-type list never reaches the tree.
+   */
+  exclusions: z21.array(CABProgressTierExclusion).default(() => []),
   /**
    * Smart-cart product (gift) tiers only (onsite `filter_oos_variants`): when set, the client drops this
    * tier entirely once its gift has NO in-stock eligible variant — the milestone, fill slot and gift
@@ -3612,6 +3646,7 @@ var iconSizeOf = (tier) => {
   const px = Math.round(Number.parseFloat(String(tier.productTierElementSize ?? "")));
   return Number.isFinite(px) && px > 0 ? Math.min(px, MAX_ICON_SIZE_PX) : void 0;
 };
+var positiveIds = (ids) => (ids ?? []).filter((id) => Number.isInteger(id) && id > 0);
 var giftOf = (tier) => {
   if (tier.type !== "product") return void 0;
   const product = tier.products?.[0] ?? tier.allProducts?.[0];
@@ -3621,12 +3656,26 @@ var giftOf = (tier) => {
   return {
     productId,
     title: product.title,
-    // One junk (non-positive) variant id must not fail the whole tier's schema — drop only the bad ids.
-    variantIds: (product.variantIds ?? []).filter((id) => Number.isInteger(id) && id > 0)
+    variantIds: positiveIds(product.variantIds)
   };
 };
+var RULE_LIST = { collections: "collectionIds", products: "productIds", tags: "tags" };
+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 === "tags" && { tags: (rule.tags ?? []).map((tag) => tag.trim()).filter(Boolean) },
+      type: rule.type
+    });
+    return parsed.success && parsed.data[RULE_LIST[parsed.data.type]].length > 0 ? [parsed.data] : [];
+  });
+  return rules.length > 0 ? rules : void 0;
+};
 var toTierMeta = (tier) => {
   const discount = discountOf(tier);
+  const exclusions = exclusionsOf(tier);
   const gift = giftOf(tier);
   const iconSizePx = iconSizeOf(tier);
   const isItemCount = tier.unlockConditionType === "item_quantity";
@@ -3634,6 +3683,8 @@ var toTierMeta = (tier) => {
   const type = tier.type;
   return {
     ...discount && { discount },
+    /** Carry per-tier exclusion rules only when enabled and non-empty — absent ⇒ the schema's `[]`, the plain bar-level progress. */
+    ...exclusions && { exclusions },
     /** Carry the OOS-filter flag only on gift tiers that set it — the client drops the tier when its gift is fully out of stock. */
     ...gift && tier.filterOosVariants && { filterOosVariants: true },
     ...gift && { gift },

package/dist/transforms/index.cjs

@@ -178,6 +178,8 @@ var progressTierTypes = ["decorative", "discount", "product", "shipping"];
 var ProgressTierType = freezeEnum(progressTierTypes);
 var progressTierUnits = ["currency", "item"];
 var ProgressTierUnit = freezeEnum(progressTierUnits);
+var progressTierExclusionTypes = ["collections", "products", "tags"];
+var ProgressTierExclusionType = freezeEnum(progressTierExclusionTypes);
 var quantityInputs = ["select", "number"];
 var QuantityInput = freezeEnum(quantityInputs);
 var resultCountOperators = ["equals", "greater_than", "less_than"];
@@ -1092,6 +1094,12 @@ 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(() => []),
+  tags: import_zod15.z.array(import_zod15.z.string().min(1)).default(() => []),
+  type: import_zod15.z.enum(progressTierExclusionTypes)
+});
 var CABProgressTier = import_zod15.z.object({
   /**
    * Order-discount tiers only (onsite `discount`): the reward the order-discount Function applies at
@@ -1100,6 +1108,13 @@ var CABProgressTier = import_zod15.z.object({
    * `percentage`: the whole-percent number rendered raw (`{n}%`). Absent on non-discount tiers.
    */
   discount: import_zod15.z.object({ amount: import_zod15.z.number().nonnegative(), type: import_zod15.z.enum(["fixedAmount", "percentage"]) }).optional(),
+  /**
+   * Per-tier exclusion rules (onsite `exclusions` when `exclusions_enabled`): lines they match don't count
+   * toward this tier. Empty (the default, and the converter's output for a disabled or ruleless tier) means
+   * the tier measures the plain bar-level adjusted progress. Consumers read ONLY the list named by the rule's
+   * `type` — the converter leaves the other two at `[]`, so a populated off-type list never reaches the tree.
+   */
+  exclusions: import_zod15.z.array(CABProgressTierExclusion).default(() => []),
   /**
    * Smart-cart product (gift) tiers only (onsite `filter_oos_variants`): when set, the client drops this
    * tier entirely once its gift has NO in-stock eligible variant — the milestone, fill slot and gift
@@ -3497,6 +3512,7 @@ var iconSizeOf = (tier) => {
   const px = Math.round(Number.parseFloat(String(tier.productTierElementSize ?? "")));
   return Number.isFinite(px) && px > 0 ? Math.min(px, MAX_ICON_SIZE_PX) : void 0;
 };
+var positiveIds = (ids) => (ids ?? []).filter((id) => Number.isInteger(id) && id > 0);
 var giftOf = (tier) => {
   if (tier.type !== "product") return void 0;
   const product = tier.products?.[0] ?? tier.allProducts?.[0];
@@ -3506,12 +3522,26 @@ var giftOf = (tier) => {
   return {
     productId,
     title: product.title,
-    // One junk (non-positive) variant id must not fail the whole tier's schema — drop only the bad ids.
-    variantIds: (product.variantIds ?? []).filter((id) => Number.isInteger(id) && id > 0)
+    variantIds: positiveIds(product.variantIds)
   };
 };
+var RULE_LIST = { collections: "collectionIds", products: "productIds", tags: "tags" };
+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 === "tags" && { tags: (rule.tags ?? []).map((tag) => tag.trim()).filter(Boolean) },
+      type: rule.type
+    });
+    return parsed.success && parsed.data[RULE_LIST[parsed.data.type]].length > 0 ? [parsed.data] : [];
+  });
+  return rules.length > 0 ? rules : void 0;
+};
 var toTierMeta = (tier) => {
   const discount = discountOf(tier);
+  const exclusions = exclusionsOf(tier);
   const gift = giftOf(tier);
   const iconSizePx = iconSizeOf(tier);
   const isItemCount = tier.unlockConditionType === "item_quantity";
@@ -3519,6 +3549,8 @@ var toTierMeta = (tier) => {
   const type = tier.type;
   return {
     ...discount && { discount },
+    /** Carry per-tier exclusion rules only when enabled and non-empty — absent ⇒ the schema's `[]`, the plain bar-level progress. */
+    ...exclusions && { exclusions },
     /** Carry the OOS-filter flag only on gift tiers that set it — the client drops the tier when its gift is fully out of stock. */
     ...gift && tier.filterOosVariants && { filterOosVariants: true },
     ...gift && { gift },

package/dist/transforms/index.mjs

@@ -119,6 +119,8 @@ var progressTierTypes = ["decorative", "discount", "product", "shipping"];
 var ProgressTierType = freezeEnum(progressTierTypes);
 var progressTierUnits = ["currency", "item"];
 var ProgressTierUnit = freezeEnum(progressTierUnits);
+var progressTierExclusionTypes = ["collections", "products", "tags"];
+var ProgressTierExclusionType = freezeEnum(progressTierExclusionTypes);
 var quantityInputs = ["select", "number"];
 var QuantityInput = freezeEnum(quantityInputs);
 var resultCountOperators = ["equals", "greater_than", "less_than"];
@@ -1033,6 +1035,12 @@ 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(() => []),
+  tags: z15.array(z15.string().min(1)).default(() => []),
+  type: z15.enum(progressTierExclusionTypes)
+});
 var CABProgressTier = z15.object({
   /**
    * Order-discount tiers only (onsite `discount`): the reward the order-discount Function applies at
@@ -1041,6 +1049,13 @@ var CABProgressTier = z15.object({
    * `percentage`: the whole-percent number rendered raw (`{n}%`). Absent on non-discount tiers.
    */
   discount: z15.object({ amount: z15.number().nonnegative(), type: z15.enum(["fixedAmount", "percentage"]) }).optional(),
+  /**
+   * Per-tier exclusion rules (onsite `exclusions` when `exclusions_enabled`): lines they match don't count
+   * toward this tier. Empty (the default, and the converter's output for a disabled or ruleless tier) means
+   * the tier measures the plain bar-level adjusted progress. Consumers read ONLY the list named by the rule's
+   * `type` — the converter leaves the other two at `[]`, so a populated off-type list never reaches the tree.
+   */
+  exclusions: z15.array(CABProgressTierExclusion).default(() => []),
   /**
    * Smart-cart product (gift) tiers only (onsite `filter_oos_variants`): when set, the client drops this
    * tier entirely once its gift has NO in-stock eligible variant — the milestone, fill slot and gift
@@ -3438,6 +3453,7 @@ var iconSizeOf = (tier) => {
   const px = Math.round(Number.parseFloat(String(tier.productTierElementSize ?? "")));
   return Number.isFinite(px) && px > 0 ? Math.min(px, MAX_ICON_SIZE_PX) : void 0;
 };
+var positiveIds = (ids) => (ids ?? []).filter((id) => Number.isInteger(id) && id > 0);
 var giftOf = (tier) => {
   if (tier.type !== "product") return void 0;
   const product = tier.products?.[0] ?? tier.allProducts?.[0];
@@ -3447,12 +3463,26 @@ var giftOf = (tier) => {
   return {
     productId,
     title: product.title,
-    // One junk (non-positive) variant id must not fail the whole tier's schema — drop only the bad ids.
-    variantIds: (product.variantIds ?? []).filter((id) => Number.isInteger(id) && id > 0)
+    variantIds: positiveIds(product.variantIds)
   };
 };
+var RULE_LIST = { collections: "collectionIds", products: "productIds", tags: "tags" };
+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 === "tags" && { tags: (rule.tags ?? []).map((tag) => tag.trim()).filter(Boolean) },
+      type: rule.type
+    });
+    return parsed.success && parsed.data[RULE_LIST[parsed.data.type]].length > 0 ? [parsed.data] : [];
+  });
+  return rules.length > 0 ? rules : void 0;
+};
 var toTierMeta = (tier) => {
   const discount = discountOf(tier);
+  const exclusions = exclusionsOf(tier);
   const gift = giftOf(tier);
   const iconSizePx = iconSizeOf(tier);
   const isItemCount = tier.unlockConditionType === "item_quantity";
@@ -3460,6 +3490,8 @@ var toTierMeta = (tier) => {
   const type = tier.type;
   return {
     ...discount && { discount },
+    /** Carry per-tier exclusion rules only when enabled and non-empty — absent ⇒ the schema's `[]`, the plain bar-level progress. */
+    ...exclusions && { exclusions },
     /** Carry the OOS-filter flag only on gift tiers that set it — the client drops the tier when its gift is fully out of stock. */
     ...gift && tier.filterOosVariants && { filterOosVariants: true },
     ...gift && { gift },

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@rebuy/rebuy",
-    "version": "3.19.0",
+    "version": "3.20.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.",