@rebuy/rebuy 3.10.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/composeOffer.d.ts

@@ -3,8 +3,8 @@ import { type AdsEngineOffer } from '../server/adsEngine';
 import { type MonetizeInput } from '../server/shared';
 /**
  * Compose one ads-engine offer into a renderable CAB card: a bordered `layout` whose `viewUrl` is the
- * impression pixel, holding the header chrome, the copy (headline + HTML body, coerced to Tiptap by
- * the text-content schema on parse) beside the optional image (75%/fill — the React desktop split),
+ * impression pixel, holding the header chrome, the copy (headline + HTML body, pre-converted to a
+ * small-sized Tiptap doc by {@link smallText}) beside the optional image (75%/fill — the React desktop split),
  * the two CTAs in a 50/50 row, and the right-aligned Privacy Policy footer. `acceptOffer` links out
  * to the advertiser (`destinationUrl` = `click_url`, which self-tracks); `declineOffer` fires the
  * decline pixel (`trackingUrl`) and advances. Parsing through the schema fills defaults and validates

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
@@ -2386,12 +2419,21 @@ var NAMED_ENTITIES = {
   rsquo: "\u2019",
   trade: "\u2122"
 };
-var decodeEntities = (input = "") => input.replace(/&(#x[\da-f]+|#\d+|[a-z][a-z\d]*);/gi, (match, code) => {
-  if (code[0] !== "#") return NAMED_ENTITIES[code.toLowerCase()] ?? match;
-  const isHex = /^#x/i.test(code);
-  const cp = parseInt(code.slice(isHex ? 2 : 1), isHex ? 16 : 10);
-  return Number.isInteger(cp) && cp >= 0 && cp <= 1114111 ? String.fromCodePoint(cp) : match;
+var decodeEntities = (input = "", { keepAngles = false } = {}) => input.replace(/&(#x[\da-f]+|#\d+|[a-z][a-z\d]*);/gi, (match, code) => {
+  let decoded;
+  if (code[0] !== "#") {
+    decoded = NAMED_ENTITIES[code.toLowerCase()] ?? match;
+  } else {
+    const isHex = /^#x/i.test(code);
+    const cp = parseInt(code.slice(isHex ? 2 : 1), isHex ? 16 : 10);
+    decoded = Number.isInteger(cp) && cp >= 0 && cp <= 1114111 ? String.fromCodePoint(cp) : match;
+  }
+  return keepAngles && (decoded === "<" || decoded === ">") ? match : decoded;
 });
+var decodeTextEntities = (input = "") => {
+  const decoded = decodeEntities(input);
+  return isHTML(decoded) ? decodeEntities(input, { keepAngles: true }) : decoded;
+};
 
 // src/transforms/htmlToTiptap/parseAttribs.ts
 var ATTRIB_RE = /([a-zA-Z_:][\w:.-]*)(?:\s*=\s*(?:"([^"]*)"|'([^']*)'|([^\s"'`=<>]+)))?/g;
@@ -2446,7 +2488,7 @@ var openTag = (stack, name, attrs) => {
 // src/transforms/htmlToTiptap/pushText.ts
 var pushText = (state, rawText) => {
   if (!rawText || isSkipping(state.stack)) return;
-  decodeEntities(rawText).split("\n").forEach((segment, index) => {
+  decodeTextEntities(rawText).split("\n").forEach((segment, index) => {
     if (index > 0) flushParagraph(state);
     if (!segment) return;
     const marks = state.stack.flatMap((entry) => entry.marks);
@@ -2718,11 +2760,11 @@ var isMonetizeV1 = isWidgetV1(WidgetType.ui_extension_ad);
 var HTML_TAG_RE2 = /<[a-zA-Z]/;
 var containsHtml = (text2) => HTML_TAG_RE2.test(text2);
 var isObject = (x) => x !== null && typeof x === "object" && !Array.isArray(x);
-var normalizeLangValue = (value) => {
-  if (typeof value !== "string") return value;
+var normalizeTextValue = (value, options = {}) => {
   const tokenized = normalizeTokens(value);
-  return containsHtml(tokenized) ? htmlToTiptap(tokenized) : tokenized;
+  return containsHtml(tokenized) || options.defaultTextStyle ? htmlToTiptap(tokenized, options) : decodeTextEntities(tokenized);
 };
+var normalizeLangValue = (value) => typeof value === "string" ? normalizeTextValue(value) : value;
 var normalizeTextContent = (node) => {
   if (Array.isArray(node)) return node.map(normalizeTextContent);
   if (!isObject(node)) return node;
@@ -3521,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);
@@ -3539,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];
@@ -3555,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;
@@ -3563,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 },
@@ -3990,6 +4040,10 @@ var label = (text2) => ({
   sectionType: SectionType.text
 });
 var text = (content) => ({ content: { en: content }, sectionType: SectionType.text });
+var smallText = (raw) => ({
+  content: { en: normalizeTextValue(raw, { defaultTextStyle: { fontSize: "small" } }) },
+  sectionType: SectionType.text
+});
 var styled = (value, { align, bold, color, fontSize, href }) => ({
   content: {
     en: {
@@ -4019,8 +4073,8 @@ var shopName = (shop) => shop.replace(/\.myshopify\.com$/, "") || "store";
 var headerSections = (input) => [
   {
     sections: [
-      styled("Congratulations!", { bold: true, fontSize: "large" }),
-      styled(`Your ${shopName(input.shop)} purchase unlocked a bonus:`, { bold: true, fontSize: "large" })
+      styled("Congratulations!", { bold: true, fontSize: "heading" }),
+      styled(`Your ${shopName(input.shop)} purchase unlocked a bonus:`, { bold: true, fontSize: "heading" })
     ],
     sectionType: SectionType.layout,
     spacing: Spacing.none
@@ -4029,7 +4083,7 @@ var headerSections = (input) => [
 ];
 var composeOfferCard = (offer, input) => {
   const copy = {
-    sections: [text(offer.headline), text(offer.description)],
+    sections: [text(offer.headline), smallText(offer.description)],
     sectionType: SectionType.layout,
     spacing: Spacing.tight
   };

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
@@ -2338,12 +2371,21 @@ var NAMED_ENTITIES = {
   rsquo: "\u2019",
   trade: "\u2122"
 };
-var decodeEntities = (input = "") => input.replace(/&(#x[\da-f]+|#\d+|[a-z][a-z\d]*);/gi, (match, code) => {
-  if (code[0] !== "#") return NAMED_ENTITIES[code.toLowerCase()] ?? match;
-  const isHex = /^#x/i.test(code);
-  const cp = parseInt(code.slice(isHex ? 2 : 1), isHex ? 16 : 10);
-  return Number.isInteger(cp) && cp >= 0 && cp <= 1114111 ? String.fromCodePoint(cp) : match;
+var decodeEntities = (input = "", { keepAngles = false } = {}) => input.replace(/&(#x[\da-f]+|#\d+|[a-z][a-z\d]*);/gi, (match, code) => {
+  let decoded;
+  if (code[0] !== "#") {
+    decoded = NAMED_ENTITIES[code.toLowerCase()] ?? match;
+  } else {
+    const isHex = /^#x/i.test(code);
+    const cp = parseInt(code.slice(isHex ? 2 : 1), isHex ? 16 : 10);
+    decoded = Number.isInteger(cp) && cp >= 0 && cp <= 1114111 ? String.fromCodePoint(cp) : match;
+  }
+  return keepAngles && (decoded === "<" || decoded === ">") ? match : decoded;
 });
+var decodeTextEntities = (input = "") => {
+  const decoded = decodeEntities(input);
+  return isHTML(decoded) ? decodeEntities(input, { keepAngles: true }) : decoded;
+};
 
 // src/transforms/htmlToTiptap/parseAttribs.ts
 var ATTRIB_RE = /([a-zA-Z_:][\w:.-]*)(?:\s*=\s*(?:"([^"]*)"|'([^']*)'|([^\s"'`=<>]+)))?/g;
@@ -2398,7 +2440,7 @@ var openTag = (stack, name, attrs) => {
 // src/transforms/htmlToTiptap/pushText.ts
 var pushText = (state, rawText) => {
   if (!rawText || isSkipping(state.stack)) return;
-  decodeEntities(rawText).split("\n").forEach((segment, index) => {
+  decodeTextEntities(rawText).split("\n").forEach((segment, index) => {
     if (index > 0) flushParagraph(state);
     if (!segment) return;
     const marks = state.stack.flatMap((entry) => entry.marks);
@@ -2670,11 +2712,11 @@ var isMonetizeV1 = isWidgetV1(WidgetType.ui_extension_ad);
 var HTML_TAG_RE2 = /<[a-zA-Z]/;
 var containsHtml = (text2) => HTML_TAG_RE2.test(text2);
 var isObject = (x) => x !== null && typeof x === "object" && !Array.isArray(x);
-var normalizeLangValue = (value) => {
-  if (typeof value !== "string") return value;
+var normalizeTextValue = (value, options = {}) => {
   const tokenized = normalizeTokens(value);
-  return containsHtml(tokenized) ? htmlToTiptap(tokenized) : tokenized;
+  return containsHtml(tokenized) || options.defaultTextStyle ? htmlToTiptap(tokenized, options) : decodeTextEntities(tokenized);
 };
+var normalizeLangValue = (value) => typeof value === "string" ? normalizeTextValue(value) : value;
 var normalizeTextContent = (node) => {
   if (Array.isArray(node)) return node.map(normalizeTextContent);
   if (!isObject(node)) return node;
@@ -3473,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);
@@ -3491,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];
@@ -3507,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;
@@ -3515,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 },
@@ -3942,6 +3992,10 @@ var label = (text2) => ({
   sectionType: SectionType.text
 });
 var text = (content) => ({ content: { en: content }, sectionType: SectionType.text });
+var smallText = (raw) => ({
+  content: { en: normalizeTextValue(raw, { defaultTextStyle: { fontSize: "small" } }) },
+  sectionType: SectionType.text
+});
 var styled = (value, { align, bold, color, fontSize, href }) => ({
   content: {
     en: {
@@ -3971,8 +4025,8 @@ var shopName = (shop) => shop.replace(/\.myshopify\.com$/, "") || "store";
 var headerSections = (input) => [
   {
     sections: [
-      styled("Congratulations!", { bold: true, fontSize: "large" }),
-      styled(`Your ${shopName(input.shop)} purchase unlocked a bonus:`, { bold: true, fontSize: "large" })
+      styled("Congratulations!", { bold: true, fontSize: "heading" }),
+      styled(`Your ${shopName(input.shop)} purchase unlocked a bonus:`, { bold: true, fontSize: "heading" })
     ],
     sectionType: SectionType.layout,
     spacing: Spacing.none
@@ -3981,7 +4035,7 @@ var headerSections = (input) => [
 ];
 var composeOfferCard = (offer, input) => {
   const copy = {
-    sections: [text(offer.headline), text(offer.description)],
+    sections: [text(offer.headline), smallText(offer.description)],
     sectionType: SectionType.layout,
     spacing: Spacing.tight
   };

package/dist/transforms/htmlToTiptap/decodeEntities.d.ts

@@ -1 +1,19 @@
-export declare const decodeEntities: (input?: string) => string;
+export type DecodeEntitiesOptions = {
+    /**
+     * Leave every entity that would decode to `<` or `>` (named, decimal or hex, any case) as its
+     * literal source text. Decided on the DECODED character, not the spelling, so `&lt;`, `&#60;`
+     * and `&#x3C;` are one rule — there is no second list of angle spellings to keep in sync.
+     */
+    keepAngles?: boolean;
+};
+export declare const decodeEntities: (input?: string, { keepAngles }?: DecodeEntitiesOptions) => string;
+/**
+ * The entity decode for DISPLAY text — every text run and plain-string content value the CAB
+ * pipeline produces. Fully decodes ordinary entities (`&amp;` → `&`, `5 &lt; 10` → `5 < 10`), but
+ * when the fully-decoded result is tag-shaped (`&lt;b&gt;` → `<b>`) it re-decodes holding the
+ * angle entities, because `CABTextSection.content` carries a `NO_HTML` refine that rejects
+ * tag-shaped text and would otherwise drop the whole section — silent content loss, which is worse
+ * than showing the escaped literal. Uses the refine's own `isHTML` predicate so guard and gate can't
+ * drift. Single-pass by construction: a double-escaped `&amp;lt;` resolves to literal `&lt;` and stops.
+ */
+export declare const decodeTextEntities: (input?: string) => string;

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
@@ -1837,12 +1856,21 @@ var NAMED_ENTITIES = {
   rsquo: "\u2019",
   trade: "\u2122"
 };
-var decodeEntities = (input = "") => input.replace(/&(#x[\da-f]+|#\d+|[a-z][a-z\d]*);/gi, (match, code) => {
-  if (code[0] !== "#") return NAMED_ENTITIES[code.toLowerCase()] ?? match;
-  const isHex = /^#x/i.test(code);
-  const cp = parseInt(code.slice(isHex ? 2 : 1), isHex ? 16 : 10);
-  return Number.isInteger(cp) && cp >= 0 && cp <= 1114111 ? String.fromCodePoint(cp) : match;
+var decodeEntities = (input = "", { keepAngles = false } = {}) => input.replace(/&(#x[\da-f]+|#\d+|[a-z][a-z\d]*);/gi, (match, code) => {
+  let decoded;
+  if (code[0] !== "#") {
+    decoded = NAMED_ENTITIES[code.toLowerCase()] ?? match;
+  } else {
+    const isHex = /^#x/i.test(code);
+    const cp = parseInt(code.slice(isHex ? 2 : 1), isHex ? 16 : 10);
+    decoded = Number.isInteger(cp) && cp >= 0 && cp <= 1114111 ? String.fromCodePoint(cp) : match;
+  }
+  return keepAngles && (decoded === "<" || decoded === ">") ? match : decoded;
 });
+var decodeTextEntities = (input = "") => {
+  const decoded = decodeEntities(input);
+  return isHTML(decoded) ? decodeEntities(input, { keepAngles: true }) : decoded;
+};
 
 // src/transforms/htmlToTiptap/parseAttribs.ts
 var ATTRIB_RE = /([a-zA-Z_:][\w:.-]*)(?:\s*=\s*(?:"([^"]*)"|'([^']*)'|([^\s"'`=<>]+)))?/g;
@@ -1897,7 +1925,7 @@ var openTag = (stack, name, attrs) => {
 // src/transforms/htmlToTiptap/pushText.ts
 var pushText = (state, rawText) => {
   if (!rawText || isSkipping(state.stack)) return;
-  decodeEntities(rawText).split("\n").forEach((segment, index) => {
+  decodeTextEntities(rawText).split("\n").forEach((segment, index) => {
     if (index > 0) flushParagraph(state);
     if (!segment) return;
     const marks = state.stack.flatMap((entry) => entry.marks);
@@ -2169,11 +2197,11 @@ var isMonetizeV1 = isWidgetV1(WidgetType.ui_extension_ad);
 var HTML_TAG_RE2 = /<[a-zA-Z]/;
 var containsHtml = (text) => HTML_TAG_RE2.test(text);
 var isObject = (x) => x !== null && typeof x === "object" && !Array.isArray(x);
-var normalizeLangValue = (value) => {
-  if (typeof value !== "string") return value;
+var normalizeTextValue = (value, options = {}) => {
   const tokenized = normalizeTokens(value);
-  return containsHtml(tokenized) ? htmlToTiptap(tokenized) : tokenized;
+  return containsHtml(tokenized) || options.defaultTextStyle ? htmlToTiptap(tokenized, options) : decodeTextEntities(tokenized);
 };
+var normalizeLangValue = (value) => typeof value === "string" ? normalizeTextValue(value) : value;
 var normalizeTextContent = (node) => {
   if (Array.isArray(node)) return node.map(normalizeTextContent);
   if (!isObject(node)) return node;
@@ -3403,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);
@@ -3421,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];
@@ -3437,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;
@@ -3445,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
@@ -1780,12 +1799,21 @@ var NAMED_ENTITIES = {
   rsquo: "\u2019",
   trade: "\u2122"
 };
-var decodeEntities = (input = "") => input.replace(/&(#x[\da-f]+|#\d+|[a-z][a-z\d]*);/gi, (match, code) => {
-  if (code[0] !== "#") return NAMED_ENTITIES[code.toLowerCase()] ?? match;
-  const isHex = /^#x/i.test(code);
-  const cp = parseInt(code.slice(isHex ? 2 : 1), isHex ? 16 : 10);
-  return Number.isInteger(cp) && cp >= 0 && cp <= 1114111 ? String.fromCodePoint(cp) : match;
+var decodeEntities = (input = "", { keepAngles = false } = {}) => input.replace(/&(#x[\da-f]+|#\d+|[a-z][a-z\d]*);/gi, (match, code) => {
+  let decoded;
+  if (code[0] !== "#") {
+    decoded = NAMED_ENTITIES[code.toLowerCase()] ?? match;
+  } else {
+    const isHex = /^#x/i.test(code);
+    const cp = parseInt(code.slice(isHex ? 2 : 1), isHex ? 16 : 10);
+    decoded = Number.isInteger(cp) && cp >= 0 && cp <= 1114111 ? String.fromCodePoint(cp) : match;
+  }
+  return keepAngles && (decoded === "<" || decoded === ">") ? match : decoded;
 });
+var decodeTextEntities = (input = "") => {
+  const decoded = decodeEntities(input);
+  return isHTML(decoded) ? decodeEntities(input, { keepAngles: true }) : decoded;
+};
 
 // src/transforms/htmlToTiptap/parseAttribs.ts
 var ATTRIB_RE = /([a-zA-Z_:][\w:.-]*)(?:\s*=\s*(?:"([^"]*)"|'([^']*)'|([^\s"'`=<>]+)))?/g;
@@ -1840,7 +1868,7 @@ var openTag = (stack, name, attrs) => {
 // src/transforms/htmlToTiptap/pushText.ts
 var pushText = (state, rawText) => {
   if (!rawText || isSkipping(state.stack)) return;
-  decodeEntities(rawText).split("\n").forEach((segment, index) => {
+  decodeTextEntities(rawText).split("\n").forEach((segment, index) => {
     if (index > 0) flushParagraph(state);
     if (!segment) return;
     const marks = state.stack.flatMap((entry) => entry.marks);
@@ -2112,11 +2140,11 @@ var isMonetizeV1 = isWidgetV1(WidgetType.ui_extension_ad);
 var HTML_TAG_RE2 = /<[a-zA-Z]/;
 var containsHtml = (text) => HTML_TAG_RE2.test(text);
 var isObject = (x) => x !== null && typeof x === "object" && !Array.isArray(x);
-var normalizeLangValue = (value) => {
-  if (typeof value !== "string") return value;
+var normalizeTextValue = (value, options = {}) => {
   const tokenized = normalizeTokens(value);
-  return containsHtml(tokenized) ? htmlToTiptap(tokenized) : tokenized;
+  return containsHtml(tokenized) || options.defaultTextStyle ? htmlToTiptap(tokenized, options) : decodeTextEntities(tokenized);
 };
+var normalizeLangValue = (value) => typeof value === "string" ? normalizeTextValue(value) : value;
 var normalizeTextContent = (node) => {
   if (Array.isArray(node)) return node.map(normalizeTextContent);
   if (!isObject(node)) return node;
@@ -3346,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);
@@ -3364,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];
@@ -3380,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;
@@ -3388,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/dist/transforms/normalizeTextContent.d.ts

@@ -1,11 +1,38 @@
+import { type TiptapDocument } from '../schema/widgets/checkout-and-beyond/text';
+import { type HtmlToTiptapOptions } from '../transforms/htmlToTiptap/htmlToTiptap';
+export type NormalizeTextOptions = Pick<HtmlToTiptapOptions, 'defaultTextStyle'>;
 /**
- * Walks an untyped CABRootSection-shaped object (post deepCamelCase, pre schema
- * parse) and rewrites `text` sections' `content[lang]` strings so that:
+ * THE text pipeline for one content value — the single path every text a CAB tree renders takes,
+ * whether it is merchant-authored, converted from a legacy widget, or third-party ad creative:
+ *
+ * 1. `{firstName}` (single brace) becomes `{{firstName}}` (canonical).
+ * 2. HTML becomes a fully-formed `TiptapDocument` (entities decoded per run by `htmlToTiptap`).
+ * 3. Plain text is entity-decoded in place and stays a string, so `Sale &amp; Save` never renders
+ * its `&amp;` literally and URL-bearing values (`buttonField: destinationUrl`) keep the string
+ * shape their validation expects.
+ *
+ * Both decodes run through `decodeTextEntities`, which holds tag-shaped angle entities escaped so a
+ * decode can never manufacture the text the section's `NO_HTML` refine rejects.
+ *
+ * `defaultTextStyle` is the server-side analogue of React's `defaultTextStyle` prop: the doc's runs
+ * carry that `textStyle` unless the markup set their own. A default forces plain text through the
+ * converter too, since only a doc can carry a mark.
  *
- * - `{firstName}` (single brace) becomes `{{firstName}}` (canonical), and
- * - HTML-laden strings become a fully-formed `TiptapDocument`.
+ * NOT idempotent for entity-bearing strings (`&amp;amp;` → `&amp;` → `&`), by nature of decoding.
+ * That is safe because this runs at SERVE time on the stored original and its output is returned,
+ * never written back — rebuy-api's `/cab/*` routes are read-only and admin-nextjs never invokes the
+ * walk. Keep it that way: a save path that persisted this output would degrade one entity level per
+ * cycle. (Docs are immune — the walk leaves them untouched.)
+ */
+export declare const normalizeTextValue: (value: string, options?: NormalizeTextOptions) => string | TiptapDocument;
+/**
+ * Walks an untyped CABRootSection-shaped object (post deepCamelCase, pre schema
+ * parse) and runs every `text` section's `content[lang]` string through
+ * {@link normalizeTextValue}. Already-converted Tiptap docs pass through untouched,
+ * so a caller that needed {@link normalizeTextValue}'s options can convert first
+ * and hand the result to this walk without double-conversion.
  *
- * Plain strings pass through unchanged. Non-text sections only recurse into
- * their `sections` array; Tiptap docs and other nested objects are not walked.
+ * Non-text sections only recurse into their `sections` array; Tiptap docs and
+ * other nested objects are not walked.
  */
 export declare const normalizeTextContent: (node: unknown) => unknown;

package/package.json

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