@rebuy/rebuy 3.11.0 → 3.12.0

package/dist/index.cjs

@@ -1058,6 +1058,20 @@ var SmartCartTier = import_zod.z.looseObject({
   productAmountRemainingLabel: import_zod.z.boolean().optional(),
   productAmountRemainingLabelText: import_zod.z.string().optional(),
   products: import_zod.z.array(SmartCartTierProduct).optional(),
+  /**
+   * onsite `product_tier_element_size`: the step-row icon's square size as a px STRING (`'18px'` …
+   * `'36px'` — the admin's five-value Size control, default `'18px'`). React stamps it onto the icon
+   * SVG's `width`/`height` (`getProgressStepIconSize`), so the milestone renders at the merchant's
+   * chosen size; the converter turns it into `CABProgressTier.iconSizePx` for the CAB renderer.
+   *
+   * `.catch(undefined)` for the same blast-radius reason as `productTierImage` below: this key was
+   * previously unknown-and-ignored by the `looseObject`, and `SmartCartConfig` is parsed
+   * `.nullish().catch(undefined)` with no intermediate catch, so one drifted value (a bare number, a
+   * `'2rem'`) would drop EVERY progress bar for the shop rather than just this setting. Failing open to
+   * `undefined` lands on the documented 18px default — strictly safer than that blast radius. The
+   * converter parses the number out and clamps it, so a junk-but-string value degrades the same way.
+   */
+  productTierElementSize: import_zod.z.string().optional().catch(void 0),
   /**
    * onsite `product_tier_image`: on a product (gift) tier, show the gift's product image in the step-row
    * slot instead of the generic bag icon (React `TierProgressIcon` swaps in the image when this is set and
@@ -2703,6 +2717,25 @@ var CABProgressTier = import_zod24.z.object({
     title: import_zod24.z.string().optional(),
     variantIds: import_zod24.z.array(import_zod24.z.number().int().positive()).default(() => [])
   }).optional(),
+  /**
+   * The step-row icon's square size in PIXELS (onsite `product_tier_element_size`, an admin px string the
+   * converter parses): 18 (default) / 20 / 24 / 30 / 36. React sizes the milestone by stamping this onto
+   * the icon SVG's `width`/`height` (`getProgressStepIconSize`), so a merchant who deliberately enlarged
+   * their milestones keeps that at checkout instead of every icon collapsing to one hardcoded square.
+   *
+   * A NUMBER, not the raw `'18px'` string: the renderer needs it as a length for the icon slot's grid
+   * track, and a px-suffixed string would push unit parsing into every consumer. Deliberately NOT named
+   * `iconSize` — the `iconSize` on an `image` section is the `s-icon` token enum, and one name covering both a
+   * token and a pixel count is the kind of ambiguity that gets one passed where the other is meant.
+   *
+   * Bounded (not merely positive) because it is a raw merchant-controlled length: the step row is a grid
+   * of per-tier cells, and an out-of-domain value would stretch the row rather than fail loudly. The
+   * converter clamps to this same ceiling, so drifted config lands on a big-but-sane icon and never on a
+   * tier the strict parse drops. `.default(18)` holds React's default at parse time (schema-first — the
+   * renderer never spells a fallback), which also makes a tree authored before this field render at
+   * React's size rather than the old hardcoded 20.
+   */
+  iconSizePx: import_zod24.z.number().int().min(1).max(64).default(18),
   /**
    * The step-row label at this tier's slot (onsite `getTierLabel`): the merchant custom label, else the
    * type default — 'Free Shipping' or '{n}% Discount'. A PRODUCT tier gets NO converter label: its name is

package/dist/index.mjs

@@ -772,6 +772,20 @@ var SmartCartTier = z.looseObject({
   productAmountRemainingLabel: z.boolean().optional(),
   productAmountRemainingLabelText: z.string().optional(),
   products: z.array(SmartCartTierProduct).optional(),
+  /**
+   * onsite `product_tier_element_size`: the step-row icon's square size as a px STRING (`'18px'` …
+   * `'36px'` — the admin's five-value Size control, default `'18px'`). React stamps it onto the icon
+   * SVG's `width`/`height` (`getProgressStepIconSize`), so the milestone renders at the merchant's
+   * chosen size; the converter turns it into `CABProgressTier.iconSizePx` for the CAB renderer.
+   *
+   * `.catch(undefined)` for the same blast-radius reason as `productTierImage` below: this key was
+   * previously unknown-and-ignored by the `looseObject`, and `SmartCartConfig` is parsed
+   * `.nullish().catch(undefined)` with no intermediate catch, so one drifted value (a bare number, a
+   * `'2rem'`) would drop EVERY progress bar for the shop rather than just this setting. Failing open to
+   * `undefined` lands on the documented 18px default — strictly safer than that blast radius. The
+   * converter parses the number out and clamps it, so a junk-but-string value degrades the same way.
+   */
+  productTierElementSize: z.string().optional().catch(void 0),
   /**
    * onsite `product_tier_image`: on a product (gift) tier, show the gift's product image in the step-row
    * slot instead of the generic bag icon (React `TierProgressIcon` swaps in the image when this is set and
@@ -2417,6 +2431,25 @@ var CABProgressTier = z24.object({
     title: z24.string().optional(),
     variantIds: z24.array(z24.number().int().positive()).default(() => [])
   }).optional(),
+  /**
+   * The step-row icon's square size in PIXELS (onsite `product_tier_element_size`, an admin px string the
+   * converter parses): 18 (default) / 20 / 24 / 30 / 36. React sizes the milestone by stamping this onto
+   * the icon SVG's `width`/`height` (`getProgressStepIconSize`), so a merchant who deliberately enlarged
+   * their milestones keeps that at checkout instead of every icon collapsing to one hardcoded square.
+   *
+   * A NUMBER, not the raw `'18px'` string: the renderer needs it as a length for the icon slot's grid
+   * track, and a px-suffixed string would push unit parsing into every consumer. Deliberately NOT named
+   * `iconSize` — the `iconSize` on an `image` section is the `s-icon` token enum, and one name covering both a
+   * token and a pixel count is the kind of ambiguity that gets one passed where the other is meant.
+   *
+   * Bounded (not merely positive) because it is a raw merchant-controlled length: the step row is a grid
+   * of per-tier cells, and an out-of-domain value would stretch the row rather than fail loudly. The
+   * converter clamps to this same ceiling, so drifted config lands on a big-but-sane icon and never on a
+   * tier the strict parse drops. `.default(18)` holds React's default at parse time (schema-first — the
+   * renderer never spells a fallback), which also makes a tree authored before this field render at
+   * React's size rather than the old hardcoded 20.
+   */
+  iconSizePx: z24.number().int().min(1).max(64).default(18),
   /**
    * The step-row label at this tier's slot (onsite `getTierLabel`): the merchant custom label, else the
    * type default — 'Free Shipping' or '{n}% Discount'. A PRODUCT tier gets NO converter label: its name is

package/dist/schema/cabShopConfig.d.ts

@@ -144,6 +144,7 @@ export declare const CabUserConfig: z.ZodObject<{
                             title: z.ZodOptional<z.ZodString>;
                             variantIds: z.ZodOptional<z.ZodArray<z.ZodCoercedNumber<unknown>>>;
                         }, z.core.$loose>>>;
+                        productTierElementSize: z.ZodCatch<z.ZodOptional<z.ZodString>>;
                         productTierImage: z.ZodCatch<z.ZodOptional<z.ZodBoolean>>;
                         type: z.ZodOptional<z.ZodString>;
                         unlockConditionType: z.ZodOptional<z.ZodString>;

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

@@ -1272,6 +1272,25 @@ var CABProgressTier = import_zod14.z.object({
     title: import_zod14.z.string().optional(),
     variantIds: import_zod14.z.array(import_zod14.z.number().int().positive()).default(() => [])
   }).optional(),
+  /**
+   * The step-row icon's square size in PIXELS (onsite `product_tier_element_size`, an admin px string the
+   * converter parses): 18 (default) / 20 / 24 / 30 / 36. React sizes the milestone by stamping this onto
+   * the icon SVG's `width`/`height` (`getProgressStepIconSize`), so a merchant who deliberately enlarged
+   * their milestones keeps that at checkout instead of every icon collapsing to one hardcoded square.
+   *
+   * A NUMBER, not the raw `'18px'` string: the renderer needs it as a length for the icon slot's grid
+   * track, and a px-suffixed string would push unit parsing into every consumer. Deliberately NOT named
+   * `iconSize` — the `iconSize` on an `image` section is the `s-icon` token enum, and one name covering both a
+   * token and a pixel count is the kind of ambiguity that gets one passed where the other is meant.
+   *
+   * Bounded (not merely positive) because it is a raw merchant-controlled length: the step row is a grid
+   * of per-tier cells, and an out-of-domain value would stretch the row rather than fail loudly. The
+   * converter clamps to this same ceiling, so drifted config lands on a big-but-sane icon and never on a
+   * tier the strict parse drops. `.default(18)` holds React's default at parse time (schema-first — the
+   * renderer never spells a fallback), which also makes a tree authored before this field render at
+   * React's size rather than the old hardcoded 20.
+   */
+  iconSizePx: import_zod14.z.number().int().min(1).max(64).default(18),
   /**
    * The step-row label at this tier's slot (onsite `getTierLabel`): the merchant custom label, else the
    * type default — 'Free Shipping' or '{n}% Discount'. A PRODUCT tier gets NO converter label: its name is

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

@@ -1075,6 +1075,25 @@ var CABProgressTier = z14.object({
     title: z14.string().optional(),
     variantIds: z14.array(z14.number().int().positive()).default(() => [])
   }).optional(),
+  /**
+   * The step-row icon's square size in PIXELS (onsite `product_tier_element_size`, an admin px string the
+   * converter parses): 18 (default) / 20 / 24 / 30 / 36. React sizes the milestone by stamping this onto
+   * the icon SVG's `width`/`height` (`getProgressStepIconSize`), so a merchant who deliberately enlarged
+   * their milestones keeps that at checkout instead of every icon collapsing to one hardcoded square.
+   *
+   * A NUMBER, not the raw `'18px'` string: the renderer needs it as a length for the icon slot's grid
+   * track, and a px-suffixed string would push unit parsing into every consumer. Deliberately NOT named
+   * `iconSize` — the `iconSize` on an `image` section is the `s-icon` token enum, and one name covering both a
+   * token and a pixel count is the kind of ambiguity that gets one passed where the other is meant.
+   *
+   * Bounded (not merely positive) because it is a raw merchant-controlled length: the step row is a grid
+   * of per-tier cells, and an out-of-domain value would stretch the row rather than fail loudly. The
+   * converter clamps to this same ceiling, so drifted config lands on a big-but-sane icon and never on a
+   * tier the strict parse drops. `.default(18)` holds React's default at parse time (schema-first — the
+   * renderer never spells a fallback), which also makes a tree authored before this field render at
+   * React's size rather than the old hardcoded 20.
+   */
+  iconSizePx: z14.number().int().min(1).max(64).default(18),
   /**
    * The step-row label at this tier's slot (onsite `getTierLabel`): the merchant custom label, else the
    * type default — 'Free Shipping' or '{n}% Discount'. A PRODUCT tier gets NO converter label: its name is

package/dist/schema/smartCart.d.ts

@@ -59,6 +59,7 @@ export declare const SmartCartTier: z.ZodObject<{
         title: z.ZodOptional<z.ZodString>;
         variantIds: z.ZodOptional<z.ZodArray<z.ZodCoercedNumber<unknown>>>;
     }, z.core.$loose>>>;
+    productTierElementSize: z.ZodCatch<z.ZodOptional<z.ZodString>>;
     productTierImage: z.ZodCatch<z.ZodOptional<z.ZodBoolean>>;
     type: z.ZodOptional<z.ZodString>;
     unlockConditionType: z.ZodOptional<z.ZodString>;
@@ -120,6 +121,7 @@ export declare const SmartCartBar: z.ZodObject<{
             title: z.ZodOptional<z.ZodString>;
             variantIds: z.ZodOptional<z.ZodArray<z.ZodCoercedNumber<unknown>>>;
         }, z.core.$loose>>>;
+        productTierElementSize: z.ZodCatch<z.ZodOptional<z.ZodString>>;
         productTierImage: z.ZodCatch<z.ZodOptional<z.ZodBoolean>>;
         type: z.ZodOptional<z.ZodString>;
         unlockConditionType: z.ZodOptional<z.ZodString>;
@@ -180,6 +182,7 @@ export declare const SmartCartComponent: z.ZodObject<{
                     title: z.ZodOptional<z.ZodString>;
                     variantIds: z.ZodOptional<z.ZodArray<z.ZodCoercedNumber<unknown>>>;
                 }, z.core.$loose>>>;
+                productTierElementSize: z.ZodCatch<z.ZodOptional<z.ZodString>>;
                 productTierImage: z.ZodCatch<z.ZodOptional<z.ZodBoolean>>;
                 type: z.ZodOptional<z.ZodString>;
                 unlockConditionType: z.ZodOptional<z.ZodString>;
@@ -251,6 +254,7 @@ export declare const SmartCartConfig: z.ZodObject<{
                         title: z.ZodOptional<z.ZodString>;
                         variantIds: z.ZodOptional<z.ZodArray<z.ZodCoercedNumber<unknown>>>;
                     }, z.core.$loose>>>;
+                    productTierElementSize: z.ZodCatch<z.ZodOptional<z.ZodString>>;
                     productTierImage: z.ZodCatch<z.ZodOptional<z.ZodBoolean>>;
                     type: z.ZodOptional<z.ZodString>;
                     unlockConditionType: z.ZodOptional<z.ZodString>;

package/dist/schema/user-config.cjs

@@ -151,6 +151,20 @@ var SmartCartTier = import_zod2.z.looseObject({
   productAmountRemainingLabel: import_zod2.z.boolean().optional(),
   productAmountRemainingLabelText: import_zod2.z.string().optional(),
   products: import_zod2.z.array(SmartCartTierProduct).optional(),
+  /**
+   * onsite `product_tier_element_size`: the step-row icon's square size as a px STRING (`'18px'` …
+   * `'36px'` — the admin's five-value Size control, default `'18px'`). React stamps it onto the icon
+   * SVG's `width`/`height` (`getProgressStepIconSize`), so the milestone renders at the merchant's
+   * chosen size; the converter turns it into `CABProgressTier.iconSizePx` for the CAB renderer.
+   *
+   * `.catch(undefined)` for the same blast-radius reason as `productTierImage` below: this key was
+   * previously unknown-and-ignored by the `looseObject`, and `SmartCartConfig` is parsed
+   * `.nullish().catch(undefined)` with no intermediate catch, so one drifted value (a bare number, a
+   * `'2rem'`) would drop EVERY progress bar for the shop rather than just this setting. Failing open to
+   * `undefined` lands on the documented 18px default — strictly safer than that blast radius. The
+   * converter parses the number out and clamps it, so a junk-but-string value degrades the same way.
+   */
+  productTierElementSize: import_zod2.z.string().optional().catch(void 0),
   /**
    * onsite `product_tier_image`: on a product (gift) tier, show the gift's product image in the step-row
    * slot instead of the generic bag icon (React `TierProgressIcon` swaps in the image when this is set and

package/dist/schema/user-config.mjs

@@ -127,6 +127,20 @@ var SmartCartTier = z2.looseObject({
   productAmountRemainingLabel: z2.boolean().optional(),
   productAmountRemainingLabelText: z2.string().optional(),
   products: z2.array(SmartCartTierProduct).optional(),
+  /**
+   * onsite `product_tier_element_size`: the step-row icon's square size as a px STRING (`'18px'` …
+   * `'36px'` — the admin's five-value Size control, default `'18px'`). React stamps it onto the icon
+   * SVG's `width`/`height` (`getProgressStepIconSize`), so the milestone renders at the merchant's
+   * chosen size; the converter turns it into `CABProgressTier.iconSizePx` for the CAB renderer.
+   *
+   * `.catch(undefined)` for the same blast-radius reason as `productTierImage` below: this key was
+   * previously unknown-and-ignored by the `looseObject`, and `SmartCartConfig` is parsed
+   * `.nullish().catch(undefined)` with no intermediate catch, so one drifted value (a bare number, a
+   * `'2rem'`) would drop EVERY progress bar for the shop rather than just this setting. Failing open to
+   * `undefined` lands on the documented 18px default — strictly safer than that blast radius. The
+   * converter parses the number out and clamps it, so a junk-but-string value degrades the same way.
+   */
+  productTierElementSize: z2.string().optional().catch(void 0),
   /**
    * onsite `product_tier_image`: on a product (gift) tier, show the gift's product image in the step-row
    * slot instead of the generic bag icon (React `TierProgressIcon` swaps in the image when this is set and

package/dist/schema/userConfig.d.ts

@@ -133,6 +133,7 @@ export declare const UserConfig: z.ZodObject<{
                             title: z.ZodOptional<z.ZodString>;
                             variantIds: z.ZodOptional<z.ZodArray<z.ZodCoercedNumber<unknown>>>;
                         }, z.core.$loose>>>;
+                        productTierElementSize: z.ZodCatch<z.ZodOptional<z.ZodString>>;
                         productTierImage: z.ZodCatch<z.ZodOptional<z.ZodBoolean>>;
                         type: z.ZodOptional<z.ZodString>;
                         unlockConditionType: z.ZodOptional<z.ZodString>;

package/dist/schema/widget-data.cjs

@@ -1113,6 +1113,25 @@ var CABProgressTier = import_zod17.z.object({
     title: import_zod17.z.string().optional(),
     variantIds: import_zod17.z.array(import_zod17.z.number().int().positive()).default(() => [])
   }).optional(),
+  /**
+   * The step-row icon's square size in PIXELS (onsite `product_tier_element_size`, an admin px string the
+   * converter parses): 18 (default) / 20 / 24 / 30 / 36. React sizes the milestone by stamping this onto
+   * the icon SVG's `width`/`height` (`getProgressStepIconSize`), so a merchant who deliberately enlarged
+   * their milestones keeps that at checkout instead of every icon collapsing to one hardcoded square.
+   *
+   * A NUMBER, not the raw `'18px'` string: the renderer needs it as a length for the icon slot's grid
+   * track, and a px-suffixed string would push unit parsing into every consumer. Deliberately NOT named
+   * `iconSize` — the `iconSize` on an `image` section is the `s-icon` token enum, and one name covering both a
+   * token and a pixel count is the kind of ambiguity that gets one passed where the other is meant.
+   *
+   * Bounded (not merely positive) because it is a raw merchant-controlled length: the step row is a grid
+   * of per-tier cells, and an out-of-domain value would stretch the row rather than fail loudly. The
+   * converter clamps to this same ceiling, so drifted config lands on a big-but-sane icon and never on a
+   * tier the strict parse drops. `.default(18)` holds React's default at parse time (schema-first — the
+   * renderer never spells a fallback), which also makes a tree authored before this field render at
+   * React's size rather than the old hardcoded 20.
+   */
+  iconSizePx: import_zod17.z.number().int().min(1).max(64).default(18),
   /**
    * The step-row label at this tier's slot (onsite `getTierLabel`): the merchant custom label, else the
    * type default — 'Free Shipping' or '{n}% Discount'. A PRODUCT tier gets NO converter label: its name is

package/dist/schema/widget-data.mjs

@@ -1088,6 +1088,25 @@ var CABProgressTier = z17.object({
     title: z17.string().optional(),
     variantIds: z17.array(z17.number().int().positive()).default(() => [])
   }).optional(),
+  /**
+   * The step-row icon's square size in PIXELS (onsite `product_tier_element_size`, an admin px string the
+   * converter parses): 18 (default) / 20 / 24 / 30 / 36. React sizes the milestone by stamping this onto
+   * the icon SVG's `width`/`height` (`getProgressStepIconSize`), so a merchant who deliberately enlarged
+   * their milestones keeps that at checkout instead of every icon collapsing to one hardcoded square.
+   *
+   * A NUMBER, not the raw `'18px'` string: the renderer needs it as a length for the icon slot's grid
+   * track, and a px-suffixed string would push unit parsing into every consumer. Deliberately NOT named
+   * `iconSize` — the `iconSize` on an `image` section is the `s-icon` token enum, and one name covering both a
+   * token and a pixel count is the kind of ambiguity that gets one passed where the other is meant.
+   *
+   * Bounded (not merely positive) because it is a raw merchant-controlled length: the step row is a grid
+   * of per-tier cells, and an out-of-domain value would stretch the row rather than fail loudly. The
+   * converter clamps to this same ceiling, so drifted config lands on a big-but-sane icon and never on a
+   * tier the strict parse drops. `.default(18)` holds React's default at parse time (schema-first — the
+   * renderer never spells a fallback), which also makes a tree authored before this field render at
+   * React's size rather than the old hardcoded 20.
+   */
+  iconSizePx: z17.number().int().min(1).max(64).default(18),
   /**
    * The step-row label at this tier's slot (onsite `getTierLabel`): the merchant custom label, else the
    * type default — 'Free Shipping' or '{n}% Discount'. A PRODUCT tier gets NO converter label: its name is

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

@@ -15,6 +15,7 @@ export declare const CABProgressTier: z.ZodObject<{
         title: z.ZodOptional<z.ZodString>;
         variantIds: z.ZodDefault<z.ZodArray<z.ZodNumber>>;
     }, z.core.$strip>>;
+    iconSizePx: z.ZodDefault<z.ZodNumber>;
     label: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
     productTierImage: z.ZodDefault<z.ZodBoolean>;
     threshold: z.ZodNumber;
@@ -334,6 +335,7 @@ export declare const CABProgressBarSection: z.ZodLazy<z.ZodObject<{
             title: z.ZodOptional<z.ZodString>;
             variantIds: z.ZodDefault<z.ZodArray<z.ZodNumber>>;
         }, z.core.$strip>>;
+        iconSizePx: z.ZodDefault<z.ZodNumber>;
         label: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
         productTierImage: z.ZodDefault<z.ZodBoolean>;
         threshold: z.ZodNumber;

package/dist/server/index.cjs

@@ -478,6 +478,20 @@ var SmartCartTier = import_zod5.z.looseObject({
   productAmountRemainingLabel: import_zod5.z.boolean().optional(),
   productAmountRemainingLabelText: import_zod5.z.string().optional(),
   products: import_zod5.z.array(SmartCartTierProduct).optional(),
+  /**
+   * onsite `product_tier_element_size`: the step-row icon's square size as a px STRING (`'18px'` …
+   * `'36px'` — the admin's five-value Size control, default `'18px'`). React stamps it onto the icon
+   * SVG's `width`/`height` (`getProgressStepIconSize`), so the milestone renders at the merchant's
+   * chosen size; the converter turns it into `CABProgressTier.iconSizePx` for the CAB renderer.
+   *
+   * `.catch(undefined)` for the same blast-radius reason as `productTierImage` below: this key was
+   * previously unknown-and-ignored by the `looseObject`, and `SmartCartConfig` is parsed
+   * `.nullish().catch(undefined)` with no intermediate catch, so one drifted value (a bare number, a
+   * `'2rem'`) would drop EVERY progress bar for the shop rather than just this setting. Failing open to
+   * `undefined` lands on the documented 18px default — strictly safer than that blast radius. The
+   * converter parses the number out and clamps it, so a junk-but-string value degrades the same way.
+   */
+  productTierElementSize: import_zod5.z.string().optional().catch(void 0),
   /**
    * onsite `product_tier_image`: on a product (gift) tier, show the gift's product image in the step-row
    * slot instead of the generic bag icon (React `TierProgressIcon` swaps in the image when this is set and
@@ -1657,6 +1671,25 @@ var CABProgressTier = import_zod21.z.object({
     title: import_zod21.z.string().optional(),
     variantIds: import_zod21.z.array(import_zod21.z.number().int().positive()).default(() => [])
   }).optional(),
+  /**
+   * The step-row icon's square size in PIXELS (onsite `product_tier_element_size`, an admin px string the
+   * converter parses): 18 (default) / 20 / 24 / 30 / 36. React sizes the milestone by stamping this onto
+   * the icon SVG's `width`/`height` (`getProgressStepIconSize`), so a merchant who deliberately enlarged
+   * their milestones keeps that at checkout instead of every icon collapsing to one hardcoded square.
+   *
+   * A NUMBER, not the raw `'18px'` string: the renderer needs it as a length for the icon slot's grid
+   * track, and a px-suffixed string would push unit parsing into every consumer. Deliberately NOT named
+   * `iconSize` — the `iconSize` on an `image` section is the `s-icon` token enum, and one name covering both a
+   * token and a pixel count is the kind of ambiguity that gets one passed where the other is meant.
+   *
+   * Bounded (not merely positive) because it is a raw merchant-controlled length: the step row is a grid
+   * of per-tier cells, and an out-of-domain value would stretch the row rather than fail loudly. The
+   * converter clamps to this same ceiling, so drifted config lands on a big-but-sane icon and never on a
+   * tier the strict parse drops. `.default(18)` holds React's default at parse time (schema-first — the
+   * renderer never spells a fallback), which also makes a tree authored before this field render at
+   * React's size rather than the old hardcoded 20.
+   */
+  iconSizePx: import_zod21.z.number().int().min(1).max(64).default(18),
   /**
    * The step-row label at this tier's slot (onsite `getTierLabel`): the merchant custom label, else the
    * type default — 'Free Shipping' or '{n}% Discount'. A PRODUCT tier gets NO converter label: its name is
@@ -3530,6 +3563,7 @@ var feedbackDoc = (raw, tokens) => ({
   ],
   type: "doc"
 });
+var MAX_ICON_SIZE_PX = 64;
 var IN_SCOPE_TIER_TYPES = new Set(progressTierTypes);
 var inScope = (tier) => IN_SCOPE_TIER_TYPES.has(tier.type ?? "");
 var thresholdOf = (tier) => tier.unlockConditionType === "item_quantity" ? Math.ceil(Number(tier.minimum)) : Math.round(Number(tier.minimum) * 100);
@@ -3548,6 +3582,10 @@ var discountOf = (tier) => {
   const amount = tier.discountAmountFromTotal ?? 0;
   return tier.discountType === "fixedAmount" ? { amount: Math.round(amount * 100), type: "fixedAmount" } : { amount, type: "percentage" };
 };
+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 giftOf = (tier) => {
   if (tier.type !== "product") return void 0;
   const product = tier.products?.[0] ?? tier.allProducts?.[0];
@@ -3564,6 +3602,7 @@ var giftOf = (tier) => {
 var toTierMeta = (tier) => {
   const discount = discountOf(tier);
   const gift = giftOf(tier);
+  const iconSizePx = iconSizeOf(tier);
   const isItemCount = tier.unlockConditionType === "item_quantity";
   const label2 = tierLabel(tier);
   const type = tier.type;
@@ -3572,6 +3611,8 @@ var toTierMeta = (tier) => {
     /** 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 },
+    /** Carry the merchant's milestone icon size only when set — absent ⇒ the schema's 18px (React) default. */
+    ...iconSizePx !== void 0 && { iconSizePx },
     ...label2 && { label: { en: label2 } },
     /** Carry the image-swap flag only on gift tiers that set it — the client shows the gift's product image in the step slot instead of the bag icon. */
     ...gift && tier.productTierImage && { productTierImage: true },

package/dist/server/index.mjs

@@ -430,6 +430,20 @@ var SmartCartTier = z5.looseObject({
   productAmountRemainingLabel: z5.boolean().optional(),
   productAmountRemainingLabelText: z5.string().optional(),
   products: z5.array(SmartCartTierProduct).optional(),
+  /**
+   * onsite `product_tier_element_size`: the step-row icon's square size as a px STRING (`'18px'` …
+   * `'36px'` — the admin's five-value Size control, default `'18px'`). React stamps it onto the icon
+   * SVG's `width`/`height` (`getProgressStepIconSize`), so the milestone renders at the merchant's
+   * chosen size; the converter turns it into `CABProgressTier.iconSizePx` for the CAB renderer.
+   *
+   * `.catch(undefined)` for the same blast-radius reason as `productTierImage` below: this key was
+   * previously unknown-and-ignored by the `looseObject`, and `SmartCartConfig` is parsed
+   * `.nullish().catch(undefined)` with no intermediate catch, so one drifted value (a bare number, a
+   * `'2rem'`) would drop EVERY progress bar for the shop rather than just this setting. Failing open to
+   * `undefined` lands on the documented 18px default — strictly safer than that blast radius. The
+   * converter parses the number out and clamps it, so a junk-but-string value degrades the same way.
+   */
+  productTierElementSize: z5.string().optional().catch(void 0),
   /**
    * onsite `product_tier_image`: on a product (gift) tier, show the gift's product image in the step-row
    * slot instead of the generic bag icon (React `TierProgressIcon` swaps in the image when this is set and
@@ -1609,6 +1623,25 @@ var CABProgressTier = z21.object({
     title: z21.string().optional(),
     variantIds: z21.array(z21.number().int().positive()).default(() => [])
   }).optional(),
+  /**
+   * The step-row icon's square size in PIXELS (onsite `product_tier_element_size`, an admin px string the
+   * converter parses): 18 (default) / 20 / 24 / 30 / 36. React sizes the milestone by stamping this onto
+   * the icon SVG's `width`/`height` (`getProgressStepIconSize`), so a merchant who deliberately enlarged
+   * their milestones keeps that at checkout instead of every icon collapsing to one hardcoded square.
+   *
+   * A NUMBER, not the raw `'18px'` string: the renderer needs it as a length for the icon slot's grid
+   * track, and a px-suffixed string would push unit parsing into every consumer. Deliberately NOT named
+   * `iconSize` — the `iconSize` on an `image` section is the `s-icon` token enum, and one name covering both a
+   * token and a pixel count is the kind of ambiguity that gets one passed where the other is meant.
+   *
+   * Bounded (not merely positive) because it is a raw merchant-controlled length: the step row is a grid
+   * of per-tier cells, and an out-of-domain value would stretch the row rather than fail loudly. The
+   * converter clamps to this same ceiling, so drifted config lands on a big-but-sane icon and never on a
+   * tier the strict parse drops. `.default(18)` holds React's default at parse time (schema-first — the
+   * renderer never spells a fallback), which also makes a tree authored before this field render at
+   * React's size rather than the old hardcoded 20.
+   */
+  iconSizePx: z21.number().int().min(1).max(64).default(18),
   /**
    * The step-row label at this tier's slot (onsite `getTierLabel`): the merchant custom label, else the
    * type default — 'Free Shipping' or '{n}% Discount'. A PRODUCT tier gets NO converter label: its name is
@@ -3482,6 +3515,7 @@ var feedbackDoc = (raw, tokens) => ({
   ],
   type: "doc"
 });
+var MAX_ICON_SIZE_PX = 64;
 var IN_SCOPE_TIER_TYPES = new Set(progressTierTypes);
 var inScope = (tier) => IN_SCOPE_TIER_TYPES.has(tier.type ?? "");
 var thresholdOf = (tier) => tier.unlockConditionType === "item_quantity" ? Math.ceil(Number(tier.minimum)) : Math.round(Number(tier.minimum) * 100);
@@ -3500,6 +3534,10 @@ var discountOf = (tier) => {
   const amount = tier.discountAmountFromTotal ?? 0;
   return tier.discountType === "fixedAmount" ? { amount: Math.round(amount * 100), type: "fixedAmount" } : { amount, type: "percentage" };
 };
+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 giftOf = (tier) => {
   if (tier.type !== "product") return void 0;
   const product = tier.products?.[0] ?? tier.allProducts?.[0];
@@ -3516,6 +3554,7 @@ var giftOf = (tier) => {
 var toTierMeta = (tier) => {
   const discount = discountOf(tier);
   const gift = giftOf(tier);
+  const iconSizePx = iconSizeOf(tier);
   const isItemCount = tier.unlockConditionType === "item_quantity";
   const label2 = tierLabel(tier);
   const type = tier.type;
@@ -3524,6 +3563,8 @@ var toTierMeta = (tier) => {
     /** 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 },
+    /** Carry the merchant's milestone icon size only when set — absent ⇒ the schema's 18px (React) default. */
+    ...iconSizePx !== void 0 && { iconSizePx },
     ...label2 && { label: { en: label2 } },
     /** Carry the image-swap flag only on gift tiers that set it — the client shows the gift's product image in the step slot instead of the bag icon. */
     ...gift && tier.productTierImage && { productTierImage: true },

package/dist/transforms/index.cjs

@@ -1108,6 +1108,25 @@ var CABProgressTier = import_zod15.z.object({
     title: import_zod15.z.string().optional(),
     variantIds: import_zod15.z.array(import_zod15.z.number().int().positive()).default(() => [])
   }).optional(),
+  /**
+   * The step-row icon's square size in PIXELS (onsite `product_tier_element_size`, an admin px string the
+   * converter parses): 18 (default) / 20 / 24 / 30 / 36. React sizes the milestone by stamping this onto
+   * the icon SVG's `width`/`height` (`getProgressStepIconSize`), so a merchant who deliberately enlarged
+   * their milestones keeps that at checkout instead of every icon collapsing to one hardcoded square.
+   *
+   * A NUMBER, not the raw `'18px'` string: the renderer needs it as a length for the icon slot's grid
+   * track, and a px-suffixed string would push unit parsing into every consumer. Deliberately NOT named
+   * `iconSize` — the `iconSize` on an `image` section is the `s-icon` token enum, and one name covering both a
+   * token and a pixel count is the kind of ambiguity that gets one passed where the other is meant.
+   *
+   * Bounded (not merely positive) because it is a raw merchant-controlled length: the step row is a grid
+   * of per-tier cells, and an out-of-domain value would stretch the row rather than fail loudly. The
+   * converter clamps to this same ceiling, so drifted config lands on a big-but-sane icon and never on a
+   * tier the strict parse drops. `.default(18)` holds React's default at parse time (schema-first — the
+   * renderer never spells a fallback), which also makes a tree authored before this field render at
+   * React's size rather than the old hardcoded 20.
+   */
+  iconSizePx: import_zod15.z.number().int().min(1).max(64).default(18),
   /**
    * The step-row label at this tier's slot (onsite `getTierLabel`): the merchant custom label, else the
    * type default — 'Free Shipping' or '{n}% Discount'. A PRODUCT tier gets NO converter label: its name is
@@ -3412,6 +3431,7 @@ var feedbackDoc = (raw, tokens) => ({
   ],
   type: "doc"
 });
+var MAX_ICON_SIZE_PX = 64;
 var IN_SCOPE_TIER_TYPES = new Set(progressTierTypes);
 var inScope = (tier) => IN_SCOPE_TIER_TYPES.has(tier.type ?? "");
 var thresholdOf = (tier) => tier.unlockConditionType === "item_quantity" ? Math.ceil(Number(tier.minimum)) : Math.round(Number(tier.minimum) * 100);
@@ -3430,6 +3450,10 @@ var discountOf = (tier) => {
   const amount = tier.discountAmountFromTotal ?? 0;
   return tier.discountType === "fixedAmount" ? { amount: Math.round(amount * 100), type: "fixedAmount" } : { amount, type: "percentage" };
 };
+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 giftOf = (tier) => {
   if (tier.type !== "product") return void 0;
   const product = tier.products?.[0] ?? tier.allProducts?.[0];
@@ -3446,6 +3470,7 @@ var giftOf = (tier) => {
 var toTierMeta = (tier) => {
   const discount = discountOf(tier);
   const gift = giftOf(tier);
+  const iconSizePx = iconSizeOf(tier);
   const isItemCount = tier.unlockConditionType === "item_quantity";
   const label = tierLabel(tier);
   const type = tier.type;
@@ -3454,6 +3479,8 @@ var toTierMeta = (tier) => {
     /** 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 },
+    /** Carry the merchant's milestone icon size only when set — absent ⇒ the schema's 18px (React) default. */
+    ...iconSizePx !== void 0 && { iconSizePx },
     ...label && { label: { en: label } },
     /** Carry the image-swap flag only on gift tiers that set it — the client shows the gift's product image in the step slot instead of the bag icon. */
     ...gift && tier.productTierImage && { productTierImage: true },

package/dist/transforms/index.mjs

@@ -1051,6 +1051,25 @@ var CABProgressTier = z15.object({
     title: z15.string().optional(),
     variantIds: z15.array(z15.number().int().positive()).default(() => [])
   }).optional(),
+  /**
+   * The step-row icon's square size in PIXELS (onsite `product_tier_element_size`, an admin px string the
+   * converter parses): 18 (default) / 20 / 24 / 30 / 36. React sizes the milestone by stamping this onto
+   * the icon SVG's `width`/`height` (`getProgressStepIconSize`), so a merchant who deliberately enlarged
+   * their milestones keeps that at checkout instead of every icon collapsing to one hardcoded square.
+   *
+   * A NUMBER, not the raw `'18px'` string: the renderer needs it as a length for the icon slot's grid
+   * track, and a px-suffixed string would push unit parsing into every consumer. Deliberately NOT named
+   * `iconSize` — the `iconSize` on an `image` section is the `s-icon` token enum, and one name covering both a
+   * token and a pixel count is the kind of ambiguity that gets one passed where the other is meant.
+   *
+   * Bounded (not merely positive) because it is a raw merchant-controlled length: the step row is a grid
+   * of per-tier cells, and an out-of-domain value would stretch the row rather than fail loudly. The
+   * converter clamps to this same ceiling, so drifted config lands on a big-but-sane icon and never on a
+   * tier the strict parse drops. `.default(18)` holds React's default at parse time (schema-first — the
+   * renderer never spells a fallback), which also makes a tree authored before this field render at
+   * React's size rather than the old hardcoded 20.
+   */
+  iconSizePx: z15.number().int().min(1).max(64).default(18),
   /**
    * The step-row label at this tier's slot (onsite `getTierLabel`): the merchant custom label, else the
    * type default — 'Free Shipping' or '{n}% Discount'. A PRODUCT tier gets NO converter label: its name is
@@ -3355,6 +3374,7 @@ var feedbackDoc = (raw, tokens) => ({
   ],
   type: "doc"
 });
+var MAX_ICON_SIZE_PX = 64;
 var IN_SCOPE_TIER_TYPES = new Set(progressTierTypes);
 var inScope = (tier) => IN_SCOPE_TIER_TYPES.has(tier.type ?? "");
 var thresholdOf = (tier) => tier.unlockConditionType === "item_quantity" ? Math.ceil(Number(tier.minimum)) : Math.round(Number(tier.minimum) * 100);
@@ -3373,6 +3393,10 @@ var discountOf = (tier) => {
   const amount = tier.discountAmountFromTotal ?? 0;
   return tier.discountType === "fixedAmount" ? { amount: Math.round(amount * 100), type: "fixedAmount" } : { amount, type: "percentage" };
 };
+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 giftOf = (tier) => {
   if (tier.type !== "product") return void 0;
   const product = tier.products?.[0] ?? tier.allProducts?.[0];
@@ -3389,6 +3413,7 @@ var giftOf = (tier) => {
 var toTierMeta = (tier) => {
   const discount = discountOf(tier);
   const gift = giftOf(tier);
+  const iconSizePx = iconSizeOf(tier);
   const isItemCount = tier.unlockConditionType === "item_quantity";
   const label = tierLabel(tier);
   const type = tier.type;
@@ -3397,6 +3422,8 @@ var toTierMeta = (tier) => {
     /** 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 },
+    /** Carry the merchant's milestone icon size only when set — absent ⇒ the schema's 18px (React) default. */
+    ...iconSizePx !== void 0 && { iconSizePx },
     ...label && { label: { en: label } },
     /** Carry the image-swap flag only on gift tiers that set it — the client shows the gift's product image in the step slot instead of the bag icon. */
     ...gift && tier.productTierImage && { productTierImage: true },

package/package.json

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